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

unicode_logic_kit/fol/unification.py

@@ -0,0 +1,157 @@
+"""Robinson first-order term unification (with occurs-check).
+
+Computes a most-general unifier (MGU) of two terms, or of two atoms, over the
+classical term language: Variable, Constant, Number, Function (and Atom for the
+literal case). A substitution is a plain dict mapping a variable NAME (str) to a
+term Node. The algorithm is functional: inputs are never mutated, and the input
+substitution is copied before any binding is added.
+
+Unification rules:
+  - A Variable unifies with any term t, binding its name to t, provided the
+    occurs-check passes (the variable does not occur in t under the current
+    substitution).
+  - Constant and Number unify iff they are equal (same value).
+  - Function unify iff they share name and arity and their arguments unify
+    pairwise.
+  - Atom unify iff they share predicate and arity and their arguments unify
+    pairwise.
+"""
+
+from typing import Dict, Optional
+
+from .nodes import Variable, Constant, Number, Function, Atom, Node, Measure
+
+
+def apply_subst(node: Node, subst: Dict[str, Node]) -> Node:
+    """Apply substitution subst to node, returning a new node.
+
+    Recurses into Function/Atom arguments. A Variable is replaced by its bound
+    term when its name is a key of subst (the replacement is itself substituted
+    into, so chained bindings resolve fully); otherwise it is returned
+    unchanged. Constants and Numbers are returned unchanged. The input node is
+    never mutated.
+    """
+    if isinstance(node, Variable):
+        if node.name in subst:
+            return apply_subst(subst[node.name], subst)
+        return node
+    if isinstance(node, (Constant, Number)):
+        return node
+    if isinstance(node, Function):
+        return Function(node.name, [apply_subst(a, subst) for a in node.args])
+    if isinstance(node, Measure):
+        # μ(entity, dimension) is an ordinary binary term (lowered to the
+        # function measure/2 by the exports): substitute into both slots.
+        return Measure(apply_subst(node.entity, subst),
+                       apply_subst(node.dimension, subst))
+    if isinstance(node, Atom):
+        return Atom(node.predicate, [apply_subst(a, subst) for a in node.args])
+    raise TypeError(f"apply_subst: unsupported node type {type(node).__name__}")
+
+
+def _occurs(name: str, term: Node, subst: Dict[str, Node]) -> bool:
+    """Return True if the variable name occurs in term after applying subst.
+
+    Used by the occurs-check to reject bindings such as x ↦ f(x) that would
+    create an infinite (cyclic) term.
+    """
+    term = apply_subst(term, subst)
+    if isinstance(term, Variable):
+        return term.name == name
+    if isinstance(term, (Function, Atom)):
+        return any(_occurs(name, a, subst) for a in term.args)
+    if isinstance(term, Measure):
+        return (_occurs(name, term.entity, subst)
+                or _occurs(name, term.dimension, subst))
+    return False
+
+
+def _bind(name: str, term: Node, subst: Dict[str, Node]) -> Optional[Dict[str, Node]]:
+    """Extend subst with the binding name ↦ term, with occurs-check.
+
+    Returns a new substitution dict (the input is copied, never mutated), or
+    None if the occurs-check fails. Binding a variable to itself is a no-op that
+    leaves the substitution unchanged.
+    """
+    if isinstance(term, Variable) and term.name == name:
+        return subst
+    if _occurs(name, term, subst):
+        return None
+    new_subst = dict(subst)
+    new_subst[name] = apply_subst(term, subst)
+    return new_subst
+
+
+def unify(t1: Node, t2: Node, subst: Optional[Dict[str, Node]] = None) -> Optional[Dict[str, Node]]:
+    """Most-general unifier of t1 and t2, or None if they do not unify.
+
+    Robinson's algorithm with occurs-check. The result is a dict mapping
+    variable NAME -> term such that applying it to t1 and t2 (via apply_subst)
+    yields structurally equal nodes. An empty dict means the terms are already
+    equal / trivially unifiable.
+
+    Accepts Variable, Constant, Number, Function term nodes, or two Atoms (which
+    unify iff they share predicate and arity and their arguments unify
+    pairwise). The optional subst argument is treated as immutable: it is copied
+    before extension, never modified in place.
+    """
+    if subst is None:
+        subst = {}
+
+    t1 = apply_subst(t1, subst)
+    t2 = apply_subst(t2, subst)
+
+    # Variable on either side: bind it (occurs-check inside _bind).
+    if isinstance(t1, Variable):
+        return _bind(t1.name, t2, subst)
+    if isinstance(t2, Variable):
+        return _bind(t2.name, t1, subst)
+
+    # Constants / Numbers: unify iff equal in value.
+    if isinstance(t1, (Constant, Number)) or isinstance(t2, (Constant, Number)):
+        if type(t1) is type(t2) and _leaf_value(t1) == _leaf_value(t2):
+            return subst
+        return None
+
+    # Function applications: same name + arity, then unify arguments pairwise.
+    if isinstance(t1, Function) and isinstance(t2, Function):
+        if t1.name != t2.name or len(t1.args) != len(t2.args):
+            return None
+        return _unify_args(t1.args, t2.args, subst)
+
+    # Measure terms: a fixed binary function symbol — unify slot-wise. Purely
+    # syntactic: a Measure never unifies with a Function (even one literally
+    # named "measure"); the measure/2 spelling is an EXPORT convention, not an
+    # AST identity.
+    if isinstance(t1, Measure) and isinstance(t2, Measure):
+        return _unify_args((t1.entity, t1.dimension),
+                           (t2.entity, t2.dimension), subst)
+
+    # Atoms (literal-level unification): same predicate + arity, then args.
+    if isinstance(t1, Atom) and isinstance(t2, Atom):
+        if t1.predicate != t2.predicate or len(t1.args) != len(t2.args):
+            return None
+        return _unify_args(t1.args, t2.args, subst)
+
+    return None
+
+
+def _leaf_value(node: Node):
+    """Return the comparable payload of a leaf node (Constant name / Number value)."""
+    if isinstance(node, Constant):
+        return node.name
+    if isinstance(node, Number):
+        return node.value
+    return None
+
+
+def _unify_args(args1, args2, subst: Dict[str, Node]) -> Optional[Dict[str, Node]]:
+    """Unify two equal-length argument lists left-to-right, threading the substitution.
+
+    Returns the accumulated substitution, or None as soon as any pair fails.
+    """
+    for a, b in zip(args1, args2):
+        subst = unify(a, b, subst)
+        if subst is None:
+            return None
+    return subst

