Independent · an Obsidian corpus of two CFD textbooks
The same two textbooks as CFDLab, in notes instead of code, with a test for what is finished.
A knowledge base is easy to make look complete. Every note links to other notes, the graph fills the screen, and nothing tells you where the holes are. This one carries an explicit test instead: a topic is closed only when all four of theory, derivation, code and evidence exist as real artifacts. A topic with all four is a family: the topic plus every artifact the corpus attaches to it. Everything that fails the test is marked, on purpose, at the edge of the graph.
What is in it
The corpusTwo textbooks, worked through: Lomax, Pulliam and Zingg on the
fundamentals, and Pulliam and Zingg on the algorithms. The same two books
CFDLab turns into runnable code. This is not a project
beside that one: vault/ is a directory of the CFDLab repository,
tracked in the same history as the solvers, so a note and the code it describes are
versioned together. Neither is a summary of the other. The notes carry the reasoning,
the repository carries the executable, and the interesting engineering is in the
links between them: two ways into the same body of knowledge, one you run and one
you read.
The authored layer is small enough to read in a week and structured enough to navigate without search. A concept is one idea stated plainly. A derivation is the maths behind one concept. An exercise is a textbook problem with its status recorded. A chapter maps a book chapter onto the concepts it introduces. Nothing is a dumping ground and nothing is called notes.
The generated layer is an order of magnitude larger and carries no authored knowledge at all. It is built by a script from the link structure and a community detection run over it, and it exists so the graph can be navigated visually. Keeping the two apart matters: a reader has to be able to tell what a person decided from what a script inferred, and every count here is marked as one or the other.
A folder of notes is not a graph
StructureThree hundred and seventy files in thirteen folders is a filing system. What makes it a graph is 39,520 links, and what makes the graph useful is that its groupings were found rather than declared: the eight clusters below come from running community detection over the link structure, not from the directory names. A concept and a derivation can sit in different folders and the same cluster, which is exactly what you want, because the folder says what kind of note it is and the cluster says what it is about.
This is the argument for retrieval over search. A search for dissipation returns the notes with that word in them. A question like where does the modified-equation argument show up in both books has no keyword: the answer lives in the fact that a concept in one cluster is linked to a section in another, twenty-seven times across the corpus, and no amount of matching on the query's words will find that.
What the graph cannot do is answer in a sentence. It can put you next to the right six notes and it can show you that two things are connected, but it cannot read them for you. That gap is the whole reason a retrieval layer was built at all, and it is also the layer that cannot be shown (chapter 06).
The test a topic has to pass
ClosureHere is the idea the whole corpus is organised around. A topic is not understood because there is a note about it. It is understood when four different kinds of artifact exist and point at each other:
Narration
01 The four corners
Theory. A concept note stating the idea in words, with no maths and no code. If you cannot write this one, you do not have the idea yet, you have a technique. Derivation. The maths, worked. Not quoted from the book: written out, with the step that is usually skipped written out. Code. A probe or a kernel function in the repository that realises the idea and can be run. This corner lives outside the vault, and the link crosses the boundary into CFDLab. Evidence. A figure or a milestone showing the code produced the behaviour the theory predicted. Without this the third corner is only an assertion in a language a compiler happens to accept.
02 Passing, and failing
Twenty families have all four. Each one is a hub you can click through in the order above, and every link in it points at a real artifact rather than a placeholder, which the generator checks before it writes the atom. Twenty-two do not, and the corpus records which corner each is missing. It is not spread evenly and it is not the corner you would guess: twenty of the twenty-two are missing the derivation. The other two are missing evidence. Nothing is missing theory and nothing is missing code, which is a statement about how this vault was built and about what I find easy.
And what is missing is the maths
The frontierThirty atoms sit deliberately at the edge of the graph, sparsely linked, marking what is not part of the closed core. Eight of them are open decisions: gates in the project's own architecture records that have to be settled before a whole direction can proceed. The other twenty-two are closure gaps, and they are the interesting ones, because the corpus records which corner each is missing.
Chapter by chapter, exercise by exercise
CoverageThe other thing the corpus counts about itself. Every textbook exercise that was attempted has a note with a status on it, and the coverage layer rolls those up by chapter and by book. It carries metadata only, never a problem statement and never a close paraphrase, which is a deliberate line: the corpus records that an exercise was solved and how, not the book's own text.
generated Rolled up from the exercise notes by the same script that builds the graph layer, so the table cannot drift from the notes: it is regenerated from them.
The layer that was never committed
The retrieval layerThe point of building the corpus this way was to put a retrieval layer on top of it: LightRAG, a knowledge-graph framework that extracts entities and relations from documents and answers questions against them, run entirely on local models so that the model reading the corpus and the model answering the query are both on the machine and neither is a hosted API.
None of it was committed. Not the install, not the index, not the server, not one query and not one answer. So there is no retrieval trace here, no graph of extracted entities, no chat box and no quality number, because all four would have to be invented.
What can be said is what the corpus supports on its own, which is a good deal: that it is a real graph rather than a folder, that its groupings were measured, that it carries an explicit completeness test, and that it fails that test in a specific and countable way. Answer quality was never measured.
- authoredA note a person wrote, under one of the thirteen vault layers.
- generatedA graph-brain atom, written by the corpus's own generator from the link structure. Carries no authored knowledge.
- newCounted or derived here and recorded nowhere in the vault. The corner census is the main one.
What it shows
A retrieval system can only answer what its corpus holds, and most corpora have no way to say what they are missing. This one does, by construction: a topic counts as understood when four different kinds of artifact exist and point at each other, and everything that fails that test is written down rather than quietly absent.
Applying the test to the corpus itself gives a result the corpus was not built to produce. Twenty families close. Twenty-two do not, and twenty of those twenty-two are missing the same corner: the derivation. This is a set of notes about two mathematics textbooks whose least complete layer is the mathematics, and the only reason that is knowable is that somebody wrote down what closure means before counting.
What I would do differently
Tune to the corpus earlier. Most of the early friction went into making the framework's defaults behave at a generic scale, and the late wins were all specific to this vault's shape: chunking that respects a short concept note, prompts that know a derivation is not prose, embeddings chosen against the exercise and brief pairs. The pipeline narrows itself much faster when the corpus is treated as a fixed input from day one and the framework parameters are the only variables.
And commit the pipeline, not just its output. The corpus survived because it was in git. The layer built on top of it did not.
Retrieval quality was never measured. Everything counted here was counted from the corpus in the repository.