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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unicode-fol-kit
-Version: 0.2.0
+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
@@ -24,11 +24,11 @@ Description-Content-Type: text/markdown
 
 # unicode-fol-kit
 
-A Python toolkit for parsing and working with first-order logic (FOL) formulas written with Unicode operators. The single parser class `MSFLParser` supports three modes — classical FOL, many-sorted FOL (MSFOL), and many-sorted fuzzy logic (MSFL, Łukasiewicz) — selected by constructor flags.
+A Python toolkit for parsing and working with first-order logic (FOL) formulas written with Unicode operators. The single parser class `MSFLParser` supports four modes — classical FOL, many-sorted FOL (MSFOL), many-sorted fuzzy logic (MSFL), and single-sorted fuzzy logic (FL, Łukasiewicz) — selected by constructor flags.
 
 ## Features
 
-- **Three parser modes** — FOL, many-sorted FOL (MSFOL), and many-sorted fuzzy/Łukasiewicz logic (MSFL), all from one class
+- **Four parser modes** — FOL, many-sorted FOL (MSFOL), many-sorted fuzzy/Łukasiewicz logic (MSFL), and single-sorted fuzzy/Łukasiewicz logic (FL), all from one class
 - **Unicode surface syntax** — natural symbols (∀ ∃ ∧ ∨ ¬ → ↔ ⊕ ⊗ = ≠ ≤ ≥) with no ASCII fallbacks needed
 - **Sorted quantifiers and constants** — `∀x:Human P(x)`, `P(alice:Human)` in MSFOL and MSFL modes
 - **Łukasiewicz operators** — weak ∧ / ∨ (min/max), strong ⊗ / ⊕ (t-norm/t-conorm), and Łukasiewicz ¬ → ↔ in MSFL mode
@@ -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
@@ -69,7 +70,7 @@ pip install .
 MSFLParser(many_sorted=False, fuzzy=False)   # FOL   (default)
 MSFLParser(many_sorted=True,  fuzzy=False)   # MSFOL
 MSFLParser(many_sorted=True,  fuzzy=True)    # MSFL
-MSFLParser(many_sorted=False, fuzzy=True)    # → raises ValueError
+MSFLParser(many_sorted=False, fuzzy=True)    # FL
 ```
 
 | `many_sorted` | `fuzzy` | Mode | Quantifiers | Constants | Connectives |
@@ -77,6 +78,7 @@ MSFLParser(many_sorted=False, fuzzy=True)    # → raises ValueError
 | `False` | `False` | **FOL** | unsorted `∀x` | unsorted | classical ∧ ∨ ⊕ ¬ → ↔ |
 | `True` | `False` | **MSFOL** | sorted `∀x:Sort` | sorted `alice:Sort` | classical ∧ ∨ ¬ → ↔ (no ⊕) |
 | `True` | `True` | **MSFL** | sorted `∀x:Sort` | sorted `alice:Sort` | weak ∧ ∨, strong ⊗ ⊕, Łuk ¬ → ↔ |
+| `False` | `True` | **FL** | unsorted `∀x` | unsorted | weak ∧ ∨, strong ⊗ ⊕, Łuk ¬ → ↔ |
 
 ## Usage
 
@@ -120,6 +122,26 @@ parser.parse("P(x) → Q(x)")    # LukImplication (min{1, 1−x+y})
 parser.parse("∀x:Human P(x)")  # SortedQuantifier
 ```
 