unicode_logic_kit/fol/verbalize.py

@@ -0,0 +1,263 @@
+"""Verbalize a formula as an English sentence (a readability aid, not a parse inverse).
+
+``to_english(node)`` renders a formula with structural English templates: ``∀x φ`` →
+"for every x, …", ``A → B`` → "if A, then B", a unary atom ``Human(x)`` → "x is
+human", an equality → "a is equal to b", and so on. It is deliberately predictable
+rather than fluent, and — unlike ``to_unicode_str``/``parse`` — it is **not** an exact
+round-trip: the English phrasing of nested connectives can be ambiguous. Use it to
+explain a formula, not to re-parse one.
+
+The two truth constants (the nullary atoms ``$true`` / ``⊤`` and ``$false`` / ``⊥``) are
+not propositional letters and are not printed as one: ``⊤`` is read "truth" and ``⊥``
+"falsity", so ``P → ⊥`` is "if P, then falsity" and ``¬⊥`` is "it is not the case that
+falsity". A nullary atom of any other name is read as its name.
+
+Public API: :func:`to_english`.
+"""
+
+from ..fol.nodes import (
+    Node, Atom, Not, And, Or, Xor, Implies, Iff, Quantifier,
+    Variable, Constant, Number, Function,
+    SortedQuantifier, SortedConstant,
+    Count, Measure, Cardinality, Contrast,
+    SortedCount, SortedCardinality,
+    Nominal, At,
+    Dependence, SlashedExists,
+    Tensor, With, OPlus, LinearImplies, OfCourse, One,
+    Product, Under, Over,
+    Box, Diamond, Knows, Believes, Says, Wants, Obligatory, Permitted,
+    Always, Eventually, Next, Until,
+    Historically, Once, Previous, Since,
+    Would, Might,
+    WeakConjunction, WeakDisjunction, StrongConjunction, StrongDisjunction,
+    LukNegation, LukImplication, LukEquivalence,
+)
+from ._so_nodes import SecondOrderQuantifier
+from ._modal_nodes import Announce, AnnounceDiamond
+from ._truth_constants import truth_value
+
+
+# Counting-quantifier op codes → English determiner phrases.
+_COUNT_WORDS = {"ge": "at least", "le": "at most", "eq": "exactly"}
+
+
+# Comparison / equality predicates rendered with an English copula.
+_COPULA = {
+    "=": ("is equal to", "is not equal to"),
+    "≠": ("is not equal to", "is equal to"),
+    "<": ("is less than", "is not less than"),
+    ">": ("is greater than", "is not greater than"),
+    "≤": ("is at most", "is greater than"),
+    "≥": ("is at least", "is less than"),
+}
+
+
+def _term(node: Node) -> str:
+    """Render a term in a readable form."""
+    if isinstance(node, (Variable, Constant, SortedConstant)):
+        return node.name
+    if isinstance(node, Number):
+        return str(node.value)
+    if isinstance(node, Function):
+        return f"{node.name}({', '.join(_term(a) for a in node.args)})"
+    if isinstance(node, Measure):
+        return f"the {_term(node.dimension)} of {_term(node.entity)}"
+    if isinstance(node, Cardinality):
+        return f"the number of {node.variable.name} such that {to_english(node.formula)}"
+    if isinstance(node, SortedCardinality):
+        return (f"the number of {node.variable.name} of sort {node.sort} such that "
+                f"{to_english(node.formula)}")
+    return node.to_unicode_str()
+
+
+def _atom(node: Atom, negated: bool = False) -> str:
+    """Render an atom (optionally negated) in English."""
+    pred, args = node.predicate, node.args
+    if pred in _COPULA and len(args) == 2:
+        phrase = _COPULA[pred][1 if negated else 0]
+        return f"{_term(args[0])} {phrase} {_term(args[1])}"
+    if len(args) == 0:
+        constant = truth_value(node)
+        if constant is None:
+            body = pred
+        else:
+            body = "truth" if constant else "falsity"       # the truth constants, not letters
+        return f"it is not the case that {body}" if negated else body
+    if len(args) == 1:
+        # "x is human" / "x is not human"
+        prop = pred.lower()
+        return f"{_term(args[0])} is {'not ' if negated else ''}{prop}"
+    call = f"{pred}({', '.join(_term(a) for a in args)})"
+    return f"it is not the case that {call}" if negated else call
+
+
+def _needs_clause(node: Node) -> bool:
+    """True if a sub-formula should be wrapped as a parenthetical clause for clarity."""
+    return isinstance(node, (And, Or, Xor, Implies, Iff))
+
+
+def _sub(node: Node) -> str:
+    """Render a sub-formula, parenthesising a nested binary connective."""
+    text = to_english(node)
+    return f"({text})" if _needs_clause(node) else text
+
+
+def to_english(node: Node) -> str:
+    """Return an English paraphrase of ``node`` (best-effort, not a parse inverse)."""
+    if isinstance(node, Atom):
+        return _atom(node)
+
+    if isinstance(node, Not):
+        inner = node.formula
+        if isinstance(inner, Atom):
+            return _atom(inner, negated=True)
+        return f"it is not the case that {_sub(inner)}"
+
+    if isinstance(node, And):
+        return f"{_sub(node.left)} and {_sub(node.right)}"
+
+    if isinstance(node, Or):
+        return f"{_sub(node.left)} or {_sub(node.right)}"
+
+    if isinstance(node, Xor):
+        return f"either {_sub(node.left)} or {_sub(node.right)}, but not both"
+
+    if isinstance(node, Contrast):
+        return f"{_sub(node.left)}, whereas {_sub(node.right)}"
+
+    if isinstance(node, Implies):
+        return f"if {_sub(node.left)}, then {_sub(node.right)}"
+
+    if isinstance(node, Iff):
+        return f"{_sub(node.left)} if and only if {_sub(node.right)}"
+
+    if isinstance(node, SortedQuantifier):
+        kind = "every" if node.type in ("∀", "forall") else "some"
+        return f"for {kind} {node.variable.name} of sort {node.sort}, {to_english(node.formula)}"
+
+    if isinstance(node, Quantifier):
+        if node.type in ("∀", "forall"):
+            return f"for every {node.variable.name}, {to_english(node.formula)}"
+        return f"for some {node.variable.name}, {to_english(node.formula)}"
+
+    if isinstance(node, Count):
+        return (f"there are {_COUNT_WORDS[node.op]} {node.n.value} {node.variable.name} "
+                f"such that {to_english(node.formula)}")
+
+    if isinstance(node, SortedCount):
+        return (f"there are {_COUNT_WORDS[node.op]} {node.n.value} {node.variable.name} "
+                f"of sort {node.sort} such that {to_english(node.formula)}")
+
+    if isinstance(node, SecondOrderQuantifier):
+        kind = "every" if node.type in ("∀", "forall") else "some"
+        return f"for {kind} {node.arity}-ary predicate {node.predicate}, {to_english(node.formula)}"
+
+    # --- modal / temporal / epistemic / doxastic / deontic ---
+    if isinstance(node, Box):
+        return f"necessarily, {_sub(node.formula)}"
+    if isinstance(node, Diamond):
+        return f"possibly, {_sub(node.formula)}"
+    if isinstance(node, Knows):
+        return f"agent {_term(node.agent)} knows that {_sub(node.formula)}"
+    if isinstance(node, Believes):
+        return f"agent {_term(node.agent)} believes that {_sub(node.formula)}"
+    if isinstance(node, Says):
+        return f"agent {_term(node.agent)} says that {_sub(node.formula)}"
+    if isinstance(node, Wants):
+        return f"agent {_term(node.agent)} wants it to be that {_sub(node.formula)}"
+    if isinstance(node, Obligatory):
+        return f"it is obligatory that {_sub(node.formula)}"
+    if isinstance(node, Permitted):
+        return f"it is permitted that {_sub(node.formula)}"
+    if isinstance(node, Always):
+        return f"it will always be the case that {_sub(node.formula)}"
+    if isinstance(node, Eventually):
+        return f"it will eventually be the case that {_sub(node.formula)}"
+    if isinstance(node, Next):
+        return f"at the next moment, {_sub(node.formula)}"
+    if isinstance(node, Until):
+        return f"{_sub(node.left)} until {_sub(node.right)}"
+    if isinstance(node, Historically):
+        return f"it has always been the case that {_sub(node.formula)}"
+    if isinstance(node, Once):
+        return f"it was once the case that {_sub(node.formula)}"
+    if isinstance(node, Previous):
+        return f"at the previous moment, {_sub(node.formula)}"
+    if isinstance(node, Since):
+        return f"{_sub(node.left)} since {_sub(node.right)}"
+
+    # --- public announcement logic (PAL) ---
+    if isinstance(node, Announce):
+        return (f"after it is truthfully announced that {to_english(node.announcement)}, "
+                f"{_sub(node.formula)}")
+    if isinstance(node, AnnounceDiamond):
+        return (f"{to_english(node.announcement)}, and after it is truthfully "
+                f"announced, {_sub(node.formula)}")
+
+    # --- counterfactual conditionals (subjunctive, not material) ---
+    if isinstance(node, Would):
+        return f"if {_sub(node.left)} were the case, {_sub(node.right)} would be"
+    if isinstance(node, Might):
+        return f"if {_sub(node.left)} were the case, {_sub(node.right)} might be"
+
+    # --- hybrid (nominals and @) ---
+    if isinstance(node, Nominal):
+        return f"this is world {node.name}"
+    if isinstance(node, At):
+        return f"at world {node.nominal.name}, {_sub(node.formula)}"
+
+    # --- dependence / IF (team semantics) ---
+    if isinstance(node, Dependence):
+        if len(node.args) == 1:
+            return f"the value of {_term(node.args[0])} is constant"
+        deps = ", ".join(_term(a) for a in node.args[:-1])
+        return (f"the value of {_term(node.args[-1])} is functionally "
+                f"determined by {deps}")
+    if isinstance(node, SlashedExists):
+        indep = ", ".join(node.slashed)
+        return (f"for some {node.variable.name} chosen independently of "
+                f"{indep}, {to_english(node.formula)}")
+
+    # --- linear logic (resource reading) ---
+    if isinstance(node, Tensor):
+        return f"{_sub(node.left)} together with {_sub(node.right)}"
+    if isinstance(node, With):
+        return f"a free choice between {_sub(node.left)} and {_sub(node.right)}"
+    if isinstance(node, OPlus):
+        return f"{_sub(node.left)} or else {_sub(node.right)}"
+    if isinstance(node, LinearImplies):
+        return f"consuming {_sub(node.left)} yields {_sub(node.right)}"
+    if isinstance(node, OfCourse):
+        return f"an unlimited supply of {_sub(node.formula)}"
+    if isinstance(node, One):
+        return "the empty resource"
+
+    # --- Lambek calculus (categorial reading) ---
+    if isinstance(node, Product):
+        return f"{_sub(node.left)} followed by {_sub(node.right)}"
+    if isinstance(node, Under):
+        return (f"something that combines with {_sub(node.left)} on its left "
+                f"to give {_sub(node.right)}")
+    if isinstance(node, Over):
+        return (f"something that combines with {_sub(node.right)} on its right "
+                f"to give {_sub(node.left)}")
+
+    # --- fuzzy (Łukasiewicz): name the strong/weak/Łukasiewicz operators so they do
+    # NOT read as their classical look-alikes ---
+    if isinstance(node, LukNegation):
+        return f"it is fuzzily not the case that {_sub(node.formula)}"
+    if isinstance(node, WeakConjunction):
+        return f"{_sub(node.left)} and weakly {_sub(node.right)}"
+    if isinstance(node, WeakDisjunction):
+        return f"{_sub(node.left)} or weakly {_sub(node.right)}"
+    if isinstance(node, StrongConjunction):
+        return f"{_sub(node.left)} and strongly {_sub(node.right)}"
+    if isinstance(node, StrongDisjunction):
+        return f"{_sub(node.left)} or strongly {_sub(node.right)}"
+    if isinstance(node, LukImplication):
+        return f"if {_sub(node.left)} then fuzzily {_sub(node.right)}"
+    if isinstance(node, LukEquivalence):
+        return f"{_sub(node.left)} is fuzzily equivalent to {_sub(node.right)}"
+
+    # Anything else (e.g. lambda) falls back to its glyph form.
+    return node.to_unicode_str()

