Update app.py

app.py

@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 12.0 — SET-BASED AXIOMATIC RAY TRACING
+PRACTICALITY SYSTEM 12.1 — AXIOMATIC ENZYMES
 ═══════════════════════════════════════════════════════════════════
-NEW IN 12.0:
-  · True Theorist Layer: Human-named domains deleted. 
-  · Boolean Hypercube: 4,708 valid axiomatic permutations generated on boot.
-  · Strict Configuration: Axioms dictate Hypothesis weights directly (No soft constraints).
-  · Absolute Verification: Solver searches pure base problem, VerifyLayer arbitrates.
-  · Wavefront Search: Batches of rays are fired to deduce the problem signature.
+NEW IN 12.1:
+  · Nomenclature: HypothesisOracle -> HypothesisGenerator (Permutations, not judges).
+  · Axiom Efficacy: Explicit shortcodes (CNT vs CSV) for perfect UI tracking.
+  · Stacked Chains (Enzymes): Combines Branching and Topological Chains into 
+    composite hypotheses. A single algebraic guess cascades through interval 
+    arithmetic to fold the problem before numerical solving begins.
 """
 
 import time, random, math, threading, asyncio, warnings, itertools
@@ -29,7 +29,7 @@ import uvicorn
 warnings.filterwarnings("ignore")
 USE_GPU = torch.cuda.is_available()
 DEVICE  = torch.device("cuda" if USE_GPU else "cpu")
-print(f"[SYSTEM 12.0] Compute: {'GPU' if USE_GPU else 'CPU'}")
+print(f"[SYSTEM 12.1] Compute: {'GPU' if USE_GPU else 'CPU'}")
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 1: CONSTANTS
@@ -517,7 +517,6 @@ VERIFY_LAYER=VerifyLayer()
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 7: HYPERCUBE SET-BASED THEORIST
-# The fundamental engine. No names. No soft weights. Pure Logic.
 # ══════════════════════════════════════════════════════════════════════
 class Axiom:
     DISCRETE="DISCRETE"; CONTINUOUS="CONTINUOUS"; METRIC="METRIC"; NETWORK="NETWORK"
@@ -532,6 +531,15 @@ ALL_AXIOMS = [
     Axiom.TRANSITIVE, Axiom.ATOMIC, Axiom.COMPOSITE
 ]
 
+# Explicit short-codes to prevent UI collision (e.g. CNT vs CSV)
+AXIOM_ABBR = {
+    Axiom.DISCRETE: "DIS", Axiom.CONTINUOUS: "CNT", Axiom.METRIC: "MET",
+    Axiom.NETWORK: "NET", Axiom.INJECTIVE: "INJ", Axiom.SURJECTIVE: "SUR",
+    Axiom.CONSERVED: "CSV", Axiom.MUTABLE: "MUT", Axiom.QUADRATIC: "QUA",
+    Axiom.BILINEAR: "BIL", Axiom.ORDERED: "ORD", Axiom.SYMMETRIC: "SYM",
+    Axiom.TRANSITIVE: "TRA", Axiom.ATOMIC: "ATO", Axiom.COMPOSITE: "CMP"
+}
+
 AXIOM_CONTRADICTIONS=[
     {Axiom.DISCRETE,Axiom.CONTINUOUS},
     {Axiom.INJECTIVE,Axiom.SURJECTIVE},
@@ -541,7 +549,6 @@ AXIOM_CONTRADICTIONS=[
 ]
 
 def build_hypercube() -> List[Set[str]]:
-    """Generates all non-contradictory combinations of axioms up to length 6."""
     valid = []
     for r in range(1, 7):
         for combo in itertools.combinations(ALL_AXIOMS, r):
@@ -550,44 +557,32 @@ def build_hypercube() -> List[Set[str]]:
                 valid.append(cset)
     return valid
 
-# Boots instantly. Generates exactly 4,708 valid universal rays.
 AXIOM_HYPERCUBE = build_hypercube()
-print(f"[SYSTEM 12.0] Axiomatic Hypercube Booted: {len(AXIOM_HYPERCUBE)} valid rays.")
+print(f"[SYSTEM 12.1] Axiomatic Hypercube Booted: {len(AXIOM_HYPERCUBE)} valid rays.")
 
 @dataclass
 class DomainStrategy:
     name:           str
-    hyp_weights:    Dict[str,float]   # 0.0 strictly prunes hypothesis type
-    polish:         str               # "adam" | "gradient" | "both"
+    hyp_weights:    Dict[str,float]   
+    polish:         str               
     explore_early:  bool              
 
 def compile_strategy(axioms: Set[str]) -> DomainStrategy:
-    """Translates a pure axiom set into strict search constraints."""
-    name = "|".join(a[:3] for a in sorted(axioms)) if axioms else "BASE"
+    name = "|".join(AXIOM_ABBR[a] for a in sorted(axioms)) if axioms else "BASE"
     weights = {"branch": 0.0, "chain": 0.0, "coherence": 0.0, "residual_chain": 0.0, "manifold": 0.0}
     polish = "both"
     explore_early = False
 
     if Axiom.CONTINUOUS in axioms:
-        weights["manifold"] = 1.5
-        weights["branch"] = 1.0
-        weights["residual_chain"] = 1.0
-        polish = "adam"
+        weights["manifold"] = 1.5; weights["branch"] = 1.0; weights["residual_chain"] = 1.0; polish = "adam"
     if Axiom.DISCRETE in axioms:
-        weights["chain"] = 2.0
-        weights["branch"] = 1.5
-        weights["coherence"] = 1.0
-        polish = "gradient"
-        explore_early = True
-
+        weights["chain"] = 2.0; weights["branch"] = 1.5; weights["coherence"] = 1.0; polish = "gradient"; explore_early = True
     if Axiom.QUADRATIC in axioms or Axiom.METRIC in axioms:
-        weights["manifold"] += 1.0
-        weights["branch"] += 0.5
+        weights["manifold"] += 1.0; weights["branch"] += 0.5
     if Axiom.ORDERED in axioms or Axiom.NETWORK in axioms:
         weights["chain"] += 1.0
     if Axiom.MUTABLE in axioms or Axiom.BILINEAR in axioms:
-        weights["branch"] += 1.0
-        weights["residual_chain"] += 1.0
+        weights["branch"] += 1.0; weights["residual_chain"] += 1.0
 
     if sum(weights.values()) < 0.1:
         weights = {"branch": 1.0, "chain": 1.0, "coherence": 1.0, "residual_chain": 1.0, "manifold": 1.0}
@@ -682,9 +677,7 @@ class ResidualOracle:
         re=[e for e,c in sorted(de,key=lambda x:-x[1])[:5]]
         return L9Certificate(round(ce,6),rv,re)
 
-TOPOLOGY_ORACLE=TopologyOracle()
-COHERENCE_ORACLE=CoherenceOracle()
-RESIDUAL_ORACLE=ResidualOracle()
+TOPOLOGY_ORACLE=TopologyOracle(); COHERENCE_ORACLE=CoherenceOracle(); RESIDUAL_ORACLE=ResidualOracle()
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 10: CORE SOLVERS
@@ -820,13 +813,13 @@ def solve_by_hypothesis(problem:Problem, budget:int=TOTAL_BUDGET, strategy:Optio
         l9=RESIDUAL_ORACLE.evaluate(model.best_binding,problem,l7.hub_vars)
         return {"binding":model.best_binding,"ce":model.best_ce,"solved":True,"l7":l7,"l9":l9,"time":round(time.time()-t0,3)}
 
-    oracle=HypothesisOracle(strategy=strategy); consec=0
+    generator=HypothesisGenerator(strategy=strategy); consec=0
     for round_idx in range(HYPOTHESIS_MAX_ROUNDS):
         if model.best_ce<SOLVE_THRESHOLD: break
         l7=TOPOLOGY_ORACLE.evaluate(problem,active_scopes)
         l8=COHERENCE_ORACLE.evaluate(model.scope_witnesses)
         l9=RESIDUAL_ORACLE.evaluate(model.best_binding,problem,l7.hub_vars)
-        hypotheses=oracle.generate(problem,model,l7,l8,l9,round_idx)
+        hypotheses=generator.generate(problem,model,l7,l8,l9,round_idx)
         improved=False
         for hyp in hypotheses[:MAX_HYPS_PER_ROUND]:
             if model.best_ce<SOLVE_THRESHOLD: break
@@ -858,26 +851,29 @@ def solve_by_hypothesis(problem:Problem, budget:int=TOTAL_BUDGET, strategy:Optio
             "l7":final_l7,"l9":final_l9,"time":round(time.time()-t0,3)}
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 11: HYPOTHESIS ENGINE (Strict Pruning)
+# SECTION 11: HYPOTHESIS GENERATOR (Enzymes / Permutation Factory)
 # ══════════════════════════════════════════════════════════════════════
-class HypothesisOracle:
+class HypothesisGenerator:
     def __init__(self, strategy:Optional[DomainStrategy]=None):
         self.strategy=strategy
 
     def generate(self,problem,model,l7,l8,l9,round_idx):
         hyps=[]
-        # Strict pruning: If strategy assigns 0 weight, do NOT generate.
         w_br = self.strategy.hyp_weights.get("branch",1.0) if self.strategy else 1.0
         w_ch = self.strategy.hyp_weights.get("chain",1.0) if self.strategy else 1.0
         w_co = self.strategy.hyp_weights.get("coherence",1.0) if self.strategy else 1.0
         w_rc = self.strategy.hyp_weights.get("residual_chain",1.0) if self.strategy else 1.0
         w_mf = self.strategy.hyp_weights.get("manifold",1.0) if self.strategy else 1.0
+        
+        # Stacking (Enzyme): Branch + Chain composite
+        w_cmp = min(w_br, w_ch)
 
         if w_br > 0.01: hyps.extend(self._branch_hypotheses(problem,model,l9))
         if w_ch > 0.01: hyps.extend(self._chain_hypotheses(problem,model,l7))
         if w_co > 0.01: hyps.extend(self._coherence_hypotheses(problem,model,l8))
         if w_rc > 0.01: hyps.extend(self._residual_chain_hypotheses(problem,model,l9))
         if w_mf > 0.01 and round_idx>=3: hyps.extend(self._manifold_tangent_hypotheses(problem,model,l9))
+        if w_cmp > 0.01: hyps.extend(self._composite_hypotheses(problem,model,l7,l9))
 
         if self.strategy:
             for hyp in hyps:
@@ -887,6 +883,44 @@ class HypothesisOracle:
         hyps=[h for h in hyps if h.hid not in model.failure_patterns]
         return sorted(hyps,key=lambda h:-h.confidence)
 
+    def _composite_hypotheses(self,problem,model,l7,l9):
+        """Enzyme: Pins a branch value and instantly cascades a chain reaction through interval arithmetic."""
+        hyps=[]
+        if not l7.solve_order or not l9.dominant_exprs: return hyps
+        ref=model.best_binding
+        tb=_global_hc4_tighten(problem)
+        for expr_str in l9.dominant_exprs[:3]:
+            mc=next((mc for mc in problem.compiled_constraints if mc.expr_str==expr_str),None)
+            if not mc or not mc.projections: continue
+            for v,proj_list in mc.projections.items():
+                lo,hi=problem.bounds.get(v,(-1e18,1e18))
+                for pi,proj in enumerate(proj_list):
+                    try:
+                        val=float(proj["func"](*[ref.get(s,0.0) for s in proj["syms"]]))
+                        if not math.isfinite(val) or abs(val)>1e6 or not(lo<=val<=hi): continue
+                        
+                        # 1. Pin the branch
+                        start_box={u: IV(*tb.get(u, problem.bounds.get(u, (-10,10)))) for u in problem.variables}
+                        start_box[v]=IV(val-1e-6, val+1e-6)
+                        
+                        # 2. Trigger the cascade
+                        cont=_hc4(start_box, problem.compiled_constraints)
+                        if cont:
+                            b=dict(ref)
+                            for u,iv in cont.items(): b[u]=iv.mid()
+                            # Anything contracted to near-zero width is solidly pinned by the cascade
+                            pinned={u:b[u] for u in problem.variables if cont[u].width() < 1e-2}
+                            hyps.append(Hypothesis(
+                                hid=f"cmp_{hash(expr_str)%9999}_{v}_{pi}",
+                                binding=b, h_type="composite",
+                                claim=f"Enz(Br({v})→Chain)",
+                                derivation=[expr_str, "hc4_chain"],
+                                pinned_vars=pinned,
+                                free_vars=[u for u in problem.variables if u not in pinned],
+                                confidence=0.90 if pi==0 else 0.80))
+                    except: pass
+        return hyps
+
     def _branch_hypotheses(self,problem,model,l9):
         hyps=[]; ref=model.best_binding
         for expr_str in l9.dominant_exprs[:4]:
@@ -1017,7 +1051,6 @@ def _test_hypothesis(problem,hyp):
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 12: AXIOMATIC RAY TRACER (THE THEORIST)
-# Fires strict conceptual sets at the base problem. VerifyLayer arbitrates.
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class RayTraceRound:
@@ -1034,10 +1067,7 @@ class AxiomRayTracer:
         best_ray = None
         history = []
 
-        # Phase 1: The Wavefront (Sample diverse universal rays)
         rays_to_test = random.sample(AXIOM_HYPERCUBE, self.WAVEFRONT_SIZE)
-        
-        # Always test the explicitly defined axioms as a baseline ray
         if axl_def.axioms and axl_def.axioms not in rays_to_test:
             rays_to_test[0] = axl_def.axioms
 
@@ -1048,13 +1078,10 @@ class AxiomRayTracer:
             print(f"\n[Ray {round_idx+1}/{self.WAVEFRONT_SIZE}] Firing: {strategy.name}")
             
             t_start = time.time()
-            # Strict solver search using base problem + axiom strategy limits
             result = solve_by_hypothesis(base_problem, budget=TOTAL_BUDGET, strategy=strategy)
             elapsed = round((time.time()-t_start)*1000, 1)
             
             binding = result["binding"]
-            
-            # The VerifyLayer is the absolute arbiter.
             verify = VERIFY_LAYER.run(binding, base_problem, axl_def.anchors)
             base_ce = verify.gate1_ce 
             
@@ -1254,7 +1281,7 @@ async def lifespan(app):
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 15: FASTAPI + DASHBOARD
 # ══════════════════════════════════════════════════════════════════════
-app=FastAPI(title="Practicality 12.0",lifespan=lifespan)
+app=FastAPI(title="Practicality 12.1",lifespan=lifespan)
 
 def _render_collapse(record:Dict) -> str:
     b=record["binding"]; traces=record["traces"]
@@ -1328,7 +1355,6 @@ async def dashboard():
     runs=len(RUN_LOG); solved=sum(1 for r in RUN_LOG if r.get("solved",False))
     avg_ce=round(sum(r["ce"] for r in RUN_LOG)/max(1,runs),5) if RUN_LOG else 0
 
-    # Calculate efficacy by individual Axiom (very insightful)
     axiom_stats = defaultdict(lambda: {"tried": 0, "survived": 0, "total_ce": 0.0})
     for r in log:
         for t in r.get("traces", []):
@@ -1354,7 +1380,7 @@ async def dashboard():
     collapses="".join(_render_collapse(r) for r in log) if log else \
         "<div style='color:#222;padding:20px'>Warming up…</div>"
 
-    return f"""<!DOCTYPE html><html><head><title>Practicality 12.0</title>
+    return f"""<!DOCTYPE html><html><head><title>Practicality 12.1</title>
 <meta http-equiv="refresh" content="4">
 <style>
   body{{background:#090909;color:#e0e0e0;font-family:monospace;padding:20px;max-width:1400px}}
@@ -1365,9 +1391,9 @@ async def dashboard():
   th{{color:#2a2a2a;font-size:0.72em}}
   .badge{{display:inline-block;padding:3px 10px;border-radius:3px;background:#0e0e0e;margin:2px;font-size:0.78em;border:1px solid #1a1a1a}}
 </style></head><body>
-<h1>⚗ Practicality 12.0 — Axiomatic Ray Tracing</h1>
+<h1>⚗ Practicality 12.1 — Axiomatic Enzymes (Permutation Spaces)</h1>
 <div style='color:#333;font-size:0.75em;margin-bottom:12px'>
-  Boolean Hypercube → Wavefront Rays → Strict Solver Conf → Absolute Base Verify
+  Boolean Hypercube → Wavefront Rays → Generator (Enzyme Stacked Chains) → Verify Layer
 </div>
 <div style='margin-bottom:16px'>
   <span class='badge' style='color:#aaa'>Runs: {runs}</span>