+### FL mode
+
+Łukasiewicz operators with **unsorted** quantifiers and plain constants — same connectives as MSFL, same quantifier/constant syntax as FOL:
+
+```python
+parser = MSFLParser(many_sorted=False, fuzzy=True)
+
+parser.parse("P(x) ∧ Q(x)")          # WeakConjunction (min)
+parser.parse("P(x) ⊗ Q(x)")          # StrongConjunction (t-norm: max{0, x+y−1})
+parser.parse("P(x) ⊕ Q(x)")          # StrongDisjunction (t-conorm: min{1, x+y})
+parser.parse("¬P(x)")                 # LukNegation (1−x)
+parser.parse("P(x) → Q(x)")          # LukImplication (min{1, 1−x+y})
+parser.parse("∀x P(x)")              # unsorted Quantifier (no sort annotation)
+parser.parse("P(alice)")             # plain Constant (no sort annotation)
+
+# Lambda works in FL mode too
+parser.parse("λx. P(x) ⊗ Q(x)")
+# Lambda(LambdaVar("x"), StrongConjunction(Atom("P",[LambdaVar("x")]), Atom("Q",[LambdaVar("x")])))
+```
+
 ### ASCII tree view
 
 ```python
@@ -133,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
@@ -365,6 +407,21 @@ Connectives are reinterpreted as Łukasiewicz operators:
 | `φ ↔ ψ` | Łuk. equivalence | 1 − \|φ − ψ\| |
 | `∀x:Sort φ`, `∃x:Sort φ` | sorted quantifiers | |
 
+#### FL mode
+
+Same Łukasiewicz connectives as MSFL, but with **unsorted** quantifiers and plain constants (no `:Sort` required):
+
+| Syntax | Operator | Semantics |
+|---|---|---|
+| `¬φ` | Łuk. negation | 1 − φ |
+| `φ ∧ ψ` | weak conjunction | min(φ, ψ) |
+| `φ ∨ ψ` | weak disjunction | max(φ, ψ) |
+| `φ ⊗ ψ` | strong conjunction | max(0, φ + ψ − 1) |
+| `φ ⊕ ψ` | strong disjunction | min(1, φ + ψ) |
+| `φ → ψ` | Łuk. implication | min(1, 1 − φ + ψ) |
+| `φ ↔ ψ` | Łuk. equivalence | 1 − \|φ − ψ\| |
+| `∀x φ`, `∃x φ` | unsorted quantifiers | |
+
 A formula may be wrapped in parentheses `( … )` or square brackets `[ … ]`; the two are interchangeable for grouping.
 
 ### Operator precedence
@@ -374,7 +431,7 @@ The precedence levels are the same across all three modes (MSFL uses the same sy
 | Precedence | Operators | Associativity |
 |---|---|---|
 | 1 (highest) | `¬`, quantifiers `∀` / `∃` | prefix |
-| 2 | `∧` `∨` `⊕` (FOL) / `∧` `∨` (MSFOL) / `∧` `∨` `⊗` `⊕` (MSFL) | left |
+| 2 | `∧` `∨` `⊕` (FOL) / `∧` `∨` (MSFOL) / `∧` `∨` `⊗` `⊕` (MSFL / FL) | left |
 | 3 | `→` | right |
 | 4 (lowest) | `↔` | right |
 
@@ -404,7 +461,7 @@ P(x) ∧ Q(x) ∨ R(x)      # rejected
 (P(x) ∧ Q(x)) ∨ R(x)    # accepted
 ```
 
-**MSFL mode** — `∧`, `∨`, `⊗`, `⊕` cannot be mixed:
+**MSFL / FL mode** — `∧`, `∨`, `⊗`, `⊕` cannot be mixed:
 
 ```text
 P(x) ∧ Q(x) ⊗ R(x)        # rejected
@@ -433,16 +490,16 @@ Quantifiers can be stacked directly: `∀x:H ∀y:H ∃z:A φ`.
 
 ### Supported symbols
 
-| Category | FOL | MSFOL | MSFL |
-|---|---|---|---|
-| Quantifiers | `∀` `∃` (unsorted) | `∀` `∃` (sorted `:Sort`) | `∀` `∃` (sorted `:Sort`) |
-| Connectives | `∧` `∨` `⊕` `¬` `→` `↔` | `∧` `∨` `¬` `→` `↔` | `∧` `∨` `⊗` `⊕` `¬` `→` `↔` |
-| Lambda | `λ` | `λ` | `λ` |
-| Sort annotations | — | `:Sort` | `:Sort` |
-| Equality / comparison | `=` `≠` `<` `>` `≤` `≥` | same | same |
-| Arithmetic | `+` `-` `*` `/` | same | same |
-| Grouping | `(` `)` `[` `]` | same | same |
-| Argument separator | `,` | same | same |
+| Category | FOL | MSFOL | MSFL | FL |
+|---|---|---|---|---|
+| Quantifiers | `∀` `∃` (unsorted) | `∀` `∃` (sorted `:Sort`) | `∀` `∃` (sorted `:Sort`) | `∀` `∃` (unsorted) |
+| Connectives | `∧` `∨` `⊕` `¬` `→` `↔` | `∧` `∨` `¬` `→` `↔` | `∧` `∨` `⊗` `⊕` `¬` `→` `↔` | `∧` `∨` `⊗` `⊕` `¬` `→` `↔` |
+| Lambda | `λ` | `λ` | `λ` | `λ` |
+| Sort annotations | — | `:Sort` | `:Sort` | — |
+| Equality / comparison | `=` `≠` `<` `>` `≤` `≥` | same | same | same |
+| Arithmetic | `+` `-` `*` `/` | same | same | same |
+| Grouping | `(` `)` `[` `]` | same | same | same |
+| Argument separator | `,` | same | same | same |
 
 Whitespace is insignificant and may be used freely between tokens — including before sort annotation colons.
 
@@ -524,15 +581,23 @@ 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
+
+```text
+∀x ∀y
+    (Effective(y) ⊗ Tolerable(x, y))
+    → Recommended(x, y)
 ```
 
 ## AST nodes
@@ -618,6 +683,11 @@ MSFLParser(many_sorted=True).parse("P(x) ∧ Q(x) ∨ R(x)")
 MSFLParser(many_sorted=True, fuzzy=True).parse("P(x) ∧ Q(x) ⊗ R(x)")
 # SYNTAX_ERROR: … Hint: Cannot mix weak conjunction (∧), weak disjunction (∨),
 #                        strong conjunction (⊗), and strong disjunction (⊕) without parentheses
+
+# FL mode — same hint as MSFL (Łukasiewicz connectives, unsorted)
+MSFLParser(many_sorted=False, fuzzy=True).parse("P(x) ∧ Q(x) ⊗ R(x)")
+# SYNTAX_ERROR: … Hint: Cannot mix weak conjunction (∧), weak disjunction (∨),
+#                        strong conjunction (⊗), and strong disjunction (⊕) without parentheses
 ```
 
 ## Citation

{unicode_fol_kit-0.2.0 → unicode_fol_kit-0.3.0}/README.md

@@ -1,10 +1,10 @@
 # unicode-fol-kit
 
-A Python toolkit for parsing and working with first-order logic (FOL) formulas written with Unicode operators. The single parser class `MSFLParser` supports three modes — classical FOL, many-sorted FOL (MSFOL), and many-sorted fuzzy logic (MSFL, Łukasiewicz) — selected by constructor flags.
+A Python toolkit for parsing and working with first-order logic (FOL) formulas written with Unicode operators. The single parser class `MSFLParser` supports four modes — classical FOL, many-sorted FOL (MSFOL), many-sorted fuzzy logic (MSFL), and single-sorted fuzzy logic (FL, Łukasiewicz) — selected by constructor flags.
 
 ## Features
 
-- **Three parser modes** — FOL, many-sorted FOL (MSFOL), and many-sorted fuzzy/Łukasiewicz logic (MSFL), all from one class
+- **Four parser modes** — FOL, many-sorted FOL (MSFOL), many-sorted fuzzy/Łukasiewicz logic (MSFL), and single-sorted fuzzy/Łukasiewicz logic (FL), all from one class
 - **Unicode surface syntax** — natural symbols (∀ ∃ ∧ ∨ ¬ → ↔ ⊕ ⊗ = ≠ ≤ ≥) with no ASCII fallbacks needed
 - **Sorted quantifiers and constants** — `∀x:Human P(x)`, `P(alice:Human)` in MSFOL and MSFL modes
 - **Łukasiewicz operators** — weak ∧ / ∨ (min/max), strong ⊗ / ⊕ (t-norm/t-conorm), and Łukasiewicz ¬ → ↔ in MSFL mode
@@ -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
@@ -45,7 +46,7 @@ pip install .
 MSFLParser(many_sorted=False, fuzzy=False)   # FOL   (default)
 MSFLParser(many_sorted=True,  fuzzy=False)   # MSFOL
 MSFLParser(many_sorted=True,  fuzzy=True)    # MSFL
