Glossary

📍 Quick reference: This is your pocket dictionary for the whole volume — every recurring term, in plain words. Bookmark it and come back anytime a word stops making sense.

Neuro-symbolic AI has its own language — one part borrowed from logic, one part from machine learning, and a third part invented to join the two. Here are the recurring terms of this volume, in plain words, listed alphabetically so they are easy to find. Each entry is a plain-language starting point; the chapter it points to gives the full, precise picture.

ABox / TBox — the two halves of a knowledge base: the ABox (assertion box) is the facts about named individuals (alice is a professor), and the TBox (terminology box) is the schema-level axioms about kinds (every professor is a researcher). Our facts are the ABox; our rules imply a TBox. (See The Running Example: One Knowledge Base, Five Volumes.)

Abstract syntax tree (AST) — a formula stored not as a flat string but as a nested tree whose top node names the connective and whose branches are its parts; the parsed skeleton every operation walks. (See Propositional Logic: True, False, and What Follows.)

Activation function — the nonlinear squash a neuron applies after its weighted sum; without it, stacked layers collapse into a single linear map, and with it a network can bend space. The sigmoid is the one used here. (See Neural Networks: Differentiable Function Approximators.)

Antisymmetric — one of the three laws of a partial order: if a sits below b and b sits below a, then a and b must be the very same thing — no two different items can each be below the other. (See Order and Lattices: When Things Have Rank.)

Ascending chain — a sequence of sets or values that only ever grows, X0 then X1 then X2 and so on; its least upper bound is the smallest thing sitting above the whole chain at once, and reasoning is often the act of climbing one. (See Order and Lattices: When Things Have Rank.)

Atom (atomic proposition) — the smallest complete claim, one that is simply true or false with no inner parts to inspect; in first-order logic it is a predicate applied to its arguments, like advises(alice, bob). (See Propositional Logic: True, False, and What Follows.)

Backpropagation — the training algorithm that applies the chain rule of calculus to pass a network's error backward through its layers, so every weight learns its share of the blame and can be nudged downhill. (See Neural Networks: Differentiable Function Approximators.)

Backward chaining — goal-driven reasoning: start from the question, ask which rule could conclude it, recurse on what that rule needs, and stop when every branch lands on a known fact. The opposite direction from forward chaining. (See Resolution and SLD: How a Machine Proves.)

Black box — a trained model that produces a working answer with no readable reason attached, its rule smeared across weights that individually mean nothing rather than stated anywhere you can point to. (See Neural Networks: Differentiable Function Approximators.)

Brittleness — the symbolic failure mode: a fact that is missing, absent, or misspelled yields no proof and no answer at all, rather than a gracefully degraded one; the system goes silent instead of guessing. (See Two Cultures: Symbols versus Vectors.)

Calibration — the property that a stated confidence matches reality, so an edge asserted at 0.9 turns out right about nine times in ten; the concern that keeps a learned model's numbers honest. (See The Running Example: One Knowledge Base, Five Volumes.)

Cartesian product (A × B) — the set of every ordered pair you can form with a first element from A and a second from B; the space of all conceivable pairings, out of which a relation picks a chosen few. (See Sets, Relations, and Functions: The Language of Structure.)

Chase (the chase) — the forward-chaining process specialized to existential rules; because such a rule invents a fresh individual each time it fires, the chase can climb forever and never reach a fixpoint. (See Fixpoints: Reasoning as Reaching a Limit.)

Clash — the failure case of unification: two distinct constants that cannot be made equal by any substitution, so the attempted match fails. (See Resolution and SLD: How a Machine Proves.)

Class hierarchy — a chain of subsumptions such as professor is a kind of researcher is a kind of person, written with the ⊑ symbol; the ontology quietly folded into a set of rules. (See The Running Example: One Knowledge Base, Five Volumes.)

Clause — an "or" of literals; a Horn clause is the special case with at most one un-negated atom, the shape that makes inference cheap. (See Propositional Logic: True, False, and What Follows.)

