Update app.py

app.py

@@ -11,11 +11,15 @@ ARCHITECTURE:
             → [GEMINI COLLAPSER]  → Domain-language explanation
 
 CRITICAL FIXES MAINTAINED:
-  - The Squeeze Bug Fix (.view(B, -1).sum(dim=1) for absolute dimensional stability against hallucinations)
+  - The Squeeze Bug Fix (.view(B, -1).sum(dim=1) for absolute dimensional stability)
   - The Two Brains Sync (Gate 1 Verification directly calls PyTorch L2 loss)
   - The Anti-LaTeX Shield (Native handling of hallucinated `^` characters)
   - Unbound Local Safety (Zero-Shot crash protection in Axiom constructors)
   - Fully Expanded Codebase (Zero minification for maximum Python stability)
+  - Undefined Observation Shield (Force-injects orphaned LLM observations)
+  - Undefined Symbol Shield (Blocks SymPy from invoking float() on Tensors)
+  - Extended PT Map Shield (Wires complex trig/logs directly to PyTorch)
+  - Relational Hallucination Shield (Forces Eq(x,y) into x - y)
 """
 
 import os, time, random, math, threading, warnings, json, textwrap, itertools
@@ -270,10 +274,19 @@ class AXLInvariant:
     syms_used:List[str]=field(default_factory=list)
 
     def compile(self,variables:List[str]):
-        # Anti-LaTeX Syntax Shield
         self.expr = self.expr.replace("^", "**")
         syms={v:sp.Symbol(v) for v in variables}
         parsed=parse_expr(self.expr,local_dict=syms)
+        
+        # Relational Hallucination Shield
+        if getattr(parsed, 'is_Equality', False) or getattr(parsed, 'is_Relational', False):
+            parsed = parsed.lhs - parsed.rhs
+            
+        # Undefined Symbol Shield
+        for s in list(parsed.free_symbols):
+            if str(s) not in variables:
+                parsed = parsed.subs(s, 1.0)
+                
         self.syms_used=[str(s) for s in parsed.free_symbols if str(s) in variables]
         self.compiled_func=sp.lambdify([sp.Symbol(v) for v in self.syms_used],parsed,modules="math")
 
@@ -287,10 +300,21 @@ class AXLProblemDef:
 class AXLtoPSLCompiler:
     def compile(self,prob:AXLProblemDef) -> str:
         lines=[f"SPACE base_{prob.name}"]
+        emitted_vars = set()
+        
         for v in prob.variables:
             lo,hi=v["lo"],v["hi"]
             if v["name"] in prob.observations: val=prob.observations[v["name"]]; lo=hi=val
             lines.append(f"VAR {v['name']} {lo} {hi}")
+            emitted_vars.add(v["name"])
+            
+        # ── UNDEFINED OBSERVATION SHIELD ──
+        # Ensure any observations hallucinated purely into constraints without variable declarations are injected into the space
+        for obs_name, obs_val in prob.observations.items():
+            if obs_name not in emitted_vars:
+                lines.append(f"VAR {obs_name} {obs_val} {obs_val}")
+                emitted_vars.add(obs_name)
+                
         for c in prob.constraints:
             wt=c.get("weight",1.0)
             expr = str(c['expr']).replace("^", "**")
@@ -358,12 +382,29 @@ def compile_mc(kind,expr_str,direction,variables,weight=1.0,scope="root",branche
 
     syms = {v: sp.Symbol(v) for v in variables}
     try:
-        parsed = parse_expr(expr_str, local_dict=syms)
+        parsed = parse_expr(expr_str, local_dict=syms) if kind!="or_eq" else None
+        if parsed:
+            # Relational Hallucination Shield
+            if getattr(parsed, 'is_Equality', False) or getattr(parsed, 'is_Relational', False):
+                parsed = parsed.lhs - parsed.rhs
+                
+            # Undefined Symbol Shield: Swap out generic symbols before lambdifying to PyTorch
+            for s in list(parsed.free_symbols):
+                if str(s) not in variables:
+                    parsed = parsed.subs(s, 1.0)
+                    
         mc.parsed = parsed
         mc.syms_used = [v for v in variables if sp.Symbol(v) in parsed.free_symbols]
         mc.fast_iv = compile_iv(parsed, variables)
         
-        pt_map = {'sin': torch.sin, 'cos': torch.cos, 'exp': torch.exp, 'sqrt': torch.sqrt, 'Abs': torch.abs}
+        # ── EXTENDED PT MAP SHIELD ──
+        pt_map = {
+            'sin': torch.sin, 'cos': torch.cos, 'tan': torch.tan,
+            'exp': torch.exp, 'log': torch.log, 'sqrt': torch.sqrt,
+            'Abs': torch.abs, 'asin': torch.asin, 'acos': torch.acos,
+            'atan': torch.atan, 'sinh': torch.sinh, 'cosh': torch.cosh,
+            'tanh': torch.tanh, 'pi': math.pi, 'E': math.e
+        }
         t_func_raw = sp.lambdify([sp.Symbol(v) for v in mc.syms_used], parsed, modules=[pt_map, "math"])
         
         def _t_wrapper(*args):
@@ -512,7 +553,6 @@ class Problem:
             total += (out_of_bounds ** 2) * 10.0
             
         # ── THE TRUE SQUEEZE BUG FIX ──
-        # Reduce any extra tensor dimensions hallucinated by the LLM back to exactly 1 value per batch
         return total.view(batch_size, -1).sum(dim=1)
 
     def scalar_energy(self, b: Dict[str, float]) -> float: