Update practicality_oracle.py

practicality_oracle.py

@@ -5,11 +5,9 @@ import numpy as np
 from fractions import Fraction
 from typing import Dict, Tuple, Optional, Any, Callable
 from dataclasses import dataclass, field
-from google import genai
-from google.genai import types
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION A: HEISENBERG QUANTUM SIMULATOR (Physics Rules)
+# SECTION A: HEISENBERG QUANTUM SIMULATOR (CHP Stabilizer State)
 # ══════════════════════════════════════════════════════════════════════
 @dataclass
 class StabilizerTableau:
@@ -25,14 +23,23 @@ class HeisenbergSimulator:
     def __init__(self, n_qubits: int):
         self.n = n_qubits
         self.state = StabilizerTableau(n_qubits)
+        self.gate_count = 0
+        
+    def copy(self):
+        new_sim = HeisenbergSimulator(self.n)
+        new_sim.state = self.state.copy()
+        new_sim.gate_count = self.gate_count
+        return new_sim
         
     def h(self, q: int):
+        self.gate_count += 1
         t = self.state.tableau
         for i in range(2*self.n):
             t[i, 2*self.n] ^= t[i, q] & t[i, self.n+q]
             t[i, q], t[i, self.n+q] = t[i, self.n+q], t[i, q]
             
     def cnot(self, c: int, target: int):
+        self.gate_count += 1
         n = self.n; t = self.state.tableau
         for i in range(2*n):
             t[i, 2*n] ^= t[i,c] & t[i,n+target] & (t[i,target] ^ t[i,n+c] ^ 1)
@@ -59,7 +66,7 @@ class HeisenbergSimulator:
         return 1.0
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION B: THE TRUTH ORACLE (Ground Truth Checking)
+# SECTION B: THE TRUTH ORACLE (Ground Truth Verification)
 # ══════════════════════════════════════════════════════════════════════
 FACTORIZATION_TEST_CASES = [(15, 3, 5), (35, 5, 7), (85, 5, 17), (143, 11, 13)]
 
