Update app.py

app.py

@@ -1,36 +1,25 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 3.12
-
-===================================================================
-ARCHITECTURE & TENSOR TRANSITION MANIFESTO (V4.0 PREP)
-===================================================================
-As the system scales to hundreds of scopes, the current scalar-dict 
-architecture will bottleneck. To transition to GPU/Numba in V4.0 
-without regressions, we must adhere to the following mapping:
-
-1. DATA STRUCTURES:
-   - Current: `Box = Dict[str, IV]` passing through Python queues.
-   - Future Tensor: `bounds = np.zeros((N_boxes, N_vars, 2), dtype=np.float32)`
-     Dimension 0 represents independent hypotheses/regions.
-     Dimension 1 represents PSL variables (mapped to integer indices).
-     Dimension 2 represents [lower_bound, upper_bound].
-
-2. EVALUATION (SIMD):
-   - Current: AST loops evaluating `MathConstraint.fast_iv` one by one.
-   - Future Tensor: Constraints pre-compiled into vectorized Numpy universal 
-     functions (ufuncs). E.g., `np.add(bounds[:, v1, :], bounds[:, v2, :])`.
-     Invalid regions generate boolean bitmasks `valid_mask = np.ones(N_boxes)`.
-===================================================================
-
-Changes from 3.11:
-  FIX 1 — Bounded Coordinate Walker: V3.11 evaluated spikes against the rolling 
-          `current_ce`, causing a divergent walk that ruined chain10. Spikes are 
-          now strictly bounded against `best_ce`, allowing ridge-walking without 
-          exponential climbing.
-  FIX 2 — True Greedy Pass: The secondary snap pass now sorts variables dynamically 
-          by their L9 residual impact, rather than blindly relying on the PSL file's 
-          lexical variable order.
+PRACTICALITY SYSTEM 4.0
+═══════════════════════════════════════════════════════════════════
+THE VECTORIZED DIAL SYSTEM
+
+Changes from 3.12:
+  NEW 1 — Tensorized Permutations: The engine now compiles SymPy ASTs into 
+          pure Numpy ufuncs. `Perturb` no longer loops over 4 single hypotheses; 
+          it generates a continuous float32 tensor of 1,000 parallel dimensions 
+          and evaluates them simultaneously in a single SIMD clock cycle.
+          
+  NEW 2 — The Gradient Dial: Introduced a multi-variable Finite-Difference 
+          Gradient Descent hypothesis. To prevent "greedy bias" and mode collapse, 
+          it does not override the system. It competes in the consensus debate 
+          against the Vectorized Permutations. If the gradient gets stuck in a 
+          local minimum, the dial dynamically shifts budget back to stochastic 
+          sampling to blast it out.
+
+  FIX 1 — Replaced Algebraic Sniper with Gradient Refine: Removed the highly 
+          unstable single-variable algebraic snap (which oscillated on fully10 
+          and spiked on chain10) in favor of the controlled multi-variable dial.
 """
 
 import asyncio, time, random, math, threading, warnings
@@ -63,14 +52,14 @@ HUB_BUDGET_MULT      = 2.0
 HUB_RESIDUAL_MULT    = 2.0
 CONSENSUS_MAX_ITER   = 8
 CONSENSUS_PATIENCE   = 3      
-NEAR_SOLVED_CE       = 0.25   
+NEAR_SOLVED_CE       = 0.50     # Dial engages refinement earlier
 HUB_DEGREE_RATIO     = 0.6
 PERTURB_BASE_SCALE   = 0.05
 CYCLE_WINDOW         = 3
 MIN_HYP_FRAC         = 0.15 
 HC4_VOLUME_FLOOR     = 0.20   
 L9_CONTRIB_THRESHOLD = 1e-8   
-N_PERTURB_RESTARTS   = 4      
+N_TENSOR_PERMUTES    = 1000     # V4.0: 1,000 parallel tensor evaluations per perturb
 STRUCT_PROBE_COUNT   = 5      
 MERGE_WEIGHT_EXP     = 2.0    
 MIN_SWEEP_BUDGET     = 40     
@@ -258,7 +247,7 @@ def expand_psl(prog:PSLProgram) -> ExpandedProblem:
 
     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[]))
+        constraints.append(Constraint(kind,expr,direction,weight,scope,branches or []))
         scope_groups[scope].append(idx)
         try:
             syms={v:sp.Symbol(v) for v in variables}
@@ -328,11 +317,9 @@ def expand_psl(prog:PSLProgram) -> ExpandedProblem:
     return ExpandedProblem(variables,bounds,constraints, dict(scope_groups),dict(scope_vars),scope_order)
 
 # ══════════════════════════════════════════════════════════════════════════
-# SECTION 4: PROBLEM DEFINITION (WITH ALGEBRAIC CACHING)
+# SECTION 4: PROBLEM DEFINITION (WITH NUMPY COMPILATION)
 # ══════════════════════════════════════════════════════════════════════════
 
-PROJECTION_CACHE: Dict[str, Dict[str, List[Dict]]] = {}
-
 @dataclass
 class Constraint:
     kind:str; expr:str; direction:str; weight:float=1.0; scope:str="root"
@@ -343,11 +330,11 @@ class MathConstraint:
     kind:str; expr_str:str; direction:str; weight:float=1.0
     fast_iv:Optional[Callable]=field(default=None,repr=False)
     fast_pt:Optional[Callable]=field(default=None,repr=False)
+    fast_np:Optional[Callable]=field(default=None,repr=False) # V4.0 Vectorized Evaluator
     syms_used:List[str]=field(default_factory=list)
     parsed:Optional[sp.Expr]=field(default=None,repr=False)
     degree:int=1; scope:str="root"
     branches:List['MathConstraint']=field(default_factory=list)
-    projections:Dict[str,List[Dict]]=field(default_factory=dict) 
 
 def compile_mc(kind,expr_str,direction,variables,weight=1.0,scope="root",branches=None):
     mc=MathConstraint(kind=kind,expr_str=expr_str,direction=direction,weight=weight,scope=scope)
@@ -373,25 +360,14 @@ def compile_mc(kind,expr_str,direction,variables,weight=1.0,scope="root",branche
         parsed=parse_expr(expr_str,local_dict=syms); mc.parsed=parsed
         mc.syms_used=[v for v in variables if sp.Symbol(v) in parsed.free_symbols]
         mc.fast_iv=compile_iv(parsed,variables)
-        mc.fast_pt=sp.lambdify([sp.Symbol(v) for v in mc.syms_used], parsed,modules="math")
-        mc.degree=int(sp.total_degree(parsed)) if parsed.is_polynomial() else 1
         
-        if kind == "equality":
-            if expr_str not in PROJECTION_CACHE:
-                proj_map = {}
-                for sym in parsed.free_symbols:
-                    v_str = str(sym)
-                    try:
-                        sols = sp.solve(parsed, sym)
-                        if v_str not in proj_map: proj_map[v_str] =[]
-                        for sol in sols:
-                            free_syms = list(sol.free_symbols)
-                            func = sp.lambdify(free_syms, sol, modules="math")
-                            proj_map[v_str].append({"syms": [str(s) for s in free_syms], "func": func})
-                    except: pass
-                PROJECTION_CACHE[expr_str] = proj_map
-            mc.projections = PROJECTION_CACHE.get(expr_str, {})
-            
+        # Compile standard Math backend for scalars
+        mc.fast_pt=sp.lambdify([sp.Symbol(v) for v in mc.syms_used], parsed, modules="math")
+        
+        # Compile Numpy backend for tensors (V4.0 SIMD Evaluation)
+        mc.fast_np=sp.lambdify([sp.Symbol(v) for v in mc.syms_used], parsed, modules="numpy")
+        
+        mc.degree=int(sp.total_degree(parsed)) if parsed.is_polynomial() else 1
     except: pass
     return mc
 
@@ -435,6 +411,48 @@ class Problem:
             bv=b.get(v,0.0)
             total+=max(0.0,lo-bv)+max(0.0,bv-hi)
         return total
+        
+    def constraint_energy_tensor(self, b_matrix: np.ndarray, var_order: List[str]) -> np.ndarray:
+        """
+        V4.0: Evaluates thousands of permutations simultaneously using Numpy ufuncs.
+        b_matrix shape: (N_permutations, N_variables)
+        Returns shape: (N_permutations,)
+        """
+        N = b_matrix.shape[0]
+        total = np.zeros(N, dtype=np.float32)
+        var_to_idx = {v: i for i, v in enumerate(var_order)}
+        
+        for mc in self.compiled_constraints:
+            if mc.kind == "or_eq":
+                branch_vals =[]
+                for bmc in mc.branches:
+                    if bmc.fast_np:
+                        try:
+                            args = [b_matrix[:, var_to_idx[v]] for v in bmc.syms_used]
+                            val = np.abs(bmc.fast_np(*args))
+                            branch_vals.append(val)
+                        except: pass
+                if branch_vals:
+                    min_vals = np.minimum.reduce(branch_vals)
+                    total += min_vals * mc.weight
+                else: total += 1.0
+            else:
+                if mc.fast_np is None:
+                    total += 1.0; continue
+                try:
+                    args = [b_matrix[:, var_to_idx[v]] for v in mc.syms_used]
+                    val = bmc.fast_np(*args) if hasattr(bmc, 'fast_np') else mc.fast_np(*args)
+                    if mc.kind == "equality": total += np.abs(val) * mc.weight
+                    elif mc.direction == "geq": total += np.maximum(0.0, -val) * mc.weight
+                    else: total += np.maximum(0.0, val) * mc.weight
+                except: total += 1.0
+                
+        for i, v in enumerate(var_order):
+            lo, hi = self.bounds[v]
+            col = b_matrix[:, i]
+            total += np.maximum(0.0, lo - col) + np.maximum(0.0, col - hi)
+            
+        return total
 
     def make_sub_problem(self,scope_name,transferred_bounds=None):
         cidxs=self.scope_groups.get(scope_name,[])
@@ -615,138 +633,6 @@ def _global_hc4_tighten(problem:Problem) -> Dict[str,Tuple[float,float]]:
     if orig_vol > 0 and new_vol < orig_vol * HC4_VOLUME_FLOOR: return dict(problem.bounds)
     return {v:(max(problem.bounds[v][0], contracted[v].lo), min(problem.bounds[v][1], contracted[v].hi)) for v in problem.bounds if v in contracted}
 
-def _single_snap_pass(problem: Problem, current_binding: Dict[str, float], ordered_vars: List[str], current_ce: float, max_spike_ce: float) -> Tuple[Dict[str, float], float, bool]:
-    # FIX 1: Max Spike CE is now strictly anchored to the absolute best CE of the pass, preventing divergent walks.
-    l9 = RESIDUAL_ORACLE.evaluate(current_binding, problem,[])
-    if not l9.dominant_exprs: 
-        return current_binding, current_ce, False
-
-    for worst_expr in l9.dominant_exprs[:3]:
-        target_mc = next((mc for mc in problem.compiled_constraints if mc.expr_str == worst_expr), None)
-        if not target_mc:
-            for mc in problem.compiled_constraints:
-                if mc.kind == "or_eq":
-                    for bmc in mc.branches:
-                        if bmc.expr_str == worst_expr: target_mc = bmc; break
-                if target_mc: break
-                
-        if not (target_mc and hasattr(target_mc, 'projections') and target_mc.projections):
-            continue
-            
-        for v in ordered_vars:
-            if v not in target_mc.projections: continue
-            for proj in target_mc.projections[v]:
-                test_binding = dict(current_binding)
-                val = None
-                try:
-                    args = [test_binding.get(s, 0.0) for s in proj["syms"]]
-                    val = float(proj["func"](*args))
-                except (ValueError, TypeError):
-                    for s in proj["syms"]:
-                        lo, hi = problem.bounds.get(s, (-1e18, 1e18))
-                        mid = (lo + hi) / 2.0 if lo != -1e18 else 0.0
-                        test_binding[s] = test_binding.get(s, mid) * 0.9 + mid * 0.1
-                    try:
-                        args = [test_binding.get(s, 0.0) for s in proj["syms"]]
-                        val = float(proj["func"](*args))
-                    except: continue
-
-                if val is None or not math.isfinite(val) or abs(val) > 1e6:
-                    continue
-                    
-                lo, hi = problem.bounds.get(v, (-1e18, 1e18))
-                if not (lo <= val <= hi): continue
-                    
-                test_binding[v] = val
-                new_ce = problem.constraint_energy(test_binding)
-                
-                # Check against the absolute bound, not the rolling CE
-                if new_ce < max_spike_ce:
-                    return test_binding, new_ce, True
-                    
-    return current_binding, current_ce, False
-
-def _algebraic_snap(problem: Problem, binding: Dict[str, float]) -> Tuple[Dict[str, float], float]:
-    best_ce_overall = problem.constraint_energy(binding)
-    best_binding_overall = dict(binding)
-    
-    active_scopes = [s for s in problem.scope_order if s != "root" and problem.scope_vars.get(s)]
-    l7 = TOPOLOGY_ORACLE.evaluate(problem, active_scopes)
-    
-    # 1. Causal order pass
-    ordered_vars =[]
-    if l7.solve_order:
-        for sn in l7.solve_order:
-            for v in problem.scope_vars.get(sn,[]):
-                if v not in ordered_vars: ordered_vars.append(v)
-    for v in problem.variables:
-        if v not in ordered_vars: ordered_vars.append(v)
-
-    causal_b = dict(binding)
-    causal_ce = best_ce_overall
-    causal_best = best_ce_overall
-    for _ in range(20):
-        # FIX 1: Anchor the tolerance mathematically to the best known state
-        max_allowable_spike = causal_best * 1.15
-        causal_b, causal_ce, improved = _single_snap_pass(problem, causal_b, ordered_vars, causal_ce, max_allowable_spike)
-        if improved and causal_ce < causal_best:
-            causal_best = causal_ce
-            if causal_ce < best_ce_overall:
-                best_ce_overall = causal_ce
-                best_binding_overall = dict(causal_b)
-        if not improved or causal_ce < SOLVE_THRESHOLD: break
-
-    # 2. FIX 2: True Greedy Pass. Prioritize variables causing the most error dynamically.
-    greedy_b = dict(binding)
-    greedy_ce = problem.constraint_energy(binding)
-    greedy_best = greedy_ce
-    for _ in range(20):
-        l9 = RESIDUAL_ORACLE.evaluate(greedy_b, problem,[])
-        dynamic_greedy_vars = l9.dominant_vars if l9.dominant_vars else problem.variables
-        # Ensure all variables are included as fallbacks
-        for v in problem.variables:
-            if v not in dynamic_greedy_vars: dynamic_greedy_vars.append(v)
-            
-        max_allowable_spike = greedy_best * 1.15
-        greedy_b, greedy_ce, improved = _single_snap_pass(problem, greedy_b, dynamic_greedy_vars, greedy_ce, max_allowable_spike)
-        if improved and greedy_ce < greedy_best:
-            greedy_best = greedy_ce
-            if greedy_ce < best_ce_overall:
-                best_ce_overall = greedy_ce
-                best_binding_overall = dict(greedy_b)
-        if not improved or greedy_ce < SOLVE_THRESHOLD: break
-        
-    return best_binding_overall, best_ce_overall
-
-def _normalisation_sweep(problem:Problem, binding:Dict[str,float], budget:int) -> Dict:
-    snap_binding, snap_ce = _algebraic_snap(problem, binding)
-    if snap_ce < SOLVE_THRESHOLD:
-        return {"binding": snap_binding, "ce": snap_ce, "steps": 1, "hypothesis": "AlgebraicSnap"}
-    
-    span_box={}
-    for v in problem.variables:
-        lo,hi=problem.bounds[v]; cv=snap_binding.get(v,(lo+hi)/2)
-        half=max(0.005,(hi-lo)*0.05)
-        span_box[v]=IV(max(lo,cv-half),min(hi,cv+half))
-    r=_solve_region(problem,span_box,budget)
-    if r["ce"]>=snap_ce:
-        wide_box={}
-        for v in problem.variables:
-            lo,hi=problem.bounds[v]; cv=snap_binding.get(v,(lo+hi)/2)
-            half=(hi-lo)*0.15
-            wide_box[v]=IV(max(lo,cv-half),min(hi,cv+half))
-        r2=_solve_region(problem,wide_box,budget)
-        if r2["ce"]<r["ce"]: r=r2
-    
-    if snap_ce < r["ce"]:
-        r["binding"] = snap_binding; r["ce"] = snap_ce
-    r["hypothesis"]="NormSweep"; return r
-
-def _is_norm_problem(problem:Problem) -> bool:
-    for c in problem.constraints:
-        if c.kind == "or_eq": return False
-    return True
-
 def solve_ae(problem:Problem, budget:int=TOTAL_BUDGET, injected_seed:Dict[str,float]=None) -> Dict:
     t0=time.time()
     active_scopes=[s for s in problem.scope_order if s!="root" and len(problem.scope_vars.get(s,[]))>0]
@@ -763,9 +649,6 @@ def solve_ae(problem:Problem, budget:int=TOTAL_BUDGET, injected_seed:Dict[str,fl
         start_box={v:IV(lo,hi) for v,(lo,hi) in problem.bounds.items()}
         res=_solve_region(problem,start_box,budget)
         l9=RESIDUAL_ORACLE.evaluate(res["binding"],problem,[])
-        if res["ce"]<10.0 and res["ce"]>SOLVE_THRESHOLD and _is_norm_problem(problem):
-            nr=_normalisation_sweep(problem,res["binding"],max(MIN_SWEEP_BUDGET, budget//2))
-            if nr["ce"]<res["ce"]: res=nr
         return {"binding":res["binding"],"ce":res["ce"],
                 "solved":res["ce"]<SOLVE_THRESHOLD,"steps":res["steps"],
                 "l7":None,"l9":l9,"time":round(time.time()-t0,3)}
@@ -826,17 +709,12 @@ def solve_ae(problem:Problem, budget:int=TOTAL_BUDGET, injected_seed:Dict[str,fl
         total_steps+=r["steps"]
         if r["ce"]<ce: composed_binding=r["binding"]; ce=r["ce"]
 
-    if ce<10.0 and ce>SOLVE_THRESHOLD and _is_norm_problem(problem):
-        nr=_normalisation_sweep(problem,composed_binding,max(MIN_SWEEP_BUDGET, budget//4))
-        total_steps+=nr["steps"]
-        if nr["ce"]<ce: composed_binding=nr["binding"]; ce=nr["ce"]
-
     return {"binding":composed_binding,"ce":ce,
             "solved":ce<SOLVE_THRESHOLD,"steps":total_steps,
             "l7":l7_cert,"l9":l9_cert,"time":round(time.time()-t0,3)}
 
 # ══════════════════════════════════════════════════════════════════════════
-# SECTION 7: AE2 HYPOTHESIS GENERATORS
+# SECTION 7: HYPOTHESIS GENERATORS (THE VECTORIZED DIAL)
 # ══════════════════════════════════════════════════════════════════════════
 
 def _hypothesis_seed(problem:Problem, budget:int, current_binding:Dict[str,float], round_idx:int=0) -> Dict:
@@ -910,44 +788,91 @@ def _hypothesis_struct(problem:Problem, budget:int, current_binding:Dict[str,flo
             best_result["hypothesis"]=f"Struct:freeze({target_hub}@{hv:.2f})"
     return best_result
 
-def _hypothesis_perturb(problem:Problem, budget:int, current_binding:Dict[str,float], stale_rounds:int=0) -> Dict:
-    scale=PERTURB_BASE_SCALE*(1+stale_rounds)
-    per_budget=max(10,budget//N_PERTURB_RESTARTS)
-    best_result=None
-    for _ in range(N_PERTURB_RESTARTS):
-        perturbed={}
-        for v,val in current_binding.items():
-            lo,hi=problem.bounds[v]
-            noise=random.gauss(0,scale*(hi-lo))
-            perturbed[v]=max(lo,min(hi,val+noise))
-        r=solve_ae(problem,per_budget,injected_seed=perturbed)
-        if best_result is None or r["ce"]<best_result["ce"]: best_result=r
-    best_result["hypothesis"]=f"Perturb:σ={scale:.3f}×{N_PERTURB_RESTARTS}"
-    return best_result
-
-def _local_refine(problem:Problem, budget:int, binding:Dict[str,float]) -> Dict:
-    snap_binding, snap_ce = _algebraic_snap(problem, binding)
-    if snap_ce < SOLVE_THRESHOLD:
-        return {"binding": snap_binding, "ce": snap_ce, "steps": 1, "hypothesis": "AlgebraicSnap"}
+def _hypothesis_vector_perturb(problem:Problem, current_binding:Dict[str,float], stale_rounds:int=0) -> Dict:
+    """
+    NEW 1: The Vectorized Permutation Bomb.
+    Generates N_TENSOR_PERMUTES hypotheses in a continuous Numpy tensor,
+    evaluates them simultaneously, and returns the absolute best.
+    """
+    scale = PERTURB_BASE_SCALE * (1 + stale_rounds)
+    N = N_TENSOR_PERMUTES
+    V = len(problem.variables)
+    
+    # Generate [N, V] tensor of base coordinates
+    base_matrix = np.zeros((N, V), dtype=np.float32)
+    for i, v in enumerate(problem.variables):
+        base_matrix[:, i] = current_binding.get(v, 0.0)
         
-    tight_box={}
-    for v in problem.variables:
-        lo,hi=problem.bounds[v]; cv=snap_binding.get(v,(lo+hi)/2)
-        half=(hi-lo)*0.02
-        tight_box[v]=IV(max(lo,cv-half),min(hi,cv+half))
-    r=_solve_region(problem,tight_box,max(MIN_SWEEP_BUDGET, budget))
+    # Generate [N, V] tensor of perturbations
+    noise_matrix = np.zeros((N, V), dtype=np.float32)
+    for i, v in enumerate(problem.variables):
+        lo, hi = problem.bounds[v]
+        noise_matrix[:, i] = np.random.normal(0, scale * (hi - lo), N)
+        
+    # Apply noise and clip to bounds
+    test_matrix = base_matrix + noise_matrix
+    for i, v in enumerate(problem.variables):
+        lo, hi = problem.bounds[v]
+        test_matrix[:, i] = np.clip(test_matrix[:, i], lo, hi)
+        
+    # Vectorized CE Evaluation
+    ce_vector = problem.constraint_energy_tensor(test_matrix, problem.variables)
+    
+    best_idx = np.argmin(ce_vector)
+    best_ce = float(ce_vector[best_idx])
     
-    if r["ce"]>=snap_ce:
-        wide_box={v:IV(max(problem.bounds[v][0], snap_binding.get(v,0)-(problem.bounds[v][1]-problem.bounds[v][0])*0.10),
-                       min(problem.bounds[v][1], snap_binding.get(v,0)+(problem.bounds[v][1]-problem.bounds[v][0])*0.10))
-                  for v in problem.variables}
-        r2=_solve_region(problem,wide_box,max(MIN_SWEEP_BUDGET, budget))
-        if r2["ce"]<r["ce"]: r=r2
+    best_binding = {v: float(test_matrix[best_idx, i]) for i, v in enumerate(problem.variables)}
+    
+    # Run the single best point through the standard region solver to stabilize it
+    return solve_ae(problem, budget=max(10, TOTAL_BUDGET//4), injected_seed=best_binding)
+
+
+def _hypothesis_gradient_refine(problem: Problem, budget: int, binding: Dict[str, float]) -> Dict:
+    """
+    NEW 2: The Gradient Dial.
+    Competes in the Debate Engine. If it falls into a local minimum "greedy" trap, 
+    it will be mathematically defeated by the Vectorized Permutation Engine and 
+    lose its budget allocation.
+    """
+    b = dict(binding)
+    best_ce = problem.constraint_energy(b)
+    
+    steps_taken = 0
+    for _ in range(50):
+        if best_ce < SOLVE_THRESHOLD: break
+        steps_taken += 1
         
-    if snap_ce < r["ce"]:
-        r["binding"] = snap_binding; r["ce"] = snap_ce
+        grad = {}
+        for v in problem.variables:
+            lo, hi = problem.bounds[v]
+            eps = max(1e-7, (hi - lo) * 1e-5)
+            
+            b_plus = dict(b); b_plus[v] += eps
+            b_minus = dict(b); b_minus[v] -= eps
+            
+            cp = problem.constraint_energy(b_plus)
+            cm = problem.constraint_energy(b_minus)
+            
+            grad[v] = (cp - cm) / (2 * eps)
+            
+        grad_mag_sq = sum(g**2 for g in grad.values())
+        if grad_mag_sq < 1e-12: break
         
-    r["hypothesis"]="LocalRefine"; return r
+        lr = min(0.1, best_ce / grad_mag_sq)
+        
+        next_b = {}
+        for v in problem.variables:
+            lo, hi = problem.bounds[v]
+            next_b[v] = max(lo, min(hi, b[v] - lr * grad[v]))
+            
+        next_ce = problem.constraint_energy(next_b)
+        
+        if next_ce >= best_ce: break 
+        best_ce = next_ce
+        b = dict(next_b)
+
+    return {"binding": b, "ce": best_ce, "steps": steps_taken, "hypothesis": "GradientRefine"}
+
 
 def _merge_bindings(problem:Problem, b1:Dict[str,float], ce1:float, b2:Dict[str,float], ce2:float, budget:int) -> Dict:
     w1=1.0/(ce1**MERGE_WEIGHT_EXP+1e-12); w2=1.0/(ce2**MERGE_WEIGHT_EXP+1e-12); wt=w1+w2
@@ -955,22 +880,14 @@ def _merge_bindings(problem:Problem, b1:Dict[str,float], ce1:float, b2:Dict[str,
     for v,(lo,hi) in problem.bounds.items(): merged[v]=max(lo,min(hi,merged[v]))
     
     r=solve_ae(problem,budget,injected_seed=merged)
-    
-    if r["ce"] < 10.0 and _is_norm_problem(problem):
-        nr = _normalisation_sweep(problem, r["binding"], max(MIN_SWEEP_BUDGET, budget))
-        if nr["ce"] < r["ce"]:
-            r["binding"] = nr["binding"]
-            r["ce"] = nr["ce"]
-            r["steps"] += nr["steps"]
-            
     r["hypothesis"]=f"Merge:w={w1/wt:.2f}/{w2/wt:.2f}"
     return r
 
 # ══════════════════════════════════════════════════════════════════════════
-# SECTION 8: CONSENSUS ENGINE
+# SECTION 8: CONSENSUS ENGINE (THE 4-WAY DIAL)
 # ══════════════════════════════════════════════════════════════════════════
 
-def solve_consensus(problem:Problem, budget:int=TOTAL_BUDGET, budget_split:Tuple[float,float,float]=(0.34,0.33,0.33)) -> Dict:
+def solve_consensus(problem:Problem, budget:int=TOTAL_BUDGET, budget_split:Tuple[float,float,float,float]=(0.25,0.25,0.25,0.25)) -> Dict:
     t0=time.time()
     round_budget=max(30,budget//(CONSENSUS_MAX_ITER+1))
 
@@ -987,14 +904,15 @@ def solve_consensus(problem:Problem, budget:int=TOTAL_BUDGET, budget_split:Tuple
         state["consensus_rounds"]=0; state["consensus_history"]=[]
         return state
 
-    seed_f, struct_f, perturb_f = budget_split
+    seed_f, struct_f, vec_f, grad_f = budget_split
 
     for round_idx in range(CONSENSUS_MAX_ITER):
-        if current_ce<NEAR_SOLVED_CE:
-            r=_local_refine(problem,round_budget,current_binding)
-            total_steps+=r["steps"]
-            history.append({"round":round_idx+1,"mode":"refine","seed_ce":None,"struct_ce":None,"perturb_ce":None,
-                "winner":"refine","ce":round(r["ce"],5),"seed_h":"","struct_h":"","perturb_h":r.get("hypothesis","")})
+        # NEW: The Dial allows the Gradient step to fire earlier
+        if current_ce < NEAR_SOLVED_CE:
+            r = _hypothesis_gradient_refine(problem, round_budget, current_binding)
+            total_steps += r["steps"]
+            history.append({"round":round_idx+1,"mode":"refine","seed_ce":None,"struct_ce":None,"vec_ce":None,"grad_ce":None,
+                "winner":"refine","ce":round(r["ce"],5),"seed_h":"","struct_h":"","vec_h":"","grad_h":r.get("hypothesis","")})
             if r["ce"]<global_best_ce:
                 global_best_ce=r["ce"]; global_best_binding=dict(r["binding"])
             current_ce=r["ce"]; current_binding=r["binding"]
@@ -1006,25 +924,28 @@ def solve_consensus(problem:Problem, budget:int=TOTAL_BUDGET, budget_split:Tuple
 
         seed_b    = max(10, int(round_budget * seed_f))
         struct_b  = max(10, int(round_budget * struct_f))
-        perturb_b = max(10, round_budget - seed_b - struct_b)
+        grad_b    = max(10, int(round_budget * grad_f))
 
         if force_perturb:
-            p_res=_hypothesis_perturb(problem,round_budget,current_binding,stale_rounds+2)
-            total_steps+=p_res["steps"]
-            candidates=[("current",current_ce,current_binding), ("perturb",p_res["ce"],p_res["binding"])]
-            mode="force_perturb"; s_res=t_res={"ce":None,"hypothesis":"–","steps":0,"binding":{}}
+            p_res = _hypothesis_vector_perturb(problem, current_binding, stale_rounds+2)
+            total_steps += p_res["steps"]
+            candidates = [("current",current_ce,current_binding), ("vector",p_res["ce"],p_res["binding"])]
+            mode="force_perturb"; s_res=t_res=g_res={"ce":None,"hypothesis":"–","steps":0,"binding":{}}
             merge_res=None
         else:
-            s_res =_hypothesis_seed(problem, seed_b, current_binding, round_idx)
-            t_res =_hypothesis_struct(problem, struct_b, s_res["binding"], round_idx)
-            p_res =_hypothesis_perturb(problem, perturb_b, current_binding, stale_rounds)
-            total_steps+=s_res["steps"]+t_res["steps"]+p_res["steps"]
+            s_res = _hypothesis_seed(problem, seed_b, current_binding, round_idx)
+            t_res = _hypothesis_struct(problem, struct_b, s_res["binding"], round_idx)
+            g_res = _hypothesis_gradient_refine(problem, grad_b, current_binding)
+            p_res = _hypothesis_vector_perturb(problem, current_binding, stale_rounds)
+            
+            total_steps += s_res["steps"] + t_res["steps"] + p_res["steps"] + g_res["steps"]
             
             candidates=[
                 ("current", current_ce,   current_binding),
                 ("seed",    s_res["ce"],  s_res["binding"]),
                 ("struct",  t_res["ce"],  t_res["binding"]),
-                ("perturb", p_res["ce"],  p_res["binding"]),
+                ("vector",  p_res["ce"],  p_res["binding"]),
+                ("gradient",g_res["ce"],  g_res["binding"]),
             ]
             mode="debate"
             
@@ -1046,10 +967,11 @@ def solve_consensus(problem:Problem, budget:int=TOTAL_BUDGET, budget_split:Tuple
         history.append({"round": round_idx+1, "mode": mode,
             "seed_ce":   round(s_res["ce"],5) if s_res["ce"] is not None else None,
             "struct_ce": round(t_res["ce"],5) if t_res["ce"] is not None else None,
-            "perturb_ce":round(p_res["ce"],5) if p_res["ce"] is not None else None,
+            "vec_ce":    round(p_res["ce"],5) if p_res["ce"] is not None else None,
+            "grad_ce":   round(g_res["ce"],5) if g_res["ce"] is not None else None,
             "merge_ce":  round(merge_res["ce"],5) if merge_res else None,
             "winner":    winner_name, "ce": round(winner_ce,5),
-            "seed_h":    s_res.get("hypothesis",""), "struct_h":  t_res.get("hypothesis",""), "perturb_h": p_res.get("hypothesis",""),
+            "seed_h":    s_res.get("hypothesis",""), "struct_h":  t_res.get("hypothesis",""), "vec_h": "Vector[1000]", "grad_h": g_res.get("hypothesis","")
         })
 
         current_ce=winner_ce; current_binding=winner_bind
@@ -1232,13 +1154,13 @@ EMPIRICAL_DATA:Dict={
     "by_pid": defaultdict(_empty_prob_stats)
 }
 
-DEBATE_WINS={"seed":1,"struct":1,"perturb":1,"refine":1,"merge":1}
+DEBATE_WINS={"seed":1,"struct":1,"vector":1,"gradient":1,"merge":1}
 INJECTED_SEEDS:Dict[str,Dict[str,float]]={}
 
-def _adaptive_budget_split() -> Tuple[float,float,float]:
-    s=DEBATE_WINS["seed"]; t=DEBATE_WINS["struct"]; p=DEBATE_WINS["perturb"]
-    total=s+t+p
-    raw=(s/total, t/total, p/total)
+def _adaptive_budget_split() -> Tuple[float,float,float,float]:
+    s=DEBATE_WINS["seed"]; t=DEBATE_WINS["struct"]; v=DEBATE_WINS["vector"]; g=DEBATE_WINS["gradient"]
+    total=s+t+v+g
+    raw=(s/total, t/total, v/total, g/total)
     floored=[max(MIN_HYP_FRAC,r) for r in raw]
     fsum=sum(floored)
     return tuple(f/fsum for f in floored)
@@ -1300,7 +1222,7 @@ async def lifespan(app: FastAPI):
     yield
     POOL.shutdown(wait=False)
 
-app = FastAPI(title="Practicality System 3.12", lifespan=lifespan)
+app = FastAPI(title="Practicality System 4.0", lifespan=lifespan)
 
 @app.post("/inject/{pid}")
 async def inject_seed(pid:str, request:Request):
@@ -1332,8 +1254,8 @@ async def dashboard():
     con=d["Consensus"]
     avg_rounds=round(con["rounds"]/runs,2)
     history=con["history"]; debate_rows=""
-    col_map={"seed":"#4CAF50","struct":"#FF9800","perturb":"#E040FB",
-             "refine":"#26C6DA","merge":"#FFD700","current":"#555","force_perturb":"#FF5252"}
+    col_map={"seed":"#4CAF50","struct":"#FF9800","vector":"#E040FB",
+             "gradient":"#26C6DA","refine":"#26C6DA","merge":"#FFD700","current":"#555","force_perturb":"#FF5252"}
              
     for h in reversed(history):
         wc=col_map.get(h["winner"],"#888")
@@ -1346,12 +1268,14 @@ async def dashboard():
             f"<td style='color:{mc};font-size:0.8em'>{h['mode']}</td>"
             +ce_cell(h['seed_ce'],   '#4CAF50')
             +ce_cell(h['struct_ce'], '#FF9800')
-            +ce_cell(h['perturb_ce'], '#E040FB')
+            +ce_cell(h.get('vec_ce'),'#E040FB')
+            +ce_cell(h.get('grad_ce'),'#26C6DA')
             +ce_cell(h.get('merge_ce'),'#FFD700')
             +f"<td style='color:{wc};font-weight:bold'>{h['winner']}</td>"
-            f"<td style='color:#888;font-size:0.75em'>{h.get('seed_h','')[:18]}</td>"
-            f"<td style='color:#888;font-size:0.75em'>{h.get('struct_h','')[:18]}</td>"
-            f"<td style='color:#888;font-size:0.75em'>{h.get('perturb_h','')[:18]}</td>"
+            f"<td style='color:#888;font-size:0.75em'>{h.get('seed_h','')[:15]}</td>"
+            f"<td style='color:#888;font-size:0.75em'>{h.get('struct_h','')[:15]}</td>"
+            f"<td style='color:#888;font-size:0.75em'>{h.get('vec_h','')[:15]}</td>"
+            f"<td style='color:#888;font-size:0.75em'>{h.get('grad_h','')[:15]}</td>"
             f"</tr>")
             
     prob_rows = ""
@@ -1375,7 +1299,7 @@ async def dashboard():
                 f"font-size:0.85em;margin:2px'>{label}: {val}</span>")
                 
     html=f"""<!DOCTYPE html><html>
