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

unicode_logic_kit/fol/_lambek_nodes.py

@@ -0,0 +1,112 @@
+"""Lambek-calculus node classes and the ``lambek`` parser mode.
+
+The Lambek calculus L (Lambek 1958) is the substructural logic of ORDERED
+resources — the type logic of categorial grammar. On top of dropping weakening
+and contraction (as linear logic does) it also drops EXCHANGE: the antecedent
+of a sequent is a sequence, not a multiset, so ``A, A\\B ⊢ B`` is derivable but
+``A\\B, A ⊢ B`` is not. The ``lambek`` mode (``MSFLParser(lambek=True)``)
+provides the three connectives over atomic categories (nullary predicates such
+as ``NP``, ``S``):
+
+- ``A • B``  the product (A followed by B),
+- ``A \\ B``  *under*: combines with an ``A`` on its LEFT to give a ``B``,
+- ``B / A``  *over*: combines with an ``A`` on its RIGHT to give a ``B``.
+
+``•`` binds tighter than ``\\`` and ``/`` (the categorial convention); ``\\``
+and ``/`` are right-associative in the grammar — parenthesise where the
+non-associative reading matters. Derivability lives in
+``unicode_logic_kit.atp.lambek`` (a complete, terminating cut-free decision
+procedure — L is decidable). There is no classical export: collapsing the
+directional implications to ``→`` erases word order, which is the calculus's
+entire point, so ``to_z3`` / ``to_prover9`` / ``to_tptp`` reject.
+"""
+
+from dataclasses import dataclass
+
+from ._fol_nodes import (
+    Node, Z3Env,
+    NODE_CLASSES, register_operator, register_parser_op, _fold_binary,
+)
+
+# Shared rejection message: the order-forgetting collapse is deliberately absent.
+_NO_LAMBEK_EXPORT = (
+    "Lambek-calculus types have no classical first-order export: collapsing the "
+    "directional implications \\ and / to → forgets word order, which is what "
+    "the calculus is about. Use the decision procedure "
+    "(unicode_logic_kit.lambek_derivable / lambek_prove) instead."
+)
+
+
+def _lambek_binary(name, doc):
+    """Build a frozen binary Lambek node class with the shared boilerplate."""
+
+    @dataclass(frozen=True)
+    class _Binary(Node):
+        left: Node
+        right: Node
+
+        def to_dict(self):
+            """Serialise to dict with type tag and recursively serialised operands."""
+            return {"_type": name, "left": self.left.to_dict(),
+                    "right": self.right.to_dict()}
+
+        @staticmethod
+        def from_dict(d):
+            """Deserialise from a dict produced by to_dict."""
+            return NODE_CLASSES[name](Node.from_dict(d["left"]),
+                                      Node.from_dict(d["right"]))
+
+        def to_z3(self, env: Z3Env = None):
+            """Reject Z3 export: Lambek types have no order-preserving collapse."""
+            raise NotImplementedError(_NO_LAMBEK_EXPORT)
+
+        def to_prover9(self) -> str:
+            """Reject Prover9 export: Lambek types have no order-preserving collapse."""
+            raise NotImplementedError(_NO_LAMBEK_EXPORT)
+
+        def to_tptp(self) -> str:
+            """Reject TPTP export: Lambek types have no order-preserving collapse."""
+            raise NotImplementedError(_NO_LAMBEK_EXPORT)
+
+    _Binary.__name__ = _Binary.__qualname__ = name
+    _Binary.__doc__ = doc
+    return _Binary
+
+
+Product = _lambek_binary(
+    "Product",
+    "The Lambek product ``A • B``: an ``A`` immediately followed by a ``B``.")
+Under = _lambek_binary(
+    "Under",
+    "The Lambek *under* type ``A \\\\ B``: combines with an ``A`` on its LEFT "
+    "to yield a ``B`` (fields are as written: left=A, right=B).")
+Over = _lambek_binary(
+    "Over",
+    "The Lambek *over* type ``B / A``: combines with an ``A`` on its RIGHT "
+    "to yield a ``B`` (fields are as written: left=B, right=A).")
+
+
+NODE_CLASSES.update({"Product": Product, "Under": Under, "Over": Over})
+
+
+# =========================
+# Renderer + parser registration — the "lambek" mode
+# =========================
+#
+# All three connectives are regular registry operators (no renderer branches).
+# '\\' and '/' sit at the implication level (right-assoc; parenthesise for the
+# non-associative reading), '•' at the tighter same-level group. The '/' glyph
+# is arithmetic division in the TERM layer of other modes; at the formula level
+# of the lambek mode it is unambiguous (categories are formulas, not terms).
+
+register_operator(Product, "level2", "•", "\\bullet", 3)
+register_operator(Under, "binary_implies", "\\", "\\backslash", 2)
+register_operator(Over, "binary_implies", "/", "/", 2)
+
+register_parser_op(Product, "lambek", "level2", "product_", '"•"',
+                   lambda items: _fold_binary(items, Product),
+                   only_name="only_product")
+register_parser_op(Under, "lambek", "implication", "under_", '"\\\\"',
+                   lambda items: Under(items[0], items[1]))
+register_parser_op(Over, "lambek", "implication", "over_", '"/"',
+                   lambda items: Over(items[0], items[1]))

