Update app.py

app.py

@@ -1,13 +1,28 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 12.1 — AXIOMATIC ENZYMES
+PRACTICALITY SYSTEM 13.0 — SEQUENCE RAYS
 ═══════════════════════════════════════════════════════════════════
-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.
+NEW IN 13.0:
+  · 27 Axioms: expanded from 15 to include physics (EQUILIBRIUM,
+    SUPERPOSITION, LOCALITY, EXTREMAL, ENTROPY), mathematics
+    (MONOTONE, CONVEX, PARSIMONY), logic/philosophy (DUALITY,
+    HOLISM, IMPLICATION, NEGATION).
+  · Rays as Ordered Sequences: [A→B→C] ≠ [C→B→A]. Sequence order
+    is structural. Each axiom constructor is called in order with
+    the partial binding produced by all prior axioms as its context.
+  · Contradiction at Distance: contradicting axioms forbidden only
+    when ADJACENT in the sequence. Non-adjacent contradictions are
+    allowed — the chain earns its own coherence through mediating
+    axioms between them.
+  · Baton Protocol: rays do not fail, they terminate with a partial
+    binding (the baton). Child rays inherit it and continue.
+    Branching occurs from both stalling AND productive rays.
+  · Earned Extension: a ray earns the right to branch by achieving
+    a CE reduction ratio. Below MIN_DEPTH all rays branch freely.
+  · Each axiom owns its own hypothesis constructor derived from its
+    mathematical/physical meaning — not a weight scalar on shared types.
+  · Wisdom lives in the combinatorial sequence space itself.
+    No learning. No signatures. No bias.
 """
 
 import time, random, math, threading, asyncio, warnings, itertools
@@ -29,7 +44,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.1] Compute: {'GPU' if USE_GPU else 'CPU'}")
+print(f"[SYSTEM 13.0] Compute: {'GPU' if USE_GPU else 'CPU'}")
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 1: CONSTANTS
@@ -37,13 +52,11 @@ print(f"[SYSTEM 12.1] Compute: {'GPU' if USE_GPU else 'CPU'}")
 SOLVE_THRESHOLD       = 0.05
 VERIFY_G1_THRESHOLD   = 0.08
 VERIFY_G2_TOLERANCE   = 1e-3
-TOTAL_BUDGET          = 400
 HC4_VOLUME_FLOOR      = 0.20
 L9_CONTRIB_THRESHOLD  = 1e-8
 HUB_RESIDUAL_MULT     = 2.0
 HUB_DEGREE_RATIO      = 0.6
-HYPOTHESIS_MAX_ROUNDS = 20
-MAX_HYPS_PER_ROUND    = 8
+MAX_HYPS_PER_AXIOM    = 4
 BRANCH_DEPTH          = 3
 MANIFOLD_STEPS        = [0.05, 0.2, -0.05, -0.2, 0.5, -0.5]
 N_MPRT_EXPLORE        = 20000 if USE_GPU else 3000
@@ -121,7 +134,7 @@ def compile_iv(expr,variables):
     return _c(expr)
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 3: PSL 2.0 PARSER
+# SECTION 3: PSL 2.0 PARSER (unchanged from 12.1)
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class PSLVar:        name:str; lo:float; hi:float; weight:float=1.0
@@ -167,10 +180,9 @@ def parse_psl(text:str) -> PSLProgram:
                 advance()
                 scons.append(PSLConstraint("or_eq","",scope=sname,weight=1.0,branches=opts))
             elif kw=="ANNOTATE":
-                parts=rest.split();
+                parts=rest.split()
                 if len(parts)>=3: prog.annotations[parts[0]]=parts[2]
         return PSLScope(sname,order,depends or [],svars,links,scons)
-
     while i<len(lines):
         l=advance(); tk=l.split(None,1)
         kw=tk[0].upper() if tk else ""; rest=tk[1].strip() if len(tk)>1 else ""
@@ -190,7 +202,7 @@ def parse_psl(text:str) -> PSLProgram:
             advance()
             prog.constraints.append(PSLConstraint("or_eq","",weight=1.0,branches=opts))
         elif kw=="ANNOTATE":
-            parts=rest.split();
+            parts=rest.split()
             if len(parts)>=3: prog.annotations[parts[0]]=parts[2]
         elif kw=="SCOPE":
             parts=rest.split(); sname=parts[0] if parts else f"s{len(prog.scopes)}"
@@ -218,11 +230,9 @@ class ExpandedProblem:
 def expand_psl(prog:PSLProgram) -> ExpandedProblem:
     variables=[]; bounds={}; constraints=[]
     scope_groups=defaultdict(list); scope_vars=defaultdict(list)
-
     def add_var(name,lo,hi,scope="root"):
         if name not in bounds: variables.append(name); bounds[name]=(lo,hi)
         if scope!="root" and name not in scope_vars[scope]: scope_vars[scope].append(name)
-
     def add_con(kind,expr,direction,scope="root",weight=1.0,branches=None):
         idx=len(constraints)
         constraints.append(Constraint(kind,expr,direction,weight,scope,branches or []))
@@ -241,7 +251,6 @@ def expand_psl(prog:PSLProgram) -> ExpandedProblem:
                     if sp.Symbol(v) in parsed.free_symbols and scope!="root" and v not in scope_vars[scope]:
                         scope_vars[scope].append(v)
         except: pass
-
     for v in prog.vars: add_var(v.name,v.lo,v.hi)
     for c in prog.constraints:
         kind="or_eq" if c.kind=="or_eq" else "equality" if c.kind=="eq" else "inequality"
@@ -256,7 +265,7 @@ def expand_psl(prog:PSLProgram) -> ExpandedProblem:
     return ExpandedProblem(variables,bounds,constraints,dict(scope_groups),dict(scope_vars),prog.scope_order,prog.annotations)
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 4: AXL LAYER
+# SECTION 4: AXL LAYER (unchanged from 12.1)
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class AXLInvariant:
@@ -311,7 +320,7 @@ class AXLtoPSLCompiler:
 AXL_COMPILER=AXLtoPSLCompiler()
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 5: PROBLEM & CONSTRAINT COMPILATION
+# SECTION 5: PROBLEM & CONSTRAINT COMPILATION (unchanged from 12.1)
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class Constraint:
@@ -484,7 +493,7 @@ class Problem:
         return total
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 6: VERIFY LAYER
+# SECTION 6: VERIFY LAYER (unchanged from 12.1)
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class VerifyResult:
@@ -494,7 +503,7 @@ class VerifyResult:
     failed_gates:List[str]=field(default_factory=list)
 
 class VerifyLayer:
-    def run(self,binding:Dict[str,float],base_problem:Problem,anchors:List[AXLInvariant]) -> VerifyResult:
+    def run(self,binding,base_problem,anchors):
         g1_ce=base_problem.constraint_energy(binding)
         g1_pass=g1_ce<VERIFY_G1_THRESHOLD
         g2={}
@@ -509,85 +518,92 @@ class VerifyLayer:
             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]]
-        return VerifyResult(gate1_ce=round(g1_ce,6),gate1_pass=g1_pass,
-                            gate2_results=g2,gate2_pass=g2_pass,
-                            overall_pass=g1_pass and g2_pass,failed_gates=failed)
+        return VerifyResult(round(g1_ce,6),g1_pass,g2,g2_pass,g1_pass and g2_pass,failed)
 
 VERIFY_LAYER=VerifyLayer()
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 7: HYPERCUBE SET-BASED THEORIST
+# SECTION 7: EXPANDED AXIOM SPACE — 27 Axioms
+# Sources: Mathematics, Physics, Logic, Philosophy
+# Each axiom is a lens. The sequence of lenses is the ray.
 # ══════════════════════════════════════════════════════════════════════
 class Axiom:
-    DISCRETE="DISCRETE"; CONTINUOUS="CONTINUOUS"; METRIC="METRIC"; NETWORK="NETWORK"
-    INJECTIVE="INJECTIVE"; SURJECTIVE="SURJECTIVE"; CONSERVED="CONSERVED"; MUTABLE="MUTABLE"
-    QUADRATIC="QUADRATIC"; BILINEAR="BILINEAR"; ORDERED="ORDERED"; SYMMETRIC="SYMMETRIC"
-    TRANSITIVE="TRANSITIVE"; ATOMIC="ATOMIC"; COMPOSITE="COMPOSITE"
+    # ── Mathematics ──────────────────────────────────────────────────
+    CONTINUOUS  = "CONTINUOUS"   # smooth, differentiable structure
+    DISCRETE    = "DISCRETE"     # integer/graph/combinatorial structure
+    QUADRATIC   = "QUADRATIC"    # second-degree relationships
+    BILINEAR    = "BILINEAR"     # products of variable pairs
+    METRIC      = "METRIC"       # norm/distance structure
+    SYMMETRIC   = "SYMMETRIC"    # invariance under permutation
+    ORDERED     = "ORDERED"      # total/partial ordering
+    MONOTONE    = "MONOTONE"     # monotone function relationships
+    CONVEX      = "CONVEX"       # convex structure, convex relaxation
+    # ── Physics ──────────────────────────────────────────────────────
+    CONSERVED   = "CONSERVED"    # conservation law (zero divergence)
+    MUTABLE     = "MUTABLE"      # state changes, perturbation
+    NETWORK     = "NETWORK"      # graph/flow/connectivity
+    EQUILIBRIUM = "EQUILIBRIUM"  # force balance, opposing terms cancel
+    SUPERPOSITION="SUPERPOSITION"# linear combination of valid states
+    LOCALITY    = "LOCALITY"     # local-to-global propagation
+    EXTREMAL    = "EXTREMAL"     # least action / saddle point
+    ENTROPY     = "ENTROPY"      # maximum spread / disorder
+    # ── Logic ────────────────────────────────────────────────────────
+    INJECTIVE   = "INJECTIVE"    # one-to-one (distinct values)
+    SURJECTIVE  = "SURJECTIVE"   # onto (full range coverage)
+    TRANSITIVE  = "TRANSITIVE"   # chain: A→B, B→C implies A→C
+    ATOMIC      = "ATOMIC"       # solve one constraint at a time
+    IMPLICATION = "IMPLICATION"  # if-then: pin one, propagate others
+    NEGATION    = "NEGATION"     # complement / mirror exploration
+    # ── Philosophy ───────────────────────────────────────────────────
+    COMPOSITE   = "COMPOSITE"    # whole from parts (enzyme stacking)
+    HOLISM      = "HOLISM"       # global view, all constraints at once
+    PARSIMONY   = "PARSIMONY"    # simplest (Occam): integer/rational vals
+    DUALITY     = "DUALITY"      # dual: make inequalities exactly tight
 
 ALL_AXIOMS = [
-    Axiom.DISCRETE, Axiom.CONTINUOUS, Axiom.METRIC, Axiom.NETWORK,
-    Axiom.INJECTIVE, Axiom.SURJECTIVE, Axiom.CONSERVED, Axiom.MUTABLE,
-    Axiom.QUADRATIC, Axiom.BILINEAR, Axiom.ORDERED, Axiom.SYMMETRIC,
-    Axiom.TRANSITIVE, Axiom.ATOMIC, Axiom.COMPOSITE
+    Axiom.CONTINUOUS, Axiom.DISCRETE, Axiom.QUADRATIC, Axiom.BILINEAR,
+    Axiom.METRIC, Axiom.SYMMETRIC, Axiom.ORDERED, Axiom.MONOTONE, Axiom.CONVEX,
+    Axiom.CONSERVED, Axiom.MUTABLE, Axiom.NETWORK, Axiom.EQUILIBRIUM,
+    Axiom.SUPERPOSITION, Axiom.LOCALITY, Axiom.EXTREMAL, Axiom.ENTROPY,
+    Axiom.INJECTIVE, Axiom.SURJECTIVE, Axiom.TRANSITIVE, Axiom.ATOMIC,
+    Axiom.IMPLICATION, Axiom.NEGATION,
+    Axiom.COMPOSITE, Axiom.HOLISM, Axiom.PARSIMONY, Axiom.DUALITY,
 ]
 
-# 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.CONTINUOUS:"CNT", Axiom.DISCRETE:"DIS", Axiom.QUADRATIC:"QUA",
+    Axiom.BILINEAR:"BIL",   Axiom.METRIC:"MET",   Axiom.SYMMETRIC:"SYM",
+    Axiom.ORDERED:"ORD",    Axiom.MONOTONE:"MON",  Axiom.CONVEX:"CVX",
+    Axiom.CONSERVED:"CSV",  Axiom.MUTABLE:"MUT",   Axiom.NETWORK:"NET",
+    Axiom.EQUILIBRIUM:"EQL",Axiom.SUPERPOSITION:"SUP",Axiom.LOCALITY:"LOC",
+    Axiom.EXTREMAL:"EXT",   Axiom.ENTROPY:"ENT",
+    Axiom.INJECTIVE:"INJ",  Axiom.SURJECTIVE:"SUR",Axiom.TRANSITIVE:"TRA",
+    Axiom.ATOMIC:"ATO",     Axiom.IMPLICATION:"IMP",Axiom.NEGATION:"NEG",
+    Axiom.COMPOSITE:"CMP",  Axiom.HOLISM:"HOL",    Axiom.PARSIMONY:"PAR",
+    Axiom.DUALITY:"DUA",
 }
 
-AXIOM_CONTRADICTIONS=[
-    {Axiom.DISCRETE,Axiom.CONTINUOUS},
-    {Axiom.INJECTIVE,Axiom.SURJECTIVE},
-    {Axiom.ORDERED,Axiom.SYMMETRIC},
-    {Axiom.ATOMIC,Axiom.COMPOSITE},
-    {Axiom.CONSERVED,Axiom.MUTABLE}
+# Contradictions forbidden only when ADJACENT in a sequence.
+# At distance ≥ 2, both can exist — the chain earns its coherence.
+ADJACENT_CONTRADICTIONS: List[Tuple[str,str]] = [
+    (Axiom.DISCRETE,    Axiom.CONTINUOUS),
+    (Axiom.INJECTIVE,   Axiom.SURJECTIVE),
+    (Axiom.ORDERED,     Axiom.SYMMETRIC),
+    (Axiom.ATOMIC,      Axiom.COMPOSITE),
+    (Axiom.CONSERVED,   Axiom.MUTABLE),
+    (Axiom.PARSIMONY,   Axiom.ENTROPY),     # simplest vs most-spread
+    (Axiom.HOLISM,      Axiom.LOCALITY),    # global vs local-first
+    (Axiom.EXTREMAL,    Axiom.ENTROPY),     # minimize vs maximize disorder
+    (Axiom.NEGATION,    Axiom.IMPLICATION), # deny vs affirm-and-propagate
 ]
+_CONTRA_SET = {frozenset(p) for p in ADJACENT_CONTRADICTIONS}
 
-def build_hypercube() -> List[Set[str]]:
-    valid = []
-    for r in range(1, 7):
-        for combo in itertools.combinations(ALL_AXIOMS, r):
-            cset = set(combo)
-            if not any(contra.issubset(cset) for contra in AXIOM_CONTRADICTIONS):
-                valid.append(cset)
-    return valid
-
-AXIOM_HYPERCUBE = build_hypercube()
-print(f"[SYSTEM 12.1] Axiomatic Hypercube Booted: {len(AXIOM_HYPERCUBE)} valid rays.")
-
-@dataclass
-class DomainStrategy:
-    name:           str
-    hyp_weights:    Dict[str,float]   
-    polish:         str               
-    explore_early:  bool              
-
-def compile_strategy(axioms: Set[str]) -> DomainStrategy:
-    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"
-    if Axiom.DISCRETE in axioms:
-        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
-    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
-
-    if sum(weights.values()) < 0.1:
-        weights = {"branch": 1.0, "chain": 1.0, "coherence": 1.0, "residual_chain": 1.0, "manifold": 1.0}
-
-    return DomainStrategy(name=f"[{name}]", hyp_weights=weights, polish=polish, explore_early=explore_early)
+def sequence_valid(seq: List[str]) -> bool:
+    """Only adjacent pairs checked. Distance ≥ 2 contradiction = allowed."""
+    for i in range(len(seq)-1):
+        if frozenset([seq[i], seq[i+1]]) in _CONTRA_SET:
+            return False
+    return True
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 8: SHARED DATACLASSES
@@ -598,29 +614,66 @@ class Hypothesis:
     derivation:List[str]; pinned_vars:Dict[str,float]; free_vars:List[str]
     confidence:float; ce:float=float('inf')
 
+@dataclass
+class Baton:
+    """
+    The partial solution passed between rays like a relay baton.
+    A ray does not fail — it terminates and hands this to its children.
+    """
+    binding: Dict[str,float]
+    ce:      float
+    ray_id:  str  = ""
+    depth:   int  = 0
+    l7:      Optional[Any] = None   # TopologyCert — lazily computed
+    l9:      Optional[Any] = None   # ResidualCert — lazily computed
+
+@dataclass
+class AxiomRay:
+    """
+    A ray is an ordered sequence of axioms, not an unordered set.
+    [A→B→C] is structurally different from [C→B→A].
+    """
+    sequence:  List[str]
+    ray_id:    str
+    depth:     int               = 0
+    parent_id: Optional[str]     = None
+    baton:     Optional[Baton]   = None
+
+    @property
+    def name(self) -> str:
+        return "→".join(AXIOM_ABBR.get(a,a[:3]) for a in self.sequence)
+
+    def extend(self, axiom: str) -> Optional['AxiomRay']:
+        new_seq = self.sequence + [axiom]
+        if sequence_valid(new_seq):
+            return AxiomRay(
+                sequence  = new_seq,
+                ray_id    = f"{self.ray_id}+{AXIOM_ABBR.get(axiom,'?')}",
+                depth     = self.depth + 1,
+                parent_id = self.ray_id,
+                baton     = None   # caller sets baton
+            )
+        return None
+
 @dataclass
 class HypothesisTrace:
     hid:str; round_idx:int; ray_name:str; action:str
     ce_before:float; ce_after:float
     verify:Optional[VerifyResult]; survived:bool; elapsed_ms:float
+    depth:int=0; parent_id:str=""
 
 @dataclass
 class StructuralModel:
     best_binding:Dict[str,float]; best_ce:float
-    tested:List[Hypothesis]=field(default_factory=list)
     failure_patterns:Set[str]=field(default_factory=set)
     scope_witnesses:Dict[str,Dict[str,Tuple]]=field(default_factory=dict)
-    confirmed_ranges:Dict[str,Tuple[float,float]]=field(default_factory=dict)
-    conflict_vars:Set[str]=field(default_factory=set)
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 9: ORACLES
+# SECTION 9: ORACLES (unchanged from 12.1)
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class L7Certificate: topology_sig:str; hub_vars:List[str]; solve_order:List[str]
 @dataclass
-class L8Certificate: incoherent_vars:List[str]; tightened_bounds:Dict[str,Tuple[float,float]]
-@dataclass
 class L9Certificate: residual_ce:float; dominant_vars:List[str]; dominant_exprs:List[str]
 
 class TopologyOracle:
@@ -633,19 +686,6 @@ class TopologyOracle:
         so=sorted(active_scopes,key=lambda sn:sum(vd.get(v,0) for v in problem.scope_vars.get(sn,[])))
         return L7Certificate("mesh" if len(hub)>2 else "hub" if hub else "chain",hub,so)
 
-class CoherenceOracle:
-    def evaluate(self,wd):
-        inc=set(); tight={}; scopes=list(wd.keys())
-        for i in range(len(scopes)):
-            for j in range(i+1,len(scopes)):
-                ba,bb=wd[scopes[i]],wd[scopes[j]]
-                for v in set(ba)&set(bb):
-                    lo_a,hi_a=ba[v]; lo_b,hi_b=bb[v]
-                    o_lo=max(lo_a,lo_b); o_hi=min(hi_a,hi_b)
-                    if o_lo>o_hi+1e-8: inc.add(v); tight[v]=(min(lo_a,lo_b),max(hi_a,hi_b))
-                    elif o_hi>o_lo: tight[v]=(o_lo,o_hi)
-        return L8Certificate(list(inc),tight)
-
 class ResidualOracle:
     def evaluate(self,binding,problem,hub_vars):
         ce=problem.constraint_energy(binding)
@@ -677,10 +717,11 @@ 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()
+RESIDUAL_ORACLE=ResidualOracle()
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 10: CORE SOLVERS
+# SECTION 10: CORE SOLVERS (unchanged from 12.1)
 # ══════════════════════════════════════════════════════════════════════
 def _hc4(box,constraints):
     cur=dict(box)
@@ -792,239 +833,6 @@ def _adam_polish(problem,binding,steps=ADAM_STEPS):
         if nce<best_ce: best_ce=nce; best_b=dict(b)
     return best_b,best_ce
 
-def solve_by_hypothesis(problem:Problem, budget:int=TOTAL_BUDGET, strategy:Optional[DomainStrategy]=None) -> Dict:
-    t0=time.time()
-    explore_trigger = 2 if (strategy and strategy.explore_early) else 4
-    polish_pref     = strategy.polish if strategy else "both"
-
-    init_b={v:max(lo,min(hi,(lo+hi)/2)) for v,(lo,hi) in problem.bounds.items()}
-    tb=_global_hc4_tighten(problem)
-    full_box={v:IV(tb[v][0],tb[v][1]) for v in problem.variables if v in tb}
-    mprt_b,mprt_ce=_mprt_sample(problem,full_box,N_MPRT_EXPLORE//5)
-    if mprt_ce<problem.constraint_energy(init_b): init_b=mprt_b
-    snap_b,snap_ce=_algebraic_snap(problem,init_b)
-    if snap_ce<problem.constraint_energy(init_b): init_b=snap_b
-
-    model=StructuralModel(best_binding=dict(init_b),best_ce=problem.constraint_energy(init_b))
-    active_scopes=[s for s in problem.scope_order if s!="root" and problem.scope_vars.get(s)]
-
-    if model.best_ce<SOLVE_THRESHOLD:
-        l7=TOPOLOGY_ORACLE.evaluate(problem,active_scopes)
-        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)}
-
-    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=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
-            tb2,tce=_test_hypothesis(problem,hyp)
-            if tce<model.best_ce:
-                model.best_ce=tce; model.best_binding=dict(tb2); improved=True; consec=0
-                for sn in active_scopes:
-                    sv=problem.scope_vars.get(sn,[]); sb={v:tb2[v] for v in sv if v in tb2}
-                    if sb: model.scope_witnesses[sn]={v:(val-1e-3,val+1e-3) for v,val in sb.items()}
-            else: model.failure_patterns.add(hyp.hid)
-        if not improved:
-            consec+=1
-            if consec>=explore_trigger:
-                work_box={v:IV(*problem.bounds[v]) for v in problem.variables}
-                eb,ece=_mprt_sample(problem,work_box,N_MPRT_EXPLORE)
-                if ece<model.best_ce: model.best_ce=ece; model.best_binding=dict(eb); consec=0
-
-    # Strategy-directed polish
-    if polish_pref in ("gradient","both") and SOLVE_THRESHOLD<model.best_ce<2.0:
-        gb,gce=_gradient_polish(problem,model.best_binding)
-        if gce<model.best_ce: model.best_ce=gce; model.best_binding=gb
-    if polish_pref in ("adam","both") and SOLVE_THRESHOLD<model.best_ce<1.0:
-        ab,ace=_adam_polish(problem,model.best_binding)
-        if ace<model.best_ce: model.best_ce=ace; model.best_binding=ab
-
-    final_l7=TOPOLOGY_ORACLE.evaluate(problem,active_scopes)
-    final_l9=RESIDUAL_ORACLE.evaluate(model.best_binding,problem,final_l7.hub_vars)
-    return {"binding":model.best_binding,"ce":model.best_ce,"solved":model.best_ce<SOLVE_THRESHOLD,
-            "l7":final_l7,"l9":final_l9,"time":round(time.time()-t0,3)}
-
-# ══════════════════════════════════════════════════════════════════════
-# SECTION 11: HYPOTHESIS GENERATOR (Enzymes / Permutation Factory)
-# ══════════════════════════════════════════════════════════════════════
-class HypothesisGenerator:
-    def __init__(self, strategy:Optional[DomainStrategy]=None):
-        self.strategy=strategy
-
-    def generate(self,problem,model,l7,l8,l9,round_idx):
-        hyps=[]
-        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:
-                w=self.strategy.hyp_weights.get(hyp.h_type,1.0)
-                hyp.confidence=min(0.99,hyp.confidence*w)
-
-        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]:
-            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
-                        b=dict(ref); b[v]=val
-                        hyps.append(Hypothesis(hid=f"br_{hash(expr_str)%9999}_{v}_{pi}",
-                            binding=b,h_type="branch",claim=f"AlgBranch:{v}={val:.4f}",
-                            derivation=[expr_str],pinned_vars={v:val},
-                            free_vars=[u for u in problem.variables if u!=v],
-                            confidence=0.85 if pi==0 else 0.70))
-                    except: pass
-        return hyps
-
-    def _chain_hypotheses(self,problem,model,l7):
-        if not l7.solve_order: return []
-        hyps=[]; tb=_global_hc4_tighten(problem); b=dict(model.best_binding); chain_steps=[]
-        for sn in l7.solve_order:
-            svars=problem.scope_vars.get(sn,[])
-            if not svars: continue
-            scope_mcs=[problem.compiled_constraints[i] for i in problem.scope_groups.get(sn,[])]
-            if not scope_mcs: continue
-            start_box={v:IV(*tb.get(v,problem.bounds.get(v,(-10,10)))) for v in svars if v in problem.bounds}
-            cont=_hc4(start_box,scope_mcs)
-            if cont:
-                for v,iv in cont.items():
-                    b[v]=iv.mid()
-                chain_steps.append(sn)
-        if chain_steps:
-            hyps.append(Hypothesis(
-                hid=f"chain_{'_'.join(c[:4] for c in chain_steps)}",
-                binding=b,h_type="chain",claim=f"TopoChain({' → '.join(chain_steps)})",
-                derivation=chain_steps,
-                pinned_vars={v:b[v] for sn in chain_steps for v in problem.scope_vars.get(sn,[]) if v in b},
-                free_vars=[v for v in problem.variables if not any(v in problem.scope_vars.get(sn,[]) for sn in chain_steps)],
-                confidence=0.80))
-        return hyps
-
-    def _coherence_hypotheses(self,problem,model,l8):
-        if not l8.incoherent_vars: return []
-        b=dict(model.best_binding)
-        for v,(lo,hi) in l8.tightened_bounds.items():
-            if v in problem.bounds: b[v]=(lo+hi)/2.0
-        return [Hypothesis(hid=f"coh_{hash(tuple(sorted(l8.incoherent_vars)))%9999}",
-            binding=b,h_type="coherence",claim=f"CoherMeet({', '.join(list(l8.incoherent_vars)[:3])})",
-            derivation=list(l8.incoherent_vars),
-            pinned_vars={v:b[v] for v in l8.incoherent_vars if v in b},
-            free_vars=[v for v in problem.variables if v not in l8.incoherent_vars],
-            confidence=0.70)]
-
-    def _residual_chain_hypotheses(self,problem,model,l9):
-        if not l9.dominant_vars: return []
-        hyps=[]; b=dict(model.best_binding); chain=[]; depth=0
-        for tv in l9.dominant_vars[:BRANCH_DEPTH]:
-            if depth>=BRANCH_DEPTH: break
-            for mc in problem.compiled_constraints:
-                if tv not in mc.syms_used or tv not in mc.projections: continue
-                for proj in mc.projections[tv]:
-                    try:
-                        val=float(proj["func"](*[b.get(s,0.0) for s in proj["syms"]]))
-                        lo,hi=problem.bounds.get(tv,(-1e18,1e18))
-                        if not(lo<=val<=hi) or not math.isfinite(val): continue
-                        b[tv]=val; chain.append(f"{tv}={val:.3f}"); depth+=1; break
-                    except: pass
-                if depth>len(chain)-1: break
-        if chain:
-            hyps.append(Hypothesis(hid=f"rchain_{hash(str(chain))%9999}",
-                binding=b,h_type="residual_chain",claim=f"ResChain({' → '.join(chain)})",
-                derivation=l9.dominant_exprs[:len(chain)],
-                pinned_vars={v:b[v] for v in l9.dominant_vars[:len(chain)] if v in b},
-                free_vars=[v for v in problem.variables if v not in l9.dominant_vars[:len(chain)]],
-                confidence=0.65))
-        return hyps
-
-    def _manifold_tangent_hypotheses(self,problem,model,l9):
-        hyps=[]; b=model.best_binding
-        eq_mcs=[mc for mc in problem.compiled_constraints if mc.kind=="equality" and mc.fast_jac]
-        if not eq_mcs: return hyps
-        nv=len(problem.variables); J=np.zeros((len(eq_mcs),nv))
-        for i,mc in enumerate(eq_mcs):
-            for j,v in enumerate(problem.variables):
-                if v not in mc.fast_jac: continue
-                jac=mc.fast_jac[v]
-                try: J[i,j]=float(jac["func"](*[b.get(s,0.0) for s in jac["syms"]]))
-                except: pass
-        try:
-            _,sv,Vt=np.linalg.svd(J,full_matrices=True); rank=np.sum(sv>1e-8)
-            if rank>=Vt.shape[0]: return hyps
-            for di,nd in enumerate(Vt[rank:][:2]):
-                for step in MANIFOLD_STEPS:
-                    nb={v:max(problem.bounds[v][0],min(problem.bounds[v][1],b.get(v,0.0)+step*nd[j]))
-                        for j,v in enumerate(problem.variables)}
-                    hyps.append(Hypothesis(hid=f"mfld_d{di}_s{step}",binding=nb,h_type="manifold",
-                        claim=f"Manifold(dir={di},step={step:.2f})",derivation=[f"null_dir_{di}"],
-                        pinned_vars={},free_vars=problem.variables,confidence=0.45))
-        except: pass
-        return hyps
-
 def _test_hypothesis(problem,hyp):
     b=dict(hyp.binding)
     for v,(lo,hi) in problem.bounds.items():
@@ -1050,71 +858,700 @@ def _test_hypothesis(problem,hyp):
     return best_b,best_ce
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 12: AXIOMATIC RAY TRACER (THE THEORIST)
+# SECTION 11: HYPOTHESIS CONSTRUCTORS
+# One constructor per axiom. Each derives its behavior from what that
+# axiom MEANS mathematically/physically, not from a weight scalar.
+# Signature: (problem, baton, all_batons, model) -> List[Hypothesis]
 # ══════════════════════════════════════════════════════════════════════
-@dataclass
-class RayTraceRound:
-    round_idx:int; ray_axioms:Set[str]; ray_name:str
-    ce:float; solved:bool; traces:List[HypothesisTrace]=field(default_factory=list)
 
-class AxiomRayTracer:
-    WAVEFRONT_SIZE = 6
+def _proj_val(mc, v, b):
+    """Utility: attempt projection of variable v from constraint mc."""
+    if v not in mc.projections: return None
+    for proj in mc.projections[v]:
+        try:
+            val = float(proj["func"](*[b.get(s,0.0) for s in proj["syms"]]))
+            if math.isfinite(val) and abs(val) < 1e6: return val
+        except: pass
+    return None
+
+def _make_hyp(hid, binding, h_type, claim, derivation, pinned, free, conf):
+    return Hypothesis(hid=hid, binding=binding, h_type=h_type, claim=claim,
+                      derivation=derivation, pinned_vars=pinned, free_vars=free, confidence=conf)
+
+# ── Mathematics ────────────────────────────────────────────────────────
+
+def _hyp_continuous(problem, baton, all_batons, model):
+    """Null-space tangent step on the equality manifold."""
+    hyps = []; b = baton.binding
+    eq_mcs = [mc for mc in problem.compiled_constraints if mc.kind=="equality" and mc.fast_jac]
+    if not eq_mcs: return hyps
+    nv = len(problem.variables)
+    J = np.zeros((len(eq_mcs), nv))
+    for i,mc in enumerate(eq_mcs):
+        for j,v in enumerate(problem.variables):
+            if v not in mc.fast_jac: continue
+            jac = mc.fast_jac[v]
+            try: J[i,j] = float(jac["func"](*[b.get(s,0.0) for s in jac["syms"]]))
+            except: pass
+    try:
+        _,sv,Vt = np.linalg.svd(J,full_matrices=True); rank = np.sum(sv>1e-8)
+        if rank >= Vt.shape[0]: return hyps
+        for di,nd in enumerate(Vt[rank:][:2]):
+            for step in MANIFOLD_STEPS:
+                nb = {v:max(problem.bounds[v][0],min(problem.bounds[v][1],b.get(v,0.0)+step*nd[j]))
+                      for j,v in enumerate(problem.variables)}
+                hyps.append(_make_hyp(f"cnt_d{di}_s{step}",nb,"continuous",
+                    f"Manifold(dir={di},step={step:.2f})",[f"null_{di}"],{},problem.variables,0.45))
+    except: pass
+    return hyps
+
+def _hyp_discrete(problem, baton, all_batons, model):
+    """Topological chain: propagate HC4 through scope ordering."""
+    tb = _global_hc4_tighten(problem); b = dict(baton.binding); steps = []
+    l7 = baton.l7
+    if not l7 or not l7.solve_order: return []
+    for sn in l7.solve_order:
+        svars = problem.scope_vars.get(sn,[])
+        if not svars: continue
+        smcs = [problem.compiled_constraints[i] for i in problem.scope_groups.get(sn,[])]
+        if not smcs: continue
+        box = {v:IV(*tb.get(v,problem.bounds.get(v,(-10,10)))) for v in svars if v in problem.bounds}
+        cont = _hc4(box, smcs)
+        if cont:
+            for v,iv in cont.items(): b[v]=iv.mid()
+            steps.append(sn)
+    if not steps: return []
+    pinned = {v:b[v] for sn in steps for v in problem.scope_vars.get(sn,[]) if v in b}
+    return [_make_hyp(f"dis_{'_'.join(s[:4] for s in steps)}",b,"discrete",
+        f"TopoChain({' → '.join(steps)})",steps,pinned,
+        [v for v in problem.variables if v not in pinned],0.80)]
+
+def _hyp_quadratic(problem, baton, all_batons, model):
+    """Algebraic root projection on quadratic constraints."""
+    hyps = []; b = dict(baton.binding); l9 = baton.l9
+    if not l9: return hyps
+    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,projs in mc.projections.items():
+            lo,hi = problem.bounds.get(v,(-1e18,1e18))
+            for pi,proj in enumerate(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"qua_{hash(expr_str)%9999}_{v}_{pi}",nb,"quadratic",
+                        f"QuadRoot({v}={val:.4f})",[expr_str],{v:val},
+                        [u for u in problem.variables if u!=v],0.80 if pi==0 else 0.65))
+                except: pass
+    return hyps
+
+def _hyp_bilinear(problem, baton, all_batons, model):
+    """Geometric mean split for bilinear product constraints."""
+    hyps = []; b = dict(baton.binding)
+    for mc in problem.compiled_constraints:
+        if not mc.parsed: continue
+        expr = mc.parsed
+        if not expr.is_Add: continue
+        for term in expr.args:
+            if not term.is_Mul: continue
+            syms_in = [str(s) for s in term.free_symbols if str(s) in problem.variables]
+            if len(syms_in) != 2: continue
+            vi,vj = syms_in
+            lo_i,hi_i = problem.bounds.get(vi,(0,10))
+            lo_j,hi_j = problem.bounds.get(vj,(0,10))
+            product = abs(b.get(vi,1)*b.get(vj,1))
+            gm = math.sqrt(product) if product >= 0 else 0
+            if lo_i<=gm<=hi_i and lo_j<=gm<=hi_j:
+                nb = dict(b); nb[vi]=gm; nb[vj]=gm
+                hyps.append(_make_hyp(f"bil_{vi}_{vj}",nb,"bilinear",
+                    f"GeoMean({vi}={vj}={gm:.4f})",["bilinear"],{vi:gm,vj:gm},
+                    [v for v in problem.variables if v not in [vi,vj]],0.70))
+    return hyps
+
+def _hyp_metric(problem, baton, all_batons, model):
+    """Radial projection onto norm sphere constraints."""
+    hyps = []; b = dict(baton.binding)
+    for mc in problem.compiled_constraints:
+        if mc.kind!="equality" or not mc.parsed: continue
+        expr = mc.parsed
+        if not expr.is_Add: continue
+        sq_terms = [t for t in expr.args if t.is_Pow and t.args[1]==2]
+        if len(sq_terms) < 2: continue
+        vars_in = [str(s) for s in expr.free_symbols if str(s) in problem.variables]
+        curr_val = sum(b.get(v,0)**2 for v in vars_in)
+        if curr_val < 1e-8: continue
+        const_terms = [t for t in expr.args if t.is_Number]
+        if not const_terms: continue
+        target = -float(const_terms[0])
+        if target <= 0: continue
+        scale = math.sqrt(target/curr_val)
+        nb = dict(b)
+        for v in vars_in:
+            lo,hi = problem.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})",["metric",mc.expr_str],{},list(problem.variables),0.75))
+    return hyps
+
+def _hyp_symmetric(problem, baton, all_batons, model):
+    """Pairwise variable swaps — symmetry group exploration."""
+    hyps = []; b = dict(baton.binding); vl = problem.variables
+    for i in range(min(len(vl),5)):
+        for j in range(i+1,min(len(vl),5)):
+            vi,vj = vl[i],vl[j]
+            lo_i,hi_i = problem.bounds[vi]; lo_j,hi_j = problem.bounds[vj]
+            if lo_i<=b.get(vj,0)<=hi_i and lo_j<=b.get(vi,0)<=hi_j:
+                nb = dict(b); nb[vi],nb[vj] = b.get(vj,0),b.get(vi,0)
+                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 vl if v not in [vi,vj]],0.60))
+    return hyps
+
+def _hyp_ordered(problem, baton, all_batons, model):
+    """Enforce variable ordering by midpoint balancing."""
+    b = dict(baton.binding); nb = dict(b)
+    ord_mcs = [mc for mc in problem.compiled_constraints
+               if mc.kind=="inequality" and len(mc.syms_used)==2]
+    for mc in ord_mcs:
+        vi,vj = mc.syms_used
+        lo_i,hi_i = problem.bounds.get(vi,(-1e18,1e18))
+        lo_j,hi_j = problem.bounds.get(vj,(-1e18,1e18))
+        if mc.direction=="geq" and nb.get(vi,0)<nb.get(vj,0):
+            mid = (nb[vi]+nb[vj])/2
+            nb[vi]=max(lo_i,mid); nb[vj]=min(hi_j,mid)
+    return [_make_hyp(f"ord_{hash(str(nb))%9999}",nb,"ordered","OrderBalance",
+        ["ordered"],{},list(problem.variables),0.67)]
+
+def _hyp_monotone(problem, baton, all_batons, model):
+    """Step variables in order of gradient magnitude — monotone path."""
+    b = dict(baton.binding); grad = problem.evaluate_gradient(b)
+    ordered = sorted(problem.variables,key=lambda v:-abs(grad.get(v,0)))
+    nb = dict(b)
+    for v in ordered:
+        lo,hi = problem.bounds[v]; g = grad.get(v,0)
+        if abs(g)>1e-10: nb[v]=max(lo,min(hi,nb[v]-0.05*g))
+    return [_make_hyp(f"mon_{hash(str(nb))%9999}",nb,"monotone","MonotonePath",
+        ["monotone"],{},list(problem.variables),0.67)]
+
+def _hyp_convex(problem, baton, all_batons, model):
+    """Convex combination of current binding and constraint projection."""
+    hyps = []; b = dict(baton.binding)
+    for mc in problem.compiled_constraints:
+        if mc.kind!="equality" 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] = 0.5*b[v]+0.5*val
+                    hyps.append(_make_hyp(f"cvx_{hash(mc.expr_str)%9999}_{v}",nb,"convex",
+                        f"ConvexMix({v}→{val:.3f})",["convex",mc.expr_str],{v:nb[v]},
+                        [u for u in problem.variables if u!=v],0.63))
+                except: pass
+    return hyps
+
+# ── Physics ────────────────────────────────────────────────────────────
+
+def _hyp_conserved(problem, baton, all_batons, model):
+    """Enforce conservation laws directly via projection."""
+    hyps = []; b = dict(baton.binding)
+    cons_mcs = [mc for mc in problem.compiled_constraints if mc.kind=="equality" and mc.weight>=5.0]
+    for mc in cons_mcs:
+        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"csv_{hash(mc.expr_str)%9999}_{v}",nb,"conserved",
+                        f"Conserve({v}={val:.4f})",[mc.expr_str],{v:val},
+                        [u for u in problem.variables if u!=v],0.82))
+                except: pass
+    return hyps
+
+def _hyp_mutable(problem, baton, all_batons, model):
+    """Gaussian perturbation of dominant residual variables."""
+    hyps = []; l9 = baton.l9; b = dict(baton.binding)
+    if not l9 or not l9.dominant_vars: return hyps
+    for v in l9.dominant_vars[:3]:
+        lo,hi = problem.bounds.get(v,(-10,10))
+        for _ in range(3):
+            noise = random.gauss(0,(hi-lo)*0.05)
+            val = max(lo,min(hi,b[v]+noise))
+            nb = dict(b); nb[v]=val
+            hyps.append(_make_hyp(f"mut_{v}_{random.randint(0,9999)}",nb,"mutable",
+                f"Perturb({v}±{noise:.4f})",["mutable",v],{},list(problem.variables),0.40))
+    return hyps
+
+def _hyp_network(problem, baton, all_batons, model):
+    """Hub-and-spoke: propagate from most-connected variable."""
+    vd = defaultdict(int)
+    for mc in problem.compiled_constraints:
+        for v in mc.syms_used: vd[v]+=1
+    if not vd: return []
+    hub = max(vd,key=vd.get); b = dict(baton.binding)
+    for mc in problem.compiled_constraints:
+        if hub not in mc.syms_used or hub not in mc.projections: continue
+        val = _proj_val(mc,hub,b)
+        if val is None: continue
+        lo,hi = problem.bounds.get(hub,(-1e18,1e18))
+        if lo<=val<=hi: b[hub]=val; break
+    return [_make_hyp(f"net_{hub}_{hash(str(b))%9999}",b,"network",
+        f"HubProp({hub},deg={vd[hub]})",["network",hub],{hub:b[hub]},
+        [v for v in problem.variables if v!=hub],0.65)]
+
+def _hyp_equilibrium(problem, baton, all_batons, model):
+    """Find gradient balance point — opposing forces cancel."""
+    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.15, 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"eql_{hash(str(nb))%9999}",nb,"equilibrium",
+        f"GradBalance(lr={lr:.4f})",["equilibrium"],{},list(problem.variables),0.72)]
+
+def _hyp_superposition(problem, baton, all_batons, model):
+    """Linear combinations of inherited batons from parent rays."""
+    hyps = []; recent = [bt for bt in all_batons[-8:] if bt.ce < float('inf') and bt.binding]
+    if not recent: return hyps
+    for lam in [0.25, 0.5, 0.75]:
+        other = random.choice(recent)
+        nb = {}
+        for v in problem.variables:
+            lo,hi = problem.bounds[v]
+            val = lam*baton.binding.get(v,0)+(1-lam)*other.binding.get(v,0)
+            nb[v] = max(lo,min(hi,val))
+        hyps.append(_make_hyp(f"sup_{int(lam*10)}_{random.randint(0,999)}",nb,"superposition",
+            f"Superpose(λ={lam:.2f},ray={other.ray_id})",["superposition",other.ray_id],
+            {},list(problem.variables),0.58))
+    return hyps
+
+def _hyp_locality(problem, baton, all_batons, model):
+    """Solve densest-constraint variable first, propagate outward."""
+    vd = defaultdict(float)
+    for mc in problem.compiled_constraints:
+        for v in mc.syms_used: vd[v]+=mc.weight
+    ordered = sorted(problem.variables,key=lambda v:-vd[v])
+    b = dict(baton.binding)
+    for v in ordered[:4]:
+        for mc in problem.compiled_constraints:
+            if v not in mc.syms_used or v not in mc.projections: continue
+            val = _proj_val(mc,v,b)
+            if val is None: continue
+            lo,hi = problem.bounds.get(v,(-1e18,1e18))
+            if lo<=val<=hi: b[v]=val; break
+    return [_make_hyp(f"loc_{hash(str(b))%9999}",b,"locality",
+        f"LocalFirst({ordered[0] if ordered else '?'})",["locality"],
+        {v:b[v] for v in ordered[:4] if v in b},ordered[4:],0.72)]
+
+def _hyp_extremal(problem, baton, all_batons, model):
+    """Extremal principle: test boundary values of dominant variables."""
+    hyps = []; l9 = baton.l9; b = dict(baton.binding)
+    if not l9 or not l9.dominant_vars: return hyps
+    for v in l9.dominant_vars[:3]:
+        lo,hi = problem.bounds.get(v,(0,1))
+        for val in [lo,hi,(lo+hi)/2]:
+            nb = dict(b); nb[v]=val
+            hyps.append(_make_hyp(f"ext_{v}_{val:.4f}",nb,"extremal",
+                f"Extremal({v}={val:.4f})",["extremal"],{v:val},
+                [u for u in problem.variables if u!=v],0.65))
+    return hyps
+
+def _hyp_entropy(problem, baton, all_batons, model):
+    """Maximum disorder: spread variables across their bounds."""
+    nb_mid  = {v:(lo+hi)/2 for v,(lo,hi) in problem.bounds.items()}
+    nb_rand = {v:random.uniform(lo,hi) for v,(lo,hi) in problem.bounds.items()}
+    return [
+        _make_hyp("ent_mid",nb_mid,"entropy","MaxEntropy(mid)",["entropy"],{},list(problem.variables),0.48),
+        _make_hyp(f"ent_rnd_{random.randint(0,999)}",nb_rand,"entropy","MaxEntropy(random)",["entropy"],{},list(problem.variables),0.42),
+    ]
+
+# ── Logic ──────────────────────────────────────────────────────────────
+
+def _hyp_injective(problem, baton, all_batons, model):
+    """Ensure distinct values — nudge duplicates apart."""
+    b = dict(baton.binding); nb = dict(b); seen = {}
+    for v in problem.variables:
+        val = nb[v]
+        rval = round(val,4)
+        if rval in seen:
+            lo,hi = problem.bounds[v]
+            nb[v] = max(lo,min(hi,val+(hi-lo)*0.01*(len(seen)+1)))
+        seen[rval]=v
+    return [_make_hyp(f"inj_{hash(str(nb))%9999}",nb,"injective","EnsureDistinct",
+        ["injective"],{},list(problem.variables),0.50)]
+
+def _hyp_surjective(problem, baton, all_batons, model):
+    """Range sweep: test fractional positions along each variable's span."""
+    hyps = []
+    for v in problem.variables[:5]:
+        lo,hi = problem.bounds[v]
+        for frac in [0.1,0.9]:
+            nb = dict(baton.binding); nb[v]=lo+frac*(hi-lo)
+            hyps.append(_make_hyp(f"sur_{v}_{int(frac*100)}",nb,"surjective",
+                f"RangeSweep({v}@{frac:.0%})",["surjective"],{v:nb[v]},
+                [u for u in problem.variables if u!=v],0.45))
+    return hyps
+
+def _hyp_transitive(problem, baton, all_batons, model):
+    """Transitively snap projections until convergence."""
+    b = dict(baton.binding); nb = dict(b); changed=True; iters=0
+    while changed and iters<6:
+        changed=False; iters+=1
+        for mc in problem.compiled_constraints:
+            if mc.kind!="equality" or not mc.projections: continue
+            for v,projs in mc.projections.items():
+                val = _proj_val(mc,v,nb)
+                if val is None: continue
+                lo,hi = problem.bounds.get(v,(-1e18,1e18))
+                if lo<=val<=hi and abs(val-nb.get(v,0))>1e-6:
+                    nb[v]=val; changed=True
+    if nb==b: return []
+    pinned = {v:nb[v] for v in nb if abs(nb[v]-b.get(v,0))>1e-4}
+    return [_make_hyp(f"tra_{hash(str(nb))%9999}",nb,"transitive",
+        f"TransitiveSnap({iters}iters)",["transitive"],pinned,
+        [v for v in problem.variables if v not in pinned],0.77)]
+
+def _hyp_atomic(problem, baton, all_batons, model):
+    """Solve a single most-violated constraint; ignore the rest."""
+    b = dict(baton.binding); worst_mc=None; worst_val=0.0
+    for mc in problem.compiled_constraints:
+        if mc.fast_pt is None: continue
+        try:
+            val = abs(float(mc.fast_pt(*[b.get(v,0.0) for v in mc.syms_used])))
+            if val>worst_val: worst_val=val; worst_mc=mc
+        except: pass
+    if not worst_mc or not worst_mc.projections: return []
+    hyps = []
+    for v,projs in worst_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"ato_{hash(worst_mc.expr_str)%9999}_{v}",nb,"atomic",
+                    f"SolveOne({worst_mc.expr_str[:20]}→{v}={val:.4f})",[worst_mc.expr_str],
+                    {v:val},[u for u in problem.variables if u!=v],0.70))
+            except: pass
+    return hyps
+
+def _hyp_implication(problem, baton, all_batons, model):
+    """Pin a dominant variable, propagate implications through HC4."""
+    hyps = []; l9 = baton.l9; b = dict(baton.binding)
+    if not l9 or not l9.dominant_vars: return hyps
+    tb = _global_hc4_tighten(problem)
+    for v in l9.dominant_vars[:2]:
+        val = b.get(v,(problem.bounds[v][0]+problem.bounds[v][1])/2)
+        box = {u:IV(*tb.get(u,problem.bounds.get(u,(-10,10)))) for u in problem.variables}
+        box[v] = IV(val-1e-4,val+1e-4)
+        contracted = _hc4(box,problem.compiled_constraints)
+        if not contracted: continue
+        nb = {u:contracted[u].mid() for u in problem.variables}
+        pinned = {u:nb[u] for u in problem.variables if contracted[u].width()<1e-2}
+        hyps.append(_make_hyp(f"imp_{v}_{hash(str(nb))%9999}",nb,"implication",
+            f"Imply({v}={val:.3f}→HC4)",["implication",v],pinned,
+            [u for u in problem.variables if u not in pinned],0.78))
+    return hyps
+
+def _hyp_negation(problem, baton, all_batons, model):
+    """Mirror current binding through the centre of variable bounds."""
+    nb = {}
+    for v in problem.variables:
+        lo,hi = problem.bounds[v]; mid=(lo+hi)/2
+        nb[v] = max(lo,min(hi,2*mid-baton.binding.get(v,mid)))
+    return [_make_hyp(f"neg_{hash(str(nb))%9999}",nb,"negation","MirrorBounds",
+        ["negation"],{},list(problem.variables),0.42)]
+
+# ── Philosophy ─────────────────────────────────────────────────────────
+
+def _hyp_composite(problem, baton, all_batons, model):
+    """Enzyme: pin branch value, cascade HC4 (Practicality 12.1 enzyme)."""
+    hyps = []; l9 = baton.l9
+    if not l9: return hyps
+    ref = baton.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
+                    box = {u:IV(*tb.get(u,problem.bounds.get(u,(-10,10)))) for u in problem.variables}
+                    box[v] = IV(val-1e-6,val+1e-6)
+                    cont = _hc4(box,problem.compiled_constraints)
+                    if not cont: continue
+                    b = dict(ref)
+                    for u,iv in cont.items(): b[u]=iv.mid()
+                    pinned = {u:b[u] for u in problem.variables if cont[u].width()<1e-2}
+                    hyps.append(_make_hyp(f"cmp_{hash(expr_str)%9999}_{v}_{pi}",b,"composite",
+                        f"Enz(Br({v})→Chain)",[expr_str,"hc4_chain"],pinned,
+                        [u for u in problem.variables if u not in pinned],0.90 if pi==0 else 0.80))
+                except: pass
+    return hyps
+
+def _hyp_holism(problem, baton, all_batons, model):
+    """Single global gradient step treating all constraints simultaneously."""
+    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"GlobalStep(lr={lr:.4f})",["holism"],{},list(problem.variables),0.73)]
+
+def _hyp_parsimony(problem, baton, all_batons, model):
+    """Occam: simplest (integer / half-integer) values."""
+    b = dict(baton.binding); nb = {}
+    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(round)",
+        ["parsimony"],{},list(problem.variables),0.58)]
+
+def _hyp_duality(problem, baton, all_batons, model):
+    """Dual: make each inequality constraint exactly tight."""
+    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"DualTight({v}∈{mc.expr_str[:18]})",["duality",mc.expr_str],{v:val},
+                        [u for u in problem.variables if u!=v],0.68))
+                    break
+                except: pass
+    return hyps
+
+# Registry: axiom string → constructor function
+AXIOM_CONSTRUCTORS: Dict[str, Callable] = {
+    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.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,
+}
+
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 12: SEQUENCE HYPOTHESIS GENERATOR
+# Processes the axiom sequence of a ray in order.
+# Each axiom adds hypotheses; the best result updates the baton for
+# the next axiom in the sequence. The chain earns its own direction.
+# ══════════════════════════════════════════════════════════════════════
+class SequenceHypothesisGenerator:
+    def generate(self, sequence: List[str], problem: Problem,
+                 baton: Baton, all_batons: List[Baton],
+                 model: StructuralModel) -> Tuple[List[Hypothesis], Baton]:
+        accumulated: List[Hypothesis] = []
+        current = baton
+
+        for i, axiom in enumerate(sequence):
+            constructor = AXIOM_CONSTRUCTORS.get(axiom)
+            if not constructor:
+                continue
+
+            # Lazily enrich baton with oracle context
+            if current.l7 is None:
+                active = [s for s in problem.scope_order if s!="root" and problem.scope_vars.get(s)]
+                current.l7 = TOPOLOGY_ORACLE.evaluate(problem, active)
+            if current.l9 is None:
+                hubs = current.l7.hub_vars if current.l7 else []
+                current.l9 = RESIDUAL_ORACLE.evaluate(current.binding, problem, hubs)
+
+            new_hyps = constructor(problem, current, all_batons, model)
+            accumulated.extend(new_hyps)
+
+            # Test top hypotheses; best result becomes context for next axiom
+            best_ce = current.ce
+            best_b  = current.binding
+            for hyp in sorted(new_hyps, key=lambda h: -h.confidence)[:MAX_HYPS_PER_AXIOM]:
+                if hyp.hid in model.failure_patterns: continue
+                tb, tce = _test_hypothesis(problem, hyp)
+                if tce < best_ce:
+                    best_ce = tce; best_b = tb
+
+            if best_ce < current.ce:
+                current = Baton(binding=best_b, ce=best_ce,
+                                ray_id=current.ray_id, depth=i+1,
+                                l7=None, l9=None)  # recomputed next iteration
+
+        return accumulated, current
 
