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

unicode_logic_kit/fol/_numeral_symbols.py

@@ -0,0 +1,231 @@
+"""A numeral is a constant: the one name a writer gives it, and the check that keeps it apart.
+
+On every route that was not asked for arithmetic, a :class:`~unicode_logic_kit.fol.nodes.Number`
+is a CONSTANT symbol identified by its VALUE: ``Number(1)``, ``Number(1.0)`` and the
+numeral written ``01`` are one constant (one node: a ``Number`` stores a float with a
+whole value as the integer it equals), and
+nothing else is known about it, so two numerals of different value may denote the same
+element, like any two constants. The operators ``+ - * /`` are uninterpreted function
+symbols and ``< > ≤ ≥`` uninterpreted predicates. A problem writer for a language whose
+own numbers are arithmetic (TPTP's ``1`` is an ``$int``, ``$sum`` is addition) must not
+hand a numeral to the prover as a number: Vampire and E read the bare ``1`` as an
+integer, and the text ``p(1)`` is then a type error for a predicate over individuals,
+while ``1 != 2`` and ``$sum(1,1) = 2`` are theorems of the prover's arithmetic that the
+kit's reading does not have.
+
+This module is what such a writer shares:
+
+* :func:`numeral_name` -- the name a numeral is written under, one per VALUE: the text of
+  the number, with an integral float spelled as the integer (``1.0`` is ``1``). The writer
+  then treats it as a constant of that name, so the writer's ordinary renaming (a name
+  that is no word in the target language is replaced by a legal, collision-free token,
+  and the replacement is recorded) gives it its word, and the writer's name map reads it
+  back. :func:`numeral_value` is the inverse.
+* :func:`numerals_as_constants` -- rewrite every numeral in term position as that
+  constant, and refuse by name a constant, sorted constant or function that is spelled
+  like a numeral of the problem (``Number(1)`` and ``Constant('1')``): they would be one
+  symbol under one name, and the kit keeps a numeral and a constant apart.
+
+A ``Number`` that is the bound of a counting quantifier (``Count.n``,
+``SortedCount.n``) is not a term and is left as it is. A writer whose target states a
+comparison with a cardinality arithmetically (``|{x : P(x)}| ≥ 2`` is HOL's ``card {x. P x}
+≥ 2`` over the naturals) asks for ``counting_comparisons=True``: a ``Number`` operand of
+such a comparison is then the number of the comparison and not a constant, and is left as
+it is too.
+"""
+
+from dataclasses import replace
+from typing import Callable, Dict, FrozenSet, Iterable, Iterator, List, Sequence, Tuple, Union
+
+from ._fol_nodes import _number_text
+from .nodes import (
+    Atom, Cardinality, Constant, Count, Function, Node, Number, SortedCardinality,
+    SortedConstant, SortedCount,
+)
+
+__all__ = ["numeral_name", "prefixed_numeral_name", "numeral_value", "term_numerals",
+           "numerals_as_constants"]
+
+_COUNT_NODES = (Count, SortedCount)
+
+#: The comparisons whose operands are numbers when one of them is a cardinality.
+_COMPARISONS = frozenset({"=", "≠", "<", ">", "≤", "≥"})
+
+
+def _plain(value: Union[int, float]) -> Union[int, float]:
+    """``value`` as the ``int`` or ``float`` it is; a ``bool`` is the integer it equals."""
+    if isinstance(value, bool):
+        return int(value)
+    if isinstance(value, (int, float)):
+        return value
+    raise NotImplementedError(
+        f"Number({value!r}) holds a {type(value).__name__}, and only an int or a float is a "
+        "numeral the kit's writers can name; convert the value first.")
+
+
+def numeral_name(value: Union[int, float]) -> str:
+    """The name a numeral of value ``value`` is written under: ONE name per value.
+
+    The text of the number as the kit prints it everywhere (digits, an optional fractional
+    part, a leading ``-``, no exponent), except that a float with an integral value is
+    spelled as that integer, so ``1`` and ``1.0`` are one name
+    (``numeral_name(1.0) == numeral_name(1) == '1'``) while ``2.5`` stays ``'2.5'``. A
+    :class:`~unicode_logic_kit.fol.nodes.Number` already stores such a float as the integer, so for
+    the value of a node this is simply its printed text; the function takes a raw value too.
+
+    Raises:
+        ValueError: ``value`` is ``inf``, ``-inf`` or ``nan``: no syntax of the kit has a
+            literal for it.
+        NotImplementedError: ``value`` is neither an ``int`` nor a ``float``.
+    """
+    value = _plain(value)
+    if isinstance(value, float) and value.is_integer():
+        value = int(value)
+    return _number_text(value)
+
+
+def prefixed_numeral_name(value: Union[int, float]) -> str:
+    """:func:`numeral_name` with an ``n`` in front (``n1``, ``n2.5``, ``n-1``): the spelling
+    the higher-order writers (THF, Isabelle/HOL) give a numeral, so that the identifier
+    their own sanitiser makes of it starts with a lower-case letter (``n1``, ``n2_5``,
+    ``n_1``). One name per value, like :func:`numeral_name`."""
+    return "n" + numeral_name(value)
+
+
+def numeral_value(name: str) -> Union[int, float]:
+    """The value of the numeral that :func:`numeral_name` named ``name``: an ``int`` when the
+    name has no ``.``, a ``float`` otherwise.
+
+    The exact inverse of :func:`numeral_name` and of nothing else: the name of a float is the
+    shortest text that reads back as that float, so reading it back gives the float that was
+    named. A text a person typed is read by ``_numeral_from_text`` (at most 15 significant digits),
+    never by this function, and a name that :func:`numeral_name` does not produce is refused, so
+    two different names are never read as one value.
+
+    Raises:
+        ValueError: ``name`` is not a name :func:`numeral_name` produces (``1.0``, ``007``, ``1e3``
+            and ``0.30000000000000005``, whose nearest float is named ``0.30000000000000004``,
+            are not).
+    """
+    value = float(name) if "." in name else int(name)
+    if numeral_name(value) != name:
+        raise ValueError(
+            f"{name!r} is not a name numeral_name produces (the numeral of that value is named "
+            f"{numeral_name(value)!r}), so it is not read as that value")
+    return value
+
+
+def _is_counting_comparison(atom: Atom) -> bool:
+    """Whether ``atom`` compares a cardinality (``|{x : φ}|``, sorted or not) with
+    something, by ``= ≠ < > ≤ ≥``: its ``Number`` operands are numbers, not individuals."""
+    return (atom.predicate in _COMPARISONS and len(atom.args) == 2
+            and any(isinstance(a, (Cardinality, SortedCardinality)) for a in atom.args))
+
+
+def _term_children(node: Node, counting_comparisons: bool = False) -> List[Node]:
+    """The children of ``node`` that can hold a term: the bound of a counting quantifier
+    is not a term, and (with ``counting_comparisons``) neither is a number compared with a
+    cardinality; everything else is read as it is."""
+    if isinstance(node, _COUNT_NODES):
+        return [node.variable, node.formula]
+    if counting_comparisons and isinstance(node, Atom) and _is_counting_comparison(node):
+        return [a for a in node.args if not isinstance(a, Number)]
+    return node._child_nodes()
+
+
+def term_numerals(formula: Node, *, counting_comparisons: bool = False) -> Iterator[Number]:
+    """Every :class:`~unicode_logic_kit.fol.nodes.Number` of ``formula`` that stands in term
+    position, in pre-order: not the bound ``n`` of a ``Count`` / ``SortedCount`` and, with
+    ``counting_comparisons=True``, not a ``Number`` compared with a cardinality."""
+    stack: List[Node] = [formula]
+    while stack:
+        node = stack.pop()
+        if isinstance(node, Number):
+            yield node
+            continue
+        stack.extend(reversed(_term_children(node, counting_comparisons)))
+
+
+def _spellings(numeral: Number, spell: Callable[[Union[int, float]], str]) -> Tuple[str, ...]:
+    """The texts a numeral is written as: the name ``spell`` gives it and its canonical name.
+
+    A value has one spelling (a :class:`~unicode_logic_kit.fol.nodes.Number` stores a float with a
+    whole value as the integer it equals), so the text the kit prints for the node is the
+    canonical name and there is no third text."""
+    value = _plain(numeral.value)
+    return tuple(dict.fromkeys((spell(value), numeral_name(value))))
+
+
+def _clash(where: str, numeral: Number, spelling: str, kind: str, name: str) -> NotImplementedError:
+    return NotImplementedError(
+        f"{where}: the number {_number_text(_plain(numeral.value))} and the {kind} {name!r} are spelled "
+        f"alike ({spelling!r}), so they would be written under one name and be ONE symbol. "
+        "A numeral is a constant of its own, identified by its value (1 and 1.0 are one "
+        "constant), and it is not the constant of the same spelling -- the kit refuses to "
+        f"merge the two. Rename the {kind}.")
+
+
+def _check_names(formulas: Sequence[Node], spelled: Dict[str, Number], where: str) -> None:
+    for formula in formulas:
+        for node in formula.walk():
+            if isinstance(node, (Constant, SortedConstant)):
+                kind = "constant"
+            elif isinstance(node, Function):
+                kind = "function"
+            else:
+                continue
+            numeral = spelled.get(node.name)
+            if numeral is not None:
+                raise _clash(where, numeral, node.name, kind, node.name)
+
+
+def _rewrite(node: Node, spell: Callable[[Union[int, float]], str],
+             counting_comparisons: bool = False) -> Node:
+    if isinstance(node, Number):
+        return Constant(spell(_plain(node.value)))
+    if isinstance(node, _COUNT_NODES):
+        return replace(node, formula=_rewrite(node.formula, spell, counting_comparisons))   # the bound variable holds no numeral
+    if counting_comparisons and isinstance(node, Atom) and _is_counting_comparison(node):
+        return Atom(node.predicate, tuple(a if isinstance(a, Number) else _rewrite(a, spell, True)
+                                          for a in node.args))
+    return node.map_children(lambda child: _rewrite(child, spell, counting_comparisons))
+
+
+def numerals_as_constants(formulas: Iterable[Node], *, where: str,
+                          spell: Callable[[Union[int, float]], str] = numeral_name,
+                          counting_comparisons: bool = False
+                          ) -> Tuple[List[Node], FrozenSet[str]]:
+    """``formulas`` with every numeral in term position written as a constant, and the set
+    of the names of those constants.
+
+    The constant of a numeral is named ``spell(value)``: :func:`numeral_name` unless a writer
+    has its own spelling (the HOL writers spell a numeral ``n1``, ``n2.5``), which is
+    one name per value either way. A formula without a numeral comes back as the very same
+    object. ``where`` is the name of the writer that is calling, which a refusal opens with.
+    With ``counting_comparisons=True`` a ``Number`` that is an operand of a comparison with a
+    cardinality (``|{x : P(x)}| ≥ 2``) is not in term position: it is the number the target
+    compares the count with, and stays a ``Number``.
+
+    Raises:
+        NotImplementedError: a ``Constant``, ``SortedConstant`` or ``Function`` of the
+            formulas is spelled like a numeral of the formulas (``Number(1)`` next to
+            ``Constant('1')``, or ``Number(2.5)`` next to ``Constant('2.5')``; ``Number(1.0)``
+            is ``Number(1)``, so ``Constant('1.0')`` is spelled like no numeral), or a
+            ``Number`` holds a value that is neither an ``int`` nor a ``float``.
+        ValueError: a numeral is ``inf``, ``-inf`` or ``nan``.
+    """
+    formulas = list(formulas)
+    spelled: Dict[str, Number] = {}
+    numerals_of: List[List[Number]] = []
+    for formula in formulas:
+        found = list(term_numerals(formula, counting_comparisons=counting_comparisons))
+        numerals_of.append(found)
+        for numeral in found:
+            for spelling in _spellings(numeral, spell):
+                spelled.setdefault(spelling, numeral)
+    if not spelled:
+        return formulas, frozenset()
+    _check_names(formulas, spelled, where)
+    names = frozenset(spell(_plain(n.value)) for found in numerals_of for n in found)
+    return [_rewrite(f, spell, counting_comparisons) if found else f
+            for f, found in zip(formulas, numerals_of)], names

