Update app.py

app.py

@@ -1,36 +1,23 @@
-
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 27.2 — THE RESTORED CORE & SAFE MINIMIZE
+PRACTICALITY SYSTEM 27.3 — THE FAIL-FAST RESTORATION
 ══════════════════════════════════════════════════════════════════════
-REGRESSIONS FIXED FROM 27.1:
+REGRESSIONS FIXED FROM 27.2:
 
-  1. THE DEPTH-0 BRANCHING FIX
-       Seed axioms unconditionally branch again. The ray queue no longer 
-       drains prematurely at ~400 rays. Search trees fully expand.
-       
-  2. DYNAMIC BATON REGISTRY
-       The registry threshold dynamically scales with the problem's CE 
-       (max(2.0, best_ce * 1.5, init_ce * 0.1)). High-CE spaces like GLV 
-       will now successfully save intermediate recombinations.
-       
-  3. DECOUPLED MINIMIZE DIRECTIVE
-       The MINIMIZE penalty is strictly isolated to the Adam gradient 
-       backward pass (is_optimizing=True). scalar_energy (Gate 1) evaluates 
-       absolute structural truth (CE = 0), unpoisoned by soft objectives.
-       
-  4. FLOAT32 OVERFLOW SHIELD
-       t_func_raw now intercepts OverflowError natively. Astronomical 
-       variables (e.g., 2^1000000 in GHZ) clamp to 1e38 instead of returning 
-       Infinity and destroying the constraint graph.
+  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.
        
-  5. ADAM GRADIENT EXPLOSION
-       Reverted the X_n range-normalized Adam step back to original-space 
-       evaluation. Prevents catastrophic boundary jumps in modular spaces.
+  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.
 
 HERITAGE MAINTAINED:
-  Direct template parser, INT grid permutations, Proxy Decomposition 
-  (with proper short-circuit for connected graphs), SymPy anti-LaTeX shield.
+  All 17 domain templates. Original-Space Adam. Depth-0 Ray Expansion.
+  Dynamic Baton Registry. Float32 Overflow Shield. Decoupled MINIMIZE.
 """
 
 import os, time, random, math, threading, warnings, json, textwrap, itertools, copy
@@ -61,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.2] Compute: {DEVICE.type.upper()} | Restored Search Core")
+print(f"[SYSTEM 27.3] Compute: {DEVICE.type.upper()} | Fail-Fast Core Active")
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 1: CONSTANTS & SAFE HELPERS
@@ -97,7 +84,6 @@ def safe_round(val, ndigits=8):
     except: return val
 
 def _c38(v):
-    """Clamps giant floats (like 1e301) to 1e38 so PyTorch float32 doesn't trigger inf."""
     try:
         if not math.isfinite(v): return 1e38 if v > 0 else -1e38
         return max(-1e38, min(1e38, float(v)))
@@ -417,9 +403,7 @@ 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:
-                # Catch math.OverflowError natively (e.g. 2**1000000)
                 val = torch.tensor(1e38, device=DEVICE, dtype=torch.float32)
-            # Guarantee no posinf/neginf ruins the CE summation
             return torch.nan_to_num(val, posinf=1e38, neginf=-1e38)
             
         mc.torch_func=_t_wrapper
@@ -547,7 +531,7 @@ class Problem:
             out_of_bounds=torch.relu(lo-margin-col)+torch.relu(col-(hi+margin))
             total+=(out_of_bounds**2)*10.0
             
-        # DECOUPLED MINIMIZE DIRECTIVE: Only inject penalty during gradient optimization
+        # 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])
@@ -562,7 +546,6 @@ class Problem:
         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_t=torch.tensor(x_arr,device=DEVICE,dtype=torch.float32).unsqueeze(0)
         with torch.no_grad():
-            # Gate 1 verification explicitly requires is_optimizing=False
             return float(self.tensor_energy(X_t, step_ratio=1.0, is_optimizing=False).item())
 
 def build_base_problem(axl_def:AXLProblemDef) -> Problem:
@@ -743,7 +726,7 @@ def _global_hc4_tighten_bounds(problem:Problem) -> Dict[str,Tuple[float,float]]:
             for v in problem.bounds if v in c}
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 5.10: DIRECT TEMPLATE PARSER 
+# SECTION 5.10: DIRECT TEMPLATE PARSER
 # ══════════════════════════════════════════════════════════════════════
 _VAR_RE = re.compile(r'^\s*([a-zA-Z_][a-zA-Z0-9_]*(?:,\s*[a-zA-Z_][a-zA-Z0-9_]*)*)\s+in\s+\[([^\]]+)\]\s*(INT)?\s*',re.IGNORECASE)
 _CON_RE = re.compile(r'^\s*(EQ|GEQ|LEQ)(?:\s+weight\s*=\s*([0-9.]+))?\s*:\s*(.+)$',re.IGNORECASE)
