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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unicode-fol-kit
-Version: 0.2.1
+Version: 0.3.0
 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,6 +36,7 @@ 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
 - **Z3 export** — translate formulas to Z3 expressions for SMT solving
 - **Prover9 export** — translate formulas to Prover9 syntax for automated theorem proving
 - **TPTP export** — translate formulas to TPTP syntax
@@ -154,6 +155,26 @@ 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
@@ -560,15 +581,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.0}/README.md

@@ -12,6 +12,7 @@ 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
 - **Z3 export** — translate formulas to Z3 expressions for SMT solving
 - **Prover9 export** — translate formulas to Prover9 syntax for automated theorem proving
 - **TPTP export** — translate formulas to TPTP syntax
@@ -130,6 +131,26 @@ 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
@@ -536,15 +557,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.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "unicode-fol-kit"
-version = "0.2.1"
+version = "0.3.0"
 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.0}/unicode_fol_kit/__init__.py

@@ -17,7 +17,7 @@ from .fol import (
 )
 from .atp import formulas_are_equivalent, check_logical_entailment
 
-__version__ = "0.2.1"
+__version__ = "0.3.0"
 
 __all__ = [
     "MSFLParser",

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

@@ -108,6 +108,17 @@ 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 tree_str(self) -> str:
         """Render the AST as a multi-line ASCII tree using ├──/└── connectors."""
         label, children = self._tree_parts()

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

@@ -893,6 +893,182 @@ 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}")
+
+
 # =========================
 # Registry extension
 # =========================