evaluation_function implemented

Author: HarrySu123

evaluation_function/evaluation.py

@@ -2,98 +2,100 @@
 from lf_toolkit.evaluation import Result, Params
 
 from evaluation_function.domain.formula import *
+from parsing.tokenizer import *
+from parsing.tree_builder import *
 
 
-def parse_response(response: str) -> tuple[bool, Formula | str]:
+# def parse_response(response: str) -> tuple[bool, Formula | str]:
 
-    response = response.strip()
+#     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}")
+#     # 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)
+#             parse_left = parse_response(left)
+#             parse_right = parse_response(right)
 
-            error = False
-            err_msgs = []
+#             error = False
+#             err_msgs = []
 
-            if not parse_left[0]:
-                error = True
-                err_msgs.append(parse_left[1])
+#             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 not parse_right[0]:
+#                 error = True
+#                 err_msgs.append(parse_right[1])
 
-            if error:
-                return (False, err_msgs.join("\n"))
+#             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)
+#             # 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
-    }
+#     # TODO: keep this mapping somewhere else for maintainability
+#     unaryOperators = {
+#         "¬" : Negation
+#     }
 
-    for unaryOperator in unaryOperators.keys():
+#     for unaryOperator in unaryOperators.keys():
 
-        #unary operator must syntactically be at the start of the string
-        if response[0] == unaryOperator:
+#         #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
+#             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)
+#             result = unaryOperators[unaryOperator](parse_right[1])
+#             return (True, result)
 
-    # check if the formual is just True or Falsity
+#     # check if the formual is just True or Falsity
 
-    singletons = { # not sure what the official term for these symbols is
-        "⊤" : Truth,
-        "⊥" : Falsity
-    }
+#     singletons = { # not sure what the official term for these symbols is
+#         "⊤" : Truth,
+#         "⊥" : Falsity
+#     }
 
-    for singleton in singletons:
+#     for singleton in singletons:
 
-        if len(response) > 1 and singleton in response:
-            return (False, f"not allowed to use {singleton} in the atom identifier")
+#         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)
+#         elif response == singleton:
+#             result = singletons[singleton]()
+#             return (True, result)
 
-    # response is likely an atom identifier
+#     # response is likely an atom identifier
 
-    return (True, Atom(response))
+#     return (True, Atom(response))
 
 
 
@@ -129,8 +131,8 @@ def evaluation_function(
     """
 
 
-    if not isinstance(answer, str):
-        raise Exception("Answer must be a string/text.")
+    # if not isinstance(answer, str):
+    #     raise Exception("Answer must be a string/text.")
 
 
     if not isinstance(response, str):
@@ -147,8 +149,44 @@ def evaluation_function(
     feedback   = None
     is_correct = False
 
-    pl_formula = parse_response(response) 
+    # tokenize response
+    tokenizer = Tokenizer(response)
+    tokens = []
 
-    #swtich on action       
+    try:
+        while True:
+            token = tokenizer.next_token()
+            tokens.append(token)
+            if token.type == TokenType.EOF:
+                break
+    
+    except ValueError as e:
+        return Result(
+            is_correct=False,
+            feedback=str(e)
+        )
+
+
+    # parse tokens into Formula
+    try:
+        builder = TreeBuilder(tokens)
+        formula = builder.build()
+    
+    except BuildError as e:
+        return Result(
+            is_correct=False,
+            feedback=str(e)
+        )
+
+    #swtich on action
+    
+    match action:
+        case "tautology":
+            is_correct = TautologyEvaluator(formula).evaluate()
+        
+        case "satisfiability":
+            is_correct = SatisfiabilityEvaluator(formula).evaluate()
+
+        # equivalence
 
-    return Result(is_correct=False)
+    return Result(is_correct=is_correct)