Update QuantumCircuits.py

QuantumCircuits.py

@@ -5,9 +5,6 @@ Heisenberg-picture quantum circuit encoding for the Practicality Wisdom Layer.
 UPDATE 24.1: Non-Linear Cumulant Closure (BBGKY Hierarchy Fix)
 CNOT operations natively generate 3-body entanglement. We now approximate 
 them using non-linear combinations of 1-body and 2-body observables.
-
-UPDATE: Replaced arbitrary target_hamiltonian anchors with exact 
-`expected_observables` to prevent Gate 2 verification traps.
 """
 
 from __future__ import annotations
@@ -39,21 +36,28 @@ class QuantumCircuit:
     param_bounds:         Dict[str, Tuple[float, float]] = field(default_factory=dict)
     initial_state:        str = "zero"
     initial_obs:          Dict[str, float] = field(default_factory=dict)
-    expected_observables: Dict[str, float] = field(default_factory=dict) # ← NEW FIX
+    expected_observables: Dict[str, float] = field(default_factory=dict)
     include_2body:        bool = True
     name:                 str = "QuantumCircuit"
     description:          str = ""
 
     @property
-    def n_layers(self) -> int: return max([g.layer for g in self.gates] + [-1]) + 1
+    def n_layers(self) -> int: 
+        return max([g.layer for g in self.gates] + [-1]) + 1
+        
     @property
-    def has_cnot(self) -> bool: return any(g.type in ("CNOT", "CZ") for g in self.gates)
+    def has_cnot(self) -> bool: 
+        return any(g.type in ("CNOT", "CZ") for g in self.gates)
+        
     @property
     def all_params(self) -> List[str]:
-        seen = set(); params = []
+        seen = set()
+        params = []
         for g in self.gates:
             for p in g.params:
-                if p not in seen: seen.add(p); params.append(p)
+                if p not in seen: 
+                    seen.add(p)
+                    params.append(p)
         return params
 
 PAULI = ("x", "y", "z")
@@ -63,15 +67,19 @@ def obs1(pauli: str, qubit: int, layer: int) -> str:
     return f"{pauli}{qubit}_L{layer}"
 
 def obs2_safe(pauli1: str, q1: int, pauli2: str, q2: int, layer: int) -> str:
-    if q1 == q2: raise ValueError(f"Invalid 2-body observable on same qubit: {q1}")
-    if q1 > q2: return f"{pauli2}{pauli1}{q2}{q1}_L{layer}"
+    if q1 == q2: 
+        raise ValueError(f"Invalid 2-body observable on same qubit: {q1}")
+    if q1 > q2: 
+        return f"{pauli2}{pauli1}{q2}{q1}_L{layer}"
     return f"{pauli1}{pauli2}{q1}{q2}_L{layer}"
 
 def _initial_obs_values(circuit: QuantumCircuit) -> Dict[str, float]:
     obs = {}
     if circuit.initial_state == "zero":
         for q in range(circuit.n_qubits):
-            obs[obs1("z", q, 0)] = 1.0; obs[obs1("x", q, 0)] = 0.0; obs[obs1("y", q, 0)] = 0.0
+            obs[obs1("z", q, 0)] = 1.0
+            obs[obs1("x", q, 0)] = 0.0
+            obs[obs1("y", q, 0)] = 0.0
         if circuit.include_2body:
             for q1 in range(circuit.n_qubits):
                 for q2 in range(q1 + 1, circuit.n_qubits):
@@ -80,27 +88,39 @@ def _initial_obs_values(circuit: QuantumCircuit) -> Dict[str, float]:
     return obs
 
 def _cumulant_3(pA: str, qA: int, pB: str, qB: int, pC: str, qC: int, layer: int) -> str:
-    oA, oB, oC = obs1(pA, qA, layer), obs1(pB, qB, layer), obs1(pC, qC, layer)
+    oA = obs1(pA, qA, layer)
+    oB = obs1(pB, qB, layer)
+    oC = obs1(pC, qC, layer)
+    
     oAB = obs2_safe(pA, qA, pB, qB, layer)
     oAC = obs2_safe(pA, qA, pC, qC, layer)
     oBC = obs2_safe(pB, qB, pC, qC, layer)
+    
     return f"({oAB}*{oC} + {oAC}*{oB} + {oBC}*{oA} - 2.0*{oA}*{oB}*{oC})"
 
 def _rz_constraints(q: int, theta: str, layer_in: int, layer_out: int, circuit: QuantumCircuit) -> List[Dict]:
     c = []
     xq_in, yq_in, zq_in = obs1("x", q, layer_in), obs1("y", q, layer_in), obs1("z", q, layer_in)
     xq_out, yq_out, zq_out = obs1("x", q, layer_out), obs1("y", q, layer_out), obs1("z", q, layer_out)
+    
     c.extend([
         {"kind": "EQ", "expr": f"{xq_out} - cos({theta})*{xq_in} - sin({theta})*{yq_in}", "weight": 5.0},
         {"kind": "EQ", "expr": f"{yq_out} + sin({theta})*{xq_in} - cos({theta})*{yq_in}", "weight": 5.0},
         {"kind": "EQ", "expr": f"{zq_out} - {zq_in}", "weight": 5.0}
     ])
+    
     if circuit.include_2body:
         for r in range(circuit.n_qubits):
             if r == q: continue
             for pr in PAULI:
-                xpr_in, ypr_in, zpr_in = obs2_safe("x", q, pr, r, layer_in), obs2_safe("y", q, pr, r, layer_in), obs2_safe("z", q, pr, r, layer_in)
-                xpr_out, ypr_out, zpr_out = obs2_safe("x", q, pr, r, layer_out), obs2_safe("y", q, pr, r, layer_out), obs2_safe("z", q, pr, r, layer_out)
+                xpr_in = obs2_safe("x", q, pr, r, layer_in)
+                ypr_in = obs2_safe("y", q, pr, r, layer_in)
+                zpr_in = obs2_safe("z", q, pr, r, layer_in)
+                
+                xpr_out = obs2_safe("x", q, pr, r, layer_out)
+                ypr_out = obs2_safe("y", q, pr, r, layer_out)
+                zpr_out = obs2_safe("z", q, pr, r, layer_out)
+                
                 c.extend([
                     {"kind": "EQ", "expr": f"{xpr_out} - cos({theta})*{xpr_in} - sin({theta})*{ypr_in}", "weight": 5.0},
                     {"kind": "EQ", "expr": f"{ypr_out} + sin({theta})*{xpr_in} - cos({theta})*{ypr_in}", "weight": 5.0},
@@ -112,17 +132,25 @@ def _hadamard_constraints(q: int, layer_in: int, layer_out: int, circuit: Quantu
     c = []
     xq_in, yq_in, zq_in = obs1("x", q, layer_in), obs1("y", q, layer_in), obs1("z", q, layer_in)
     xq_out, yq_out, zq_out = obs1("x", q, layer_out), obs1("y", q, layer_out), obs1("z", q, layer_out)
+    
     c.extend([
         {"kind": "EQ", "expr": f"{xq_out} - {zq_in}", "weight": 5.0},
         {"kind": "EQ", "expr": f"{yq_out} + {yq_in}", "weight": 5.0},
         {"kind": "EQ", "expr": f"{zq_out} - {xq_in}", "weight": 5.0}
     ])
+    
     if circuit.include_2body:
         for r in range(circuit.n_qubits):
             if r == q: continue
             for pr in PAULI:
-                xpr_in, ypr_in, zpr_in = obs2_safe("x", q, pr, r, layer_in), obs2_safe("y", q, pr, r, layer_in), obs2_safe("z", q, pr, r, layer_in)
-                xpr_out, ypr_out, zpr_out = obs2_safe("x", q, pr, r, layer_out), obs2_safe("y", q, pr, r, layer_out), obs2_safe("z", q, pr, r, layer_out)
+                xpr_in = obs2_safe("x", q, pr, r, layer_in)
+                ypr_in = obs2_safe("y", q, pr, r, layer_in)
+                zpr_in = obs2_safe("z", q, pr, r, layer_in)
+                
+                xpr_out = obs2_safe("x", q, pr, r, layer_out)
+                ypr_out = obs2_safe("y", q, pr, r, layer_out)
+                zpr_out = obs2_safe("z", q, pr, r, layer_out)
+                
                 c.extend([
                     {"kind": "EQ", "expr": f"{xpr_out} - {zpr_in}", "weight": 5.0},
                     {"kind": "EQ", "expr": f"{ypr_out} + {ypr_in}", "weight": 5.0},
@@ -131,9 +159,13 @@ def _hadamard_constraints(q: int, layer_in: int, layer_out: int, circuit: Quantu
     return c
 
 def _cnot_constraints(control: int, target: int, layer_in: int, layer_out: int, circuit: QuantumCircuit) -> List[Dict]:
-    if not circuit.include_2body: raise ValueError("CNOT requires include_2body=True")
+    if not circuit.include_2body: 
+        raise ValueError("CNOT requires include_2body=True")
+        
     k, j = control, target
     c = []
+    
+    # Inner control-target mapping
     c.extend([
         {"kind": "EQ", "expr": f"{obs1('x', k, layer_out)} - {obs2_safe('x', k, 'x', j, layer_in)}", "weight": 5.0},
         {"kind": "EQ", "expr": f"{obs1('y', k, layer_out)} - {obs2_safe('y', k, 'x', j, layer_in)}", "weight": 5.0},
@@ -152,9 +184,13 @@ def _cnot_constraints(control: int, target: int, layer_in: int, layer_out: int,
         {"kind": "EQ", "expr": f"{obs2_safe('z', k, 'y', j, layer_out)} - {obs1('y', j, layer_in)}", "weight": 5.0},
         {"kind": "EQ", "expr": f"{obs2_safe('z', k, 'z', j, layer_out)} - {obs1('z', j, layer_in)}", "weight": 5.0},
     ])
+    
+    # Spectator BBGKY Cumulant mapping
     for r in range(circuit.n_qubits):
         if r in (k, j): continue
-        for p in PAULI: c.append({"kind": "EQ", "expr": f"{obs1(p, r, layer_out)} - {obs1(p, r, layer_in)}", "weight": 5.0})
+        for p in PAULI: 
+            c.append({"kind": "EQ", "expr": f"{obs1(p, r, layer_out)} - {obs1(p, r, layer_in)}", "weight": 5.0})
+            
         if circuit.include_2body:
             for pr in PAULI:
                 c.append({"kind": "EQ", "expr": f"{obs2_safe('x', k, pr, r, layer_out)} - {_cumulant_3('x', k, 'x', j, pr, r, layer_in)}", "weight": 4.0})
@@ -163,6 +199,7 @@ def _cnot_constraints(control: int, target: int, layer_in: int, layer_out: int,
                 c.append({"kind": "EQ", "expr": f"{obs2_safe('x', j, pr, r, layer_out)} - {obs2_safe('x', j, pr, r, layer_in)}", "weight": 5.0})
                 c.append({"kind": "EQ", "expr": f"{obs2_safe('y', j, pr, r, layer_out)} - {_cumulant_3('z', k, 'y', j, pr, r, layer_in)}", "weight": 4.0})
                 c.append({"kind": "EQ", "expr": f"{obs2_safe('z', j, pr, r, layer_out)} - {_cumulant_3('z', k, 'z', j, pr, r, layer_in)}", "weight": 4.0})
+            
             for q2 in range(r + 1, circuit.n_qubits):
                 if q2 in (k, j): continue
                 for p1p2 in PAULI2:
@@ -170,26 +207,45 @@ def _cnot_constraints(control: int, target: int, layer_in: int, layer_out: int,
     return c
 
 def build_quantum_axl(circuit: QuantumCircuit, axl_problem_class: Any, axl_invariant_class: Any) -> Any:
-    for g in circuit.gates: g.validate()
-    n = circuit.n_qubits; n_layers = circuit.n_layers; include_2b = circuit.include_2body and circuit.has_cnot
-
-    variables = [{"name": pname, "lo": circuit.param_bounds.get(pname, (-math.pi, math.pi))[0], "hi": circuit.param_bounds.get(pname, (-math.pi, math.pi))[1]} for pname in circuit.all_params]
+    for g in circuit.gates: 
+        g.validate()
+        
+    n = circuit.n_qubits
+    n_layers = circuit.n_layers
+    include_2b = circuit.include_2body and circuit.has_cnot
+
+    variables = []
+    for pname in circuit.all_params:
+        lo, hi = circuit.param_bounds.get(pname, (-math.pi, math.pi))
+        variables.append({"name": pname, "lo": lo, "hi": hi})
+        
     for layer in range(n_layers + 1):
         for q in range(n):
-            for p in PAULI: variables.append({"name": obs1(p, q, layer), "lo": -1.0, "hi": 1.0})
+            for p in PAULI: 
+                variables.append({"name": obs1(p, q, layer), "lo": -1.0, "hi": 1.0})
         if include_2b:
             for q1 in range(n):
                 for q2 in range(q1 + 1, n):
-                    for p1p2 in PAULI2: variables.append({"name": obs2_safe(p1p2[0], q1, p1p2[1], q2, layer), "lo": -1.0, "hi": 1.0})
+                    for p1p2 in PAULI2: 
+                        variables.append({"name": obs2_safe(p1p2[0], q1, p1p2[1], q2, layer), "lo": -1.0, "hi": 1.0})
 
     obs_fixed = _initial_obs_values(circuit)
-    global_constraints = [{"kind": "GEQ", "expr": f"1.0 - {obs1('x', q, layer)}**2 - {obs1('y', q, layer)}**2 - {obs1('z', q, layer)}**2", "weight": 2.0} for layer in range(n_layers + 1) for q in range(n)]
+    
+    global_constraints = []
+    for layer in range(n_layers + 1):
+        for q in range(n):
+            global_constraints.append({
+                "kind": "GEQ", 
+                "expr": f"1.0 - {obs1('x', q, layer)}**2 - {obs1('y', q, layer)}**2 - {obs1('z', q, layer)}**2", 
+                "weight": 2.0
+            })
 
     scopes = []
     for layer_in in range(n_layers):
         layer_out = layer_in + 1
         layer_gates = [g for g in circuit.gates if g.layer == layer_in]
-        scope_constraints = []; gates_affecting = set()
+        scope_constraints = []
+        gates_affecting = set()
 
         for gate in layer_gates:
             if gate.type == "Rz":
@@ -204,68 +260,100 @@ def build_quantum_axl(circuit: QuantumCircuit, axl_problem_class: Any, axl_invar
 
         unaffected = [q for q in range(n) if q not in gates_affecting]
         for q in unaffected:
-            for p in PAULI: scope_constraints.append({"kind": "EQ", "expr": f"{obs1(p, q, layer_out)} - {obs1(p, q, layer_in)}", "weight": 5.0})
+            for p in PAULI: 
+                scope_constraints.append({"kind": "EQ", "expr": f"{obs1(p, q, layer_out)} - {obs1(p, q, layer_in)}", "weight": 5.0})
             if include_2b:
                 for q2 in range(n):
                     if q2 == q or q2 in gates_affecting: continue
-                    for p1p2 in PAULI2: scope_constraints.append({"kind": "EQ", "expr": f"{obs2_safe(p1p2[0], q, p1p2[1], q2, layer_out)} - {obs2_safe(p1p2[0], q, p1p2[1], q2, layer_in)}", "weight": 5.0})
+                    for p1p2 in PAULI2: 
+                        scope_constraints.append({"kind": "EQ", "expr": f"{obs2_safe(p1p2[0], q, p1p2[1], q2, layer_out)} - {obs2_safe(p1p2[0], q, p1p2[1], q2, layer_in)}", "weight": 5.0})
 
         scope_var_names = []
         for q in range(n):
-            for p in PAULI: scope_var_names.extend([obs1(p, q, layer_in), obs1(p, q, layer_out)])
+            for p in PAULI: 
+                scope_var_names.extend([obs1(p, q, layer_in), obs1(p, q, layer_out)])
         if include_2b:
             for q1 in range(n):
                 for q2 in range(q1 + 1, n):
-                    for p1p2 in PAULI2: scope_var_names.extend([obs2_safe(p1p2[0], q1, p1p2[1], q2, layer_in), obs2_safe(p1p2[0], q1, p1p2[1], q2, layer_out)])
+                    for p1p2 in PAULI2: 
+                        scope_var_names.extend([obs2_safe(p1p2[0], q1, p1p2[1], q2, layer_in), obs2_safe(p1p2[0], q1, p1p2[1], q2, layer_out)])
         scope_var_names.extend(circuit.all_params)
 
-        scopes.append({"name": f"layer_{layer_in}_to_{layer_out}", "order": layer_in, "vars": scope_var_names, "constraints": scope_constraints})
+        scopes.append({
+            "name": f"layer_{layer_in}_to_{layer_out}", 
+            "order": layer_in, 
+            "vars": scope_var_names, 
+            "constraints": scope_constraints
+        })
 
     anchors = []
-    # FIX: Create proper verification anchors from exact expectations, avoiding arbitrary optimization traps
+    # FIX: Exact Correlator Verification
     for obs, val in circuit.expected_observables.items():
-        if len(obs) == 2:   expr = obs1(obs[0], int(obs[1:]), n_layers)
-        elif len(obs) == 4: expr = obs2_safe(obs[0], int(obs[2]), obs[1], int(obs[3]), n_layers)
-        anchors.append(axl_invariant_class(name=f"verify_{obs}", expr=f"{expr} - ({val})", tolerance=0.05, mode="eq"))
+        if len(obs) == 2:   
+            expr = obs1(obs[0], int(obs[1:]), n_layers)
+        elif len(obs) == 4: 
+            expr = obs2_safe(obs[0], int(obs[2]), obs[1], int(obs[3]), n_layers)
+        
+        anchors.append(axl_invariant_class(
+            name=f"verify_{obs}", 
+            expr=f"{expr} - ({val})", 
+            tolerance=0.05, 
+            mode="eq"
+        ))
 
     for q in range(n):
-        anchors.append(axl_invariant_class(name=f"bloch_q{q}", expr=f"1.0 - {obs1('x', q, n_layers)}**2 - {obs1('y', q, n_layers)}**2 - {obs1('z', q, n_layers)}**2", tolerance=0.05, mode="geq"))
+        anchors.append(axl_invariant_class(
+            name=f"bloch_q{q}", 
+            expr=f"1.0 - {obs1('x', q, n_layers)}**2 - {obs1('y', q, n_layers)}**2 - {obs1('z', q, n_layers)}**2", 
+            tolerance=0.05, 
+            mode="geq"
+        ))
 
     return axl_problem_class(
-        name=circuit.name, description=circuit.description,
+        name=circuit.name, 
+        description=circuit.description,
         axioms={"CONTINUOUS", "CONSERVED", "TRANSITIVE", "BILINEAR", "METRIC", "SUPERPOSITION", "SYMMETRIC"},
-        variables=variables, constraints=global_constraints, scopes=scopes, anchors=anchors, observations=obs_fixed)
-
+        variables=variables, 
+        constraints=global_constraints, 
+        scopes=scopes, 
+        anchors=anchors, 
+        observations=obs_fixed
+    )
 
 # ══════════════════════════════════════════════════════════════════════
-# EXAMPLE CIRCUITS (Updated for correct anchor verification)
+# EXAMPLE CIRCUITS
 # ══════════════════════════════════════════════════════════════════════
 
 def example_bell_state() -> QuantumCircuit:
     return QuantumCircuit(
-        n_qubits=2, name="BellStatePrep",
-        gates=[QGate("H", [0], layer=0), QGate("CNOT", [0, 1], layer=1)],
-        initial_state="zero", include_2body=True,
-        # Now verifies exactly what the Bell State should be, preventing infinite loops.
+        n_qubits=2, 
+        name="BellStatePrep",
+        gates=[
+            QGate("H", [0], layer=0), 
+            QGate("CNOT", [0, 1], layer=1)
+        ],
+        initial_state="zero", 
+        include_2body=True,
         expected_observables={"zz01": 1.0, "xx01": 1.0} 
     )
 
 def example_vqe_h2() -> QuantumCircuit:
     return QuantumCircuit(
-        n_qubits=2, name="VQE_H2",
+        n_qubits=2, 
+        name="VQE_H2",
         gates=[
             QGate("Ry", [0], ["theta0"], layer=0),
             QGate("Ry", [1], ["theta1"], layer=0),
             QGate("CNOT", [0, 1], layer=1),
         ],
         param_bounds={"theta0": (-math.pi, math.pi), "theta1": (-math.pi, math.pi)},
-        # Let it purely optimize without Gate 2 anchor traps
         expected_observables={} 
     )
 
 def example_qaoa_maxcut_p1() -> QuantumCircuit:
     return QuantumCircuit(
-        n_qubits=3, name="QAOA_MaxCut",
+        n_qubits=3, 
+        name="QAOA_MaxCut",
         gates=[
             QGate("H", [0], layer=0), QGate("H", [1], layer=0), QGate("H", [2], layer=0),
             QGate("Rz", [0], ["gamma"], layer=1), QGate("Rz", [1], ["gamma"], layer=1), QGate("Rz", [2], ["gamma"], layer=1),