fix: fixed typos in param names

Author: ashwin6-dev

docs/dev.md

@@ -11,20 +11,20 @@ Select the sort of evlauation you want to using the check box. Make sure to only
 {
   "response": { "formula": "<str>", "truthTable": null | { "variables": ["<str>"], "cells": [[ "<str>" ]] } },
   "answer": {
-    "satisability": true | false,
+    "satisfiability": true | false,
     "tautology": true | false,
     "equivalent": null | "<str>",
-    "truthTable": null | { }
+    "validTruthTable": true | false
   },
   "params": { }
 }
 ```
 
-Exactly one of `satisability`, `tautology`, `equivalent` (non-null), or `truthTable` (non-null) must be set in `answer` to choose the evaluation mode.
+Exactly one of `satisfiability`, `tautology`, `equivalent` (non-null), or `validTruthTable` (true) must be set in `answer` to choose the evaluation mode.
 
-### `truthTable`
+### `validTruthTable`
 
-When `answer.truthTable` is not null, uses truth table evaluation (response must include `truthTable` with `variables` and `cells`).
+When `answer.validTruthTable` is true, uses truth table evaluation (response must include `truthTable` with `variables` and `cells`).
 
 ### `equivalent`
 
@@ -34,9 +34,9 @@ When `answer.equivalent` is a string, checks if response formula and that formul
 
 When `answer.tautology` is true, checks if response formula is a tautology.
 
-### `satisability`
+### `satisfiability`
 
-When `answer.satisability` is true, checks if response formula is satisfiable.
+When `answer.satisfiability` is true, checks if response formula is satisfiable.
 
 ## Outputs
 

evaluation_function/evaluation.py

@@ -66,25 +66,24 @@ def evaluation_function(
 
         formula = formula_parser(response_formula)
 
-        # Answer shape: satisability (bool), tautology (bool), equivalent (None|str), truthTable (None|dict)
-        satisability = answer.get("satisability", False) is True
+        # Answer shape: satisfiability (bool), tautology (bool), equivalent (None|str), validTruthTable (bool)
+        satisfiability = answer.get("satisfiability", answer.get("satisability", False)) is True
         tautology = answer.get("tautology", False) is True
         equivalent = answer.get("equivalent")
         if equivalent is not None and not isinstance(equivalent, str):
             equivalent = None
         elif equivalent is not None and isinstance(equivalent, str) and equivalent.strip() == "":
             equivalent = None
-        answer_truth_table = answer.get("truthTable")
-
+        # validTruthTable (bool) or truthTable (None|dict) for backward compat
+        has_truth_table = answer.get("validTruthTable", False) is True or answer.get("truthTable") is not None
         has_equivalence = equivalent is not None
-        has_truth_table = answer_truth_table is not None
 
-        num_selected = sum([satisability, tautology, has_equivalence, has_truth_table])
+        num_selected = sum([satisfiability, tautology, has_equivalence, has_truth_table])
 
         if num_selected == 0:
             return Result(
                 is_correct=False,
-                feedback_items=[("invalid param", f"please select a param. got {answer}")]
+                feedback_items=[("invalid param", "please select a param")]
             )
         if num_selected > 1:
             return Result(
@@ -120,7 +119,7 @@ def evaluation_function(
             is_correct = EquivalenceEvaluator(formula, answer_formula).evaluate()
         elif tautology:
             is_correct = TautologyEvaluator(formula).evaluate()
-        elif satisability:
+        elif satisfiability:
             is_correct = SatisfiabilityEvaluator(formula).evaluate()
         elif has_truth_table:
             is_correct = True  # already validated above

evaluation_function/evaluation_test.py

@@ -50,7 +50,7 @@ def test_check_tautology_fail(self):
 
     def test_check_satisfiability(self):
         response = {"formula": "p ∧ q"}
-        answer = {"satisability": True, "tautology": False, "equivalent": None, "truthTable": None}
+        answer = {"satisfiability": True, "tautology": False, "equivalent": None, "validTruthTable": False}
         params = Params()
 
         result = evaluation_function(response, answer, params).to_dict()
@@ -59,7 +59,7 @@ def test_check_satisfiability(self):
 
     def test_check_satisfiability_fail(self):
         response = {"formula": "p ∧ ¬p"}
-        answer = {"satisability": True, "tautology": False, "equivalent": None, "truthTable": None}
+        answer = {"satisfiability": True, "tautology": False, "equivalent": None, "validTruthTable": False}
         params = Params()
 
         result = evaluation_function(response, answer, params).to_dict()
@@ -68,7 +68,7 @@ def test_check_satisfiability_fail(self):
 
     def test_check_equivalence(self):
         response = {"formula": "p ∧ q"}
-        answer = {"satisability": False, "tautology": False, "equivalent": "p ∧ (q ∨ q)", "truthTable": None}
+        answer = {"satisfiability": False, "tautology": False, "equivalent": "p ∧ (q ∨ q)", "validTruthTable": False}
         params = Params()
 
         result = evaluation_function(response, answer, params).to_dict()
@@ -77,7 +77,7 @@ def test_check_equivalence(self):
 
     def test_check_equivalence_fail(self):
         response = {"formula": "p ∧ q"}
-        answer = {"satisability": False, "tautology": False, "equivalent": "p", "truthTable": None}
+        answer = {"satisfiability": False, "tautology": False, "equivalent": "p", "validTruthTable": False}
         params = Params()
 
         result = evaluation_function(response, answer, params).to_dict()
@@ -97,7 +97,7 @@ def test_truth_table_valid(self):
                 ]
             }
         }
-        answer = {"satisability": False, "tautology": False, "equivalent": None, "truthTable": {}}
+        answer = {"satisfiability": False, "tautology": False, "equivalent": None, "validTruthTable": True}
         params = Params()
 
         result = evaluation_function(response, answer, params).to_dict()
@@ -117,7 +117,7 @@ def test_truth_table_invalid(self):
                 ]
             }
         }
-        answer = {"satisability": False, "tautology": False, "equivalent": None, "truthTable": {}}
+        answer = {"satisfiability": False, "tautology": False, "equivalent": None, "validTruthTable": True}
         params = Params()
 
         result = evaluation_function(response, answer, params).to_dict()
@@ -145,7 +145,7 @@ def test_missing_formula_field(self):
 
     def test_no_params_selected(self):
         response = {"formula": "p"}
-        answer = {"satisability": False, "tautology": False, "equivalent": None, "truthTable": None}
+        answer = {"satisfiability": False, "tautology": False, "equivalent": None, "validTruthTable": False}
         params = Params()
 
         result = evaluation_function(response, answer, params).to_dict()
@@ -154,7 +154,7 @@ def test_no_params_selected(self):
 
     def test_multiple_params_selected(self):
         response = {"formula": "p"}
-        answer = {"satisability": True, "tautology": True, "equivalent": None, "truthTable": None}
+        answer = {"satisfiability": True, "tautology": True, "equivalent": None, "validTruthTable": False}
         params = Params()
 
         result = evaluation_function(response, answer, params).to_dict()