unicode_logic_kit/fol/_so_nodes.py

@@ -0,0 +1,200 @@
+"""Second-order quantifier AST node: ∀P / ∃P binding a predicate variable.
+
+This node extends the classical FOL AST with second-order quantification over a
+predicate variable. It is purely syntactic in this phase: there is no semantics
+yet, and it rejects the first-order export back-ends (to_z3/to_prover9/to_tptp) —
+second-order quantification is not first-order and is not SMT-expressible, so a
+formula must first be evaluated by the finite-model evaluator (a later phase).
+
+SecondOrderQuantifier is a frozen dataclass (hashable) subclassing Node. The
+bound symbol is a PREDICATE name (uppercase, e.g. ``P``), not an object variable,
+so binding a predicate name leaves the object-level free variables untouched:
+free_variables walks _child_nodes() (only the ``formula`` child) and the scalar
+``predicate``/``arity`` fields are invisible to it. Structural methods
+(to_msfol, _relativize, traversal) are inherited unchanged because
+Node.map_children / Node._child_nodes treat ``formula`` as the single Node child
+and copy the scalar ``type``/``predicate``/``arity`` fields verbatim. The Unicode
+and LaTeX renderers live in _msfl_nodes.py and dispatch by class name;
+serialisation, the tree label, and export-rejection live here.
+
+The bound predicate's ``arity`` is INFERRED from its applications in the body at
+parse time (see ``_second_order_quantifier_transform`` / ``_infer_so_arity`` below);
+it is recorded on the node for the semantics phase but is NOT printed by the
+renderers, because it is
+re-inferred on re-parse — keeping the parse → to_unicode_str → parse round-trip
+stable.
+"""
+
+from dataclasses import dataclass
+
+from ._fol_nodes import Node, Z3Env, NODE_CLASSES, Atom, register_parser_op
+from .naming import ParsingError
+
+
+# Shared message for the export back-ends: second-order quantification has no
+# first-order / SMT encoding.
+_NO_EXPORT = (
+    "Second-order quantification is not first-order and is not SMT-expressible; "
+    "it has no direct to_z3/to_prover9/to_tptp export. Evaluate the formula with "
+    "the finite-model evaluator instead."
+)
+
+
+@dataclass(frozen=True)
+class SecondOrderQuantifier(Node):
+    """A second-order quantifier ∀P / ∃P binding a predicate variable.
+
+    type is "∀" (universal) or "∃" (existential). predicate is the bound
+    predicate-variable NAME (uppercase, as it appears applied in the body).
+    arity is that predicate variable's arity, inferred from its applications in
+    the body (0 for a never-applied / propositional predicate variable).
+    formula is the body.
+
+    Semantics: ∀P φ asserts φ holds for every interpretation of the
+    arity-``arity`` predicate P over the domain; ∃P φ for some interpretation.
+    Evaluation is a later (finite-model) phase.
+    """
+
+    type: str
+    predicate: str
+    arity: int
+    formula: Node
+
+    def _tree_parts(self):
+        """Return the ``∀ P/2`` style label and the single subformula child."""
+        return f"{self.type} {self.predicate}/{self.arity}", [self.formula]
+
+    def to_dict(self):
+        """Serialise to dict with type tag, quantifier type, bound predicate, arity, and body."""
+        return {
+            "_type": "SecondOrderQuantifier",
+            "type": self.type,
+            "predicate": self.predicate,
+            "arity": self.arity,
+            "formula": self.formula.to_dict(),
+        }
+
+    @staticmethod
+    def from_dict(d):
+        """Deserialise a SecondOrderQuantifier from a dict produced by to_dict."""
+        return SecondOrderQuantifier(
+            d["type"],
+            d["predicate"],
+            d["arity"],
+            Node.from_dict(d["formula"]),
+        )
+
+    def to_z3(self, env: Z3Env = None):
+        """Reject Z3 export: second-order quantification is not SMT-expressible."""
+        raise NotImplementedError(_NO_EXPORT)
+
+    def to_prover9(self) -> str:
+        """Reject Prover9 export: second-order quantification is not first-order."""
+        raise NotImplementedError(_NO_EXPORT)
+
+    def to_tptp(self) -> str:
+        """Reject TPTP export: second-order quantification is not first-order."""
+        raise NotImplementedError(_NO_EXPORT)
+
+
+# =========================
+# Registry extension
+# =========================
+
+NODE_CLASSES.update({
+    "SecondOrderQuantifier": SecondOrderQuantifier,
+})
+
+
+# =========================
+# Arity inference + parser registration (second-order mode)
+# =========================
+#
+# The bound predicate variable's arity is not in the surface syntax; it is
+# inferred from the predicate's applications in the body at parse time. These two
+# names (the inference helper and its error) live here, next to the node, and are
+# re-exported by msflparser for backward compatibility.
+
+
+class ConflictingArityError(ParsingError):
+    """Raised when a second-order-bound predicate is applied at conflicting arities.
+
+    Subclasses ParsingError so callers catching the parser's error type also
+    catch this inference-level failure. It is constructed directly (not from a
+    Lark exception), so it bypasses ParsingError.__init__ and sets its own
+    message.
+    """
+
+    def __init__(self, predname: str, arities):
+        arities_str = ", ".join(str(a) for a in arities)
+        message = (
+            f"SYNTAX_ERROR: Second-order predicate variable '{predname}' is "
+            f"applied at conflicting arities ({arities_str}); a bound predicate "
+            f"variable must be used at a single, consistent arity."
+        )
+        self.args = (message,)
+
+    def __str__(self):
+        return self.args[0]
+
+
+def _infer_so_arity(body: Node, predname: str) -> int:
+    """Infer the arity of a second-order-bound predicate from its uses in body.
+
+    Scans ``body`` for ``Atom(predname, args)`` occurrences and returns the
+    common application arity (``len(args)``). All applications of ``predname``
+    must share the same arity, else a ConflictingArityError is raised. A predicate
+    that is never applied has arity 0 (a propositional / Boolean predicate
+    variable).
+
+    Shadowing: an inner ``SecondOrderQuantifier`` that rebinds the SAME predicate
+    name introduces a fresh binding, so its body is NOT scanned for the outer
+    binder's arity — the descent stops at such a rebinder. (An inner binder over a
+    DIFFERENT name is descended into normally.)
+    """
+    arities: set = set()
+
+    def visit(node: Node) -> None:
+        if isinstance(node, SecondOrderQuantifier) and node.predicate == predname:
+            return  # inner binder shadows predname; do not descend into its scope
+        if isinstance(node, Atom) and node.predicate == predname:
+            arities.add(len(node.args))
+        for child in node._child_nodes():
+            visit(child)
+
+    visit(body)
+
+    if len(arities) > 1:
+        raise ConflictingArityError(predname, sorted(arities))
+    return arities.pop() if arities else 0
+
+
+def _second_order_quantifier_transform(items):
+    """Build a SecondOrderQuantifier from [FORALL/EXISTS, PREDICATE, body].
+
+    The PREDICATE token has no terminal handler (raw Token), the body is already a
+    built AST node (Lark transforms bottom-up), and the bound predicate's arity is
+    inferred from its applications in the body.
+    """
+    quant = str(items[0])
+    predname = str(items[1])
+    body = items[2]
+    # Imported at call time, not at module scope: _ho_nodes is defined ON TOP of
+    # this module (it imports SecondOrderQuantifier and _infer_so_arity), so the
+    # dependency only closes once both are loaded — which, by the time any
+    # formula is parsed, they are. In a second-order body infer_bound_arity IS
+    # _infer_so_arity; it differs only where a property actually stands in an
+    # argument slot, which the second-order grammar cannot even express.
+    from ._ho_nodes import infer_bound_arity
+    arity = infer_bound_arity(body, predname)
+    return SecondOrderQuantifier(quant, predname, arity, body)
+
+
+# ∀P / ∃P over a PREDICATE variable, at the quantifier level. The classical
+# first-order quantifier (∀x / ∃x -> quantifier_) is registered for the
+# "second_order" mode in _fol_nodes.py; this adds the second alternative (the
+# grammar's two-alternative quantifier rule).
+register_parser_op(SecondOrderQuantifier, "second_order", "quantifier",
+                   "second_order_quantifier_",
+                   "(FORALL | EXISTS) PREDICATE prefix",
+                   _second_order_quantifier_transform)