Competency check — one executable assertion over the running example; the volume's claims are its tests, so the harness's exit code is the verdict — zero if every claim holds, one if any regressed. (See The Honest Verdict: What Foundations Buy You.)

Completeness — the guarantee that a procedure derives all the facts that follow: if something is entailed, forward chaining will eventually produce it, so nothing true is missed. (See Inference and Proof: Chaining Facts into Conclusions.)

Completion / saturation — a description-logic reasoner's fixpoint iteration: repeatedly apply a fixed set of entailment rules, adding memberships and edges until a round changes nothing; the same engine as forward chaining under a different name. (See Fixpoints: Reasoning as Reaching a Limit.)

Composition (R ∘ S) — chaining two relations, "do R, then S," recording the shortcut from a to c whenever R goes a to b and S goes b to c; composing advises with itself yields grand-advising. (See Sets, Relations, and Functions: The Language of Structure.)

Conjunctive query — a question in the existential-conjunctive fragment: an existentially quantified "and" of atoms with some variables left free to be filled, returning a set of answer bindings; the core of database querying. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Connective — an operator that joins truth values: not (¬), and (∧), or (∨), implies (→), and if-and-only-if (↔). (See Propositional Logic: True, False, and What Follows.)

Connectionism — the tradition, crystallized in Parallel Distributed Processing, that treats intelligence as the emergent behavior of many simple units adjusting the strengths of their connections on data, with knowledge spread across the weights rather than written as rules. (See Two Cultures: Symbols versus Vectors.)

Constant — a term that names one fixed individual (alice, p1, mit); lowercase, by the running example's convention. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Corrupted triple — a manufactured negative example, made by swapping a true triple's tail for a random wrong entity, so a ranking model has a false fact to score against a true one. (See Embeddings: Meaning as Geometry.)

Coupling (loose to tight) — the single axis that orders the Kautz taxonomy: from parts that merely exchange symbols at their edges (loose) to parts fused into one differentiable object you cannot pry apart (tight). (See The Kautz Taxonomy: Six Ways to Combine.)

Covering pair — a direct "sits immediately below" edge in an order (professor immediately below researcher); the minimal links a Hasse diagram draws, letting transitivity recover the rest. (See Order and Lattices: When Things Have Rank.)

Decidable fragment — a rule shape (adding guarded and sticky existential rules) where query answering stays decidable even when the chase can run forever, bought at the cost of some expressive power. (See Fixpoints: Reasoning as Reaching a Limit.)

Decision boundary — the surface in feature space where a classifier flips from calling an input one label to the other; for a linear model it is a straight line. (See What Is Learning: Fitting Functions to Data.)

Differentiable — having a well-defined slope at every step; the property that lets backpropagation assign blame and gradient descent improve the parameters, and later lets a logical constraint be trained by the very same machinery. (See Neural Networks: Differentiable Function Approximators.)

Distributed representation — a scheme where a symbol's meaning is spread across all of its coordinates rather than stored in one slot, so that nearby patterns mean similar things. (See Embeddings: Meaning as Geometry.)

EL / EL++ — EL is the lightweight description logic whose core constructors are conjunction (⊓) and existential restriction (∃r.C); EL++ extends it with features such as role chains, and is the basis of the OWL 2 EL ontology profile — the logic our rules implicitly inhabit. (See The Running Example: One Knowledge Base, Five Volumes.)

Embedding — a map from symbols to vectors, chosen so that geometric relationships (distance, direction) encode meaning; the neural bridge that turns entities a network cannot read into points it can compute with. (See Embeddings: Meaning as Geometry.)

Empty set (∅) — the perfectly good set that happens to hold zero elements; it appears the moment a question has no answer (who advises alice? nobody, so the answer is ∅). (See Sets, Relations, and Functions: The Language of Structure.)

Entailment — premises entail a conclusion when every model of the premises is also a model of the conclusion; equivalently, when the premises together with the negated conclusion have no model at all. (See Propositional Logic: True, False, and What Follows.)

