The Kautz Taxonomy: Six Ways to Combine

📍 Where we are: Part IV · The Neuro-Symbolic Idea — Chapter 13. The previous chapter, Two Cultures: Symbols versus Vectors, set the exact reasoning of logic beside the fluent geometry of embeddings and named the tension the whole series exists to resolve. This chapter hands you the field's shared map of the six concrete ways people have tried to join them.

Two Cultures left us with a problem stated cleanly but not solved: logic proves and never guesses, geometry guesses and never proves, and we want both at once. The moment you try to build that, a new confusion arrives. "Neuro-symbolic" names wildly different machines: a chatbot that spits out a database query, a chess engine with a learned position scorer, a network with a theorem prover buried inside it. Calling all three by one name is how two people end up arguing past each other. The Kautz taxonomy cut the knot with six named categories, each a different way the neural part and the symbolic part can be wired together [1].

This chapter does more than list the six. It reads each one as a precise wiring diagram, decodes the notation mark by mark until the names read themselves, fixes the one axis that orders them, and then works every category against the running academic world and the committed companion code, with the actual numbers those files print. By the end you will be able to take any hybrid system and place it, predict its strengths and failure modes from that placement, and see the plot of the whole series as a single move across the map.

The simple version

Imagine you own a calculator and a poet and want them to work as a team. There are only so many ways to arrange two workers: let the poet do all the talking while the calculator works in silence; let the calculator run the job and ask the poet for a hunch when it gets stuck; have the poet draft and the calculator check the math after; or, the deepest version, teach the calculator to feel rhythm so the two become one worker. The Kautz taxonomy is that list of arrangements, written for neural networks and logic engines: six slots, from "barely touching" to "fused into one."

What this chapter covers

• Why a map at all — "neuro-symbolic" spans dozens of unlike architectures, so without a shared vocabulary two papers can mean opposite things by the phrase.
• The one ordering axis, made precise — coupling from loose to tight, defined by a concrete test: how far does a gradient reach across the seam between the two halves?
• The notation, fully decoded — how side-by-side placement, brackets, a pipe, a colon-and-arrow, and a subscript each name a data-flow signature, read from loose to tight.
• The six categories, each worked on our world — plain words, one real-world example, and a numeric trace grounded in the companion code: the forward-chaining waves [23, 41, 47, 47], the TransE score gap 0.399 versus 0.929, a real proof tree, the 24 derived atoms turned into 24 labeled pairs.
• A map at a glance — all six on one table: who drives, what the seam is made of, whether a gradient crosses it, whether the logical guarantee survives.
• Where the later volumes land — the exact cells this series occupies: ontology embeddings (Volume 3), probabilistic logic programming and complex query answering (Volume 4), and the SATORI capstone (Volume 5).
• A lens, not a law — why real systems straddle cells, and why the same system gets different coordinates at different zoom levels.
• The open question — the map tells you what couplings exist, never which one your task should use.

Why the field needs a map

A field that cannot name its own parts cannot compare them. By 2020 "neuro-symbolic AI" was an umbrella wide enough to shelter a spell-checker and a differentiable theorem prover, and the surveys that tried to organize it kept reaching for the same fix: a small, shared set of categories to point at [2][3]. The Kautz taxonomy is the one that stuck, because it is not a wishlist of what should be built but a census of what has been, sorted by one honest question: how tightly are the two halves coupled?

To make "tightly coupled" more than a feeling, fix two objects and one test. Write $N$ for the neural component: a function whose behavior is set by a list of tunable real numbers, adjusted by the gradient descent of Chapter 9. Write $S$ for the symbolic component: an exact procedure over symbol structures, such as the forward chainer or the SLD prover of Part II, which either fires a rule or does not and has no dials to turn. The two speak different languages. $N$ consumes and produces vectors, points in $\mathbb{R}^d$ (the space of lists of $d$ real numbers; the superscript $d$ is the dimension, how many numbers are in each point). $S$ consumes and produces symbol structures: ground atoms like advises(bob, carol), strings, proof trees. Between $N$ and $S$ there is always a seam, the place where one hands off to the other.

