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

unicode_logic_kit/atp/__init__.py

@@ -0,0 +1,177 @@
+from .z3_equivalence import formulas_are_equivalent
+from .prover9_entailment import check_logical_entailment
+from .vampire_entailment import check_logical_entailment_vampire
+from .z3_models import is_satisfiable, is_valid, get_model
+from .z3_fuzzy import (
+    fuzzy_is_satisfiable, fuzzy_is_valid, fuzzy_get_model, degree_expr,
+)
+from .z3_arith import (
+    to_z3_arith, is_satisfiable_arith, is_valid_arith, get_model_arith, ArithEnv,
+)
+from .resolution import to_clauses, refute, prove, is_valid_resolution
+from .resolution_check import (
+    ResolutionStep, ResolutionDerivation, ResolutionCheckResult,
+    check_resolution_proof, verify_resolution_proof, render_resolution_proof,
+)
+from .fitch import (
+    Proof, Line, Subproof, Justification, ProofResult,
+    premise, assume, line, flag, FALSUM,
+    check_proof, verify_proof,
+    render_fitch, render_latex_fitch,
+)
+from .sequent import (
+    Sequent, Derivation, Comprehension, SequentResult,
+    sequent, derive, axiom,
+    check_sequent_proof, verify_sequent_proof, render_sequent_proof,
+)
+from .z3_input import from_z3, parse_smtlib, load_smtlib, to_smtlib
+from .fitch_search import find_fitch_proof, fitch_prove, is_valid_fitch
+from .tableau import (
+    tableau_closed, is_valid_tableau, prove_tableau, tableau_model,
+    prove_tableau_detailed, TableauProof, TableauStep, TableauClosure,
+)
+from .tableau_check import (
+    TableauCheckError, check_tableau_proof, check_entailment_tableau_detailed,
+)
+from .modal_tableau import (
+    modal_tableau_closed, is_modal_valid, modal_prove, modal_decide, modal_countermodel,
+)
+from .lj import check_lj_proof, verify_lj_proof, int_prove, int_decide
+from .linear import (
+    ill_prove, ill_derivable, check_ill_proof, verify_ill_proof,
+    render_ill_proof, ILLSequent, ILLDerivation,
+)
+from .lambek import (
+    lambek_prove, lambek_derivable, check_lambek_proof, verify_lambek_proof,
+    render_lambek_proof, LambekSequent, LambekDerivation,
+)
+from .protocol import (
+    Verdict, BackendUnavailable, ProverBackend,
+    register_backend, get_backend, available_backends, default_chain,
+    run_backend,
+    z3_relevant_premises,
+)
+from .vampire_entailment import check_entailment_vampire_detailed
+from .tstp import (
+    extract_szs_status, szs_to_verdict_fields,
+    TstpStep, TstpDerivation, parse_tstp_derivation,
+    relevant_premises_from_tstp,
+    to_tstp,
+)
+from .tstp_check import (
+    TstpStepResult, TstpCheckResult, check_tstp_derivation,
+    VAMPIRE_CLAUSIFICATION_RULES, VAMPIRE_CHECKED_RULES,
+    EPROVER_CLAUSIFICATION_RULES, EPROVER_CHECKED_RULES,
+)
+from .portfolio import portfolio_prove
+from .cvc5_backend import Cvc5Backend
+from .incremental import IncrementalSession
+from .eprover_backend import (
+    EProverBackend, ZipperpositionBackend,
+    check_entailment_eprover_detailed,
+    eprover_available, zipperposition_available,
+    eprover_relevant_premises,
+)
+from .hets_backend import HetsBackend
+from .nanocop_backend import NanocopBackend, to_nanocop, nanocop_available
+from .twee_backend import TweeBackend
+from .twee_entailment import twee_available, check_entailment_twee_detailed
+from .twee_check import check_twee_proof, TweeCheckResult
+from .kripke_enum import (
+    EnumSearchResult, modal_enum_search, modal_enum_countermodel,
+    kripke_model_to_dict, kripke_model_from_dict, KripkeEnumBackend,
+)
+from .hybrid_down import down_decide
+from .tptp_ncl import to_tptp_ncl
+from .leo3_backend import Leo3Backend
+from .finite_domain import (
+    lower_msfol, FiniteDomainProblem, fragment_check, structure_from_solution, verify_model,
+)
+from .clingo_backend import ClingoBackend, clingo_available, to_asp
+from .minizinc_backend import MinizincBackend, minizinc_available, to_minizinc
+from .tptp_tff import generate_tff_problem, generate_tff_problem_with_mapping
+from ._tff_problem import generate_tff_arith_problem
+from ._tptp_problem import (
+    generate_tptp_problem, generate_tptp_problem_with_mapping,
+    TptpNameMap, apply_reverse_tptp,
+)
+from .ltl_tableau import (
+    LTLTrace, ltl_tableau_closed, ltl_valid, ltl_decide, ltl_countermodel,
+    ltl_trace_satisfies, LtlTableauBackend,
+)
+from .logic_backends import (
+    IntBackend, LambekBackend, IllBackend, RelevantBackend, HybridBackend,
+)
+
+__all__ = [
+    "formulas_are_equivalent",
+    "check_logical_entailment",
+    "check_logical_entailment_vampire",
+    "is_satisfiable", "is_valid", "get_model",
+    "fuzzy_is_satisfiable", "fuzzy_is_valid", "fuzzy_get_model", "degree_expr",
+    "to_z3_arith", "is_satisfiable_arith", "is_valid_arith", "get_model_arith", "ArithEnv",
+    "to_clauses", "refute", "prove", "is_valid_resolution",
+    "ResolutionStep", "ResolutionDerivation", "ResolutionCheckResult",
+    "check_resolution_proof", "verify_resolution_proof", "render_resolution_proof",
+    "Proof", "Line", "Subproof", "Justification", "ProofResult",
+    "premise", "assume", "line", "flag", "FALSUM",
+    "check_proof", "verify_proof",
+    "render_fitch", "render_latex_fitch",
+    "Sequent", "Derivation", "Comprehension", "SequentResult",
+    "sequent", "derive", "axiom",
+    "check_sequent_proof", "verify_sequent_proof", "render_sequent_proof",
+    "from_z3", "parse_smtlib", "load_smtlib", "to_smtlib",
+    "find_fitch_proof", "fitch_prove", "is_valid_fitch",
+    "tableau_closed", "is_valid_tableau", "prove_tableau", "tableau_model",
+    "prove_tableau_detailed", "TableauProof", "TableauStep", "TableauClosure",
+    "TableauCheckError", "check_tableau_proof",
+    "check_entailment_tableau_detailed",
+    "modal_tableau_closed", "is_modal_valid", "modal_prove", "modal_decide",
+    "modal_countermodel",
+    "check_lj_proof", "verify_lj_proof", "int_prove", "int_decide",
+    "ill_prove", "ill_derivable", "check_ill_proof", "verify_ill_proof",
+    "render_ill_proof", "ILLSequent", "ILLDerivation",
+    "lambek_prove", "lambek_derivable", "check_lambek_proof",
+    "verify_lambek_proof", "render_lambek_proof", "LambekSequent",
+    "LambekDerivation",
+    "Verdict", "BackendUnavailable", "ProverBackend",
+    "register_backend", "get_backend", "available_backends", "default_chain",
+    "run_backend",
+    "z3_relevant_premises",
+    "check_entailment_vampire_detailed",
+    "extract_szs_status", "szs_to_verdict_fields",
+    "TstpStep", "TstpDerivation", "parse_tstp_derivation",
+    "relevant_premises_from_tstp",
+    "to_tstp",
+    "TstpStepResult", "TstpCheckResult", "check_tstp_derivation",
+    "VAMPIRE_CLAUSIFICATION_RULES", "VAMPIRE_CHECKED_RULES",
+    "EPROVER_CLAUSIFICATION_RULES", "EPROVER_CHECKED_RULES",
+    "portfolio_prove",
+    "Cvc5Backend",
+    "IncrementalSession",
+    "EProverBackend", "ZipperpositionBackend",
+    "check_entailment_eprover_detailed",
+    "eprover_available", "zipperposition_available",
+    "eprover_relevant_premises",
+    "HetsBackend",
+    "NanocopBackend", "to_nanocop", "nanocop_available",
+    "TweeBackend", "twee_available", "check_entailment_twee_detailed",
+    "check_twee_proof", "TweeCheckResult",
+    "EnumSearchResult", "modal_enum_search", "modal_enum_countermodel",
+    "kripke_model_to_dict", "kripke_model_from_dict", "KripkeEnumBackend",
+    "down_decide",
+    "to_tptp_ncl",
+    "Leo3Backend",
+    "lower_msfol",
+    "FiniteDomainProblem", "fragment_check", "structure_from_solution", "verify_model",
+    "ClingoBackend", "clingo_available", "to_asp",
+    "MinizincBackend", "minizinc_available", "to_minizinc",
+    "generate_tff_problem", "generate_tff_problem_with_mapping",
+    "generate_tff_arith_problem",
+    "generate_tptp_problem", "generate_tptp_problem_with_mapping",
+    "TptpNameMap", "apply_reverse_tptp",
+    "LTLTrace", "ltl_tableau_closed", "ltl_valid", "ltl_decide",
+    "ltl_countermodel", "ltl_trace_satisfies", "LtlTableauBackend",
+    "IntBackend", "LambekBackend", "IllBackend", "RelevantBackend",
+    "HybridBackend",
+]