EPFO / complex query answering — existential positive first-order queries, and the task of answering them over an incomplete knowledge graph, where a learned model predicts the answer set that exact logical matching would miss. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Existential rule — a rule whose head asserts that something exists rather than naming a known individual ("every researcher has an advisor"); firing it invents a fresh individual and can make forward chaining run forever. (See Fixpoints: Reasoning as Reaching a Limit.)

Extension — the exact set of tuples for which a predicate actually holds in a given structure; advises's extension is the specific list of advising pairs. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Faithfulness — the open worry that a human-readable explanation extracted from a network may not match what the network really computes; a plausible story about the weights can still be wrong. (See Neural Networks: Differentiable Function Approximators.)

Feature — a measurable input the model learns from; here, the out-degree and in-degree read straight off the advises relation for each person. (See What Is Learning: Fitting Functions to Data.)

First-order logic — the logic that cracks the propositional atom open, adding named objects, relations among them, and the quantifiers "for all" and "there exists," so one sentence can speak about a whole crowd. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Fixpoint — a set unchanged by an operator: apply the operator and nothing moves. Forward chaining stops exactly when it reaches one. (See Fixpoints: Reasoning as Reaching a Limit.)

Formula — a sentence built from atoms and connectives; not a flat string but a tree, with a top connective whose branches are smaller formulas down to bare atoms. (See Propositional Logic: True, False, and What Follows.)

Forward chaining — data-driven reasoning: fire every rule whose body currently holds, collect the new heads, and repeat until no new fact appears; it grows the whole model rather than answering one question. (See Inference and Proof: Chaining Facts into Conclusions.)

Forward pass — computing a network's output from an input, left to right: weighted sums, squashed by activations, layer after layer, down to the final number. (See Neural Networks: Differentiable Function Approximators.)

Function — a single-valued relation: each input maps to at most one output, so the arrows never fork. Affiliated qualifies (one institution per person); advises does not (bob advises two students). (See Sets, Relations, and Functions: The Language of Structure.)

Generalization versus memorization — capturing the real pattern (so the model works on inputs it never saw) versus merely recording the answers it was shown (so it fails on the first new one); refereed by a train/test split. (See What Is Learning: Fitting Functions to Data.)

Goal — an atom to be established by a proof; leaving a variable inside it turns the proof into a query for every value that makes it provable. (See Resolution and SLD: How a Machine Proves.)

Gradient descent — the core loop of learning: read the slope of the loss (the gradient), step every parameter a little way downhill, and repeat; the step size is the learning rate and one pass over the data is an epoch. (See What Is Learning: Fitting Functions to Data.)

Grain / zoom level — the observation that a hybrid system's Kautz category depends on how closely you look, so one system can occupy more than one cell at different zoom levels or life stages. (See The Kautz Taxonomy: Six Ways to Combine.)

Hallucination — the neural failure mode: a confident, fluent output for something that is simply false, with no internal signal that it is wrong. (See Two Cultures: Symbols versus Vectors.)

Hasse diagram — the tidy drawing of an order that shows only its direct (covering) edges, places more general items higher, and lets your eye recover everything else by following edges upward. (See Order and Lattices: When Things Have Rank.)

Herbrand base — the finite set of all ground atoms that can be formed from a program's constants; its finiteness is why forward chaining terminates, while backward search relies on acyclic data (or tabling) instead. (See Resolution and SLD: How a Machine Proves.)

Hidden layer — a row of neurons between input and output that rewrites each input as new coordinates — a bent space — in which a task no straight line could solve becomes separable. (See Neural Networks: Differentiable Function Approximators.)

Horn clause / Horn rule — a clause with at most one positive literal, read as "head holds if the whole body holds"; the restricted shape that makes inference branch-free, and a fact is the special case with an empty body. (See Propositional Logic: True, False, and What Follows.)

Immediate-consequence operator (T_P) — one sweep of forward chaining: fire every rule whose body holds and add all the resulting heads. It is monotone, so iterating it climbs to a least fixpoint. (See Inference and Proof: Chaining Facts into Conclusions.)

Incomparable — two elements of an order where neither sits below the other (professor and student); the reason an order is called "partial" rather than total. (See Order and Lattices: When Things Have Rank.)