The coupling axis is a statement about that seam, and the sharpest test is the one gradient descent forces on us. A gradient, written $\nabla$ ("del," the vector of partial derivatives from Chapter 9), can only flow through a computation that is differentiable: every internal quantity must be a smooth real number, so that a tiny nudge to any input produces a measurable change in the output. A discrete choice, "did rule $r$ fire, yes or no," has no such slope; a gradient hits it and stops. So the single question how far does a gradient reach across the seam? orders the whole map. At the loose end the gradient never crosses: the two parts trade finished messages and neither can tune the other. At the tight end the gradient flows all the way through the symbolic side, so the logic and the network improve together, as one differentiable object you cannot pry apart. That axis, from a gradient that stops at the seam to a gradient that passes clean through the reasoning, is the spine of everything below. The taxonomy's own numbering, one through six, tracks it closely.

Reading the notation

Before the six names, learn to read them, because the notation is the meaning. Each name is a tiny wiring diagram of $N$ and $S$, and five marks do all the work. For each mark we give the plain reading and its signature: the shape of data flowing in and out, written with $\to$ meaning "produces" (the arrow reads "maps to," so $A \to B$ is "an $A$ turned into a $B$").

• Side by side (Symbolic Neuro Symbolic) means a straight sequence: one part, then the next, then the next. Signature: symbols in, decoded to vectors, run through the net, re-encoded to symbols, so $\mathbb{S} \to \mathbb{R}^d \to \cdots \to \mathbb{S}$, where $\mathbb{S}$ is the set of symbol structures. Only the two ends speak symbols.
• Brackets (X[Y]) mean Y is nested inside X: X is in charge and calls Y as a subroutine. Which name sits outside the brackets names the boss. Signature: X runs, and at one step invokes Y on a sub-input and uses Y's answer.
• A pipe (Neuro | Symbolic) means a pipeline: two full, separate components wired end to end, the first's output becoming the second's input. Signature: $N: \text{raw} \to \mathbb{S}$, then $S: \mathbb{S} \to \mathbb{S}$, one-way, with a symbol interface at the seam.
• A colon and arrow (Neuro : Symbolic → Neuro) mean "use the left thing to produce the right thing": a compile step, not a runtime call. Signature: offline, $S$ generates a labeled dataset; then $N$ is trained on it; at runtime only $N$ remains and $S$ is gone.
• A subscript (Neuro_Symbolic, read "Neuro sub Symbolic") means the symbolic part lives inside the neural representation itself: not a separate stage but a term folded into what the network optimizes. Signature: a single loss $L = L_{\text{data}} + \lambda\, L_{\text{logic}}$, one differentiable objective in which the logical term $L_{\text{logic}}$ is just another summand.

Two of these five marks deserve a closer look because they carry the two ends of the coupling axis on the same rule. Symbolic[Neuro] and Neuro[Symbolic] both use the bracket, "the outer one is boss," yet they sit at opposite ends of the map: in the first a logic engine bosses a network, in the second a network bosses a logic engine, and the second is far tighter because the nested reasoner must itself be differentiable for the arrangement to train. Hold this decoder in mind, and the six categories read almost by themselves. Along the way we will meet one more logical symbol, $\sqsubseteq$ (read "is subsumed by," or in plain speech "is a kind of," so researcher ⊑ person says every researcher is a person), and the norm bars $\lVert \cdot \rVert$ (the length of a vector, the square root of the sum of its squared components), both of which the running example will need.

The six categories arranged on the one axis that orders them — how tightly the neural and symbolic halves are bound, from a pipeline that only speaks symbols at its edges to a reasoning engine fused inside a network. Original diagram by the authors, created with AI assistance.

The six ways to combine

1. Symbolic Neuro Symbolic — the standard deep pipeline

The workhorse of modern deep learning, and the loosest coupling of all: symbols go in, symbols come out, and a neural network does everything in between. Its signature is $\mathbb{S} \to \mathbb{R}^d \to \cdots \to \mathbb{R}^d \to \mathbb{S}$, a single neural function bracketed by an encode step and a decode step. A translation model takes words and returns words with nothing but tensors (the multi-dimensional arrays of real numbers a neural network computes with) in the middle; a classifier takes a sentence and returns a label. It is neuro-symbolic only in the weak sense that its interface speaks symbols. No rule is ever applied and $S$ is absent entirely.

