V9.0.1: SymPy Pipeline Hardening (Aggressive Sanitizer, Hebrew & Arrow Stripping)

domain/math_validator.py

@@ -7,6 +7,7 @@ import asyncio
 from typing import Tuple, List, Optional
 import sympy
 from sympy.parsing.sympy_parser import parse_expr
+from utils.math_utils import aggressive_sympy_sanitizer
 
 logger = logging.getLogger(__name__)
 
@@ -205,18 +206,13 @@ class MathPolygraph:
     @staticmethod
     async def _check_segment(raw_segment: str, step_id) -> Tuple[bool, str]:
         """Internal helper to validate a single extracted math segment."""
-        # 4. Multi-Equal Sign Handling & Unpacking Crash Prevention
-        eq_count = raw_segment.count('=')
+        # V9.0.1: Use Aggressive Sanitizer to handle Hebrew, Arrows, and Comma-splitting
+        sanitized_parts = aggressive_sympy_sanitizer(raw_segment)
         
-        parts_to_check = []
-        if eq_count >= 1:
-            # Split by all equalities and check each segment (e.g. x=y=5 -> check x, y, 5)
-            # This bypasses SymPy's inability to parse "=" and prevents split() unpacking errors.
-            parts_to_check = [p.strip() for p in raw_segment.split('=') if p.strip()]
-        else:
-            parts_to_check = [raw_segment]
+        if not sanitized_parts:
+            return True, ""
 
-        for part in parts_to_check:
+        for part in sanitized_parts:
             sympy_str = _latex_to_sympy_str(part)
             if not sympy_str or sympy_str in ('', '-', '()', '( )'):
                 continue
@@ -225,6 +221,8 @@ class MathPolygraph:
                 # Run with timeout to prevent ReDoS or complex simplification hangs
                 status = await asyncio.to_thread(MathPolygraph._sympify_with_timeout, sympy_str)
                 if status is False:
+                    # Provide clearer error context
+                    logger.warning(f"[V9.0.1] SymPy Parse Error on part '{part}' (from segment '{raw_segment}')")
                     return False, f"SYMPY_PARSE_ERROR:step_{step_id}"
                 elif status is None:
                     # Timeout is treated as a soft warning for now

orchestrator.py

@@ -9,7 +9,7 @@ from domain.math_validator import MathPolygraph         # V1.0: SymPy Polygraph
 from domain.processing_strategy import ProcessingStrategy
 from domain.ontology import get_allowed_concepts, get_pedagogical_tag
 from domain.math_normalizer import MathCanonicalizer
-from utils.math_utils import sanitize_latex_for_sympy
+from utils.math_utils import sanitize_latex_for_sympy, aggressive_sympy_sanitizer
 from domain.curriculum_classifier import CurriculumClassifier
 from domain.proposal_engine import ProposalEngine
 from domain.risk_engine import CognitiveRiskEngine
@@ -58,12 +58,10 @@ def build_ast_metadata(math_input: str, category: str) -> dict:
     estimated_complexity = 0.5
 
     try:
-        parts = str(math_input).split(',')
+        parts = aggressive_sympy_sanitizer(math_input)
         free_syms = set()
-        for part in parts:
+        for clean_part in parts:
             try:
-                # V317.8: Clean LaTeX (colors/text) before validation
-                clean_part = sanitize_latex_for_sympy(part)
                 expr = sp.sympify(clean_part.replace('=', '-'), evaluate=False)
                 free_syms.update(expr.free_symbols)
             except Exception as e:
@@ -80,7 +78,7 @@ def build_ast_metadata(math_input: str, category: str) -> dict:
     # Build node registry for Planner (IDs → expressions)
     ast_registry = {}
     try:
-        parts = [p.strip() for p in str(math_input).split(',')]
+        parts = aggressive_sympy_sanitizer(math_input)
         for i, part in enumerate(parts):
             ast_registry[f"ast_node_{i}"] = part
     except Exception as e:

smart_solver.py

@@ -11,6 +11,8 @@ from dataclasses import dataclass
 import copy
 from domain.step_types import StepType, SignedStep
 
+from utils.math_utils import aggressive_sympy_sanitizer
+
 logger = logging.getLogger(__name__)
 
 # ==================== V7.3: TYPED ACTION CONTRACT ====================