unicode_logic_kit/fol/_symbol_names.py

@@ -0,0 +1,81 @@
+"""Shared symbol-name de-collision for the HOL / THF / Isabelle exporters.
+
+Every exporter that sanitises predicate / constant / function names into a target
+syntax must guarantee that **distinct source symbols never collapse to one emitted
+name** — otherwise a non-valid formula could be emitted as a tautology (e.g. ``□Ab →
+□ab`` collapsing to ``□ab → □ab``) or produce duplicate / ill-typed declarations. This
+module factors out the two pieces that were duplicated across those exporters:
+
+- :func:`dedupe` — assign a unique identifier by suffixing ``_2``, ``_3``, …;
+- :class:`SymbolNames` — collect every ``(kind, name, arity)`` symbol of a formula and
+  map each to a unique functor, keyed so a predicate used at two arities is two symbols.
+  Parameterised by the target's base sanitiser and its alias map, so the THF and
+  Isabelle resolvers are one shared implementation.
+"""
+
+from typing import Callable
+
+from .nodes import Atom, Constant, Number, Function, Node
+from ._numeral_symbols import prefixed_numeral_name
+from ._truth_constants import truth_value
+
+
+def dedupe(base: str, used: set) -> str:
+    """Return ``base`` (or ``base_2``, ``base_3``, …) not already in ``used``; mark it used."""
+    name, i = base, 2
+    while name in used:
+        name, i = f"{base}_{i}", i + 1
+    used.add(name)
+    return name
+
+
+class SymbolNames:
+    """Map each distinct ``(kind, name, arity)`` symbol of ``formula`` to a unique name.
+
+    ``sanitize`` turns a raw name into a (possibly non-injective) target identifier;
+    ``alias`` is the set/mapping of names that should claim their natural sanitised form
+    first (e.g. ``=`` → ``feq``), so a user symbol that sanitises to the same stem is
+    pushed off it rather than the other way round. Predicates are keyed by
+    ``(name, arity)`` so a predicate used at two arities yields two distinct symbols.
+
+    ``reserved`` pre-claims the target's OWN fixed identifiers (built-in functors,
+    relation names, defined operators), so a user symbol that sanitises onto one of
+    them is pushed to a suffixed variant instead of silently colliding with — and
+    re-typing — a built-in (e.g. a user predicate named ``r`` colliding with the THF
+    accessibility relation ``r``, which would emit two conflicting declarations).
+    """
+
+    def __init__(self, formula: Node, sanitize: Callable[[str], str], alias=frozenset(),
+                 reserved=frozenset()):
+        preds, consts, funcs = set(), set(), set()
+        for n in formula.walk():
+            if isinstance(n, Atom):
+                if truth_value(n) is not None:
+                    continue    # `$true` / `$false` are written as the target's own constants
+                preds.add((n.predicate, len(n.args)))
+            elif isinstance(n, Constant):
+                consts.add(n.name)
+            elif isinstance(n, Number):
+                # one constant per VALUE (``1`` and ``1.0`` are ``n1``); a writer that must also
+                # refuse a constant spelled ``n1`` rewrites its numerals first
+                # (:func:`~unicode_logic_kit.fol._numeral_symbols.numerals_as_constants`)
+                consts.add(prefixed_numeral_name(n.value))
+            elif isinstance(n, Function):
+                funcs.add((n.name, len(n.args)))
+        used: set = set(reserved)
+        self.pred, self.const, self.func = {}, {}, {}
+        for key in sorted(preds, key=lambda k: (k[0] not in alias, k)):
+            self.pred[key] = dedupe(sanitize(key[0]), used)
+        for name in sorted(consts):
+            self.const[name] = dedupe(sanitize(name), used)
+        for key in sorted(funcs):
+            self.func[key] = dedupe(sanitize(key[0]), used)
+
+    def atom(self, node: Atom) -> str:
+        return self.pred[(node.predicate, len(node.args))]
+
+    def constant(self, name: str) -> str:
+        return self.const[name]
+
+    def function(self, node) -> str:
+        return self.func[(node.name, len(node.args))]