Update app.py

app.py

@@ -1,23 +1,23 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 27.3 — THE FAIL-FAST RESTORATION
+PRACTICALITY SYSTEM 27.4 — THE FAIL-FAST CORE & L2 OVERFLOW SHIELD
 ══════════════════════════════════════════════════════════════════════
-REGRESSIONS FIXED FROM 27.2:
-
-  1. REMOVED LLM AUTO-RETRY LOOP (The "Endless Looping" Bug)
-       The system now operates on a strict One-Shot paradigm. If the ray 
-       budget is exhausted (even if Gate 2 fails), it immediately collapses 
-       and returns the JSON/Markdown to the user for manual recalibration.
-       
-  2. EARLY STOPPING CLARITY
-       The system will only short-circuit if CE < SOLVE_THRESHOLD AND Gate 2 
-       (Anchors) pass. If an anchor is mathematically malformed (returns 999.0), 
-       it will exhaust the search budget trying to satisfy it, then fail-fast 
-       and report.
+REGRESSIONS FIXED FROM 27.3:
+
+  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).
+
+  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.
 
 HERITAGE MAINTAINED:
   All 17 domain templates. Original-Space Adam. Depth-0 Ray Expansion.
-  Dynamic Baton Registry. Float32 Overflow Shield. Decoupled MINIMIZE.
+  Dynamic Baton Registry. Decoupled MINIMIZE. Proxy Decomposition.
 """
 
 import os, time, random, math, threading, warnings, json, textwrap, itertools, copy
@@ -48,7 +48,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.3] Compute: {DEVICE.type.upper()} | Fail-Fast Core Active")
+print(f"[SYSTEM 27.4] Compute: {DEVICE.type.upper()} | Fail-Fast + L2 Shield")
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 1: CONSTANTS & SAFE HELPERS
@@ -83,10 +83,11 @@ def safe_round(val, ndigits=8):
         return round(val, ndigits)
     except: return val
 
-def _c38(v):
+def _c15(v):
+    """Clamps floats to 1e15 so PyTorch MSE squaring doesn't trigger inf."""
     try:
-        if not math.isfinite(v): return 1e38 if v > 0 else -1e38
-        return max(-1e38, min(1e38, float(v)))
+        if not math.isfinite(v): return 1e15 if v > 0 else -1e15
+        return max(-1e15, min(1e15, float(v)))
     except: return 0.0
 
 # ══════════════════════════════════════════════════════════════════════
@@ -403,8 +404,9 @@ 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:
-                val = torch.tensor(1e38, device=DEVICE, dtype=torch.float32)
-            return torch.nan_to_num(val, posinf=1e38, neginf=-1e38)
+                # 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)
             
         mc.torch_func=_t_wrapper
         if kind=="equality":
@@ -525,16 +527,15 @@ 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=_c38(self.bounds[v][0]),_c38(self.bounds[v][1])
+            lo,hi=_c15(self.bounds[v][0]),_c15(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))
             total+=(out_of_bounds**2)*10.0
             
-        # DECOUPLED MINIMIZE DIRECTIVE
         if is_optimizing and self.minimize_var and self.minimize_var in self.var_idx:
             midx = self.var_idx[self.minimize_var]
