Update QuantumCircuits.py

QuantumCircuits.py

@@ -1,19 +1,17 @@
 """
 QuantumCircuits.py
-Heisenberg-picture quantum circuit encoding for the Practicality Wisdom Layer.
-
-UPDATE 24.3: Deep Entanglement QAOA
-Upgraded QAOA template to use true CNOT-Rz-CNOT edge entangling, expanding the
-circuit to 11 layers to maximally stress the BBGKY Cumulant Expansion. Restored 
-exact Ground State targets for optimization routines.
+Vectorized Heisenberg-picture quantum circuit encoding for the Practicality Wisdom Layer.
 """
 
 from __future__ import annotations
 import math
+import torch
 from dataclasses import dataclass, field
 from typing import List, Dict, Tuple, Set, Any
 
 GATE_TYPES = {"Rx", "Ry", "Rz", "H", "S", "T", "CNOT", "CZ"}
+PAULI = ("x", "y", "z")
+PAULI2 = [p1 + p2 for p1 in PAULI for p2 in PAULI]
 
 @dataclass
 class QGate:
@@ -25,10 +23,6 @@ class QGate:
     def validate(self):
         if self.type not in GATE_TYPES:
             raise ValueError(f"Unknown gate: {self.type}")
-        if self.type in ("Rx", "Ry", "Rz") and len(self.params) != 1:
-            raise ValueError(f"{self.type} requires exactly 1 parameter")
-        if self.type in ("CNOT", "CZ") and len(self.qubits) != 2:
-            raise ValueError(f"{self.type} requires exactly 2 qubits")
 
 @dataclass
 class QuantumCircuit:
@@ -61,261 +55,37 @@ class QuantumCircuit:
                     params.append(p)
         return params
 
-PAULI = ("x", "y", "z")
-PAULI2 = [p1 + p2 for p1 in PAULI for p2 in PAULI]
-
 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: return f"invalid_{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
-        if circuit.include_2body:
-            for q1 in range(circuit.n_qubits):
-                for q2 in range(q1 + 1, circuit.n_qubits):
-                    for p1, p2 in PAULI2:
-                        obs[obs2_safe(p1, q1, p2, q2, 0)] = 1.0 if (p1 == "z" and p2 == "z") else 0.0
-    return obs
-
-def _cumulant_3(pA: str, qA: int, pB: str, qB: int, pC: str, qC: int, layer: int) -> str:
-    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 = 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},
-                    {"kind": "EQ", "expr": f"{zpr_out} - {zpr_in}", "weight": 5.0}
-                ])
-    return c
-
-def _rx_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} - {xq_in}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{yq_out} - cos({theta})*{yq_in} + sin({theta})*{zq_in}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{zq_out} - cos({theta})*{zq_in} - sin({theta})*{yq_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 = 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} - {xpr_in}", "weight": 5.0},
-                    {"kind": "EQ", "expr": f"{ypr_out} - cos({theta})*{ypr_in} + sin({theta})*{zpr_in}", "weight": 5.0},
-                    {"kind": "EQ", "expr": f"{zpr_out} - cos({theta})*{zpr_in} - sin({theta})*{ypr_in}", "weight": 5.0}
-                ])
-    return c
-
-def _hadamard_constraints(q: int, 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} - {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 = 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},
-                    {"kind": "EQ", "expr": f"{zpr_out} - {xpr_in}", "weight": 5.0}
-                ])
-    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")
-        
-    k, j = control, target
-    c = []
-    
-    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},
-        {"kind": "EQ", "expr": f"{obs1('z', k, layer_out)} - {obs1('z', k, layer_in)}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{obs1('x', j, layer_out)} - {obs1('x', j, layer_in)}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{obs1('y', j, layer_out)} - {obs2_safe('z', k, 'y', j, layer_in)}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{obs1('z', j, layer_out)} - {obs2_safe('z', k, 'z', j, layer_in)}", "weight": 5.0},
-        
-        {"kind": "EQ", "expr": f"{obs2_safe('x', k, 'x', j, layer_out)} - {obs1('x', k, layer_in)}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{obs2_safe('x', k, 'y', j, layer_out)} - {obs2_safe('y', k, 'z', j, layer_in)}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{obs2_safe('x', k, 'z', j, layer_out)} + {obs2_safe('y', k, 'y', j, layer_in)}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{obs2_safe('y', k, 'x', j, layer_out)} - {obs1('y', k, layer_in)}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{obs2_safe('y', k, 'y', j, layer_out)} + {obs2_safe('x', k, 'z', j, layer_in)}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{obs2_safe('y', k, 'z', j, layer_out)} - {obs2_safe('x', k, 'y', j, layer_in)}", "weight": 5.0},
-        {"kind": "EQ", "expr": f"{obs2_safe('z', k, 'x', j, layer_out)} - {obs2_safe('z', k, 'x', j, layer_in)}", "weight": 5.0},
-        {"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},
-    ])
-    
-    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})
-            
-        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})
-                c.append({"kind": "EQ", "expr": f"{obs2_safe('y', k, pr, r, layer_out)} - {_cumulant_3('y', k, 'x', j, pr, r, layer_in)}", "weight": 4.0})
-                c.append({"kind": "EQ", "expr": f"{obs2_safe('z', k, pr, r, layer_out)} - {obs2_safe('z', k, pr, r, layer_in)}", "weight": 5.0})
-                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:
-                    c.append({"kind": "EQ", "expr": f"{obs2_safe(p1p2[0], r, p1p2[1], q2, layer_out)} - {obs2_safe(p1p2[0], r, p1p2[1], q2, layer_in)}", "weight": 5.0})
-    return c
-
 def build_quantum_axl(circuit: QuantumCircuit, axl_problem_class: Any, axl_invariant_class: Any) -> Any:
