Update app.py

app.py

@@ -1,23 +1,27 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 27.4 — THE FAIL-FAST CORE & L2 OVERFLOW SHIELD
+PRACTICALITY SYSTEM 27.5 — THE GRADIENT-PRESERVING CORE
 ══════════════════════════════════════════════════════════════════════
-REGRESSIONS FIXED FROM 27.3:
+REGRESSIONS FIXED FROM 27.4:
 
-  1. THE L2 LOSS OVERFLOW SHIELD (1e38 -> 1e15)
-       PyTorch calculates Constraint Energy by squaring residuals (MSE). 
-       Clamping float32 limits to 1e38 caused the square to hit 1e76, 
-       which natively overflowed to Infinity, destroying the landscape.
-       The clamp is now safely set to 1e15 (square = 1e30).
+  1. THE FLOAT32 ERASURE TRAP (1e15 -> 1e5)
+       Clamping errors to 1e15 resulted in L2 losses of 1e30. In float32, 
+       adding a gradient of 1e4 to 1e30 results in 1e30 (the gradient is 
+       erased by floating point limits). Clamping is now 1e5, yielding 
+       a max penalty of 1e10, strictly preserving Adam's gradients.
 
-  2. FAIL-FAST PARADIGM ENFORCED
-       The LLM auto-retry loop is completely removed. If the geometric
-       budget is exhausted, the system immediately collapses and reports 
-       the broken anchor/constraint for manual recalibration.
+  2. BATON REGISTRY DEATH LOOP
+       A high initial CE resulted in a massive dynamic registry threshold, 
+       causing every garbage ray to be saved and infinitely re-seeded. 
+       The registry is now strictly hard-capped to never accept CE > 100,000.
+
+  3. UI RAY TRANSPARENCY
+       If the solver is trapped on a plateau, the UI will now force-display 
+       a [SCOUT] ray every 2,000 iterations to prove the axioms are firing.
 
 HERITAGE MAINTAINED:
   All 17 domain templates. Original-Space Adam. Depth-0 Ray Expansion.
-  Dynamic Baton Registry. Decoupled MINIMIZE. Proxy Decomposition.
+  Decoupled MINIMIZE. Proxy Decomposition. Fail-Fast execution.
 """
 
 import os, time, random, math, threading, warnings, json, textwrap, itertools, copy
@@ -48,7 +52,7 @@ GEMINI_MODEL = "gemini-3.5-flash"
 warnings.filterwarnings("ignore")
 USE_GPU = torch.cuda.is_available()
 DEVICE  = torch.device("cuda" if USE_GPU else "cpu")
-print(f"[SYSTEM 27.4] Compute: {DEVICE.type.upper()} | Fail-Fast + L2 Shield")
+print(f"[SYSTEM 27.5] Compute: {DEVICE.type.upper()} | Gradient-Preserving Core")
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 1: CONSTANTS & SAFE HELPERS
@@ -83,11 +87,11 @@ def safe_round(val, ndigits=8):
         return round(val, ndigits)
     except: return val
 
-def _c15(v):
-    """Clamps floats to 1e15 so PyTorch MSE squaring doesn't trigger inf."""
+def _c5(v):
+    """Clamps floats to 1e5 so PyTorch MSE (1e10) doesn't erase float32 gradients."""
     try:
-        if not math.isfinite(v): return 1e15 if v > 0 else -1e15
-        return max(-1e15, min(1e15, float(v)))
+        if not math.isfinite(v): return 1e5 if v > 0 else -1e5
+        return max(-1e5, min(1e5, float(v)))
     except: return 0.0
 
 # ══════════════════════════════════════════════════════════════════════