Grounded on our academic world: a language model reads the question "who advises carol?" and emits the string advises(bob, carol). That output happens to be true in our knowledge base, but read where it comes from. Nothing in the network consulted the fact ("advises", "bob", "carol") asserted in kb.py; the string was produced by the same next-token machinery that would just as fluently emit advises(dave, carol), which is false. The symbols are skin. The seam is the discrete encode/decode at the two ends, and a gradient reaches only within the network, never across a rule, because there is no rule to cross. Coupling: as loose as it gets, and the logical guarantee is simply absent.

2. Symbolic[Neuro] — a solver that calls a neural helper

Recall the bracket rule: X[Y] means Y is nested inside X. Here a symbolic algorithm runs the show and calls a neural network as a helper for one hard sub-decision. The famous example is a game-playing program whose tree search consults a learned evaluation function to score positions and prune the moves not worth exploring: the search owns correctness, the network is a fast oracle it queries.

On our world, let the backward-chaining SLD prover of sld.py play the boss. Its _solve routine (lines 37 through 60) hunts over proofs, and at each step it must choose which subgoal to expand first. Imagine it calling the TransE scorer of embeddings.py as its helper, using the learned geometric distance as a heuristic for "which edge is most worth chasing." The scorer, defined in score (lines 79 through 82), returns $\lVert \mathbf{h} + \mathbf{r} - \mathbf{t} \rVert$, the length of the gap between where the head-plus-relation translation lands and where the tail actually sits: lower means more plausible. The real numbers it prints are

candidate edge	TransE distance	reading
advises(alice, bob) (true in the KB)	$0.399$	short gap, plausible: expand first
advises(alice, erin) (false in the KB)	$0.929$	long gap, implausible: expand last

So the prover would try the subgoal scoring $0.399$ before the one scoring $0.929$, reaching a proof faster. Crucially, the network never decides what is true: it only reorders the search. The seam is a single scalar handed from $N$ to $S$, a discrete oracle call, and no gradient flows back through the proof. The logic still delivers a full, checkable proof tree at the end; the helper only made the hunt quicker. Coupling: loose, guarantee fully intact.

3. Neuro | Symbolic — perception feeds reasoning

The pipe means a cascade of two full components wired end to end, classically neural perception feeding a symbolic reasoner, as when a vision system turns a photograph into a structured scene description that a symbolic program then answers questions over. On our world this is the cleanest fit, and it is where we can watch the symbolic half actually move. A network reads a scanned paper and emits ground facts, the 23 base atoms of kb.py such as authored("alice", "p1") and cites("p2", "p1"). Those facts are the input to the forward chainer of forward_chain.py, which grinds them through the seven Horn rules to the full model (here model means the complete set of atoms the rules force true, not a neural model like the language model of category 1).

The engine is the immediate-consequence operator $T_P$, defined in t_p (lines 42 through 49). Given a set $S$ of atoms it returns

$$T_P(S) \;=\; S \,\cup\, \big\{\, \text{head}\cdot\theta \;:\; (\text{head} \leftarrow \text{body}) \in \text{rules},\ \theta \text{ makes every body atom true in } S \,\big\},$$

where $\cup$ is set union ("everything in either side"), $\in$ reads "is a member of," and $\theta$ (theta) is a substitution, an assignment of constants to the rule's variables, so that $\text{head}\cdot\theta$ is the head with those constants plugged in. The driver least_fixpoint (lines 52 through 64) applies $T_P$ over and over until a round adds nothing new, the least fixpoint $\text{lfp}(T_P)$, and records the size after each round. Running the file prints sizes per round: [23, 41, 47, 47]. Here is exactly what each wave does, atom by atom, which reproduces those four numbers (the mark ∘ in the table below denotes composition, chaining one advises edge into the next):

wave $t$	$T_P$ fires on	new atoms this wave	how many	cumulative
0	(the asserted base facts)	the 23 base atoms	23	23
1	23 base facts	researcher (from each professor/student)	5
		grandAdvisor (advises∘advises chains: alice→bob→carol, alice→bob→dave, bob→carol→erin)	3
		colleague (shared institution, neq guard: 2 at mit, 6 at cmu)	8
		citesTransitively (base rule on cites p2→p1, p3→p2)	2	41
2	41 atoms	person (from each researcher, now that they exist)	5
		citesTransitively(p3, p1) (transitive rule: cites(p3,p2) ∧ citesTransitively(p2,p1))	1	47
3	47 atoms	nothing new; $T_P(S) = S$, fixpoint reached	0	47

