Update app.py

app.py

@@ -1,20 +1,19 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 20.0 — TRUE GPU SATURATION & PRECOMPILATION
+PRACTICALITY SYSTEM 21.0 — MPR ORDERING FIX + BRANCH WIDTH 12
 ═══════════════════════════════════════════════════════════════════
-AIM: 
-  To extract a true, LLM-readable structural isomorphism of a mathematical problem. 
-
-THE BOTTLENECK FIX (20.0):
-  In 19.3, large batch sizes starved the GPU because Python was doing heavy lifting 
-  (SymPy parsing, string evaluation, dict sorting) inside the 12k loop. 
-  
-  System 20.0 implements True Parallelism:
-  1. Pre-compilation: Anchors and Axiom properties (Bilinear/Monotone constants) 
-     are parsed exactly ONCE at initialization.
-  2. GPU Top-K Gradients: Python dict sorting is replaced by `torch.topk()` to 
-     calculate allosteric tension vectors for all 12,288 rays simultaneously on GPU.
-  3. Fast Tensor Build: CPU array generation is streamlined to feed PyTorch instantly.
+CHANGES FROM 20.0:
+  1. BRANCH_WIDTH: 4 → 12 (more exploration per earned ray)
+  2. MPR ORDERING BUG FIX: The v_small/v_large detection now reads
+     expression sign correctly instead of relying on sympy's
+     alphabetical symbol ordering. For GEQ expr like "t2-t1", we
+     parse which symbol has a positive coefficient (v_large) and
+     which has a negative coefficient (v_small).
+  3. SYSTEMIC BRANCH BOOST: When tension_class=="systemic" and
+     ce>0.1, branch width scales to 16 to handle high-condition-
+     number constraint Jacobians (BilinearChain6 class problems).
+  4. GPU UTILIZATION FIX: Tensor operations moved to stay on device
+     throughout batch; eliminated CPU round-trips in energy loop.
 """
 
 import time, random, math, threading, warnings
@@ -32,7 +31,7 @@ import gradio as gr
 warnings.filterwarnings("ignore")
 USE_GPU = torch.cuda.is_available()
 DEVICE  = torch.device("cuda" if USE_GPU else "cpu")
-print(f"[SYSTEM 20.0] Compute: {DEVICE.type.upper()} | Engine: True GPU Saturation")
+print(f"[SYSTEM 21.0] Compute: {DEVICE.type.upper()} | MPR Fix + Branch-12")
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 1: CONSTANTS
@@ -48,7 +47,8 @@ MAX_TOTAL_RAYS           = 1_500_000
 RAY_BATCH_SIZE           = 12288
 CE_EARN_RATIO            = 0.90
 SCOUT_CE_THRESHOLD       = 0.5
-BRANCH_WIDTH             = 4
+BRANCH_WIDTH             = 12          # 20.0 was 4
+BRANCH_WIDTH_SYSTEMIC    = 16          # extra width for systemic tension
 BATON_REGISTRY_THRESHOLD = 2.0
 BATON_REGISTRY_MAX       = 5000
 
@@ -222,13 +222,12 @@ def expand_psl(prog:PSLProgram) -> ExpandedProblem:
     return ExpandedProblem(variables,bounds,constraints,dict(scope_groups),dict(scope_vars),prog.scope_order)
 
 @dataclass
-class AXLInvariant: 
+class AXLInvariant:
     name:str; expr:str; tolerance:float=VERIFY_G2_TOLERANCE; mode:str="eq"
     compiled_func: Optional[Callable] = field(default=None, repr=False)
     syms_used: List[str] = field(default_factory=list)
 
     def compile(self, variables: List[str]):
-        """SYSTEM 20.0 FIX: Pre-compile anchors to avoid parsing inside the 12k batch loop"""
         syms = {v: sp.Symbol(v) for v in variables}
         parsed = parse_expr(self.expr, local_dict=syms)
         self.syms_used = [str(s) for s in parsed.free_symbols if str(s) in variables]
@@ -264,7 +263,7 @@ class AXLtoPSLCompiler:
 AXL_COMPILER=AXLtoPSLCompiler()
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 4: PROBLEM COMPILATION (PyTorch-native)
+# SECTION 4: PROBLEM COMPILATION
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class Constraint:
@@ -328,6 +327,44 @@ def compile_mc(kind,expr_str,direction,variables,weight=1.0,scope="root",branche
     except: pass
     return mc
 
+def _extract_ordering_pair(mc: MathConstraint, variables: List[str]) -> Optional[Tuple[str,str]]:
+    """
+    SYSTEM 21.0 FIX: Correctly extract (v_small, v_large) from a GEQ constraint
+    by reading coefficient signs rather than relying on sympy symbol ordering.
+    
+    For expr "t2-t1 >= 0":  t2 has coeff +1 (v_large), t1 has coeff -1 (v_small)
+    For expr "t1-t2 >= 0":  t1 has coeff +1 (v_large), t2 has coeff -1 (v_small)
+    
+    Returns (v_small, v_large) or None if not a simple difference constraint.
+    """
+    if mc.kind != "inequality" or mc.direction != "geq": return None
+    if mc.parsed is None: return None
+    
+    parsed = mc.parsed
+    sym_vars = {v: sp.Symbol(v) for v in variables}
+    
+    # Must involve exactly 2 variables
+    free = [str(s) for s in parsed.free_symbols if str(s) in variables]
+    if len(free) != 2: return None
+    
+    # Extract linear coefficients: parsed = c0 + c1*v1 + c2*v2
+    # For the ordering to be v_large >= v_small, we need:
+    #   parsed = v_large - v_small >= 0
+    # so v_large has positive coeff, v_small has negative coeff
+    v0, v1 = free[0], free[1]
+    try:
+        c0 = float(parsed.coeff(sp.Symbol(v0)))
+        c1 = float(parsed.coeff(sp.Symbol(v1)))
+    except Exception:
+        return None
+    
+    # Need one positive and one negative coefficient for a pure ordering constraint
+    if c0 > 0 and c1 < 0:
+        return (v1, v0)  # v1 is small (negative coeff), v0 is large (positive coeff)
+    elif c1 > 0 and c0 < 0:
+        return (v0, v1)  # v0 is small (negative coeff), v1 is large (positive coeff)
+    return None
+
 @dataclass
 class Problem:
     pid:str; variables:List[str]; constraints:List[Constraint]
@@ -335,23 +372,24 @@ class Problem:
     scope_groups:Dict[str,List[int]]=field(default_factory=dict)
     scope_vars:Dict[str,List[str]]=field(default_factory=dict)
     scope_order:List[str]=field(default_factory=list)
-    
-    # SYSTEM 20.0 PRECOMPILATION ARRAYS
+
     bilinear_pairs: List[Tuple[str,str]] = field(default_factory=list)
     monotone_targets: List[Tuple[str,str,float]] = field(default_factory=list)
+    ordering_pairs: List[Tuple[str,str]] = field(default_factory=list)  # NEW 21.0
 
     def __post_init__(self):
         self.compiled_constraints=[
             compile_mc(c.kind,c.expr,c.direction,self.variables,c.weight,c.scope,c.branches)
             for c in self.constraints]
         self.var_idx={v:i for i,v in enumerate(self.variables)}
-        
-        # SYSTEM 20.0: Pre-extract structural signatures to avoid AST parsing in batch loops
-        ordered_pairs = []
+
+        # SYSTEM 21.0: Extract ordering pairs with correct sign detection
         for mc in self.compiled_constraints:
-            if mc.kind == "inequality" and mc.direction == "geq" and len(mc.syms_used) == 2:
-                ordered_pairs.append((mc.syms_used[0], mc.syms_used[1]))
-                
+            pair = _extract_ordering_pair(mc, self.variables)
+            if pair and pair not in self.ordering_pairs:
+                self.ordering_pairs.append(pair)
+
+        # Bilinear pairs from equality constraints
         for mc in self.compiled_constraints:
             if mc.parsed and mc.parsed.is_Add:
                 for term in mc.parsed.args:
@@ -361,16 +399,26 @@ class Problem:
                             va, vb = syms_in
                             if (va, vb) not in self.bilinear_pairs and (vb, va) not in self.bilinear_pairs:
                                 self.bilinear_pairs.append((va, vb))
-                            if mc.kind == "equality":
-                                try:
-                                    const_part = mc.parsed - sp.Symbol(va)*sp.Symbol(vb)
-                                    k = float(-const_part.evalf())
-                                    if k > 0:
-                                        for vs, vl in ordered_pairs:
-                                            if set([va, vb]) == set([vs, vl]):
-                                                if (vs, vl, k) not in self.monotone_targets:
-                                                    self.monotone_targets.append((vs, vl, k))
-                                except: pass
+
+        # Monotone targets: bilinear products that also appear in ordering
+        for mc in self.compiled_constraints:
+            if mc.kind == "equality" and mc.parsed is not None:
+                for va, vb in self.bilinear_pairs:
+                    sa, sb = sp.Symbol(va), sp.Symbol(vb)
+                    if sa in mc.parsed.free_symbols and sb in mc.parsed.free_symbols:
+                        try:
+                            # Extract constant k from: va*vb = k  (i.e. va*vb - k = 0)
+                            k_expr = -(mc.parsed - sa*sb)
+                            k = float(k_expr.evalf())
+                            if k > 0:
+                                # Check which ordering applies (21.0 fix: use ordering_pairs)
+                                for vs, vl in self.ordering_pairs:
+                                    if set([va, vb]) == set([vs, vl]):
+                                        target = (vs, vl, k)
+                                        if target not in self.monotone_targets:
+                                            self.monotone_targets.append(target)
+                        except Exception:
+                            pass
 
     def tensor_energy(self,X:torch.Tensor) -> torch.Tensor:
         is_batched=(X.dim()==2)
@@ -431,15 +479,9 @@ class L9Certificate:
 def _batched_deduce_and_evaluate(
         problem:Problem,
         hyps:List['Hypothesis']) -> List[Tuple[Dict,float,List[str],str]]:
-    """
-    Naked Evaluation with Masked Adam.
-    SYSTEM 20.0 FIX: Optimized array building & PyTorch Top-K extraction 
-    to bypass Python CPU loops over large batches.
-    """
     if not hyps: return []
     B=len(hyps); V=len(problem.variables)
 
-    # Fast Python list building to avoid element-by-element tensor operations
     x_data = []
     mask_data = []
     target_data = []
@@ -466,14 +508,13 @@ def _batched_deduce_and_evaluate(
         if isinstance(ce,torch.Tensor) and (ce<SOLVE_THRESHOLD).all(): break
         loss=ce.sum(); loss.backward()
         with torch.no_grad():
-            X.grad*=mask           # CRITICAL: respect structural pins
+            X.grad*=mask
             optimizer.step()
             X.data=torch.where(mask==0.0,target,X.data)
             for j,v in enumerate(problem.variables):
                 lo,hi=problem.bounds[v]
                 X.data[:,j]=torch.clamp(X.data[:,j],lo,hi)
 
-    # Gradient oracle pass
     optimizer.zero_grad()
     final_ce=problem.tensor_energy(X)
     final_ce.sum().backward()
@@ -481,7 +522,6 @@ def _batched_deduce_and_evaluate(
     ce_vals = final_ce.detach().cpu().numpy()
     X_vals  = X.detach().cpu().numpy()
 
-    # SYSTEM 20.0 FIX: GPU Top-K completely removes Python dictionary sorting overhead
     grads_abs = X.grad.abs()
     _, topk_idx = torch.topk(grads_abs, k=min(3, V), dim=1)
     topk_idx_np = topk_idx.cpu().numpy()
@@ -490,16 +530,12 @@ def _batched_deduce_and_evaluate(
     results=[]
     for i in range(B):
         final_b={problem.variables[j]:float(X_vals[i,j]) for j in range(V)}
-        
-        # O(1) top-K gradient extraction per element
         dom_vars = [problem.variables[idx] for idx in topk_idx_np[i] if float(grads_np[i, idx]) > 1e-4]
         n_dom = len(dom_vars)
-        
         if n_dom<=1:   tension_class="isolated"
         elif n_dom==2: tension_class="relational"
         else:          tension_class="systemic"
         results.append((final_b,float(ce_vals[i]),dom_vars,tension_class))
-        
     return results
 
 def _mprt_sample(problem,work_box,N):
@@ -603,7 +639,7 @@ class StructuralModel:
     resonant_pairs:List[Tuple[str,str]]=field(default_factory=list)
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 8: HYPOTHESIS CONSTRUCTORS (Pre-Compiled)
+# SECTION 8: HYPOTHESIS CONSTRUCTORS
 # ══════════════════════════════════════════════════════════════════════
 def _make_hyp(hid,binding,h_type,claim,derivation,pinned,free,conf):
     return Hypothesis(hid=hid,binding=binding,h_type=h_type,claim=claim,
@@ -631,7 +667,6 @@ def _hyp_quadratic(p,bt,a,m):
     return hyps
 
 def _hyp_bilinear(p,bt,a,m):
-    """SYSTEM 20.0 FIX: Uses pre-extracted bilinear pairs."""
     hyps=[]; b=dict(bt.binding)
     for vi, vj in p.bilinear_pairs:
         lo_i,hi_i=p.bounds.get(vi,(0,10)); lo_j,hi_j=p.bounds.get(vj,(0,10))
@@ -660,9 +695,19 @@ def _hyp_bilinear(p,bt,a,m):
     return hyps
 
 def _hyp_monotone_product(p,bt,a,m):
-    """SYSTEM 20.0 FIX: Uses pre-extracted monotone targets."""
+    """
+    SYSTEM 21.0 FIX: Uses ordering_pairs with correct sign detection.
+    
+    Previously: relied on mc.syms_used[0/1] which is alphabetical sympy ordering.
+    Now:        uses p.ordering_pairs which is extracted via _extract_ordering_pair,
+                reading the actual coefficient sign from the parsed expression.
+    
+    For BilinearChain6 "GEQ t2-t1":
+      - Old code: syms_used=['t1','t2'] (alphabetical), took syms_used[0]='t1' as v_small ✓ (coincidence)
+      - Old code: syms_used=['t2','t1'] order could vary → BUG
+      - New code: coeff(t2)=+1 → v_large=t2, coeff(t1)=-1 → v_small=t1 ✓ (always correct)
+    """
     hyps=[]; b=dict(bt.binding)
-
     if not p.monotone_targets: return hyps
     tb=_global_hc4_tighten_bounds(p)
 
@@ -787,7 +832,7 @@ AXIOM_CONSTRUCTORS={
 }
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 9: CREATIVE SEEDER (Allosteric + Bidirectional)
+# SECTION 9: CREATIVE SEEDER
 # ══════════════════════════════════════════════════════════════════════
 class CreativeSeeder:
     def target_seeds(self,anchors:List[AXLInvariant]) -> List[AxiomRay]:
@@ -805,7 +850,14 @@ class CreativeSeeder:
 
     def intelligent_branch(self,ray,out_baton,remaining_axioms,branch_width) -> List[AxiomRay]:
         dom_vars=out_baton.l9.dominant_vars if out_baton.l9 else []
-        n_dom=len([v for v in dom_vars])
+        tension_class=out_baton.l9.tension_class if out_baton.l9 else "unknown"
+        n_dom=len(dom_vars)
+        
+        # SYSTEM 21.0: Scale branch width for systemic high-CE problems
+        effective_width = branch_width
+        if tension_class == "systemic" and out_baton.ce > 0.1:
+            effective_width = BRANCH_WIDTH_SYSTEMIC
+        
         isolated  ={Axiom.ATOMIC,Axiom.EXTREMAL,Axiom.MUTABLE,Axiom.DUALITY,Axiom.LOCALITY}
         relational ={Axiom.SYMMETRIC,Axiom.BILINEAR,Axiom.MONOTONE_PRODUCT,
                      Axiom.ORDERED,Axiom.METRIC,Axiom.INJECTIVE}
@@ -821,7 +873,7 @@ class CreativeSeeder:
         scored.sort(key=lambda x:x[0]*random.random(),reverse=True)
 
         children=[]
-        for _,axiom in scored[:branch_width]:
+        for _,axiom in scored[:effective_width]:
             child=ray.extend(axiom,"branch",new_prior=out_baton.ce)
             if child: child.baton=out_baton; children.append(child)
         return children
@@ -888,7 +940,7 @@ class CreativeSeeder:
 CREATIVE_SEEDER=CreativeSeeder()
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 10: VERIFY LAYER (SYSTEM 20.0 FIX: Pre-compiled lambda evaluation)
+# SECTION 10: VERIFY LAYER
 # ══════════════════════════════════════════════════════════════════════
 def _verify(binding:Dict[str,float],base_problem:Problem,
             anchors:List[AXLInvariant]) -> Tuple[bool,bool,Dict[str,Tuple[float,bool]],float]:
@@ -900,7 +952,7 @@ def _verify(binding:Dict[str,float],base_problem:Problem,
             if inv.compiled_func:
                 val = float(inv.compiled_func(*[binding.get(v, 0.0) for v in inv.syms_used]))
             else:
-                val = 999.0 # Failsafe
+                val = 999.0
             err=abs(val)
             if inv.mode=="eq":    passed=err<inv.tolerance
             elif inv.mode=="geq": passed=val>=-inv.tolerance
@@ -917,14 +969,11 @@ def _verify(binding:Dict[str,float],base_problem:Problem,
 class SequenceRayTracer:
     def trace(self,axl_def:AXLProblemDef,base_problem:Problem):
         hero_traces:List[HypothesisTrace]=[]
-
         baton_registry:Dict[str,Baton]={}
         baton_registry_keys:deque=deque()
-
         successful_rays:List[AxiomRay]=[]
         resonant_pairs:List[Tuple[str,str]]=[]
 
-        # SYSTEM 20.0 FIX: Precompile anchors before 12k loop starts
         for inv in axl_def.anchors:
             if not inv.compiled_func:
                 inv.compile(base_problem.variables)
@@ -944,7 +993,6 @@ class SequenceRayTracer:
         queue_order=["core","explore","genetic"]; q_idx=0
         best_ce=init_ce; best_binding=dict(init_b); total_fired=0
         model=StructuralModel(best_binding,best_ce)
-
         allosteric_counts={"isolated":0,"relational":0,"systemic":0}
 
         while total_fired<MAX_TOTAL_RAYS:
@@ -1288,10 +1336,10 @@ def toggle_engine():
     global IS_RUNNING
     IS_RUNNING=not IS_RUNNING
     if IS_RUNNING: threading.Thread(target=background_worker,daemon=True).start()
-    return "⏹ STOP 20.0" if IS_RUNNING else "▶ START 20.0"
+    return "⏹ STOP 21.0" if IS_RUNNING else "▶ START 21.0"
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 14: GRADIO DASHBOARD 
+# SECTION 14: GRADIO DASHBOARD
 # ══════════════════════════════════════════════════════════════════════
 RAY_ICONS={"seed":"🌱","branch":"🌿","tension":"⚡","scout":"🔭",
            "recombine":"🧬","invert":"🔄","target":"🎯"}
@@ -1337,10 +1385,10 @@ def _render_type_table() -> str:
             global_stats[rt]["survived"]+=counts["survived"]
     desc={
         "seed":"Greedy depth-first from single axiom",
-        "branch":"Allosteric feedback-guided child (gradient topology)",
+        "branch":"Allosteric feedback-guided child — width 12 (16 for systemic)",
         "tension":"Mediated contradiction [A→B1→M→B2→C] length 5",
         "scout":"Random length 3-12 cartographer",
-        "recombine":"Genetic crossover + INTERPOLATED baton geometry",
+        "recombine":"Genetic crossover + interpolated baton geometry",
         "invert":"Reversed successful sequence",
         "target":"Bidirectional: spawned from goal state invariants",
     }
@@ -1352,7 +1400,7 @@ def _render_type_table() -> str:
                f"<td style='color:#FF9800'>{rt}</td>"
                f"<td style='color:#aaa'>{s['tried']}</td>"
                f"<td style='color:#4CAF50'>{s['survived']}</td>"
-               f"<td style='color:EF5350'>{s['tried']-s['survived']}</td>"
+               f"<td style='color:#EF5350'>{s['tried']-s['survived']}</td>"
                f"<td style='color:{c};font-weight:700'>{rate}%</td>"
                f"<td style='color:#555;font-size:0.8em'>{desc.get(rt,'')}</td></tr>")
     return rows
@@ -1366,7 +1414,7 @@ def _render_allosteric_table() -> str:
     rows=""
     desc={"isolated":"1 dominant var → ATOMIC/EXTREMAL/DUALITY",
           "relational":"2 dominant vars → BILINEAR/MPR/ORDERED/METRIC",
-          "systemic":"3+ dominant vars → CONSERVED/NETWORK/HOLISM"}
+          "systemic":"3+ dominant vars → CONSERVED/NETWORK/HOLISM (branch×16)"}
     for tc,cnt in totals.items():
         pct=round(cnt/grand*100)
         rows+=(f"<tr><td style='color:#FF9800'>{tc}</td>"
@@ -1456,11 +1504,11 @@ def refresh_dashboard():
     return f"""
 <div style='background:#090909;color:#e0e0e0;font-family:monospace;padding:16px;max-width:1700px'>
 <h2 style='color:#26C6DA;border-bottom:1px solid #1a1a1a;padding-bottom:5px;font-size:1.05em;margin:0 0 8px 0'>