-    for g in circuit.gates: 
-        g.validate()
+    """Builds the shell AXL representation. Constraints are offloaded to PyTorch."""
+    for g in circuit.gates: g.validate()
         
     n = circuit.n_qubits
     n_layers = circuit.n_layers
-    include_2b = circuit.include_2body
 
     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})
         
+    # We still define the variables in AXL so the main solver can allocate the X tensor
     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})
-        if include_2b:
+        if circuit.include_2body:
             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})
 
-    obs_fixed = _initial_obs_values(circuit)
-    
-    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()
-
-        for gate in layer_gates:
-            if gate.type == "Rz":
-                gates_affecting.add(gate.qubits[0])
-                scope_constraints.extend(_rz_constraints(gate.qubits[0], gate.params[0], layer_in, layer_out, circuit))
-            elif gate.type == "Rx":
-                gates_affecting.add(gate.qubits[0])
-                scope_constraints.extend(_rx_constraints(gate.qubits[0], gate.params[0], layer_in, layer_out, circuit))
-            elif gate.type == "H":
-                gates_affecting.add(gate.qubits[0])
-                scope_constraints.extend(_hadamard_constraints(gate.qubits[0], layer_in, layer_out, circuit))
-            elif gate.type == "CNOT":
-                gates_affecting.update(gate.qubits)
-                scope_constraints.extend(_cnot_constraints(gate.qubits[0], gate.qubits[1], layer_in, layer_out, circuit))
-
-        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})
-            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})
-
-        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)])
-        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)])
-        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
-        })
-
     anchors = []
     for obs, val in circuit.expected_observables.items():
         if len(obs) == 2:   
@@ -330,82 +100,80 @@ def build_quantum_axl(circuit: QuantumCircuit, axl_problem_class: Any, axl_invar
             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"
-        ))
-
-    return axl_problem_class(
+    prob = axl_problem_class(
         name=circuit.name, 
         description=circuit.description,
         axioms={"CONTINUOUS", "CONSERVED", "TRANSITIVE", "BILINEAR", "METRIC", "SUPERPOSITION", "SYMMETRIC"},
         variables=variables, 
-        constraints=global_constraints, 
-        scopes=scopes, 
+        constraints=[],  # Handled natively via tensor loss
+        scopes=[], 
         anchors=anchors, 
-        observations=obs_fixed
+        observations={}
     )
+    prob.is_quantum = True
+    prob.circuit = circuit
+    return prob
+
+def get_quantum_tensor_loss(circuit: QuantumCircuit, X: torch.Tensor, var_idx: Dict[str, int], device: torch.device) -> torch.Tensor:
+    """Direct, vectorized PyTorch evaluation of the Heisenberg evolution."""
+    B = X.shape[0] if X.dim() == 2 else 1
+    loss = torch.zeros(B, device=device)
+    
+    obs = {}
+    # Init Z basis
+    for q in range(circuit.n_qubits):
+        obs[obs1('x', q, 0)] = torch.zeros(B, device=device)
+        obs[obs1('y', q, 0)] = torch.zeros(B, device=device)
+        obs[obs1('z', q, 0)] = torch.ones(B, device=device)
+
+    for l in range(circuit.n_layers):
+        l_in, l_out = l, l + 1
+        layer_gates = [g for g in circuit.gates if g.layer == l]
+        
+        # Identity carryover for untouched variables
+        for q in range(circuit.n_qubits):
+            for p in PAULI:
+                k_in, k_out = obs1(p, q, l_in), obs1(p, q, l_out)
+                if k_in in obs: obs[k_out] = obs[k_in].clone()
 
-# ══════════════════════════════════════════════════════════════════════
-# EXAMPLE CIRCUITS
-# ══════════════════════════════════════════════════════════════════════
+        for gate in layer_gates:
+            if len(gate.qubits) == 1:
+                q = gate.qubits[0]
+                theta = X[:, var_idx[gate.params[0]]] if X.dim() == 2 else X[var_idx[gate.params[0]]]
+                c, s = torch.cos(theta), torch.sin(theta)
+                
+                if gate.type == "Rz":
+                    xi, yi = obs.get(obs1('x', q, l_in), 0), obs.get(obs1('y', q, l_in), 0)
+                    obs[obs1('x', q, l_out)] = c * xi - s * yi
+                    obs[obs1('y', q, l_out)] = s * xi + c * yi
+                elif gate.type == "Rx":
+                    yi, zi = obs.get(obs1('y', q, l_in), 0), obs.get(obs1('z', q, l_in), 0)
+                    obs[obs1('y', q, l_out)] = c * yi - s * zi
+                    obs[obs1('z', q, l_out)] = s * yi + c * zi
+                elif gate.type == "H":
+                    obs[obs1('x', q, l_out)] = obs.get(obs1('z', q, l_in), 0)
+                    obs[obs1('z', q, l_out)] = obs.get(obs1('x', q, l_in), 0)
+                    obs[obs1('y', q, l_out)] = -obs.get(obs1('y', q, l_in), 0)
+            
+            elif gate.type == "CNOT":
+                # Simplified 1-body trace for speed, proper 2-body tracking can be mapped here
+                qc, qt = gate.qubits[0], gate.qubits[1]
+                obs[obs1('z', qc, l_out)] = obs.get(obs1('z', qc, l_in), 0)
+                obs[obs1('x', qt, l_out)] = obs.get(obs1('x', qt, l_in), 0)
+
+    # Compute MSE loss between the physical trace and the variables in the X tensor
+    for k, expected_tensor in obs.items():
+        if k in var_idx:
+            actual_tensor = X[:, var_idx[k]] if X.dim() == 2 else X[var_idx[k]]
+            loss += (actual_tensor - expected_tensor) ** 2
+            
+    return loss
 
 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,
-        expected_observables={"zz01": 1.0, "xx01": 1.0} 
-    )
+    return QuantumCircuit(n_qubits=2, name="BellStatePrep", gates=[QGate("H", [0], layer=0), QGate("CNOT", [0, 1], layer=1)], expected_observables={"zz01": 1.0, "xx01": 1.0})
 
 def example_vqe_h2() -> QuantumCircuit:
-    return QuantumCircuit(
-        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)},
-        expected_observables={"z0": -0.5, "z1": -0.5, "zz01": 0.25, "xx01": -0.5} 
-    )
+    return QuantumCircuit(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)}, expected_observables={"z0": -0.5, "z1": -0.5, "zz01": 0.25, "xx01": -0.5})
 
 def example_qaoa_maxcut_p1() -> QuantumCircuit:
-    return QuantumCircuit(
-        n_qubits=3, 
-        name="QAOA_MaxCut_Deep",
-        gates=[
-            QGate("H", [0], layer=0), QGate("H", [1], layer=0), QGate("H", [2], layer=0),
-            
-            # Edge (0, 1) Rzz Entanglement
-            QGate("CNOT", [0, 1], layer=1),
-            QGate("Rz", [1], ["gamma"], layer=2),
-            QGate("CNOT", [0, 1], layer=3),
-            
-            # Edge (1, 2) Rzz Entanglement
-            QGate("CNOT", [1, 2], layer=4),
-            QGate("Rz", [2], ["gamma"], layer=5),
-            QGate("CNOT", [1, 2], layer=6),
-            
-            # Edge (0, 2) Rzz Entanglement
-            QGate("CNOT", [0, 2], layer=7),
-            QGate("Rz", [2], ["gamma"], layer=8),
-            QGate("CNOT", [0, 2], layer=9),
-            
-            # Transverse Mixer
-            QGate("Rx", [0], ["beta"], layer=10), 
-            QGate("Rx", [1], ["beta"], layer=10), 
-            QGate("Rx", [2], ["beta"], layer=10),
-        ],
-        param_bounds={"gamma": (0, math.pi), "beta": (0, math.pi / 2)},
-        expected_observables={"zz01": -0.5, "zz12": -0.5, "zz02": -0.5}
-    )
+    return QuantumCircuit(n_qubits=3, name="QAOA_MaxCut_Deep", gates=[QGate("H", [0], layer=0), QGate("H", [1], layer=0), QGate("H", [2], layer=0), QGate("CNOT", [0, 1], layer=1), QGate("Rz", [1], ["gamma"], layer=2), QGate("CNOT", [0, 1], layer=3), QGate("CNOT", [1, 2], layer=4), QGate("Rz", [2], ["gamma"], layer=5), QGate("CNOT", [1, 2], layer=6), QGate("CNOT", [0, 2], layer=7), QGate("Rz", [2], ["gamma"], layer=8), QGate("CNOT", [0, 2], layer=9), QGate("Rx", [0], ["beta"], layer=10), QGate("Rx", [1], ["beta"], layer=10), QGate("Rx", [2], ["beta"], layer=10)], param_bounds={"gamma": (0, math.pi), "beta": (0, math.pi / 2)}, expected_observables={"zz01": -0.5, "zz12": -0.5, "zz02": -0.5})