Create QuantumCircuits.py

QuantumCircuits.py

@@ -0,0 +1,400 @@
+"""
+QuantumCircuits.py
+Heisenberg-picture quantum circuit encoding for the Practicality Wisdom Layer.
+"""
+
+from __future__ import annotations
+import math
+from dataclasses import dataclass, field
+from typing import List, Dict, Tuple, Set, Any
+
+# ── Gate definitions ─────────────────────────────────────────────────
+
+GATE_TYPES = {
+    "Rx", "Ry", "Rz",    # Parameterized rotations
+    "H",                  # Hadamard
+    "S", "T",             # Phase gates 
+    "CNOT",               # Entangling gate
+    "CZ",                 # Controlled-Z
+}
+
+@dataclass
+class QGate:
+    type:    str
+    qubits:  List[int]
+    params:  List[str] = field(default_factory=list)
+    layer:   int = 0
+
+    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")
+        if self.type in ("H", "S", "T") and len(self.qubits) != 1:
+            raise ValueError(f"{self.type} is a single-qubit gate")
+
+@dataclass
+class QuantumCircuit:
+    n_qubits:           int
+    gates:              List[QGate]
+    param_bounds:       Dict[str, Tuple[float, float]] = field(default_factory=dict)
+    initial_state:      str = "zero"
+    initial_obs:        Dict[str, float] = field(default_factory=dict)
+    target_hamiltonian: Dict[str, float] = field(default_factory=dict)
+    include_2body:      bool = True
+    name:               str = "QuantumCircuit"
+    description:        str = ""
+
+    @property
+    def n_layers(self) -> int:
+        if not self.gates: return 0
+        return max(g.layer for g in self.gates) + 1
+
+    @property
+    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 = []
+        for g in self.gates:
+            for p in g.params:
+                if p not in seen:
+                    seen.add(p)
+                    params.append(p)
+        return params
+
+# ── Observable naming ─────────────────────────────────────────────────
+
+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(pauli1: str, pauli2: str, q1: int, q2: int, layer: int) -> str:
+    if q1 > q2:
+        q1, q2 = q2, q1
+        pauli1, pauli2 = pauli2, pauli1
+    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(p1, p2, q1, q2, 0)] = 1.0 if (p1 == "z" and p2 == "z") else 0.0
+
+    elif circuit.initial_state == "plus":
+        for q in range(circuit.n_qubits):
+            obs[obs1("x", q, 0)] = 1.0   
+            obs[obs1("y", q, 0)] = 0.0
+            obs[obs1("z", 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 p1p2 in PAULI2:
+                        obs[obs2(p1p2[0], p1p2[1], q1, q2, 0)] = 1.0 if p1p2 == "xx" else 0.0
+
+    elif circuit.initial_state == "custom":
+        obs.update(circuit.initial_obs)
+    return obs
+
+# ── Heisenberg evolution constraints ─────────────────────────────────
+
+def _rz_constraints(q: int, theta: str, layer_in: int, layer_out: int, circuit: QuantumCircuit) -> List[Dict]:
+    constraints = []
+    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)
+
+    constraints.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("x", pr, q, r, layer_in), obs2("y", pr, q, r, layer_in), obs2("z", pr, q, r, layer_in)
+                xpr_out, ypr_out, zpr_out = obs2("x", pr, q, r, layer_out), obs2("y", pr, q, r, layer_out), obs2("z", pr, q, r, layer_out)
+                constraints.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 constraints
+
+def _rx_constraints(q: int, theta: str, layer_in: int, layer_out: int, circuit: QuantumCircuit) -> List[Dict]:
+    constraints = []
+    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)
+
+    constraints.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, ypr_in, zpr_in = obs2("x", pr, q, r, layer_in), obs2("y", pr, q, r, layer_in), obs2("z", pr, q, r, layer_in)
+                xpr_out, ypr_out, zpr_out = obs2("x", pr, q, r, layer_out), obs2("y", pr, q, r, layer_out), obs2("z", pr, q, r, layer_out)
+                constraints.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 constraints
+
+def _hadamard_constraints(q: int, layer_in: int, layer_out: int, circuit: QuantumCircuit) -> List[Dict]:
+    constraints = []
+    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)
+
+    constraints.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("x", pr, q, r, layer_in), obs2("y", pr, q, r, layer_in), obs2("z", pr, q, r, layer_in)
+                xpr_out, ypr_out, zpr_out = obs2("x", pr, q, r, layer_out), obs2("y", pr, q, r, layer_out), obs2("z", pr, q, r, layer_out)
+                constraints.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 constraints
+
+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
+    constraints = []
+
+    # ── Single-qubit output
+    constraints.extend([
+        {"kind": "EQ", "expr": f"{obs1('x', k, layer_out)} - {obs2('x', 'x', k, j, layer_in)}", "weight": 5.0},
+        {"kind": "EQ", "expr": f"{obs1('y', k, layer_out)} - {obs2('y', 'x', k, 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('z', 'y', k, j, layer_in)}", "weight": 5.0},
+        {"kind": "EQ", "expr": f"{obs1('z', j, layer_out)} - {obs2('z', 'z', k, j, layer_in)}", "weight": 5.0}
+    ])
+
+    # ── Two-qubit output (ctrl and tgt)
+    constraints.extend([
+        {"kind": "EQ", "expr": f"{obs2('x', 'x', k, j, layer_out)} - {obs1('x', k, layer_in)}", "weight": 5.0},
+        {"kind": "EQ", "expr": f"{obs2('z', 'z', k, j, layer_out)} - {obs1('z', j, layer_in)}", "weight": 5.0},
+        {"kind": "EQ", "expr": f"{obs2('z', 'x', k, j, layer_out)} - {obs2('z', 'x', k, j, layer_in)}", "weight": 5.0},
+        {"kind": "EQ", "expr": f"{obs2('x', 'z', k, j, layer_out)} + {obs2('y', 'y', k, j, layer_in)}", "weight": 5.0},
+        {"kind": "EQ", "expr": f"{obs2('y', 'z', k, j, layer_out)} - {obs2('x', 'y', k, j, layer_in)}", "weight": 5.0}
+    ])
+
+    handled_pairs = {("x","x"), ("z","z"), ("z","x"), ("x","z"), ("y","z"), ("y","x"), ("x","y"), ("z","y"), ("y","y")}
+    for p1p2 in PAULI2:
+        if (p1p2[0], p1p2[1]) not in handled_pairs:
+            constraints.append({
+                "kind": "EQ",
+                "expr": f"{obs2(p1p2[0], p1p2[1], k, j, layer_out)} - {obs2(p1p2[0], p1p2[1], k, j, layer_in)}",
+                "weight": 2.0
+            })
+    return constraints
+
+# ── Main builder ──────────────────────────────────────────────────────
+
+def build_quantum_axl(circuit: QuantumCircuit, axl_problem_class: Any, axl_invariant_class: Any) -> Any:
+    """
+    Builds the AXL problem. 
+    Pass AXLProblemDef and AXLInvariant classes from your main script to avoid circular imports.
+    """
+    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: List[Dict] = []
+    
+    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})
+        if include_2b:
+            for q1 in range(n):
+                for q2 in range(q1 + 1, n):
+                    for p1p2 in PAULI2:
+                        variables.append({"name": obs2(p1p2[0], p1p2[1], q1, q2, layer), "lo": -1.0, "hi": 1.0})
+
+    obs_fixed = _initial_obs_values(circuit)
+
+    global_constraints: List[Dict] = []
+    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: List[Dict] = []
+    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: List[Dict] = []
+        gates_affecting: Set[int] = 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))
+            elif gate.type == "S":
+                q = gate.qubits[0]
+                gates_affecting.add(q)
+                scope_constraints.extend([
+                    {"kind": "EQ", "expr": f"{obs1('x', q, layer_out)} - {obs1('y', q, layer_in)}", "weight": 5.0},
+                    {"kind": "EQ", "expr": f"{obs1('y', q, layer_out)} + {obs1('x', q, layer_in)}", "weight": 5.0},
+                    {"kind": "EQ", "expr": f"{obs1('z', q, layer_out)} - {obs1('z', q, layer_in)}", "weight": 5.0}
+                ])
+            elif gate.type == "T":
+                q = gate.qubits[0]
+                gates_affecting.add(q)
+                c = round(math.cos(math.pi / 4), 8)
+                scope_constraints.extend([
+                    {"kind": "EQ", "expr": f"{obs1('x', q, layer_out)} - {c}*{obs1('x', q, layer_in)} - {c}*{obs1('y', q, layer_in)}", "weight": 5.0},
+                    {"kind": "EQ", "expr": f"{obs1('y', q, layer_out)} + {c}*{obs1('x', q, layer_in)} - {c}*{obs1('y', q, layer_in)}", "weight": 5.0},
+                    {"kind": "EQ", "expr": f"{obs1('z', q, layer_out)} - {obs1('z', q, layer_in)}", "weight": 5.0}
+                ])
+
+        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(p1p2[0], p1p2[1], q, q2, layer_out)} - {obs2(p1p2[0], p1p2[1], q, 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(p1p2[0], p1p2[1], q1, q2, layer_in), obs2(p1p2[0], p1p2[1], q1, 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 = []
+    if circuit.target_hamiltonian:
+        h_terms = []
+        for pauli_str, coeff in circuit.target_hamiltonian.items():
+            if len(pauli_str) == 2:
+                h_terms.append(f"({coeff})*{obs1(pauli_str[0], int(pauli_str[1:]), n_layers)}")
+            elif len(pauli_str) == 4:
+                h_terms.append(f"({coeff})*{obs2(pauli_str[0], pauli_str[1], int(pauli_str[2]), int(pauli_str[3]), n_layers)}")
+        if h_terms:
+            anchors.append(axl_invariant_class(
+                name="hamiltonian_expectation",
+                expr=" + ".join(h_terms),
+                tolerance=0.01,
+                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(
+        name=circuit.name,
+        description=(circuit.description or f"{n}-qubit circuit, {n_layers} layers"),
+        axioms={"CONTINUOUS", "CONSERVED", "TRANSITIVE", "BILINEAR", "METRIC", "SUPERPOSITION", "SYMMETRIC"},
+        variables=variables,
+        constraints=global_constraints,
+        scopes=scopes,
+        anchors=anchors,
+        observations=obs_fixed,
+    )
+
+# ══════════════════════════════════════════════════════════════════════
+# 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,
+        target_hamiltonian={"zz01": -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)},
+        target_hamiltonian={"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",
+        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),
+            QGate("Rx", [0], ["beta"], layer=2), QGate("Rx", [1], ["beta"], layer=2), QGate("Rx", [2], ["beta"], layer=2),
+        ],
+        param_bounds={"gamma": (0, math.pi), "beta": (0, math.pi / 2)},
+        target_hamiltonian={"zz01": -0.5, "zz12": -0.5, "zz02": -0.5}
+    )