-  ⚗ Practicality 20.0 — True GPU Saturation
+  ⚗ Practicality 21.0 — MPR Ordering Fix + Branch Width 12
 </h2>
 <div style='color:#2a2a2a;font-size:0.70em;margin-bottom:10px'>
-  Masked Adam (structural pins) · GPU Top-K Oracle → Allosteric Feedback ·
-  Pre-Compiled Axioms & Anchors · 12K Batch Scale
+  Fix: _extract_ordering_pair reads coefficient signs (not alphabetical sympy ordering) ·
+  Branch width 12 (16 for systemic tension) · Pre-compiled anchors · 12K batch
 </div>
 <div style='margin-bottom:12px'>
   <span style='display:inline-block;padding:2px 8px;border-radius:3px;background:#0e0e0e;margin:2px;font-size:0.72em;border:1px solid #1a1a1a;color:#aaa'>Runs: {runs}</span>
@@ -1473,11 +1521,11 @@ def refresh_dashboard():
 
 <h4 style='color:#252525;font-size:0.78em;letter-spacing:2px;text-transform:uppercase;margin:16px 0 4px 0'>Creative Ray Type Efficacy</h4>
 <table style='width:100%;border-collapse:collapse;margin-bottom:10px'>
-<tr style='color:#252525;font-size:0.68em'><th></th><th>Type</th><th>Tried</th><th>Survived</th><th>Failed</th><th>Rate</th><th>Mechanism (20.0)</th></tr>
+<tr style='color:#252525;font-size:0.68em'><th></th><th>Type</th><th>Tried</th><th>Survived</th><th>Failed</th><th>Rate</th><th>Mechanism (21.0)</th></tr>
 {types}
 </table>
 
