Update app.py

app.py

@@ -185,17 +185,14 @@ def _extract_json_from_text(text: str) -> str:
     if not text:
         return ""
         
-    # 1. First, search for explicit markdown blocks
     blocks = re.findall(r'```(?:json)?\s*(\{.*?\})\s*```', text, re.DOTALL | re.IGNORECASE)
     for b in blocks:
         cleaned = b.strip()
-        # Verify it looks like our AXL/Collapser schema
         if any(k in cleaned for k in ['"variables"', '"constraints"', '"hypothesis_markdown"', '"name"']):
             return cleaned
     if blocks:
         return blocks[0].strip()
         
-    # 2. Scope-matching parser to isolate valid candidates
     candidates = []
     for match in re.finditer(r'\{', text):
         start_idx = match.start()
@@ -209,20 +206,17 @@ def _extract_json_from_text(text: str) -> str:
                     candidates.append(text[start_idx:i+1])
                     break
                     
-    # Prioritize candidates containing key schema elements
     for cand in candidates:
         cleaned = cand.strip()
         if any(k in cleaned for k in ['"variables"', '"constraints"', '"hypothesis_markdown"', '"name"']):
             return cleaned
             
-    # Fallback to the largest bracket scope
     if candidates:
         return max(candidates, key=len).strip()
         
     return text
 
 def call_external_ai(url: str, model: str, system_prompt: str, prompt: str) -> str:
-    """Interfaces with the external Express.js server."""
     url = url.rstrip("/")
     try:
         res = requests.post(f"{url}/api/chats", timeout=10)
@@ -269,7 +263,7 @@ def encode_problem(text: str, api_key: str, use_ext: bool, ext_url: str, ext_mod
 
     raw = raw.strip()
     if not raw:
-        raise ValueError("The AI model returned an empty response. Check rate limits or external server logs.")
+        raise ValueError("The AI model returned an empty response.")
 
     json_str = _extract_json_from_text(raw)
     if not json_str:
@@ -320,49 +314,8 @@ def collapse_solution(payload: dict, api_key: str, use_ext: bool, ext_url: str,
         return f"JSON Decode Error from Collapser: {e}\n\nRaw Output:\n{raw}"
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION 4: THE ORCHESTRATOR LOOP
+# SECTION 4: THE ORCHESTRATOR LOOP (Adversary Pre-Flight Removed)
 # ══════════════════════════════════════════════════════════════════════
-def quick_solver_callback(axl_def: AXLProblemDef, N: int) -> Dict[str, float]:
-    try:
-        prob = build_core_problem(axl_def)
-        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)])
-                
-            import itertools
-            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:
-            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
-            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:
-        print(f"Quick solver callback error: {e}")
-        return {}
 
 def global_solve_task(original_text: str, api_key: str, template_name: str = None,
                       use_ext: bool = False, ext_url: str = "", ext_model: str = ""):