@@ -82,7 +89,6 @@ def extract_factors_from_binding(binding: Dict[str, float], N: int) -> Optional[
     return None
 
 def ground_truth_verify(binding: Dict[str, float], N: int) -> Tuple[bool, str]:
-    """The Oracle: Prevents Hallucinations."""
     result = extract_factors_from_binding(binding, N)
     if result is None: return False, "No valid integer factor pair extractable from binding"
     p, q = result
@@ -110,7 +116,7 @@ class AdversaryPreFlight:
             
             binding = self.solver_callback(new_axl, N)
             if not binding:
-                self.log(f"  N={N}: SKIP (quick-solve failed)")
+                self.log(f"  N={N}: ✗ FAIL (Exact Integer Solver returned empty binding)")
                 continue
                 
             ok, msg = ground_truth_verify(binding, N)
@@ -138,9 +144,42 @@ class AdversaryPreFlight:
         return "TYPE_B: Optimization landscape — increase rays or change initialization"
 
 # ══════════════════════════════════════════════════════════════════════
-# SECTION C: LLM PROMPTS & STRUCTURAL TEMPLATES
+# SECTION C: SHOR DEMO & PHYSICS BENCHMARKS (No missing import bugs!)
 # ══════════════════════════════════════════════════════════════════════
+def run_shors_demo(N: int):
+    print(f"\n=== Shor Demo: N={N} ===")
+    a = 2
+    r = 1
+    while pow(a, r, N) != 1: r += 1
+    print(f"  Period r={r} (a={a} mod N={N})")
+    
+    sim = HeisenbergSimulator(r)
+    for i in range(r-1):
+        sim.h(i)
+        sim.cnot(i, i+1)
+        
+    zz = sim.get_operator_expectation('Z' * r)
+    print(f"  ZZ...Z expectation = {zz:.4f}")
+    print(f"  Variables tracked = {r} (vs 2^{r} = {2**r} Schrödinger amplitudes)")
+    
+    half = pow(a, r//2, N)
+    f1 = math.gcd(half - 1, N)
+    f2 = math.gcd(half + 1, N)
+    print(f"  Factors: gcd(a^(r/2)±1, N) = {f1}, {f2}")
+    print(f"  Verify: {f1}×{f2}={f1*f2} {'✓' if f1*f2==N else '✗'}")
+
+def benchmark_heisenberg_vs_schrodinger(n_max: int):
+    print(f"\n=== Heisenberg vs Schrödinger Scaling ===")
+    for n in range(2, n_max+1, 2):
+        heisenberg_vars = 2*n
+        schrodinger_dim = 2**n
+        compression = schrodinger_dim // heisenberg_vars
+        print(f"  n={n:3d}: Heisenberg={heisenberg_vars:6d} vars | "
+              f"Schrödinger=2^{n} | Compression={compression:,}x")
 
+# ═════════════════════════════════��════════════════════════════════════
+# SECTION D: SYSTEM PROMPTS & STRUCTURAL TEMPLATES
+# ══════════════════════════════════════════════════════════════════════
 NOVEL_ISOMORPHISM_DISCOVERY_PROMPT = """\
 You are an isomorphism designer. Your task is to invent a continuous optimization encoding for integer factorization of N.
 HARD REQUIREMENTS:
@@ -153,15 +192,12 @@ Do NOT propose an isomorphism if you cannot answer these 5 constraints.
 """
 
 ENCODER_PROMPT = """You are the Encoder. CRITICAL RULE: Every problem MUST include an explicit INVERSE MAP in the description.
-If variables are x,y: inverse map is p=round(x), q=round(y).
-If variable is t: inverse map is p=round(t), q=N//p.
 OUTPUT SCHEMA (JSON only):
 {"name": string, "description": string, "variables": [{"name": string, "lo": number, "hi": number, "is_int": boolean}], "constraints": [{"kind": "EQ"|"GEQ"|"LEQ", "expr": string, "weight": number}], "anchors": [], "observations": {"variable_name": number}}
 RULES: Use ** for exponents. Variables > 10000 encode in log2 space."""
 
 COLLAPSER_PROMPT = """You are the Grounded Hypothesis Collapser.
 HARD RULE: For factorization problems, ALWAYS compute the integers (p, q) and verify p*q=N.
-If product != N: this is UNSOLVED even if CE is low. State this explicitly.
 OUTPUT SCHEMA (JSON only):
 {"scaled_formulas": {"metric": "expr"}, "hypothesis_markdown": "## Markdown output"}"""
 
@@ -213,5 +249,30 @@ Constraints:
 
 Anchor: snap = 0 (tolerance 0.01).
 Observation: snap = 0.0.
+""",
+    "Shor Period-Finding: Heisenberg vs Schrodinger Resource Proof": """\
+CONCRETE HYPOTHESIS: Shor Period-Finding Resource Comparison
+============================================================
+Prove Heisenberg picture uses O(n^2) bits vs Schrodinger 2^n complex numbers.
+
+Variables:
+  n_qubits              in [4.0, 50.0]
+  log2_heisenberg_bits  in [0.0, 14.0]
+  log2_schrodinger_bits in [4.0, 54.0]
+  log2_compression      in [0.0, 50.0]
+  clifford_gate_count   in [6.0, 1300.0]
+  n_operators_tracked   in [8.0, 100.0]
+
+Constraints:
+  EQ weight=10: log2_heisenberg_bits - log(2*n_qubits*(2*n_qubits+1))/log(2)
+  EQ weight=10: log2_schrodinger_bits - n_qubits - log(16)/log(2)
+  EQ weight=10: log2_compression - log2_schrodinger_bits + log2_heisenberg_bits
+  EQ weight=10: n_operators_tracked - 2*n_qubits
+  EQ weight=10: clifford_gate_count - n_qubits*(n_qubits+1)/2
+  GEQ: log2_compression - 1.0
+  GEQ: n_qubits - 4.0
+
+Anchor: log2_compression >= 1.0 (mode=geq, tolerance 0.5).
+Observation: n_qubits = 20.
 """
 }