unicode-fol-kit 0.2.1__tar.gz → 0.3.1__tar.gz

{unicode_fol_kit-0.2.1 → unicode_fol_kit-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unicode-fol-kit
-Version: 0.2.1
+Version: 0.3.1
 Summary: Parser and toolkit for first-order logic formulas using Unicode operators
 Project-URL: Repository, https://github.com/fvossel/unicode-fol-kit
 Project-URL: Issues, https://github.com/fvossel/unicode-fol-kit/issues
@@ -36,7 +36,14 @@ A Python toolkit for parsing and working with first-order logic (FOL) formulas w
 - **Reductions** — `to_msfol()` lowers Łukasiewicz operators to classical nodes; `to_fol()` further eliminates sorts via relativisation
 - **Serialisation** — convert formulas to/from JSON dictionaries; round-trip safe
 - **Tree view** — render any formula as a readable ASCII tree
+- **Unicode round-trip** — `to_unicode_str()` renders any node back to a parseable Unicode formula; re-parsing in the matching mode yields a structurally equal AST
+- **LaTeX export** — `to_latex()` renders any node as LaTeX math-mode markup, with the same precedence-aware parenthesisation as the Unicode renderer
+- **Normal forms** — `to_nnf()`, `to_pnf()`, `to_cnf()` (equivalence-preserving), and `skolemize()` (satisfiability-preserving) for classical FOL
+- **Horn check** — `is_horn()` reports whether a formula's clausal form consists of Horn clauses
+- **Traversal API** — `walk()`, `subformulas()`, `atoms()`, `variables()`, `count()`, `depth()` on every node
+- **Graphviz export** — `to_dot()` renders the AST as a Graphviz DOT digraph
 - **Z3 export** — translate formulas to Z3 expressions for SMT solving
+- **Satisfiability / validity / models** — `is_satisfiable()`, `is_valid()`, and `get_model()` (counterexample extraction) via Z3
 - **Prover9 export** — translate formulas to Prover9 syntax for automated theorem proving
 - **TPTP export** — translate formulas to TPTP syntax
 - **Equivalence checking** — check if two formulas are logically equivalent via Z3
@@ -154,14 +161,67 @@ print(formula.tree_str())
 #         └── Variable: x
 ```
 
+### Round-trip to Unicode
+
+`to_unicode_str()` is the inverse of parsing: it renders any node back to a Unicode formula string. Re-parsing that string in the same mode reproduces a structurally equal AST. The renderer is precedence-aware and only inserts the parentheses the grammar requires — including the no-mixing rule for same-level connectives and the tight-binding rule for quantifiers.
+
+```python
+parser = MSFLParser()
+
+ast = parser.parse("∀x P(x) ∧ Q(x)")
+ast.to_unicode_str()              # '∀x P(x) ∧ Q(x)'
+parser.parse(ast.to_unicode_str()) == ast   # True
+
+# Precedence-driven parentheses are reconstructed, not the original spelling:
+parser.parse("((P(x) ∧ Q(x)))").to_unicode_str()   # 'P(x) ∧ Q(x)'
+parser.parse("P(x) ∧ (Q(x) ∨ R(x))").to_unicode_str()  # 'P(x) ∧ (Q(x) ∨ R(x))'
+```
+
+Available on every node, so subformulas render too. The output targets parseable
+ASTs; alpha-renamed variables introduced by `beta_reduce` (e.g. `x_0`) are not
+valid surface tokens and will not round-trip.
+
 ### Exporting to other formats
 
 ```python
 formula.to_prover9()   # '(all x (Human(x) -> Mortal(x)))'
 formula.to_tptp()      # '(![X]: (human(X) => mortal(X)))'
+formula.to_latex()     # '\\forall x\\, (Human(x) \\rightarrow Mortal(x))'
 formula.to_dict()      # JSON-serialisable dict
 ```
 
+`to_latex()` uses the same precedence-aware parenthesisation as `to_unicode_str()`. Sorts render as `\forall x{:}\mathrm{Human}\,`; strong Łukasiewicz operators as `\otimes` / `\oplus`. Symbol and predicate names are emitted verbatim (no `\mathrm` wrapping).
+
+### Traversal and inspection
+
+Every node exposes a small traversal API:
+
+```python
+f = MSFLParser().parse("∀x (Human(x) → Mortal(x))")
+
+list(f.walk())        # pre-order: every node and descendant
+f.subformulas()       # every sub-node that is a formula (terms excluded)
+f.atoms()             # [Atom("Human", …), Atom("Mortal", …)]
+f.variables()         # {Variable("x")}  — set of logical variables (free + bound)
+f.count()             # total node count
+f.count(Atom)         # nodes of a given type
+f.depth()             # tree height (a leaf has depth 1)
+```
+
+### Graphviz export
+
+```python
+print(f.to_dot())
+# digraph AST {
+#   node [shape=box];
+#   n0 [label="∀ x"];
+#   n1 [label="→"];
+#   ...
+# }
+```
+
+`to_dot()` mirrors the `tree_str()` view (the quantifier's bound variable is folded into its node label). Pipe the output to `dot -Tpng` to render an image.
+
 ### Serialisation
 
 ```python
@@ -271,6 +331,38 @@ classical = to_fol(formula)
 classical_with_facts = to_fol(formula, include_sort_facts=True)
 ```
 
+### Normal forms
+
+`to_nnf()`, `to_pnf()`, `to_cnf()`, and `skolemize()` operate on classical FOL. They accept FOL, MSFOL, MSFL, and FL inputs — sorts and Łukasiewicz operators are reduced via `to_fol()` first. (Lambda terms must be beta-reduced and lambda-eliminated beforehand.)
+
+```python
+from unicode_fol_kit import MSFLParser, to_nnf, to_pnf, to_cnf, skolemize
+
+parser = MSFLParser()
+
+to_nnf(parser.parse("P → Q"))        # eliminates → ↔ ⊕, pushes ¬ down to atoms
+to_pnf(parser.parse("∀x P(x) ∧ ∃y Q(y)"))   # quantifier prefix + quantifier-free matrix
+to_cnf(parser.parse("P ∨ (Q ∧ R)"))  # matrix as a conjunction of clauses
+skolemize(parser.parse("∀x ∃y Loves(x, y)"))
+# ∀v0 Loves(v0, sk0(v0)) — the existential becomes a Skolem function of x
+```
+
+- `to_nnf` / `to_pnf` / `to_cnf` are **equivalence-preserving**: the result is logically equivalent to the (classical) input.
+- `skolemize` is **satisfiability-preserving** (not equivalence-preserving): existentials are replaced by Skolem terms over the universals in scope, and the universal prefix is retained. Bound variables are standardised apart (renamed to fresh `v0, v1, …`); Skolem symbols are named `sk0, sk1, …`.
+
+### Horn check
+
+`is_horn()` reports whether a formula's clausal form consists of Horn clauses — each clause has at most one positive literal. The formula is skolemised, its universal prefix dropped, and the matrix put into CNF before the clauses are checked.
+
+```python
+from unicode_fol_kit import MSFLParser, is_horn
+
+parser = MSFLParser()
+is_horn(parser.parse("∀x (Body(x) → Head(x))"))     # True  (definite clause)
+is_horn(parser.parse("P → (Q ∧ R)"))                # True  (splits into two Horn clauses)
+is_horn(parser.parse("P → (Q ∨ R)"))                # False (clause has two positive literals)
+```
+
 ### Equivalence checking (Z3)
 
 ```python
@@ -283,6 +375,26 @@ f2 = parser.parse("¬P(x) ∨ ¬Q(x)")
 formulas_are_equivalent(f1, f2)  # True
 ```
 
+### Satisfiability, validity, and counterexamples (Z3)
+
+```python
+from unicode_fol_kit import MSFLParser, is_satisfiable, is_valid, get_model, Not
+
+parser = MSFLParser()
+
+is_satisfiable(parser.parse("P ∧ Q"))     # True
+is_satisfiable(parser.parse("P ∧ ¬P"))    # False
+is_valid(parser.parse("P ∨ ¬P"))          # True
+
+get_model(parser.parse("P ∧ Q"))          # {'P': 'True', 'Q': 'True'}
+get_model(parser.parse("P ∧ ¬P"))         # None  (unsatisfiable)
+
+# Counterexample to a claimed equivalence: a model of its negation.
+get_model(Not(parser.parse("P ↔ Q")))     # e.g. {'P': 'True', 'Q': 'False'}
+```
+
+`get_model` returns a dict mapping each Z3 declaration (constants, uninterpreted predicates/functions) to its interpretation, or `None` when the formula is unsatisfiable or Z3 returns `unknown` within the timeout.
+
 ### Entailment checking (Prover9)
 
 ```python
@@ -560,15 +672,15 @@ parser.parse("(λP. P(x))(Q)")
 ### A complete MSFOL example
 
 ```text
-∀x:Person ∀y:Person (Knows(x, y) ∧ Trusted(y:Person)) → Shares(x, y)
+∀x:Person ∀y:Person (Knows(x, y) ∧ Trusted(y)) → Shares(x, y)
 ```
 
 ### A complete MSFL example
 
 ```text
 ∀x:Patient ∀y:Treatment
-    (Effective(y:Treatment) ⊗ Tolerable(x:Patient, y:Treatment))
-    → Recommended(x:Patient, y:Treatment)
+    (Effective(y) ⊗ Tolerable(x, y))
+    → Recommended(x, y)
 ```
 
 ### A complete FL example

{unicode_fol_kit-0.2.1 → unicode_fol_kit-0.3.1}/README.md

@@ -12,7 +12,14 @@ A Python toolkit for parsing and working with first-order logic (FOL) formulas w
 - **Reductions** — `to_msfol()` lowers Łukasiewicz operators to classical nodes; `to_fol()` further eliminates sorts via relativisation
 - **Serialisation** — convert formulas to/from JSON dictionaries; round-trip safe
 - **Tree view** — render any formula as a readable ASCII tree
+- **Unicode round-trip** — `to_unicode_str()` renders any node back to a parseable Unicode formula; re-parsing in the matching mode yields a structurally equal AST
+- **LaTeX export** — `to_latex()` renders any node as LaTeX math-mode markup, with the same precedence-aware parenthesisation as the Unicode renderer
+- **Normal forms** — `to_nnf()`, `to_pnf()`, `to_cnf()` (equivalence-preserving), and `skolemize()` (satisfiability-preserving) for classical FOL
+- **Horn check** — `is_horn()` reports whether a formula's clausal form consists of Horn clauses
+- **Traversal API** — `walk()`, `subformulas()`, `atoms()`, `variables()`, `count()`, `depth()` on every node
+- **Graphviz export** — `to_dot()` renders the AST as a Graphviz DOT digraph
 - **Z3 export** — translate formulas to Z3 expressions for SMT solving
+- **Satisfiability / validity / models** — `is_satisfiable()`, `is_valid()`, and `get_model()` (counterexample extraction) via Z3
 - **Prover9 export** — translate formulas to Prover9 syntax for automated theorem proving
 - **TPTP export** — translate formulas to TPTP syntax
 - **Equivalence checking** — check if two formulas are logically equivalent via Z3
@@ -130,14 +137,67 @@ print(formula.tree_str())
 #         └── Variable: x
 ```
 
+### Round-trip to Unicode
+
+`to_unicode_str()` is the inverse of parsing: it renders any node back to a Unicode formula string. Re-parsing that string in the same mode reproduces a structurally equal AST. The renderer is precedence-aware and only inserts the parentheses the grammar requires — including the no-mixing rule for same-level connectives and the tight-binding rule for quantifiers.
+
+```python
+parser = MSFLParser()
+
+ast = parser.parse("∀x P(x) ∧ Q(x)")
+ast.to_unicode_str()              # '∀x P(x) ∧ Q(x)'
+parser.parse(ast.to_unicode_str()) == ast   # True
+
+# Precedence-driven parentheses are reconstructed, not the original spelling:
+parser.parse("((P(x) ∧ Q(x)))").to_unicode_str()   # 'P(x) ∧ Q(x)'
+parser.parse("P(x) ∧ (Q(x) ∨ R(x))").to_unicode_str()  # 'P(x) ∧ (Q(x) ∨ R(x))'
+```
+
+Available on every node, so subformulas render too. The output targets parseable
+ASTs; alpha-renamed variables introduced by `beta_reduce` (e.g. `x_0`) are not
+valid surface tokens and will not round-trip.
+
 ### Exporting to other formats
 
 ```python
 formula.to_prover9()   # '(all x (Human(x) -> Mortal(x)))'
 formula.to_tptp()      # '(![X]: (human(X) => mortal(X)))'
+formula.to_latex()     # '\\forall x\\, (Human(x) \\rightarrow Mortal(x))'
 formula.to_dict()      # JSON-serialisable dict
 ```
 
+`to_latex()` uses the same precedence-aware parenthesisation as `to_unicode_str()`. Sorts render as `\forall x{:}\mathrm{Human}\,`; strong Łukasiewicz operators as `\otimes` / `\oplus`. Symbol and predicate names are emitted verbatim (no `\mathrm` wrapping).
+
+### Traversal and inspection
+
+Every node exposes a small traversal API:
+
+```python
+f = MSFLParser().parse("∀x (Human(x) → Mortal(x))")
+
+list(f.walk())        # pre-order: every node and descendant
+f.subformulas()       # every sub-node that is a formula (terms excluded)
+f.atoms()             # [Atom("Human", …), Atom("Mortal", …)]
+f.variables()         # {Variable("x")}  — set of logical variables (free + bound)
+f.count()             # total node count
+f.count(Atom)         # nodes of a given type
+f.depth()             # tree height (a leaf has depth 1)
+```
+
+### Graphviz export
+
+```python
+print(f.to_dot())
+# digraph AST {
+#   node [shape=box];
+#   n0 [label="∀ x"];
+#   n1 [label="→"];
+#   ...
+# }
+```
+
+`to_dot()` mirrors the `tree_str()` view (the quantifier's bound variable is folded into its node label). Pipe the output to `dot -Tpng` to render an image.
+
 ### Serialisation
 
 ```python
@@ -247,6 +307,38 @@ classical = to_fol(formula)
 classical_with_facts = to_fol(formula, include_sort_facts=True)
 ```
 
+### Normal forms
+
+`to_nnf()`, `to_pnf()`, `to_cnf()`, and `skolemize()` operate on classical FOL. They accept FOL, MSFOL, MSFL, and FL inputs — sorts and Łukasiewicz operators are reduced via `to_fol()` first. (Lambda terms must be beta-reduced and lambda-eliminated beforehand.)
+
+```python
+from unicode_fol_kit import MSFLParser, to_nnf, to_pnf, to_cnf, skolemize
+
+parser = MSFLParser()
+
+to_nnf(parser.parse("P → Q"))        # eliminates → ↔ ⊕, pushes ¬ down to atoms
+to_pnf(parser.parse("∀x P(x) ∧ ∃y Q(y)"))   # quantifier prefix + quantifier-free matrix
+to_cnf(parser.parse("P ∨ (Q ∧ R)"))  # matrix as a conjunction of clauses
+skolemize(parser.parse("∀x ∃y Loves(x, y)"))
+# ∀v0 Loves(v0, sk0(v0)) — the existential becomes a Skolem function of x
+```
+
+- `to_nnf` / `to_pnf` / `to_cnf` are **equivalence-preserving**: the result is logically equivalent to the (classical) input.
+- `skolemize` is **satisfiability-preserving** (not equivalence-preserving): existentials are replaced by Skolem terms over the universals in scope, and the universal prefix is retained. Bound variables are standardised apart (renamed to fresh `v0, v1, …`); Skolem symbols are named `sk0, sk1, …`.
+
+### Horn check
+
+`is_horn()` reports whether a formula's clausal form consists of Horn clauses — each clause has at most one positive literal. The formula is skolemised, its universal prefix dropped, and the matrix put into CNF before the clauses are checked.
+
+```python
+from unicode_fol_kit import MSFLParser, is_horn
+
+parser = MSFLParser()
+is_horn(parser.parse("∀x (Body(x) → Head(x))"))     # True  (definite clause)
+is_horn(parser.parse("P → (Q ∧ R)"))                # True  (splits into two Horn clauses)
+is_horn(parser.parse("P → (Q ∨ R)"))                # False (clause has two positive literals)
+```
+
 ### Equivalence checking (Z3)
 
 ```python
@@ -259,6 +351,26 @@ f2 = parser.parse("¬P(x) ∨ ¬Q(x)")
 formulas_are_equivalent(f1, f2)  # True
 ```
 
+### Satisfiability, validity, and counterexamples (Z3)
+
+```python
+from unicode_fol_kit import MSFLParser, is_satisfiable, is_valid, get_model, Not
+
+parser = MSFLParser()
+
+is_satisfiable(parser.parse("P ∧ Q"))     # True
+is_satisfiable(parser.parse("P ∧ ¬P"))    # False
+is_valid(parser.parse("P ∨ ¬P"))          # True
+
+get_model(parser.parse("P ∧ Q"))          # {'P': 'True', 'Q': 'True'}
+get_model(parser.parse("P ∧ ¬P"))         # None  (unsatisfiable)
+
+# Counterexample to a claimed equivalence: a model of its negation.
+get_model(Not(parser.parse("P ↔ Q")))     # e.g. {'P': 'True', 'Q': 'False'}
+```
+
+`get_model` returns a dict mapping each Z3 declaration (constants, uninterpreted predicates/functions) to its interpretation, or `None` when the formula is unsatisfiable or Z3 returns `unknown` within the timeout.
+
 ### Entailment checking (Prover9)
 
 ```python
@@ -536,15 +648,15 @@ parser.parse("(λP. P(x))(Q)")
 ### A complete MSFOL example
 
 ```text
-∀x:Person ∀y:Person (Knows(x, y) ∧ Trusted(y:Person)) → Shares(x, y)
+∀x:Person ∀y:Person (Knows(x, y) ∧ Trusted(y)) → Shares(x, y)
 ```
 
 ### A complete MSFL example
 
 ```text
 ∀x:Patient ∀y:Treatment
-    (Effective(y:Treatment) ⊗ Tolerable(x:Patient, y:Treatment))
-    → Recommended(x:Patient, y:Treatment)
+    (Effective(y) ⊗ Tolerable(x, y))
+    → Recommended(x, y)
 ```
 
 ### A complete FL example

{unicode_fol_kit-0.2.1 → unicode_fol_kit-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "unicode-fol-kit"
-version = "0.2.1"
+version = "0.3.1"
 description = "Parser and toolkit for first-order logic formulas using Unicode operators"
 readme = "README.md"
 license = { text = "MIT" }

{unicode_fol_kit-0.2.1 → unicode_fol_kit-0.3.1}/unicode_fol_kit/__init__.py

@@ -14,10 +14,14 @@ from .fol import (
     eta_reduce, beta_eta_normalize,
     resolve_lambda_scope,
     to_fol,
+    to_nnf, to_pnf, to_cnf, skolemize, is_horn,
+)
+from .atp import (
+    formulas_are_equivalent, check_logical_entailment,
+    is_satisfiable, is_valid, get_model,
 )
-from .atp import formulas_are_equivalent, check_logical_entailment
 
-__version__ = "0.2.1"
+__version__ = "0.3.1"
 
 __all__ = [
     "MSFLParser",
@@ -36,4 +40,6 @@ __all__ = [
     "eta_reduce", "beta_eta_normalize",
     "resolve_lambda_scope",
     "to_fol",
+    "to_nnf", "to_pnf", "to_cnf", "skolemize", "is_horn",
+    "is_satisfiable", "is_valid", "get_model",
 ]

unicode_fol_kit-0.3.1/unicode_fol_kit/atp/__init__.py

@@ -0,0 +1,9 @@
+from .z3_equivalence import formulas_are_equivalent
+from .prover9_entailment import check_logical_entailment
+from .z3_models import is_satisfiable, is_valid, get_model
+
+__all__ = [
+    "formulas_are_equivalent",
+    "check_logical_entailment",
+    "is_satisfiable", "is_valid", "get_model",
+]

unicode_fol_kit-0.3.1/unicode_fol_kit/atp/z3_models.py

@@ -0,0 +1,45 @@
+"""Satisfiability / validity checks and model (counterexample) extraction via Z3."""
+
+from ..fol.nodes import Node
+from z3 import Solver, sat, unsat, Not
+
+
+def is_satisfiable(formula: Node, timeout: int = 10000) -> bool:
+    """Return True if the formula has a model (Z3 reports sat).
+
+    A Z3 ``unknown`` result (e.g. on hard quantified formulas hitting the
+    timeout) is treated as not-known-satisfiable and returns False.
+    """
+    solver = Solver()
+    solver.set("timeout", timeout)
+    solver.set("random_seed", 42)
+    solver.add(formula.to_z3())
+    return solver.check() == sat
+
+
+def is_valid(formula: Node, timeout: int = 10000) -> bool:
+    """Return True if the formula is valid, i.e. its negation is unsatisfiable."""
+    solver = Solver()
+    solver.set("timeout", timeout)
+    solver.set("random_seed", 42)
+    solver.add(Not(formula.to_z3()))
+    return solver.check() == unsat
+
+
+def get_model(formula: Node, timeout: int = 10000):
+    """Return a satisfying assignment as a dict, or None if unsat/unknown.
+
+    The dict maps each Z3 declaration name (constants, uninterpreted
+    functions/predicates) to the string form of its interpretation. For an
+    invalid equivalence or entailment, ``get_model(Not(...))`` yields the
+    concrete counterexample. Returns None when the formula is unsatisfiable or
+    Z3 cannot decide it within the timeout.
+    """
+    solver = Solver()
+    solver.set("timeout", timeout)
+    solver.set("random_seed", 42)
+    solver.add(formula.to_z3())
+    if solver.check() != sat:
+        return None
+    model = solver.model()
+    return {str(decl.name()): str(model[decl]) for decl in model.decls()}

{unicode_fol_kit-0.2.1 → unicode_fol_kit-0.3.1}/unicode_fol_kit/fol/__init__.py

@@ -14,6 +14,7 @@ from .nodes import (
     resolve_lambda_scope,
     to_fol,
 )
+from .normalforms import to_nnf, to_pnf, to_cnf, skolemize, is_horn
 from .naming import NamingError, ParsingError
 
 __all__ = [
@@ -32,4 +33,5 @@ __all__ = [
     "eta_reduce", "beta_eta_normalize",
     "resolve_lambda_scope",
     "to_fol",
+    "to_nnf", "to_pnf", "to_cnf", "skolemize", "is_horn",
 ]

{unicode_fol_kit-0.2.1 → unicode_fol_kit-0.3.1}/unicode_fol_kit/fol/_fol_nodes.py

@@ -108,6 +108,28 @@ class Node:
                 children.extend(c for c in value if isinstance(c, Node))
         return label, children
 
+    def to_unicode_str(self) -> str:
+        """Render this node back to a parseable Unicode formula string.
+
+        The result, re-parsed in the matching MSFLParser mode, yields a
+        structurally equal AST (parser round-trip). The renderer lives in
+        _msfl_nodes.py (imported lazily to avoid a circular import) because it
+        dispatches over both the FOL nodes here and the MSFL/lambda nodes there.
+        """
+        from ._msfl_nodes import _uni
+        return _uni(self)
+
+    def to_latex(self) -> str:
+        """Render this node as a LaTeX math-mode string (no surrounding $…$).
+
+        Uses the same precedence-driven parenthesisation as to_unicode_str.
+        Symbol/function/predicate names are emitted verbatim (no \\mathrm
+        wrapping). The renderer lives in _msfl_nodes.py (imported lazily) so it
+        can dispatch over both FOL and MSFL/lambda nodes.
+        """
+        from ._msfl_nodes import _latex
+        return _latex(self)
+
     def tree_str(self) -> str:
         """Render the AST as a multi-line ASCII tree using ├──/└── connectors."""
         label, children = self._tree_parts()
@@ -158,6 +180,88 @@ class Node:
                 new_kwargs[f.name] = val
         return type(self)(**new_kwargs)
 
+    # ---------------------------------------------------------------
+    # Traversal / inspection API
+    # ---------------------------------------------------------------
+
+    def _child_nodes(self) -> List["Node"]:
+        """Return the immediate Node-valued children, in declaration order.
+
+        Covers both single Node fields and lists of Nodes. Quantifier exposes
+        its bound variable here (it is a Node); for a rendering-oriented child
+        view see _tree_parts.
+        """
+        result: List["Node"] = []
+        for f in fields(self):
+            val = getattr(self, f.name)
+            if isinstance(val, Node):
+                result.append(val)
+            elif isinstance(val, list):
+                result.extend(c for c in val if isinstance(c, Node))
+        return result
+
+    def walk(self):
+        """Yield this node and every descendant in pre-order (depth-first)."""
+        yield self
+        for child in self._child_nodes():
+            yield from child.walk()
+
+    def subformulas(self):
+        """Yield every sub-node that is a formula (i.e. not an atomic term).
+
+        Terms (Variable, Constant, Number, Function, SortedConstant, LambdaVar)
+        are excluded; everything else reachable is returned in pre-order.
+        """
+        return [n for n in self.walk() if type(n).__name__ not in _TERM_NAMES]
+
+    def atoms(self):
+        """Return all Atom nodes in pre-order (duplicates kept; comparisons included)."""
+        return [n for n in self.walk() if isinstance(n, Atom)]
+
+    def variables(self):
+        """Return the set of logical Variable nodes occurring anywhere (free and bound)."""
+        return {n for n in self.walk() if isinstance(n, Variable)}
+
+    def count(self, cls=None) -> int:
+        """Count nodes in the tree; if cls is given, only nodes of that type."""
+        return sum(1 for n in self.walk() if cls is None or isinstance(n, cls))
+
+    def depth(self) -> int:
+        """Return the height of the tree; a leaf node has depth 1."""
+        children = self._child_nodes()
+        return 1 + max((c.depth() for c in children), default=0)
+
+    def to_dot(self) -> str:
+        """Render the AST as a Graphviz DOT digraph string.
+
+        Uses the same label/child view as tree_str (the bound variable of a
+        quantifier is folded into its node label, not shown as a child), so the
+        graph mirrors the ASCII tree. No external dependency: returns the source.
+        """
+        lines = ["digraph AST {", "  node [shape=box];"]
+        counter = [0]
+
+        def emit(node: "Node") -> int:
+            my_id = counter[0]
+            counter[0] += 1
+            label, children = node._tree_parts()
+            safe = label.replace("\\", "\\\\").replace('"', '\\"')
+            lines.append(f'  n{my_id} [label="{safe}"];')
+            for child in children:
+                child_id = emit(child)
+                lines.append(f"  n{my_id} -> n{child_id};")
+            return my_id
+
+        emit(self)
+        lines.append("}")
+        return "\n".join(lines)
+
+
+# Term node class names — used by Node.subformulas to exclude atomic terms.
+_TERM_NAMES = frozenset({
+    "Variable", "Constant", "Number", "Function", "SortedConstant", "LambdaVar",
+})
+
 
 # =========================
 # Term Nodes

{unicode_fol_kit-0.2.1 → unicode_fol_kit-0.3.1}/unicode_fol_kit/fol/_msfl_nodes.py

@@ -893,6 +893,296 @@ def resolve_lambda_scope(node: Node) -> Node:
     return _resolve(node, frozenset())
 
 
+# =========================
+# Unicode rendering (parser round-trip)
+# =========================
+#
+# These functions render any node back to a Unicode formula string that, when
+# re-parsed in the matching MSFLParser mode, yields a structurally equal AST.
+# Dispatch is by class name so this single block covers both the FOL nodes
+# (from _fol_nodes.py) and the MSFL/lambda nodes defined above.
+#
+# Formula precedence — higher binds tighter — mirrors the grammar layering
+# (biimplication < implication < same-level binary < prefix < atomic):
+_UNI_FORMULA_PREC = {
+    "Lambda": 0, "Application": 0,
+    "Iff": 1, "LukEquivalence": 1,
+    "Implies": 2, "LukImplication": 2,
+    "And": 3, "Or": 3, "Xor": 3,
+    "WeakConjunction": 3, "WeakDisjunction": 3,
+    "StrongConjunction": 3, "StrongDisjunction": 3,
+    "Not": 4, "LukNegation": 4,
+    "Quantifier": 4, "SortedQuantifier": 4,
+}
+
+# Binary connective glyphs. Xor and StrongDisjunction share ⊕ (disjoint modes);
+# the weak/strong and classical operators reuse ∧ ∨ → ↔ by class identity.
+_UNI_BINSYM = {
+    "And": "∧", "Or": "∨", "Xor": "⊕",
+    "Implies": "→", "Iff": "↔",
+    "WeakConjunction": "∧", "WeakDisjunction": "∨",
+    "StrongConjunction": "⊗", "StrongDisjunction": "⊕",
+    "LukImplication": "→", "LukEquivalence": "↔",
+}
+
+# The same-level binary group (grammar precedence 2): cannot be mixed without
+# parentheses, and chains are left-folded.
+_UNI_LEVEL2 = frozenset({
+    "And", "Or", "Xor",
+    "WeakConjunction", "WeakDisjunction",
+    "StrongConjunction", "StrongDisjunction",
+})
+
+_UNI_INFIX_COMPARE = frozenset({"=", "≠", "<", ">", "≤", "≥"})
+_UNI_ARITH_OPS = frozenset({"+", "-", "*", "/"})
+
+
+def _uni_prec(node) -> int:
+    """Formula precedence of a node; atomic nodes (atoms, terms) default to 5."""
+    return _UNI_FORMULA_PREC.get(type(node).__name__, 5)
+
+
+def _uni_wrap(node, min_prec: int) -> str:
+    """Render node, parenthesising it when it binds looser than the slot allows."""
+    s = _uni(node)
+    return f"({s})" if _uni_prec(node) < min_prec else s
+
+
+def _uni_level2_child(node, parent_cls: str, side: str) -> str:
+    """Render a same-level (∧ ∨ ⊗ ⊕) operand with no-mixing / left-assoc parens.
+
+    Left operand: a same-class chain stays flat (a ∧ b ∧ c); a different
+    same-level operator is parenthesised (no silent mixing). Right operand:
+    any same-level node is parenthesised, since the parser left-folds chains.
+    """
+    s = _uni(node)
+    p = _uni_prec(node)
+    if side == "left":
+        need = p < 3 or (p == 3 and type(node).__name__ != parent_cls)
+    else:
+        need = p < 4
+    return f"({s})" if need else s
+
+
+def _uni_atom(node) -> str:
+    """Render an Atom: infix comparison, nullary predicate, or applied predicate."""
+    if node.predicate in _UNI_INFIX_COMPARE and len(node.args) == 2:
+        return f"{_uni_term(node.args[0])} {node.predicate} {_uni_term(node.args[1])}"
+    if not node.args:
+        return node.predicate
+    return f"{node.predicate}(" + ", ".join(_uni_term(a) for a in node.args) + ")"
+
+
+def _uni_term_prec(node) -> int:
+    """Arithmetic term precedence: + - → 1, * / → 2, everything atomic → 3."""
+    if (type(node).__name__ == "Function"
+            and node.name in _UNI_ARITH_OPS and len(node.args) == 2):
+        return 2 if node.name in ("*", "/") else 1
+    return 3
+
+
+def _uni_term_wrap(node, parent_prec: int, is_right: bool) -> str:
+    """Render an arithmetic operand, parenthesising per left-associative precedence."""
+    s = _uni_term(node)
+    p = _uni_term_prec(node)
+    need = p < parent_prec or (p == parent_prec and is_right)
+    return f"({s})" if need else s
+
+
+def _uni_spine(node):
+    """Uncurry a left-nested Application into (head, [arg0, arg1, …])."""
+    args = []
+    n = node
+    while isinstance(n, Application):
+        args.append(n.arg)
+        n = n.func
+    args.reverse()
+    return n, args
+
+
+def _uni_term(node) -> str:
+    """Render a node occurring in term (argument) position.
+
+    Higher-order applications produced by scope resolution (e.g. foo(x) under
+    λfoo, parsed as a Function then rewritten to Application(LambdaVar, …)) are
+    rendered back as function-call syntax so they re-parse and re-resolve to the
+    same node.
+    """
+    cls = type(node).__name__
+    if cls in ("Variable", "LambdaVar", "Constant"):
+        return node.name
+    if cls == "Number":
+        return str(node.value)
+    if cls == "SortedConstant":
+        return f"{node.name}:{node.sort}"
+    if cls == "Function":
+        if node.name in _UNI_ARITH_OPS and len(node.args) == 2:
+            p = _uni_term_prec(node)
+            left = _uni_term_wrap(node.args[0], p, is_right=False)
+            right = _uni_term_wrap(node.args[1], p, is_right=True)
+            return f"{left} {node.name} {right}"
+        return f"{node.name}(" + ", ".join(_uni_term(a) for a in node.args) + ")"
+    if cls == "Application":
+        head, args = _uni_spine(node)
+        if isinstance(head, (LambdaVar, Variable, Constant)) and args:
+            return f"{head.name}(" + ", ".join(_uni_term(a) for a in args) + ")"
+        return f"({_uni(node.func)})({_uni(node.arg)})"
+    # Atoms / other formula nodes are not valid terms; best-effort fall-through.
+    return _uni(node)
+
+
+def _uni(node) -> str:
+    """Render node as a formula-level Unicode string (no surrounding parens)."""
+    cls = type(node).__name__
+
+    if cls in ("Variable", "LambdaVar", "Constant", "Number", "SortedConstant", "Function"):
+        return _uni_term(node)
+    if cls == "Atom":
+        return _uni_atom(node)
+
+    if cls in ("Not", "LukNegation"):
+        return "¬" + _uni_wrap(node.formula, 4)
+
+    if cls == "Quantifier":
+        return f"{node.type}{node.variable.name} " + _uni_wrap(node.formula, 4)
+    if cls == "SortedQuantifier":
+        return f"{node.type}{node.variable.name}:{node.sort} " + _uni_wrap(node.formula, 4)
+
+    if cls in ("Iff", "LukEquivalence"):
+        # ↔ right-assoc: left slot is implication (≥2), right slot biimplication (≥1)
+        return f"{_uni_wrap(node.left, 2)} {_UNI_BINSYM[cls]} {_uni_wrap(node.right, 1)}"
+    if cls in ("Implies", "LukImplication"):
+        # → right-assoc: left slot same_level_ops (≥3), right slot implication (≥2)
+        return f"{_uni_wrap(node.left, 3)} {_UNI_BINSYM[cls]} {_uni_wrap(node.right, 2)}"
+    if cls in _UNI_LEVEL2:
+        left = _uni_level2_child(node.left, cls, "left")
+        right = _uni_level2_child(node.right, cls, "right")
+        return f"{left} {_UNI_BINSYM[cls]} {right}"
+
+    if cls == "Lambda":
+        # Body extends rightward through the whole formula; never wrapped here.
+        return f"λ{node.param.name}. " + _uni(node.body)
+    if cls == "Application":
+        # (func)(arg): both sides are delimited by parens in the grammar.
+        return f"({_uni(node.func)})({_uni(node.arg)})"
+
+    raise TypeError(f"to_unicode_str: unknown node type {cls}")
+
+
+# =========================
+# LaTeX rendering
+# =========================
+#
+# Mirrors the Unicode renderer above but emits LaTeX math-mode markup. It reuses
+# the same precedence tables (_UNI_FORMULA_PREC, _UNI_LEVEL2, _uni_prec) so the
+# parenthesisation is identical; only the operator glyphs and term formatting
+# differ. Output is not parseable by MSFLParser (so no round-trip), hence tests
+# assert on exact strings.
+
+_LATEX_BINSYM = {
+    "And": "\\land", "Or": "\\lor", "Xor": "\\oplus",
+    "Implies": "\\rightarrow", "Iff": "\\leftrightarrow",
+    "WeakConjunction": "\\land", "WeakDisjunction": "\\lor",
+    "StrongConjunction": "\\otimes", "StrongDisjunction": "\\oplus",
+    "LukImplication": "\\rightarrow", "LukEquivalence": "\\leftrightarrow",
+}
+
+_LATEX_COMPARE = {
+    "=": "=", "≠": "\\neq", "<": "<", ">": ">", "≤": "\\leq", "≥": "\\geq",
+}
+
+_LATEX_ARITH = {"+": "+", "-": "-", "*": "\\cdot", "/": "/"}
+
+_LATEX_QUANT = {"∀": "\\forall", "forall": "\\forall", "∃": "\\exists", "exists": "\\exists"}
+
+
+def _latex_wrap(node, min_prec: int) -> str:
+    s = _latex(node)
+    return f"({s})" if _uni_prec(node) < min_prec else s
+
+
+def _latex_level2_child(node, parent_cls: str, side: str) -> str:
+    s = _latex(node)
+    p = _uni_prec(node)
+    if side == "left":
+        need = p < 3 or (p == 3 and type(node).__name__ != parent_cls)
+    else:
+        need = p < 4
+    return f"({s})" if need else s
+
+
+def _latex_term(node) -> str:
+    cls = type(node).__name__
+    if cls in ("Variable", "LambdaVar", "Constant"):
+        return node.name
+    if cls == "Number":
+        return str(node.value)
+    if cls == "SortedConstant":
+        return f"{node.name}{{:}}\\mathrm{{{node.sort}}}"
+    if cls == "Function":
+        if node.name in _UNI_ARITH_OPS and len(node.args) == 2:
+            p = _uni_term_prec(node)
+            left = node.args[0]
+            right = node.args[1]
+            ls = _latex_term(left)
+            rs = _latex_term(right)
+            if _uni_term_prec(left) < p:
+                ls = f"({ls})"
+            if _uni_term_prec(right) < p or (_uni_term_prec(right) == p):
+                rs = f"({rs})"
+            return f"{ls} {_LATEX_ARITH[node.name]} {rs}"
+        return f"{node.name}(" + ", ".join(_latex_term(a) for a in node.args) + ")"
+    if cls == "Application":
+        head, args = _uni_spine(node)
+        if isinstance(head, (LambdaVar, Variable, Constant)) and args:
+            return f"{head.name}(" + ", ".join(_latex_term(a) for a in args) + ")"
+        return f"({_latex(node.func)})({_latex(node.arg)})"
+    return _latex(node)
+
+
+def _latex_atom(node) -> str:
+    if node.predicate in _UNI_INFIX_COMPARE and len(node.args) == 2:
+        return f"{_latex_term(node.args[0])} {_LATEX_COMPARE[node.predicate]} {_latex_term(node.args[1])}"
+    if not node.args:
+        return node.predicate
+    return f"{node.predicate}(" + ", ".join(_latex_term(a) for a in node.args) + ")"
+
+
+def _latex(node) -> str:
+    """Render node as a LaTeX math-mode string (no surrounding parens)."""
+    cls = type(node).__name__
+
+    if cls in ("Variable", "LambdaVar", "Constant", "Number", "SortedConstant", "Function"):
+        return _latex_term(node)
+    if cls == "Atom":
+        return _latex_atom(node)
+
+    if cls in ("Not", "LukNegation"):
+        return "\\lnot " + _latex_wrap(node.formula, 4)
+
+    if cls == "Quantifier":
+        return f"{_LATEX_QUANT[node.type]} {node.variable.name}\\, " + _latex_wrap(node.formula, 4)
+    if cls == "SortedQuantifier":
+        return (f"{_LATEX_QUANT[node.type]} {node.variable.name}{{:}}\\mathrm{{{node.sort}}}\\, "
+                + _latex_wrap(node.formula, 4))
+
+    if cls in ("Iff", "LukEquivalence"):
+        return f"{_latex_wrap(node.left, 2)} {_LATEX_BINSYM[cls]} {_latex_wrap(node.right, 1)}"
+    if cls in ("Implies", "LukImplication"):
+        return f"{_latex_wrap(node.left, 3)} {_LATEX_BINSYM[cls]} {_latex_wrap(node.right, 2)}"
+    if cls in _UNI_LEVEL2:
+        left = _latex_level2_child(node.left, cls, "left")
+        right = _latex_level2_child(node.right, cls, "right")
+        return f"{left} {_LATEX_BINSYM[cls]} {right}"
+
+    if cls == "Lambda":
+        return f"\\lambda {node.param.name}.\\, " + _latex(node.body)
+    if cls == "Application":
+        return f"({_latex(node.func)})({_latex(node.arg)})"
+
+    raise TypeError(f"to_latex: unknown node type {cls}")
+
+
 # =========================
 # Registry extension
 # =========================

unicode_fol_kit-0.3.1/unicode_fol_kit/fol/normalforms.py

@@ -0,0 +1,282 @@
+"""Classical-FOL normal forms: NNF, PNF, CNF, Skolemization, and a Horn check.
+
+All entry points first call ``to_fol`` to eliminate sort annotations and
+Łukasiewicz operators, so they accept FOL, MSFOL, MSFL, and FL inputs. Lambda
+terms must be beta-reduced and lambda-eliminated first (``to_fol`` will raise
+otherwise).
+
+- ``to_nnf``  — negation normal form (eliminate → ↔ ⊕, push ¬ to atoms).
+- ``to_pnf``  — prenex normal form (quantifier prefix + quantifier-free NNF
+  matrix), with bound variables standardised apart. Equivalence-preserving.
+- ``to_cnf``  — prenex form whose matrix is a conjunction of clauses.
+  Equivalence-preserving.
+- ``skolemize`` — prenex NNF with existentials replaced by Skolem terms over
+  the universals in scope; universal prefix retained. Satisfiability-preserving
+  (NOT equivalence-preserving).
+- ``is_horn`` — True iff the clausal form (skolemise → drop ∀ → CNF) consists of
+  Horn clauses (each clause has at most one positive literal).
+"""
+
+from .nodes import (
+    Node, Atom, Not, And, Or, Xor, Implies, Iff, Quantifier,
+    Variable, Constant, Number, Function, to_fol,
+)
+from ._msfl_nodes import _rename
+
+_FORALL = ("∀", "forall")
+_EXISTS = ("∃", "exists")
+
+
+# ---------------------------------------------------------------------------
+# Negation normal form
+# ---------------------------------------------------------------------------
+
+def to_nnf(node: Node) -> Node:
+    """Return the negation normal form of node (after reducing to classical FOL)."""
+    return _nnf(to_fol(node))
+
+
+def _nnf(n: Node) -> Node:
+    if isinstance(n, Atom):
+        return n
+    if isinstance(n, Not):
+        return _nnf_neg(n.formula)
+    if isinstance(n, And):
+        return And(_nnf(n.left), _nnf(n.right))
+    if isinstance(n, Or):
+        return Or(_nnf(n.left), _nnf(n.right))
+    if isinstance(n, Implies):
+        return Or(_nnf(Not(n.left)), _nnf(n.right))
+    if isinstance(n, Iff):
+        return And(_nnf(Implies(n.left, n.right)), _nnf(Implies(n.right, n.left)))
+    if isinstance(n, Xor):
+        return Or(And(_nnf(n.left), _nnf(Not(n.right))),
+                  And(_nnf(Not(n.left)), _nnf(n.right)))
+    if isinstance(n, Quantifier):
+        return Quantifier(n.type, n.variable, _nnf(n.formula))
+    raise TypeError(f"to_nnf: unexpected node type {type(n).__name__}")
+
+
+def _nnf_neg(n: Node) -> Node:
+    """Return the NNF of ¬n."""
+    if isinstance(n, Atom):
+        return Not(n)
+    if isinstance(n, Not):
+        return _nnf(n.formula)  # ¬¬a → a
+    if isinstance(n, And):
+        return Or(_nnf_neg(n.left), _nnf_neg(n.right))
+    if isinstance(n, Or):
+        return And(_nnf_neg(n.left), _nnf_neg(n.right))
+    if isinstance(n, Implies):  # ¬(a → b) ≡ a ∧ ¬b
+        return And(_nnf(n.left), _nnf_neg(n.right))
+    if isinstance(n, Iff):  # ¬(a ↔ b) ≡ (a ∧ ¬b) ∨ (¬a ∧ b)
+        return Or(And(_nnf(n.left), _nnf_neg(n.right)),
+                  And(_nnf_neg(n.left), _nnf(n.right)))
+    if isinstance(n, Xor):  # ¬(a ⊕ b) ≡ a ↔ b
+        return _nnf(Iff(n.left, n.right))
+    if isinstance(n, Quantifier):
+        dual = "∃" if n.type in _FORALL else "∀"
+        return Quantifier(dual, n.variable, _nnf_neg(n.formula))
+    raise TypeError(f"to_nnf: unexpected node type {type(n).__name__}")
+
+
+# ---------------------------------------------------------------------------
+# Fresh-name plumbing
+# ---------------------------------------------------------------------------
+
+def _all_names(node: Node) -> set:
+    """Collect every predicate, function, constant, and variable name in node."""
+    names = set()
+    for n in node.walk():
+        cls = type(n).__name__
+        if cls == "Atom":
+            names.add(n.predicate)
+        elif cls == "Function":
+            names.add(n.name)
+        elif cls in ("Variable", "Constant"):
+            names.add(n.name)
+    return names
+
+
+def _gensym(base: str, counter: list, used: set) -> str:
+    """Return a fresh name base+N not already in used; record it in used."""
+    while True:
+        name = f"{base}{counter[0]}"
+        counter[0] += 1
+        if name not in used:
+            used.add(name)
+            return name
+
+
+# ---------------------------------------------------------------------------
+# Prenex normal form
+# ---------------------------------------------------------------------------
+
+def to_pnf(node: Node) -> Node:
+    """Return the prenex normal form: quantifier prefix over a quantifier-free
+    NNF matrix, with all bound variables standardised apart."""
+    nnf = _nnf(to_fol(node))
+    std = _standardize(nnf, [0], _all_names(nnf))
+    prefix, matrix = _prenex_split(std)
+    for qtype, qvar in reversed(prefix):
+        matrix = Quantifier(qtype, qvar, matrix)
+    return matrix
+
+
+def _standardize(n: Node, counter: list, used: set) -> Node:
+    """Rename every bound variable to a globally unique fresh name."""
+    if isinstance(n, Quantifier):
+        fresh = Variable(_gensym("v", counter, used))
+        body = _rename(n.formula, n.variable, fresh)
+        return Quantifier(n.type, fresh, _standardize(body, counter, used))
+    if isinstance(n, (And, Or)):
+        return type(n)(_standardize(n.left, counter, used),
+                       _standardize(n.right, counter, used))
+    if isinstance(n, Not):
+        return Not(_standardize(n.formula, counter, used))
+    return n  # Atom
+
+
+def _prenex_split(n: Node):
+    """Split a standardised-apart NNF formula into (prefix, quantifier-free matrix).
+
+    prefix is a list of (quantifier_type, Variable) in outer-to-inner order.
+    Sound because bound variables are disjoint, so quantifiers hoist freely.
+    """
+    if isinstance(n, Quantifier):
+        prefix, matrix = _prenex_split(n.formula)
+        return [(n.type, n.variable)] + prefix, matrix
+    if isinstance(n, (And, Or)):
+        pl, ml = _prenex_split(n.left)
+        pr, mr = _prenex_split(n.right)
+        return pl + pr, type(n)(ml, mr)
+    return [], n  # Not(atom) or Atom
+
+
+# ---------------------------------------------------------------------------
+# Conjunctive normal form
+# ---------------------------------------------------------------------------
+
+def to_cnf(node: Node) -> Node:
+    """Return prenex form whose matrix is a conjunction of clauses. Equivalence-preserving."""
+    pnf = to_pnf(node)
+    prefix, matrix = _prenex_split(pnf)
+    cnf_matrix = _cnf(matrix)
+    for qtype, qvar in reversed(prefix):
+        cnf_matrix = Quantifier(qtype, qvar, cnf_matrix)
+    return cnf_matrix
+
+
+def _cnf(n: Node) -> Node:
+    """Distribute ∨ over ∧ in a quantifier-free NNF formula."""
+    if isinstance(n, (Atom, Not)):
+        return n
+    if isinstance(n, And):
+        return And(_cnf(n.left), _cnf(n.right))
+    if isinstance(n, Or):
+        return _distribute(_cnf(n.left), _cnf(n.right))
+    raise TypeError(f"to_cnf: unexpected node type {type(n).__name__}")
+
+
+def _distribute(left: Node, right: Node) -> Node:
+    if isinstance(left, And):
+        return And(_distribute(left.left, right), _distribute(left.right, right))
+    if isinstance(right, And):
+        return And(_distribute(left, right.left), _distribute(left, right.right))
+    return Or(left, right)
+
+
+# ---------------------------------------------------------------------------
+# Skolemization
+# ---------------------------------------------------------------------------
+
+def skolemize(node: Node) -> Node:
+    """Return prenex NNF with existentials replaced by Skolem terms.
+
+    Each ∃-bound variable becomes a Skolem function of the universals in scope
+    (a Skolem constant if there are none); the existential quantifiers are
+    dropped and the universal prefix is retained. Satisfiability-preserving.
+    """
+    pnf = to_pnf(node)
+    prefix, matrix = _prenex_split(pnf)
+    used = _all_names(pnf)
+    sk_counter = [0]
+
+    universals = []          # Variables of the ∀ seen so far, in order
+    kept_prefix = []         # the ∀ Variables to re-wrap
+    subst = {}               # existential var name -> Skolem term
+
+    for qtype, qvar in prefix:
+        if qtype in _FORALL:
+            universals.append(qvar)
+            kept_prefix.append(qvar)
+        else:
+            fname = _gensym("sk", sk_counter, used)
+            term = Function(fname, list(universals)) if universals else Constant(fname)
+            subst[qvar.name] = term
+
+    result = matrix
+    for name, term in subst.items():
+        result = _subst_term(result, name, term)
+    for qvar in reversed(kept_prefix):
+        result = Quantifier("∀", qvar, result)
+    return result
+
+
+def _subst_term(n: Node, varname: str, term: Node) -> Node:
+    """Replace every free Variable(varname) with term inside a formula/term."""
+    if isinstance(n, Variable):
+        return term if n.name == varname else n
+    if isinstance(n, (Constant, Number)):
+        return n
+    if isinstance(n, Function):
+        return Function(n.name, [_subst_term(a, varname, term) for a in n.args])
+    if isinstance(n, Atom):
+        return Atom(n.predicate, [_subst_term(a, varname, term) for a in n.args])
+    if isinstance(n, Not):
+        return Not(_subst_term(n.formula, varname, term))
+    if isinstance(n, (And, Or)):
+        return type(n)(_subst_term(n.left, varname, term),
+                       _subst_term(n.right, varname, term))
+    if isinstance(n, Quantifier):
+        if n.variable.name == varname:
+            return n  # shadowed (cannot happen after standardising apart, but safe)
+        return Quantifier(n.type, n.variable, _subst_term(n.formula, varname, term))
+    return n
+
+
+# ---------------------------------------------------------------------------
+# Horn check
+# ---------------------------------------------------------------------------
+
+def is_horn(node: Node) -> bool:
+    """Return True iff node's clausal form consists of Horn clauses.
+
+    Syntactic/clausal definition: skolemise, drop the universal prefix, put the
+    matrix into CNF, split into clauses, and check that every clause has at most
+    one positive literal.
+    """
+    sk = skolemize(node)
+    _, matrix = _prenex_split(sk)
+    cnf = _cnf(matrix)
+    for clause in _clauses(cnf):
+        if sum(1 for lit in clause if isinstance(lit, Atom)) > 1:
+            return False
+    return True
+
+
+def _conjuncts(n: Node) -> list:
+    if isinstance(n, And):
+        return _conjuncts(n.left) + _conjuncts(n.right)
+    return [n]
+
+
+def _disjuncts(n: Node) -> list:
+    if isinstance(n, Or):
+        return _disjuncts(n.left) + _disjuncts(n.right)
+    return [n]
+
+
+def _clauses(cnf: Node) -> list:
+    """Split a CNF matrix into a list of clauses, each a list of literals."""
+    return [_disjuncts(c) for c in _conjuncts(cnf)]

unicode_fol_kit-0.2.1/unicode_fol_kit/atp/__init__.py

@@ -1,4 +0,0 @@
-from .z3_equivalence import formulas_are_equivalent
-from .prover9_entailment import check_logical_entailment
-
-__all__ = ["formulas_are_equivalent", "check_logical_entailment"]