-    def trace(self, axl_def: AXLProblemDef, base_problem: Problem) -> Tuple[Dict, float, List[RayTraceRound]]:
-        self.all_traces = []
+# ══════════════════════════════════════════════════════════════════════
+# SECTION 13: SEQUENCE RAY TRACER
+# Manages a tree of AxiomRays.  Rays terminate with a Baton.
+# Children inherit the Baton and extend the sequence.
+# Branching from both stalling and productive rays.
+# Earned Extension: must reduce CE by CE_EARN_RATIO to branch,
+#   except when depth < MIN_DEPTH where branching is always allowed.
+# ══════════════════════════════════════════════════════════════════════
+class SequenceRayTracer:
+    MAX_TOTAL_RAYS  = 80
+    BRANCH_WIDTH    = 4
+    MIN_DEPTH       = 1
+    CE_EARN_RATIO   = 0.90   # 10% CE reduction earns a branch
+
+    def trace(self, axl_def: AXLProblemDef, base_problem: Problem):
+        self.all_traces: List[HypothesisTrace] = []
+        generator = SequenceHypothesisGenerator()
+
+        # Seed: one length-1 ray per axiom, shuffled (no ordering bias)
+        active: List[AxiomRay] = [
+            AxiomRay(sequence=[a], ray_id=f"S{i}", depth=0)
+            for i,a in enumerate(ALL_AXIOMS)
+        ]
+        random.shuffle(active)
+
+        all_batons: List[Baton] = []
         best_ce = float('inf')
