Update app.py

app.py

@@ -1,22 +1,24 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 24.1 — STRUCTURAL SKETCH, QUANTUM ENGINE & HOMOTOPY CONTINUATION
+PRACTICALITY SYSTEM 24.2 — POSITIVE SPACE SKETCHING & TRANSCENDENTAL GRIDS
 ══════════════════════════════════════════════════════════════════════════════════
 ARCHITECTURE:
   User Text → [GEMINI ENCODER] → AXLProblemDef
             → [STRUCTURAL SKETCH] → Axiom affinity map + SymPy Derivation
-            → [TEMPLATE ENGINE]   → Analytically-derived partial hypotheses
-            → [WISDOM LAYER]      → Sketch-weighted rays + Masked Deduction (with Homotopy)
+            → [TEMPLATE ENGINE]   → Positive Space Grid Sketching + Algebraic Roots
+            → [WISDOM LAYER]      → Masked Deduction (with Homotopy)
             → [GEMINI COLLAPSER]  → Domain-language explanation
 
-CRITICAL STABILITY FIXES:
-  1. The Tensor Shield: Built impenetrable wrapper around SymPy lambda calls to
-     prevent unresolvable SymPy symbolic leakages from crashing PyTorch gradients.
-  2. Thread Crash Safety: Entire solver loop wrapped in try/finally to prevent UI lockups.
-  3. UI Responsive Layout: Clean flexbox rendering for mobile devices.
+CRITICAL UPDATE 24.2:
+  - Positive Space Sketching: Dynamically detects variables trapped in highly 
+    non-linear transcendental functions (sin, cos) and sweeps their parameter 
+    space in the Template Engine. By pinning the non-linear axes, the remaining 
+    system collapses into a linear manifold, allowing PyTorch to solve complex 
+    variational circuits (QAOA/VQE) without gradient gridlock.
+  - Increased DEDUCE_ADAM_STEPS to 40 for deeper local convergence.
 """
 
-import os, time, random, math, threading, warnings, json, textwrap
+import os, time, random, math, threading, warnings, json, textwrap, itertools
 from functools import reduce
 from typing import Optional, Callable, List, Dict, Tuple, Any, Set
 from dataclasses import dataclass, field
@@ -43,13 +45,13 @@ except ImportError:
 # ══════════════════════════════════════════════════════════════════════
 # AI CONFIGURATION
 # ══════════════════════════════════════════════════════════════════════
-DEFAULT_GEMINI_API_KEY = os.environ.get("AI_Key", "")
-GEMINI_MODEL = "gemini-3-flash-preview" # "gemma-4-26b-a4b-it"  #
+DEFAULT_GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
+GEMINI_MODEL = "gemini-2.5-pro-preview-06-05"
 
 warnings.filterwarnings("ignore")
 USE_GPU = torch.cuda.is_available()
 DEVICE  = torch.device("cuda" if USE_GPU else "cpu")
-print(f"[SYSTEM 24.1] Compute: {DEVICE.type.upper()} | Homotopy + Tensor Shield Active")
+print(f"[SYSTEM 24.2] Compute: {DEVICE.type.upper()} | Positive Space Sketching Active")
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 1: CONSTANTS
@@ -57,13 +59,13 @@ print(f"[SYSTEM 24.1] Compute: {DEVICE.type.upper()} | Homotopy + Tensor Shield
 SOLVE_THRESHOLD          = 0.05
 VERIFY_G1_THRESHOLD      = 0.08
 VERIFY_G2_TOLERANCE      = 1e-3
-DEDUCE_ADAM_STEPS        = 25
+DEDUCE_ADAM_STEPS        = 40      # Increased for deeper gradient convergence
 N_MPRT_EXPLORE           = 1000
 PROJECTION_CACHE: Dict   = {}
 
 MAX_RAYS_PER_ATTEMPT     = 24576 * 10
 RAY_BATCH_SIZE           = 24576
-TEMPLATE_BATCH_SIZE      = 512
+TEMPLATE_BATCH_SIZE      = 1024    # Increased to accommodate Grid Sweeps
 CE_EARN_RATIO            = 0.90
 SCOUT_CE_THRESHOLD       = 0.5
 BRANCH_WIDTH             = 12
@@ -80,28 +82,18 @@ SYMPY_TIMEOUT_SECS       = 4.0
 STATE_LOCK = threading.Lock()
 
 GLOBAL_SOLVE_STATE = {
-    "is_running": False,
-    "phase": "IDLE",
-    "best_ce": float('inf'),
-    "total_fired": 0,
-    "best_ray": "—",
-    "recent_traces": deque(maxlen=25),
-    "high_level_logs": [],
-    "answer": "",
-    "sketch_summary": "",
-    "template_count": 0,
-    "template_best_ce": float('inf'),
-    "sympy_derivation": [],
+    "is_running": False, "phase": "IDLE", "best_ce": float('inf'), "total_fired": 0,
+    "best_ray": "—", "recent_traces": deque(maxlen=25), "high_level_logs": [],
+    "answer": "", "sketch_summary": "", "template_count": 0,
+    "template_best_ce": float('inf'), "sympy_derivation": [],
 }
 
 def _update_state(**kwargs):
     with STATE_LOCK:
-        for k, v in kwargs.items():
-            GLOBAL_SOLVE_STATE[k] = v
+        for k, v in kwargs.items(): GLOBAL_SOLVE_STATE[k] = v
 
 def _add_log(line: str):
-    with STATE_LOCK:
-        GLOBAL_SOLVE_STATE["high_level_logs"].append(line)
+    with STATE_LOCK: GLOBAL_SOLVE_STATE["high_level_logs"].append(line)
 
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 3: INTERVAL ARITHMETIC (HC4)
@@ -368,10 +360,8 @@ def compile_mc(kind,expr_str,direction,variables,weight=1.0,scope="root",branche
             val = t_func_raw(*args)
             if not isinstance(val, torch.Tensor):
                 try:
-                    # Catch Python floats, ints, or fully resolved SymPy numbers
                     val = torch.tensor(float(val), device=DEVICE, dtype=torch.float32)
                 except Exception:
-                    # If an unresolvable SymPy Add/Symbol leaked through, penalize heavily instead of crashing
                     return torch.tensor(9999.0, device=DEVICE, dtype=torch.float32)
             return val
             
@@ -446,7 +436,7 @@ class Problem:
                         except: pass
 
     # ══════════════════════════════════════════════════════════════════════
-    # HOMOTOPY CONTINUATION FIX: tensor_energy now scales transcendentals
+    # HOMOTOPY CONTINUATION FIX: tensor_energy scales transcendentals
     # ══════════════════════════════════════════════════════════════════════
     def tensor_energy(self, X: torch.Tensor, step_ratio: float = 1.0) -> torch.Tensor:
         is_batched = (X.dim() == 2)
@@ -456,8 +446,6 @@ class Problem:
             if getattr(mc, 'weight', 1.0) == 0.0: continue
             
             eff_weight = float(mc.weight)
-            
-            # Soften highly non-linear constraints early in the gradient search
             if step_ratio < 1.0 and any(f in mc.expr_str for f in ["sin", "cos", "exp"]):
                 eff_weight *= (0.1 + 0.9 * step_ratio)
                 
@@ -480,11 +468,10 @@ class Problem:
                 else:                       
                     total += torch.relu(val) * eff_weight
 
-        # Bounds with exploratory margins for Homotopy Continuation
         for i, v in enumerate(self.variables):
             lo, hi = self.bounds[v]
             col = X[:, i] if is_batched else X[i]
-            margin = (hi - lo) * 0.1 * (1.0 - step_ratio)  # Allow 10% out-of-bounds at step 0
+            margin = (hi - lo) * 0.1 * (1.0 - step_ratio)
             total += torch.relu(lo - margin - col) + torch.relu(col - (hi + margin))
             
         return total.squeeze()
@@ -521,7 +508,7 @@ def build_base_problem(axl_def:AXLProblemDef) -> Problem:
                    scope_order=ep.scope_order)
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 6: STRUCTURAL SKETCH — The World Model Prior
+# SECTION 6: STRUCTURAL SKETCH & POSITIVE SPACE SWEEP
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class StructuralSketch:
@@ -558,8 +545,7 @@ def _try_sympy_solve(problem: Problem) -> Tuple[List[Dict[str, float]], bool, Li
     syms = [sp.Symbol(v) for v in problem.variables]
     equations = [mc.parsed for mc in eq_mcs]
 
-    def _solve(): 
-        return sp.solve(equations, syms, dict=True)
+    def _solve(): return sp.solve(equations, syms, dict=True)
 
     try:
         with concurrent.futures.ThreadPoolExecutor(max_workers=1) as ex:
@@ -586,14 +572,6 @@ def _try_sympy_solve(problem: Problem) -> Tuple[List[Dict[str, float]], bool, Li
             else: 
                 derivation.append(f"  {sym} = {simplified}  [eliminates {sym}, depends on {', '.join(str(s) for s in free_s)}]")
         
-        if len(sorted_sol) == 1:
-            sym, val = sorted_sol[0]
-            try:
-                poly = sp.Poly(equations[0], sp.Symbol(str(sym)))
-                b_lo, b_hi = problem.bounds.get(str(sym), ('?', '?'))
-                derivation.append(f"  Univariate polynomial: degree {poly.degree()}, roots selected by bounds")
-            except: pass
-
     valid = []
     b_mid = {v: (problem.bounds[v][0] + problem.bounds[v][1]) / 2 for v in problem.variables}
     for sol in raw:
@@ -662,22 +640,6 @@ def compute_sketch(problem: Problem) -> StructuralSketch:
         affinities["CONTINUOUS"] += 1.5
         notes.append("Sum-of-squares → METRIC/QUADRATIC/CONTINUOUS boosted")
 
-    tight = sum(1 for v in problem.variables if abs(problem.bounds[v][1] - problem.bounds[v][0]) < 10)
-    if tight > n_vars // 2: 
-        affinities["PARSIMONY"] += 2.0
-        notes.append("Tight bounds → PARSIMONY boosted")
-
-    if n_vars >= 6: 
-        affinities["HOLISM"] += 1.5
-        affinities["NETWORK"] += 1.5
-        notes.append(f"High-D ({n_vars} vars) → HOLISM/NETWORK boosted")
-
-    bound_groups = defaultdict(list)
-    for v in problem.variables: bound_groups[problem.bounds[v]].append(v)
-    if any(len(g) >= 2 for g in bound_groups.values()): 
-        affinities["SYMMETRIC"] += 1.5
-        notes.append("Symmetric bounds → SYMMETRIC boosted")
-
     has_transcendental = any(mc.parsed is not None and (mc.parsed.has(sp.sin) or mc.parsed.has(sp.cos) or mc.parsed.has(sp.exp)) for mc in problem.compiled_constraints)
     if has_transcendental: 
         affinities["CONTINUOUS"] += 2.0
@@ -701,9 +663,7 @@ def compute_sketch(problem: Problem) -> StructuralSketch:
     n_obs = sum(1 for v in problem.variables if problem.bounds[v][0] == problem.bounds[v][1])
     n_free_dof = max(0, n_vars - n_obs - n_eq)
 
-    exact_solutions = []
-    solvable = False
-    sympy_derivation = []
+    exact_solutions = []; solvable = False; sympy_derivation = []
     if n_vars <= SYMPY_MAX_VARS and dom_type in ("linear", "quadratic") and not has_transcendental:
         exact_solutions, solvable, sympy_derivation = _try_sympy_solve(problem)
         if solvable: 
@@ -722,12 +682,14 @@ def generate_templates(problem: Problem, sketch: StructuralSketch) -> List[Hypot
     templates = []
     b_mid = {v: (problem.bounds[v][0] + problem.bounds[v][1]) / 2 for v in problem.variables}
 
+    # ── 1. SymPy Exact Solutions
     for i, sol in enumerate(sketch.exact_solutions):
         templates.append(HypothesisTemplate(
             template_id=f"sympy_{i}", pinned_vars=sol, 
             free_vars=[v for v in problem.variables if v not in sol], 
             source="sympy_exact", confidence=0.99, derivation=f"SymPy exact solution #{i+1}"))
 
+    # ── 2. Conservation Projections
     for mc in problem.compiled_constraints:
         if mc.kind != "equality" or mc.weight < 5.0 or not mc.projections: continue
         for v, projs in mc.projections.items():
@@ -742,22 +704,55 @@ def generate_templates(problem: Problem, sketch: StructuralSketch) -> List[Hypot
                             confidence=0.75, derivation=f"Conservation {mc.expr_str} → {v}={val:.4f}"))
                 except: pass
 
+    # ── 3. POSITIVE SPACE SKETCHING (Transcendental Parameter Grid Sweep)
+    # Detects free parameters trapped in non-linear functions (like QAOA angles)
+    # and pins them via a grid sweep, reducing the remaining system to linear.
+    if sketch.has_transcendental:
+        transcendental_vars = set()
+        for mc in problem.compiled_constraints:
+            if mc.parsed and (mc.parsed.has(sp.sin) or mc.parsed.has(sp.cos) or mc.parsed.has(sp.exp)):
+                for func in mc.parsed.atoms(sp.sin, sp.cos, sp.exp):
+                    for sym in func.free_symbols:
+                        v_name = str(sym)
+                        if v_name in problem.bounds:
+                            transcendental_vars.add(v_name)
+        
+        if transcendental_vars and len(transcendental_vars) <= 3:
+            grids = []
+            for v in transcendental_vars:
+                lo, hi = problem.bounds[v]
+                pts = [lo + (hi-lo)*0.15, lo + (hi-lo)*0.5, lo + (hi-lo)*0.85]
+                grids.append((v, pts))
+                
+            keys = [g[0] for g in grids]
+            val_lists = [g[1] for g in grids]
+            
+            for combo in itertools.product(*val_lists):
+                pinned = dict(zip(keys, combo))
+                templates.append(HypothesisTemplate(
+                    template_id=f"grid_{'_'.join(f'{k[:2]}{v:.2f}' for k,v in pinned.items())}",
+                    pinned_vars=pinned,
+                    free_vars=[u for u in problem.variables if u not in pinned],
+                    source="grid_sweep",
+                    confidence=0.85,
+                    derivation=f"Positive Space Sketch: Pinned non-linear parameters {pinned}"
+                ))
+
+    # ── 4. Monotone Product Splits
     tb = _global_hc4_tighten_bounds(problem)
     for v_small, v_large, k in problem.monotone_targets:
         lo_s, hi_s = problem.bounds.get(v_small, (-1e9, 1e9))
         lo_l, hi_l = problem.bounds.get(v_large, (-1e9, 1e9))
-        for ratio in [0.1, 0.25, 0.5, 0.707, 0.9]:
+        for ratio in [0.25, 0.5, 0.707]:
             vs_sq = k * ratio
             if vs_sq <= 0: continue
             vs = math.sqrt(vs_sq); vl = k / vs
             if not (lo_s <= vs <= hi_s and lo_l <= vl <= hi_l and vs <= vl): continue
             
             nb = dict(b_mid)
-            nb[v_small] = vs
-            nb[v_large] = vl
+            nb[v_small] = vs; nb[v_large] = vl
             box = {u: IV(*tb.get(u, problem.bounds.get(u, (-10, 10)))) for u in problem.variables}
-            box[v_small] = IV(vs - 1e-6, vs + 1e-6)
-            box[v_large] = IV(vl - 1e-6, vl + 1e-6)
+            box[v_small] = IV(vs - 1e-6, vs + 1e-6); box[v_large] = IV(vl - 1e-6, vl + 1e-6)
             cont = _hc4(box, problem.compiled_constraints)
             
             pinned = {v_small: vs, v_large: vl}
@@ -769,41 +764,13 @@ def generate_templates(problem: Problem, sketch: StructuralSketch) -> List[Hypot
             templates.append(HypothesisTemplate(
                 template_id=f"mpr_{v_small}_{v_large}_r{int(ratio*100)}", pinned_vars=pinned, 
                 free_vars=[u for u in problem.variables if u not in pinned], source="monotone_prod", 
-                confidence=0.88, derivation=f"Monotone {v_small}={vs:.4f}≤{v_large}={vl:.4f}"))
-
-    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, (-1e9, 1e9))
-            for proj in projs:
-                try:
-                    val = float(proj["func"](*[b_mid.get(s, 0.0) for s in proj["syms"]]))
-                    if math.isfinite(val) and lo <= val <= hi:
-                        templates.append(HypothesisTemplate(
-                            template_id=f"proj_{v}_{hash(mc.expr_str)%9999}", pinned_vars={v: val}, 
-                            free_vars=[u for u in problem.variables if u != v], source="projection", 
-                            confidence=0.72, derivation=f"Root of {mc.expr_str[:30]} → {v}={val:.4f}"))
-                except: pass
-
-    bound_groups = defaultdict(list)
-    for v in problem.variables: bound_groups[problem.bounds[v]].append(v)
-    for bnd, grp in bound_groups.items():
-        if len(grp) < 2: continue
-        avg = sum(b_mid[v] for v in grp) / len(grp)
-        lo, hi = bnd
-        if lo <= avg <= hi:
-            pinned = {v: avg for v in grp}
-            templates.append(HypothesisTemplate(
-                template_id=f"sym_avg_{'_'.join(grp[:3])}", pinned_vars=pinned, 
-                free_vars=[u for u in problem.variables if u not in pinned], source="symmetry", 
-                confidence=0.55, derivation=f"Symmetry orbit: {grp} averaged to {avg:.4f}"))
+                confidence=0.82, derivation=f"Monotone {v_small}={vs:.4f}≤{v_large}={vl:.4f}"))
 
     seen = set(); unique = []
     for t in sorted(templates, key=lambda t: -t.confidence):
         key = str(sorted(t.pinned_vars.items()))
         if key not in seen: 
-            seen.add(key)
-            unique.append(t)
+            seen.add(key); unique.append(t)
             
     return unique[:TEMPLATE_BATCH_SIZE]
 
@@ -881,7 +848,7 @@ def _batched_deduce_and_evaluate(problem: Problem, hyps: List['Hypothesis']) ->
             
             for j, v in enumerate(problem.variables):
                 lo, hi = problem.bounds[v]
-                margin = (hi - lo) * 0.1 * (1.0 - step_ratio) # Exploratory bounds fade to 0
+                margin = (hi - lo) * 0.1 * (1.0 - step_ratio)
                 X.data[:, j] = torch.clamp(X.data[:, j], lo - margin, hi + margin)
 
     optimizer.zero_grad()
@@ -1934,8 +1901,8 @@ def build_live_html():
     </div>
     """
 