Inference rule — a licensed move from premises you already hold to a conclusion you may now add; the smallest step of reasoning. (See Inference and Proof: Chaining Facts into Conclusions.)

Interface problem — the unsolved task of passing information between an exact prover and a differentiable model — proofs into gradients, gradients into proofs — without the guarantees of one side or the robustness of the other leaking away. (See Two Cultures: Symbols versus Vectors.)

Join (⊔) / least common subsumer — the least upper bound of two elements: the most specific thing still above both. In a concept hierarchy it is their nearest shared ancestor, so the join of professor and student is researcher. (See Order and Lattices: When Things Have Rank.)

Kautz taxonomy — the field-defining map of neuro-symbolic systems into six categories ordered by how tightly the neural and symbolic parts are coupled: a standard deep pipeline, a solver calling a neural helper, neural perception feeding a symbolic reasoner, rules compiled into a network, logic baked into vectors as a differentiable loss, and a reasoner nested inside the network. (See The Kautz Taxonomy: Six Ways to Combine.)

Kleene fixed-point construction — the constructive recipe that reaches a least fixpoint by iterating the operator from the bottom and taking the limit; it is guaranteed to arrive on a finite lattice, or when the operator is continuous. (See Fixpoints: Reasoning as Reaching a Limit.)

Knaster–Tarski theorem — every monotone operator on a complete lattice has a least fixpoint; an existence guarantee that the target is there, silent on how to compute it. (See Fixpoints: Reasoning as Reaching a Limit.)

Knowledge graph — a database of facts drawn as a labelled network; formally a set of typed relation-triples, the symbolic object that reasoning composes and closes. (See Sets, Relations, and Functions: The Language of Structure.)

Lattice — a partial order in which every pair of elements has both a join and a meet; a join-semilattice has only every join, and a bounded lattice additionally carries a top and a bottom. (See Order and Lattices: When Things Have Rank.)

Learning rate — the size of each downhill step in gradient descent; too small and learning crawls, too large and it overshoots the valley. (See Neural Networks: Differentiable Function Approximators.)

Least fixpoint (lfp) — the smallest fixpoint of a monotone operator; for forward chaining it is the least model, the whole meaning of the program — everything the rules force and nothing more. (See Fixpoints: Reasoning as Reaching a Limit.)

Least Herbrand model — the smallest set of ground facts that makes every rule true; it equals the least fixpoint of T_P, so the procedure and the meaning of the program coincide. (See Fixpoints: Reasoning as Reaching a Limit.)

Linear regression — fitting a straight line to predict a continuous number, by gradient descent on the mean squared error; the from-scratch fit recovers a slope of about two. (See What Is Learning: Fitting Functions to Data.)

Linearly separable — a labeled dataset whose two classes can be split by a single straight boundary; the academic world's professors-versus-students data is separable, and XOR is not. (See Neural Networks: Differentiable Function Approximators.)

Literal — an atom or its negation; the building block of a clause. (See Propositional Logic: True, False, and What Follows.)

Logistic regression — classification by passing the linear score through the sigmoid to produce a probability, then thresholding it; it tells professors from students using two features and a bias. (See What Is Learning: Fitting Functions to Data.)

Loss function — a single number measuring how wrong the model is, which training drives down; mean squared error (MSE) for regression, binary cross-entropy (BCE) for classification. (See What Is Learning: Fitting Functions to Data.)

Margin ranking — the training objective that forces each true triple to score below its corrupted version by at least a fixed margin, so the model cannot collapse everything to a single point. (See Embeddings: Meaning as Geometry.)

Meet (⊓) — the greatest lower bound of two elements: the most general thing still below both. In the academic hierarchy professor and student have no common sub-concept, so their meet is absent without a bottom. (See Order and Lattices: When Things Have Rank.)

Model (logic) — an assignment or structure that makes a formula true; a formula's models are all the ways the world could be for the formula to hold. (See Propositional Logic: True, False, and What Follows.)

Model / parametric function (machine learning) — a fixed functional shape with adjustable knobs (parameters); learning is the search for the parameter setting that fits best, the line y = w x + b being the simplest. (See What Is Learning: Fitting Functions to Data.)

