unicode-logic-kit 0.31.0__py3-none-any.whl

unicode_logic_kit/semantics/thirdorder.py

@@ -0,0 +1,358 @@
+"""Third-order finite-model semantics: satisfaction where an argument can be a property.
+
+:mod:`semantics.secondorder` quantifies over relations on the domain. This
+evaluator adds the level above: a predicate whose ARGUMENT is a relation —
+``Positive(G)``, ``Essence(G, x)``, ``Positive(λx. ¬G(x))`` — and quantification
+over such predicates. It reuses :class:`semantics.tarski.Structure` and
+:func:`semantics.tarski.term_value` unchanged; what changes is that an argument
+slot may now be filled by a relation rather than an individual, so a "tuple in
+the extension" may have relations among its components.
+
+**Slots, not just arities.** At second order a bound predicate variable is fully
+described by its arity. At third order it is not: ``Positive`` and ``G`` can both
+have arity 1 and mean entirely different things, because ``G``'s slot holds an
+individual and ``Positive``'s holds a property. What each slot holds is inferred
+by :func:`unicode_logic_kit.fol.nodes.analyse_signatures` and threaded through the
+evaluation, which is why this module's quantifier case enumerates over a
+SIGNATURE where the second-order one enumerates over an arity.
+
+**Cost.** An individual slot ranges over the ``n`` domain elements; a property
+slot of arity ``j`` over the ``2 ** (n ** j)`` relations of that arity. A
+predicate of a given signature is any subset of the product of its slots, so a
+monadic third-order predicate over a domain of ``n`` has ``2 ** (2 ** n)``
+interpretations: 16 for ``n = 2``, 256 for 3, 65 536 for 4, about 4·10⁹ for 5.
+Small, then suddenly not — which is what :data:`MAX_INTERPRETATIONS` guards, by
+raising a clear error rather than hanging.
+
+**Scope.** Two-valued, classical, constant-domain. Łukasiewicz and modal nodes
+are rejected by name, as in the second-order evaluator — a third-order MODAL
+formula is not evaluated here but exported by
+:mod:`unicode_logic_kit.hol.ho_modal`. λ-abstractions are NOT rejected here,
+unlike at second order: in argument position a λ is precisely how an anonymous
+property is written, and it is evaluated to its extension. A λ anywhere else
+still has no reading.
+"""
+
+from itertools import product
+from typing import Any, FrozenSet, Iterable, List, Mapping, Optional, Tuple
+
+from ..fol.nodes import (
+    Node,
+    Atom, Not, And, Or, Xor, Implies, Iff, Quantifier,
+    SortedQuantifier, SecondOrderQuantifier,
+    Lambda, LambdaVar, PredicateTerm, Variable,
+    analyse_signatures,
+)
+from ..fol._ho_nodes import INDIVIDUAL, Signatures
+from .tarski import (
+    Structure, term_value, _atom_value, _extend,
+    _FORALL, _EXISTS, _FUZZY_TYPES,
+)
+
+#: A relation: a (frozen)set of argument tuples. A component of one of those
+#: tuples is an individual at first/second order, and may be another relation at
+#: third order — which is the whole difference.
+Relation = FrozenSet[Tuple[Any, ...]]
+PredBinding = Mapping[str, Relation]
+
+#: Safety cap on one quantifier's enumeration. See the module docstring for how
+#: fast the count grows; raise this attribute if you really mean to enumerate
+#: more.
+MAX_INTERPRETATIONS = 1 << 20  # ~1.05 million
+
+
+def slot_values(kind, domain: Tuple[Any, ...]) -> Tuple[Any, ...]:
+    """Return everything one argument slot can hold.
+
+    ``kind`` is :data:`unicode_logic_kit.fol._ho_nodes.INDIVIDUAL` — in which case
+    the answer is the domain — or ``("p", j)``, in which case it is every
+    ``j``-ary relation on the domain, i.e. every subset of ``domain ** j``.
+    """
+    if kind == INDIVIDUAL:
+        return domain
+    arity = kind[1]
+    base = list(product(domain, repeat=arity))
+    return tuple(
+        frozenset(base[i] for i in range(len(base)) if (mask >> i) & 1)
+        for mask in range(1 << len(base))
+    )
+
+
+def all_interpretations(signature: Tuple[Any, ...],
+                        domain: Tuple[Any, ...]) -> Iterable[Relation]:
+    """Yield every interpretation of a predicate with the given argument ``signature``.
+
+    An interpretation is any subset of the product of the slots' value sets, so
+    the count is ``2 ** prod(len(slot_values(kind)) for kind in signature)``. An
+    empty signature (a propositional variable) has the single-element product
+    ``{()}``, hence exactly the two interpretations false and true — matching
+    the second-order evaluator's arity-0 case.
+    """
+    columns = [slot_values(kind, domain) for kind in signature]
+    base = list(product(*columns)) if columns else [()]
+    for mask in range(1 << len(base)):
+        yield frozenset(base[i] for i in range(len(base)) if (mask >> i) & 1)
+
+
+def interpretation_count(signature: Tuple[Any, ...], domain_size: int) -> int:
+    """How many interpretations :func:`all_interpretations` would yield.
+
+    Computed without enumerating anything, so a caller (and the evaluator's own
+    guard) can refuse an impossible enumeration before starting it.
+    """
+    width = 1
+    for kind in signature:
+        width *= (domain_size if kind == INDIVIDUAL
+                  else 1 << (domain_size ** kind[1]))
+    return 1 << width
+
+
+def satisfies_to(formula: Node,
+                 structure: Structure,
+                 assignment: Optional[Mapping[str, Any]] = None,
+                 pred_binding: Optional[PredBinding] = None,
+                 signatures: Optional[Signatures] = None) -> bool:
+    """Return whether ``structure`` satisfies ``formula`` (third-order Tarski).
+
+    ``assignment`` maps object-variable names to individuals; ``pred_binding``
+    maps a bound predicate name to its current interpretation. ``signatures``
+    is the argument-slot analysis; it is computed from ``formula`` when omitted,
+    and threaded unchanged through the recursion so every occurrence of a symbol
+    is read at the same type.
+
+    The recursion differs from :func:`semantics.secondorder.satisfies_so` in
+    exactly two places, both about arguments:
+
+    - an **atom's** arguments are evaluated with :func:`argument_value`, so an
+      argument may be a :class:`~unicode_logic_kit.fol.nodes.PredicateTerm` or a
+      λ-abstraction and evaluate to a RELATION. When every argument is an
+      ordinary term the atom is handed to the first-order
+      :func:`semantics.tarski._atom_value` unchanged, so ``=`` / ``≠`` and the
+      arithmetic fallbacks behave exactly as they do at first order;
+    - a **predicate quantifier** enumerates over the bound symbol's SIGNATURE
+      rather than its arity, which is what makes ``∀Positive`` range over
+      predicates of properties instead of over relations on the domain.
+
+    Raises:
+        ValueError: on a Łukasiewicz node, an unknown quantifier or node type,
+            or when a quantifier's enumeration would exceed
+            :data:`MAX_INTERPRETATIONS`.
+        NotImplementedError: on a modal node (use the Kripke evaluator, or
+            export a third-order modal formula with ``hol.ho_modal``), or on a
+            λ outside argument position.
+    """
+    if assignment is None:
+        assignment = {}
+    if pred_binding is None:
+        pred_binding = {}
+    if signatures is None:
+        signatures = analyse_signatures([formula])
+
+    if isinstance(formula, Atom):
+        return _atom_truth(formula, structure, assignment, pred_binding, signatures)
+
+    if isinstance(formula, Not):
+        return not satisfies_to(formula.formula, structure, assignment,
+                                pred_binding, signatures)
+    if isinstance(formula, And):
+        return (satisfies_to(formula.left, structure, assignment, pred_binding, signatures)
+                and satisfies_to(formula.right, structure, assignment, pred_binding, signatures))
+    if isinstance(formula, Or):
+        return (satisfies_to(formula.left, structure, assignment, pred_binding, signatures)
+                or satisfies_to(formula.right, structure, assignment, pred_binding, signatures))
+    if isinstance(formula, Xor):
+        return (satisfies_to(formula.left, structure, assignment, pred_binding, signatures)
+                != satisfies_to(formula.right, structure, assignment, pred_binding, signatures))
+    if isinstance(formula, Implies):
+        return ((not satisfies_to(formula.left, structure, assignment, pred_binding, signatures))
+                or satisfies_to(formula.right, structure, assignment, pred_binding, signatures))
+    if isinstance(formula, Iff):
+        return (satisfies_to(formula.left, structure, assignment, pred_binding, signatures)
+                == satisfies_to(formula.right, structure, assignment, pred_binding, signatures))
+
+    if isinstance(formula, Quantifier):
+        return _object_quantifier(formula.type, formula.variable.name,
+                                  structure.domain, formula.formula, structure,
+                                  assignment, pred_binding, signatures)
+    if isinstance(formula, SortedQuantifier):
+        return _object_quantifier(formula.type, formula.variable.name,
+                                  structure.sort_universe(formula.sort),
+                                  formula.formula, structure, assignment,
+                                  pred_binding, signatures)
+    if isinstance(formula, SecondOrderQuantifier):
+        return _predicate_quantifier(formula, structure, assignment,
+                                     pred_binding, signatures)
+
+    if isinstance(formula, _FUZZY_TYPES):
+        raise ValueError(
+            f"Cannot evaluate Łukasiewicz node {type(formula).__name__} with the "
+            "two-valued third-order evaluator; use the fuzzy evaluator instead.")
+    if isinstance(formula, Lambda):
+        raise NotImplementedError(
+            "A λ-abstraction denotes a PROPERTY, not a truth value; it has a "
+            "reading here only in argument position (Positive(λx. ¬G(x))).")
+    if type(formula).__name__ in ("Box", "Diamond"):
+        raise NotImplementedError(
+            f"Modal node {type(formula).__name__} is out of scope for the "
+            "third-order evaluator; use the Kripke evaluator, or export the "
+            "formula with hol.ho_modal for a higher-order prover.")
+    raise ValueError(f"satisfies_to: unsupported node type {type(formula).__name__}.")
+
+
+def _extension_in(structure: Structure, name: str, arity: int) -> Iterable[Tuple[Any, ...]]:
+    """The extension of the predicate ``name/arity`` in ``structure``.
+
+    The structure's table for it. A missing table is the empty relation, matching
+    the first-order convention -- unless the name is a SORT of the structure: a sort
+    and the unary predicate of that name are one symbol, so a unary ``name`` that
+    the structure knows only as a sort is that sort's universe, one 1-tuple per
+    member. This is the reading :func:`semantics.tarski._atom_value` gives an atom
+    ``S(t)``, and the laws a sort must satisfy are checked here as they are there
+    (an :class:`~unicode_logic_kit.semantics.tarski.IllegalStructureError` for an
+    empty sort, or one that disagrees with the predicate table of its name).
+    """
+    extension = structure.predicates.get((name, arity))
+    if arity == 1 and name in structure.sorts:
+        universe = structure.sort_universe(name)
+        if extension is None:
+            return {(d,) for d in universe}
+    return extension if extension is not None else ()
+
+
+def argument_value(node: Node, structure: Structure,
+                   assignment: Mapping[str, Any],
+                   pred_binding: PredBinding,
+                   signatures: Signatures) -> Any:
+    """Evaluate a node in ARGUMENT position — to an individual or to a relation.
+
+    A :class:`~unicode_logic_kit.fol.nodes.PredicateTerm` denotes the relation its
+    name stands for: the current binding if the name is bound, otherwise the
+    structure's table for it (a missing table is the empty relation, matching
+    the first-order convention, except that a unary name the structure knows as
+    a sort denotes that sort -- see :func:`_extension_in`). A λ-abstraction
+    denotes its EXTENSION, computed
+    by evaluating the body at every tuple of individuals its binders range over.
+    Anything else is an ordinary term.
+    """
+    if isinstance(node, PredicateTerm):
+        if node.name in pred_binding:
+            return pred_binding[node.name]
+        arity = signatures.arity.get(node.name, 1)
+        return frozenset(_extension_in(structure, node.name, arity))
+    if isinstance(node, Lambda):
+        names: List[str] = []
+        body: Node = node
+        while isinstance(body, Lambda):
+            names.append(body.param.name)
+            body = body.body
+        body = _lambda_vars_as_variables(body)
+        extension = []
+        for values in product(structure.domain, repeat=len(names)):
+            local = dict(assignment)
+            local.update(zip(names, values))
+            if satisfies_to(body, structure, local, pred_binding, signatures):
+                extension.append(values)
+        return frozenset(extension)
+    return term_value(node, structure, assignment)
+
+
+def _lambda_vars_as_variables(node: Node) -> Node:
+    """Turn every LambdaVar in ``node`` back into an ordinary object Variable.
+
+    The parser resolves a λ binder's occurrences to LambdaVar, which the
+    first-order term evaluator has no reading for -- correctly, since a
+    λ-abstraction is not a term it can evaluate. Here the binder IS being
+    interpreted: its variables are about to range over the domain through the
+    assignment, which is exactly what an object variable does. Converting them
+    is sound including under nesting, because an inner λ's own binder is
+    re-bound by name on the way in, so the shadowing the LambdaVars encoded is
+    reproduced by the assignment.
+    """
+    if isinstance(node, LambdaVar):
+        return Variable(node.name)
+    return node.map_children(_lambda_vars_as_variables)
+
+
+def _atom_truth(atom: Atom, structure: Structure,
+                assignment: Mapping[str, Any], pred_binding: PredBinding,
+                signatures: Signatures) -> bool:
+    """Truth of an atom, consulting ``pred_binding`` and allowing property arguments.
+
+    An atom whose arguments are all ordinary terms and whose predicate is not
+    currently bound is delegated to the first-order
+    :func:`semantics.tarski._atom_value` verbatim — so nothing about first-order
+    satisfaction is re-implemented, and ``=`` / ``≠`` are never treated as
+    bindable.
+    """
+    higher_order = any(isinstance(a, (PredicateTerm, Lambda)) for a in atom.args)
+    if atom.predicate in pred_binding and atom.predicate not in ("=", "≠"):
+        values = tuple(argument_value(a, structure, assignment, pred_binding, signatures)
+                       for a in atom.args)
+        return values in pred_binding[atom.predicate]
+    if not higher_order:
+        return _atom_value(atom, structure, assignment)
+    values = tuple(argument_value(a, structure, assignment, pred_binding, signatures)
+                   for a in atom.args)
+    extension = _extension_in(structure, atom.predicate, len(atom.args))
+    return values in extension
+
+
+def _object_quantifier(qtype: str, var_name: str, universe: Iterable[Any],
+                       body: Node, structure: Structure,
+                       assignment: Mapping[str, Any], pred_binding: PredBinding,
+                       signatures: Signatures) -> bool:
+    """Evaluate an object-level ∀/∃, threading the predicate binding and signatures."""
+    if qtype in _FORALL:
+        return all(satisfies_to(body, structure, _extend(assignment, var_name, d),
+                                pred_binding, signatures) for d in universe)
+    if qtype in _EXISTS:
+        return any(satisfies_to(body, structure, _extend(assignment, var_name, d),
+                                pred_binding, signatures) for d in universe)
+    raise ValueError(f"Unknown quantifier type: {qtype!r}")
+
+
+def _predicate_quantifier(node: SecondOrderQuantifier, structure: Structure,
+                          assignment: Mapping[str, Any],
+                          pred_binding: PredBinding,
+                          signatures: Signatures) -> bool:
+    """Evaluate ∀P / ∃P by enumerating every interpretation of P's SIGNATURE.
+
+    The signature — not the arity — is what decides the range: an arity-1 ``P``
+    whose slot holds an individual ranges over the ``2 ** n`` subsets of the
+    domain (the second-order case), while an arity-1 ``P`` whose slot holds a
+    monadic property ranges over the ``2 ** (2 ** n)`` sets of such properties.
+    Both fall out of the same enumeration.
+    """
+    signature = signatures.slots.get(node.predicate)
+    if signature is None:
+        signature = tuple(INDIVIDUAL for _ in range(node.arity))
+    count = interpretation_count(signature, len(structure.domain))
+    if count > MAX_INTERPRETATIONS:
+        raise ValueError(
+            f"Predicate quantifier {node.type}{node.predicate} with signature "
+            f"{signature} over a {len(structure.domain)}-element domain would "
+            f"enumerate {count} interpretations, above MAX_INTERPRETATIONS = "
+            f"{MAX_INTERPRETATIONS}. Shrink the domain (or raise "
+            "thirdorder.MAX_INTERPRETATIONS).")
+    candidates = all_interpretations(signature, structure.domain)
+    if node.type in _FORALL:
+        return all(satisfies_to(node.formula, structure, assignment,
+                                _extend(pred_binding, node.predicate, candidate),
+                                signatures)
+                   for candidate in candidates)
+    if node.type in _EXISTS:
+        return any(satisfies_to(node.formula, structure, assignment,
+                                _extend(pred_binding, node.predicate, candidate),
+                                signatures)
+                   for candidate in candidates)
+    raise ValueError(f"Unknown predicate quantifier type: {node.type!r}")
+
+
+def holds_to(formula: Node, structure: Structure) -> bool:
+    """Convenience: ``satisfies_to(formula, structure)`` for a closed formula.
+
+    Reads as "structure satisfies the third-order sentence": the empty
+    assignment and empty predicate binding are what a formula with no free
+    object or predicate variables needs.
+    """
+    return satisfies_to(formula, structure)

