Update app.py

app.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-PRACTICALITY SYSTEM 28.0 — MODULAR ISOMORPHISM ENGINE
+PRACTICALITY SYSTEM 28.0 — MODULAR ORACLE ENGINE
 ══════════════════════════════════════════════════════════════════════════
 Architecture:
 - practicality_core.py   : Tensor Math, Interval Arithmetic, Adam Optimizer
@@ -10,7 +10,7 @@ Architecture:
 """
 
 import os, time, threading, json, re, textwrap, copy
-import traceback, html
+import traceback, html, itertools, math
 from collections import deque, defaultdict
 from typing import Dict, List, Tuple, Any, Optional, Set
 from dataclasses import dataclass, field
@@ -27,7 +27,7 @@ import practicality_axioms as axioms
 import practicality_oracle as oracle
 
 DEFAULT_GEMINI_API_KEY = os.environ.get("AI_Key", "")
-GEMINI_MODEL = "gemini-3-flash-preview"
+GEMINI_MODEL = "gemini-2.5-flash"
 
 print(f"[SYSTEM 28.0] Orchestrator Initialized. Compute: {core.DEVICE.type.upper()}")
 
@@ -158,9 +158,14 @@ def build_core_problem(axl_def: AXLProblemDef) -> core.Problem:
         
     var_names = list(bounds.keys())
     compiled_constraints = []
+    
+    # Bug 2 Fix: Safe, mathematically accurate EQ/GEQ/LEQ kinds translation
+    kind_map = {'EQ': 'equality', 'GEQ': 'inequality', 'LEQ': 'inequality'}
+    dir_map  = {'EQ': 'eq',       'GEQ': 'geq',        'LEQ': 'leq'}
+    
     for c in axl_def.constraints:
-        mc = core.compile_mc(c['kind'].lower() if c['kind'] != 'EQ' else 'equality', 
-                             c['expr'], c['kind'].lower(), var_names, c.get('weight', 1.0))
+        k = c['kind'].upper()
+        mc = core.compile_mc(kind_map[k], c['expr'], dir_map[k], var_names, c.get('weight', 1.0))
         compiled_constraints.append(mc)
         
     prob = core.Problem(
@@ -222,13 +227,51 @@ def collapse_solution(payload: dict, api_key: str) -> str:
 # ══════════════════════════════════════════════════════════════════════
 # SECTION 4: THE ORCHESTRATOR LOOP
 # ══════════════════════════════════════════════════════════════════════
+
+# Bug 1 Fix: Explicit, exact integer-propagation solve callback
 def quick_solver_callback(axl_def: AXLProblemDef, N: int) -> Dict[str, float]:
     try:
         prob = build_core_problem(axl_def)
-        binding, _ = axioms._mprt_sample(prob, 200)
-        return binding
+        
+        # Pull integer vars bounded up to width 100
+        int_vars = [v for v in prob.variables if v in prob.int_vars
+                    and math.isfinite(prob.bounds[v][0])
+                    and prob.bounds[v][1] - prob.bounds[v][0] <= 100]
+                    
+        if int_vars:
+            grids = []
+            for v in int_vars:
+                lo = int(math.ceil(prob.bounds[v][0]))
+                hi = int(math.floor(prob.bounds[v][1]))
+                grids.append([(v, float(val)) for val in range(lo, hi+1)])
+                
+            for combo in itertools.product(*grids):
+                pinned = dict(combo)
+                resolved, _ = core.algebraic_propagate_pinned(prob, pinned)
+                ok, msg = oracle.ground_truth_verify(resolved, N)
+                if ok: return resolved
+        else:
+            # 1D single-parameter search (e.g. 1D Sine Snap)
+            if 't' in prob.variables:
+                lo, hi = prob.bounds['t']
+                for t_val in range(max(2, int(lo)), min(100, int(hi)) + 1):
+                    pinned = {'t': float(t_val)}
+                    resolved, _ = core.algebraic_propagate_pinned(prob, pinned)
+                    ok, msg = oracle.ground_truth_verify(resolved, N)
+                    if ok: return resolved
+            # s, d Fermat grid search
+            if 's' in prob.variables and 'd' in prob.variables:
+                lo_s, hi_s = prob.bounds['s']
+                lo_d, hi_d = prob.bounds['d']
+                for s_val in range(max(2, int(lo_s)), min(200, int(hi_s)) + 1, 2):
+                    for d_val in range(max(0, int(lo_d)), min(100, int(hi_d)) + 1, 2):
+                        pinned = {'s': float(s_val), 'd': float(d_val)}
+                        resolved, _ = core.algebraic_propagate_pinned(prob, pinned)
+                        ok, msg = oracle.ground_truth_verify(resolved, N)
+                        if ok: return resolved
+        return {}
     except Exception as e:
-        _add_log(f"Callback solver error: {e}")
+        print(f"Quick solver callback error: {e}")
         return {}
 
 def global_solve_task(original_text: str, api_key: str, template_name: str = None):
@@ -267,21 +310,25 @@ def global_solve_task(original_text: str, api_key: str, template_name: str = Non
         if preflight_passed:
             _update_state(phase="RAY TRACING")
             base_prob = build_core_problem(axl_def)
+            
+            # Setup initial seeds & execute exhaustive templates
             init_b, init_ce = axioms._mprt_sample(base_prob, 1000)
-            seed_hyp = axioms.Hypothesis(
-                hid="seed", binding=init_b, h_type="seed", claim="Seed", derivation=[],
-                pinned_vars={}, free_vars=base_prob.variables, confidence=1.0, ce=init_ce
+            _add_log("Searching continuous relaxation...")
+            
+            templates = axioms.generate_templates(base_prob, axioms.compute_sketch(base_prob))
+            _add_log(f"Assembled {len(templates)} integer grid mappings.")
+            
+            # Restoring full 27.7 Ray Tracer engine with bandit feedback & batons
+            tracer = axioms.SequenceRayTracer(
+                log_callback=_add_log,
+                update_state_callback=lambda **kwargs: _update_state(**kwargs)
             )
             
-            _add_log(f"Starting Adam Descent. Initial CE = {init_ce:.4f}")
-            results = axioms._batched_deduce_and_evaluate(base_prob, [seed_hyp], steps=150)
+            binding, ce, traces, best_ray_name = tracer.trace(
+                base_prob, init_b, init_ce, templates, max_rays=1500
+            )
             
-            if results:
-                binding, ce, _, _ = results[0]
-            else:
-                binding, ce = init_b, init_ce
-                
-            _add_log(f"Descent Complete. Final CE = {ce:.6f}")
+            _add_log(f"Deduction Engine Complete. Best CE = {ce:.6f}")
             g1_pass = ce < core.SOLVE_THRESHOLD
             
             g2_pass = True
@@ -314,7 +361,6 @@ def global_solve_task(original_text: str, api_key: str, template_name: str = Non
         error_msg = f"💥 FATAL ERROR ({type(e).__name__}): {str(e)}"
         _add_log(error_msg)
         
-        # Display the full traceback nicely in the answer box
         md_error = f"## 💥 SYSTEM CRASH\n\n**Error Type:** `{type(e).__name__}`\n**Message:** {str(e)}\n\n### Traceback\n```python\n{tb_str}\n```"
         _update_state(phase="ERROR", answer=md_error)
         
@@ -329,15 +375,14 @@ def trigger_hyp_solve(template_name, api_key):
     if GLOBAL_SOLVE_STATE["is_running"]: return
     threading.Thread(target=global_solve_task, args=("", api_key, template_name), daemon=True).start()
 
+# Bug 3 Fix: Shors Demo imports directly from oracle without ModuleNotFoundError
 def run_quantum_demo():
     _update_state(is_running=True, phase="QUANTUM SIMULATION", answer="Running Physics Simulator...\nCheck console for output.", high_level_logs=[])
     def _run():
         try:
-            # We import the quantum sim here to avoid circular dependencies
-            import quantum_heisenberg as qh
-            qh.run_shors_demo(15)
-            qh.run_shors_demo(35)
-            qh.benchmark_heisenberg_vs_schrodinger(20)
+            oracle.run_shors_demo(15)
+            oracle.run_shors_demo(35)
+            oracle.benchmark_heisenberg_vs_schrodinger(20)
             _update_state(phase="DONE", answer="Quantum simulation complete. Output logged to console.")
         except Exception as e:
             tb_str = traceback.format_exc()
@@ -371,9 +416,7 @@ def build_live_html():
 
     log_html = "<ul style='margin:0;padding-left:20px;color:#aaa;font-size:0.82em'>"
     for l in logs[-15:]:
-        # Escape HTML to prevent broken formatting on tracebacks
         safe_l = html.escape(str(l)).replace('\n', '<br>')
-        # Highlight fatal errors in red
         if "FATAL ERROR" in safe_l or "CRASH" in safe_l:
             log_html += f"<li style='margin-bottom:4px;color:#FF6B6B;font-weight:bold;'>{safe_l}</li>"
         else:
@@ -470,5 +513,4 @@ with gr.Blocks(title="Practicality 28.0") as demo:
     q_btn.click(fn=handle_q_run, inputs=[ans_cache], outputs=[ans_cache])
 
 if __name__ == "__main__":
-    # CSS properly initialized inside launch()
     demo.launch(server_name="0.0.0.0", server_port=7860, share=False, css=CSS)