Glossary

📍 Where we are: The back-of-the-book reference for all of Volume 4 — every recurring term of neuro-symbolic integration, in plain words. Keep it open in a second tab and come back whenever a word stops making sense.

Neuro-symbolic integration inherits its vocabulary from three directions at once: the logic of Volume 2, the geometry and gradients of Volume 3, and the probability theory that binds them, then sharpens every term against one small academic knowledge graph. Below are the volume's recurring terms, in plain language, listed alphabetically so they are easy to find. Each entry is a starting point; the chapter it points to gives the full, exact picture.

Abstention — a pipeline's explicit refusal to answer when no translation survives parsing; a visible failure rather than a silent wrong answer, and the committed harness asserts that the two never trade places. (See Translate-Then-Prove: Logic-LM and LINC.)

Annotated disjunction — ProbLog's construct for a probabilistic choice among several alternative rule heads, at most one of which holds: the head probabilities sum to at most one, with any remainder on the outcome that no head fires. The escape from pure fact-by-fact independence, and the declaration form DeepProbLog's neural predicates reuse. (See DeepProbLog: Neural Predicates and the Gradient Semiring.)

Beam search — evaluating a query's computation DAG while keeping only the top k concrete candidate entities at each bound variable (k is the beam width). Fast and interpretable, but a pruned witness is unrecoverable, which is the beam's derived failure mode. (See Fuzzy and Training-Free CLQA: CQD, GNN-QE, QTO.)

Chain rule (logical) — a Horn rule whose body is a single path of relations through fresh intermediate variables, so that applying the rule is an ordered product of adjacency matrices; the entire hypothesis space of Neural-LP and DRUM. (See Neural-LP and DRUM: Learning Chain Rules.)

Circuit (arithmetic) — a directed acyclic graph whose leaves are literals or constants and whose internal nodes are AND and OR gates; once the right structural properties hold, one bottom-up pass with numbers in place of truth values computes a weighted model count, and a different algebra in the same pass answers a different question. (See Circuits: SDD, d-DNNF, and Fast Evaluation.)

Closed-world assumption — the convention that an atom which cannot be proved is false. RuleTaker's data generation depends on it, and query embedding's negation-as-complement is its knowledge-graph form: a convention about missing edges, not a truth about them. (See Soft Reasoners: RuleTaker and ProofWriter.)

Computation DAG — a query written as a directed acyclic graph: anchor entities at the leaves; projection, intersection, union, and complement at the internal nodes; evaluated in topological order, with the existential variable absorbed into projection. (See Query Embedding: The Computation DAG.)

Constraint layer — a final network layer that renormalizes probability mass onto the constraint-satisfying outputs, so violating the constraint becomes impossible by construction rather than merely expensive; the design alternative to the semantic loss, pricing the same quantity. (See Semantic Loss and Constraint Layers.)

d-DNNF (deterministic decomposable negation normal form) — the target language of knowledge compilation, combining decomposability, determinism, and smoothness; counting, most probable explanation, and enumeration each run in one bottom-up pass over the compiled circuit. (See Circuits: SDD, d-DNNF, and Fast Evaluation.)

Decomposability — the circuit property that every AND's children mention pairwise disjoint variable sets; exactly the condition under which the weighted model count of a conjunction is the product of its children's counts, with no coin double-used. (See Circuits: SDD, d-DNNF, and Fast Evaluation.)

Designated value — a truth value a many-valued logic counts as asserted, good enough to stand behind; a formula is a tautology when every valuation lands it in the designated set, so the same truth tables with a different designated set define a different logic. (See Many-Valued Logic: Beyond True and False.)

Determinism (circuit) — the property that every OR's children are pairwise logically disjoint, so no assignment satisfies two branches at once; exactly the condition under which addition needs no inclusion-exclusion correction, and the structural cure for the disjoint-sum problem. (See Circuits: SDD, d-DNNF, and Fast Evaluation.)

Disjoint-sum problem — proofs are overlapping events, so summing per-proof probabilities double counts the worlds where several proofs hold together; the volume's recurring witness is a "probability" of 1.575 against the true 0.8865. (See Distribution Semantics: Logic Meets Probability.)

Distribution semantics — the semantics in which independent probabilistic facts induce a probability distribution over possible worlds, and a query's probability is the total weight of the worlds that derive it; exact and calibrated by construction, at #P cost. (See Distribution Semantics: Logic Meets Probability.)

Dual number — a pair (value, derivative) carried through a computation, with addition acting on both slots and multiplication following the product rule; forward-mode differentiation as plain arithmetic, and the shape of the gradient semiring's tags. (See Scallop: Differentiable Datalog with Provenance.)

Easy vs. hard answers — easy answers to a query are derivable from the observed training edges alone; hard answers require imputing at least one held-out edge, and the field's metrics are computed on the hard answers only. (See Query Embedding: The Computation DAG.)

EM (expectation-maximization) — the alternation that trains models with latent variables: infer the latent variable given the current models (the E-step), then refit the models given the inferred latent variable (the M-step). RNNLogic's latent variable is the rule set itself. (See RNNLogic and the Symbolic Baseline AnyBURL.)