unicode_logic_kit/semantics/tnorm.py

@@ -0,0 +1,85 @@
+"""Continuous t-norms for the fuzzy (BL / Hájek basic-logic) family.
+
+A *t-norm* ``T`` fixes the semantics of the **strong** fuzzy connectives over the
+real interval ``[0, 1]``:
+
+- strong conjunction ``⊗`` is ``T`` itself;
+- strong disjunction ``⊕`` is the dual *t-conorm* ``S(x, y) = 1 − T(1−x, 1−y)``;
+- implication ``→`` is the *residuum* ``R(x, y) = sup {z : T(x, z) ≤ y}``;
+- negation ``¬x`` is ``R(x, 0)``;
+- biconditional ``↔`` is ``min(R(x, y), R(y, x))``.
+
+The *weak* connectives ``∧`` / ``∨`` are always ``min`` / ``max`` (the lattice meet /
+join), independent of the t-norm, and so are the quantifiers ``∀`` (infimum) / ``∃``
+(supremum). Three continuous t-norms — whose ordinal sums generate every
+continuous t-norm (the Mostert–Shields theorem) — ship here:
+
+- **Łukasiewicz** ``T(x, y) = max(0, x + y − 1)`` (the default; involutive negation);
+- **Gödel** ``T(x, y) = min(x, y)`` (idempotent; a relative pseudo-complement negation);
+- **product** ``T(x, y) = x · y`` (strict; Goguen residuum ``y / x``).
+
+Public API: :class:`TNorm`, the instances :data:`LUKASIEWICZ`, :data:`GODEL`,
+:data:`PRODUCT`, the registry :data:`TNORMS`, and :func:`get_tnorm`.
+"""
+
+from dataclasses import dataclass
+from typing import Callable
+
+
+@dataclass(frozen=True)
+class TNorm:
+    """A t-norm and the strong connective operations it induces over ``[0, 1]``.
+
+    ``conj`` / ``disj`` / ``impl`` / ``neg`` are the strong ⊗ / ⊕ / → / ¬; ``equiv``
+    is derived as ``min(x→y, y→x)``. (The weak ∧/∨ are min/max regardless and live
+    in the evaluator, not here.)
+    """
+
+    name: str
+    conj: Callable[[float, float], float]
+    disj: Callable[[float, float], float]
+    impl: Callable[[float, float], float]
+    neg: Callable[[float], float]
+
+    def equiv(self, x: float, y: float) -> float:
+        """Residuated biconditional ``min(x → y, y → x)``."""
+        return min(self.impl(x, y), self.impl(y, x))
+
+
+LUKASIEWICZ = TNorm(
+    "lukasiewicz",
+    conj=lambda x, y: max(0.0, x + y - 1.0),
+    disj=lambda x, y: min(1.0, x + y),
+    impl=lambda x, y: min(1.0, 1.0 - x + y),
+    neg=lambda x: 1.0 - x,
+)
+
+GODEL = TNorm(
+    "godel",
+    conj=lambda x, y: min(x, y),
+    disj=lambda x, y: max(x, y),
+    impl=lambda x, y: 1.0 if x <= y else y,
+    neg=lambda x: 1.0 if x <= 0.0 else 0.0,
+)
+
+PRODUCT = TNorm(
+    "product",
+    conj=lambda x, y: x * y,
+    disj=lambda x, y: x + y - x * y,
+    impl=lambda x, y: 1.0 if x <= y else y / x,
+    neg=lambda x: 1.0 if x <= 0.0 else 0.0,
+)
+
+#: The three built-in t-norms by name (``"lukasiewicz"``, ``"godel"``,
+#: ``"product"``) — what :func:`get_tnorm` looks up and what the fuzzy
+#: evaluator accepts as a ``tnorm=`` argument.
+TNORMS = {t.name: t for t in (LUKASIEWICZ, GODEL, PRODUCT)}
+
+
+def get_tnorm(name: str) -> TNorm:
+    """Return the :class:`TNorm` for ``name`` (``"lukasiewicz"`` / ``"godel"`` / ``"product"``)."""
+    try:
+        return TNORMS[name]
+    except KeyError:
+        raise ValueError(
+            f"unknown t-norm {name!r}; use one of {sorted(TNORMS)}.") from None

