Update app.py

app.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 3.9
+PRACTICALITY SYSTEM 3.10
 
 ===================================================================
 ARCHITECTURE & TENSOR TRANSITION MANIFESTO (V4.0 PREP)
@@ -21,20 +21,18 @@ without regressions, we must adhere to the following mapping:
    - Future Tensor: Constraints pre-compiled into vectorized Numpy universal 
      functions (ufuncs). E.g., `np.add(bounds[:, v1, :], bounds[:, v2, :])`.
      Invalid regions generate boolean bitmasks `valid_mask = np.ones(N_boxes)`.
-
-3. THE DEBATE ENGINE:
-   - Current: Sequential execution of Seed, Struct, Perturb, Merge.
-   - Future Tensor: En masse generation. `Perturb` generates 1,000 offsets 
-     via `np.random.normal`, evaluated in parallel against the CE tensor matrix.
 ===================================================================
 
-Changes from 3.8:
-  NEW 1 — Topology-Ordered Snap (The Causal Sniper): The `_algebraic_snap` 
-          function now queries the `L7 Topology Oracle` to determine the causal 
-          solve order of the variables (e.g., x1 -> x2 -> x3 in chain10). 
-          Instead of greedily picking the "minimum distance" projection, it 
-          enforces projections in structural order. This prevents artificial 
-          downstream energy spikes and honors the physical propagation of the constraints.
+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.
 """
 
 import asyncio, time, random, math, threading, warnings
@@ -332,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 (WITH ALGEBRAIC CACHING)
+# SECTION 4: PROBLEM DEFINITION 
 # ══════════════════════════════════════════════════════════════════════════
 
 PROJECTION_CACHE: Dict[str, Dict[str, List[Dict]]] = {}
@@ -351,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)
@@ -537,8 +535,7 @@ class ResidualOracle:
 
 class BridgeOracle:
     def generate_witness(self, problem: Problem, binding: Dict[str, float], ce: float, l7: L7Certificate, l9: L9Certificate) -> str:
-        lines = []
-
+        lines =[]
         lines.append(f"====== UNIVERSAL WITNESS: {problem.pid} ======")
         lines.append(f"STATUS: {'SOLVED' if ce < SOLVE_THRESHOLD else 'STUCK'} (CE: {ce:.6f})")
         lines.append(f"TOPOLOGY: {l7.topology_sig.upper() if l7 else 'NONE'} | Hubs: {', '.join(l7.hub_vars) if l7 and l7.hub_vars else 'None'}")
@@ -620,81 +617,103 @@ 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
+
+    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)
+        if not target_mc:
+            for mc in problem.compiled_constraints:
+                if mc.kind == "or_eq":
+                    for bmc in mc.branches:
+                        if bmc.expr_str == worst_expr: target_mc = bmc; break
+                if target_mc: break
+                
+        if not (target_mc and hasattr(target_mc, 'projections') and target_mc.projections):
+            continue
+            
+        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.
+                val = None
+                try:
+                    args = [proj_binding.get(s, 0.0) for s in proj["syms"]]
+                    val = float(proj["func"](*args))
+                except (ValueError, TypeError):
+                    shrunk_args =[]
+                    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))
+                    except: continue
+
+                if val is None or not math.isfinite(val) or abs(val) > 1e6:
+                    continue
+                    
+                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
+
 def _algebraic_snap(problem: Problem, binding: Dict[str, float]) -> Tuple[Dict[str, float], float]:
     """
-    NEW 1: Topology-Ordered Snap (The Causal Sniper).
-    Walks in scope order so downstream variables resolve upstream dependencies correctly.
+    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.
     """
-    proj_binding = dict(binding)
-    best_ce = problem.constraint_energy(proj_binding)
-    best_binding = dict(proj_binding)
+    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:
             for v in problem.scope_vars.get(sn,[]):
-                if v not in ordered_vars:
-                    ordered_vars.append(v)
+                if v not in ordered_vars: ordered_vars.append(v)
     for v in problem.variables:
-        if v not in ordered_vars:
-            ordered_vars.append(v)
-
-    SNAP_SPIKE_TOLERANCE = 0.15 
-
-    for _ in range(20): 
-        l9 = RESIDUAL_ORACLE.evaluate(proj_binding, problem,[])
-        if not l9.dominant_exprs: break
-        
-        improved_in_step = 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)
-            if not target_mc:
-                for mc in problem.compiled_constraints:
-                    if mc.kind == "or_eq":
-                        for bmc in mc.branches:
-                            if bmc.expr_str == worst_expr: target_mc = bmc; break
-                    if target_mc: break
-                    
-            if not (target_mc and hasattr(target_mc, 'projections') and target_mc.projections):
-                continue
-                
-            # Walk in topology order, not minimum-distance order
-            for v in ordered_vars:
-                if v not in target_mc.projections:
-                    continue
-                for proj in target_mc.projections[v]:
-                    try:
-                        args = [proj_binding.get(s, 0.0) for s in proj["syms"]]
-                        val = float(proj["func"](*args))
-                        if not math.isfinite(val) or abs(val) > 1e6:
-                            continue
-                        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 + SNAP_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
-                    except: pass
-                if improved_in_step: break
-            if improved_in_step: break
-                
-        if not improved_in_step: break
-        if best_ce < SOLVE_THRESHOLD: break
+        if v not in ordered_vars: ordered_vars.append(v)
+
+    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 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
+    for _ in range(20):
+        greedy_b, greedy_ce, improved = _single_snap_pass(problem, greedy_b, greedy_vars, greedy_ce, 0.15)
+        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, best_ce
+    return best_binding_overall, best_ce_overall
 
 def _normalisation_sweep(problem:Problem, binding:Dict[str,float], budget:int) -> Dict:
     snap_binding, snap_ce = _algebraic_snap(problem, binding)
@@ -1278,7 +1297,7 @@ async def lifespan(app: FastAPI):
     yield
     POOL.shutdown(wait=False)
 
-app = FastAPI(title="Practicality System 3.9", lifespan=lifespan)
+app = FastAPI(title="Practicality System 3.10", lifespan=lifespan)
 
 @app.post("/inject/{pid}")
 async def inject_seed(pid:str, request:Request):
@@ -1353,7 +1372,7 @@ async def dashboard():
                 f"font-size:0.85em;margin:2px'>{label}: {val}</span>")
                 
     html=f"""<!DOCTYPE html><html>
-<head><title>Practicality System 3.9</title>
+<head><title>Practicality System 3.10</title>
 <meta http-equiv="refresh" content="3">
 <style>
   body{{background:#0a0a0a;color:#e0e0e0;font-family:monospace;padding:20px}}
@@ -1364,7 +1383,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.9</h1>
+<h1>⚗ Practicality System 3.10</h1>
 <div style='margin-bottom:16px;line-height:2.2em;'>
   {badge("Trials",runs,"#aaa")}
   {badge("Avg rounds",avg_rounds,"#aaa")}
@@ -1409,4 +1428,4 @@ async def dashboard():
     return html
 
 if __name__=="__main__":
-    uvicorn.run(app,host="0.0.0.0",port=7860,log_level="warning")
+    uvicorn.run(app,host="0.0.0.0",port=7860,log_level="warning")