Modus ponens — the oldest inference rule: from a fact P and a rule "if P then Q," conclude Q; truth-preserving, and the single move forward chaining fires over and over. (See Inference and Proof: Chaining Facts into Conclusions.)

Monotone map / monotone operator — a function that never scrambles the order: whenever a is below b, its output on a is below its output on b — a bigger input yields a bigger output. This is the property Knaster–Tarski needs. (See Order and Lattices: When Things Have Rank.)

Multi-hop query — a question whose answer is stored nowhere and must be composed by following several edges in turn, such as "who does alice grand-advise." (See The Running Example: One Knowledge Base, Five Volumes.)

Multi-layer perceptron (MLP) — the plainest neural network: stacked layers of neurons, here in the 2-4-1 shape (2 inputs, 4 hidden units, 1 output) that learns XOR. (See Neural Networks: Differentiable Function Approximators.)

Neuro-symbolic AI — the program of joining neural learning with symbolic reasoning so one system can both generalize like geometry and prove like logic; the subject of the whole series, and the "third wave" of the field. (See Two Cultures: Symbols versus Vectors.)

Neuron — a unit that computes a weighted sum of its inputs, adds a bias, and passes the result through a nonlinear activation; the atom a network is built from. (See Neural Networks: Differentiable Function Approximators.)

Never silent, never certain — the embedding's signature trade-off: it returns a number for every triple you can name (never silent), but any single answer can be wrong (never certain) — the mirror image of a prover that is sound and complete yet silent about the open world. (See Embeddings: Meaning as Geometry.)

Occurs-check — the unification guard, needed only when function symbols are present, that stops a variable from being bound to a term containing it; unnecessary in function-free Datalog. (See Resolution and SLD: How a Machine Proves.)

Open-world generalization — an embedding's ability to assign a plausibility to triples that appear nowhere in the data and follow from no rule; the prize logic could not offer, since logic stays silent on what it cannot derive. (See Embeddings: Meaning as Geometry.)

Ordered pair (a, b) — a two-slot object where order carries meaning, so (alice, bob) is a different object from (bob, alice); the ingredient a relation is built from. (See Sets, Relations, and Functions: The Language of Structure.)

Partial order (poset) — a relation, written ≤, that is reflexive, antisymmetric, and transitive; it ranks a domain into a hierarchy while allowing some pairs to remain incomparable. (See Order and Lattices: When Things Have Rank.)

Physical symbol system hypothesis — the founding claim of symbolic AI: that a system manipulating symbols by explicit rules has the necessary and sufficient means for general intelligent action. (See Two Cultures: Symbols versus Vectors.)

Predicate — a symbol for a property (professor, unary) or a relationship (advises, binary); applied to terms it forms an atom, the smallest complete claim. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Proof / derivation — a finite sequence of atoms in which every atom is a base fact or the head of a rule whose body atoms all appear earlier; the auditable trail of firings behind a derived fact. (See Inference and Proof: Chaining Facts into Conclusions.)

Proof tree — the nested record of a goal and the sub-goals that established it, returned by backward chaining; an auditable trace a human can read line by line, not just a yes-or-no. (See Resolution and SLD: How a Machine Proves.)

Propositional logic — the smallest complete logic: claims that are simply true or false, glued together with connectives, small enough to decide by enumerating every truth assignment. (See Propositional Logic: True, False, and What Follows.)

Quantifier — one of the two words first-order logic adds: "for all" (∀) asserts a body of every individual, "there exists" (∃) asserts it of at least one; checked over a finite domain by an all-or-any sweep. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Query answering — enumerating every binding of a goal's variables that proves it, so asking for the colleagues of alice returns bob. (See Resolution and SLD: How a Machine Proves.)

Reasoning shortcut — a model reaching the right answer through a shallow proxy rather than the concept we meant; the classifier leaning on "being advised" as a stand-in for "student" is a small example. (See What Is Learning: Fitting Functions to Data.)