unicode_logic_kit/semantics/truthtable.py

@@ -0,0 +1,201 @@
+"""Truth tables for propositional formulas — classical, Kleene K3, and Priest LP.
+
+A truth table enumerates every assignment of truth values to the formula's atoms and
+records the formula's value (and whether that value is *designated*) under each. The
+three logics share the strong-Kleene connective tables and differ only in the value
+set and the designated values:
+
+- **classical** — values ``{0, 1}``; designated ``{1}``.
+- **K3** (strong Kleene) — values ``{0, ½, 1}``; designated ``{1}``.
+- **LP** (Priest) — values ``{0, ½, 1}``; designated ``{½, 1}`` (paraconsistent).
+
+Restricted to ``{0, 1}`` the strong-Kleene tables coincide with the classical ones,
+so all three reuse :func:`unicode_logic_kit.semantics.manyvalued.kleene_value`.
+
+Each distinct atom (by surface form — ``P`` and ``P(a)`` are different columns) is a
+propositional variable, except the nullary atoms ``$true`` and ``$false`` (``⊤`` and
+``⊥``): those are the constants truth and falsity, they get no column, and their
+value is ``1`` and ``0`` in every row. Quantified formulas have no finite truth table
+and are rejected. A column is named by the text the atom prints as, so two different
+atoms that print alike (the numeral ``1`` and a constant named ``1``, a free variable
+``x`` and a constant named ``x``) would be one column: such a formula is refused by name,
+and so is a sorted constant (``alice:Human``), whose sort is a fact that a truth table
+has no way to state.
+
+Public API: :func:`truth_table`, :class:`TruthTable`, and the convenience predicates
+:func:`is_tautology`, :func:`is_contradiction`, :func:`is_satisfiable_tt`.
+"""
+
+import html
+from dataclasses import dataclass
+from itertools import product
+from typing import Dict, List, Tuple
+
+from ..fol.nodes import Node, Atom, Quantifier, SortedQuantifier
+from ..fol._atom_keys import AtomKeys, atom_key
+from ..fol._so_nodes import SecondOrderQuantifier
+from ..fol._truth_constants import truth_value as _truth_value
+from .manyvalued import _kleene_value, DESIGNATED
+
+
+# Value sets and designated sets per logic (classical added to the K3/LP table).
+_VALUES = {
+    "classical": (1.0, 0.0),
+    "K3": (1.0, 0.5, 0.0),
+    "LP": (1.0, 0.5, 0.0),
+}
+_DESIGNATED = {"classical": frozenset({1.0}), **DESIGNATED}
+
+# Display glyphs.
+_GLYPH_BOOL = {1.0: "T", 0.0: "F"}
+_GLYPH_MANY = {1.0: "1", 0.5: "½", 0.0: "0"}
+
+
+def _collect_atoms(formula: Node) -> List[str]:
+    """Return the distinct atom surface-forms in ``formula``, in first-occurrence order.
+
+    Raises ValueError on a quantified formula (no finite truth table exists).
+    """
+    if isinstance(formula, (Quantifier, SortedQuantifier, SecondOrderQuantifier)):
+        raise ValueError(
+            "truth_table: quantified formulas have no finite truth table; "
+            "use the finite model finder or an evaluator instead."
+        )
+    order: List[str] = []
+    seen = set()
+
+    def walk(node: Node) -> None:
+        if isinstance(node, (Quantifier, SortedQuantifier, SecondOrderQuantifier)):
+            raise ValueError(
+                "truth_table: quantified formulas have no finite truth table."
+            )
+        if isinstance(node, Atom):
+            if _truth_value(node) is not None:
+                return              # `$true` / `$false` are constants, not columns
+            key = atom_key(node)
+            if key not in seen:
+                seen.add(key)
+                order.append(key)
+            return
+        for child in node._child_nodes():
+            walk(child)
+
+    walk(formula)
+    return order
+
+
+@dataclass(frozen=True)
+class TruthTable:
+    """A computed truth table: atom columns, value rows, and the designated flags.
+
+    ``atoms`` are the column headers (atom surface-forms). ``rows`` is a tuple of
+    ``(assignment, value, designated)`` where ``assignment`` is the tuple of atom
+    values aligned with ``atoms``, ``value`` is the formula's value, and
+    ``designated`` says whether ``value`` is designated under ``logic``.
+    """
+
+    formula: Node
+    atoms: Tuple[str, ...]
+    rows: Tuple[Tuple[Tuple[float, ...], float, bool], ...]
+    logic: str
+
+    @property
+    def is_tautology(self) -> bool:
+        """True iff the formula is designated under every assignment."""
+        return all(d for _, _, d in self.rows)
+
+    @property
+    def is_contradiction(self) -> bool:
+        """True iff the formula is designated under no assignment."""
+        return not any(d for _, _, d in self.rows)
+
+    @property
+    def is_satisfiable(self) -> bool:
+        """True iff the formula is designated under some assignment."""
+        return any(d for _, _, d in self.rows)
+
+    def _rows_and_glyphs(self) -> Tuple[List[str], Dict[float, str]]:
+        """Column headers (atoms + the formula) and the value-to-glyph map for ``logic``.
+
+        Shared by :meth:`render` (Markdown) and :meth:`_repr_html_` (HTML) so the
+        two renderers walk ``self.rows`` with the same headers and the same glyphs
+        and can never quietly disagree.
+        """
+        glyph = _GLYPH_BOOL if self.logic == "classical" else _GLYPH_MANY
+        head = list(self.atoms) + [self.formula.to_unicode_str()]
+        return head, glyph
+
+    def render(self) -> str:
+        """Render the truth table as a GitHub-flavoured Markdown table."""
+        head, glyph = self._rows_and_glyphs()
+        lines = ["| " + " | ".join(head) + " |",
+                 "|" + "|".join(["---"] * len(head)) + "|"]
+        for assignment, value, _ in self.rows:
+            cells = [glyph[v] for v in assignment] + [glyph[value]]
+            lines.append("| " + " | ".join(cells) + " |")
+        return "\n".join(lines)
+
+    def __str__(self) -> str:
+        return self.render()
+
+    def _repr_html_(self) -> str:
+        """Jupyter/IPython rich-display hook: the truth table as an HTML ``<table>``.
+
+        Built directly from ``self.atoms``/``self.rows`` via :meth:`_rows_and_glyphs`
+        — NOT by round-tripping ``render()``'s Markdown through a Markdown-to-HTML
+        parser, since no such parser is a dependency of this kit (and none is added
+        for this). Column/atom labels come from user-chosen predicate and constant
+        names, so they are HTML-escaped; the glyphs themselves are always one of the
+        fixed strings in ``_GLYPH_BOOL``/``_GLYPH_MANY`` and need no escaping.
+        """
+        head, glyph = self._rows_and_glyphs()
+        header_cells = "".join(f"<th>{html.escape(h)}</th>" for h in head)
+        body_rows = []
+        for assignment, value, _ in self.rows:
+            cells = [glyph[v] for v in assignment] + [glyph[value]]
+            row_html = "".join(f"<td>{c}</td>" for c in cells)
+            body_rows.append(f"<tr>{row_html}</tr>")
+        return (f"<table><thead><tr>{header_cells}</tr></thead>"
+                f"<tbody>{''.join(body_rows)}</tbody></table>")
+
+
+def truth_table(formula: Node, logic: str = "classical") -> TruthTable:
+    """Compute the :class:`TruthTable` of a propositional ``formula`` under ``logic``.
+
+    Args:
+        formula: a quantifier-free formula; each distinct atom is a propositional
+            variable.
+        logic: ``"classical"`` (values {0,1}), ``"K3"`` or ``"LP"`` (values {0,½,1}).
+
+    Raises:
+        ValueError: on an unknown logic or a quantified formula.
+        NotImplementedError: a sorted constant, or two different atoms that print alike.
+    """
+    if logic not in _VALUES:
+        raise ValueError(f"truth_table: unknown logic {logic!r} "
+                         f"(use 'classical', 'K3', or 'LP').")
+    atoms = _collect_atoms(formula)
+    AtomKeys("truth_table", "refuse").letters([formula])
+    values = _VALUES[logic]
+    designated = _DESIGNATED[logic]
+    rows = []
+    for assignment in product(values, repeat=len(atoms)):
+        valuation: Dict[str, float] = dict(zip(atoms, assignment))
+        value = _kleene_value(formula, valuation, None, None)
+        rows.append((assignment, value, value in designated))
+    return TruthTable(formula, tuple(atoms), tuple(rows), logic)
+
+
+def is_tautology(formula: Node, logic: str = "classical") -> bool:
+    """True iff ``formula`` is designated under every assignment (a logical truth)."""
+    return truth_table(formula, logic).is_tautology
+
+
+def is_contradiction(formula: Node, logic: str = "classical") -> bool:
+    """True iff ``formula`` is designated under no assignment."""
+    return truth_table(formula, logic).is_contradiction
+
+
+def is_satisfiable_tt(formula: Node, logic: str = "classical") -> bool:
+    """True iff ``formula`` is designated under some assignment."""
+    return truth_table(formula, logic).is_satisfiable