unicode-fol-kit 0.1.0__py3-none-any.whl

unicode_fol_kit/__init__.py

@@ -0,0 +1,17 @@
+from .fol import (
+    FOLParser,
+    Node, Variable, Constant, Number, Function,
+    Atom, Not, And, Or, Xor, Implies, Iff, Quantifier,
+    Z3Env,
+    NamingError, ParsingError,
+)
+from .atp import formulas_are_equivalent, check_logical_entailment
+
+__all__ = [
+    "FOLParser",
+    "Node", "Variable", "Constant", "Number", "Function",
+    "Atom", "Not", "And", "Or", "Xor", "Implies", "Iff", "Quantifier",
+    "Z3Env",
+    "NamingError", "ParsingError",
+    "formulas_are_equivalent", "check_logical_entailment",
+]

unicode_fol_kit/atp/__init__.py

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

unicode_fol_kit/atp/prover9_entailment.py

@@ -0,0 +1,70 @@
+import subprocess
+import tempfile
+import os
+from ..fol.nodes import Node
+
+def _generate_prover9_input(premises: list[Node], conclusion: Node) -> str:
+    """
+    Generates a Prover9 input string from given premises and conclusion.
+
+    Args:
+        premises (list[Node]): List of premise formulas in FOL.
+        conclusion (Node): Conclusion formula in FOL.
+
+    Returns:
+        str: Formatted Prover9 input string.
+    """
+    prover9_input = []
+
+    #Header section
+    prover9_input.append("set(prolog_style_variables).")
+    prover9_input.append("set(auto_denials).")
+    prover9_input.append("clear(print_initial_clauses).")
+    prover9_input.append("clear(print_kept).")
+    prover9_input.append("clear(print_given).")
+    prover9_input.append("")
+
+    # Premises section
+    prover9_input.append("formulas(assumptions).")
+    for premise in premises:
+        prover9_formula = premise.to_prover9()
+        prover9_input.append(f"  {prover9_formula}.")
+    prover9_input.append("end_of_list.")
+    prover9_input.append("")
+
+    # Goal section
+    prover9_input.append("formulas(goals).")
+    prover9_goal = conclusion.to_prover9()
+    prover9_input.append(f"  {prover9_goal}.")
+    prover9_input.append("end_of_list.")
+
+    return "\n".join(prover9_input)
+
+def _run_prover9(input: str, prover9_path: str, timeout: int=30) ->bool:
+    """Run the prover9 command line tool."""
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.in', delete=False) as temp_file:
+        temp_file.write(input)
+        temp_filename = temp_file.name
+
+    try:
+        result = subprocess.run(
+            [prover9_path, '-f', temp_filename],
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        success = "THEOREM PROVED" in result.stdout
+    except subprocess.TimeoutExpired:
+        success = False
+
+    os.unlink(temp_filename)
+    return success
+
+
+def check_logical_entailment(premises: list[Node], conclusion: Node, prover9_path: str) ->bool:
+    """Checks if a conclusion entails from the defined premises by using prover9."""
+
+    prover9_input = _generate_prover9_input(premises, conclusion)
+    success = _run_prover9(prover9_input, prover9_path)
+    return success

unicode_fol_kit/atp/z3_equivalence.py

@@ -0,0 +1,22 @@
+from ..fol.nodes import Node
+from z3 import Solver, unsat, set_param, Not
+
+
+def formulas_are_equivalent(formula1: Node, formula2: Node, timeout: int=10000) -> bool:
+    """Checks if two formulas are equivalent by using z3 solver by verifying the unsatisfiability
+    of ¬(φ ↔ ψ), where φ is the formula produced by the LLM and ψ is the ground-truth formula.
+    """
+
+    phi = formula1.to_z3()
+    psi = formula2.to_z3()
+
+    solver = Solver()
+    solver.set("timeout", timeout)
+    solver.set("random_seed", 42)
+    solver.add(Not(phi==psi))
+
+    result = solver.check()
+    if result == unsat:
+        return True
+
+    return False

unicode_fol_kit/fol/__init__.py

@@ -0,0 +1,15 @@
+from .folparser import FOLParser
+from .nodes import (
+    Node, Variable, Constant, Number, Function,
+    Atom, Not, And, Or, Xor, Implies, Iff, Quantifier,
+    Z3Env,
+)
+from .naming import NamingError, ParsingError
+
+__all__ = [
+    "FOLParser",
+    "Node", "Variable", "Constant", "Number", "Function",
+    "Atom", "Not", "And", "Or", "Xor", "Implies", "Iff", "Quantifier",
+    "Z3Env",
+    "NamingError", "ParsingError",
+]

unicode_fol_kit/fol/folparser.py

@@ -0,0 +1,21 @@
+import pathlib
+from lark import Lark, UnexpectedCharacters, UnexpectedToken, UnexpectedEOF
+from .nodes import Node, FOLTransformer
+from .naming import NamingError, ParsingError
+
+
+class FOLParser:
+    def __init__(self):
+        grammar_path = pathlib.Path(__file__).parent / "syntax.lark"
+        with open(grammar_path, encoding="utf-8") as file:
+            grammar = file.read()
+        self.parser = Lark(grammar, parser='earley')
+
+    def parse(self, text: str) -> Node:
+        try:
+            tree = self.parser.parse(text)
+            return FOLTransformer().transform(tree)
+        except UnexpectedCharacters as e:
+            raise NamingError(self.parser, e, text)
+        except (UnexpectedToken, UnexpectedEOF) as e:
+            raise ParsingError(self.parser, e, text)

unicode_fol_kit/fol/naming.py

@@ -0,0 +1,174 @@
+from lark import Lark, UnexpectedCharacters, UnexpectedToken, UnexpectedEOF
+from lark.exceptions import ParseError
+
+
+_SYMBOL_NAMES = {
+    "↔": "biconditional",
+    "→": "implication",
+    "∧": "conjunction",
+    "∨": "disjunction",
+    "⊕": "exclusive or",
+    "¬": "negation",
+    "∀": "universal quantifier",
+    "∃": "existential quantifier",
+    "≤": "less-than-or-equal",
+    "≥": "greater-than-or-equal",
+    "≠": "not-equal",
+    "=": "equality",
+    "<": "less-than",
+    ">": "greater-than",
+    "+": "plus",
+    "-": "minus",
+    "*": "times",
+    "/": "division",
+    "(": "opening parenthesis",
+    ")": "closing parenthesis",
+    "[": "opening bracket",
+    "]": "closing bracket",
+    ",": "comma",
+}
+
+_NAMED_TOKENS = {
+    "PREDICATE": "predicate",
+    "NAME": "name/constant",
+    "VARIABLE": "variable",
+    "CONSTANT": "constant",
+    "NUMBER": "number",
+}
+
+_MIXING_SYMBOLS = {"∧", "∨", "⊕"}
+
+
+def _build_pattern_index(parser: Lark) -> dict:
+    """Map terminal name -> raw pattern string for every terminal in the grammar."""
+    index = {}
+    for term in parser.terminals:
+        pattern = term.pattern
+        index[term.name] = pattern.value if hasattr(pattern, "value") else str(pattern)
+    return index
+
+
+def _display_name(token_type: str, patterns: dict) -> str:
+    """Resolve a terminal name to a human-readable label.
+
+    Named tokens use a fixed label; symbol tokens are resolved through their
+    pattern; anything unknown falls back to the raw terminal name.
+    """
+    if token_type in _NAMED_TOKENS:
+        return _NAMED_TOKENS[token_type]
+    pattern = patterns.get(token_type)
+    if pattern in _SYMBOL_NAMES:
+        return _SYMBOL_NAMES[pattern]
+    return token_type
+
+
+def _is_structural(token_type: str) -> bool:
+    """True if the token is a symbol/operator rather than a name-like token."""
+    return token_type not in _NAMED_TOKENS
+
+
+def _format_expected(expected, patterns: dict) -> str:
+    """Render a set of expected terminal names as a sorted, deduplicated label list."""
+    labels = []
+    seen = set()
+    for token_type in expected or ():
+        label = _display_name(token_type, patterns)
+        if label not in seen:
+            seen.add(label)
+            labels.append(label)
+    return ", ".join(sorted(labels)) if labels else "a valid token"
+
+
+class NamingError(UnexpectedCharacters):
+    """Human-readable wrapper around a lexer-level UnexpectedCharacters failure.
+
+    Token names are resolved through the grammar's terminal patterns rather
+    than hard-coded anonymous-token numbers, so messages stay correct when the
+    grammar changes.
+    """
+
+    def __init__(self, parser: Lark, original_exception: UnexpectedCharacters, formula: str):
+        self._patterns = _build_pattern_index(parser)
+
+        pos = original_exception.pos_in_stream
+        prefix = formula[:pos] if pos is not None and pos >= 0 else formula
+        tokens = list(parser.lex(prefix))
+        last_token = tokens[-1] if tokens else None
+
+        if last_token is None:
+            message = (
+                f"SYNTAX_ERROR: Unexpected character "
+                f"'{original_exception.char}' at position {original_exception.column}"
+            )
+        else:
+            message = self._build_message(last_token, original_exception)
+
+        self.__dict__.update(original_exception.__dict__)
+        self.args = (message,)
+
+    def _build_message(self, last_token, exc: UnexpectedCharacters) -> str:
+        """Compose the final error message for a lexer-level failure."""
+        display = _display_name(last_token.type, self._patterns)
+
+        if _is_structural(last_token.type):
+            message = (
+                f"SYNTAX_ERROR: Unexpected character '{exc.char}' at position "
+                f"{exc.column} after {display} '{last_token.value}'"
+            )
+            if exc.char in _MIXING_SYMBOLS:
+                message += (
+                    ". Hint: Cannot mix conjunction (∧), disjunction (∨), and "
+                    "exclusive or (⊕) without parentheses"
+                )
+            return message
+
+        message = (
+            f"SYNTAX_ERROR: Invalid {display} '{last_token.value}' - "
+            f"unexpected character '{exc.char}' at position {exc.column}"
+        )
+        pattern = self._patterns.get(last_token.type)
+        if pattern:
+            message += f". Expected pattern: {pattern}"
+        return message
+
+    def __str__(self):
+        return self.args[0]
+
+
+class ParsingError(ParseError):
+    """Human-readable wrapper around parser-level failures.
+
+    Handles both UnexpectedToken (a valid token in an invalid position) and
+    UnexpectedEOF (the formula ended before it was complete). The expected-token
+    set is rendered through the same pattern-based resolution as NamingError.
+    """
+
+    def __init__(self, parser: Lark, original_exception, formula: str):
+        self._patterns = _build_pattern_index(parser)
+        expected_str = _format_expected(getattr(original_exception, "expected", None), self._patterns)
+
+        if isinstance(original_exception, UnexpectedEOF):
+            message = (
+                f"SYNTAX_ERROR: Incomplete formula - the input ended unexpectedly. "
+                f"Expected: {expected_str}"
+            )
+        else:
+            token = original_exception.token
+            display = _display_name(token.type, self._patterns)
+            column = getattr(original_exception, "column", None)
+            where = f" at position {column}" if column not in (None, -1) else ""
+            message = (
+                f"SYNTAX_ERROR: Unexpected {display} '{token.value}'{where}. "
+                f"Expected: {expected_str}"
+            )
+            if str(token.value) in _MIXING_SYMBOLS:
+                message += (
+                    ". Hint: Cannot mix conjunction (∧), disjunction (∨), and "
+                    "exclusive or (⊕) without parentheses"
+                )
+
+        self.__dict__.update(original_exception.__dict__)
+        self.args = (message,)
+
+    def __str__(self):
+        return self.args[0]