unicode_logic_kit/atp/_ascii_names.py

@@ -0,0 +1,113 @@
+"""Shared ASCII-identifier sanitisation for the ASCII-only export surfaces:
+TPTP (:mod:`atp._tptp_problem`), Prover9 (:mod:`atp.prover9_entailment`), and
+SMT-LIB2/cvc5 (:mod:`atp.cvc5_backend`).
+
+WHY THIS IS NOT :mod:`fol.sanitize`
+-------------------------------------
+:mod:`fol.sanitize`'s :class:`~fol.sanitize.NameMapping` already solves
+exactly this shape of problem — an injective, whole-problem-consistent
+rewrite to legal tokens, with a reverse mapping back to the originals — but
+its target legality is the kit's OWN ``MSFLParser`` grammar, not any of
+these export formats'. The two disagree in a way that matters: a single-
+letter constant such as ``a`` is not a legal bare ``NAME`` token in the
+kit's own grammar (it would re-lex as a ``VARIABLE``), so
+``NameMapping.for_constant("a")`` rewrites it to ``c_a`` — but ``a`` is
+already a perfectly legal TPTP ``lower_word`` / Prover9 ``NAME`` /
+SMT-LIB2 simple symbol, and an exporter that "fixed" it anyway would
+silently change the output of every formula using a short constant,
+breaking the "already-legal names pass through byte-identical" guarantee
+these export entry points make to their callers (see each of this module's
+callers' own module docstrings). So each target format gets its OWN
+legality test and its own synthesis rule for the names that fail it, built
+from the primitives below — the same INJECTIVE / whole-problem-consistent
+/ reversible SHAPE :class:`~fol.sanitize.NameMapping` uses (a shared
+reservation set, numeric-suffix de-collision, a flat reverse dict), just
+parametrised per format instead of reusing that class's kit-specific
+methods directly.
+
+:func:`ascii_safe_base` is the one piece every target genuinely shares:
+transliterating non-ASCII characters via
+:func:`unicode_logic_kit.fol._fol_nodes.constant_name_to_ascii` (the same
+Greek-letter-name / reversible ``uXXXX``-escape rule
+:meth:`~fol.nodes.Constant.to_tptp` and :meth:`~fol.nodes.Constant.to_prover9`
+already use) and guaranteeing the result does not start with a digit or come
+out empty.
+"""
+
+import re
+from typing import Callable, Dict, Set
+
+from ..fol._fol_nodes import constant_name_to_ascii
+
+__all__ = ["ascii_safe_base", "reserve_rendered", "reverse_map_text"]
+
+
+def ascii_safe_base(name: str, prefix: str) -> str:
+    """Transliterate ``name`` to ASCII and ensure a non-digit-leading result.
+
+    Reuses :func:`constant_name_to_ascii` (ASCII passes through, a Greek
+    letter becomes its spelled name, anything else non-ASCII becomes a
+    reversible ``uXXXX`` escape) — every one of those three outcomes starts
+    with a letter, so the ONLY way the result can still start with a digit
+    (or be empty) is if ``name`` itself was already plain ASCII and
+    digit-leading (transliteration is a no-op on it). ``prefix`` is
+    prepended in that case; it is also prepended to an empty transliteration
+    (``name`` was empty, or every character became... nothing — not reached
+    by any of :func:`constant_name_to_ascii`'s cases today, but kept as an
+    honest fallback rather than an assumption).
+    """
+    ascii_name = constant_name_to_ascii(name)
+    if not ascii_name or ascii_name[0].isdigit():
+        ascii_name = prefix + ascii_name
+    return ascii_name
+
+
+def reserve_rendered(base: str, used: Set[str],
+                     render: Callable[[str], str] = lambda s: s) -> str:
+    """Return a token starting from ``base`` whose ``render(...)`` form is not
+    yet in ``used``, reserving that rendered form; mirrors
+    :meth:`fol.sanitize.NameMapping._reserve`'s numeric-suffix scheme
+    (``base``, then ``base2``, ``base3``, ...) but de-collides on the
+    RENDERED form (what actually appears in the exported text — e.g. after
+    TPTP's first-letter fold) rather than on ``base`` itself, since two
+    different raw candidates can still render to the same text (``Foo2`` and
+    ``foo2`` both fold to ``foo2``). ``render`` defaults to the identity
+    (Prover9 and SMT-LIB2 render every accepted token verbatim; only TPTP
+    needs a non-identity ``render``).
+    """
+    candidate = base
+    i = 2
+    while render(candidate) in used:
+        candidate = f"{base}{i}"
+        i += 1
+    used.add(render(candidate))
+    return candidate
+
+
+def reverse_map_text(text: str, *reverse_dicts: Dict[str, str]) -> str:
+    """Replace whole-token occurrences of a sanitised identifier in free
+    text with its original kit-level name.
+
+    Used for the free-text side of the Rückweg (R3's "Erklärungstexte") —
+    a prover's raw stdout excerpt, an error detail string, and similar —
+    where the identifiers of interest sit inside a larger human-readable
+    string rather than in a parsed :class:`~fol.nodes.Node`. Matching is by
+    whole token (regex word boundaries) so a sanitised name that happens to
+    be a substring of something else (another identifier, a longer word in
+    surrounding prose) is never partially rewritten; the first
+    ``reverse_dicts`` entry to contain a given token wins, and tokens are
+    tried longest-first so one sanitised name that is itself a prefix of
+    another is not matched short. Returns ``text`` unchanged if every dict
+    is empty (the common case: nothing needed sanitising, so nothing needs
+    reversing) or if ``text`` is empty.
+    """
+    combined: Dict[str, str] = {}
+    for d in reverse_dicts:
+        for token, original in d.items():
+            combined.setdefault(token, original)
+    if not combined or not text:
+        return text
+    pattern = re.compile(
+        r"\b(" + "|".join(re.escape(t) for t in sorted(combined, key=len, reverse=True)) + r")\b"
+    )
+    return pattern.sub(lambda m: combined[m.group(1)], text)

unicode_logic_kit/atp/_html.py

@@ -0,0 +1,72 @@
+"""Shared HTML-rendering primitives for the ``atp`` proof renderers.
+
+:meth:`~unicode_logic_kit.atp.fitch.Proof.to_html` and
+:meth:`~unicode_logic_kit.atp.sequent.Derivation.to_html` both render a
+self-contained, theme-aware HTML page in the same idiom already established by
+:meth:`unicode_logic_kit.fol.derivation.CCGDerivation.to_html` — a ``<!doctype
+html>`` page, CSS custom properties themed via both
+``@media(prefers-color-scheme:dark)`` *and* a ``:root[data-theme=dark]``
+override, and HTML-escaping of every user-supplied string (predicate/variable
+names, surface text). This private module holds the pieces genuinely common
+to the two ``atp`` renderers — escaping, a shared base colour palette, and the
+page wrapper — so :mod:`~unicode_logic_kit.atp.fitch` and
+:mod:`~unicode_logic_kit.atp.sequent` do not each reimplement them.
+
+It deliberately does **not** import from :mod:`unicode_logic_kit.fol.derivation`
+(nor the reverse): every ``unicode_logic_kit.atp`` module already imports
+``unicode_logic_kit.fol`` at module scope (``Node`` and friends), so ``atp`` →
+``fol`` is the established one-way dependency direction — ``fol`` only ever
+reaches into ``atp`` from inside a function body (e.g. ``fol.qml``,
+``fol.modal_translation``, ``fol._fol_nodes``, all lazily importing
+``atp.z3_models``/``atp.z3_input`` to keep ``fol`` importable without ``z3``).
+Having ``fol/derivation.py`` import this module at module scope would invert
+that and risks a real import cycle (``fol/__init__.py`` imports
+``.derivation`` eagerly). The handful of lines duplicated below
+(``esc_html``) are therefore an intentional, explicitly-permitted duplicate of
+``fol.derivation._esc_html`` rather than a cross-package import — see the C56
+roadmap item.
+"""
+
+__all__: list = []  # private helper module; nothing here is part of the public API
+
+
+def esc_html(s: str) -> str:
+    """Escape ``&``, ``<``, ``>`` for safe inclusion in HTML text content.
+
+    Mirrors ``fol.derivation._esc_html`` exactly (a stable, three-line
+    function); duplicated here rather than imported, see the module docstring.
+    """
+    return s.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+
+# Shared colour tokens (page background / ink / muted text / rule lines /
+# accent), following the exact idiom CCGDerivation.to_html() established:
+# default (light) values live in :root, overridden both by the OS-level
+# prefers-color-scheme media query and by an explicit :root[data-theme=...]
+# attribute a host page can set to force one theme regardless of the OS.
+_LIGHT_VARS = "--pg:#faf9f6;--ink:#23232a;--muted:#6b6b76;--bar:#3f3f47;--accent:#1c46b0"
+_DARK_VARS = "--pg:#15151a;--ink:#e9e8e4;--muted:#a6a6b0;--bar:#c3c3cd;--accent:#84a6ff"
+
+BASE_CSS = (
+    "\n:root{%s}"
+    "\n@media(prefers-color-scheme:dark){:root{%s}}"
+    "\n:root[data-theme=light]{%s}"
+    "\n:root[data-theme=dark]{%s}"
+    "\nbody{margin:0;background:var(--pg);color:var(--ink)}\n"
+) % (_LIGHT_VARS, _DARK_VARS, _LIGHT_VARS, _DARK_VARS)
+
+
+def html_page(title: str, body_html: str, extra_css: str) -> str:
+    """Wrap ``body_html`` in a self-contained, theme-aware HTML page.
+
+    Same skeleton as ``CCGDerivation.to_html()``'s page wrapper: a
+    ``<!doctype html>`` document with a viewport meta tag and one inline
+    ``<style>`` combining the shared colour tokens (:data:`BASE_CSS`) with the
+    caller's ``extra_css``. ``title`` is HTML-escaped.
+    """
+    return (
+        "<!doctype html>\n<html><head><meta charset=\"utf-8\">\n"
+        "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"
+        "<title>%s</title>\n<style>%s%s</style></head>\n<body>\n%s\n</body></html>\n"
+        % (esc_html(title), BASE_CSS, extra_css, body_html)
+    )