-            lo,hi = _c38(self.bounds[self.minimize_var][0]), _c38(self.bounds[self.minimize_var][1])
+            lo,hi = _c15(self.bounds[self.minimize_var][0]), _c15(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
@@ -543,7 +544,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,(_c38(self.bounds.get(v,(-1,1))[0])+_c38(self.bounds.get(v,(-1,1))[1]))/2) for v in self.variables]
+        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_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())
@@ -1639,7 +1640,7 @@ Anchor: xx01 - 1 = 0 (tolerance 0.01).
 }
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 7: MASKED DEDUCTION — ORIGINAL SPACE ADAM (RESTORED)
+# SECTION 7: MASKED DEDUCTION — ORIGINAL SPACE ADAM
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class L9Certificate:
@@ -1666,18 +1667,17 @@ def _batched_deduce_and_evaluate(problem, hyps: List['Hypothesis']) -> List[Tupl
     adam_hyps=[hyps[i] for i in solve_indices]
     B=len(adam_hyps); V=len(problem.variables)
 
-    # RESTORED 24.11 ADAM BEHAVIOR: Original Space Evaluation (with _c38 clamps)
     x_data, mask_data, target_data = [], [], []
     for hyp in adam_hyps:
         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=_c38(problem.bounds[v][0]),_c38(problem.bounds[v][1])
+            lo,hi=_c15(problem.bounds[v][0]),_c15(problem.bounds[v][1])
             if v in hyp.pinned_vars:
-                val=_c38(hyp.pinned_vars[v])
+                val=_c15(hyp.pinned_vars[v])
                 xr.append(val); mr.append(0.0); tr.append(val)
             else:
-                val=_c38(hyp.binding.get(v,(lo+hi)/2))
+                val=_c15(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 +1703,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 = _c38(problem.bounds[v][0]), _c38(problem.bounds[v][1])
+                lo, hi = _c15(problem.bounds[v][0]), _c15(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 +1729,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([_c38(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([_c38(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([_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)
     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)
@@ -2185,7 +2185,6 @@ class SequenceRayTracer:
                     best_ce=final_ce; best_binding=dict(final_b)
                     model.best_ray=ray.name; best_ray_name=ray.name
                 
-                # STRICT EARLY EXIT: If CE is perfect AND anchors pass, stop everything.
                 if g1_pass and g2_pass and final_ce<SOLVE_THRESHOLD: solved=True
                 
                 if (passed_pruning or improved or ray.depth < 1) and ray.depth < MAX_CHAIN_DEPTH:
@@ -2246,7 +2245,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.3.
+COLLAPSER_SYSTEM_PROMPT = """You are the Grounded Hypothesis Engine for Practicality 27.4.
 
 Check infeasibility_report first. If non-empty: the system proved infeasibility via
 algebraic propagation before firing any rays. Output:
@@ -2652,9 +2651,9 @@ def _reset_ans_cache(a_cache):
     return a_cache
 
 # ── Gradio App ────────────────────────────────────────────────────────
-with gr.Blocks(css=CSS, title="Practicality 27.3") as demo:
+with gr.Blocks(css=CSS, title="Practicality 27.4") as demo:
     gr.Markdown(
-        "## ⚗ Practicality 27.3 — The Fail-Fast Core\n"
+        "## ⚗ Practicality 27.4 — The Fail-Fast Core\n"
         "`[Direct Parser / LLM] -> [INT Grid] -> [Orig Space Adam] -> [No Retry Loops — Manual Recalibration]`"
     )
 
@@ -2702,16 +2701,15 @@ with gr.Blocks(css=CSS, title="Practicality 27.3") as demo:
                 value=(f"Compute: {DEVICE.type.upper()}\n"
                        f"Axioms: {len(ALL_AXIOMS)}\n"
                        f"Templates: {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)}\n"
-                       f"\n27.3 UPDATES (Fail-Fast Paradigm):\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"  ✓ CE=0 with Anchor=999 correctly explores, \n"
-                       f"    then fails fast to show broken constraint.\n"
                        f"  ✓ All 17 templates fully restored.\n"
                        f"\n27.2 FEATURES RETAINED:\n"
                        f"  ray.depth < 1 unconditional branching.\n"
                        f"  MINIMIZE Soft Objectives (isolated)\n"
-                       f"  Float32 max overflow native handler.\n"
                        f"  Range-normalized Adam reverted to orig space.\n"
                        f"\n  MAX_RAYS={MAX_RAYS_PER_ATTEMPT:,}\n"
                        f"  MAX_CHAIN_DEPTH={MAX_CHAIN_DEPTH}"),
@@ -2741,15 +2739,15 @@ with gr.Blocks(css=CSS, title="Practicality 27.3") as demo:
         outputs=[live_html,dash_cache,ans_cache],
         js="""
         function() {
-            if (!window._p273_dash) {
-                window._p273_dash = setInterval(() => {
+            if (!window._p274_dash) {
+                window._p274_dash = setInterval(() => {
                     const el = document.getElementById('dash_poll_btn');
                     if (!el) return;
                     (el.tagName === 'BUTTON' ? el : el.querySelector('button'))?.click();
                 }, 1000);
             }
-            if (!window._p273_ans) {
-                window._p273_ans = setInterval(() => {
+            if (!window._p274_ans) {
+                window._p274_ans = setInterval(() => {
                     const el = document.getElementById('ans_poll_btn');
                     if (!el) return;
                     (el.tagName === 'BUTTON' ? el : el.querySelector('button'))?.click();
@@ -2787,11 +2785,11 @@ with gr.Blocks(css=CSS, title="Practicality 27.3") as demo:
                            outputs=[ans_cache])
 
     gr.Markdown(
-        f"Practicality 27.3 · Strict One-Shot Paradigm · Fail-Fast Core",
+        f"Practicality 27.4 · Strict One-Shot Paradigm · 1e15 Shield",
         elem_classes=["status-bar"])
 
 if __name__ == "__main__":
-    print(f"[SYSTEM 27.3] Compute: {DEVICE.type.upper()} | Quantum={HAS_QUANTUM}")
-    print(f"[SYSTEM 27.3] Templates: {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)}")
-    print(f"[SYSTEM 27.3] Fixes: Removed LLM auto-retry endless loop.")
+    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.")
     demo.launch(server_name="0.0.0.0", server_port=7860, share=False)