-<head><title>Practicality System 3.12</title>
+<head><title>Practicality System 4.0</title>
 <meta http-equiv="refresh" content="3">
 <style>
   body{{background:#0a0a0a;color:#e0e0e0;font-family:monospace;padding:20px}}
@@ -1386,7 +1310,7 @@ async def dashboard():
   th{{color:#444}}
   .witness-box{{background:#111; border:1px solid #333; padding:15px; color:#aaa; white-space:pre-wrap; font-size:0.9em;}}
 </style></head><body>
-<h1>⚗ Practicality System 3.12</h1>
+<h1>⚗ Practicality System 4.0</h1>
 <div style='margin-bottom:16px;line-height:2.2em;'>
   {badge("Trials",runs,"#aaa")}
   {badge("Avg rounds",avg_rounds,"#aaa")}
@@ -1395,13 +1319,14 @@ async def dashboard():
   <br>
   {badge("Seed wins",   wins['seed'],   '#4CAF50')}
   {badge("Struct wins", wins['struct'], '#FF9800')}
-  {badge("Perturb wins",wins['perturb'],'#E040FB')}
-  {badge("Refine wins", wins['refine'], '#26C6DA')}
+  {badge("Vector wins", wins['vector'], '#E040FB')}
+  {badge("Gradient wins", wins['gradient'], '#26C6DA')}
   {badge("Merge wins",  wins['merge'],  '#FFD700')}
   <br>
   {badge("Seed bdgt",   f"{split[0]:.0%}",'#4CAF50')}
   {badge("Struct bdgt", f"{split[1]:.0%}",'#FF9800')}
-  {badge("Perturb bdgt",f"{split[2]:.0%}",'#E040FB')}
+  {badge("Vector bdgt", f"{split[2]:.0%}",'#E040FB')}
+  {badge("Grad bdgt",   f"{split[3]:.0%}",'#26C6DA')}
 </div>
 <table>
   <tr><th>Strategy</th><th>Solve Rate</th><th>Avg CE</th><th>Avg Time</th></tr>
@@ -1418,11 +1343,12 @@ async def dashboard():
   <tr><th>Prob/Round</th><th>Mode</th>
   <th style='color:#4CAF50'>Seed</th>
   <th style='color:#FF9800'>Struct</th>
-  <th style='color:#E040FB'>Perturb</th>
+  <th style='color:#E040FB'>Vector</th>
+  <th style='color:#26C6DA'>Gradient</th>
   <th style='color:#FFD700'>Merge</th>
   <th>Winner</th>
-  <th>Seed hyp</th><th>Struct hyp</th><th>Perturb hyp</th></tr>
-  {debate_rows or "<tr><td colspan='10' style='color:#333'>Warming up…</td></tr>"}
+  <th>Seed hyp</th><th>Struct hyp</th><th>Vector hyp</th><th>Gradient hyp</th></tr>
+  {debate_rows or "<tr><td colspan='12' style='color:#333'>Warming up…</td></tr>"}
 </table>
 
 <h3>Latest LLM Bridge Export (Universal Witness)</h3>