Implemented parser to convert string into propositional logic.

Does not support brackets.

Author: HarrySu123

evaluation_function/evaluation.py

@@ -1,6 +1,105 @@
 from typing import Any
 from lf_toolkit.evaluation import Result, Params
 
+from evaluation_function.propositional_logic.formula import *
+
+
+def parse_response(response: str) -> tuple[bool, Formula | str]:
+
+    response = response.strip()
+    
+    # binaryOperators = ["↔","→","∨","∧"]
+    # TODO: keep this mapping somewhere else for maintainability
+    binaryOperators = {
+        "↔" : Biconditional,
+        "→" : Implication,
+        "∨" : Disjunction,
+        "∧" : Conjunction
+    }
+
+    for binaryOperator in binaryOperators.keys():
+
+        if binaryOperator in response:
+            split_index = response.rindex(binaryOperator)
+
+            left  = response[:split_index]
+            right = response[split_index+1:]
+
+            # check left and right not empty strings
+            if not left:
+                return (False, f"missing text on left of {binaryOperator}")
+            elif not right:
+                return (False, f"missing text on right of {binaryOperator}")
+            
+            parse_left = parse_response(left)
+            parse_right = parse_response(right)
+
+            error = False
+            err_msgs = []
+
+            if not parse_left[0]:
+                error = True
+                err_msgs.append(parse_left[1])
+
+            if not parse_right[0]:
+                error = True
+                err_msgs.append(parse_right[1])
+            
+            if error:
+                return (False, err_msgs.join("\n"))
+            
+            # both sides are find and valid
+            result = binaryOperators[binaryOperator](parse_left[1], parse_right[1])
+            return (True, result)
+    
+
+    # TODO: keep this mapping somewhere else for maintainability
+    unaryOperators = {
+        "¬" : Negation
+    }
+
+    for unaryOperator in unaryOperators.keys():
+
+        #unary operator must syntactically be at the start of the string
+        if response[0] == unaryOperator:
+            
+            right = response[1:]
+            #check not empty
+            if not right:
+                return (False, f"missing text on right of {unaryOperator}")
+
+            parse_right = parse_response(right)
+            if not parse_right[0]:
+                return parse_right
+            
+            result = unaryOperators[unaryOperator](parse_right[1])
+            return (True, result)
+    
+    # check if the formual is just True or Falsity
+    
+    singletons = { # not sure what the official term for these symbols is
+        "⊤" : Truth,
+        "⊥" : Falsity
+    }
+
+    for singleton in singletons:
+
+        if len(response) > 1 and singleton in response:
+            return (False, f"not allowed to use {singleton} in the atom identifier")
+
+        elif response == singleton:
+            result = singletons[singleton]()
+            return (True, result)
+    
+    # response is likely an atom identifier
+    
+    return (True, Atom(response))
+
+
+        
+    
+
+
 def evaluation_function(
     response: Any,
     answer: Any,
@@ -29,6 +128,27 @@ def evaluation_function(
     to output the evaluation response.
     """
 
-    return Result(
-        is_correct=response == answer
-    )
+
+    if not isinstance(answer, str):
+        raise Exception("Answer must be a string/text.")
+    
+
+    if not isinstance(response, str):
+        return Result(
+            is_correct=False,
+            feedback="Please enter a string/text."
+        )
+
+    
+    # this can be "equivilance", "tautology", "satisfiability"
+    #potnetially can be switched with classes
+    action = params.get("action", None)
+    
+    feedback   = None
+    is_correct = False
+
+    pl_formula = parse_response(response) 
+
+    #swtich on action       
+
+    return Result(is_correct=False)

examples/basic_formula_parsing.py

@@ -0,0 +1,61 @@
+from evaluation_function.evaluation import parse_response
+
+from evaluation_function.propositional_logic import (
+    Atom,
+    Truth,
+    Falsity,
+    Negation,
+    Conjunction,
+    Disjunction,
+    Implication,
+    Biconditional,
+    Assignment,
+    FormulaEvaluator,
+)
+
+def main():
+    p = Atom("p")
+    q = Atom("q")
+    
+    print("=== Basic Formula Parsing ===")
+    print()
+
+    formulas = [
+        ("p", p),
+        ("q", q),
+        ("⊤", Truth()),
+        ("⊥", Falsity()),
+        ("¬p", Negation(p)),
+        ("p ∧ q", Conjunction(p, q)),
+        ("p ∨ q", Disjunction(p, q)),
+        ("p → q", Implication(p, q)),
+        ("p ↔ q", Biconditional(p, q)),
+    ]
+
+    passed = 0
+
+    for name, formula in formulas:
+        result = None
+
+        try:
+            result = parse_response(name)[1]
+        except Exception as e:
+            reslt = e
+
+        if formula != result:
+            print()
+            print("failed!!!!!!!!!!!!!!!!!!!!!!")
+            print(f"formula:  {name}")
+            print(f"expected: {formula}")
+            print(f"actual:   {result}")
+        else:
+            print("passed")
+            passed += 1
+
+    print()
+    print("=== Result ===")
+    print(f"{passed}/{len(formulas)}")
+    
+
+if __name__ == "__main__":
+    main()

examples/complex_formula_parsing.py

@@ -0,0 +1,58 @@
+from evaluation_function.evaluation import parse_response
+
+from evaluation_function.propositional_logic import (
+    Atom,
+    Truth,
+    Falsity,
+    Negation,
+    Conjunction,
+    Disjunction,
+    Implication,
+    Biconditional,
+    Assignment,
+    FormulaEvaluator,
+)
+
+def main():
+    p = Atom("p")
+    q = Atom("q")
+    
+    print("=== Complex Formula Parsing ===")
+    print()
+
+    formulas = [
+        ("p ∧ q ∨ q", Disjunction(Conjunction(p, q), q)),
+        # ("p ∨ q",     Disjunction(p, q)),
+        ("p → p ∨ q", Implication(p, Disjunction(p, q))),
+        ("p ↔ p → p", Biconditional(p, Implication(p, p))),
+        ("p ↔ p ↔ p ↔ p", Biconditional(Biconditional(Biconditional(p, p), p), p)),
+        ("p ∧ q → ¬p ∨ q", Implication((Conjunction(p, q)), Disjunction(Negation(p), q)))
+    ]
+
+    passed = 0
+
+    for name, formula in formulas:
+        result = None
+
+        try:
+            result = parse_response(name)[1]
+        except Exception as e:
+            reslt = e
+
+        if formula != result:
+            print()
+            print("failed!!!!!!!!!!!!!!!!!!!!!!")
+            print(f"formula:  {name}")
+            print(f"expected: {formula}")
+            print(f"actual:   {result}")
+        else:
+            print("passed")
+            passed += 1
+
+    print()
+    print("=== Result ===")
+    print(f"{passed}/{len(formulas)}")
+    
+
+if __name__ == "__main__":
+    main()