@@ -449,8 +451,19 @@ class StepValidator:
         Deterministically verifies the algebraic equivalence between two steps.
         """
         try:
-            expr_n = sympify(str(step_n).replace('=', '-'), evaluate=False)
-            expr_n_plus_1 = sympify(str(step_n_plus_1).replace('=', '-'), evaluate=False)
+            # V9.0.1: Aggressive sanitization before comparison
+            # We take the first expression from the sanitizer if multiple are returned
+            parts_n = aggressive_sympy_sanitizer(str(step_n))
+            parts_n_plus_1 = aggressive_sympy_sanitizer(str(step_n_plus_1))
+            
+            if not parts_n or not parts_n_plus_1:
+                return False
+                
+            clean_n = parts_n[0].replace('=', '-')
+            clean_n_plus_1 = parts_n_plus_1[0].replace('=', '-')
+
+            expr_n = sympify(clean_n, evaluate=False)
+            expr_n_plus_1 = sympify(clean_n_plus_1, evaluate=False)
             
             # Use simplify to check equivalence
             diff = simplify(expr_n - expr_n_plus_1)
@@ -481,12 +494,15 @@ class StepValidator:
         and no hallucinations occurred via injected fake constants/variables.
         """
         try:
-            initial_exprs = [sympify(str(p).replace('=', '-'), evaluate=False) for p in str(initial_math).split(',')]
+            # V9.0.1: Aggressive sanitization
+            initial_parts = aggressive_sympy_sanitizer(str(initial_math))
+            initial_exprs = [sympify(str(p).replace('=', '-'), evaluate=False) for p in initial_parts]
             initial_vars = set()
             for ex in initial_exprs:
                 initial_vars.update(ex.free_symbols)
                 
-            final_exprs = [sympify(str(p).replace('=', '-'), evaluate=False) for p in str(final_step).split(',')]
+            final_parts = aggressive_sympy_sanitizer(str(final_step))
+            final_exprs = [sympify(str(p).replace('=', '-'), evaluate=False) for p in final_parts]
             final_vars = set()
             for ex in final_exprs:
                 final_vars.update(ex.free_symbols)

utils/math_utils.py

@@ -21,3 +21,38 @@ def sanitize_latex_for_sympy(latex_str: str) -> str:
     cleaned = cleaned.replace(r'\left', '').replace(r'\right', '')
     
     return cleaned
+
+from typing import List
+
+def aggressive_sympy_sanitizer(latex_str: str) -> List[str]:
+    """
+    V9.0.1: Cleans dirty LaTeX generated by the LLM before feeding it to SymPy.
+    Splits comma-separated equations into a list of pure math strings.
+    """
+    if not latex_str:
+        return []
+    
+    s = latex_str
+    
+    # 1. Strip Hebrew Content including surrounding parentheses (e.g. (לכן C))
+    # This prevents leaving behind empty shells like "( C)" which crash SymPy.
+    s = re.sub(r'\([^)]*[\u0590-\u05FF]+[^)]*\)', '', s)
+    s = re.sub(r'[\u0590-\u05FF]+', '', s)
+    
+    # 2. Strip formatting tags (\text{} and \color{})
+    s = re.sub(r'\\text\{.*?\}', '', s)
+    s = re.sub(r'\\color\{.*?\}', '', s)
+    
+    # 3. Replace Logical Arrows with Equals (to maintain equation structure)
+    arrows = [r'\Rightarrow', r'\implies', r'\iff', r'\rightarrow']
+    for arrow in arrows:
+        s = s.replace(arrow, '=')
+        
+    # 4. Split multiple equations
+    # SymPy cannot parse "x=0, y=9" as a single AST node. 
+    # We must split by comma and return a list of clean equations.
+    # We also run the existing sanitize_latex_for_sympy on each part.
+    expressions = [sanitize_latex_for_sympy(expr.strip()) for expr in s.split(',')]
+    
+    # Filter out empty strings that might have resulted from the split/regex
+    return [e for e in expressions if e]

visuals.py

@@ -13,12 +13,14 @@ def clean_latex_for_sympy(latex_str):
     cleaned = cleaned.replace(r'\ln', 'log')
     return cleaned
 
-def sanitize_math_for_sympy(expr_str: str) -> str:
-    if not expr_str: return ""
-    expr_str = clean_latex_for_sympy(expr_str)
-    
-    # 1. Strip Hebrew
+    # 1. Strip Hebrew Characters and parenthetical Hebrew explanations (V9.0.1)
+    expr_str = re.sub(r'\([^)]*[\u0590-\u05FF]+[^)]*\)', '', expr_str)
     expr_str = re.sub(r'[\u0590-\u05FF]', '', expr_str)
+
+    # 1.1 Replace Logical Arrows with Equals (V9.0.1)
+    arrows = [r'\Rightarrow', r'\implies', r'\iff', r'\rightarrow']
+    for arrow in arrows:
+        expr_str = expr_str.replace(arrow, '=')
     
     # 2. Cut multiple equations
     if r'\\' in expr_str: