Update app.py

app.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 25.4 — DYNAMIC STALEMATE RESOLUTION
+PRACTICALITY SYSTEM 25.5 — TRUE SYNTHESIS & EARTHQUAKE PROTOCOL
 ══════════════════════════════════════════════════════════════════════════════════
 ARCHITECTURE:
   User Text → [GEMINI ENCODER] → AXLProblemDef (with is_int strict typing)
@@ -14,11 +14,12 @@ ARCHITECTURE:
             → [GEMINI COLLAPSER]  → Synthesize Formulas & Algorithms
             → [SYMBOLIC LOOPBACK] → SymPy evaluates formulas → FINAL OUTPUT
 
-NEW IN 25.4 (STALEMATE BREAKER):
-  - Dynamic Depth Allocation: Monitors ray progress. If stuck for 15k rays, 
-    dynamically adds +10 to max depth and relaxes pruning to break local minima.
-  - Baton Resurrection: Injects top dead branches back into the active queue
-    when a stalemate is detected, utilizing the newly expanded depth.
+NEW IN 25.5 (EARTHQUAKE PROTOCOL & BOUND EXPANSION):
+  - Earthquake Protocol: When stalemate hits, instead of small jitters, 
+    the system injects severe ENTROPY mutations and pure Monte Carlo seeds
+    to violently kick Adam out of boundary traps.
+  - Synthesis Bounds Expanded: 5P Manifold coordinates widened from [-15, 15] 
+    to [-1000, 10000] to prevent the physical math from choking on the boundary wall.
 """
 
 import os, time, random, math, threading, warnings, json, textwrap, itertools, copy
@@ -48,12 +49,12 @@ except ImportError:
 # AI CONFIGURATION
 # ══════════════════════════════════════════════════════════════════════
 DEFAULT_GEMINI_API_KEY = os.environ.get("AI_Key", "")
-GEMINI_MODEL = "gemini-3.5-flash" # "gemma-4-26b-a4b-it"  # 
+GEMINI_MODEL = "gemini-2.5-pro-preview-06-05"
 
 warnings.filterwarnings("ignore")
 USE_GPU = torch.cuda.is_available()
 DEVICE  = torch.device("cuda" if USE_GPU else "cpu")
-print(f"[SYSTEM 25.4] Compute: {DEVICE.type.upper()} | Dynamic Stalemate Breaker Active")
+print(f"[SYSTEM 25.5] Compute: {DEVICE.type.upper()} | Earthquake Protocol Active")
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 1: CONSTANTS
@@ -68,10 +69,10 @@ MAX_RAYS_PER_ATTEMPT     = 24576 * 20  # ~491,520 rays
 RAY_BATCH_SIZE           = 24576
 TEMPLATE_BATCH_SIZE      = 1024
 
-# Base pruning and depth values (Dynamically altered by Stalemate Breaker)
+# Base pruning and depth values
 INITIAL_CE_EARN_RATIO    = 0.98
 INITIAL_MAX_DEPTH        = 10
-STALEMATE_TRIGGER        = 15000       # Rays fired without improvement to trigger breaker
+STALEMATE_TRIGGER        = 15000       # Rays fired without improvement to trigger Earthquake
 
 N_MPRT_EXPLORE           = 1000
 PROJECTION_CACHE: Dict   = {}
@@ -886,6 +887,35 @@ def get_fingerprint_summary(problem_name:str) -> str:
 # ══════════════════════════════════════════════════════════════════════
 STRUCTURAL_HYPOTHESIS_TEMPLATES = {
 
+"secp256k1 Direct 5P Manifold Synthesis": """\
+WORKING HYPOTHESIS: secp256k1 Direct Addition Shortcut (P to 5P)
+================================================================
+Bypass the standard double-and-add chain. Synthesize a direct algebraic mapping
+from a base point P to 5P by identifying where intermediate tangent denominators cancel.
+
+Variables:
+  x1 in [0.5, 3.0]     Base point x
+  y1 in [0.5, 5.0]     Base point y
+  lam1 in [-100, 100]  First composite slope
+  lam2 in [-100, 100]  Second composite slope
+  x5 in [-1000, 1000]  Direct 5P x-coordinate (WIDENED BOUNDS)
+  y5 in [-10000, 10000] Direct 5P y-coordinate (WIDENED BOUNDS)
+  denom in [-50, 50]   The vanishing denominator
+
+Constraints:
+  EQ weight=10: y1**2 - x1**3 - 7
+  EQ weight=10: denom - (x5 - x1)
+  EQ weight=5: lam1*denom - (y5 - y1)
+  EQ weight=5: lam2*denom - (y5 + y1)
+  EQ weight=10: x5 - lam1**2 + 2*x1
+  EQ weight=10: y5**2 - x5**3 - 7
+
+Anchor: y5**2 - x5**3 - 7 = 0 (tolerance 0.01).
+
+COLLAPSER INSTRUCTION: The solver has found a consistent manifold connecting P to 5P.
+Extract the relationship between `lam1` and `x1` to write the closed-form direct mapping algorithm.
+""",
+
 "Quantum Heisenberg VQE Synthesis": """\
 WORKING HYPOTHESIS: Transverse Field Ising Model (TFIM) Ground State Synthesis
 =============================================================================
@@ -919,42 +949,13 @@ COLLAPSER INSTRUCTION: From the synthesized observables `x_i` and `z_i`, derive
 the rotation angles (Rx, Ry) needed to instantiate this state on a quantum computer.
 """,
 
-"secp256k1 Direct 5P Manifold Synthesis": """\
-WORKING HYPOTHESIS: secp256k1 Direct Addition Shortcut (P to 5P)
-================================================================
-Bypass the standard double-and-add chain. Synthesize a direct algebraic mapping
-from a base point P to 5P by identifying where intermediate tangent denominators cancel.
-
-Variables:
-  x1 in [0.5, 3.0]     Base point x
-  y1 in [0.5, 5.0]     Base point y
-  lam1 in [-10, 10]    First composite slope
-  lam2 in [-10, 10]    Second composite slope
-  x5 in [-15, 15]      Direct 5P x-coordinate
-  y5 in [-30, 30]      Direct 5P y-coordinate
-  denom in [-5, 5]     The vanishing denominator
-
-Constraints:
-  EQ weight=10: y1**2 - x1**3 - 7
-  EQ weight=10: denom - (x5 - x1)
-  EQ weight=5: lam1*denom - (y5 - y1)
-  EQ weight=5: lam2*denom - (y5 + y1)
-  EQ weight=10: x5 - lam1**2 + 2*x1
-  EQ weight=10: y5**2 - x5**3 - 7
-
-Anchor: y5**2 - x5**3 - 7 = 0 (tolerance 0.01).
-
-COLLAPSER INSTRUCTION: The solver has found a consistent manifold connecting P to 5P.
-Extract the relationship between `lam1` and `x1` to write the closed-form direct mapping algorithm.
-""",
-
 "secp256k1 wNAF Integer Traversal": """\
 WORKING HYPOTHESIS: secp256k1 Optimal Scalar Multiplication via wNAF
 =====================================================================
 Find the optimal INTEGER window size w for computing kG on secp256k1.
 
 Variables:
-  w            in [2, 6] INT    window size for wNAF (BOUNDED TO PREVENT CANYON)
+  w            in [2, 6] INT    window size for wNAF
   precomp_ops  in [0, 64]       point additions for precomputation
   naf_adds     in [0, 512]      additions in main loop
   naf_doubles  in [200, 280]    doublings (≈256 always)
@@ -1277,7 +1278,7 @@ def _verify(binding,base_problem,anchors):
     return g1_pass,all(v[1] for v in g2.values()) if g2 else True,g2,round(g1_ce,6)
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 13: SEQUENCE RAY TRACER (WITH DYNAMIC STALEMATE BREAKER)
+# SECTION 13: SEQUENCE RAY TRACER (WITH EARTHQUAKE PROTOCOL)
 # ══════════════════════════════════════════════════════════════════════
 class SequenceRayTracer:
 
@@ -1359,7 +1360,7 @@ class SequenceRayTracer:
         seed_baton=Baton(binding=best_binding,ce=best_ce,ray_id="SEED",
                          l9=L9Certificate(best_ce,base_problem.variables[:3],[],"systemic"))
 
-        # --- 25.4 Dynamic Stalemate Breaker State ---
+        # --- 25.5 Earthquake Protocol State ---
         current_max_depth = INITIAL_MAX_DEPTH
         current_earn_ratio = INITIAL_CE_EARN_RATIO
         stalemate_counter = 0
@@ -1371,7 +1372,7 @@ class SequenceRayTracer:
             if not batch_rays:
                 if total_fired>0 and total_fired<5000:
                     _add_log("⚠ Ray extinction! Firing mutation scouts from global best...")
-                    queues["core"]=[AxiomRay(["MUTABLE"],f"RESURRECT_{i}","scout",
+                    queues["core"]=[AxiomRay(["ENTROPY"],f"RESURRECT_{i}","scout",
                                               ce_prior=best_ce,
                                               baton=Baton(best_binding,best_ce))
                                     for i in range(64)]
@@ -1389,7 +1390,6 @@ class SequenceRayTracer:
 
             eval_results=_batched_deduce_and_evaluate(base_problem,[h for _,h in batch_hyps])
             
-            # Track if this batch improved the global best CE
             batch_improved_global = False
 
             for (ray_idx,hyp),(final_b,final_ce,dom_vars,tension_class) in zip(batch_hyps,eval_results):
@@ -1400,7 +1400,6 @@ class SequenceRayTracer:
                 improved=final_ce<best_ce
                 if improved: batch_improved_global = True
                 
-                # 25.4: Dynamic Pruning Check
                 passed_pruning = final_ce <= parent_ce * current_earn_ratio
                 
                 if improved or (g1_pass and g2_pass) or passed_pruning:
@@ -1420,29 +1419,35 @@ class SequenceRayTracer:
                     model.best_ray=ray.name; best_ray_name=ray.name
                 if g1_pass and g2_pass and final_ce<SOLVE_THRESHOLD: solved=True
                 
-                # Extend if pruning passed AND we haven't hit the dynamic depth limit
                 if (passed_pruning or improved) and ray.depth < current_max_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))
 
-            # --- STALEMATE BREAKER LOGIC ---
+            # --- 25.5 EARTHQUAKE PROTOCOL ---
             if batch_improved_global:
                 stalemate_counter = 0
-                # Slowly restore strict pruning if we broke out
                 current_earn_ratio = max(INITIAL_CE_EARN_RATIO, current_earn_ratio - 0.005)
             else:
                 stalemate_counter += len(batch_rays)
 
             if stalemate_counter > STALEMATE_TRIGGER and not solved:
                 current_max_depth += 10
-                current_earn_ratio = min(1.05, current_earn_ratio + 0.02) # Annealing step
-                _add_log(f"⚡ STALEMATE DETECTED. Depth allowed → {current_max_depth}, Pruning relaxed → {current_earn_ratio:.2f}")
+                current_earn_ratio = min(1.05, current_earn_ratio + 0.02)
+                _add_log(f"🌋 STALEMATE DETECTED. Triggering Earthquake Protocol (Depth → {current_max_depth})")
                 
-                # Resurrect the top 64 batons to explore the new depth
+                # 1. Mutate existing dead branches violently to kick them out of the basin
                 best_batons = sorted(baton_registry.values(), key=lambda b: b.ce)[:64]
-                for b in best_batons:
-                    queues["core"].append(AxiomRay(["MUTABLE"], f"STLM_{b.ray_id[:6]}", "recombine", depth=0, baton=b, ce_prior=b.ce))
-                stalemate_counter = 0 # Reset counter after triggering
+                for i, b in enumerate(best_batons):
+                    axiom_to_apply = "ENTROPY" if i % 2 == 0 else "NEGATION"
+                    queues["core"].append(AxiomRay([axiom_to_apply], f"EQK_{b.ray_id[:4]}", "scout", depth=0, baton=b, ce_prior=b.ce))
+                
+                # 2. Inject completely fresh pure random seeds (Monte Carlo Restart)
+                _add_log("  ↳ Injecting pure random global seeds to escape local minimum...")
+                for _ in range(16):
+                    init_b, init_ce = _mprt_sample(base_problem, {v: IV(*base_problem.bounds[v]) for v in base_problem.variables}, 200)
+                    queues["core"].append(AxiomRay(["ENTROPY"], f"EQK_RND", "seed", depth=0, baton=Baton(init_b, init_ce), ce_prior=init_ce))
+                    
+                stalemate_counter = 0
 
             queues["core"].sort(key=lambda r:r.ce_prior+(r.depth*0.0001))
             with STATE_LOCK:
