Update app.py

app.py

@@ -516,7 +516,6 @@ class VerifyLayer:
                 elif inv.mode=="geq": passed=val>=-inv.tolerance
                 elif inv.mode=="leq": passed=val<=inv.tolerance
                 else:                 passed=err<inv.tolerance
-                # 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
@@ -1230,18 +1229,22 @@ 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):
-    """
-    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:
         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:
@@ -1252,6 +1255,24 @@ def _hyp_parsimony(problem,baton,all_batons,model):
             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)]
 
+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
+
 AXIOM_CONSTRUCTORS:Dict[str,Callable]={
     Axiom.CONTINUOUS:_hyp_continuous, Axiom.DISCRETE:_hyp_discrete,
     Axiom.QUADRATIC:_hyp_quadratic,   Axiom.BILINEAR:_hyp_bilinear,
@@ -1295,10 +1316,6 @@ class SequenceHypothesisGenerator:
 
             best_ce=current.ce; best_b=current.binding
             
-            # 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]
                           
@@ -1427,11 +1444,10 @@ class SequenceRayTracer:
         scout_rays = CREATIVE_SEEDER.random_scouts(n=500)
         for r in scout_rays: r.ce_prior = init_ce
 
-        # 15.6 FIX: Round-Robin Queue setup
         queues = {
-            "core": [],     # Seeds, Branches
-            "explore": [],  # Scouts, Tensions
-            "genetic": []   # Recombine, Invert
+            "core": [],     
+            "explore": [],  
+            "genetic": []   
         }
         
         for r in seed_rays: queues["core"].append(r)
@@ -1453,14 +1469,13 @@ class SequenceRayTracer:
         q_idx = 0
 
         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
+                break 
                 
             ray = queues[queue_order[q_idx]].pop(0)
             q_idx = (q_idx + 1) % 3
@@ -1531,13 +1546,11 @@ class SequenceRayTracer:
                     CREATIVE_SEEDER.resonance_extensions(
                         ray, output_baton.ce, shared_model.resonant_pairs))
 
-            # 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))
 
@@ -2182,4 +2195,4 @@ async def dashboard():
 </body></html>"""
 
 if __name__=="__main__":
-    uvicorn.run(app,host="0.0.0.0",port=7860,log_level="warning")
+    uvicorn.run(app,host="0.0.0.0",port=7860,log_level="warning")