Read the structure of the climb. Wave 1 can only fire rules whose bodies mention base predicates, so person (whose body needs a researcher, which does not yet exist) waits, and the recursive citesTransitively gets only its base edges. Wave 2 is where the derived atoms feed other rules: the five researcher atoms born in wave 1 now let person fire, and the freshly derived citesTransitively(p2, p1) composes with cites(p3, p2) to reach across two hops to citesTransitively(p3, p1), a link no single fact showed. Wave 3 adds nothing, so the loop halts. The total is $47 - 23 = 24$ derived atoms, exactly what forward_chain.py reports. The network saw 23 facts off a page; the logic concluded 24 more, including a transitive citation and eight colleague pairs no pixel ever contained. The seam is the discrete set of facts handed across, so no gradient crosses it and the two stages are built separately, but every derived atom carries a guarantee: it is true in every model of the rules. Coupling: loose at the seam, guarantee fully intact.

4. Neuro : Symbolic → Neuro — compiling rules into a network

The colon-and-arrow reads "use the symbolic thing to make the neural thing." Symbolic knowledge becomes a teacher; the trained network is the student. Take a known ruleset, use it to generate a mountain of labeled examples, train a network until it reproduces the rules' answers, and the logic is compiled away into weights. The arrow is a compile-time step, not a runtime call: once training ends, $S$ is discarded and only $N$ answers.

On our world the teacher is already sitting in forward_chain.py and sld.py. The forward chainer's 24 derived atoms become 24 labeled training pairs, "these arguments stand in this derived relation, those do not." Take the grandAdvisor rule from kb.py (line 79), grandAdvisor(X, Z) ← advises(X, Y) ∧ advises(Y, Z), where $\wedge$ is logical "and." The SLD prover in sld.py not only confirms an instance but returns its derivation. Running it prints a real proof tree:

proof of grandAdvisor(alice, carol):
  grandAdvisor(alice, carol)
    advises(alice, bob)
    advises(bob, carol)

That tree says: grandAdvisor(alice, carol) holds because the intermediate person is bob, with advises(alice, bob) and advises(bob, carol) both asserted. The prover's answers routine (lines 82 through 93) enumerates every such binding, yielding the three positive grandAdvisor labels the code confirms, (alice, carol), (alice, dave), and (bob, erin), while every other ordered pair of people is a negative label. Feed those labeled pairs to a network and fit it until it reproduces them. At runtime the rule is gone; only its shadow in the weights remains. Here a gradient does flow, but only within $N$ during training, never across the seam to $S$, because $S$ vanished at compile time. You gain speed and the chance to generalize past the exact training facts; you pay by giving up the guarantee the rule gave for free, since a fitted network can and will answer some unseen pair wrongly. Coupling: still loose at the seam, but now the guarantee is lost.

5. Neuro_Symbolic — logic baked into the vectors

The subscript means the logic lives inside the neural representation, a term in what training optimizes rather than a separate stage. The move is to turn a logical constraint into a differentiable penalty so the network is rewarded for obeying it, the idea behind Logic Tensor Networks and "semantic loss." This is the first category where a gradient crosses into the logic, because the logical term is written to be differentiable.

On our world this fixes the exact crack the Embeddings chapter exposed. The TransE model in embeddings.py optimizes a single loss, the margin-ranking term of its training loop (the condition margin + d_pos - d_neg <= 0 on line 65, which pushes true triples closer together than corrupted ones). Read that loop and you will find no term that mentions the subsumption researcher ⊑ person. Nothing in the geometry knows that every researcher is a person, so a flat TransE placement can, and generally will, put a researcher's point outside wherever the person points cluster. Category 5 adds a second summand to the objective, so the network minimizes

$$L \;=\; L_{\text{TransE}} \;+\; \lambda \sum_{a} \max\!\big(0,\ \operatorname{viol}(a)\big),$$

where $\Sigma$ sums over entities $a$, the coefficient $\lambda$ (lambda) sets how hard the constraint bites, $\max(0, \cdot)$ is the hinge (zero when the term inside is negative, so a satisfied constraint costs nothing), and $\operatorname{viol}(a)$ measures how far entity $a$ classed as a researcher pokes outside the region assigned to person. The penalty is smooth in the coordinates, so its gradient flows straight into the same vectors TransE is already learning. Logic and geometry stop being two systems and become one loss function: the hierarchy is trained into the coordinates instead of hoped for. Coupling: tight, and the guarantee becomes soft, encouraged by the penalty but not proven.