unicode_logic_kit/hets/__init__.py

@@ -0,0 +1,163 @@
+r"""REST binding to a Dockerized HETS (Heterogeneous Tool Set) server.
+
+`HETS <https://github.com/spechub/Hets>`_ is the reference heterogeneous
+proof-management system for CASL and its extensions (and, via comorphisms,
+many other logics): a development-graph manager over a network of theories
+that dispatches proof obligations to external provers (SPASS, darwin,
+Vampire, E, ...) through translations/comorphisms it selects. This subpackage
+does not reimplement any of that — it is a thin client that lets the rest of
+the kit drive a real HETS instance and read back its verdicts.
+
+Architecture: process/network separation, not in-process linking
+--------------------------------------------------------------------
+HETS is GPL-licensed Haskell with a build realistically only reproducible via
+its official Docker image. Two integration routes exist:
+
+* **In-process bindings** — the ``hets``/``spechub`` Python API some
+  installs expose links this process directly against the GPL Haskell
+  library via its GHC-built shared objects, and is only buildable on Linux
+  with a working GHC toolchain. That is wrong for this kit on two independent
+  axes: it would pull a GPL dependency into an MIT-licensed process, and it
+  is not available on this kit's primary development platform (Windows) at
+  all. Documented here as the alternative that was considered and rejected,
+  not silently omitted.
+* **REST against Docker** — the route this subpackage takes.
+  :mod:`~unicode_logic_kit.hets.docker` starts (or discovers) a
+  ``spechub2/hets:latest`` container running HETS's own bundled HTTP server;
+  :mod:`~unicode_logic_kit.hets.client` speaks plain HTTP/JSON to it via
+  stdlib ``urllib`` (no ``requests`` dependency, matching this kit's other
+  external-tool adapters). This process and the HETS process share nothing
+  but a TCP socket — no linking, no shared address space, no GPL code ever
+  imported into this Python process. The boundary is enforced structurally,
+  not by a license header: :class:`~unicode_logic_kit.hets.client.HetsClient`
+  cannot reach HETS internals any way other than the documented REST API.
+
+This mirrors the kit-wide convention for external provers that are
+subprocess-spawned rather than linked (``atp.prover9_entailment``,
+``atp.vampire_entailment``, ``hol.isabelle_runner``) — HETS just uses a
+network boundary instead of a process boundary, because that is how its
+official distribution ships (a server, not a CLI batch tool).
+
+Modules
+-------
+* :mod:`~unicode_logic_kit.hets.docker` — :class:`~unicode_logic_kit.hets.docker.HetsContainer`
+  (start/stop/health-poll one container) and
+  :func:`~unicode_logic_kit.hets.docker.discover_hets_url` (the precedence
+  ``$UFK_HETS_URL`` -> localhost -> optionally auto-start, never a silent
+  guess — raises :class:`~unicode_logic_kit.atp.protocol.BackendUnavailable`
+  with an actionable message otherwise). Also documents which reasoners in
+  the shipped image actually work.
+* :mod:`~unicode_logic_kit.hets.client` — :class:`~unicode_logic_kit.hets.client.HetsClient`,
+  the REST binding itself (upload, development-graph inspection, prover /
+  translation listing, theory rendering/translation, prove,
+  consistency-check).
+* :mod:`~unicode_logic_kit.hets.bridge` — the server's CASL comorphisms as
+  dynamic ``hets:<Name>`` edges in the kit's translation registry
+  (:func:`~unicode_logic_kit.hets.bridge.register_hets_comorphisms`).
+* :mod:`~unicode_logic_kit.hets.dol` — DOL library EMISSION
+  (:func:`~unicode_logic_kit.hets.dol.to_dol_library`): multiple named CASL
+  specs, ``then``-extension structure and ``%implied`` goals in one
+  ``library`` document a HETS server turns into a multi-node development
+  graph (no DOL *parsing* — same emission-only cut as the rest of the
+  CASL route; the importer for single basic specs is
+  :func:`unicode_logic_kit.fol.casl_import.parse_casl_spec`).
+* :mod:`~unicode_logic_kit.hets.owl_backend` — a second, independent external
+  OWL 2 DL reasoner (FaCT++ via the server's ``Fact`` prover identifier),
+  over the ALCHQ + I + O fragment; mirrors
+  :mod:`~unicode_logic_kit.dl.owl_reasoner`'s function-per-namesake shape,
+  opt-in and never in a default chain.
+* :mod:`~unicode_logic_kit.hets.haskell_json` —
+  :func:`~unicode_logic_kit.hets.haskell_json.repair_haskell_json`, which
+  recovers the Haskell ``show`` escapes HETS 0.108.0 leaks into its JSON
+  (``"Verdi\226\128\153s Requiem"`` for ``"Verdi’s Requiem"``). Without it
+  ``GET /dg`` is unreadable for any library with one non-ASCII annotation,
+  and with it the real 8.3 MB OEO graph loads. Applied by
+  :meth:`~unicode_logic_kit.hets.client.HetsClient.dg` only on the failure
+  path, so a body ``json`` already accepts is never touched.
+* :mod:`~unicode_logic_kit.hets.symbols` — the join between HETS' mangled TPTP
+  symbols and the OWL entities they came from
+  (:func:`~unicode_logic_kit.hets.symbols.hets_symbol_table`), plus the axioms
+  a translation silently dropped
+  (:func:`~unicode_logic_kit.hets.symbols.untranslated_axioms`). Pure
+  functions over a ``/dg`` dict and a TPTP string: no network, no Docker.
+* :mod:`~unicode_logic_kit.hets.owl_cli` —
+  :func:`~unicode_logic_kit.hets.owl_cli.owl_to_tptp`, the COMMAND-LINE route
+  (``docker exec`` into a running container). It exists for exactly one
+  reason: ``hets-server``'s lossy ``-Y`` switch, which translates an
+  ontology whose sublogic a comorphism does not cover and which has no REST
+  equivalent. It runs the non-lossy translation first so the loss is always
+  reported, never silent.
+
+The TPTP a HETS ``GET /theory`` returns is NOT a TPTP problem — HETS
+prefixes it with a DOL ``logic TPTP.FOF`` line and a CASL ``%{ ... }%``
+signature block. :func:`~unicode_logic_kit.hets.client.strip_hets_theory_header`
+splits the two (and
+:meth:`~unicode_logic_kit.hets.client.HetsClient.theory_tptp` does it for you);
+:func:`unicode_logic_kit.fol.tptp_input.parse_tptp` refuses the unstripped text
+BY NAME and points here, rather than learning a comment syntax that is not
+TPTP's.
+
+Kit formulas reach HETS through the Verdict layer:
+:class:`unicode_logic_kit.atp.hets_backend.HetsBackend` (registry name
+``"hets"``, never in a default chain) exports FOL/MSFOL problems to CASL
+via :mod:`unicode_logic_kit.fol.casl_export` and maps the per-goal results
+back onto the kit's :class:`~unicode_logic_kit.atp.protocol.Verdict`.
+"""
+
+from .bridge import HETS_EDGE_PREFIX, register_hets_comorphisms
+from .client import (
+    HetsClient,
+    HetsNoTranslationsError,
+    HetsSublogicError,
+    strip_hets_theory_header,
+)
+from .docker import HETS_IMAGE, HetsContainer, discover_hets_url, hets_available
+from .haskell_json import (
+    HaskellJsonRepair,
+    HaskellJsonRepairError,
+    repair_haskell_json,
+)
+from .owl_cli import (
+    HetsOwlNormalizationError,
+    OwlTptpResult,
+    SublogicMismatch,
+    owl_to_tptp,
+)
+from .symbols import (
+    HetsSymbol,
+    HetsSymbolCollisionError,
+    HetsSymbolTable,
+    UntranslatedAxiom,
+    hets_prefixes,
+    hets_symbol_table,
+    untranslated_axioms,
+)
+from .dol import DolSpec, to_dol_library, to_dol_library_from_modal, sanitize_modal_identifiers
+from .owl_backend import (
+    hets_owl_available,
+    external_concept_satisfiable, external_concept_unsatisfiable,
+    external_subsumes, external_equivalent,
+    external_abox_consistent, external_instance_check, external_instance_retrieval,
+    external_realize, external_realize_all,
+    HetsOwlError,
+)
+
+__all__ = [
+    "HetsClient",
+    "HetsNoTranslationsError", "HetsSublogicError", "strip_hets_theory_header",
+    "HaskellJsonRepair", "HaskellJsonRepairError", "repair_haskell_json",
+    "owl_to_tptp", "OwlTptpResult", "SublogicMismatch",
+    "HetsOwlNormalizationError",
+    "hets_symbol_table", "HetsSymbolTable", "HetsSymbol",
+    "HetsSymbolCollisionError",
+    "untranslated_axioms", "UntranslatedAxiom", "hets_prefixes",
+    "HETS_IMAGE", "HetsContainer", "discover_hets_url", "hets_available",
+    "HETS_EDGE_PREFIX", "register_hets_comorphisms",
+    "DolSpec", "to_dol_library", "to_dol_library_from_modal", "sanitize_modal_identifiers",
+    "hets_owl_available",
+    "external_concept_satisfiable", "external_concept_unsatisfiable",
+    "external_subsumes", "external_equivalent",
+    "external_abox_consistent", "external_instance_check", "external_instance_retrieval",
+    "external_realize", "external_realize_all",
+    "HetsOwlError",
+]