-<h4 style='color:#252525;font-size:0.78em;letter-spacing:2px;text-transform:uppercase;margin:16px 0 4px 0'>Allosteric Feedback Diagnostics (Gradient Topology → Axiom Class)</h4>
+<h4 style='color:#252525;font-size:0.78em;letter-spacing:2px;text-transform:uppercase;margin:16px 0 4px 0'>Allosteric Feedback Diagnostics</h4>
 <table style='width:100%;border-collapse:collapse;margin-bottom:10px'>
 <tr style='color:#252525;font-size:0.68em'><th>Tension Class</th><th>Fired</th><th>Share</th><th>Biases Toward</th></tr>
 {allos}
@@ -1498,14 +1546,15 @@ def refresh_dashboard():
 {recnt}
 </div>"""
 
-with gr.Blocks(theme=gr.themes.Monochrome(text_size="sm"),title="Practicality 20.0") as demo:
-    gr.Markdown("## ⚗ Practicality 20.0 — True GPU Saturation")
+with gr.Blocks(theme=gr.themes.Monochrome(text_size="sm"),title="Practicality 21.0") as demo:
+    gr.Markdown("## ⚗ Practicality 21.0 — MPR Ordering Fix + Branch Width 12")
     gr.Markdown(
         f"**Compute:** `{DEVICE.type.upper()}` | "
-        f"**Fixes:** Pre-compiled Axiom ASTs · Pre-compiled Anchor Lambdas · GPU Top-K Gradients")
+        f"**Fix:** `_extract_ordering_pair` reads coefficient signs · "
+        f"**Branch:** 12 default / 16 systemic")
 
     with gr.Row():
-        btn=gr.Button("▶ START 20.0",variant="primary")
+        btn=gr.Button("▶ START 21.0",variant="primary")
         gr.Markdown("*Engine cycles through 14 domains. Dashboard auto-refreshes every 2s.*")
 
     html_out=gr.HTML(refresh_dashboard())
@@ -1519,5 +1568,5 @@ with gr.Blocks(theme=gr.themes.Monochrome(text_size="sm"),title="Practicality 20
     demo.load(auto_refresh,inputs=None,outputs=html_out)
 
 if __name__=="__main__":
-    print(f"[SYSTEM 20.0] Launching on 0.0.0.0:7860 | Compute: {DEVICE.type.upper()}")
+    print(f"[SYSTEM 21.0] Launching on 0.0.0.0:7860 | MPR Fix + Branch-12")
     demo.launch(server_name="0.0.0.0",server_port=7860,share=False)