-        best_binding = {}
-        best_ray = None
-        history = []
-
-        rays_to_test = random.sample(AXIOM_HYPERCUBE, self.WAVEFRONT_SIZE)
-        if axl_def.axioms and axl_def.axioms not in rays_to_test:
-            rays_to_test[0] = axl_def.axioms
-
-        print(f"\n{'═'*65}\nTHEORIST RAY TRACE: {axl_def.name}\n{'═'*65}")
-
-        for round_idx, ray_axioms in enumerate(rays_to_test):
-            strategy = compile_strategy(ray_axioms)
-            print(f"\n[Ray {round_idx+1}/{self.WAVEFRONT_SIZE}] Firing: {strategy.name}")
-            
-            t_start = time.time()
-            result = solve_by_hypothesis(base_problem, budget=TOTAL_BUDGET, strategy=strategy)
-            elapsed = round((time.time()-t_start)*1000, 1)
-            
-            binding = result["binding"]
-            verify = VERIFY_LAYER.run(binding, base_problem, axl_def.anchors)
-            base_ce = verify.gate1_ce 
-            
-            trace = HypothesisTrace(
-                hid=f"R{round_idx+1}", round_idx=round_idx+1,
-                ray_name=strategy.name, action="Wavefront",
-                ce_before=best_ce if best_ce < float('inf') else 99.0,
-                ce_after=base_ce, verify=verify,
-                survived=verify.overall_pass, elapsed_ms=elapsed
-            )
-            self.all_traces.append(trace)
+        best_binding: Dict = {}
+        history: List[Dict] = []
+        total_fired = 0
 