@@ -1212,7 +1195,7 @@ def detect_divergence(problem_name):
     return False,f"ATTRACTOR-STABLE: {len(good)} runs converged."
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 6.7: HYPOTHESIS TEMPLATES 
+# SECTION 6.7: HYPOTHESIS TEMPLATES
 # ══════════════════════════════════════════════════════════════════════
 STRUCTURAL_HYPOTHESIS_TEMPLATES = {
 
@@ -1295,6 +1278,95 @@ Anchor: gap - 1.0 = 0 (tolerance 0.01).
 Anchor: energy_per_site + 1.0 = 0 (tolerance 0.05).
 """,
 
+"Heisenberg TFIM Trotter: One Circuit Step Observable Evolution": """\
+CONCRETE HYPOTHESIS: TFIM Trotterized Circuit One-Step Heisenberg Evolution
+===========================================================================
+Variables:
+  z_in            in [0.99, 1.01]
+  z_mid           in [0.9, 1.0] 
+  z_out           in [0.9, 1.0] 
+  zz_in           in [0.99, 1.01]
+  zz_mid          in [0.85, 1.0] 
+  zz_out          in [0.85, 1.0] 
+  x_out           in [-0.1, 0.1] 
+  energy_out      in [-2.0, 0.0] 
+
+Constraints:
+  EQ weight=10: z_in - 1.0
+  EQ weight=10: zz_in - 1.0
+  EQ weight=10: z_mid - z_in*0.95534
+  EQ weight=10: zz_mid - zz_in*0.91241
+  EQ weight=10: z_out - z_mid
+  EQ weight=10: zz_out - zz_mid
+  EQ weight=5: x_out
+  EQ weight=5: energy_out + zz_out + 0.5*x_out
+  GEQ: z_out - 0.85
+  GEQ: 1.0 - z_out
+
+Anchor: z_mid - 0.9553 = 0 (tolerance 0.005).
+Anchor: zz_out - 0.9124 = 0 (tolerance 0.01).
+""",
+
+"Heisenberg Clifford: 4-Qubit Chain Observable Evolution": """\
+CONCRETE HYPOTHESIS: 4-Qubit 1D Chain Clifford Circuit via Heisenberg Picture
+=============================================================================
+Variables:
+  x0, x1, x2, x3     in [-1.0, 1.0]
+  z0, z1, z2, z3     in [-1.0, 1.0]
+  zz01               in [-1.0, 1.0]
+  zz12               in [-1.0, 1.0]
+  zz23               in [-1.0, 1.0]
+  magnetization      in [-1.0, 1.0]
+  entanglement_proxy in [0.0, 1.0] 
+
+Constraints:
+  EQ weight=10: z0
+  EQ weight=10: z1
+  EQ weight=10: z2
+  EQ weight=10: z3
+  EQ weight=10: magnetization - (z0 + z1 + z2 + z3)/4.0
+  EQ weight=10: zz01
+  EQ weight=10: zz12
+  EQ weight=10: zz23
+  EQ weight=10: entanglement_proxy - (x0**2 + x1**2 + x2**2 + x3**2)/4.0
+  GEQ: 1.0 - x0**2 - z0**2
+  GEQ: 1.0 - x1**2 - z1**2
+  GEQ: 1.0 - x2**2 - z2**2
+  GEQ: 1.0 - x3**2 - z3**2
+
+Anchor: magnetization = 0 (tolerance 0.01).
+Anchor: zz01 = 0 (tolerance 0.01).
+""",
+
+"Heisenberg XXZ: Spin-Half Chain Magnetization Plateaus": """\
+CONCRETE HYPOTHESIS: 1D XXZ Chain Magnetization Plateaus via Observables
+=========================================================================
+Variables:
+  mag_z       in [-1.0, 1.0]
+  corr_xx     in [-1.0, 1.0]
+  corr_zz     in [-1.0, 1.0]
+  chirality   in [-1.0, 1.0]
+  energy_ps   in [-3.0, 0.0]
+  suscept     in [0.0, 5.0] 
+  plateau     in [0.0, 1.0] 
+
+Constraints:
+  EQ weight=10: energy_ps - (-corr_xx - 0.5*corr_zz - 0.3*mag_z)
+  EQ weight=5: corr_xx - (-0.3*mag_z - 0.1)
+  EQ weight=10: corr_zz - mag_z**2 - 0.05*(1.0 - mag_z**2)
+  EQ weight=5: chirality
+  EQ weight=5: suscept - (1.0 - mag_z**2)*2.0
+  GEQ: 1.0 - mag_z**2 - corr_xx**2
+  GEQ: corr_zz - (mag_z**2 - 0.3)
+  GEQ: mag_z + 1.0
+  LEQ: mag_z - 1.0
+  GEQ: plateau
+  LEQ: plateau - 1.0
+
+Anchor: chirality = 0 (tolerance 0.01).
+Anchor: energy_ps + 0.75 = 0 (tolerance 0.1).
+""",
+
 "secp256k1 Optimal Window: MINIMIZE total operations": """\
 CONCRETE HYPOTHESIS: secp256k1 wNAF Optimal Window via Integer Minimization
 ============================================================================
@@ -1344,6 +1416,70 @@ Anchor: k1 + k2*77 - (314 - m*1000) = 0 (tolerance 0.01).
 Observation: k_target = 314.
 """,
 
+"secp256k1 Montgomery Ladder vs Double-and-Add": """\
+CONCRETE HYPOTHESIS: Montgomery Ladder Constant-Time Overhead
+=============================================================
+Variables:
+  scalar_bits      in [254, 258] INT
+  montgomery_ops   in [500, 520] INT
+  dbl_add_doubles  in [252, 260] INT
+  dbl_add_adds     in [100, 140] INT
+  dbl_add_total    in [350, 400] INT
+  ct_overhead      in [0.2, 0.5]
+
+Constraints:
+  EQ weight=10: montgomery_ops - 2*scalar_bits
+  EQ weight=10: dbl_add_doubles - scalar_bits
+  EQ weight=10: dbl_add_adds - scalar_bits/2
+  EQ weight=10: dbl_add_total - dbl_add_doubles - dbl_add_adds
+  EQ weight=10: ct_overhead - (montgomery_ops - dbl_add_total)/dbl_add_total
+  GEQ: ct_overhead - 0.28
+  LEQ: ct_overhead - 0.40
+
+Anchor: montgomery_ops - 2*scalar_bits = 0 (tolerance 2.0).
+""",
+
+"secp256k1 Schnorr Batch Verify: Pippenger Scaling": """\
+CONCRETE HYPOTHESIS: Schnorr Batch Verification via Pippenger
+=============================================================
+Variables:
+  n_sigs          in [2, 10000] INT
+  naive_ops       in [500, 3000000]
+  pippenger_adds  in [100, 500000]
+  bucket_width    in [4, 16] INT
+  n_buckets       in [16, 65536] INT
+  batch_speedup   in [1.0, 1000.0]
+
+Constraints:
+  EQ weight=10: naive_ops - n_sigs*768
+  EQ weight=10: n_buckets - 2**bucket_width
+  EQ weight=10: pippenger_adds - 256*n_buckets + n_sigs*256/bucket_width
+  EQ weight=10: batch_speedup - naive_ops/pippenger_adds
+  GEQ: batch_speedup - 1.0
+
+Anchor: batch_speedup - 1.0 >= 0 (mode=geq, tolerance 0.1).
+""",
+
+"secp256k1 Group Law Feasibility": """\
+STRUCTURAL HYPOTHESIS: secp256k1 Elliptic Curve Group Law
+==========================================================
+Variables:
+  x1 in [0.1, 3.0]
+  y1 in [0.1, 10.0]
+  m  in [-50.0, 50.0]
+  x3 in [-5.0, 15.0]
+  y3 in [-30.0, 30.0]
+
+Constraints:
+  EQ weight=10: y1**2 - x1**3 - 7
+  EQ weight=10: 2*y1*m - 3*x1**2
+  EQ weight=10: x3 - m**2 + 2*x1
+  EQ weight=10: y3 + m*(x3 - x1) + y1
+  EQ weight=10: y3**2 - x3**3 - 7
+
+Anchor: y3**2 - x3**3 - 7 = 0 (tolerance 0.001).
+""",
+
 "1024-Qubit Shor: Concrete Full Gate Audit": """\
 CONCRETE HYPOTHESIS: Shor RSA-1024 at 1024 Logical Qubits
 ==========================================================
@@ -1368,6 +1504,137 @@ Constraints:
 
 Anchor: n_log_qubits - 1027 = 0 (tolerance 2.0).
 Observation: n_bits = 512.
+""",
+
+"2048-Qubit Shor: RSA-2048 Full Resource Certificate": """\
+CONCRETE HYPOTHESIS: Shor RSA-2048 Resource Certificate
+========================================================
+Variables:
+  n_bits          in [2046, 2050] INT
+  n_log_qubits    in [4096, 4104] INT
+  total_tgates    in [1e12, 1e17]
+  total_cnots     in [1e12, 1e17]
+  code_dist       in [25, 50] INT
+  phys_qubits     in [1e6, 1e10]
+  wall_time_days  in [1.0, 100000000.0]
+  gate_time_ns    in [100.0, 2000.0]
+
+Constraints:
+  EQ weight=10: n_log_qubits - (2*n_bits + 3)
+  EQ weight=10: total_tgates - 512*n_bits**3
+  EQ weight=10: total_cnots - 256*n_bits**3
+  EQ weight=10: code_dist - 31
+  EQ weight=10: phys_qubits - n_log_qubits*2*code_dist**2
+  EQ weight=5: wall_time_days - total_tgates*code_dist*gate_time_ns*1e-9/86400
+  GEQ: gate_time_ns - 100
+  LEQ: gate_time_ns - 1000
+
+Anchor: n_log_qubits - 4099 = 0 (tolerance 2.0).
+Observation: n_bits = 2048.
+""",
+
+"Kyber-1024 NTT: Post-Quantum Key Generation Audit": """\
+CONCRETE HYPOTHESIS: CRYSTALS-Kyber-1024 NTT Operation Count
+=============================================================
+Variables:
+  n_poly           in [254, 258] INT
+  k_param          in [3, 5] INT
+  ntt_butterflies  in [900, 1100] INT
+  ntt_mults        in [900, 1100] INT
+  ntt_adds         in [1800, 2200] INT
+  keygen_ntts      in [10, 25] INT
+  total_mults      in [5000, 30000] INT
+  total_adds       in [10000, 60000] INT
+
+Constraints:
+  EQ weight=10: ntt_butterflies - n_poly*4
+  EQ weight=10: ntt_mults - ntt_butterflies
+  EQ weight=10: ntt_adds - 2*ntt_butterflies
+  EQ weight=10: keygen_ntts - k_param*(k_param + 1)
+  EQ weight=10: total_mults - keygen_ntts*ntt_mults
+  EQ weight=10: total_adds - keygen_ntts*ntt_adds
+
+Anchor: total_mults - keygen_ntts*ntt_mults = 0 (tolerance 10.0).
+Observation: k_param = 4.
+""",
+
+"Grover Oracle: SHA256 Preimage Circuit Cost": """\
+CONCRETE HYPOTHESIS: Grover SHA-256 Preimage Circuit
+=====================================================
+Variables:
+  output_bits      in [254, 258] INT
+  oracle_toffoli   in [1400, 1600] INT
+  oracle_cnots     in [2800, 3200] INT
+  grover_iters     in [125, 130]
+  total_log2_ops   in [128, 132]
+  toffoli_to_t     in [6, 8] INT
+  log2_tgates      in [135, 145]
+  code_dist        in [25, 55] INT
+
+Constraints:
+  EQ weight=10: oracle_toffoli - 1500
+  EQ weight=10: oracle_cnots - 3000
+  EQ weight=10: grover_iters - output_bits/2
+  EQ weight=10: total_log2_ops - grover_iters + 1
+  EQ weight=10: toffoli_to_t - 7
+  EQ weight=10: log2_tgates - total_log2_ops + 10
+  EQ weight=5: code_dist - 33
+  GEQ: log2_tgates - 135
+
+Anchor: grover_iters - 128 = 0 (tolerance 1.0).
+""",
+
+"LWE Lattice Crypto: Short Vector Feasibility": """\
+STRUCTURAL HYPOTHESIS: Learning With Errors (n=4 proxy)
+========================================================
+Variables:
+  s0 in [-5.0, 5.0] INT
+  s1 in [-5.0, 5.0] INT
+  s2 in [-5.0, 5.0] INT
+  s3 in [-5.0, 5.0] INT
+  e0 in [-1.5, 1.5]
+  e1 in [-1.5, 1.5]
+  e2 in [-1.5, 1.5]
+  e3 in [-1.5, 1.5]
+
+Constraints:
+  EQ: 3*s0 + s1 + 4*s2 + s3 + e0 - 17
+  EQ: 5*s0 + 9*s1 + 2*s2 + 6*s3 + e1 - 43
+  EQ: 5*s0 + 3*s1 + 5*s2 + 8*s3 + e2 - 31
+  EQ: 9*s0 + 7*s1 + 9*s2 + 3*s3 + e3 - 36
+  GEQ: 1 - e0**2
+  GEQ: 1 - e1**2
+  GEQ: 1 - e2**2
+  GEQ: 1 - e3**2
+
+Anchor: s0 - 1 = 0 (tolerance 0.1).
+""",
+
+"Quantum Bell State Structural Feasibility": """\
+STRUCTURAL HYPOTHESIS: Bell State Maximal Entanglement
+======================================================
+Variables:
+  x0  in [-1.0, 1.0]
+  y0  in [-1.0, 1.0]
+  z0  in [-1.0, 1.0]
+  x1  in [-1.0, 1.0]
+  y1  in [-1.0, 1.0]
+  z1  in [-1.0, 1.0]
+  xx01 in [-1.0, 1.0]
+  zz01 in [-1.0, 1.0]
+
+Constraints:
+  EQ weight=5: z0
+  EQ weight=5: z1
+  EQ weight=5: x0
+  EQ weight=5: x1
+  EQ weight=10: zz01 - 1
+  EQ weight=10: xx01 - 1
+  GEQ: 1 - x0**2 - y0**2 - z0**2
+  GEQ: 1 - x1**2 - y1**2 - z1**2
+
+Anchor: zz01 - 1 = 0 (tolerance 0.01).
+Anchor: xx01 - 1 = 0 (tolerance 0.01).
 """
 }
 
@@ -1425,9 +1692,7 @@ def _batched_deduce_and_evaluate(problem, hyps: List['Hypothesis']) -> List[Tupl
         optimizer.zero_grad()
         step_ratio = min(1.0, step / (DEDUCE_ADAM_STEPS * 0.8))
         
-        # DECOUPLED MINIMIZE FIX: Apply soft objective strictly in optimization loop
         ce = problem.tensor_energy(X, step_ratio, is_optimizing=True)
-        
         if isinstance(ce, torch.Tensor) and (ce < SOLVE_THRESHOLD).all() and step_ratio == 1.0:
             break
         ce.sum().backward()
@@ -1443,7 +1708,6 @@ def _batched_deduce_and_evaluate(problem, hyps: List['Hypothesis']) -> List[Tupl
                 X.data[:, j] = torch.clamp(X.data[:, j], lo - margin, hi + margin)
 
     optimizer.zero_grad()
-    # Evaluate final energy WITHOUT optimization penalties for accurate verification
     final_ce = problem.tensor_energy(X, 1.0, is_optimizing=False).view(-1)
     final_ce.sum().backward()
     
@@ -1555,14 +1819,11 @@ def _make_hyp(hid, binding, h_type, claim, derivation, pinned, free, conf, is_fd
                       derivation=derivation, pinned_vars=pinned, free_vars=free,
                       confidence=conf, is_fully_determined=is_fd)
 
-def _hyp_continuous(p,bt,a,m):
-    return [_make_hyp("cnt",bt.binding,"continuous","Manifold",[],{},p.variables,0.45)]
-
+def _hyp_continuous(p,bt,a,m): return [_make_hyp("cnt",bt.binding,"continuous","Manifold",[],{},p.variables,0.45)]
 def _hyp_discrete(p,bt,a,m):
     b=dict(bt.binding); pinned={}
     for sn in p.scope_order:
-        svars=p.scope_vars.get(sn,[])
-        smcs=[p.compiled_constraints[i] for i in p.scope_groups.get(sn,[])]
+        svars=p.scope_vars.get(sn,[]); smcs=[p.compiled_constraints[i] for i in p.scope_groups.get(sn,[])]
         if svars and smcs:
             box={v:IV(b.get(v,0)-max(0.05*(p.bounds[v][1]-p.bounds[v][0]),1e-4),
                       b.get(v,0)+max(0.05*(p.bounds[v][1]-p.bounds[v][0]),1e-4))
@@ -1573,35 +1834,26 @@ def _hyp_discrete(p,bt,a,m):
                     b[v]=iv.mid()
                     if iv.width()<1e-2: pinned[v]=b[v]
     return [_make_hyp("dis",b,"discrete","TopoScope",[],pinned,p.variables,0.80)]
-
 def _hyp_quadratic(p,bt,a,m):
     hyps=[]; b=dict(bt.binding)
     if bt.l9 and bt.l9.dominant_vars:
-        for v in bt.l9.dominant_vars[:2]:
-            hyps.append(_make_hyp(f"qua_{v}",b,"quadratic",f"Root({v})",[],{v:b[v]},p.variables,0.70))
+        for v in bt.l9.dominant_vars[:2]: hyps.append(_make_hyp(f"qua_{v}",b,"quadratic",f"Root({v})",[],{v:b[v]},p.variables,0.70))
     return hyps if hyps else [_make_hyp("qua",b,"quadratic","Root",[],{},p.variables,0.55)]
-
 def _hyp_bilinear(p,bt,a,m):
     hyps=[]; b=dict(bt.binding)
     for vi,vj in p.bilinear_pairs:
-        lo_i,hi_i=p.bounds.get(vi,(0,10)); lo_j,hi_j=p.bounds.get(vj,(0,10))
-        product=abs(b.get(vi,1)*b.get(vj,1))
+        lo_i,hi_i=p.bounds.get(vi,(0,10)); lo_j,hi_j=p.bounds.get(vj,(0,10)); product=abs(b.get(vi,1)*b.get(vj,1))
         if product<=0: continue
         gm=math.sqrt(product)
         if lo_i<=gm<=hi_i and lo_j<=gm<=hi_j:
             nb=dict(b); nb[vi]=nb[vj]=gm
-            hyps.append(_make_hyp(f"bil_eq_{vi}_{vj}",nb,"bilinear",
-                f"GeoMean({vi}={vj}={gm:.3f})",["bilinear"],{vi:gm,vj:gm},
-                [v for v in p.variables if v not in [vi,vj]],0.70))
+            hyps.append(_make_hyp(f"bil_eq_{vi}_{vj}",nb,"bilinear",f"GeoMean({vi}={vj}={gm:.3f})",["bilinear"],{vi:gm,vj:gm},[v for v in p.variables if v not in [vi,vj]],0.70))
         for ratio in [0.4,0.7071,0.9]:
             vs=gm*ratio; vl=product/(vs+1e-9)
             if lo_i<=vs<=hi_i and lo_j<=vl<=hi_j and vs<vl:
                 nb2=dict(b); nb2[vi]=vs; nb2[vj]=vl
-                hyps.append(_make_hyp(f"bil_asc_{int(ratio*100)}_{vi}_{vj}",nb2,"bilinear",
-                    f"BilAsc({vi}={vs:.3f}<{vj}={vl:.3f})",["bilinear"],{vi:vs,vj:vl},
-                    [v for v in p.variables if v not in [vi,vj]],0.75))
+                hyps.append(_make_hyp(f"bil_asc_{int(ratio*100)}_{vi}_{vj}",nb2,"bilinear",f"BilAsc({vi}={vs:.3f}<{vj}={vl:.3f})",["bilinear"],{vi:vs,vj:vl},[v for v in p.variables if v not in [vi,vj]],0.75))
     return hyps
-
 def _hyp_monotone_product(p,bt,a,m):
     hyps=[]; b=dict(bt.binding)
     if not p.monotone_targets: return hyps
@@ -1615,24 +1867,18 @@ def _hyp_monotone_product(p,bt,a,m):
             vs=math.sqrt(vs_sq); vl=k/vs
             if not(lo_s<=vs<=hi_s and lo_l<=vl<=hi_l and vs<=vl): continue
             nb=dict(b); nb[v_small]=vs; nb[v_large]=vl
-            box={u:IV(*tb.get(u,p.bounds.get(u,(-10,10)))) for u in p.variables}
-            box[v_small]=IV(vs-1e-6,vs+1e-6); box[v_large]=IV(vl-1e-6,vl+1e-6)
-            cont=_hc4(box,p.compiled_constraints)
-            pinned={v_small:vs,v_large:vl}
+            box={u:IV(*tb.get(u,p.bounds.get(u,(-10,10)))) for u in p.variables}; box[v_small]=IV(vs-1e-6,vs+1e-6); box[v_large]=IV(vl-1e-6,vl+1e-6)
+            cont=_hc4(box,p.compiled_constraints); pinned={v_small:vs,v_large:vl}
             if cont:
                 for u,iv in cont.items():
                     if u in p.bounds: nb[u]=iv.mid()
                 pinned={u:nb[u] for u in p.variables if cont[u].width()<1e-2}
-            hyps.append(_make_hyp(f"mpr_{v_small}_{v_large}_r{int(ratio*100)}",nb,"monotone_product",
-                f"MonoProd({v_small}={vs:.4f}<={v_large}={vl:.4f})",["ordered","hc4"],pinned,
-                [u for u in p.variables if u not in pinned],0.88))
+            hyps.append(_make_hyp(f"mpr_{v_small}_{v_large}_r{int(ratio*100)}",nb,"monotone_product",f"MonoProd({v_small}={vs:.4f}<={v_large}={vl:.4f})",["ordered","hc4"],pinned,[u for u in p.variables if u not in pinned],0.88))
     return hyps
-
 def _hyp_metric(p,bt,a,m):
     hyps=[]; b=dict(bt.binding)
     for mc in p.compiled_constraints:
-        if mc.kind!="equality" or not mc.parsed: continue
-        if not mc.parsed.is_Add: continue
+        if mc.kind!="equality" or not mc.parsed or not mc.parsed.is_Add: continue
         sq_terms=[t for t in mc.parsed.args if t.is_Pow and t.args[1]==2]
         if len(sq_terms)<1: continue
         vars_in=[str(s) for s in mc.parsed.free_symbols if str(s) in p.variables]
@@ -1646,14 +1892,10 @@ def _hyp_metric(p,bt,a,m):
         scale=math.sqrt(target/curr_val); nb=dict(b)
         for v in vars_in:
             lo,hi=p.bounds.get(v,(-10,10)); nb[v]=max(lo,min(hi,b.get(v,0)*scale))
-        hyps.append(_make_hyp(f"met_{hash(mc.expr_str)%9999}",nb,"metric",
-            f"RadialProject(scale={scale:.4f},dim={len(vars_in)})",["metric",mc.expr_str],
-            {},list(p.variables),0.75))
+        hyps.append(_make_hyp(f"met_{hash(mc.expr_str)%9999}",nb,"metric",f"RadialProject(scale={scale:.4f},dim={len(vars_in)})",["metric",mc.expr_str],{},list(p.variables),0.75))
     return hyps
-
 def _hyp_symmetric(p,bt,a,m):
-    hyps=[]; b=dict(bt.binding)
-    groups_to_check=list(p.scope_vars.values()) if p.scope_vars else [p.variables]
+    hyps=[]; b=dict(bt.binding); groups_to_check=list(p.scope_vars.values()) if p.scope_vars else [p.variables]
     if not any(p.scope_vars.values()): groups_to_check=[p.variables]
     seen_pairs=set()
     for grp in groups_to_check:
@@ -1663,80 +1905,42 @@ def _hyp_symmetric(p,bt,a,m):
             for j in range(i+1,min(len(vl),8)):
                 vi,vj=vl[i],vl[j]
                 if (vi,vj) in seen_pairs: continue
-                seen_pairs.add((vi,vj))
-                lo_i,hi_i=p.bounds.get(vi,(-1e9,1e9)); lo_j,hi_j=p.bounds.get(vj,(-1e9,1e9))
-                bvi,bvj=b.get(vi,0),b.get(vj,0)
+                seen_pairs.add((vi,vj)); lo_i,hi_i=p.bounds.get(vi,(-1e9,1e9)); lo_j,hi_j=p.bounds.get(vj,(-1e9,1e9)); bvi,bvj=b.get(vi,0),b.get(vj,0)
                 if lo_i<=bvj<=hi_i and lo_j<=bvi<=hi_j:
                     nb=dict(b); nb[vi],nb[vj]=bvj,bvi
-                    hyps.append(_make_hyp(f"sym_{vi}_{vj}",nb,"symmetric",
-                        f"Swap({vi}<->{vj})",["symmetric"],{vi:nb[vi],vj:nb[vj]},
-                        [v for v in p.variables if v not in [vi,vj]],0.60))
+                    hyps.append(_make_hyp(f"sym_{vi}_{vj}",nb,"symmetric",f"Swap({vi}<->{vj})",["symmetric"],{vi:nb[vi],vj:nb[vj]},[v for v in p.variables if v not in [vi,vj]],0.60))
                 avg=(bvi+bvj)/2
                 if lo_i<=avg<=hi_i and lo_j<=avg<=hi_j:
                     nb2=dict(b); nb2[vi]=avg; nb2[vj]=avg
-                    hyps.append(_make_hyp(f"sym_avg_{vi}_{vj}",nb2,"symmetric",
-                        f"Average({vi}={vj}={avg:.4f})",["symmetric"],{vi:avg,vj:avg},
-                        [v for v in p.variables if v not in [vi,vj]],0.55))
+                    hyps.append(_make_hyp(f"sym_avg_{vi}_{vj}",nb2,"symmetric",f"Average({vi}={vj}={avg:.4f})",["symmetric"],{vi:avg,vj:avg},[v for v in p.variables if v not in [vi,vj]],0.55))
     return hyps[:10]
-
-def _hyp_ordered(p,bt,a,m):
-    return [_make_hyp("ord",bt.binding,"ordered","OrderBal",[],{},p.variables,0.67)]
-
-def _hyp_monotone(p,bt,a,m):
-    return [_make_hyp("mon",bt.binding,"monotone","MonoPath",[],{},p.variables,0.67)]
-
-def _hyp_convex(p,bt,a,m):
-    return [_make_hyp("cvx",bt.binding,"convex","ConvMix",[],{},p.variables,0.63)]
-
-def _hyp_conserved(p,bt,a,m):
-    return [_make_hyp("csv",bt.binding,"conserved","Conserve",[],{},p.variables,0.82)]
-
+def _hyp_ordered(p,bt,a,m): return [_make_hyp("ord",bt.binding,"ordered","OrderBal",[],{},p.variables,0.67)]
+def _hyp_monotone(p,bt,a,m): return [_make_hyp("mon",bt.binding,"monotone","MonoPath",[],{},p.variables,0.67)]
+def _hyp_convex(p,bt,a,m): return [_make_hyp("cvx",bt.binding,"convex","ConvMix",[],{},p.variables,0.63)]
+def _hyp_conserved(p,bt,a,m): return [_make_hyp("csv",bt.binding,"conserved","Conserve",[],{},p.variables,0.82)]
 def _hyp_mutable(p,bt,a,m):
     b=dict(bt.binding); pinned={}
     if bt.l9 and bt.l9.dominant_vars:
-        v=bt.l9.dominant_vars[0]; lo,hi=p.bounds.get(v,(-10,10))
-        b[v]=max(lo,min(hi,b.get(v,0)+random.gauss(0,(hi-lo)*0.05))); pinned={v:b[v]}
+        v=bt.l9.dominant_vars[0]; lo,hi=p.bounds.get(v,(-10,10)); b[v]=max(lo,min(hi,b.get(v,0)+random.gauss(0,(hi-lo)*0.05))); pinned={v:b[v]}
     return [_make_hyp("mut",b,"mutable","Perturb",[],pinned,p.variables,0.40)]
-
-def _hyp_network(p,bt,a,m):
-    return [_make_hyp("net",bt.binding,"network","HubProp",[],{},p.variables,0.65)]
-
-def _hyp_equilibrium(p,bt,a,m):
-    return [_make_hyp("eql",bt.binding,"equilibrium","GradBal",[],{},p.variables,0.72)]
-
+def _hyp_network(p,bt,a,m): return [_make_hyp("net",bt.binding,"network","HubProp",[],{},p.variables,0.65)]
+def _hyp_equilibrium(p,bt,a,m): return [_make_hyp("eql",bt.binding,"equilibrium","GradBal",[],{},p.variables,0.72)]
 def _hyp_superposition(p,bt,a,m):
     if a and len(a)>0:
-        other=random.choice(a); lam=0.5
-        nb={v:lam*bt.binding.get(v,0)+(1-lam)*other.binding.get(v,0) for v in p.variables}
+        other=random.choice(a); lam=0.5; nb={v:lam*bt.binding.get(v,0)+(1-lam)*other.binding.get(v,0) for v in p.variables}
         return [_make_hyp("sup",nb,"superposition","Superpose",[],{},p.variables,0.58)]
     return []
-
-def _hyp_locality(p,bt,a,m):
-    return [_make_hyp("loc",bt.binding,"locality","LocalFirst",[],{},p.variables,0.72)]
-
+def _hyp_locality(p,bt,a,m): return [_make_hyp("loc",bt.binding,"locality","LocalFirst",[],{},p.variables,0.72)]
 def _hyp_extremal(p,bt,a,m):
     hyps=[]; b=dict(bt.binding)
     if bt.l9 and bt.l9.dominant_vars:
         v=bt.l9.dominant_vars[0]; lo,hi=p.bounds.get(v,(0,1))
-        for val in [lo,hi]:
-            nb=dict(b); nb[v]=val
-            hyps.append(_make_hyp(f"ext_{v}_{val:.3f}",nb,"extremal",
-                f"PinBound({v}={val:.3f})",[],{v:val},p.variables,0.65))
+        for val in [lo,hi]: nb=dict(b); nb[v]=val; hyps.append(_make_hyp(f"ext_{v}_{val:.3f}",nb,"extremal",f"PinBound({v}={val:.3f})",[],{v:val},p.variables,0.65))
     return hyps
-
-def _hyp_entropy(p,bt,a,m):
-    return [_make_hyp("ent",{v:random.uniform(*p.bounds[v]) for v in p.variables},
-                      "entropy","MaxEnt",[],{},p.variables,0.48)]
-
-def _hyp_injective(p,bt,a,m):
-    return [_make_hyp("inj",bt.binding,"injective","Distinct",[],{},p.variables,0.50)]
-
-def _hyp_surjective(p,bt,a,m):
-    return [_make_hyp("sur",bt.binding,"surjective","Sweep",[],{},p.variables,0.45)]
-
-def _hyp_transitive(p,bt,a,m):
-    return [_make_hyp("tra",bt.binding,"transitive","TransSnap",[],{},p.variables,0.77)]
-
+def _hyp_entropy(p,bt,a,m): return [_make_hyp("ent",{v:random.uniform(*p.bounds[v]) for v in p.variables},"entropy","MaxEnt",[],{},p.variables,0.48)]
+def _hyp_injective(p,bt,a,m): return [_make_hyp("inj",bt.binding,"injective","Distinct",[],{},p.variables,0.50)]
+def _hyp_surjective(p,bt,a,m): return [_make_hyp("sur",bt.binding,"surjective","Sweep",[],{},p.variables,0.45)]
+def _hyp_transitive(p,bt,a,m): return [_make_hyp("tra",bt.binding,"transitive","TransSnap",[],{},p.variables,0.77)]
 def _hyp_atomic(p,bt,a,m):
     hyps=[]; b=dict(bt.binding)
     for mc in p.compiled_constraints:
@@ -1744,62 +1948,37 @@ def _hyp_atomic(p,bt,a,m):
         for v,projs in mc.projections.items():
             for proj in projs:
                 try:
-                    val=float(proj["func"](*[b.get(s,0.0) for s in proj["syms"]]))
-                    lo,hi=p.bounds.get(v,(-1e9,1e9))
+                    val=float(proj["func"](*[b.get(s,0.0) for s in proj["syms"]])); lo,hi=p.bounds.get(v,(-1e9,1e9))
                     if math.isfinite(val) and lo<=val<=hi:
-                        nb=dict(b); nb[v]=val
-                        hyps.append(_make_hyp(f"ato_{v}",nb,"atomic",
-                            f"Solve({v})",[],{v:val},p.variables,0.70))
-                        break
+                        nb=dict(b); nb[v]=val; hyps.append(_make_hyp(f"ato_{v}",nb,"atomic",f"Solve({v})",[],{v:val},p.variables,0.70)); break
                 except: pass
         if hyps: break
     return hyps
-
-def _hyp_implication(p,bt,a,m):
-    return [_make_hyp("imp",bt.binding,"implication","Imply",[],{},p.variables,0.78)]
-
+def _hyp_implication(p,bt,a,m): return [_make_hyp("imp",bt.binding,"implication","Imply",[],{},p.variables,0.78)]
 def _hyp_negation(p,bt,a,m):
-    nb={v:max(p.bounds[v][0],min(p.bounds[v][1],
-              (p.bounds[v][0]+p.bounds[v][1])-bt.binding.get(v,(p.bounds[v][0]+p.bounds[v][1])/2)))
-        for v in p.variables}
+    nb={v:max(p.bounds[v][0],min(p.bounds[v][1],(p.bounds[v][0]+p.bounds[v][1])-bt.binding.get(v,(p.bounds[v][0]+p.bounds[v][1])/2))) for v in p.variables}
     return [_make_hyp("neg",nb,"negation","Mirror",[],{},p.variables,0.42)]
-
-def _hyp_composite(p,bt,a,m):
-    return [_make_hyp("cmp",bt.binding,"composite","Enz",[],{},p.variables,0.90)]
-
-def _hyp_holism(p,bt,a,m):
-    return [_make_hyp("hol",bt.binding,"holism","Global",[],{},p.variables,0.73)]
-
+def _hyp_composite(p,bt,a,m): return [_make_hyp("cmp",bt.binding,"composite","Enz",[],{},p.variables,0.90)]
+def _hyp_holism(p,bt,a,m): return [_make_hyp("hol",bt.binding,"holism","Global",[],{},p.variables,0.73)]
 def _hyp_parsimony(p,bt,a,m):
-    b=dict(bt.binding); nb={}
-    max_val=max((abs(v) for v in b.values() if math.isfinite(v)), default=1.0)
+    b=dict(bt.binding); nb={}; max_val=max((abs(v) for v in b.values() if math.isfinite(v)), default=1.0)
     for v in p.variables:
         val=b[v]; lo,hi=p.bounds[v]
         if not math.isfinite(val): nb[v]=0.0; continue
         if abs(val)<0.1*max_val and lo<=0.0<=hi: nb[v]=0.0
         else:
-            candidates=[round(val*m)/m for m in [1,2,4] if lo<=round(val*m)/m<=hi]
-            nb[v]=min(candidates, key=lambda c:abs(c-val)) if candidates else val
+            candidates=[round(val*m)/m for m in [1,2,4] if lo<=round(val*m)/m<=hi]; nb[v]=min(candidates, key=lambda c:abs(c-val)) if candidates else val
     return [_make_hyp("par",nb,"parsimony","Occam",[],{},p.variables,0.58)]
-
-def _hyp_duality(p,bt,a,m):
-    return [_make_hyp("dua",bt.binding,"duality","Tight",[],{},p.variables,0.68)]
+def _hyp_duality(p,bt,a,m): return [_make_hyp("dua",bt.binding,"duality","Tight",[],{},p.variables,0.68)]
 
 AXIOM_CONSTRUCTORS={
-    Axiom.CONTINUOUS:_hyp_continuous,   Axiom.DISCRETE:_hyp_discrete,
-    Axiom.QUADRATIC:_hyp_quadratic,     Axiom.BILINEAR:_hyp_bilinear,
-    Axiom.METRIC:_hyp_metric,           Axiom.SYMMETRIC:_hyp_symmetric,
-    Axiom.ORDERED:_hyp_ordered,         Axiom.MONOTONE:_hyp_monotone,
-    Axiom.CONVEX:_hyp_convex,           Axiom.MONOTONE_PRODUCT:_hyp_monotone_product,
-    Axiom.CONSERVED:_hyp_conserved,     Axiom.MUTABLE:_hyp_mutable,
-    Axiom.NETWORK:_hyp_network,         Axiom.EQUILIBRIUM:_hyp_equilibrium,
-    Axiom.SUPERPOSITION:_hyp_superposition, Axiom.LOCALITY:_hyp_locality,
-    Axiom.EXTREMAL:_hyp_extremal,       Axiom.ENTROPY:_hyp_entropy,
-    Axiom.INJECTIVE:_hyp_injective,     Axiom.SURJECTIVE:_hyp_surjective,
-    Axiom.TRANSITIVE:_hyp_transitive,   Axiom.ATOMIC:_hyp_atomic,
-    Axiom.IMPLICATION:_hyp_implication, Axiom.NEGATION:_hyp_negation,
-    Axiom.COMPOSITE:_hyp_composite,     Axiom.HOLISM:_hyp_holism,
-    Axiom.PARSIMONY:_hyp_parsimony,     Axiom.DUALITY:_hyp_duality,
+    Axiom.CONTINUOUS:_hyp_continuous, Axiom.DISCRETE:_hyp_discrete, Axiom.QUADRATIC:_hyp_quadratic, Axiom.BILINEAR:_hyp_bilinear,
+    Axiom.METRIC:_hyp_metric, Axiom.SYMMETRIC:_hyp_symmetric, Axiom.ORDERED:_hyp_ordered, Axiom.MONOTONE:_hyp_monotone,
+    Axiom.CONVEX:_hyp_convex, Axiom.MONOTONE_PRODUCT:_hyp_monotone_product, Axiom.CONSERVED:_hyp_conserved, Axiom.MUTABLE:_hyp_mutable,
+    Axiom.NETWORK:_hyp_network, Axiom.EQUILIBRIUM:_hyp_equilibrium, Axiom.SUPERPOSITION:_hyp_superposition, Axiom.LOCALITY:_hyp_locality,
+    Axiom.EXTREMAL:_hyp_extremal, Axiom.ENTROPY:_hyp_entropy, Axiom.INJECTIVE:_hyp_injective, Axiom.SURJECTIVE:_hyp_surjective,
+    Axiom.TRANSITIVE:_hyp_transitive, Axiom.ATOMIC:_hyp_atomic, Axiom.IMPLICATION:_hyp_implication, Axiom.NEGATION:_hyp_negation,
+    Axiom.COMPOSITE:_hyp_composite, Axiom.HOLISM:_hyp_holism, Axiom.PARSIMONY:_hyp_parsimony, Axiom.DUALITY:_hyp_duality,
 }
 
 # ══════════════════════════════════════════════════════════════════════
@@ -1995,7 +2174,6 @@ class SequenceRayTracer:
                 out_baton=Baton(binding=final_b,ce=final_ce,ray_id=ray.ray_id,
                                 l9=L9Certificate(final_ce,dom_vars,[],tension_class))
                                 
-                # DYNAMIC BATON THRESHOLD FIX: Ensure states are saved relative to the current progress
                 dynamic_baton_thresh = 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
@@ -2006,9 +2184,10 @@ class SequenceRayTracer:
                 if improved:
                     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
                 
-                # DEPTH-0 BRANCHING FIX: Restore unconditional seed expansion (ray.depth < 1)
                 if (passed_pruning or improved or ray.depth < 1) and ray.depth < MAX_CHAIN_DEPTH:
                     remaining=[a for a in ALL_AXIOMS if a not in ray.sequence]
                     queues["core"].extend(bandit.intelligent_branch(ray,out_baton,remaining,BRANCH_WIDTH,sketch))
@@ -2067,7 +2246,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.2.
+COLLAPSER_SYSTEM_PROMPT = """You are the Grounded Hypothesis Engine for Practicality 27.3.
 
 Check infeasibility_report first. If non-empty: the system proved infeasibility via
 algebraic propagation before firing any rays. Output:
@@ -2176,7 +2355,7 @@ def collapse_solution(problem_text, axl_def, psl_text, binding, g1_pass, g2_pass
 # SECTION 15: GLOBAL SOLVE TASK
 # ══════════════════════════════════════════════════════════════════════
 def global_solve_task(original_problem_text, api_key, prebuilt_axl=None,
-                      use_proxy_decomp: bool=True, allow_retry: bool=True):
+                      use_proxy_decomp: bool=True):
     _update_state(
         is_running=True, phase="ENCODING", high_level_logs=[], answer="",
         best_ce=float('inf'), total_fired=0, best_ray="—",
@@ -2187,119 +2366,106 @@ def global_solve_task(original_problem_text, api_key, prebuilt_axl=None,
         minimize_result="",
     )
     try:
-        MAX_ATTEMPTS=3; current_text=original_problem_text
+        current_text=original_problem_text
         used_key=api_key or DEFAULT_GEMINI_API_KEY
         sketch_notes=[]; proxy_isos=[]
 
-        for attempt in range(1,MAX_ATTEMPTS+1):
-            if prebuilt_axl is not None:
-                _add_log("⚡ Direct AXL (template parser — no LLM encoder)")
-                axl_def=prebuilt_axl
-            else:
-                _add_log(f"🔍 LLM Encoding (attempt {attempt}/{MAX_ATTEMPTS})...")
-                try: axl_def=encode_problem_to_axl(current_text,used_key)
-                except Exception as e:
-                    _add_log(f"✗ Encode failed: {e}")
-                    _update_state(phase="ERROR",answer=f"Encoder Failed: {str(e)}"); return
+        if prebuilt_axl is not None:
+            _add_log("⚡ Direct AXL (template parser — no LLM encoder)")
+            axl_def=prebuilt_axl
+        else:
+            _add_log(f"🔍 LLM Encoding (One-Shot)...")
+            try: axl_def=encode_problem_to_axl(current_text,used_key)
+            except Exception as e:
+                _add_log(f"✗ Encode failed: {e}")
+                _update_state(phase="ERROR",answer=f"Encoder Failed: {str(e)}"); return
 
-            _add_log(f"✓ `{axl_def.name}` | {len(axl_def.variables)} vars | {len(axl_def.constraints)} constraints")
-            if axl_def.minimize_var: _add_log(f"  ↳ MINIMIZE Directive: {axl_def.minimize_var}")
-            _update_state(phase="COMPILING")
+        _add_log(f"✓ `{axl_def.name}` | {len(axl_def.variables)} vars | {len(axl_def.constraints)} constraints")
+        if axl_def.minimize_var: _add_log(f"  ↳ MINIMIZE Directive: {axl_def.minimize_var}")
+        _update_state(phase="COMPILING")
 
-            try: psl_text=AXL_COMPILER.compile(axl_def); base_prob=build_base_problem(axl_def)
-            except Exception as e:
-                _add_log(f"✗ Compile failed: {e}")
-                _update_state(phase="ERROR",answer=f"Compiler Failed: {str(e)}"); return
+        try: psl_text=AXL_COMPILER.compile(axl_def); base_prob=build_base_problem(axl_def)
+        except Exception as e:
+            _add_log(f"✗ Compile failed: {e}")
+            _update_state(phase="ERROR",answer=f"Compiler Failed: {str(e)}"); return
+
+        try:
+            _add_log("🚀 Ray Tracer...")
+            tracer=SequenceRayTracer()
+            binding,ce,traces,total_fired,best_ray_name=tracer.trace(
+                axl_def,base_prob,use_proxy_decomp=use_proxy_decomp)
+        except Exception as e:
+            _add_log(f"✗ Solver error: {e}")
+            _update_state(phase="ERROR",answer=f"Ray Tracer Crashed: {str(e)}"); raise e
+
+        _update_state(phase="QUANTIZING")
+        q_binding,q_ce,q_success=quantize_binding(binding,base_prob)
+        if q_success and any(abs(q_binding.get(v,0)-binding.get(v,0))>0.01 for v in base_prob.int_vars):
+            _add_log(f"🧱 Quantize+Propagate: CE {ce:.4f} -> {q_ce:.4f}")
+            binding=q_binding; ce=q_ce
+
+        with STATE_LOCK:
+            sketch_notes=GLOBAL_SOLVE_STATE.get("sketch_summary","").split("; ")
+            current_sympy_derivation=GLOBAL_SOLVE_STATE.get("sympy_derivation",[])
+            proxy_isos=GLOBAL_SOLVE_STATE.get("proxy_component_isos",[])
+            current_prop_log=GLOBAL_SOLVE_STATE.get("propagation_log",[])
+            current_infeas=GLOBAL_SOLVE_STATE.get("infeasibility_report","")
+
+        for inv in axl_def.anchors:
+            if not inv.compiled_func:
+                try: inv.compile(base_prob.variables)
+                except: pass
 
+        g1_ce=base_prob.scalar_energy(binding); g1_pass=g1_ce<VERIFY_G1_THRESHOLD
+        inv_results={}
+        for inv in axl_def.anchors:
             try:
-                _add_log("🚀 Ray Tracer...")
-                tracer=SequenceRayTracer()
-                binding,ce,traces,total_fired,best_ray_name=tracer.trace(
-                    axl_def,base_prob,use_proxy_decomp=use_proxy_decomp)
-            except Exception as e:
-                _add_log(f"✗ Solver error: {e}")
-                _update_state(phase="ERROR",answer=f"Ray Tracer Crashed: {str(e)}"); raise e
+                val=float(inv.compiled_func(*[binding.get(v,0.0) for v in inv.syms_used]))
+                err=abs(val)
+                if inv.mode=="eq": passed=err<inv.tolerance
+                elif inv.mode=="geq": passed=val>=-inv.tolerance
+                else: passed=val<=inv.tolerance
+                inv_results[inv.name]=(safe_round(val,6),passed)
+            except: inv_results[inv.name]=(999.0,False)
+        g2_pass=all(v[1] for v in inv_results.values()) if inv_results else True
+
+        infeas_obj=None
+        if current_infeas: infeas_obj=InfeasibilityReport(True,[],current_infeas,True)
+        
+        min_var = base_prob.minimize_var
+        min_val = binding.get(min_var) if min_var else None
 
-            _update_state(phase="QUANTIZING")
-            q_binding,q_ce,q_success=quantize_binding(binding,base_prob)
-            if q_success and any(abs(q_binding.get(v,0)-binding.get(v,0))>0.01 for v in base_prob.int_vars):
-                _add_log(f"🧱 Quantize+Propagate: CE {ce:.4f} -> {q_ce:.4f}")
-                binding=q_binding; ce=q_ce
+        raw_json=build_raw_results_json(binding,ce,g1_pass,g2_pass,inv_results,current_prop_log,infeas_obj,min_var,min_val)
+        _update_state(raw_results_json=raw_json)
+        if min_var and min_val is not None:
+            _update_state(minimize_result=f"{min_var} = {safe_round(min_val,4)}")
 
-            with STATE_LOCK:
-                sketch_notes=GLOBAL_SOLVE_STATE.get("sketch_summary","").split("; ")
-                current_sympy_derivation=GLOBAL_SOLVE_STATE.get("sympy_derivation",[])
-                proxy_isos=GLOBAL_SOLVE_STATE.get("proxy_component_isos",[])
-                current_prop_log=GLOBAL_SOLVE_STATE.get("propagation_log",[])
-                current_infeas=GLOBAL_SOLVE_STATE.get("infeasibility_report","")
-
-            for inv in axl_def.anchors:
-                if not inv.compiled_func:
-                    try: inv.compile(base_prob.variables)
-                    except: pass
+        solved_str=("✓ SOLVED" if (g1_pass and g2_pass)
+                    else "🚫 INFEASIBLE" if current_infeas
+                    else "~ PARTIAL" if g1_pass else "✗ UNSOLVED")
+        best_ray=traces[-1].ray_name if traces and traces[-1].survived else best_ray_name
+        _add_log(f"🏁 {solved_str} (CE: {safe_round(ce,5)}) | Ray: {best_ray}")
 
-            g1_ce=base_prob.scalar_energy(binding); g1_pass=g1_ce<VERIFY_G1_THRESHOLD
-            inv_results={}
-            for inv in axl_def.anchors:
-                try:
-                    val=float(inv.compiled_func(*[binding.get(v,0.0) for v in inv.syms_used]))
-                    err=abs(val)
-                    if inv.mode=="eq": passed=err<inv.tolerance
-                    elif inv.mode=="geq": passed=val>=-inv.tolerance
-                    else: passed=val<=inv.tolerance
-                    inv_results[inv.name]=(safe_round(val,6),passed)
-                except: inv_results[inv.name]=(999.0,False)
-            g2_pass=all(v[1] for v in inv_results.values()) if inv_results else True
-
-            infeas_obj=None
-            if current_infeas: infeas_obj=InfeasibilityReport(True,[],current_infeas,True)
-            
-            min_var = base_prob.minimize_var
-            min_val = binding.get(min_var) if min_var else None
-
-            raw_json=build_raw_results_json(binding,ce,g1_pass,g2_pass,inv_results,current_prop_log,infeas_obj,min_var,min_val)
-            _update_state(raw_results_json=raw_json)
-            if min_var and min_val is not None:
-                _update_state(minimize_result=f"{min_var} = {safe_round(min_val,4)}")
-
-            solved_str=("✓ SOLVED" if (g1_pass and g2_pass)
-                        else "🚫 INFEASIBLE" if current_infeas
-                        else "~ PARTIAL" if g1_pass else "✗ UNSOLVED")
-            best_ray=traces[-1].ray_name if traces and traces[-1].survived else best_ray_name
-            _add_log(f"🏁 {solved_str} (CE: {safe_round(ce,5)}) | Ray: {best_ray}")
-
-            record_fingerprint(axl_def.name,best_ray,binding,ce)
-            is_div,fp_msg=detect_divergence(axl_def.name)
-            if fp_msg: _update_state(fingerprint_summary=fp_msg)
-
-            if prebuilt_axl is None and allow_retry and not current_infeas:
-                if not g1_pass and attempt<MAX_ATTEMPTS:
-                    current_text=(original_problem_text+
-                        f"\n\nPREVIOUS ATTEMPT FAILED (CE: {ce}):\nApply ALGEBRAIC REDUCTION.")
-                    _add_log("⚠ Geometric failure. Retrying..."); continue
-                if not g2_pass and attempt<MAX_ATTEMPTS:
-                    failed={k:v for k,(v,ok) in inv_results.items() if not ok}
-                    current_text=(original_problem_text+
-                        f"\n\nGate 2 failed:\n{json.dumps(failed,indent=2)}\nRevise constraints.")
-                    _add_log("⚠ Gate 2 failure. Retrying..."); continue
-
-            scaling_exponents=empirical_scaling_probe(axl_def,base_prob,binding,best_ray)
-            raw_eqs=[mc.expr_str for mc in base_prob.compiled_constraints if mc.kind=="equality"]
-
-            _add_log("🔤 Collapsing → Grounded Hypothesis...")
-            _update_state(phase="COLLAPSING")
-            try:
-                answer=collapse_solution(
-                    original_problem_text,axl_def,psl_text,binding,
-                    g1_pass,g2_pass,inv_results,best_ray,total_fired,
-                    sketch_notes,current_sympy_derivation,proxy_isos,
-                    scaling_exponents,raw_eqs,current_prop_log,current_infeas,
-                    min_var,min_val,used_key)
-                _update_state(answer=answer,phase="DONE"); _add_log("✓ Done.")
-            except Exception as e:
-                _update_state(answer=f"Collapse error: {e}\n\nRAW:\n{raw_json}",phase="ERROR")
-                _add_log("✗ Collapse failed — raw results available.")
-            break
+        record_fingerprint(axl_def.name,best_ray,binding,ce)
+        is_div,fp_msg=detect_divergence(axl_def.name)
+        if fp_msg: _update_state(fingerprint_summary=fp_msg)
+
+        scaling_exponents=empirical_scaling_probe(axl_def,base_prob,binding,best_ray)
+        raw_eqs=[mc.expr_str for mc in base_prob.compiled_constraints if mc.kind=="equality"]
+
+        _add_log("🔤 Collapsing → Grounded Hypothesis...")
+        _update_state(phase="COLLAPSING")
+        try:
+            answer=collapse_solution(
+                original_problem_text,axl_def,psl_text,binding,
+                g1_pass,g2_pass,inv_results,best_ray,total_fired,
+                sketch_notes,current_sympy_derivation,proxy_isos,
+                scaling_exponents,raw_eqs,current_prop_log,current_infeas,
+                min_var,min_val,used_key)
+            _update_state(answer=answer,phase="DONE"); _add_log("✓ Done.")
+        except Exception as e:
+            _update_state(answer=f"Collapse error: {e}\n\nRAW:\n{raw_json}",phase="ERROR")
+            _add_log("✗ Collapse failed — raw results available.")
 
     except Exception as e:
         import traceback; traceback.print_exc()
@@ -2340,11 +2506,11 @@ def trigger_hypothesis_solve(template_name, api_key):
         axl_def=None
     if axl_def is not None:
         threading.Thread(target=global_solve_task,args=(problem_text,api_key),
-                         kwargs={"prebuilt_axl":axl_def,"use_proxy_decomp":True,"allow_retry":False},
+                         kwargs={"prebuilt_axl":axl_def,"use_proxy_decomp":True},
                          daemon=True).start()
     else:
         threading.Thread(target=global_solve_task,args=(problem_text,api_key),
-                         kwargs={"use_proxy_decomp":True,"allow_retry":False},
+                         kwargs={"use_proxy_decomp":True},
                          daemon=True).start()
 
 # ══════════════════════════════════════════════════════════════════════
@@ -2486,10 +2652,10 @@ def _reset_ans_cache(a_cache):
     return a_cache
 
 # ── Gradio App ────────────────────────────────────────────────────────
-with gr.Blocks(css=CSS, title="Practicality 27.2") as demo:
+with gr.Blocks(css=CSS, title="Practicality 27.3") as demo:
     gr.Markdown(
-        "## ⚗ Practicality 27.2 — The Restored Core & Safe Minimize\n"
-        "`[Direct Parser] -> [INT Grid] -> [Infeasibility Detector] -> [Original Space Adam] -> [Tree Re-expansion]`"
+        "## ⚗ Practicality 27.3 — The Fail-Fast Core\n"
+        "`[Direct Parser / LLM] -> [INT Grid] -> [Orig Space Adam] -> [No Retry Loops — Manual Recalibration]`"
     )
 
     dash_cache = gr.State({"html": ""})
@@ -2536,18 +2702,17 @@ with gr.Blocks(css=CSS, title="Practicality 27.2") as demo:
                 value=(f"Compute: {DEVICE.type.upper()}\n"
                        f"Axioms: {len(ALL_AXIOMS)}\n"
                        f"Templates: {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)}\n"
-                       f"\n27.2 RESTORATION FIXES:\n"
-                       f"  ✓ RESTORED: ray.depth < 1 unconditional branching.\n"
-                       f"    (The queue no longer drains at ~400 rays).\n"
-                       f"  ✓ DYNAMIC: Baton Registry tracks best_ce properly.\n"
-                       f"  ✓ DECOUPLED: MINIMIZE directive removed from CE verify.\n"
-                       f"  ✓ SHIELDED: Float32 max overflow native handler.\n"
-                       f"  ✓ STABLE: Range-normalized Adam reverted to orig space.\n"
-                       f"\n27.1 FEATURES RETAINED:\n"
-                       f"  MINIMIZE Soft Objectives (safely isolated)\n"
-                       f"  INT Grid Combinatorics\n"
-                       f"  Algebraic Feasibility Scanner\n"
-                       f"  Proxy Decomposition (w/ full graph skip)\n"
+                       f"\n27.3 UPDATES (Fail-Fast Paradigm):\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}"),
                 lines=35,interactive=False,elem_classes=["solver-log"])
@@ -2576,15 +2741,15 @@ with gr.Blocks(css=CSS, title="Practicality 27.2") as demo:
         outputs=[live_html,dash_cache,ans_cache],
         js="""
         function() {
-            if (!window._p272_dash) {
-                window._p272_dash = setInterval(() => {
+            if (!window._p273_dash) {
+                window._p273_dash = setInterval(() => {
                     const el = document.getElementById('dash_poll_btn');
                     if (!el) return;
                     (el.tagName === 'BUTTON' ? el : el.querySelector('button'))?.click();
                 }, 1000);
             }
-            if (!window._p272_ans) {
-                window._p272_ans = setInterval(() => {
+            if (!window._p273_ans) {
+                window._p273_ans = setInterval(() => {
                     const el = document.getElementById('ans_poll_btn');
                     if (!el) return;
                     (el.tagName === 'BUTTON' ? el : el.querySelector('button'))?.click();
@@ -2622,13 +2787,11 @@ with gr.Blocks(css=CSS, title="Practicality 27.2") as demo:
                            outputs=[ans_cache])
 
     gr.Markdown(
-        f"Practicality 27.2 · Search Re-Expanded · Float32 Overflow Protected",
+        f"Practicality 27.3 · Strict One-Shot Paradigm · Fail-Fast Core",
         elem_classes=["status-bar"])
 
 if __name__ == "__main__":
-    print(f"[SYSTEM 27.2] Compute: {DEVICE.type.upper()} | Quantum={HAS_QUANTUM}")
-    print(f"[SYSTEM 27.2] Templates: {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)}")
-    print(f"[SYSTEM 27.2] Fixes: Depth-0 Branching, Dynamic Baton Threshold, Decoupled MINIMIZE")
-    print(f"[SYSTEM 27.2] Fixes: Float32 Exponent Overflow Native Shield")
-    print(f"[SYSTEM 27.2] Adam logic: Reverted to Original Space bounds tracking")
+    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.")
     demo.launch(server_name="0.0.0.0", server_port=7860, share=False)