@@ -385,56 +338,43 @@ def global_solve_task(original_text: str, api_key: str, template_name: str = Non
         if axl_def.minimize_var: _add_log(f"  MINIMIZE: {axl_def.minimize_var}")
 
         is_factorization = any(v['name'] in ['p', 'q', 't', 's', 'd'] for v in axl_def.variables)
-        preflight_passed = True
         
-        if is_factorization:
-            _update_state(phase="ADVERSARY PRE-FLIGHT")
-            adv = oracle.AdversaryPreFlight(quick_solver_callback, _add_log)
-            preflight_passed, reason = adv.check_isomorphism(axl_def)
-            if not preflight_passed:
-                _add_log(f"ADVERSARY KILLED ISOMORPHISM: {reason}")
-                _update_state(infeasibility_report=f"ADVERSARY REJECTION: {reason}", phase="COLLAPSING")
-                ce = float('inf'); binding = {}
-                g1_pass = g2_pass = False
-
-        if preflight_passed:
-            _update_state(phase="RAY TRACING")
-            base_prob = build_core_problem(axl_def)
-            
-            init_b, init_ce = axioms._mprt_sample(base_prob, 1000)
-            _add_log("Searching continuous relaxation...")
-            
-            templates = axioms.generate_templates(base_prob, axioms.compute_sketch(base_prob))
-            
-            tracer = axioms.SequenceRayTracer(
-                log_callback=_add_log,
-                update_state_callback=lambda **kwargs: _update_state(**kwargs)
-            )
-            
-            binding, ce, traces, best_ray_name = tracer.trace(
-                base_prob, init_b, init_ce, templates, max_rays=1500
-            )
-            
-            _add_log(f"Deduction Engine Complete. Best CE = {ce:.6f}")
-            g1_pass = ce < core.SOLVE_THRESHOLD
+        _update_state(phase="RAY TRACING")
+        base_prob = build_core_problem(axl_def)
+        
+        init_b, init_ce = axioms._mprt_sample(base_prob, 1000)
+        _add_log("Searching continuous relaxation...")
+        
+        templates = axioms.generate_templates(base_prob, axioms.compute_sketch(base_prob))
+        
+        tracer = axioms.SequenceRayTracer(
+            log_callback=_add_log,
+            update_state_callback=lambda **kwargs: _update_state(**kwargs)
+        )
+        
+        binding, ce, traces, best_ray_name = tracer.trace(
+            base_prob, init_b, init_ce, templates, max_rays=1500
+        )
+        
+        _add_log(f"Deduction Engine Complete. Best CE = {ce:.6f}")
+        g1_pass = ce < core.SOLVE_THRESHOLD
+        
+        g2_pass = True
+        if is_factorization and len(axl_def.observations) > 0:
+            N_target = int(list(axl_def.observations.values())[0])
+            # Call ground_truth_verify via the oracle module import
+            gt_passed, gt_msg = oracle.ground_truth_verify(binding, N_target)
+            _add_log(f"GROUND TRUTH: {gt_msg}")
             
-            g2_pass = True
-            if is_factorization and len(axl_def.observations) > 0:
-                N_target = int(list(axl_def.observations.values())[0])
-                adv = oracle.AdversaryPreFlight(quick_solver_callback, _add_log)
-                gt_passed, gt_msg = oracle.ground_truth_verify(binding, N_target)
-                _add_log(f"GROUND TRUTH: {gt_msg}")
-                
-                if not gt_passed:
-                    failure_type = adv.failure_taxonomy(binding, N_target, ce)
-                    _update_state(infeasibility_report=f"GROUND TRUTH FAILED: {gt_msg}\nTaxonomy: {failure_type}")
-                    g2_pass = False
-
-        _update_state(phase="COLLAPSING", best_ce=ce if preflight_passed else 0)
+            if not gt_passed:
+                _update_state(infeasibility_report=f"GROUND TRUTH FAILED: {gt_msg}")
+                g2_pass = False
+
+        _update_state(phase="COLLAPSING", best_ce=ce)
         
         payload = {
-            "solved": g1_pass and g2_pass if preflight_passed else False,
-            "raw_binding": {k: core.safe_round(v, 4) for k, v in binding.items()} if preflight_passed else {},
+            "solved": g1_pass and g2_pass,
+            "raw_binding": {k: core.safe_round(v, 4) for k, v in binding.items()},
             "infeasibility_report": GLOBAL_SOLVE_STATE["infeasibility_report"]
         }
         
@@ -586,7 +526,6 @@ with gr.Blocks(title="Practicality 28.0") as demo:
     ui_timer.tick(fn=fetch_dashboard, inputs=[dash_cache], outputs=[live_html, dash_cache])
     ui_timer.tick(fn=fetch_answers, inputs=[ans_cache], outputs=[ans_box, raw_box, ans_cache])
 
-    # Event handlers routed cleanly
     solve_btn.click(fn=handle_solve, inputs=[prob_input, api_key_input, use_ext_toggle, ext_url_input, ext_model_dropdown, ans_cache], outputs=[ans_cache])
     hyp_solve_btn.click(fn=handle_hyp_solve, inputs=[hyp_dropdown, api_key_input, use_ext_toggle, ext_url_input, ext_model_dropdown, ans_cache], outputs=[ans_cache])
     q_btn.click(fn=handle_q_run, inputs=[ans_cache], outputs=[ans_cache])