-MSFLParser(many_sorted=False, fuzzy=True)    # → raises ValueError
+MSFLParser(many_sorted=False, fuzzy=True)    # FL
 ```
 
 | `many_sorted` | `fuzzy` | Mode | Quantifiers | Constants | Connectives |
@@ -53,6 +54,7 @@ MSFLParser(many_sorted=False, fuzzy=True)    # → raises ValueError
 | `False` | `False` | **FOL** | unsorted `∀x` | unsorted | classical ∧ ∨ ⊕ ¬ → ↔ |
 | `True` | `False` | **MSFOL** | sorted `∀x:Sort` | sorted `alice:Sort` | classical ∧ ∨ ¬ → ↔ (no ⊕) |
 | `True` | `True` | **MSFL** | sorted `∀x:Sort` | sorted `alice:Sort` | weak ∧ ∨, strong ⊗ ⊕, Łuk ¬ → ↔ |
+| `False` | `True` | **FL** | unsorted `∀x` | unsorted | weak ∧ ∨, strong ⊗ ⊕, Łuk ¬ → ↔ |
 
 ## Usage
 
@@ -96,6 +98,26 @@ parser.parse("P(x) → Q(x)")    # LukImplication (min{1, 1−x+y})
 parser.parse("∀x:Human P(x)")  # SortedQuantifier
 ```
 
+### FL mode
+
+Łukasiewicz operators with **unsorted** quantifiers and plain constants — same connectives as MSFL, same quantifier/constant syntax as FOL:
+
+```python
+parser = MSFLParser(many_sorted=False, fuzzy=True)
+
+parser.parse("P(x) ∧ Q(x)")          # WeakConjunction (min)
+parser.parse("P(x) ⊗ Q(x)")          # StrongConjunction (t-norm: max{0, x+y−1})
+parser.parse("P(x) ⊕ Q(x)")          # StrongDisjunction (t-conorm: min{1, x+y})
+parser.parse("¬P(x)")                 # LukNegation (1−x)
+parser.parse("P(x) → Q(x)")          # LukImplication (min{1, 1−x+y})
+parser.parse("∀x P(x)")              # unsorted Quantifier (no sort annotation)
+parser.parse("P(alice)")             # plain Constant (no sort annotation)
+
+# Lambda works in FL mode too
+parser.parse("λx. P(x) ⊗ Q(x)")
+# Lambda(LambdaVar("x"), StrongConjunction(Atom("P",[LambdaVar("x")]), Atom("Q",[LambdaVar("x")])))
+```
+
 ### ASCII tree view
 
 ```python
@@ -109,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
@@ -341,6 +383,21 @@ Connectives are reinterpreted as Łukasiewicz operators:
 | `φ ↔ ψ` | Łuk. equivalence | 1 − \|φ − ψ\| |
 | `∀x:Sort φ`, `∃x:Sort φ` | sorted quantifiers | |
 
+#### FL mode
+
+Same Łukasiewicz connectives as MSFL, but with **unsorted** quantifiers and plain constants (no `:Sort` required):
+
+| Syntax | Operator | Semantics |
+|---|---|---|
+| `¬φ` | Łuk. negation | 1 − φ |
+| `φ ∧ ψ` | weak conjunction | min(φ, ψ) |
+| `φ ∨ ψ` | weak disjunction | max(φ, ψ) |
+| `φ ⊗ ψ` | strong conjunction | max(0, φ + ψ − 1) |
+| `φ ⊕ ψ` | strong disjunction | min(1, φ + ψ) |
+| `φ → ψ` | Łuk. implication | min(1, 1 − φ + ψ) |
+| `φ ↔ ψ` | Łuk. equivalence | 1 − \|φ − ψ\| |
+| `∀x φ`, `∃x φ` | unsorted quantifiers | |
+
 A formula may be wrapped in parentheses `( … )` or square brackets `[ … ]`; the two are interchangeable for grouping.
 
 ### Operator precedence
@@ -350,7 +407,7 @@ The precedence levels are the same across all three modes (MSFL uses the same sy
 | Precedence | Operators | Associativity |
 |---|---|---|
 | 1 (highest) | `¬`, quantifiers `∀` / `∃` | prefix |
-| 2 | `∧` `∨` `⊕` (FOL) / `∧` `∨` (MSFOL) / `∧` `∨` `⊗` `⊕` (MSFL) | left |
+| 2 | `∧` `∨` `⊕` (FOL) / `∧` `∨` (MSFOL) / `∧` `∨` `⊗` `⊕` (MSFL / FL) | left |
 | 3 | `→` | right |
 | 4 (lowest) | `↔` | right |
 
@@ -380,7 +437,7 @@ P(x) ∧ Q(x) ∨ R(x)      # rejected
 (P(x) ∧ Q(x)) ∨ R(x)    # accepted
 ```
 
