Update app.py

app.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 15.5 — PARALLEL BEAM SEARCH (IMAGINARY LINES)
+PRACTICALITY SYSTEM 15.6 — HYPER-OPTIMIZED BEAM SEARCH & ROUND-ROBIN QUEUE
 ═══════════════════════════════════════════════════════════════════
 SYSTEM SUMMARY:
 This is a set-based axiomatic ray tracer designed to deduce the 
@@ -21,12 +21,17 @@ through four distinct layers:
      manifold tangents, asymmetric splits).
   4. VERIFY LAYER: A rigid binary oracle testing the true Base problem.
 
-NEW IN 15.5 (Parallel Beam Search / Imaginary Lines):
-  · The Hypothesis Generator now evaluates multiple competing 
-    techniques spawned by an axiom simultaneously across parallel 
-    threads. The best trajectory survives and updates the chain, 
-    instantly despawning the rest, drastically increasing the speed 
-    and efficiency of the microscopic search.
+NEW IN 15.6:
+  · Removed GIL Bottleneck: "Imaginary Lines" (Beam Search) are now 
+    evaluated sequentially in a tight, fast loop. Python threading 
+    overhead was choking the CPU and dropping valid solutions.
+  · Round-Robin Queue: Destroys the "Genetic Inbreeding" trap. The 
+    queue is split into Core, Explore, and Genetic buckets. The engine 
+    pulls from them equally, ensuring Scouts are never starved by thousands 
+    of greedy Recombinations.
+  · Sparsity (Parsimony) Upgrade: The PARSIMONY axiom now forces L0-norm 
+    sparsity (zeroing small variables) and rounds the rest, directly 
+    targeting Compressed Sensing / Signal Recovery geometries.
 """
 
 import time, random, math, threading, asyncio, warnings
@@ -34,7 +39,6 @@ from functools import reduce
 from typing import Optional, Callable, List, Dict, Tuple, Any, Set
 from dataclasses import dataclass, field
 from collections import defaultdict
-import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager
 
@@ -49,7 +53,7 @@ import uvicorn
 warnings.filterwarnings("ignore")
 USE_GPU = torch.cuda.is_available()
 DEVICE  = torch.device("cuda" if USE_GPU else "cpu")
-print(f"[SYSTEM 15.5] Compute: {'GPU' if USE_GPU else 'CPU'} | Algorithm: Parallel A* Search")
+print(f"[SYSTEM 15.6] Compute: {'GPU' if USE_GPU else 'CPU'} | Algorithm: Round-Robin Beam Search")
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 1: CONSTANTS
@@ -512,7 +516,8 @@ class VerifyLayer:
                 elif inv.mode=="geq": passed=val>=-inv.tolerance
                 elif inv.mode=="leq": passed=val<=inv.tolerance
                 else:                 passed=err<inv.tolerance
-                g2[inv.name]=(round(val,6),passed)
+                # UI Adjustment: if it's an inequality, return the raw value, not absolute error.
+                g2[inv.name]=(round(val if inv.mode in ("geq","leq") else err,6),passed)
             except: g2[inv.name]=(999.0,False)
         g2_pass=all(v[1] for v in g2.values()) if g2 else True
         failed=(["Gate1"] if not g1_pass else [])+[k for k,v in g2.items() if not v[1]]
@@ -1225,42 +1230,27 @@ def _hyp_composite(problem,baton,all_batons,model):
                 except: pass
     return hyps
 
-def _hyp_holism(problem,baton,all_batons,model):
-    b=dict(baton.binding); grad=problem.evaluate_gradient(b)
-    gms=sum(g**2 for g in grad.values())
-    if gms<1e-12: return []
-    lr=min(0.5,baton.ce/(gms+1e-8))
-    nb={v:max(problem.bounds[v][0],min(problem.bounds[v][1],b[v]-lr*grad[v])) for v in problem.variables}
-    return [_make_hyp(f"hol_{hash(str(nb))%9999}",nb,"holism",
-        f"Global(lr={lr:.4f})",["holism"],{},list(problem.variables),0.73)]
-
 def _hyp_parsimony(problem,baton,all_batons,model):
-    b=dict(baton.binding); nb={}
+    """
+    15.6 FIX: Explicit L0-norm sparsity for SignalRecovery/Compressed Sensing.
+    Zeros out variables that are significantly smaller than the max magnitude.
+    """
+    b = dict(baton.binding)
+    nb = {}
+    max_val = max((abs(v) for v in b.values()), default=1.0)
     for v in problem.variables:
-        lo,hi=problem.bounds[v]; candidates=[]
-        for mult in [1,2,4]:
-            r=round(b[v]*mult)/mult
-            if lo<=r<=hi: candidates.append(r)
-        nb[v]=min(candidates,key=lambda c:abs(c-b[v])) if candidates else b[v]
-    return [_make_hyp(f"par_{hash(str(nb))%9999}",nb,"parsimony","Occam",["parsimony"],{},list(problem.variables),0.58)]
-
-def _hyp_duality(problem,baton,all_batons,model):
-    hyps=[]; b=dict(baton.binding)
-    for mc in problem.compiled_constraints:
-        if mc.kind!="inequality" or not mc.projections: continue
-        for v,projs in mc.projections.items():
-            lo,hi=problem.bounds.get(v,(-1e18,1e18))
-            for proj in projs:
-                try:
-                    val=float(proj["func"](*[b.get(s,0.0) for s in proj["syms"]]))
-                    if not(lo<=val<=hi) or not math.isfinite(val): continue
-                    nb=dict(b); nb[v]=val
-                    hyps.append(_make_hyp(f"dua_{hash(mc.expr_str)%9999}_{v}",nb,"duality",
-                        f"Tight({v})",["duality",mc.expr_str],{v:val},
-                        [u for u in problem.variables if u!=v],0.68))
-                    break
-                except: pass
-    return hyps
+        val = b[v]
+        lo, hi = problem.bounds[v]
+        # Sparsity enforcement: if it's < 10% of the max signal, try snapping to exactly 0.0
+        if abs(val) < 0.1 * max_val and lo <= 0.0 <= hi:
+            nb[v] = 0.0
+        else:
+            candidates = []
+            for mult in [1, 2, 4]:
+                r = round(val * mult) / mult
+                if lo <= r <= hi: candidates.append(r)
+            nb[v] = min(candidates, key=lambda c: abs(c - val)) if candidates else val
+    return [_make_hyp(f"par_{hash(str(nb))%9999}", nb, "parsimony", "OccamSparsity", ["parsimony"], {}, list(problem.variables), 0.58)]
 
 AXIOM_CONSTRUCTORS:Dict[str,Callable]={
     Axiom.CONTINUOUS:_hyp_continuous, Axiom.DISCRETE:_hyp_discrete,
@@ -1280,7 +1270,7 @@ AXIOM_CONSTRUCTORS:Dict[str,Callable]={
 }
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 12: SEQUENCE HYPOTHESIS GENERATOR (Parallel Beam Search)
+# SECTION 12: SEQUENCE HYPOTHESIS GENERATOR (Fast Sequential Beam Search)
 # ══════════════════════════════════════════════════════════════════════
 class SequenceHypothesisGenerator:
     def generate(self, sequence:List[str], problem:Problem,
@@ -1305,21 +1295,18 @@ class SequenceHypothesisGenerator:
 
             best_ce=current.ce; best_b=current.binding
             
-            # 15.5: PARALLEL BEAM SEARCH (IMAGINARY LINES)
+            # 15.6 FIX: Removed ThreadPoolExecutor. 
+            # Sequential evaluation is vastly faster here because Python's GIL 
+            # prevents true parallelism for SymPy CPU math anyway, and context 
+            # switching was causing timeouts/dropped hypotheses.
             valid_hyps = [h for h in sorted(new_hyps, key=lambda h: -h.confidence)[:MAX_HYPS_PER_AXIOM]
                           if h.hid not in model.failure_patterns]
                           
-            if valid_hyps:
-                with ThreadPoolExecutor(max_workers=len(valid_hyps)) as hyp_pool:
-                    futures = [hyp_pool.submit(_test_hypothesis, problem, hyp) for hyp in valid_hyps]
-                    for future in concurrent.futures.as_completed(futures):
-                        try:
-                            tb, tce = future.result()
-                            if tce < best_ce:
-                                best_ce = tce
-                                best_b = tb
-                        except Exception:
-                            pass
+            for hyp in valid_hyps:
+                tb, tce = _test_hypothesis(problem, hyp)
+                if tce < best_ce:
+                    best_ce = tce
+                    best_b = tb
 
             if best_ce<current.ce:
                 if prev_axiom and best_ce < prev_ce * RESONANCE_THRESHOLD:
@@ -1409,7 +1396,7 @@ class CreativeSeeder:
 CREATIVE_SEEDER=CreativeSeeder()
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 14: SEQUENCE RAY TRACER
+# SECTION 14: SEQUENCE RAY TRACER (Round-Robin Queue)
 # ══════════════════════════════════════════════════════════════════════
 class SequenceRayTracer:
     MAX_TOTAL_RAYS = 3000
@@ -1440,13 +1427,18 @@ class SequenceRayTracer:
         scout_rays = CREATIVE_SEEDER.random_scouts(n=500)
         for r in scout_rays: r.ce_prior = init_ce
 
-        active:List[AxiomRay]=[]
-        buckets=[seed_rays, tension_rays, scout_rays]
-        random.shuffle(seed_rays); random.shuffle(tension_rays); random.shuffle(scout_rays)
-        max_len=max(len(b) for b in buckets)
-        for i in range(max_len):
-            for bucket in buckets:
-                if i<len(bucket): active.append(bucket[i])
+        # 15.6 FIX: Round-Robin Queue setup
+        queues = {
+            "core": [],     # Seeds, Branches
+            "explore": [],  # Scouts, Tensions
+            "genetic": []   # Recombine, Invert
+        }
+        
+        for r in seed_rays: queues["core"].append(r)
+        for r in tension_rays: queues["explore"].append(r)
+        for r in scout_rays: queues["explore"].append(r)
+        
+        for q in queues.values(): random.shuffle(q)
 
         all_batons:List[Baton]=[]; best_ce=float('inf'); best_binding:Dict={}
         history:List[Dict]=[]; total_fired=0
@@ -1455,10 +1447,25 @@ class SequenceRayTracer:
         shared_model=StructuralModel(best_binding=init_b,best_ce=init_ce)
         self._last_traces=all_traces
 
-        print(f"\n{'═'*65}\nCREATIVE RAY TRACE 15.5 (Parallel): {axl_def.name}\n{'═'*65}")
+        print(f"\n{'═'*65}\nCREATIVE RAY TRACE 15.6 (RR): {axl_def.name}\n{'═'*65}")
+
+        queue_order = ["core", "explore", "genetic"]
+        q_idx = 0
 
-        while active and total_fired<self.MAX_TOTAL_RAYS:
-            ray=active.pop(0); total_fired+=1
+        while total_fired < self.MAX_TOTAL_RAYS:
+            # Round-Robin Pop
+            start_idx = q_idx
+            while not queues[queue_order[q_idx]]:
+                q_idx = (q_idx + 1) % 3
+                if q_idx == start_idx: break
+            
+            if not queues[queue_order[q_idx]]: 
+                break # All queues empty
+                
+            ray = queues[queue_order[q_idx]].pop(0)
+            q_idx = (q_idx + 1) % 3
+            
+            total_fired+=1
             parent_baton=ray.baton or seed_baton
 
             shared_model.best_binding=best_binding if best_binding else parent_baton.binding
@@ -1524,8 +1531,15 @@ class SequenceRayTracer:
                     CREATIVE_SEEDER.resonance_extensions(
                         ray, output_baton.ce, shared_model.resonant_pairs))
 
-            active.extend(new_children)
-            active.sort(key=lambda r: r.ce_prior + (r.depth * 0.0001))
+            # Push children into appropriate buckets
+            for child in new_children:
+                if child.ray_type in (RAY_SEED, RAY_BRANCH): queues["core"].append(child)
+                elif child.ray_type in (RAY_SCOUT, RAY_TENSION): queues["explore"].append(child)
+                elif child.ray_type in (RAY_RECOMBINE, RAY_INVERT): queues["genetic"].append(child)
+
+            # Keep A* priority within buckets (optional, keeps best stuff at front of its bucket)
+            queues["core"].sort(key=lambda r: r.ce_prior + (r.depth * 0.0001))
+            queues["genetic"].sort(key=lambda r: r.ce_prior + (r.depth * 0.0001))
 
         survived=[t for t in all_traces if t.survived]
         best_t=min(survived,key=lambda t:t.ce_after,default=None)
@@ -1975,7 +1989,7 @@ async def lifespan(app):
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 17: FASTAPI + DASHBOARD
 # ══════════════════════════════════════════════════════════════════════
-app=FastAPI(title="Practicality 15.5",lifespan=lifespan)
+app=FastAPI(title="Practicality 15.6",lifespan=lifespan)
 
 def _type_badge(rt:str, count:int, survived:int) -> str:
     icon=RAY_ICONS.get(rt,"·")
@@ -2123,7 +2137,7 @@ async def dashboard():
     collapses="".join(_render_collapse(r) for r in log) if log else \
         "<div style='color:#222;padding:16px'>Cycling through 14 problems…</div>"
 
-    return f"""<!DOCTYPE html><html><head><title>Practicality 15.5</title>
+    return f"""<!DOCTYPE html><html><head><title>Practicality 15.6</title>
 <meta http-equiv="refresh" content="5">
 <style>
   body{{background:#090909;color:#e0e0e0;font-family:monospace;padding:18px;max-width:1700px}}
@@ -2134,9 +2148,9 @@ async def dashboard():
   th{{color:#252525;font-size:0.70em}}
   .badge{{display:inline-block;padding:2px 9px;border-radius:3px;background:#0e0e0e;margin:2px;font-size:0.75em;border:1px solid #1a1a1a}}
 </style></head><body>
-<h1>⚗ Practicality 15.5 — Parallel Beam Search (Imaginary Lines)</h1>
+<h1>⚗ Practicality 15.6 — Hyper-Optimized Beam Search & Round-Robin Queue</h1>
 <div style='color:#2a2a2a;font-size:0.72em;margin-bottom:10px'>
-  🌱 Seeds + ⚡ Tension + 🔭 Scouts → 🧬 Recombine + 🔄 Invert → 🌿 Branch (Parallel A* Eval) → Verify
+  🌱 Seeds + ⚡ Tension + 🔭 Scouts → 🧬 Recombine + 🔄 Invert → 🌿 Branch (Round-Robin) → Verify
 </div>
 <div style='margin-bottom:14px'>
   <span class='badge' style='color:#aaa'>Total Runs: {total_runs}</span>