unicode_logic_kit/fol/_linear_nodes.py

@@ -0,0 +1,352 @@
+"""Intuitionistic linear logic (ILL) node classes and the ``linear`` parser mode.
+
+Linear logic (Girard 1987) is the substructural logic in which formulas are
+RESOURCES: the structural rules of weakening and contraction are dropped, so a
+hypothesis is used exactly once unless explicitly banked under ``!``. The
+``linear`` mode (``MSFLParser(linear=True)``) covers propositional
+intuitionistic linear logic:
+
+- ``⊗``  multiplicative conjunction (*tensor*: both resources, side by side),
+- ``⊸``  linear implication (*lollipop*: consume the antecedent, produce the
+  consequent),
+- ``&``  additive conjunction (*with*: a choice offered — either can be taken,
+  not both),
+- ``⊕``  additive disjunction (one of the two, the provider chooses),
+- ``!``  the exponential (*of course*: an unlimited, reusable supply),
+- ``𝟙``  the multiplicative unit (the empty resource),
+- ``⊤``  the additive truth (*top*: always available, no information — the
+  additive unit of ``&``; ``⊤R`` holds for ANY context, so ⊤ carries no
+  information about what it takes to reach it),
+- ``𝟘``  the additive falsity (*zero*: the impossible resource — the additive
+  unit of ``⊕``; ``0L`` derives ANY sequent once 𝟘 is in the antecedent, ILL's
+  analogue of ex falso).
+
+``⊗`` / ``&`` / ``⊕`` sit in the no-mixing same-level group (parenthesise mixed
+chains); ``⊸`` is right-associative; ``!`` binds like ¬. The glyph ``⊕`` is the
+classical Xor / fuzzy strong disjunction in OTHER modes — per-mode glyph reuse
+is the established pattern here. Provability lives in
+``unicode_logic_kit.atp.linear`` (a cut-free backward-search prover, complete and
+terminating for the !-free fragment); there is no classical export — the
+classical collapse (⊗,& → ∧; ⊕ → ∨; ⊸ → →; drop !) would erase exactly the
+resource distinctions the logic is about, so ``to_z3`` / ``to_prover9`` /
+``to_tptp`` reject.
+"""
+
+from dataclasses import dataclass
+
+from ._fol_nodes import (
+    Node, Z3Env,
+    NODE_CLASSES, register_operator, register_parser_op, _fold_binary,
+)
+
+# Shared rejection message: the classical collapse is deliberately not provided.
+_NO_LINEAR_EXPORT = (
+    "Linear-logic formulas have no classical first-order export: collapsing "
+    "⊗/& to ∧, ⊕ to ∨, ⊸ to →, and dropping ! erases the resource distinctions "
+    "the logic exists to draw. Use the sequent prover "
+    "(unicode_logic_kit.ill_prove / ill_derivable) instead."
+)
+
+
+def _linear_binary(name, doc):
+    """Build a frozen binary linear-logic node class with the shared boilerplate."""
+
+    @dataclass(frozen=True)
+    class _Binary(Node):
+        left: Node
+        right: Node
+
+        def to_dict(self):
+            """Serialise to dict with type tag and recursively serialised operands."""
+            return {"_type": name, "left": self.left.to_dict(),
+                    "right": self.right.to_dict()}
+
+        @staticmethod
+        def from_dict(d):
+            """Deserialise from a dict produced by to_dict."""
+            return NODE_CLASSES[name](Node.from_dict(d["left"]),
+                                      Node.from_dict(d["right"]))
+
+        def to_z3(self, env: Z3Env = None):
+            """Reject Z3 export: linear connectives have no classical collapse here."""
+            raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+        def to_prover9(self) -> str:
+            """Reject Prover9 export: linear connectives have no classical collapse here."""
+            raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+        def to_tptp(self) -> str:
+            """Reject TPTP export: linear connectives have no classical collapse here."""
+            raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+    _Binary.__name__ = _Binary.__qualname__ = name
+    _Binary.__doc__ = doc
+    return _Binary
+
+
+Tensor = _linear_binary(
+    "Tensor",
+    "Multiplicative conjunction ``A ⊗ B``: both resources, available side by side.")
+With = _linear_binary(
+    "With",
+    "Additive conjunction ``A & B``: an offered choice — either can be taken, "
+    "but only one.")
+OPlus = _linear_binary(
+    "OPlus",
+    "Additive disjunction ``A ⊕ B``: one of the two holds, the provider chooses.")
+LinearImplies = _linear_binary(
+    "LinearImplies",
+    "Linear implication ``A ⊸ B``: consuming one ``A`` produces one ``B``.")
+
+
+@dataclass(frozen=True)
+class OfCourse(Node):
+    """The exponential ``!A``: an unlimited, reusable supply of the resource A.
+
+    ``!`` reintroduces weakening and contraction for the banked formula — the
+    only gateway back to classical-style reuse.
+    """
+
+    formula: Node
+
+    def to_dict(self):
+        """Serialise to dict with the recursively serialised operand."""
+        return {"_type": "OfCourse", "formula": self.formula.to_dict()}
+
+    @staticmethod
+    def from_dict(d):
+        """Deserialise an OfCourse from a dict produced by to_dict."""
+        return OfCourse(Node.from_dict(d["formula"]))
+
+    def to_z3(self, env: Z3Env = None):
+        """Reject Z3 export: the exponential has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+    def to_prover9(self) -> str:
+        """Reject Prover9 export: the exponential has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+    def to_tptp(self) -> str:
+        """Reject TPTP export: the exponential has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+
+@dataclass(frozen=True)
+class One(Node):
+    """The multiplicative unit ``𝟙``: the empty resource (⊗'s neutral element)."""
+
+    def _tree_parts(self):
+        """Return the unit glyph as an atomic tree label."""
+        return "𝟙", []
+
+    def to_dict(self):
+        """Serialise to dict with the type tag only (the unit has no children)."""
+        return {"_type": "One"}
+
+    @staticmethod
+    def from_dict(d):
+        """Deserialise a One from a dict produced by to_dict."""
+        return One()
+
+    def to_z3(self, env: Z3Env = None):
+        """Reject Z3 export: the unit has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+    def to_prover9(self) -> str:
+        """Reject Prover9 export: the unit has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+    def to_tptp(self) -> str:
+        """Reject TPTP export: the unit has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+
+@dataclass(frozen=True)
+class Top(Node):
+    """The additive truth ``⊤``: always derivable (rule ``⊤R``, no premise, any
+    context) — the additive unit of ``&`` (``With``). Carries no information: unlike
+    ``𝟙`` (which must be consumed exactly, ``⊗``'s unit), ``⊤`` is reachable from
+    ANY antecedent, so e.g. ``⊤ ⊸ A`` is NOT derivable in general (having reached
+    ⊤ tells the consumer nothing that would let it produce A)."""
+
+    def _tree_parts(self):
+        """Return the top glyph as an atomic tree label."""
+        return "⊤", []
+
+    def to_dict(self):
+        """Serialise to dict with the type tag only (⊤ has no children)."""
+        return {"_type": "Top"}
+
+    @staticmethod
+    def from_dict(d):
+        """Deserialise a Top from a dict produced by to_dict."""
+        return Top()
+
+    def to_z3(self, env: Z3Env = None):
+        """Reject Z3 export: ⊤ has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+    def to_prover9(self) -> str:
+        """Reject Prover9 export: ⊤ has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+    def to_tptp(self) -> str:
+        """Reject TPTP export: ⊤ has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+
+@dataclass(frozen=True)
+class Zero(Node):
+    """The additive falsity ``𝟘``: once in the antecedent, ANY sequent is derivable
+    (rule ``0L``, no premise) — the additive unit of ``⊕`` (``OPlus``) and ILL's
+    analogue of ex falso quodlibet. Dual to ``⊤``: ``⊤`` is always a valid RIGHT
+    conclusion, ``𝟘`` is always a usable LEFT hypothesis."""
+
+    def _tree_parts(self):
+        """Return the zero glyph as an atomic tree label."""
+        return "𝟘", []
+
+    def to_dict(self):
+        """Serialise to dict with the type tag only (𝟘 has no children)."""
+        return {"_type": "Zero"}
+
+    @staticmethod
+    def from_dict(d):
+        """Deserialise a Zero from a dict produced by to_dict."""
+        return Zero()
+
+    def to_z3(self, env: Z3Env = None):
+        """Reject Z3 export: 𝟘 has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+    def to_prover9(self) -> str:
+        """Reject Prover9 export: 𝟘 has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+    def to_tptp(self) -> str:
+        """Reject TPTP export: 𝟘 has no classical collapse here."""
+        raise NotImplementedError(_NO_LINEAR_EXPORT)
+
+
+NODE_CLASSES.update({
+    "Tensor": Tensor, "With": With, "OPlus": OPlus,
+    "LinearImplies": LinearImplies, "OfCourse": OfCourse, "One": One,
+    "Top": Top, "Zero": Zero,
+})
+
+
+# =========================
+# Renderer + parser registration — the "linear" mode
+# =========================
+#
+# Every connective is a regular registry operator, so the Unicode/LaTeX
+# renderers need no new branch; only the nullary constants (𝟙, and now ⊤/𝟘)
+# need an explicit renderer branch in _msfl_nodes (register_operator has no
+# "nullary" fixity — see _fol_nodes._VALID_FIXITIES — because every fixity it
+# supports arranges at least one operand). PARSING ⊤/𝟘 needs no such branch
+# (register_parser_op below is self-contained), so 'MSFLParser(linear=True)'
+# already round-trips them; Node.to_unicode_str()/to_latex() on a formula
+# that CONTAINS ⊤ or 𝟘 also renders correctly, via the central _msfl_nodes
+# branch (see the comment above render_ill_formula below for why that
+# function exists alongside to_unicode_str() anyway — a stricter
+# round-trip guarantee, not a Top/Zero workaround; its only caller in this
+# kit is atp.linear.ILLSequent).
+
+register_operator(Tensor, "level2", "⊗", "\\otimes", 3)
+register_operator(With, "level2", "&", "\\mathbin{\\&}", 3)
+register_operator(OPlus, "level2", "⊕", "\\oplus", 3)
+register_operator(LinearImplies, "binary_implies", "⊸", "\\multimap", 2)
+register_operator(OfCourse, "prefix", "!", "\\mathord{!}", 4)
+
+register_parser_op(Tensor, "linear", "level2", "tensor_", '"⊗"',
+                   lambda items: _fold_binary(items, Tensor),
+                   only_name="only_tensor")
+register_parser_op(With, "linear", "level2", "with_", '"&"',
+                   lambda items: _fold_binary(items, With),
+                   only_name="only_with")
+register_parser_op(OPlus, "linear", "level2", "oplus_", '"⊕"',
+                   lambda items: _fold_binary(items, OPlus),
+                   only_name="only_oplus")
+register_parser_op(LinearImplies, "linear", "implication", "limp_", '"⊸"',
+                   lambda items: LinearImplies(items[0], items[1]))
+register_parser_op(OfCourse, "linear", "prefix", "ofcourse_", '"!" prefix',
+                   lambda items: OfCourse(items[0]))
+register_parser_op(One, "linear", "prefix", "one_", '"𝟙"',
+                   lambda items: One())
+register_parser_op(Top, "linear", "prefix", "top_", '"⊤"',
+                   lambda items: Top())
+register_parser_op(Zero, "linear", "prefix", "zero_", '"𝟘"',
+                   lambda items: Zero())
+
+
+# ---------------------------------------------------------------------------
+# A self-contained, fully-parenthesised Unicode renderer for ILL formulas.
+# ---------------------------------------------------------------------------
+#
+# Node.to_unicode_str() dispatches through unicode_logic_kit.fol._msfl_nodes,
+# whose explicit branch table special-cases all three nullary linear-mode
+# constants — One ("𝟙"), Top ("⊤"), Zero ("𝟘") — wherever they occur in a
+# formula's tree, including nested, e.g. inside a Tensor; none of them raises.
+# Verified live: Top().to_unicode_str() == "⊤", Zero().to_latex() ==
+# "\\mathbf{0}", and Tensor(Atom("P", []), Zero()).to_unicode_str() ==
+# "P ⊗ 𝟘". So render_ill_formula below is NOT a Top/Zero workaround. The
+# reason its caller in this kit, atp.linear.ILLSequent, uses it instead of
+# to_unicode_str() is that to_unicode_str() does precedence-based MINIMAL
+# parenthesisation — e.g. Tensor(Atom("P", []), Atom("Q", [])).to_unicode_str()
+# == "P ⊗ Q" — whereas render_ill_formula fully parenthesises every compound
+# subformula (the same Tensor renders as "(P ⊗ Q)"; always safe, since
+# MSFLParser accepts redundant parens anywhere), which guarantees that
+# round-tripping through MSFLParser(linear=True).parse reproduces a
+# structurally equal AST — a guarantee minimal parenthesisation does not make
+# in general. It is a deliberately-conservative renderer for its
+# round-trip-sensitive caller, not a substitute for a rendering gap.
+def render_ill_formula(f: Node) -> str:
+    """Render an ILL (``linear`` mode) formula to Unicode text, fully
+    parenthesised.
+
+    Renders the same symbols as ``f.to_unicode_str()`` (Top/Zero included —
+    see the module comment above), but always produces text that re-parses
+    (via ``MSFLParser(linear=True).parse``) to a structurally equal formula,
+    because every compound subformula is fully parenthesised — unlike
+    ``to_unicode_str()``'s precedence-based minimal parenthesisation. Used by
+    its round-trip-sensitive caller, ``atp.linear.ILLSequent``, in place of
+    ``to_unicode_str()``. A constant whose bare name would read as something else is
+    written in quotes, as ``to_unicode_str()`` writes it.
+    """
+    return _render_ill(f, lambda atom: atom.to_unicode_str())
+
+
+def _render_ill(f: Node, atom_text) -> str:
+    """The fully parenthesised rendering of :func:`render_ill_formula`, with the text of an
+    atom (and of anything else that is not an ILL connective) given by ``atom_text``."""
+    if isinstance(f, Top):
+        return "⊤"
+    if isinstance(f, Zero):
+        return "𝟘"
+    if isinstance(f, One):
+        return "𝟙"
+    if isinstance(f, OfCourse):
+        return f"!({_render_ill(f.formula, atom_text)})"
+    if isinstance(f, Tensor):
+        return f"({_render_ill(f.left, atom_text)} ⊗ {_render_ill(f.right, atom_text)})"
+    if isinstance(f, With):
+        return f"({_render_ill(f.left, atom_text)} & {_render_ill(f.right, atom_text)})"
+    if isinstance(f, OPlus):
+        return f"({_render_ill(f.left, atom_text)} ⊕ {_render_ill(f.right, atom_text)})"
+    if isinstance(f, LinearImplies):
+        return f"({_render_ill(f.left, atom_text)} ⊸ {_render_ill(f.right, atom_text)})"
+    # Atom (and anything else the linear grammar can produce): its own text
+    # is safe here since an Atom's children are TERMS (Variable/Constant/
+    # Number/Function), never Top/Zero.
+    return atom_text(f)
+
+
+def _ill_sort_key(f: Node) -> str:
+    """A total-order string key for sorting ILL formulas (multiset bookkeeping
+    in atp.linear): the fully parenthesised rendering first (readable, and identical to
+    the pre-Top/Zero ordering for any formula without Top/Zero), with every constant
+    written by its bare name (``key_text``) so that the quotes of a quoted constant play
+    no part in the order, then ``repr()`` as a tiebreaker.
+    """
+    from ._msfl_nodes import key_text  # lazy: avoid a module-load-order cycle
+    return _render_ill(f, key_text) + "\x00" + repr(f)