-**MSFL mode** — `∧`, `∨`, `⊗`, `⊕` cannot be mixed:
+**MSFL / FL mode** — `∧`, `∨`, `⊗`, `⊕` cannot be mixed:
 
 ```text
 P(x) ∧ Q(x) ⊗ R(x)        # rejected
@@ -409,16 +466,16 @@ Quantifiers can be stacked directly: `∀x:H ∀y:H ∃z:A φ`.
 
 ### Supported symbols
 
-| Category | FOL | MSFOL | MSFL |
-|---|---|---|---|
-| Quantifiers | `∀` `∃` (unsorted) | `∀` `∃` (sorted `:Sort`) | `∀` `∃` (sorted `:Sort`) |
-| Connectives | `∧` `∨` `⊕` `¬` `→` `↔` | `∧` `∨` `¬` `→` `↔` | `∧` `∨` `⊗` `⊕` `¬` `→` `↔` |
-| Lambda | `λ` | `λ` | `λ` |
-| Sort annotations | — | `:Sort` | `:Sort` |
-| Equality / comparison | `=` `≠` `<` `>` `≤` `≥` | same | same |
-| Arithmetic | `+` `-` `*` `/` | same | same |
-| Grouping | `(` `)` `[` `]` | same | same |
-| Argument separator | `,` | same | same |
+| Category | FOL | MSFOL | MSFL | FL |
+|---|---|---|---|---|
+| Quantifiers | `∀` `∃` (unsorted) | `∀` `∃` (sorted `:Sort`) | `∀` `∃` (sorted `:Sort`) | `∀` `∃` (unsorted) |
+| Connectives | `∧` `∨` `⊕` `¬` `→` `↔` | `∧` `∨` `¬` `→` `↔` | `∧` `∨` `⊗` `⊕` `¬` `→` `↔` | `∧` `∨` `⊗` `⊕` `¬` `→` `↔` |
+| Lambda | `λ` | `λ` | `λ` | `λ` |
+| Sort annotations | — | `:Sort` | `:Sort` | — |
+| Equality / comparison | `=` `≠` `<` `>` `≤` `≥` | same | same | same |
+| Arithmetic | `+` `-` `*` `/` | same | same | same |
+| Grouping | `(` `)` `[` `]` | same | same | same |
+| Argument separator | `,` | same | same | same |
 
 Whitespace is insignificant and may be used freely between tokens — including before sort annotation colons.
 
@@ -500,15 +557,23 @@ 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
+
+```text
+∀x ∀y
+    (Effective(y) ⊗ Tolerable(x, y))
+    → Recommended(x, y)
 ```
 
 ## AST nodes
@@ -594,6 +659,11 @@ MSFLParser(many_sorted=True).parse("P(x) ∧ Q(x) ∨ R(x)")
 MSFLParser(many_sorted=True, fuzzy=True).parse("P(x) ∧ Q(x) ⊗ R(x)")
 # SYNTAX_ERROR: … Hint: Cannot mix weak conjunction (∧), weak disjunction (∨),
 #                        strong conjunction (⊗), and strong disjunction (⊕) without parentheses
+
+# FL mode — same hint as MSFL (Łukasiewicz connectives, unsorted)
+MSFLParser(many_sorted=False, fuzzy=True).parse("P(x) ∧ Q(x) ⊗ R(x)")
+# SYNTAX_ERROR: … Hint: Cannot mix weak conjunction (∧), weak disjunction (∨),
+#                        strong conjunction (⊗), and strong disjunction (⊕) without parentheses
 ```
 
 ## Citation

{unicode_fol_kit-0.2.0 → unicode_fol_kit-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "unicode-fol-kit"
-version = "0.2.0"
+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.0 → 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.0"
+__version__ = "0.3.0"
 
 __all__ = [
     "MSFLParser",

{unicode_fol_kit-0.2.0 → 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.0 → 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
 # =========================