@@ -1663,7 +1668,7 @@ def global_solve_task(original_problem_text,api_key,prebuilt_axl=None,
                 return
 
             try:
-                _add_log("🚀 Ray Tracer (Dynamic Stalemate Breaker + UCB1 Bandit)...")
+                _add_log("🚀 Ray Tracer (Earthquake Protocol + UCB1 Bandit)...")
                 tracer=SequenceRayTracer()
                 binding,ce,traces,total_fired,best_ray_name=tracer.trace(
                     axl_def,base_prob,use_proxy_decomp=use_proxy_decomp)
@@ -1672,7 +1677,7 @@ def global_solve_task(original_problem_text,api_key,prebuilt_axl=None,
                 _update_state(phase="ERROR",answer=f"Ray Tracer Crashed: {str(e)}")
                 raise e
 
-            # -- QUANTIZATION PASS (HARDENED 25.4) --
+            # -- QUANTIZATION PASS --
             _update_state(phase="QUANTIZING")
             q_binding, q_ce, q_success = quantize_binding(binding, base_prob)
             if q_success and q_binding != binding:
@@ -1731,7 +1736,7 @@ def global_solve_task(original_problem_text,api_key,prebuilt_axl=None,
                         f"{json.dumps(failed,indent=2)}\nRevise constraint encoding.")
                     _add_log("⚠ Gate 2 failed. Retrying with structural feedback..."); continue
 
-            # -- EMPIRICAL SCALING PROBE (HARDENED 25.4) --
+            # -- EMPIRICAL SCALING PROBE --
             scaling_exponents = empirical_scaling_probe(axl_def, base_prob, binding, best_ray)
 
             _add_log("🔤 Collapsing isomorphism → Grounded Hypothesis...")
@@ -1886,10 +1891,10 @@ def build_live_html():
       <div style='flex:1;overflow-y:auto;border-top:1px solid #222;padding-top:8px'>{ray_trail}</div>
     </div>"""
 
-with gr.Blocks(css=CSS,title="Practicality 25.4") as demo:
+with gr.Blocks(css=CSS,title="Practicality 25.5") as demo:
     gr.Markdown(
-        "## ⚗ Practicality 25.4 — Dynamic Stalemate Resolution\n"
-        "`[Gemini] → [Heisenberg Ray Synthesizer + Breaker] → [Empirical Phase Probe] → [SymPy Loopback] → [Output]`"
+        "## ⚗ Practicality 25.5 — Earthquake Synthesis Engine\n"
+        "`[Gemini] → [Heisenberg Ray Synthesizer + Earthquake] → [Empirical Phase Probe] → [SymPy Loopback] → [Output]`"
     )
     with gr.Row(elem_classes=["wrap-row"]):
         with gr.Column(scale=2,min_width=300):
@@ -1909,7 +1914,7 @@ with gr.Blocks(css=CSS,title="Practicality 25.4") as demo:
             with gr.Group():
                 gr.Markdown(
                     "### 2. Grounded Synthesis Templates\n"
-                    "*Runs synthesize novel algebraic shortcuts or states directly (no toy resource estimation).*"
+                    "*Runs synthesize novel algebraic shortcuts or states directly.*"
                 )
                 hyp_dropdown=gr.Dropdown(
                     choices=list(STRUCTURAL_HYPOTHESIS_TEMPLATES.keys()),
@@ -1931,20 +1936,20 @@ with gr.Blocks(css=CSS,title="Practicality 25.4") as demo:
             gr.Textbox(
                 value=(f"Compute: {DEVICE.type.upper()}\n"
                        f"Axioms: {len(ALL_AXIOMS)}\n"
-                       f"NEW 25.4: Dynamic Stalemate Breaker\n"
-                       f"  → Monitors rays for flat CE plateau\n"
+                       f"NEW 25.5: Earthquake Protocol\n"
+                       f"  → Eliminates boundary-wall traps\n"
+                       f"  → Injects massive ENTROPY / NEGATION\n"
+                       f"  → Injects pure Monte Carlo Restart seeds\n"
+                       f"NEW 25.5: Expanded Synthesis Bounds\n"
+                       f"  → 5P Manifold variables physically unchoked\n"
+                       f"KEPT: 25.4 Stalemate Breaker\n"
                        f"  → Dynamically adds +10 to Depth cap\n"
                        f"  → Relaxes Pruning rules via Annealing\n"
-                       f"  → Resurrects Top 64 dead batons\n"
                        f"KEPT: 25.3 Synthesis Engine\n"
                        f"  → Proxy Decomp fully functional\n"
-                       f"  → Heisenberg State Synthesis\n"
-                       f"  → Algebraic Shortcut Discovery\n"
                        f"  → ~500,000 Ray Search Capacity\n"
                        f"KEPT: 25.2 Guardrails\n"
-                       f"  → Strict Quantization (is_int Snap)\n"
-                       f"  → Empirical Scaling Probe (O(N^x))\n"
-                       f"  → Symbolic LLM Loopback (SymPy Eval)"),
+                       f"  → Strict Quantization (is_int Snap)"),
                 lines=20,interactive=False,elem_classes=["solver-log"])
 
     with gr.Row(elem_classes=["wrap-row"]):
@@ -1996,10 +2001,10 @@ with gr.Blocks(css=CSS,title="Practicality 25.4") as demo:
         q_solve_btn.click(fn=trigger_quantum_solve,inputs=[q_dropdown,api_key_input],outputs=None)
 
     gr.Markdown(
-        "Practicality 25.4 · Synthesis Engine · "
+        "Practicality 25.5 · Synthesis Engine · "
         f"{len(STRUCTURAL_HYPOTHESIS_TEMPLATES)} templates loaded",
         elem_classes=["status-bar"])
 
 if __name__=="__main__":
-    print(f"[SYSTEM 25.4] Compute: {DEVICE.type.upper()} | Quantum={HAS_QUANTUM}")
+    print(f"[SYSTEM 25.5] Compute: {DEVICE.type.upper()} | Quantum={HAS_QUANTUM}")
     demo.launch(server_name="0.0.0.0",server_port=7860,share=False)