Reflexive, symmetric, transitive — the three named shapes a relation can have: relates-to-itself, arrows-go-both-ways, and arrows-chain-into-shortcuts. Advising has none of the three; transitivity is the one that matters most for reasoning. (See Sets, Relations, and Functions: The Language of Structure.)

Region embedding (box, ball) — a richer geometry that represents a class as a region of space rather than a single point, so a subsumption like "every researcher is a person" can be drawn as one region genuinely containing another. (See Embeddings: Meaning as Geometry.)

Reinforcement learning — learning from rewards rather than labeled answers: an agent takes actions, receives feedback, and adjusts to maximize reward over time; the frame behind game-playing and robot control. (See What Is Learning: Fitting Functions to Data.)

Relation — a subset of a Cartesian product; a chosen set of tuples, such as advises, cites, or affiliated. It is the plainest object almost every later abstraction is built from. (See Sets, Relations, and Functions: The Language of Structure.)

Role chain — a relation composed with itself or another, such as advises followed by advises being a kind of grand-advising; formally a complex role inclusion, a step past plain EL. (See The Running Example: One Knowledge Base, Five Volumes.)

SATORI capstone — the joint neuro-symbolic system the series builds toward, measured on this same academic knowledge base so its claims have a clean answer rather than a confound. (See The Running Example: One Knowledge Base, Five Volumes.)

SAT / model counting — Boolean satisfiability, deciding whether a formula has any model (NP-complete), and the harder problem of counting how many models it has (#P-hard); the crisp ground truth a later volume approximates with weighted model counting. (See Propositional Logic: True, False, and What Follows.)

Satisfaction (holds) — the relation "sentence f is true in structure s"; for a quantifier it is decided by trying every individual in the finite domain, "for all" as an all-sweep and "there exists" as an any-sweep. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Satisfiable — a formula is satisfiable if at least one truth assignment makes it true — that is, it has a model. (See Propositional Logic: True, False, and What Follows.)

Score (TransE) — the distance from the head-plus-relation translation to the tail; a penalty where lower means more plausible, defined for any triple you can name. (See Embeddings: Meaning as Geometry.)

Sentence — a formula with no free (unquantified) variables, so it has a definite truth value once a structure is fixed. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Set — an unordered collection of distinct things called its elements; membership (∈) is all-or-nothing, order does not matter, and nothing is in twice. The most load-bearing idea in the volume. (See Sets, Relations, and Functions: The Language of Structure.)

Sigmoid — the S-shaped squashing function σ(z) that bends any real number into the range between 0 and 1, so a linear score can be read as a probability; also the classic neuron activation. (See What Is Learning: Fitting Functions to Data.)

SLD resolution — Selective Linear resolution for Definite clauses: Robinson's resolution rule specialized to Horn clauses, the backward-chaining proof procedure behind Prolog that returns a proof tree, not just a truth value. (See Resolution and SLD: How a Machine Proves.)

Soft unification — a later volume's replacement of exact symbol equality with vector similarity, so near-synonyms like advises and mentors match to a degree; the proof tree survives but now carries a confidence instead of a guarantee. (See Resolution and SLD: How a Machine Proves.)

Soundness — the guarantee that a procedure derives only true consequences: every atom in the least fixpoint is genuinely entailed, never guessed. Paired with completeness, it means the derived model is exactly the set of true consequences. (See Inference and Proof: Chaining Facts into Conclusions.)

Standardize apart (rename) — stamping a rule's variables with fresh names before each use, so two applications of the same rule in one proof never accidentally share a variable. (See Resolution and SLD: How a Machine Proves.)

Stochastic gradient descent (SGD) — the downhill-by-small-steps optimizer applied one example at a time, here nudging entity and relation vectors each pass until the geometry settles. (See Embeddings: Meaning as Geometry.)

Structure — the world a first-order sentence is checked against: a domain of individuals plus, for each predicate, its extension. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Subset (A ⊆ B) — every element of A is also in B; how "every professor is a person" is stated without naming anyone. (See Sets, Relations, and Functions: The Language of Structure.)

Substitution — a mapping of a rule's variables to constants (or terms) that makes its body match known facts; a single variable-to-term assignment is a binding. (See Inference and Proof: Chaining Facts into Conclusions.)

Supervised learning — fitting a function from labeled examples, each an input paired with its correct output; a teacher has already marked every example, and the learner's job is to imitate that teacher. (See What Is Learning: Fitting Functions to Data.)

Symbolic AI — the tradition that treats intelligence as rule-governed manipulation of symbols; exact and explainable, but brittle to anything outside its hand-authored knowledge. (See Two Cultures: Symbols versus Vectors.)

Tabling (SLG resolution) — the loop-checking discipline real Prolog adds to plain SLD, remembering already-tried goals so a recursive rule over cyclic data cannot spin forever. (See Resolution and SLD: How a Machine Proves.)

Term — a name for an individual: either a constant or a variable. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Terminating-chase fragment — a rule shape (existential-free Datalog, the EL family, weakly-acyclic or acyclic existential rules) whose chase is finite, so a plain fixpoint loop computes the answer outright. (See Fixpoints: Reasoning as Reaching a Limit.)

Three tensions — the axes on which every later method can be located: exact versus robust, explainable versus opaque, and complete versus scalable; no single method in the volume wins all three. (See The Honest Verdict: What Foundations Buy You.)

Top (⊤) / bottom (⊥) — the universal element above everything (the concept "Thing") and the empty element below everything (the concept "Nothing" with no members); adding them can repair a lattice's missing bounds. (See Order and Lattices: When Things Have Rank.)

TransE (translating embeddings) — the model in which every relation is a translation vector, so a true triple (h, r, t) satisfies h + r ≈ t and plausibility becomes a distance; the smallest complete example of "meaning as geometry." (See Embeddings: Meaning as Geometry.)

Transitive closure — the smallest transitive relation containing a given one — reachability — computed by adding composed shortcuts until a round adds nothing; the textbook recursive fixpoint, and why the citation relation closes to include p3 reaching p1. (See Sets, Relations, and Functions: The Language of Structure.)

Triple — a binary fact written (head, relation, tail), for example (alice, advises, bob). (See Embeddings: Meaning as Geometry.)

Truth assignment — a choice of true or false for every atom — one setting of all the light switches; under it, a formula has a single computable truth value. (See Propositional Logic: True, False, and What Follows.)

Undecidability of validity — the wall that no algorithm can always decide whether a first-order sentence is true in every possible structure; the best a procedure can do is semi-decide, which is why a later volume retreats to decidable description logic. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Unification — the operation that makes two atoms identical by finding a substitution, or fails when no substitution can (a clash); the shared primitive under both proof engines. (See Resolution and SLD: How a Machine Proves.)

Universal approximation — the theorem that one hidden layer of enough sigmoid units can approximate any continuous function on a bounded region to any accuracy; the theoretical license behind training a network instead of writing a rule. (See Neural Networks: Differentiable Function Approximators.)

Unsupervised learning — learning structure from inputs with no labels at all, for instance clustering people by shared institution without being told the groups. (See What Is Learning: Fitting Functions to Data.)

Upper / lower bound — an element sitting above (or below) both of two given elements; the least upper bound is the join and the greatest lower bound is the meet. (See Order and Lattices: When Things Have Rank.)

Valid / tautology — a formula that is true under every truth assignment, so it can never fail. (See Propositional Logic: True, False, and What Follows.)

Variable — a placeholder term that ranges over individuals (X, Y); uppercase, by the running example's convention. (See First-Order Logic: Objects, Relations, and Quantifiers.)

Weight and bias — the two parameters learning adjusts in a linear model: the weight w (slope, how strongly a feature counts) and the bias b (intercept, a constant offset). (See What Is Learning: Fitting Functions to Data.)

XOR (exclusive-or) — the pattern true when exactly one input is on; the smallest classic example that no single straight line can separate, which a hidden layer learns by bending space. (See Neural Networks: Differentiable Function Approximators.)

If a term here still feels fuzzy, follow it back into the chapter where it lives, and it will make far more sense in context.