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

unicode_logic_kit/eval/validate.py

@@ -0,0 +1,306 @@
+"""Well-formedness / validity report for (LLM-generated) FOL formulas.
+
+This module provides lightweight, purely structural checks that flag the
+defects most commonly seen in machine-produced first-order formulas:
+
+  * the formula is not a closed sentence (it has free logical variables);
+  * a predicate or function symbol is applied with inconsistent arities;
+  * leftover lambda machinery (Lambda / Application / LambdaVar) that should
+    have been eliminated before the formula was considered final;
+  * (via ``validate_text``) the raw model output does not even parse.
+
+The entry points are:
+
+  * ``validate(node)``      — inspect an already-parsed AST.
+  * ``is_wellformed(node)`` — the headline boolean.
+  * ``validate_text(text)`` — parse raw text first, capturing parse failures.
+
+Nothing here mutates its input; every traversal is read-only.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Tuple
+
+from unicode_logic_kit.fol.nodes import (
+    Node,
+    Variable,
+    Constant,
+    Function,
+    Atom,
+    Lambda,
+    Application,
+    LambdaVar,
+    SortedConstant,
+    free_variables,
+)
+# The node types that carry a sort name (SortedQuantifier, SortedConstant,
+# SortedCount, SortedCardinality): one definition, shared with the reduction to
+# plain FOL, so a sorted node added there is read here too.
+from unicode_logic_kit.fol._msfl_nodes import _SORTED_NODE_TYPES
+# The two truth constants are the logical constants true and false, not predicates
+# of the user's: one definition, shared with every route that reads them.
+from unicode_logic_kit.fol._truth_constants import is_truth_constant
+
+
+# ---------------------------------------------------------------------------
+# Report dataclass
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class ValidationReport:
+    """An immutable summary of the well-formedness checks run on a formula.
+
+    Namespacing of ``arity_conflicts``: predicate and function symbols live in
+    SEPARATE namespaces, so a key is a 2-tuple ``("pred", name)`` or
+    ``("func", name)``. This keeps a predicate ``P`` used as ``P/1`` from
+    falsely conflicting with an unrelated function ``p`` used as ``p/2``.
+
+    Fields:
+
+    ``is_closed``
+        True iff the formula has no free logical variables (it is a
+        sentence). Free occurrences of both ``Variable`` and ``LambdaVar``
+        count against closedness.
+    ``free_variable_names``
+        sorted, de-duplicated names of the free Variable/LambdaVar
+        occurrences.
+    ``arity_consistent``
+        True iff every predicate symbol is used with a single arity and
+        likewise every function symbol.
+    ``arity_conflicts``
+        maps a namespaced symbol key ``("pred"|"func", name)`` to the sorted
+        tuple of the distinct arities observed; only symbols with more than
+        one distinct arity appear.
+    ``has_lambdas``
+        True iff any Lambda / Application / LambdaVar remains.
+    ``predicates`` / ``functions`` / ``constants``
+        sorted ``name/arity`` (predicates, functions) or ``name`` (constants)
+        inventories for quick inspection. The comparison atoms, the arithmetic
+        functions and the two truth constants (``⊤`` / ``$true``, ``⊥`` /
+        ``$false``) are built in and are not listed.
+    ``sorts_used``
+        sorted sort names from every node that carries one: SortedQuantifier,
+        SortedConstant, SortedCount and SortedCardinality.
+    ``parseable``
+        True for ``validate(node)``; ``validate_text`` sets it False on a
+        parse failure.
+    ``error``
+        the parse-error message when ``parseable`` is False, else None.
+    """
+
+    is_closed: bool
+    free_variable_names: Tuple[str, ...]
+    arity_consistent: bool
+    arity_conflicts: Dict[Tuple[str, str], Tuple[int, ...]]
+    has_lambdas: bool
+    predicates: Tuple[str, ...]
+    functions: Tuple[str, ...]
+    constants: Tuple[str, ...]
+    sorts_used: Tuple[str, ...]
+    parseable: bool = True
+    error: Optional[str] = None
+
+    def __str__(self) -> str:
+        """Render a compact, human-readable multi-line summary."""
+        if not self.parseable:
+            return f"ValidationReport(parseable=False, error={self.error!r})"
+        lines = [
+            "ValidationReport(",
+            f"  parseable        = {self.parseable}",
+            f"  is_closed        = {self.is_closed}",
+            f"  free_variables   = {', '.join(self.free_variable_names) or '-'}",
+            f"  arity_consistent = {self.arity_consistent}",
+            f"  arity_conflicts  = {dict(self.arity_conflicts) or '-'}",
+            f"  has_lambdas      = {self.has_lambdas}",
+            f"  predicates       = {', '.join(self.predicates) or '-'}",
+            f"  functions        = {', '.join(self.functions) or '-'}",
+            f"  constants        = {', '.join(self.constants) or '-'}",
+            f"  sorts_used       = {', '.join(self.sorts_used) or '-'}",
+            ")",
+        ]
+        return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Internal inventory collection
+# ---------------------------------------------------------------------------
+
+@dataclass
+class _Inventory:
+    """Mutable scratch collector populated by a single pre-order walk.
+
+    Kept private and never returned; ``validate`` freezes the results into the
+    immutable ``ValidationReport``. Arities are accumulated per namespaced
+    symbol so that conflicts can be detected afterwards.
+    """
+
+    pred_arities: Dict[str, set] = field(default_factory=dict)
+    func_arities: Dict[str, set] = field(default_factory=dict)
+    constants: set = field(default_factory=set)
+    sorts: set = field(default_factory=set)
+    has_lambdas: bool = False
+
+
+# Comparison atoms (=, ≠, <, >, ≤, ≥) and arithmetic functions (+, -, *, /) are
+# built-in operators, not user predicate/function symbols, so they are excluded
+# from the inventories and from arity-consistency checking. So are the two truth
+# constants (the nullary atoms ``$true`` / ``⊤`` and ``$false`` / ``⊥``): a
+# formula that mentions ``⊥`` uses no predicate named ``$false``, and the
+# nullary constant never conflicts with a user predicate spelled like it that
+# takes arguments.
+_BUILTIN_PREDS = frozenset({"=", "≠", "<", ">", "≤", "≥"})
+_BUILTIN_FUNCS = frozenset({"+", "-", "*", "/"})
+
+
+def _collect(node: Node, inv: _Inventory) -> None:
+    """Walk ``node`` in pre-order, recording every symbol into ``inv``.
+
+    Uses ``node.walk()`` (the shared pre-order traversal) so that any future
+    structural node type is covered without changes here. Each occurrence is
+    classified purely by node type; nothing is mutated on the input.
+    """
+    for n in node.walk():
+        if isinstance(n, (Lambda, Application, LambdaVar)):
+            inv.has_lambdas = True
+
+        if isinstance(n, Atom):
+            if n.predicate not in _BUILTIN_PREDS and not is_truth_constant(n):
+                inv.pred_arities.setdefault(n.predicate, set()).add(len(n.args))
+        elif isinstance(n, Function):
+            if n.name not in _BUILTIN_FUNCS:
+                inv.func_arities.setdefault(n.name, set()).add(len(n.args))
+        elif isinstance(n, Constant):
+            inv.constants.add(n.name)
+        elif isinstance(n, SortedConstant):
+            inv.constants.add(n.name)
+            inv.sorts.add(n.sort)
+        elif isinstance(n, _SORTED_NODE_TYPES):
+            # SortedQuantifier, and the sorted counting quantifier and cardinality
+            # term: a sort that occurs only in one of the last two is a sort used.
+            inv.sorts.add(n.sort)
+
+
+def _arity_conflicts(inv: _Inventory) -> Dict[Tuple[str, str], Tuple[int, ...]]:
+    """Return namespaced symbols seen with more than one arity.
+
+    Keys are ``("pred", name)`` / ``("func", name)``; values are the sorted
+    tuple of distinct arities. Symbols with a single consistent arity are
+    omitted, so an empty dict means full arity consistency.
+    """
+    conflicts: Dict[Tuple[str, str], Tuple[int, ...]] = {}
+    for name, arities in inv.pred_arities.items():
+        if len(arities) > 1:
+            conflicts[("pred", name)] = tuple(sorted(arities))
+    for name, arities in inv.func_arities.items():
+        if len(arities) > 1:
+            conflicts[("func", name)] = tuple(sorted(arities))
+    return conflicts
+
+
+def _inventory_strings(arities: Dict[str, set]) -> Tuple[str, ...]:
+    """Render a name->arities map as a sorted tuple of ``name/arity`` strings.
+
+    A symbol with conflicting arities yields one entry per distinct arity (e.g.
+    ``P/1`` and ``P/2``), so the inventory faithfully shows every form seen.
+    """
+    entries = []
+    for name, arity_set in arities.items():
+        for arity in sorted(arity_set):
+            entries.append(f"{name}/{arity}")
+    return tuple(sorted(entries))
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def validate(node: Node) -> ValidationReport:
+    """Run all well-formedness checks on an already-parsed AST.
+
+    The returned report always has ``parseable=True`` (the node was, by
+    definition, parsed to exist). ``validate_text`` is the entry point that can
+    report a parse failure.
+
+    Args:
+        node: any FOL/MSFL ``Node``.
+
+    Returns:
+        A frozen ``ValidationReport`` describing closedness, arity consistency,
+        residual lambda machinery, and symbol inventories.
+    """
+    free = free_variables(node)
+    free_names = tuple(sorted({v.name for v in free}))
+
+    inv = _Inventory()
+    _collect(node, inv)
+
+    conflicts = _arity_conflicts(inv)
+
+    return ValidationReport(
+        is_closed=not free,
+        free_variable_names=free_names,
+        arity_consistent=not conflicts,
+        arity_conflicts=conflicts,
+        has_lambdas=inv.has_lambdas,
+        predicates=_inventory_strings(inv.pred_arities),
+        functions=_inventory_strings(inv.func_arities),
+        constants=tuple(sorted(inv.constants)),
+        sorts_used=tuple(sorted(inv.sorts)),
+        parseable=True,
+        error=None,
+    )
+
+
+def is_wellformed(node: Node) -> bool:
+    """Convenience headline check on an already-parsed AST.
+
+    A node is well-formed iff it is a closed sentence, every symbol is used
+    with a single arity, and no lambda machinery remains.
+    """
+    report = validate(node)
+    return report.is_closed and report.arity_consistent and not report.has_lambdas
+
+
+def validate_text(text: str, parser=None) -> ValidationReport:
+    """Parse ``text`` then validate it, capturing syntactic failures.
+
+    This is the entry point for raw model output: a parse failure
+    (``NamingError`` / ``ParsingError``) yields a report with
+    ``parseable=False`` and the error message in ``error`` rather than raising.
+
+    Args:
+        text: the raw formula string.
+        parser: an ``MSFLParser`` instance (or anything with a compatible
+            ``.parse``). Defaults to a fresh ``MSFLParser()`` (classical FOL
+            mode). Pass ``MSFLParser(many_sorted=True)`` etc. for other modes.
+
+    Returns:
+        On success, a report with ``parseable=True`` plus the ``validate(node)``
+        fields. On a parse failure, a report with ``parseable=False``, the
+        error message in ``error``, and conservative empty/false field values.
+    """
+    # Imported lazily so the AST-only checks (validate / is_wellformed) do not
+    # pull in the parser stack, and to mirror the package's import boundaries.
+    from unicode_logic_kit import MSFLParser, NamingError, ParsingError
+
+    if parser is None:
+        parser = MSFLParser()
+
+    try:
+        node = parser.parse(text)
+    except (NamingError, ParsingError) as exc:
+        return ValidationReport(
+            is_closed=False,
+            free_variable_names=(),
+            arity_consistent=False,
+            arity_conflicts={},
+            has_lambdas=False,
+            predicates=(),
+            functions=(),
+            constants=(),
+            sorts_used=(),
+            parseable=False,
+            error=str(exc),
+        )
+
+    return validate(node)

unicode_logic_kit/fol/__init__.py

@@ -0,0 +1,177 @@
+from .msflparser import MSFLParser
+from .nodes import (
+    Node, Variable, Constant, Number, Function,
+    Atom, Not, And, Or, Xor, Implies, Iff, Quantifier,
+    Count, Measure, Cardinality, Contrast,
+    Z3Env,
+    node_at, replace_at,
+    SortedQuantifier, SortedConstant,
+    SortedCount, SortedCardinality,
+    Nominal, At, Down,
+    Dependence, SlashedExists,
+    Tensor, With, OPlus, LinearImplies, OfCourse, One, Top, Zero,
+    Product, Under, Over,
+    WeakConjunction, WeakDisjunction,
+    StrongConjunction, StrongDisjunction,
+    LukNegation, LukImplication, LukEquivalence,
+    LambdaVar, Lambda, Application,
+    Box, Diamond, Knows, Believes, Says, Wants,
+    EverybodyKnows, DistributedKnowledge, CommonKnowledge,
+    Always, Eventually, Next, Until,
+    Historically, Once, Previous, Since,
+    Obligatory, Permitted,
+    Would, Might,
+    Announce, AnnounceDiamond,
+    SecondOrderQuantifier,
+    PredicateTerm, Signatures, analyse_signatures, MixedSlotError, NestedPropertySlotError,
+    free_variables,
+    substitute, beta_reduce, ReductionLimitError,
+    eta_reduce, beta_eta_normalize,
+    resolve_lambda_scope,
+    to_fol,
+    nonempty_sort_axioms,
+    sort_membership_axioms,
+    sort_axioms,
+    subsort_axioms,
+    signature_axioms,
+)
+from .normalforms import to_nnf, to_pnf, to_cnf, to_dnf, to_tseitin_cnf, skolemize, is_horn
+from .lambda_tools import has_lambdas, eliminate_lambdas, beta_reduce_step, reduce_trace
+from .unification import unify, apply_subst
+from .modal_translation import standard_translation, hybrid_is_valid, down_is_valid
+from .pal import reduce_announcements
+from .latex_input import latex_to_unicode, parse_latex
+from .tptp_input import (
+    parse_tptp, parse_tptp_formula, load_tptp, TptpFormula,
+    parse_tptp_problem, load_tptp_problem, TptpProblem, TptpHeader,
+    parse_tff_problem, load_tff_problem,
+)
+from .qmltp_input import (
+    parse_qmltp_formula, parse_qmltp, load_qmltp,
+    QmltpFormula, QmltpHeader, QmltpStatus, QmltpProblem,
+)
+from .prover9_input import (
+    parse_prover9, parse_prover9_problem, load_prover9, Prover9Formula,
+)
+from .prolog_input import (
+    parse_prolog_clause, parse_prolog_program, load_prolog, PrologParsingError,
+)
+from .prolog_export import (
+    formula_to_prolog_clause, formula_to_prolog_program, PrologExportError,
+)
+from .sanitize import sanitize_names, sanitize_all, NameMapping
+from .verbalize import to_english
+from .derivation import CCGDerivation, reduction_derivation
+from .frames import (
+    AXIOM_ALIASES, FRAMES, FRAME_CONDITIONS, MODAL_AXIOMS,
+    UnsupportedFrameCondition, resolve_frame, geach_axiom,
+    holds_on_finite_frame, modal_axiom, unguarded_frame_axiom,
+)
+from .qml import (
+    qml_translate, qml_axioms, qml_is_valid, qml_equivalent, qml_validity_formula,
+    to_thf_modal, to_isabelle_modal, BARCAN, CONVERSE_BARCAN, QML_BRIDGES,
+)
+from .naming import NamingError, ParsingError
+from .spans import (
+    Span, UNKNOWN, NodeSpans, Path, SpanMap, SpannedFormula,
+    traverse, build_span_map, project_spans,
+)
+from .serialize import SCHEMA_VERSION, serialize, deserialize
+from .casl_export import to_casl_spec, formula_to_casl
+from .casl_import import parse_casl_spec, CaslSpec, CaslImportError
+from .tptp_repair import (
+    repair_tptp_formula, repair_tptp_problem, RepairResult, Issue,
+    ProblemRepairEntry, ProblemRepairResult, TptpRepairError,
+)
+from .dialect_repair import repair_formula, DialectRepairResult
+from .simplify_check import (
+    simplify_for_checking, SimplifyResult,
+    count_from_existential_chain, expand_count,
+)
+from .dialect_detect import detect_dialects
+from .signature import (
+    Signature, PredicateDecl, FunctionDecl, ConstantDecl, inventory_of,
+)
+from ._identifiers import is_variable_name, is_bare_constant, constant_text
+from ._atom_keys import atom_key
+
+__all__ = [
+    # The shared modal frame registry — one table for every modal route.
+    "FRAMES", "FRAME_CONDITIONS", "MODAL_AXIOMS", "AXIOM_ALIASES",
+    "modal_axiom", "resolve_frame", "geach_axiom",
+    "holds_on_finite_frame", "unguarded_frame_axiom",
+    "UnsupportedFrameCondition",
+    "MSFLParser",
+    "Node", "Variable", "Constant", "Number", "Function",
+    "Atom", "Not", "And", "Or", "Xor", "Implies", "Iff", "Quantifier",
+    "Count", "Measure", "Cardinality", "Contrast",
+    "Z3Env",
+    "node_at", "replace_at",
+    "NamingError", "ParsingError",
+    "Span", "UNKNOWN", "NodeSpans", "Path", "SpanMap", "SpannedFormula",
+    "traverse", "build_span_map", "project_spans",
+    "SCHEMA_VERSION", "serialize", "deserialize",
+    "to_casl_spec", "formula_to_casl",
+    "parse_casl_spec", "CaslSpec", "CaslImportError",
+    "repair_tptp_formula", "repair_tptp_problem", "RepairResult", "Issue",
+    "ProblemRepairEntry", "ProblemRepairResult", "TptpRepairError",
+    "repair_formula", "DialectRepairResult",
+    "parse_prolog_clause", "parse_prolog_program", "load_prolog",
+    "PrologParsingError",
+    "formula_to_prolog_clause", "formula_to_prolog_program",
+    "PrologExportError",
+    "simplify_for_checking", "SimplifyResult",
+    "count_from_existential_chain", "expand_count",
+    "detect_dialects",
+    "is_variable_name", "is_bare_constant", "constant_text", "atom_key",
+    "Signature", "PredicateDecl", "FunctionDecl", "ConstantDecl",
+    "inventory_of",
+    "SortedQuantifier", "SortedConstant",
+    "SortedCount", "SortedCardinality",
+    "Nominal", "At", "Down",
+    "Dependence", "SlashedExists",
+    "Tensor", "With", "OPlus", "LinearImplies", "OfCourse", "One", "Top", "Zero",
+    "Product", "Under", "Over",
+    "WeakConjunction", "WeakDisjunction",
+    "StrongConjunction", "StrongDisjunction",
+    "LukNegation", "LukImplication", "LukEquivalence",
+    "LambdaVar", "Lambda", "Application",
+    "Box", "Diamond", "Knows", "Believes", "Says", "Wants",
+    "EverybodyKnows", "DistributedKnowledge", "CommonKnowledge",
+    "Always", "Eventually", "Next", "Until",
+    "Historically", "Once", "Previous", "Since",
+    "Obligatory", "Permitted",
+    "Would", "Might",
+    "Announce", "AnnounceDiamond",
+    "SecondOrderQuantifier",
+    "PredicateTerm", "Signatures", "analyse_signatures", "MixedSlotError", "NestedPropertySlotError",
+    "free_variables",
+    "substitute", "beta_reduce", "ReductionLimitError",
+    "eta_reduce", "beta_eta_normalize",
+    "resolve_lambda_scope",
+    "to_fol",
+    "nonempty_sort_axioms",
+    "sort_membership_axioms",
+    "sort_axioms",
+    "subsort_axioms",
+    "signature_axioms",
+    "to_nnf", "to_pnf", "to_cnf", "to_dnf", "to_tseitin_cnf", "skolemize", "is_horn",
+    "has_lambdas", "eliminate_lambdas", "beta_reduce_step", "reduce_trace",
+    "unify", "apply_subst",
+    "standard_translation", "hybrid_is_valid", "down_is_valid",
+    "reduce_announcements",
+    "latex_to_unicode", "parse_latex",
+    "parse_tptp", "parse_tptp_formula", "load_tptp", "TptpFormula",
+    "parse_tptp_problem", "load_tptp_problem", "TptpProblem", "TptpHeader",
+    "parse_tff_problem", "load_tff_problem",
+    "parse_prover9", "parse_prover9_problem", "load_prover9", "Prover9Formula",
+    "sanitize_names", "sanitize_all", "NameMapping",
+    "to_english",
+    "CCGDerivation", "reduction_derivation",
+    "qml_translate", "qml_axioms", "qml_is_valid", "qml_equivalent",
+    "qml_validity_formula",
+    "to_thf_modal", "to_isabelle_modal", "BARCAN", "CONVERSE_BARCAN",
+    "QML_BRIDGES",
+    "parse_qmltp_formula", "parse_qmltp", "load_qmltp",
+    "QmltpFormula", "QmltpHeader", "QmltpStatus", "QmltpProblem",
+]