@@ -404,9 +408,10 @@ def compile_mc(kind,expr_str,direction,variables,weight=1.0,scope="root",branche
                 if not isinstance(val, torch.Tensor):
                     val = torch.tensor(float(val), device=DEVICE, dtype=torch.float32)
             except Exception:
-                # Shield: Catch float32 overflow natively and clamp to 1e15
-                val = torch.tensor(1e15, device=DEVICE, dtype=torch.float32)
-            return torch.nan_to_num(val, posinf=1e15, neginf=-1e15)
+                # Shield: Catch mathematically invalid domains (e.g. log(-1)) and clamp to 1e5
+                val = torch.tensor(1e5, device=DEVICE, dtype=torch.float32)
+            # Replace NaNs with 1e5 so (1e5)^2 = 1e10 maintains gradients without overflowing
+            return torch.nan_to_num(val, posinf=1e5, neginf=-1e5, nan=1e5)
             
         mc.torch_func=_t_wrapper
         if kind=="equality":
@@ -527,7 +532,7 @@ class Problem:
                 elif mc.direction=="geq": total+=(torch.relu(-val)**2)*eff_weight
                 else:                     total+=(torch.relu(val)**2)*eff_weight
         for i,v in enumerate(self.variables):
-            lo,hi=_c15(self.bounds[v][0]),_c15(self.bounds[v][1])
+            lo,hi=_c5(self.bounds[v][0]),_c5(self.bounds[v][1])
             col=X[:,i] if is_batched else X[i]
             margin=(hi-lo)*0.1*(1.0-step_ratio)
             out_of_bounds=torch.relu(lo-margin-col)+torch.relu(col-(hi+margin))
@@ -535,7 +540,7 @@ class Problem:
             
         if is_optimizing and self.minimize_var and self.minimize_var in self.var_idx:
             midx = self.var_idx[self.minimize_var]
-            lo,hi = _c15(self.bounds[self.minimize_var][0]), _c15(self.bounds[self.minimize_var][1])
+            lo,hi = _c5(self.bounds[self.minimize_var][0]), _c5(self.bounds[self.minimize_var][1])
             rng = max(hi-lo, 1e-8)
             col = X[:,midx] if is_batched else X[midx]
             normalized = (col - lo) / rng
@@ -544,7 +549,7 @@ class Problem:
         return total.view(batch_size,-1).sum(dim=1)
 
     def scalar_energy(self, b: Dict[str,float]) -> float:
-        x_arr=[b.get(v,(_c15(self.bounds.get(v,(-1,1))[0])+_c15(self.bounds.get(v,(-1,1))[1]))/2) for v in self.variables]
+        x_arr=[b.get(v,(_c5(self.bounds.get(v,(-1,1))[0])+_c5(self.bounds.get(v,(-1,1))[1]))/2) for v in self.variables]
         X_t=torch.tensor(x_arr,device=DEVICE,dtype=torch.float32).unsqueeze(0)
         with torch.no_grad():
             return float(self.tensor_energy(X_t, step_ratio=1.0, is_optimizing=False).item())
@@ -1672,12 +1677,12 @@ def _batched_deduce_and_evaluate(problem, hyps: List['Hypothesis']) -> List[Tupl
         xr, mr, tr = [], [], []
         active_vars=problem.get_markov_blanket(set(hyp.pinned_vars.keys()), depth=2)
         for j,v in enumerate(problem.variables):
-            lo,hi=_c15(problem.bounds[v][0]),_c15(problem.bounds[v][1])
+            lo,hi=_c5(problem.bounds[v][0]),_c5(problem.bounds[v][1])
             if v in hyp.pinned_vars:
-                val=_c15(hyp.pinned_vars[v])
+                val=_c5(hyp.pinned_vars[v])
                 xr.append(val); mr.append(0.0); tr.append(val)
             else:
-                val=_c15(hyp.binding.get(v,(lo+hi)/2))
+                val=_c5(hyp.binding.get(v,(lo+hi)/2))
                 is_active=(v in active_vars) or (len(hyp.pinned_vars)==0)
                 xr.append(val); mr.append(1.0 if is_active else 0.0); tr.append(0.0)
         x_data.append(xr); mask_data.append(mr); target_data.append(tr)
@@ -1703,7 +1708,7 @@ def _batched_deduce_and_evaluate(problem, hyps: List['Hypothesis']) -> List[Tupl
             optimizer.step()
             X.data = torch.where(mask == 0.0, target, X.data)
             for j, v in enumerate(problem.variables):
-                lo, hi = _c15(problem.bounds[v][0]), _c15(problem.bounds[v][1])
+                lo, hi = _c5(problem.bounds[v][0]), _c5(problem.bounds[v][1])
                 margin = (hi - lo) * 0.1 * (1.0 - step_ratio)
                 X.data[:, j] = torch.clamp(X.data[:, j], lo - margin, hi + margin)
 
@@ -1729,8 +1734,8 @@ def _batched_deduce_and_evaluate(problem, hyps: List['Hypothesis']) -> List[Tupl
 
 def _mprt_sample(problem, work_box, N):
     var_list=problem.variables; V=len(var_list)
-    lo_t=torch.tensor([_c15(max(problem.bounds.get(v,(-10.0,10.0))[0], work_box[v].lo if v in work_box else problem.bounds.get(v,(-10,10))[0])) for v in var_list], device=DEVICE, dtype=torch.float32)
-    hi_t=torch.tensor([_c15(min(problem.bounds.get(v,(-10.0,10.0))[1], work_box[v].hi if v in work_box else problem.bounds.get(v,(-10,10))[1])) for v in var_list], device=DEVICE, dtype=torch.float32)
+    lo_t=torch.tensor([_c5(max(problem.bounds.get(v,(-10.0,10.0))[0], work_box[v].lo if v in work_box else problem.bounds.get(v,(-10,10))[0])) for v in var_list], device=DEVICE, dtype=torch.float32)
+    hi_t=torch.tensor([_c5(min(problem.bounds.get(v,(-10.0,10.0))[1], work_box[v].hi if v in work_box else problem.bounds.get(v,(-10,10))[1])) for v in var_list], device=DEVICE, dtype=torch.float32)
     for i in range(V):
         if lo_t[i]>=hi_t[i]: m=(lo_t[i]+hi_t[i])/2; lo_t[i]=m-1e-6; hi_t[i]=m+1e-6
     X=lo_t.unsqueeze(0)+(hi_t-lo_t).unsqueeze(0)*torch.rand((N,V), device=DEVICE)
@@ -2135,6 +2140,7 @@ class SequenceRayTracer:
         model=StructuralModel(best_binding,best_ce); total_fired=0; solved=False
         seed_baton=Baton(binding=best_binding,ce=best_ce,ray_id="SEED",
                          l9=L9Certificate(best_ce,base_problem.variables[:3],[],"systemic"))
+        last_ui_update_fired = 0
 
         while total_fired<MAX_RAYS_PER_ATTEMPT and GLOBAL_SOLVE_STATE["is_running"]:
             if not queues["core"]:
@@ -2162,19 +2168,28 @@ class SequenceRayTracer:
                 g1_pass,g2_pass,inv_results,_=_verify(final_b,base_problem,axl_def.anchors)
                 improved=final_ce<best_ce; passed_pruning=final_ce<parent_ce*CE_EARN_RATIO
                 
-                if improved or (g1_pass and g2_pass) or passed_pruning:
+                # UI Trace Visibility: Show improvements, passing states, or force a scout ray every 2k shots
+                # so the user knows the engine hasn't frozen on a flatland plateau.
+                force_ui_scout = not improved and not passed_pruning and (total_fired - last_ui_update_fired > 2000)
+                
+                if improved or (g1_pass and g2_pass) or passed_pruning or force_ui_scout:
                     with STATE_LOCK:
+                        display_name = f"[SCOUT] {ray.name}" if force_ui_scout else ray.name
                         GLOBAL_SOLVE_STATE["recent_traces"].append(HypothesisTrace(
-                            hid=ray.ray_id,round_idx=total_fired,ray_name=ray.name,
-                            ray_type=ray.ray_type,ce_before=parent_ce,ce_after=final_ce,
+                            hid=ray.ray_id,round_idx=total_fired,ray_name=display_name,
+                            ray_type="scout" if force_ui_scout else ray.ray_type,
+                            ce_before=parent_ce,ce_after=final_ce,
                             survived=(g1_pass and g2_pass),elapsed_ms=0.0,
                             g1_pass=g1_pass,g2_pass=g2_pass,binding=final_b,
                             invariant_results=inv_results,tension_class=tension_class,depth=ray.depth))
+                    if force_ui_scout: last_ui_update_fired = total_fired
                             
                 out_baton=Baton(binding=final_b,ce=final_ce,ray_id=ray.ray_id,
                                 l9=L9Certificate(final_ce,dom_vars,[],tension_class))
                                 
-                dynamic_baton_thresh = max(BATON_REGISTRY_THRESHOLD, best_ce * 1.5, init_ce * 0.1)
+                # DYNAMIC BATON REGISTRY: Cap the threshold to 100,000 so flatland garbage 
+                # doesn't flood the registry and cause endless re-seeding loops.
+                dynamic_baton_thresh = min(100000.0, max(BATON_REGISTRY_THRESHOLD, best_ce * 1.5, init_ce * 0.1))
                 if final_ce < dynamic_baton_thresh:
                     baton_registry[ray.ray_id] = out_baton
                     if len(baton_registry) > BATON_REGISTRY_MAX:
@@ -2245,7 +2260,7 @@ OUTPUT SCHEMA (JSON only, no markdown):
 RULES: USE ** FOR EXPONENTS. NEVER USE ^. No =, >=, <= inside expressions.
 EQ/GEQ/LEQ are expression's relation to zero. Output ONLY the JSON object."""
 
-COLLAPSER_SYSTEM_PROMPT = """You are the Grounded Hypothesis Engine for Practicality 27.4.
+COLLAPSER_SYSTEM_PROMPT = """You are the Grounded Hypothesis Engine for Practicality 27.5.
 
 Check infeasibility_report first. If non-empty: the system proved infeasibility via
 algebraic propagation before firing any rays. Output:
@@ -2651,10 +2666,10 @@ def _reset_ans_cache(a_cache):
     return a_cache
 
 # ── Gradio App ────────────────────────────────────────────────────────
-with gr.Blocks(css=CSS, title="Practicality 27.4") as demo:
+with gr.Blocks(css=CSS, title="Practicality 27.5") as demo:
     gr.Markdown(
-        "## ⚗ Practicality 27.4 — The Fail-Fast Core\n"
-        "`[Direct Parser / LLM] -> [INT Grid] -> [Orig Space Adam] -> [No Retry Loops — Manual Recalibration]`"
+        "## ⚗ Practicality 27.5 — The Gradient-Preserving Core\n"
+        "`[Direct Parser / LLM] -> [INT Grid] -> [1e5 Shield Adam] -> [No Death Loops]`"
     )
 
     dash_cache = gr.State({"html": ""})
@@ -2701,13 +2716,16 @@ with gr.Blocks(css=CSS, title="Practicality 27.4") as demo:
                 value=(f"Compute: {DEVICE.type.upper()}\n"
                        f"Axioms: {len(ALL_AXIOMS)}\n"
                        f"Templates: {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)}\n"
-                       f"\n27.4 UPDATES (Fail-Fast Paradigm):\n"
-                       f"  ✓ L2 LOSS SHIELD: _c15 safely bounds PyTorch MSE\n"
-                       f"    to prevent 1e76 Infinity explosions.\n"
-                       f"  ✓ REMOVED auto-retry loop entirely.\n"
-                       f"  ✓ Stops 'looping from the beginning'.\n"
-                       f"  ✓ All 17 templates fully restored.\n"
-                       f"\n27.2 FEATURES RETAINED:\n"
+                       f"\n27.5 UPDATES (Gradient-Preserving):\n"
+                       f"  ✓ 1e5 SHIELD: Fixed the 2e31 Flatland Bug.\n"
+                       f"    PyTorch now preserves gradients without \n"
+                       f"    erasing them via float32 limits.\n"
+                       f"  ✓ BATON CAP: High-CE garbage is no longer\n"
+                       f"    saved, killing the re-seed loop.\n"
+                       f"  ✓ SCOUT RAYS: UI forces a trace update\n"
+                       f"    every 2,000 rays to prove execution.\n"
+                       f"\n27.4 FEATURES RETAINED:\n"
+                       f"  Fail-Fast execution (No retries)\n"
                        f"  ray.depth < 1 unconditional branching.\n"
                        f"  MINIMIZE Soft Objectives (isolated)\n"
                        f"  Range-normalized Adam reverted to orig space.\n"
@@ -2739,15 +2757,15 @@ with gr.Blocks(css=CSS, title="Practicality 27.4") as demo:
         outputs=[live_html,dash_cache,ans_cache],
         js="""
         function() {
-            if (!window._p274_dash) {
-                window._p274_dash = setInterval(() => {
+            if (!window._p275_dash) {
+                window._p275_dash = setInterval(() => {
                     const el = document.getElementById('dash_poll_btn');
                     if (!el) return;
                     (el.tagName === 'BUTTON' ? el : el.querySelector('button'))?.click();
                 }, 1000);
             }
-            if (!window._p274_ans) {
-                window._p274_ans = setInterval(() => {
+            if (!window._p275_ans) {
+                window._p275_ans = setInterval(() => {
                     const el = document.getElementById('ans_poll_btn');
                     if (!el) return;
                     (el.tagName === 'BUTTON' ? el : el.querySelector('button'))?.click();
@@ -2785,11 +2803,11 @@ with gr.Blocks(css=CSS, title="Practicality 27.4") as demo:
                            outputs=[ans_cache])
 
     gr.Markdown(
-        f"Practicality 27.4 · Strict One-Shot Paradigm · 1e15 Shield",
+        f"Practicality 27.5 · Gradient-Preserving Core · Float32 Erasure Fixed",
         elem_classes=["status-bar"])
 
 if __name__ == "__main__":
-    print(f"[SYSTEM 27.4] Compute: {DEVICE.type.upper()} | Quantum={HAS_QUANTUM}")
-    print(f"[SYSTEM 27.4] Templates: {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)}")
-    print(f"[SYSTEM 27.4] Fixes: 1e15 L2 loss overflow shield active.")
+    print(f"[SYSTEM 27.5] Compute: {DEVICE.type.upper()} | Quantum={HAS_QUANTUM}")
+    print(f"[SYSTEM 27.5] Templates: {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)}")
+    print(f"[SYSTEM 27.5] Fixes: 1e5 shield preserves float32 gradients. Registry hard-capped.")
     demo.launch(server_name="0.0.0.0", server_port=7860, share=False)