6. Neuro[Symbolic] — a reasoner inside the network

Same bracket rule as category 2, flipped: now the neural system is the boss and a genuine symbolic reasoner is nested inside its computation. This is the tightest coupling on the map. Reasoning happens within the forward pass, and gradients flow back through it, so the system learns and proves as one differentiable object.

On our world, take the transitive-closure fixpoint that produced citesTransitively in category 3 and make it differentiable. In forward_chain.py the operator $T_P$ makes hard, all-or-nothing decisions: a fact is in the set out or it is not, added by the discrete out.add(...) on line 48. To nest this reasoner inside a network, replace each atom's crisp membership with a soft truth value in the interval $[0, 1]$ (the real numbers from zero to one, read as "how true"), and replace the discrete "was it derived by any rule instance" with a smooth approximation to the maximum. Then the very wave sequence [23, 41, 47, 47] becomes a sequence of real-valued truth vectors climbing toward a soft fixpoint, and the whole climb is differentiable. A training signal on the final citesTransitively scores can now back-propagate, through every wave of inference, all the way to whatever network produced the base cites facts. Nothing is compiled away and nothing waits in a separate stage; the proof engine is a layer. It is the hardest to build, the most powerful, and where this series is ultimately headed. Coupling: tightest, gradient flowing through the reasoning itself, guarantee soft.

The map at a glance

The six read cleanly on one axis once you fix the seam and ask the gradient question. Every entry below is the version instantiated on the running example above.

#	notation	who drives	what the seam is made of	gradient crosses seam?	logical guarantee	our-world instance
1	Symbolic Neuro Symbolic	the network	discrete encode / decode	no (no rule to cross)	absent	LM emits the string advises(bob, carol)
2	Symbolic[Neuro]	the logic engine	one scalar oracle call	no	full	SLD orders subgoals by TransE scores $0.399$ vs $0.929$
3	Neuro | Symbolic	split (perceive, then reason)	a set of discrete facts	no	full	net emits 23 facts; chainer derives 24 more, waves [23,41,47,47]
4	Neuro : Symbolic → Neuro	the network (at runtime)	an offline labeled dataset	within $N$ only	lost	24 derived atoms become 24 labeled pairs
5	Neuro_Symbolic	one joint loss	a differentiable penalty term	yes, into the weights	soft	penalty forcing researcher ⊑ person into TransE coords
6	Neuro[Symbolic]	the network	a differentiable reasoner layer	yes, through the inference	soft	differentiable citesTransitively fixpoint as a layer

Read the "gradient crosses seam?" column top to bottom and the coupling axis sorts into coarse tiers: no, no, no for the loose trio, only inside the net for the partial category 4, then yes into the weights and yes through the reasoning for the tight pair. The gradient test alone resolves those three tiers, loose 3, partial 4, tight 6; it cannot by itself rank the three loose categories against one another, since it answers "no" to all three of them. For the finer 1 < 2 < 3 order you read across to the "what the seam is made of" column, where a discrete encode/decode, then a single scalar oracle call, then a whole set of facts grow steadily richer. Tier by the gradient, then break ties within a tier by the seam material: that, and not any looser intuition, is what "loose to tight" means.

Where the later volumes land

The taxonomy is the legend for the rest of this series, and each later volume plants its flag in a specific cell. Volume 3, on embeddings of ontologies, is squarely category 5, Neuro_Symbolic: its box and ball geometries are logical containment baked into the vectors, the grown-up version of the researcher ⊑ person penalty above, where a class becomes a region and subsumption becomes literal geometric containment enforced by a differentiable term. Volume 4 straddles categories 5 and 6. Complex query answering runs logical query structure over learned embeddings, which is Neuro_Symbolic, while probabilistic logic programming makes an actual logic program differentiable inside the neural loop, which is Neuro[Symbolic], the soft-fixpoint move sketched for category 6 above. Volume 5, the SATORI capstone, aims at the tight end, category 6. Volumes 1 and 2 sit off the map at the pure-symbolic pole, and Part III of this volume sits at the pure-neural pole. Read left to right, the series is one long march from loose coupling toward tight, because the prize named in Two Cultures, to learn like geometry and prove like logic in one object, lives at the tight end.

The taxonomy is a lens, not a law

Treat the six cells as coordinates for conversation, not boxes nature enforces, because real systems refuse to sit still in one. A game engine is Symbolic[Neuro] when you watch the search run the show, but zoom into the learned scorer it calls and that component is itself Symbolic Neuro Symbolic, a board in, a number out. Our scanned-paper pipeline is Neuro | Symbolic at the seam today, yet fold the rule engine into the network's loss (the soft-fixpoint move of category 6) and it slides toward Neuro[Symbolic] without changing what it computes. The same system gets different coordinates at different zoom levels and life stages, a fact both surveys stress when they warn the boundaries are porous [2][3]. The map's value is not that it carves reality at perfect joints, but that it gives two engineers a shared word for the arrangement they are arguing about, and a place to point when they disagree about which arrangement a system should have.

The unsolved part

The map has one axis it pointedly cannot draw: which cell is best. Naming six couplings tells you nothing about whether your task wants category 3 or category 6, and the trade-offs are real and now precisely visible in the table above. Tighter coupling buys end-to-end differentiable learning, since a gradient that crosses the seam lets every part improve at once, but the same crossing costs transparency, often costs training stability, and turns the hard guarantee of rows 2 and 3 into the soft, penalized encouragement of rows 5 and 6. Looser coupling keeps the clean, checkable guarantee (every one of the 24 derived atoms is provably entailed), yet cannot learn through the seam, so the two parts never correct each other. Which trade wins is task-specific; no theorem says "for query answering over an incomplete graph, use Neuro_Symbolic." The field is still answering the slow way, benchmark by benchmark, and honest surveys report that the best coupling for a task remains an open, empirical question whose evidence is mixed and hard-won [2][3]. The taxonomy gave the field a map of the terrain; it did not, and could not, hand it the best route across.

Why it matters

From here on, nearly every method the later volumes develop will effectively announce its cell: pipeline or nesting, compiled or differentiable, loose or tight. Knowing the six lets you place any new system in a single read, predict its strengths and failure modes from its coordinates alone (does a gradient cross the seam? is the guarantee hard or soft?), and see the plot of the whole series at a glance: a steady drift from the loose left, where symbols and vectors merely trade finished messages, toward the tight right, where they become one thing that both learns and reasons. That drift is not fashion. It is the field chasing the exact prize the last chapter named, and the taxonomy is how we track how close each attempt gets.

Key terms

• Neuro-symbolic taxonomy — a classification of hybrid systems into six categories, ordered by how tightly the neural and symbolic parts are coupled.
• Coupling (loose to tight) — the single axis that orders the taxonomy, made precise by one test: how far does a gradient reach across the seam between the two halves, from not at all to all the way through the reasoning.
• The seam — the handoff point between the neural component $N$ (vectors, tunable by gradient) and the symbolic component $S$ (symbol structures, exact and non-differentiable); its material (discrete facts, a scalar, a differentiable term) sets the category.
• Symbolic Neuro Symbolic — a standard deep pipeline whose input and output are symbolic but whose processing is entirely neural; no rule fires.
• Symbolic[Neuro] — a symbolic algorithm in charge that calls a neural network as a helper for one sub-decision, such as a search with a learned evaluation function.
• Neuro | Symbolic — a two-stage pipeline in which neural perception produces facts that a separate symbolic reasoner then chains over (our 23 facts to 47-atom model).
• Neuro : Symbolic → Neuro — compiling a ruleset into a network by using the rules to generate training data, so the logic is baked into weights and discarded at runtime.
• Neuro_Symbolic — logic embedded inside the neural representation as a differentiable penalty added to the loss, for example a term forcing researcher ⊑ person into an embedding geometry.
• Neuro[Symbolic] — a symbolic reasoning engine nested inside a neural system and made differentiable so gradients flow through reasoning itself; the tightest coupling.
• Grain / zoom level — the observation that a system's category depends on how closely you look, so one system can occupy more than one cell.

Where this leads

We now hold the map; what we still need is the territory. The next chapter, The Running Example: One Knowledge Base, Five Volumes, plants that flag: it takes the tiny academic world of people, papers, and advising this volume kept returning to and shows how the same facts become, in turn, a logic program (Volume 2), an embedded geometry (Volume 3), a target for differentiable query answering (Volume 4), and the substrate of the SATORI capstone (Volume 5). One knowledge base, six ways to combine, five volumes to build them.