-with gr.Blocks(css=CSS, title="Practicality 24.1") as demo:
-    gr.Markdown("## ⚗ Practicality 24.1 — Structural Sketch, World Model Prior & Quantum Engine\n`[Gemini Encoder] → [Structural Sketch / SymPy] → [Morphing Ray Solver] → [Gemini Collapser]`")
+with gr.Blocks(css=CSS, title="Practicality 24.2") as demo:
+    gr.Markdown("## ⚗ Practicality 24.2 — Structural Sketch, World Model Prior & Quantum Engine\n`[Gemini Encoder] → [Positive Space Sketching] → [Morphing Ray Solver] → [Gemini Collapser]`")
     
     with gr.Row(elem_classes=["wrap-row"]):
         with gr.Column(scale=2, min_width=300):
@@ -1955,12 +1922,11 @@ with gr.Blocks(css=CSS, title="Practicality 24.1") as demo:
         with gr.Column(scale=1, min_width=250):
             gr.Textbox(value=(f"Compute: {DEVICE.type.upper()}\n"
                               f"Axioms: {len(ALL_AXIOMS)}\n"
-                              f"New: The Tensor Shield\n"
-                              f"New: Thread Crash Safety & UI Layout Fix\n"
+                              f"New: Positive Space Sketching\n"
+                              f"New: Transcendental Grid Sweeping\n"
                               f"New: Quantum BBGKY Cumulant Expansion\n"
-                              f"New: Homotopy Continuation\n"
-                              f"New: Anchor Fix (Gate 2 Sync)"), 
-                       lines=8, interactive=False, elem_classes=["solver-log"])
+                              f"New: Homotopy Continuation"), 
+                       lines=7, interactive=False, elem_classes=["solver-log"])
 
     with gr.Row(elem_classes=["wrap-row"]):
         with gr.Column(scale=1, min_width=300):
@@ -1982,5 +1948,5 @@ with gr.Blocks(css=CSS, title="Practicality 24.1") as demo:
     demo.load(fetch_ui, inputs=None, outputs=[live_html, answer_box])
 
 if __name__ == "__main__":
-    print(f"[SYSTEM 24.1] Compute: {DEVICE.type.upper()} | Feature Flags: Quantum={HAS_QUANTUM}")
+    print(f"[SYSTEM 24.2] Compute: {DEVICE.type.upper()} | Feature Flags: Quantum={HAS_QUANTUM}")
     demo.launch(server_name="0.0.0.0", server_port=7860, share=False)