unicode_logic_kit/atp/_substructural_input.py

@@ -0,0 +1,228 @@
+"""What the propositional substructural calculi read, and what they refuse.
+
+Intuitionistic linear logic (:mod:`~unicode_logic_kit.atp.linear`) and the Lambek calculus
+(:mod:`~unicode_logic_kit.atp.lambek`) decide derivability between formulas built from
+CATEGORIES by the calculus' own connectives. "No derivation" is a statement about a sequent
+the calculus can state, so each calculus reads exactly the node classes it has rules for, and
+refuses every other node by name.
+
+What each calculus reads (the two allow-lists, :data:`ILL` and :data:`LAMBEK`):
+
+* intuitionistic linear logic: the connectives ``⊗`` (``Tensor``), ``&`` (``With``), ``⊕``
+  (``OPlus``), ``⊸`` (``LinearImplies``), ``!`` (``OfCourse``) and the units ``𝟙`` (``One``),
+  ``⊤`` (``Top``), ``𝟘`` (``Zero``), over atoms;
+* the Lambek calculus: the connectives ``•`` (``Product``), ``\\`` (``Under``) and ``/``
+  (``Over``), over atoms.
+
+These are the node classes the two grammars (``MSFLParser(linear=True)`` and
+``MSFLParser(lambek=True)``) produce, and the classes the proof checkers and the Isabelle export
+of the two calculi have rules for; nothing either grammar can write is refused. An atom is read
+with its terms (variables, constants, numerals and function terms) as written.
+
+Both calculi are propositional: a sequent has no individuals to quantify over, no counting and
+no identity. An atom over terms (``P(alpha)``, ``Loves(john, mary)``, ``Q(f(x))``, a free
+variable included) is read as ONE category, identified by its predicate and its terms as
+written. That reading is sound in both directions: a quantifier-free, equality-free sequent has
+no rule that substitutes a term for another, so its first-order derivations and its
+propositional derivations over those categories are the same derivations, and a sequent with no
+derivation of the one kind has none of the other.
+
+Every other node is refused, in three kinds.
+
+* A quantifier, a counting or cardinality node, a sorted constant. Read as one more opaque
+  category they make a derivability verdict about ANOTHER formula: ``∀x P(x) ⊢ P(alpha)``
+  holds in first-order linear logic (instantiation) and has no derivation between the two
+  categories ``∀x P(x)`` and ``P(alpha)``. A sorted constant ``c:S`` asserts ``S(c)``, which the
+  category reading drops.
+* An equality or disequality atom: ``⊢ alpha = alpha`` holds with identity and has no derivation
+  between categories.
+* A node of any other logic: a classical connective (``And``, ``Or``, ``Not``, ``Implies``,
+  ``Iff``, ``Xor``), a modal, temporal, epistemic or hybrid operator, a connective of the other
+  calculus, a lambda, an application or a predicate in argument position (the lambda layer is
+  the one thing both grammars write besides their connectives and atoms: ``(λx. P(x))(a) ⊢ P(a)``
+  holds by beta reduction and has no derivation between the category of an application and the
+  category ``P(a)``). Neither calculus has a rule for it; ``And(A, B) ⊢ A`` holds classically
+  and has no derivation between the categories ``And(A, B)`` and ``A``. A term (a variable, a
+  constant, a numeral, a function term) where a formula stands is refused as well: it is not
+  an atom, and only an atom is a category.
+
+:func:`refuse_unreadable_input` names such a node, its class and the calculus, lists the
+connectives the calculus has, and says what to do instead.
+"""
+
+from dataclasses import dataclass
+from typing import Iterable, Optional, Tuple
+
+from ..fol._linear_nodes import Top, Zero
+from ..fol.nodes import (
+    Atom, Cardinality, Constant, Count, Function, LinearImplies, Node, Number, OfCourse, One,
+    OPlus, Over, Product, Quantifier, SecondOrderQuantifier, SlashedExists, SortedCardinality,
+    SortedConstant, SortedCount, SortedQuantifier, Tensor, Under, Variable, With,
+)
+from ..semantics._modal_reject import is_equality_atom
+
+__all__ = ["Calculus", "ILL", "LAMBEK", "refuse_unreadable_input", "unreadable_reason"]
+
+
+@dataclass(frozen=True)
+class Calculus:
+    """A propositional substructural calculus, by what it has rules for.
+
+    Fields:
+
+    * ``name``: how a message calls the calculus.
+    * ``connectives``: the node classes the calculus has rules for (atoms are read besides).
+    * ``glyphs``: those connectives as the calculus' own grammar writes them.
+    """
+
+    name: str
+    connectives: Tuple[type, ...]
+    glyphs: str
+
+
+#: Intuitionistic linear logic: the connectives of the ``linear`` grammar.
+ILL = Calculus(
+    "intuitionistic linear logic",
+    (Tensor, With, OPlus, LinearImplies, OfCourse, One, Top, Zero),
+    "⊗ & ⊕ ⊸ ! 𝟙 ⊤ 𝟘")
+
+#: The Lambek calculus: the connectives of the ``lambek`` grammar.
+LAMBEK = Calculus("the Lambek calculus", (Product, Under, Over), "• \\ /")
+
+#: The node classes of an atom's terms, read as written inside the category.
+_TERMS: Tuple[type, ...] = (Variable, Constant, Number, Function)
+
+#: The first-order node classes refused wherever they stand, with what each is called in a message.
+_FIRST_ORDER: Tuple[Tuple[Tuple[type, ...], str], ...] = (
+    ((Quantifier, SortedQuantifier, SecondOrderQuantifier, SlashedExists), "quantifier"),
+    ((Count, SortedCount), "counting quantifier"),
+    ((Cardinality, SortedCardinality), "cardinality term"),
+    ((SortedConstant,), "sorted constant"),
+)
+
+#: The longest rendering of a refused node a message quotes.
+_QUOTE_LIMIT = 100
+
+
+def _first_order_label(node: Node) -> Optional[str]:
+    """What a first-order node is called, or ``None`` for any other node."""
+    for classes, label in _FIRST_ORDER:
+        if isinstance(node, classes):
+            return label
+    return None
+
+
+def _quote(node: Node) -> str:
+    """The node's own rendering, shortened for a message."""
+    text = node.to_unicode_str()
+    return text if len(text) <= _QUOTE_LIMIT else text[:_QUOTE_LIMIT - 1] + "…"
+
+
+def _outside(node: Node, calculus: Calculus, formula_position: bool = True) -> Optional[Node]:
+    """The first node, in pre-order, that is not read where it stands, or ``None``.
+
+    A formula is an atom or a connective of the calculus whose operands are formulas; the
+    arguments of an atom are terms (variables, constants, numerals and function terms over
+    terms). Any other node, and a term where a formula stands, is outside.
+    """
+    if formula_position:
+        if isinstance(node, Atom):
+            operands, operand_position = node._child_nodes(), False
+        elif isinstance(node, calculus.connectives):
+            operands, operand_position = node._child_nodes(), True
+        else:
+            return node
+    elif isinstance(node, _TERMS):
+        operands, operand_position = node._child_nodes(), False
+    else:
+        return node
+    for operand in operands:
+        found = _outside(operand, calculus, operand_position)
+        if found is not None:
+            return found
+    return None
+
+
+#: The kinds of refusal, in the order they are looked for.
+_FIRST_ORDER_KIND, _OUTSIDE_KIND, _IDENTITY_KIND = "first order", "outside", "identity"
+
+
+def _first_refused(formulas: Tuple[Node, ...], calculus: Calculus) -> Optional[Tuple[Node, str, str]]:
+    """The first node ``calculus`` cannot read, what it is called, and the kind of refusal it gets.
+
+    The kinds, in the order they are looked for: first order (a quantifier, a count, a
+    cardinality, a sorted constant), outside (a node of another logic, or a term where a formula
+    stands), identity (an equality or disequality atom). An identity atom that merely holds a
+    refused term (``|{v : P(v)}| = 2``) is reported through that term, which says more than the
+    comparison around it, and a quantifier that holds a classical connective is reported as the
+    quantifier.
+    """
+    nodes = [node for formula in formulas for node in formula.walk()]
+    for node in nodes:
+        label = _first_order_label(node)
+        if label is not None:
+            return node, label, _FIRST_ORDER_KIND
+    for formula in formulas:
+        outside = _outside(formula, calculus)
+        if outside is not None:
+            label = "term where a formula stands" if isinstance(outside, _TERMS) else "node of another logic"
+            return outside, label, _OUTSIDE_KIND
+    for node in nodes:
+        if is_equality_atom(node):
+            return node, "equality atom" if node.predicate == "=" else "disequality atom", _IDENTITY_KIND
+    return None
+
+
+def unreadable_reason(formulas: Iterable[Node], route: str, calculus: Calculus) -> Optional[str]:
+    """Why ``calculus`` cannot read ``formulas``, or ``None`` when it can.
+
+    The text :func:`refuse_unreadable_input` raises, for a caller that reports a refusal as an
+    answer instead of an exception (a backend, a proof checker).
+    """
+    found = _first_refused(tuple(formulas), calculus)
+    if found is None:
+        return None
+    node, what, kind = found
+    name = type(node).__name__
+    head = (f"{route}: the {what} {_quote(node)!r} ({name}) is refused by name — "
+            f"{calculus.name} has the connectives {calculus.glyphs} over categories")
+    if kind != _OUTSIDE_KIND:
+        return (
+            f"{head}, with no individuals, quantifiers, counting, sorts or identity, and reading "
+            "the node as one more opaque category would answer about another formula "
+            "(∀x P(x) ⊢ P(alpha) holds in every first-order reading and has no derivation "
+            "between the two categories). Decide it with a first-order route (z3, vampire, "
+            "eprover, tableau, resolution), or write the category as an atom over terms, "
+            "without the quantifier, count, sort or identity.")
+    if isinstance(node, _TERMS):
+        return (
+            f"{head}, and a term is not one of them: reading {name} as a category would answer "
+            "about another formula. Write the category as an atom, a predicate over terms.")
+    return (
+        f"{head}, and has no rule for {name}: it belongs to another logic (or to the lambda "
+        "layer every grammar shares), and "
+        "reading it as one more opaque category would answer about another formula "
+        "(And(A, B) ⊢ A holds classically and has no derivation between the categories "
+        "And(A, B) and A). Decide it with a route of the logic the node belongs to "
+        "(list_backends names them), or write it with the connectives "
+        f"{calculus.glyphs} of {calculus.name}.")
+
+
+def refuse_unreadable_input(formulas: Iterable[Node], route: str, calculus: Calculus) -> None:
+    """Raise ``NotImplementedError`` naming the first node ``calculus`` cannot read, if any.
+
+    ``formulas`` are the antecedent formulas and the goal of one sequent. ``calculus`` reads the
+    node classes it has rules for (:data:`ILL`, :data:`LAMBEK`) and atoms over terms; a
+    quantifier (sorted, second-order or slashed), a counting or cardinality node, a sorted
+    constant, an equality or disequality atom and a node of any other logic are refused (see the
+    module docstring for the two allow-lists and for why an atom over terms is sound). ``route``
+    names the function or backend that refuses. The message quotes the node, names its class and
+    the calculus, lists the connectives the calculus has and says what to do instead. Returns
+    ``None`` when every formula is readable.
+
+    Raises:
+        NotImplementedError: a node of one of the refused kinds occurs in ``formulas``.
+    """
+    reason = unreadable_reason(formulas, route, calculus)
+    if reason is not None:
+        raise NotImplementedError(reason)