-            status = "✓ SURVIVED" if verify.overall_pass else "✗ FAILED"
-            print(f"       BaseCE={base_ce:.5f} | G1={'✓' if verify.gate1_pass else '✗'} "
-                  f"G2={'✓' if verify.gate2_pass else '✗'} | {status}")
-            for inv_name, (err, passed) in verify.gate2_results.items():
-                print(f"         [{'✓' if passed else '✗'}] {inv_name}: |err|={err:.6f}")
+        init_b  = {v:(lo+hi)/2 for v,(lo,hi) in base_problem.bounds.items()}
+        init_ce = base_problem.constraint_energy(init_b)
 
-            if base_ce < best_ce:
-                best_ce = base_ce
-                best_binding = dict(binding)
-                best_ray = strategy.name
+        # Try algebraic snap + MPRT on initial binding
+        snap_b, snap_ce = _algebraic_snap(base_problem, init_b)
+        if snap_ce < init_ce: init_b = snap_b; init_ce = snap_ce
+        mprt_b, mprt_ce = _mprt_sample(base_problem,
+            {v:IV(*base_problem.bounds[v]) for v in base_problem.variables},
+            N_MPRT_EXPLORE//5)
+        if mprt_ce < init_ce: init_b = mprt_b; init_ce = mprt_ce
 
-            history.append(RayTraceRound(round_idx, ray_axioms, strategy.name, base_ce, verify.overall_pass, [trace]))
+        seed_baton = Baton(binding=init_b, ce=init_ce, ray_id="SEED")
 
-            if verify.overall_pass:
-                print(f"\n✓ TRUE UNIVERSE FOUND in Ray {round_idx+1}"); break
+        print(f"\n{'═'*65}\nSEQUENCE RAY TRACE: {axl_def.name}\n{'═'*65}")
+
+        while active and total_fired < self.MAX_TOTAL_RAYS:
+            ray = active.pop(0)
+            total_fired += 1
 
-        print(f"\n{'─'*65}\nRESULT: BaseCE={best_ce:.5f} | Best Ray={best_ray}")
+            parent_baton = ray.baton or seed_baton
+            model = StructuralModel(
+                best_binding = best_binding if best_binding else parent_baton.binding,
+                best_ce      = best_ce if best_ce < float('inf') else init_ce
+            )
+
+            t0 = time.time()
+            hyps, output_baton = generator.generate(
+                ray.sequence, base_problem, parent_baton, all_batons, model)
+            elapsed = round((time.time()-t0)*1000, 1)
+
+            output_baton.ray_id = ray.ray_id
+            all_batons.append(output_baton)
+
+            if output_baton.ce < best_ce:
+                best_ce = output_baton.ce
+                best_binding = dict(output_baton.binding)
+
+            verify = VERIFY_LAYER.run(output_baton.binding, base_problem, axl_def.anchors)
+            trace  = HypothesisTrace(
+                hid       = ray.ray_id,
+                round_idx = total_fired,
+                ray_name  = ray.name,
+                action    = "SequenceRay",
+                ce_before = parent_baton.ce if parent_baton.ce < float('inf') else 99.0,
+                ce_after  = output_baton.ce,
+                verify    = verify,
+                survived  = verify.overall_pass,
+                elapsed_ms= elapsed,
+                depth     = ray.depth,
+                parent_id = ray.parent_id or "",
+            )
+            self.all_traces.append(trace)
+
+            status = "✓ SURVIVED" if verify.overall_pass else ""
+            print(f"  [{total_fired:3d}] {ray.name:<40} "
+                  f"CE {parent_baton.ce:.4f}→{output_baton.ce:.4f} "
+                  f"G1={'✓' if verify.gate1_pass else '✗'} "
+                  f"G2={'✓' if verify.gate2_pass else '✗'} "
+                  f"{status}")
+
+            history.append({
+                "ray_id":   ray.ray_id,
+                "sequence": ray.name,
+                "depth":    ray.depth,
+                "parent":   ray.parent_id,
+                "ce_in":    round(parent_baton.ce,5) if parent_baton.ce < float('inf') else 99.0,
+                "ce_out":   round(output_baton.ce,5),
+                "survived": verify.overall_pass,
+                "ms":       elapsed,
+            })
+
+            if verify.overall_pass:
+                print(f"\n✓ TRUE UNIVERSE FOUND: {ray.name}")
+                break
+
+            # Branching decision
+            parent_ce = parent_baton.ce if parent_baton.ce < float('inf') else init_ce
+            earned    = (output_baton.ce < parent_ce * self.CE_EARN_RATIO
+                         or ray.depth < self.MIN_DEPTH)
+            if earned:
+                children = self._spawn_children(ray, output_baton)
+                # Depth-first: children at front
+                active = children + active
+
+        survived = [t for t in self.all_traces if t.survived]
+        failed   = [t for t in self.all_traces if not t.survived]
+        best_t   = min(survived, key=lambda t: t.ce_after, default=None)
+        print(f"\n{'─'*65}")
+        print(f"RESULT: CE={best_ce:.5f} | Fired={total_fired} | "
+              f"Survived={len(survived)} | Best={best_t.ray_name if best_t else '—'}")
         return best_binding, best_ce, history
 
+    def _spawn_children(self, ray: AxiomRay, baton: Baton) -> List[AxiomRay]:
+        remaining = [a for a in ALL_AXIOMS if a not in ray.sequence]
+        random.shuffle(remaining)   # no ordering bias in child selection
+        children: List[AxiomRay] = []
+        for axiom in remaining:
+            child = ray.extend(axiom)
+            if child:
+                child.baton = baton
+                children.append(child)
+                if len(children) >= self.BRANCH_WIDTH * 2:
+                    break
+        return children
+
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 13: HARDCODED AXL PROBLEMS
+# SECTION 14: HARDCODED AXL PROBLEMS (unchanged from 12.1)
 # ══════════════════════════════════════════════════════════════════════
 AXL_PROBLEMS=[
     AXLProblemDef(
@@ -1127,7 +1564,7 @@ AXL_PROBLEMS=[
         ],
         constraints=[
             {"kind":"CONSERVE","expr":"x1**2 + x2**2 + x3**2 + x4**2 - 1.0"},
-            {"kind":"EQ",      "expr":"x1 + x2 + x3 + x4","weight":2.0},
+            {"kind":"EQ","expr":"x1 + x2 + x3 + x4","weight":2.0},
         ],
         scopes=[{"name":"sphere","order":0,"vars":["x1","x2","x3","x4"],
                  "constraints":[{"kind":"EQ","expr":"x1**2 + x2**2 + x3**2 + x4**2 - 1.0","weight":5.0}]}],
@@ -1192,7 +1629,8 @@ AXL_PROBLEMS=[
         description="3 vars packed with min separation, centred, norm=6",
         axioms={Axiom.CONTINUOUS,Axiom.METRIC,Axiom.INJECTIVE,Axiom.CONSERVED,Axiom.SYMMETRIC},
         variables=[
-            {"name":"a","lo":-3.0,"hi":3.0}, {"name":"b","lo":-3.0,"hi":3.0}, {"name":"c","lo":-3.0,"hi":3.0},
+            {"name":"a","lo":-3.0,"hi":3.0}, {"name":"b","lo":-3.0,"hi":3.0},
+            {"name":"c","lo":-3.0,"hi":3.0},
         ],
         constraints=[
             {"kind":"CONSERVE","expr":"a + b + c"},
@@ -1201,9 +1639,7 @@ AXL_PROBLEMS=[
             {"kind":"GEQ","expr":"(a - c)**2 - 4.0","weight":2.0},
         ],
         scopes=[{"name":"packing","order":0,"vars":["a","b","c"],
-                 "constraints":[
-                    {"kind":"EQ","expr":"a**2 + b**2 + c**2 - 6.0","weight":2.0},
-                 ]}],
+                 "constraints":[{"kind":"EQ","expr":"a**2 + b**2 + c**2 - 6.0","weight":2.0}]}],
         anchors=[
             AXLInvariant("centred","a + b + c",1e-3),
             AXLInvariant("sep_ab","(a - b)**2 - 1.0",0.5),
@@ -1213,50 +1649,57 @@ AXL_PROBLEMS=[
     ),
 ]
 
-def build_base_problem(axl_def:AXLProblemDef) -> Problem:
-    psl_text=AXL_COMPILER.compile(axl_def)
-    prog=parse_psl(psl_text); ep=expand_psl(prog)
-    return Problem(pid=f"base_{axl_def.name}",variables=ep.variables,
-                   constraints=ep.constraints,bounds=ep.bounds,
-                   scope_groups=ep.scope_groups,scope_vars=ep.scope_vars,
-                   scope_order=ep.scope_order,annotations=ep.annotations)
+def build_base_problem(axl_def: AXLProblemDef) -> Problem:
+    psl_text = AXL_COMPILER.compile(axl_def)
+    prog = parse_psl(psl_text); ep = expand_psl(prog)
+    return Problem(pid=f"base_{axl_def.name}", variables=ep.variables,
+                   constraints=ep.constraints, bounds=ep.bounds,
+                   scope_groups=ep.scope_groups, scope_vars=ep.scope_vars,
+                   scope_order=ep.scope_order, annotations=ep.annotations)
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 14: GLOBAL STATE + RUNNER
+# SECTION 15: GLOBAL STATE + RUNNER
 # ══════════════════════════════════════════════════════════════════════
-STATE_LOCK=threading.Lock()
-RUN_LOG:List[Dict]=[]
-THEORIST=AxiomRayTracer()
-POOL=ThreadPoolExecutor(max_workers=2)
+STATE_LOCK = threading.Lock()
+RUN_LOG: List[Dict] = []
+THEORIST = SequenceRayTracer()
+POOL = ThreadPoolExecutor(max_workers=2)
 
-def _run_problem(axl_def:AXLProblemDef):
+def _run_problem(axl_def: AXLProblemDef):
     try:
         base_prob = build_base_problem(axl_def)
-        binding, ce, rounds = THEORIST.trace(axl_def, base_prob)
-        
+        binding, ce, history = THEORIST.trace(axl_def, base_prob)
+
         survived = [t for t in THEORIST.all_traces if t.survived]
-        failed = [t for t in THEORIST.all_traces if not t.survived]
-        best_trace = min(survived, key=lambda t: t.ce_after, default=None)
-        
-        record={
-            "problem": axl_def.name,
+        failed   = [t for t in THEORIST.all_traces if not t.survived]
+        best_t   = min(survived, key=lambda t: t.ce_after, default=None)
+
+        record = {
+            "problem":     axl_def.name,
             "description": axl_def.description,
-            "ce": round(ce, 6),
-            "solved": len(survived) > 0 and ce < SOLVE_THRESHOLD,
-            "binding": {k: round(v, 5) for k, v in binding.items()},
-            "observations": axl_def.observations,
+            "ce":          round(ce, 6),
+            "solved":      len(survived) > 0 and ce < SOLVE_THRESHOLD,
+            "binding":     {k: round(v,5) for k,v in binding.items()},
+            "observations":axl_def.observations,
             "traces": [{
-                "round": t.round_idx, "ray": t.ray_name,
-                "ce": round(t.ce_after, 5),
-                "g1_ce": round(t.verify.gate1_ce, 5) if t.verify else None,
-                "g1": t.verify.gate1_pass if t.verify else False,
-                "g2": t.verify.gate2_pass if t.verify else False,
-                "g2_detail": {k: (round(err, 6), ok) for k, (err, ok) in t.verify.gate2_results.items()} if t.verify else {},
-                "survived": t.survived, "ms": t.elapsed_ms,
+                "round":    t.round_idx,
+                "ray":      t.ray_name,
+                "depth":    t.depth,
+                "parent":   t.parent_id,
+                "ce_before":round(t.ce_before,5),
+                "ce":       round(t.ce_after,5),
+                "g1_ce":    round(t.verify.gate1_ce,5) if t.verify else None,
+                "g1":       t.verify.gate1_pass if t.verify else False,
+                "g2":       t.verify.gate2_pass if t.verify else False,
+                "g2_detail":{k:(round(err,6),ok) for k,(err,ok) in t.verify.gate2_results.items()} if t.verify else {},
+                "survived": t.survived,
+                "ms":       t.elapsed_ms,
             } for t in THEORIST.all_traces],
+            "ray_tree":       history,
             "survived_count": len(survived),
-            "failed_count": len(failed),
-            "best_ray": best_trace.ray_name if best_trace else "—",
+            "failed_count":   len(failed),
+            "best_ray":       best_t.ray_name if best_t else "—",
+            "total_fired":    len(THEORIST.all_traces),
         }
         with STATE_LOCK:
             RUN_LOG.append(record)
@@ -1266,9 +1709,9 @@ def _run_problem(axl_def:AXLProblemDef):
         print(f"[RUN ERROR] {axl_def.name}: {e}")
 
 async def run_loop():
-    loop=asyncio.get_event_loop()
+    loop = asyncio.get_event_loop()
     while True:
-        prob=random.choice(AXL_PROBLEMS)
+        prob = random.choice(AXL_PROBLEMS)
         await loop.run_in_executor(POOL, _run_problem, prob)
         await asyncio.sleep(0.3)
 
@@ -1279,55 +1722,58 @@ async def lifespan(app):
     POOL.shutdown(wait=False)
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 15: FASTAPI + DASHBOARD
+# SECTION 16: FASTAPI + DASHBOARD
 # ══════════════════════════════════════════════════════════════════════
-app=FastAPI(title="Practicality 12.1",lifespan=lifespan)
+app = FastAPI(title="Practicality 13.0", lifespan=lifespan)
 
-def _render_collapse(record:Dict) -> str:
-    b=record["binding"]; traces=record["traces"]
-    survived=[t for t in traces if t["survived"]]
-    best=min(survived,key=lambda t:t["ce"],default=None)
-    if not best and traces: best=min(traces,key=lambda t:t.get("g1_ce") or 999.0)
-    obs_vars=set(record.get("observations",{}).keys())
+def _render_collapse(record: Dict) -> str:
+    b = record["binding"]; traces = record["traces"]
+    survived = [t for t in traces if t["survived"]]
+    best = min(survived, key=lambda t: t["ce"], default=None)
+    if not best and traces:
+        best = min(traces, key=lambda t: t.get("g1_ce") or 999.0)
+    obs_vars = set(record.get("observations",{}).keys())
 
-    solved=record["solved"]
-    ce=record["ce"]
-    ce_color="#4CAF50" if solved else ("#FF9800" if ce<0.5 else "#EF5350")
-    status="✓ SOLVED + VERIFIED" if solved else ("~ PARTIAL" if ce<0.5 else "✗ UNSOLVED")
+    ce = record["ce"]; solved = record["solved"]
+    ce_color = "#4CAF50" if solved else ("#FF9800" if ce < 0.5 else "#EF5350")
+    status   = "✓ SOLVED + VERIFIED" if solved else ("~ PARTIAL" if ce < 0.5 else "✗ UNSOLVED")
 
-    binding_rows="".join(
+    binding_rows = "".join(
         f"<tr><td style='color:#888;width:70px'>{v}</td>"
         f"<td style='color:#26C6DA;font-weight:700'>{val:+.5f}</td>"
         f"<td style='color:#4CAF50;font-size:0.75em'>{'[OBS]' if v in obs_vars else ''}</td></tr>"
         for v,val in b.items())
 
-    inv_rows=""
+    inv_rows = ""
     if best and best.get("g2_detail"):
         for inv,(err,ok) in best["g2_detail"].items():
-            c="#4CAF50" if ok else "#EF5350"
-            inv_rows+=(f"<tr><td style='color:{c}'>{'✓' if ok else '✗'}</td>"
-                       f"<td style='color:#aaa'>{inv}</td>"
-                       f"<td style='color:{c}'>{err:.6f}</td></tr>")
+            c = "#4CAF50" if ok else "#EF5350"
+            inv_rows += (f"<tr><td style='color:{c}'>{'✓' if ok else '✗'}</td>"
+                         f"<td style='color:#aaa'>{inv}</td>"
+                         f"<td style='color:{c}'>{err:.6f}</td></tr>")
 
     def trail_span(t):
-        c="#4CAF50" if t["survived"] else "#333"
-        star=" ◀ VERIFIED" if t["survived"] else ""
-        return (f"<div style='color:{c};font-size:0.78em;margin-bottom:3px'>"
-                f"[R{t['round']}] <span style='color:#FF9800'>{t['ray']}</span>"
-                f"  CE={t['ce']:.5f} | "
-                f"G1={'✓' if t['g1'] else '✗'}{t.get('g1_ce',0):.4f} "
-                f"G2={'✓' if t['g2'] else '✗'} "
+        depth_pad = "  " * min(t.get("depth",0), 6)
+        c = "#4CAF50" if t["survived"] else ("#555" if t.get("depth",0) > 0 else "#333")
+        ce_delta = t["ce"] - t.get("ce_before", t["ce"])
+        delta_str = f"Δ{ce_delta:+.4f}" if abs(ce_delta) > 1e-6 else ""
+        star = " ◀ VERIFIED" if t["survived"] else ""
+        return (f"<div style='color:{c};font-size:0.75em;margin-bottom:2px'>"
+                f"{depth_pad}[R{t['round']}|d{t.get('depth',0)}] "
+                f"<span style='color:#FF9800'>{t['ray']}</span> "
+                f"CE={t['ce']:.5f} <span style='color:#555'>{delta_str}</span> "
+                f"G1={'✓' if t['g1'] else '✗'} G2={'✓' if t['g2'] else '✗'}"
                 f"<span style='color:#4CAF50;font-weight:700'>{star}</span></div>")
 
-    trail="".join(trail_span(t) for t in traces)
+    trail = "".join(trail_span(t) for t in traces[:30])
 
     return f"""
-<div style='border:1px solid #222;border-radius:8px;margin-bottom:18px;overflow:hidden'>
+<div style='border:1px solid #1a1a1a;border-radius:8px;margin-bottom:18px;overflow:hidden'>
   <div style='background:#0e0e0e;padding:9px 14px;border-bottom:1px solid #1a1a1a;display:flex;align-items:center;gap:16px'>
     <span style='color:{ce_color};font-weight:700;font-size:1.05em'>{status}</span>
     <span style='color:#444;font-size:0.85em'>{record["problem"]}</span>
-    <span style='color:#333;font-size:0.8em'>BaseCE={ce:.6f}</span>
-    <span style='color:#26C6DA;font-size:0.75em'>{record["survived_count"]} survived / {record["failed_count"]} failed</span>
+    <span style='color:#333;font-size:0.8em'>CE={ce:.6f}</span>
+    <span style='color:#26C6DA;font-size:0.75em'>{record["survived_count"]} survived / {record["total_fired"]} fired</span>
   </div>
   <div style='display:flex'>
     <div style='flex:0 0 180px;padding:10px 12px;border-right:1px solid #1a1a1a'>
@@ -1340,50 +1786,54 @@ def _render_collapse(record:Dict) -> str:
         {inv_rows or "<tr><td colspan='3' style='color:#222'>—</td></tr>"}
       </table>
     </div>
-    <div style='flex:1;padding:10px 12px'>
+    <div style='flex:1;padding:10px 12px;overflow-y:auto;max-height:260px'>
       <div style='color:#333;font-size:0.7em;margin-bottom:5px'>
-        WAVEFRONT RAYS — best: <span style='color:#FF9800'>{record["best_ray"]}</span>
+        SEQUENCE RAY TREE — best: <span style='color:#FF9800'>{record["best_ray"]}</span>
       </div>
       {trail}
     </div>
   </div>
 </div>"""
 
-@app.get("/",response_class=HTMLResponse)
+@app.get("/", response_class=HTMLResponse)
 async def dashboard():
-    with STATE_LOCK: log=list(reversed(RUN_LOG[-10:]))
-    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
+    with STATE_LOCK: log = list(reversed(RUN_LOG[-10:]))
+    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
 
-    axiom_stats = defaultdict(lambda: {"tried": 0, "survived": 0, "total_ce": 0.0})
+    # Axiom efficacy across all sequence positions
+    axiom_stats = defaultdict(lambda: {"tried":0,"survived":0,"total_ce":0.0,"as_seed":0})
     for r in log:
-        for t in r.get("traces", []):
-            ray_str = t["ray"].strip("[]")
-            axioms = ray_str.split("|")
-            for ax in axioms:
-                if not ax: continue
-                axiom_stats[ax]["tried"] += 1
-                axiom_stats[ax]["total_ce"] += t["ce"]
-                if t["survived"]: axiom_stats[ax]["survived"] += 1
-
-    axiom_rows="".join(
+        for t in r.get("traces",[]):
+            ray_str = t["ray"]
+            parts   = ray_str.split("→")
+            for pos, ax_abbr in enumerate(parts):
+                if not ax_abbr: continue
+                axiom_stats[ax_abbr]["tried"]    += 1
+                axiom_stats[ax_abbr]["total_ce"] += t["ce"]
+                if t["survived"]:  axiom_stats[ax_abbr]["survived"] += 1
+                if pos == 0:       axiom_stats[ax_abbr]["as_seed"]  += 1
+
+    axiom_rows = "".join(
         f"<tr><td style='color:#FF9800'>{ax}</td>"
         f"<td style='color:#aaa'>{s['tried']}</td>"
+        f"<td style='color:#26C6DA'>{s['as_seed']}</td>"
         f"<td style='color:#4CAF50'>{s['survived']}</td>"
         f"<td style='color:#EF5350'>{s['tried']-s['survived']}</td>"
         f"<td style='color:#26C6DA'>{round(s['total_ce']/s['tried'],5) if s['tried'] else 0}</td>"
         f"<td style='color:{'#4CAF50' if s['survived']>0 else '#333'}'>"
         f"{round(s['survived']/s['tried']*100):.0f}%</td></tr>"
-        for ax,s in sorted(axiom_stats.items(),key=lambda x:-x[1]["survived"])
-    ) or "<tr><td colspan='6' style='color:#222'>Warming up…</td></tr>"
+        for ax,s in sorted(axiom_stats.items(), key=lambda x:-x[1]["survived"])
+    ) or "<tr><td colspan='7' style='color:#222'>Warming up…</td></tr>"
 
-    collapses="".join(_render_collapse(r) for r in log) if log else \
+    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.1</title>
+    return f"""<!DOCTYPE html><html><head><title>Practicality 13.0</title>
 <meta http-equiv="refresh" content="4">
 <style>
-  body{{background:#090909;color:#e0e0e0;font-family:monospace;padding:20px;max-width:1400px}}
+  body{{background:#090909;color:#e0e0e0;font-family:monospace;padding:20px;max-width:1500px}}
   h1{{color:#26C6DA;border-bottom:1px solid #1a1a1a;padding-bottom:6px;font-size:1.15em}}
   h3{{color:#2a2a2a;margin-top:20px;font-size:0.85em;letter-spacing:2px;text-transform:uppercase}}
   table{{width:100%;border-collapse:collapse;margin-bottom:10px}}
@@ -1391,25 +1841,27 @@ 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.1 — Axiomatic Enzymes (Permutation Spaces)</h1>
+<h1>⚗ Practicality 13.0 — Sequence Rays (Ordered Axiom Chains)</h1>
 <div style='color:#333;font-size:0.75em;margin-bottom:12px'>
-  Boolean Hypercube → Wavefront Rays → Generator (Enzyme Stacked Chains) → Verify Layer
+  27 Axioms (Math · Physics · Logic · Philosophy) → Ordered Sequences →
+  Baton Protocol (child inherits partial) → Earn Extension by CE reduction →
+  Contradiction at Distance allowed
 </div>
 <div style='margin-bottom:16px'>
   <span class='badge' style='color:#aaa'>Runs: {runs}</span>
   <span class='badge' style='color:#4CAF50'>Solved: {solved}</span>
-  <span class='badge' style='color:#26C6DA'>Avg BaseCE: {avg_ce}</span>
+  <span class='badge' style='color:#26C6DA'>Avg CE: {avg_ce}</span>
   <span class='badge' style='color:#FF9800'>Problems: {len(AXL_PROBLEMS)}</span>
-  <span class='badge' style='color:#5C6BC0'>Valid Universal Rays: {len(AXIOM_HYPERCUBE)}</span>
+  <span class='badge' style='color:#5C6BC0'>Axioms: {len(ALL_AXIOMS)}</span>
 </div>
-<h3>Axiom Efficacy Summary (Which properties describe reality best?)</h3>
+<h3>Axiom Efficacy — All Sequence Positions</h3>
 <table>
-  <tr><th>Axiom</th><th>Tested</th><th>Survived</th><th>Failed</th><th>Avg BaseCE</th><th>Efficacy</th></tr>
+  <tr><th>Axiom</th><th>In-Seq</th><th>As Seed</th><th>Survived</th><th>Failed</th><th>Avg CE</th><th>Efficacy</th></tr>
   {axiom_rows}
 </table>
 <h3>Collapse View — Recent Runs</h3>
 {collapses}
 </body></html>"""
 
-if __name__=="__main__":
-    uvicorn.run(app,host="0.0.0.0",port=7860,log_level="warning")
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="warning")