Update app.py

app.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 3.10
+PRACTICALITY SYSTEM 3.11
 
 ===================================================================
 ARCHITECTURE & TENSOR TRANSITION MANIFESTO (V4.0 PREP)
@@ -23,16 +23,16 @@ without regressions, we must adhere to the following mapping:
      Invalid regions generate boolean bitmasks `valid_mask = np.ones(N_boxes)`.
 ===================================================================
 
-Changes from 3.9:
-  FIX 1 — The Dual-Sniper: V3.9 enforced causal ordering, which solved chain10 
-          but slightly degraded symmetric meshes like quantum5. `_algebraic_snap` 
-          now evaluates BOTH greedy (shortest distance) and causal (topological) 
-          paths, picking the lowest CE.
-  FIX 2 — Topological Shrink (Negative Root Recovery): Resolves the `fully10` 
-          trap. If a projection yields a math domain error (e.g. sqrt of a negative 
-          due to overshooting a sphere), it geometrically contracts the inputs 10% 
-          towards their bound midpoints to bring them back into the real domain 
-          and retries the projection.
+Changes from 3.10:
+  FIX 1 — Coordinate Walker State Bug: V3.10 successfully evaluated CE spikes 
+          but failed to persist them into the walking binding, effectively 
+          paralyzing the walker and crashing chain10's solve rate. The state 
+          tracking is now correctly decoupled: the walker takes the spike, while 
+          the absolute `best_overall` state is safely preserved.
+  FIX 2 — Topological Shrink State Bug: V3.10 shrank variables to avoid math 
+          domain errors (negative roots) but didn't save the shrunk variables 
+          to the binding. It now formally updates the binding dependencies, 
+          which creates the geometric tractor-beam fully10 requires.
 """
 
 import asyncio, time, random, math, threading, warnings
@@ -260,7 +260,7 @@ def expand_psl(prog:PSLProgram) -> ExpandedProblem:
 
     def add_con(kind,expr,direction,scope="root",weight=1.0,branches=None):
         idx=len(constraints)
-        constraints.append(Constraint(kind,expr,direction,weight,scope,branches or[]))
+        constraints.append(Constraint(kind,expr,direction,weight,scope,branches or []))
         scope_groups[scope].append(idx)
         try:
             syms={v:sp.Symbol(v) for v in variables}
@@ -330,7 +330,7 @@ def expand_psl(prog:PSLProgram) -> ExpandedProblem:
     return ExpandedProblem(variables,bounds,constraints, dict(scope_groups),dict(scope_vars),scope_order)
 
 # ══════════════════════════════════════════════════════════════════════════
-# SECTION 4: PROBLEM DEFINITION 
+# SECTION 4: PROBLEM DEFINITION (WITH ALGEBRAIC CACHING)
 # ══════════════════════════════════════════════════════════════════════════
 
 PROJECTION_CACHE: Dict[str, Dict[str, List[Dict]]] = {}
@@ -349,7 +349,7 @@ class MathConstraint:
     parsed:Optional[sp.Expr]=field(default=None,repr=False)
     degree:int=1; scope:str="root"
     branches:List['MathConstraint']=field(default_factory=list)
-    projections:Dict[str,List[Dict]]=field(default_factory=dict)
+    projections:Dict[str,List[Dict]]=field(default_factory=dict) 
 
 def compile_mc(kind,expr_str,direction,variables,weight=1.0,scope="root",branches=None):
     mc=MathConstraint(kind=kind,expr_str=expr_str,direction=direction,weight=weight,scope=scope)
@@ -617,12 +617,10 @@ def _global_hc4_tighten(problem:Problem) -> Dict[str,Tuple[float,float]]:
     if orig_vol > 0 and new_vol < orig_vol * HC4_VOLUME_FLOOR: return dict(problem.bounds)
     return {v:(max(problem.bounds[v][0], contracted[v].lo), min(problem.bounds[v][1], contracted[v].hi)) for v in problem.bounds if v in contracted}
 
-def _single_snap_pass(problem: Problem, proj_binding: Dict[str, float], ordered_vars: List[str], best_ce: float, spike_tolerance: float) -> Tuple[Dict[str, float], float, bool]:
-    improved_in_step = False
-    best_binding = dict(proj_binding)
-    
-    l9 = RESIDUAL_ORACLE.evaluate(proj_binding, problem,[])
-    if not l9.dominant_exprs: return best_binding, best_ce, False
+def _single_snap_pass(problem: Problem, current_binding: Dict[str, float], ordered_vars: List[str], current_ce: float, spike_tolerance: float) -> Tuple[Dict[str, float], float, bool]:
+    l9 = RESIDUAL_ORACLE.evaluate(current_binding, problem,[])
+    if not l9.dominant_exprs: 
+        return current_binding, current_ce, False
 
     for worst_expr in l9.dominant_exprs[:3]:
         target_mc = next((mc for mc in problem.compiled_constraints if mc.expr_str == worst_expr), None)
@@ -639,21 +637,20 @@ def _single_snap_pass(problem: Problem, proj_binding: Dict[str, float], ordered_
         for v in ordered_vars:
             if v not in target_mc.projections: continue
             for proj in target_mc.projections[v]:
-                
-                # FIX 2: Topological Shrink (Domain Error Recovery)
-                # We attempt the projection. If it throws ValueError (e.g. sqrt(-x) due to being 
-                # outside a sphere), we pull the inputs 10% towards bounds-center and retry.
+                test_binding = dict(current_binding)
                 val = None
                 try:
-                    args = [proj_binding.get(s, 0.0) for s in proj["syms"]]
+                    args = [test_binding.get(s, 0.0) for s in proj["syms"]]
                     val = float(proj["func"](*args))
                 except (ValueError, TypeError):
-                    shrunk_args =[]
+                    # FIX 2: Topological Shrink. Safe state persistence.
                     for s in proj["syms"]:
                         lo, hi = problem.bounds.get(s, (-1e18, 1e18))
                         mid = (lo + hi) / 2.0 if lo != -1e18 else 0.0
-                        shrunk_args.append(proj_binding.get(s, mid) * 0.9 + mid * 0.1)
-                    try: val = float(proj["func"](*shrunk_args))
+                        test_binding[s] = test_binding.get(s, mid) * 0.9 + mid * 0.1
+                    try:
+                        args = [test_binding.get(s, 0.0) for s in proj["syms"]]
+                        val = float(proj["func"](*args))
                     except: continue
 
                 if val is None or not math.isfinite(val) or abs(val) > 1e6:
@@ -662,34 +659,23 @@ def _single_snap_pass(problem: Problem, proj_binding: Dict[str, float], ordered_
                 lo, hi = problem.bounds.get(v, (-1e18, 1e18))
                 if not (lo <= val <= hi): continue
                     
-                test_binding = dict(proj_binding)
                 test_binding[v] = val
                 new_ce = problem.constraint_energy(test_binding)
                 
-                if new_ce < best_ce * (1 + spike_tolerance):
-                    proj_binding = test_binding
-                    improved_in_step = True
-                    if new_ce < best_ce:
-                        best_ce = new_ce
-                        best_binding = dict(proj_binding)
-                    break
-            if improved_in_step: break
-        if improved_in_step: break
-        
-    return best_binding, best_ce, improved_in_step
+                # FIX 1: Proper state tracking for spikes. 
+                # Returns immediately so caller can preserve the spike into the next round.
+                if new_ce < current_ce * (1 + spike_tolerance):
+                    return test_binding, new_ce, True
+                    
+    return current_binding, current_ce, False
 
 def _algebraic_snap(problem: Problem, binding: Dict[str, float]) -> Tuple[Dict[str, float], float]:
-    """
-    FIX 1: Dual-Sniper logic. Runs both Greedy (minimum-distance) and Causal (topological) 
-    paths, returning the best. Cures the quantum5 jitter while preserving chain10 solves.
-    """
     best_ce_overall = problem.constraint_energy(binding)
     best_binding_overall = dict(binding)
     
     active_scopes = [s for s in problem.scope_order if s != "root" and problem.scope_vars.get(s)]
     l7 = TOPOLOGY_ORACLE.evaluate(problem, active_scopes)
     
-    # 1. Evaluate Causal (Topological) Order
     ordered_vars =[]
     if l7.solve_order:
         for sn in l7.solve_order:
@@ -698,20 +684,25 @@ def _algebraic_snap(problem: Problem, binding: Dict[str, float]) -> Tuple[Dict[s
     for v in problem.variables:
         if v not in ordered_vars: ordered_vars.append(v)
 
-    causal_b = dict(binding); causal_ce = best_ce_overall
+    # 1. Causal order pass
+    causal_b = dict(binding)
+    causal_ce = best_ce_overall
     for _ in range(20):
         causal_b, causal_ce, improved = _single_snap_pass(problem, causal_b, ordered_vars, causal_ce, 0.15)
+        if causal_ce < best_ce_overall:
+            best_ce_overall = causal_ce
+            best_binding_overall = dict(causal_b)
         if not improved or causal_ce < SOLVE_THRESHOLD: break
 
-    # 2. Evaluate Greedy Order (Prioritizing global variables regardless of scope topology)
-    greedy_vars = problem.variables
-    greedy_b = dict(binding); greedy_ce = best_ce_overall
+    # 2. Greedy order pass
+    greedy_b = dict(binding)
+    greedy_ce = problem.constraint_energy(binding)
     for _ in range(20):
-        greedy_b, greedy_ce, improved = _single_snap_pass(problem, greedy_b, greedy_vars, greedy_ce, 0.15)
+        greedy_b, greedy_ce, improved = _single_snap_pass(problem, greedy_b, problem.variables, greedy_ce, 0.15)
+        if greedy_ce < best_ce_overall:
+            best_ce_overall = greedy_ce
+            best_binding_overall = dict(greedy_b)
         if not improved or greedy_ce < SOLVE_THRESHOLD: break
-
-    if causal_ce < best_ce_overall: best_ce_overall = causal_ce; best_binding_overall = causal_b
-    if greedy_ce < best_ce_overall: best_ce_overall = greedy_ce; best_binding_overall = greedy_b
         
     return best_binding_overall, best_ce_overall
 
@@ -1297,7 +1288,7 @@ async def lifespan(app: FastAPI):
     yield
     POOL.shutdown(wait=False)
 
-app = FastAPI(title="Practicality System 3.10", lifespan=lifespan)
+app = FastAPI(title="Practicality System 3.11", lifespan=lifespan)
 
 @app.post("/inject/{pid}")
 async def inject_seed(pid:str, request:Request):
@@ -1372,7 +1363,7 @@ async def dashboard():
                 f"font-size:0.85em;margin:2px'>{label}: {val}</span>")
                 
     html=f"""<!DOCTYPE html><html>
-<head><title>Practicality System 3.10</title>
+<head><title>Practicality System 3.11</title>
 <meta http-equiv="refresh" content="3">
 <style>
   body{{background:#0a0a0a;color:#e0e0e0;font-family:monospace;padding:20px}}
@@ -1383,7 +1374,7 @@ async def dashboard():
   th{{color:#444}}
   .witness-box{{background:#111; border:1px solid #333; padding:15px; color:#aaa; white-space:pre-wrap; font-size:0.9em;}}
 </style></head><body>
-<h1>⚗ Practicality System 3.10</h1>
+<h1>⚗ Practicality System 3.11</h1>
 <div style='margin-bottom:16px;line-height:2.2em;'>
   {badge("Trials",runs,"#aaa")}
   {badge("Avg rounds",avg_rounds,"#aaa")}