EPFO query — an existential positive first-order query: one free variable, existential variables, conjunction and disjunction, no negation; the query family whose computation DAGs the query-embedding chapters answer, later extended with limited negation. (See Query Embedding: The Computation DAG.)

Fuzzy logic — the logic of degrees: truth values range over the whole unit interval from 0 to 1, and every connective is a truth-functional real-valued function, so a compound's degree is computed from its parts' degrees alone; probability, provably, is not truth-functional. (See T-norms and T-conorms: Fuzzy AND and OR.)

Gradient semiring — the commutative semiring on pairs (p, ∇p) whose ⊕ adds both slots and whose ⊗ applies the product rule; one circuit pass under it returns a query's probability and its exact gradient together. (See DeepProbLog: Neural Predicates and the Gradient Semiring.)

Grounding (Real Logic) — Logic Tensor Networks' mapping from symbols to tensors: constants become learnable vectors, predicates become differentiable functions into the unit interval, and formulas become compositions of both. (See Logic Tensor Networks: Real Logic.)

Inclusion-exclusion — the alternating-sum repair for overlapping events, P(A ∨ B) = P(A) + P(B) − P(A ∧ B); exact, but the number of correction terms explodes with the number of overlapping proofs, which is why compilation replaces it. (See Distribution Semantics: Logic Meets Probability.)

Knowledge compilation — spending a possibly expensive one-time effort translating a formula into a circuit with structural guarantees, after which every query about it answers in time linear in the compiled circuit's size. (See Circuits: SDD, d-DNNF, and Fast Evaluation.)

Many-valued logic — a logic whose truth set holds more than two values, such as K3 and Ł3 over 0, ½, and 1; the connective tables and the designated set are independent components, and which classical laws survive depends on the pair. (See Many-Valued Logic: Beyond True and False.)

Most probable explanation (MPE) — the single maximum-weight satisfying assignment of a formula; computed by evaluating the compiled circuit under the (max, ×) semiring and decoded by descending, at each OR, into a child attaining the node's value. (See Circuits: SDD, d-DNNF, and Fast Evaluation.)

Neural predicate — a family of probabilistic facts whose probabilities are a neural network's outputs, declared in DeepProbLog as a neural annotated disjunction: a softmax head read as a mutually exclusive choice among ground atoms, probabilities summing to one. (See DeepProbLog: Neural Predicates and the Gradient Semiring.)

p-mean quantifier — Logic Tensor Networks' aggregators for the universal and existential quantifiers: generalized p-means whose exponent p dials outlier sensitivity, recovering hard min and max in the limit, with gradient concentrating on the most-violated instances. (See Logic Tensor Networks: Real Logic.)

Possible world — one total choice over the probabilistic facts: a subset of the coins declared true, weighted by the product of p over the chosen facts and 1 − p over the omitted ones; together with the certain facts and rules, one fully classical situation. (See Distribution Semantics: Logic Meets Probability.)

Probabilistic fact — a fact written p :: f and treated as an independent coin, true with probability p; the atomic unit of the distribution semantics, and the leaf a compiled circuit prices. (See Distribution Semantics: Logic Meets Probability.)

Proof accuracy — the fraction of items whose emitted reasoning chain passes the strict step checker in full, every step valid, linked, and connected to the goal; label accuracy minus proof accuracy is the right-for-wrong-reason rate. (See NL Reasoning Benchmarks: FOLIO, LogicBench, PrOntoQA.)

Provenance semiring — a commutative semiring of tags that facts carry through the Datalog fixpoint: ⊗ combines a rule body's tags, ⊕ merges alternative derivations of the same head; max-prob, top-k proofs, and the gradient semiring are all instances of the one contract. (See Scallop: Differentiable Datalog with Provenance.)

Rank (rule learning) — the number of independent attention chains in DRUM's CP (canonical polyadic) decomposition of the body-confidence tensor. Rank 1 forces the entanglement that stops Neural-LP from holding two independent rules confidently at once; rank L suffices for any weighted set of L chain rules. (See Neural-LP and DRUM: Learning Chain Rules.)

Real Logic — the fully differentiable first-order language of Logic Tensor Networks: first-order syntax, semantics in the unit interval, every operator chosen to carry gradients, and a proved collapse to classical logic on 0/1 inputs. (See Logic Tensor Networks: Real Logic.)

Residuum — the canonical implication a t-norm owes: the largest degree that, conjoined with the premise, never overshoots the conclusion. The adjunction T(x, z) ≤ y ⇔ z ≤ I(x, y) makes it the unique arrow sound for fuzzy modus ponens, and mixing families breaks the guarantee. (See T-norms and T-conorms: Fuzzy AND and OR.)

Rule confidence — AnyBURL's score for a mined rule: its support divided by its body-grounding count plus a pessimism constant that damps rules with tiny support; exact counting on the observed graph, with no gradient anywhere. (See RNNLogic and the Symbolic Baseline AnyBURL.)

Rule template — a rule shape with free slots. In neural theorem proving the slots are learnable predicate embeddings, and learning a rule means moving a slot near a real predicate; in AnyBURL the templates are the fixed menu of generalizations of a sampled ground path. (See Neural Theorem Proving: NTP and CTP.)

SatAgg — the aggregated truth of a whole Real Logic theory, one p-mean taken over the per-axiom truths; Logic Tensor Networks train by minimizing 1 − SatAgg, satisfaction maximization as a loss. (See Logic Tensor Networks: Real Logic.)

Self-refinement — feeding the solver's error message back to the translator for a bounded number of repair rounds; it fixes syntax and lifts the executable rate, but it rarely repairs meaning, because a semantic error produces no error message. (See Translate-Then-Prove: Logic-LM and LINC.)

Semantic loss — a propositional constraint over a network's output bits priced as the negative logarithm of the weighted model count of the constraint under the network's own sigmoids: the self-information of sampling a satisfying state, pinned down uniquely (up to a constant) by three plain axioms and computed on the compiled circuit. (See Semantic Loss and Constraint Layers.)

Smoothness (circuit) — the property that every OR's children mention the same variable set, restorable with pass-through nodes of the form v ∨ ¬v; a free no-op under (+, ×) since p + (1 − p) = 1, but load-bearing under (max, ×), where a pass-through prices a free variable at max(p, 1 − p). (See Circuits: SDD, d-DNNF, and Fast Evaluation.)

Soft unification kernel — the similarity score that replaces symbolic unification's fail-or-succeed with a graded match on symbol embeddings, an exponential falloff in embedding distance; identical symbols score exactly 1, so a prover can use facts written in a vocabulary it was never given. (See Neural Theorem Proving: NTP and CTP.)

Softmin — the log-sum-exp smoothing of the minimum at temperature τ: it stays within τ log n below the true min and spreads gradient over every input, where the hard min hands its one winning input the entire gradient. (See From Fuzzy to Neural: Softmin, Softmax, and Gradients.)

Step checker — the verifier that parses each line of a reasoning chain and tests three things: the step instantiates a valid rule, its premises are immediately available where it stands, and the chain connects the premises to the goal; the conjunction of the three is strict proof accuracy. (See NL Reasoning Benchmarks: FOLIO, LogicBench, PrOntoQA.)

t-conorm — the fuzzy OR a t-norm owes through De Morgan's law, S(x, y) = 1 − T(1 − x, 1 − y): max for Gödel, the probabilistic sum x + y − xy for product, and the bounded sum min(1, x + y) for Łukasiewicz. (See T-norms and T-conorms: Fuzzy AND and OR.)

t-norm — any commutative, associative, monotone function on pairs of truth degrees with 1 as its unit: the exact axioms a graded conjunction must satisfy, and every t-norm restricts to Boolean AND on the corners. The three that carry fuzzy logic are min (Gödel), product, and Łukasiewicz. (See T-norms and T-conorms: Fuzzy AND and OR.)

TensorLog operator — a relation read as a 0/1 adjacency matrix, so that right-multiplying a mass vector pushes it one hop along the relation; the substrate over which Neural-LP and DRUM search for chain rules. (See Neural-LP and DRUM: Learning Chain Rules.)

Three-way entailment — the label scheme True / False / Unknown: True if the premises entail the conclusion, False if they entail its negation, Unknown if neither; decided by asking the prover two questions, the goal and its negation, under the open world. (See NL Reasoning Benchmarks: FOLIO, LogicBench, PrOntoQA.)

Top-k proofs — the provenance in which a fact's tag keeps at most the k most probable proofs through disjunction and conjunction; k is an exactness dial, with fidelity rising monotonically and saturating at exact inference once k reaches the proof count. (See Scallop: Differentiable Datalog with Provenance.)

Translate-then-prove — the architecture in which a translator maps natural language to a formal program and a symbolic engine derives the answer; the engine's factor in the correctness product is pinned at 1 by soundness, completeness, and termination, so all fallibility concentrates in the translation stage. (See Translate-Then-Prove: Logic-LM and LINC.)

Vocabulary independence — the design requirement that no model parameter be indexed by an entity or relation name, which is what lets one pretrained model transfer to a graph whose vocabulary it has never seen; made executable as relabeling invariance, where renaming every relation to an opaque token changes no score. (See Foundation Models for CLQA: LMPNN and UltraQuery.)

Weighted model counting (WMC) — summing, over the satisfying assignments of a formula, the product of the chosen literals' weights; the single currency of probabilistic-logic inference, #P-complete on arbitrary formulas and linear-time on a compiled circuit. (See Weighted Model Counting: The #P Wall.)

Zero-shot query answering — answering query structures, or whole knowledge graphs, never seen in training: composing trained operators along the computation DAG, or recomputing structural features on the new graph and applying frozen parameters with no gradient updates; the field's probe for operator-level rather than template-level learning. (See Foundation Models for CLQA: LMPNN and UltraQuery.)

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.