Hotfix (#149)

Author: sidprasad

CHANGELOG.md

@@ -3,6 +3,7 @@
 This document summarizes notable updates since February 2025, with commit dates from the repository history for context.【728428†L1-L48】
 
 ## 2026-03
+- **Bugfix:** Fixed `canonicalizeSpotTrace` corrupting SPOT traces containing `|` (OR) in state formulas (e.g. `(s & v) | (!s & !v)`). The canonicalizer now resolves OR operators before reordering literals, preventing garbled traces that caused wrong correct-answer labels on trace satisfaction questions.
 - Fixed trace literal canonicalization to normalize both `!` and `¬` negation markers before lexicographic sorting, so variable ordering is stable regardless of glyph choice.
 - Fixed instructor exercise preview so it renders the current draft question set (including unsaved editor changes) instead of only the previously saved database state.
 - Added explicit save confirmation showing how many questions were persisted for instructor exercises, reducing ambiguity when validating multi-question saves.

src/exerciseprocessor.py

@@ -204,25 +204,41 @@ def nodeReprListsToSpotTrace(prefix_states, cycle_states) -> str:
     return prefix_string + ";" + cycle_string
 
 
+def _resolve_ors_in_state(state_str: str) -> str:
+    """Resolve any OR (|) operators in a SPOT state formula by choosing one branch.
+    SPOT traces may contain states like '(s & v) | (!s & !v)' which represent
+    multiple valid assignments. This picks one concrete assignment."""
+    state_str = state_str.strip()
+    if not state_str or state_str in ('1', '0'):
+        return state_str
+    if '|' not in state_str:
+        return state_str
+    try:
+        return choosePathFromWord(state_str)
+    except Exception:
+        return state_str
+
+
 def canonicalizeSpotTrace(sr: str) -> str:
     """
     Return a trace string with each state's literals in canonical order.
     This preserves the original prefix/cycle structure and only normalizes
-    literal ordering within states.
+    literal ordering within states. OR operators in SPOT state formulas are
+    resolved first by choosing one concrete assignment.
     """
     sr = sr.strip()
     if sr == "":
         return ""
 
     prefix_split = sr.split('cycle', 1)
     prefix_parts = [x for x in prefix_split[0].strip().split(';') if x.strip() != ""]
-    canonical_prefix = [NodeRepr._canonicalize_state(part) for part in prefix_parts]
+    canonical_prefix = [NodeRepr._canonicalize_state(_resolve_ors_in_state(part)) for part in prefix_parts]
 
     cycle_parts = []
     if len(prefix_split) > 1:
         cycled_content = getCycleContent(prefix_split[1])
         cycle_parts = [x for x in cycled_content.split(';') if x.strip() != ""]
-        cycle_parts = [NodeRepr._canonicalize_state(part) for part in cycle_parts]
+        cycle_parts = [NodeRepr._canonicalize_state(_resolve_ors_in_state(part)) for part in cycle_parts]
 
     prefix_string = ';'.join(canonical_prefix)
     if len(cycle_parts) > 0:

src/templates/version.html

@@ -1 +1 @@
-1.9.11
+1.9.12

test/test_trace_canonicalization.py

@@ -43,6 +43,36 @@ def test_mermaid_rendering_still_shows_negation_symbol(self):
         rendered = node.__mermaid_str__()
         self.assertIn("¬b", rendered)
 
+    def test_canonicalize_resolves_or_in_state(self):
+        """SPOT may output states with | (OR). canonicalizeSpotTrace must resolve
+        ORs before reordering literals, otherwise the trace gets corrupted."""
+        trace = "(s & v) | (!s & !v); cycle{1}"
+        result = canonicalizeSpotTrace(trace)
+        # The OR should be resolved to one concrete branch, not garbled
+        self.assertNotIn("|", result.split("cycle")[0],
+            "OR should be resolved in prefix states")
+        # Result must be one of the two valid branches
+        prefix = result.split(";")[0].strip()
+        self.assertIn(prefix, ["s & v", "!s & !v"],
+            f"Expected a valid branch, got '{prefix}'")
+
+    def test_canonicalize_resolves_or_in_cycle(self):
+        """ORs in cycle states must also be resolved."""
+        trace = "s & v; cycle{(s & v) | (!s & !v)}"
+        result = canonicalizeSpotTrace(trace)
+        # Extract cycle content
+        cycle_part = result.split("cycle{")[1].rstrip("}")
+        self.assertNotIn("|", cycle_part,
+            "OR should be resolved in cycle states")
+        self.assertIn(cycle_part, ["s & v", "!s & !v"],
+            f"Expected a valid branch in cycle, got '{cycle_part}'")
+
+    def test_canonicalize_preserves_simple_traces(self):
+        """Traces without OR should be unaffected by the OR-resolution step."""
+        trace = "!s & v; cycle{s & !v}"
+        result = canonicalizeSpotTrace(trace)
+        self.assertEqual(result, "!s & v;cycle{s & !v}")
+
 
 if __name__ == "__main__":
     unittest.main()