consistent qir

Author: refraction-ray

tensorcircuit/mpscircuit.py

@@ -121,6 +121,7 @@ def __init__(
             "split": split,
             "tensors": tensors,
             "wavefunction": wavefunction,
+            "dim": dim,
         }
         if split is None:
             split = {}

tensorcircuit/stabilizercircuit.py

@@ -48,9 +48,17 @@ def __init__(
         self._stim_circuit = stim.Circuit()
         self._qir: List[Dict[str, Any]] = []
         self.is_dm = False
-        self.inputs = None
+        self.inputs = inputs
+        self.tableau_inputs = tableau_inputs
         self._extra_qir: List[Dict[str, Any]] = []
         self.current_sim = stim.TableauSimulator()
+
+        self.circuit_param = {
+            "nqubits": nqubits,
+            "inputs": inputs,
+            "tableau_inputs": tableau_inputs,
+        }
+
         if inputs:
             self.current_sim.set_state_from_stabilizers(inputs)
         if tableau_inputs:

tensorcircuit/u1circuit.py

@@ -49,6 +49,13 @@ def __init__(
         self._extra_qir: List[Dict[str, Any]] = []
         self.is_mps = False
 
+        self.circuit_param = {
+            "nqubits": nqubits,
+            "k": k,
+            "filled": filled,
+            "inputs": inputs,
+        }
+
         # Mapping helpers
         # TC uses qubit 0 as the leftmost (highest) bit
         # So qubit i corresponds to bit position (n-1-i) in the state integer
@@ -192,32 +199,6 @@ def _apply_iswap(self, i: int, j: int, theta: Any) -> None:
             cos_t * self._state + isin_t * swapped_state
         )
 
-    def _apply_fsim(self, i: int, j: int, theta: Any, phi: Any) -> None:
-        """Apply fSim(theta, phi): fermionic simulation gate."""
-        bpi, bpj = self._bit_position(i), self._bit_position(j)
-        mask_i = 1 << bpi
-        mask_j = 1 << bpj
-        bi = backend.right_shift(backend.bitwise_and(self._basis_tensor, mask_i), bpi)
-        bj = backend.right_shift(backend.bitwise_and(self._basis_tensor, mask_j), bpj)
-        diff = backend.bitwise_xor(bi, bj)
-        mask_swap = (1 << bpi) | (1 << bpj)
-        new_basis = backend.bitwise_xor(self._basis_tensor, diff * mask_swap)
-        indices = backend.searchsorted(self._basis_tensor, new_basis)
-
-        theta_c = backend.cast(backend.convert_to_tensor(theta), dtypestr)
-        phi_c = backend.cast(backend.convert_to_tensor(phi), dtypestr)
-        both_on = backend.cast(backend.bitwise_and(bi, bj), dtypestr)
-        phi_factor = 1.0 + (backend.exp(-1j * phi_c) - 1.0) * both_on
-
-        cos_theta = backend.cos(theta_c)
-        isin_theta = 1j * backend.sin(theta_c)
-        diff_f = backend.cast(diff, dtypestr)
-        swapped_state = backend.gather1d(self._state, indices)
-
-        self._state = (1.0 - diff_f) * self._state * phi_factor + diff_f * (
-            cos_theta * self._state - isin_theta * swapped_state
-        )
-
     # -------------------------------------------------------------------------
     # Public gate methods (delegate to internal implementations)
     # -------------------------------------------------------------------------
@@ -227,16 +208,24 @@ def apply_general_gate(
         gate: Any,
         *index: int,
         name: Optional[str] = None,
+        split: Optional[Dict[str, Any]] = None,
+        mpo: bool = False,
+        ir_dict: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ) -> None:
         """
         Apply a gate by name. Called by _meta_apply generated methods.
 
         :param gate: Gate tensor (ignored, dispatch is by name)
         :param index: Qubit indices
-        :param name: Gate name (rz, rzz, cz, cphase, swap, iswap, fsim)
-        :param kwargs: May contain ir_dict with parameters from _meta_apply
+        :param name: Gate name (rz, rzz, cz, cphase, swap, iswap)
+        :param split: Split configuration (ignored in U1Circuit)
+        :param mpo: MPO flag (ignored in U1Circuit)
+        :param ir_dict: QIR dictionary for recording
+        :param kwargs: Extra parameters
         """
+        if name is None:
+            name = ""
         non_u1 = {"x", "y", "h", "t", "s", "td", "sd", "rx", "ry"}
         if name and name.lower() in non_u1:
             raise ValueError(
@@ -246,7 +235,28 @@ def apply_general_gate(
         gate_name = name.lower() if name else None
 
         # Extract parameters: _meta_apply puts them in ir_dict['parameters']
-        params = kwargs.get("ir_dict", {}).get("parameters", kwargs)
+        # Also check kwargs for direct calls
+        params = {}
+        if ir_dict is not None and "parameters" in ir_dict:
+            params.update(ir_dict["parameters"])
+        params.update(kwargs)
+
+        # Record gate in QIR
+        gate_dict = {
+            "gate": gate,
+            "index": index,
+            "name": name,
+            "split": split,
+            "mpo": mpo,
+        }
+        if params:
+            gate_dict["parameters"] = params
+
+        if ir_dict is not None:
+            ir_dict.update(gate_dict)
+        else:
+            ir_dict = gate_dict
+        self._qir.append(ir_dict)
 
         if gate_name == "rz":
             self._apply_rz(index[0], params.get("theta", 0))
@@ -260,23 +270,16 @@ def apply_general_gate(
             self._apply_swap(index[0], index[1])
         elif gate_name == "iswap":
             self._apply_iswap(index[0], index[1], params.get("theta", 1.0))
-        elif gate_name == "fsim":
-            self._apply_fsim(
-                index[0], index[1], params.get("theta", 0), params.get("phi", 0)
-            )
+        elif gate_name == "cphase":
+            self._apply_cphase(index[0], index[1], params.get("theta", 0))
         else:
             raise ValueError(
                 f"Gate {name} not implemented in U1Circuit. "
-                "Supported: rz, rzz, cz, cphase, swap, iswap, fsim."
+                "Supported: rz, rzz, cz, cphase, swap, iswap."
             )
 
     # Note: Most gate methods (rz, rzz, cz, swap, iswap, cphase, etc.) are
     # auto-generated by _meta_apply() which calls apply_general_gate.
-    # fsim is not in the standard gate list, so we define it explicitly.
-
-    def fsim(self, i: int, j: int, theta: Any = 0, phi: Any = 0, **kwargs: Any) -> None:
-        """Apply fSim gate on qubits i and j."""
-        self._apply_fsim(i, j, theta, phi)
 
     # -------------------------------------------------------------------------
     # State and expectation methods
@@ -585,5 +588,3 @@ def measure(
 
 # Register gates via _meta_apply
 U1Circuit._meta_apply()
-
-# TODO(@refraction-ray): qir support

tests/test_qir_unification.py

@@ -0,0 +1,167 @@
+import numpy as np
+import pytest
+from pytest_lazyfixture import lazy_fixture as lf
+import tensorcircuit as tc
+from tensorcircuit.u1circuit import U1Circuit
+from tensorcircuit.stabilizercircuit import StabilizerCircuit
+from tensorcircuit.mpscircuit import MPSCircuit
+
+
+@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")])
+def test_u1circuit_qir_roundtrip(backend):
+    n = 4
+    k = 2
+    c = U1Circuit(n, k=k, filled=[0, 1])
+    c.rz(0, theta=0.5)
+    c.cz(0, 1)
+    c.iswap(1, 2, theta=0.8)
+    c.cphase(2, 3, theta=0.4)
+
+    qir = c.to_qir()
+    assert len(qir) == 4
+
+    # Reconstruct from QIR
+    c2 = U1Circuit.from_qir(qir, c.circuit_param)
+
+    # Verify expectations
+    for i in range(n):
+        np.testing.assert_allclose(
+            tc.backend.numpy(c.expectation_z(i)),
+            tc.backend.numpy(c2.expectation_z(i)),
+            atol=1e-5,
+        )
+
+
+@pytest.mark.parametrize("backend", [lf("npb")])
+def test_stabilizer_qir_roundtrip(backend):
+    n = 4
+    c = StabilizerCircuit(n)
+    c.h(0)
+    c.cnot(0, 1)
+    c.s(1)
+
+    qir = c.to_qir()
+    assert len(qir) == 3
+
+    c2 = StabilizerCircuit.from_qir(qir, c.circuit_param)
+
+    # Compare state vectors (TableauSimulator to_state_vector)
+    np.testing.assert_allclose(
+        tc.backend.numpy(c.state()), tc.backend.numpy(c2.state()), atol=1e-5
+    )
+
+
+@pytest.mark.parametrize("backend", [lf("npb"), lf("jaxb")])
+def test_mps_qir_roundtrip(backend):
+    n = 4
+    c = MPSCircuit(n)
+    c.h(0)
+    c.cnot(0, 1)
+    c.rz(1, theta=0.8)
+
+    qir = c.to_qir()
+    assert len(qir) == 3
+
+    c2 = MPSCircuit.from_qir(qir, c.circuit_param)
+
+    np.testing.assert_allclose(
+        tc.backend.numpy(c.wavefunction()),
+        tc.backend.numpy(c2.wavefunction()),
+        atol=1e-5,
+    )
+
+
+@pytest.mark.parametrize("backend", [lf("npb")])
+def test_circuit_to_stabilizer(backend):
+    n = 2
+    c = tc.Circuit(n)
+    c.h(0)
+    c.cnot(0, 1)
+    c.s(1)
+    c.x(0)
+
+    qir = c.to_qir()
+    # Convert to StabilizerCircuit
+    c_stab = StabilizerCircuit.from_qir(qir, circuit_params={"nqubits": n})
+
+    np.testing.assert_allclose(
+        tc.backend.numpy(c.state()), tc.backend.numpy(c_stab.state()), atol=1e-5
+    )
+
+
+@pytest.mark.parametrize("backend", [lf("npb"), lf("jaxb")])
+def test_u1_to_mps(backend):
+    n = 4
+    c_u1 = U1Circuit(n, k=2, filled=[0, 1])
+    c_u1.rz(0, theta=0.5)
+    c_u1.cz(0, 1)
+    c_u1.iswap(1, 2, theta=1.2)
+    c_u1.rzz(3, 2, theta=-0.9)
+
+    qir = c_u1.to_qir()
+
+    c_mps = MPSCircuit(n)
+    # Match initial state of U1 ([0,1] filled)
+    c_mps.x(0)
+    c_mps.x(1)
+    c_mps.append_from_qir(qir)
+
+    np.testing.assert_allclose(
+        tc.backend.numpy(c_u1.to_dense()),
+        tc.backend.numpy(c_mps.wavefunction().reshape([-1])),
+        atol=1e-5,
+    )
+
+
+@pytest.mark.parametrize("backend", [lf("npb")])
+def test_mps_to_circuit(backend):
+    n = 2
+    c_mps = MPSCircuit(n)
+    c_mps.h(0)
+    c_mps.cnot(0, 1)
+    c_mps.ryy(1, 0, theta=0.9)
+    c_mps.x(1)
+
+    qir = c_mps.to_qir()
+    c_std = tc.Circuit.from_qir(qir, circuit_params={"nqubits": n})
+
+    np.testing.assert_allclose(
+        tc.backend.numpy(c_mps.wavefunction().reshape([-1])),
+        tc.backend.numpy(c_std.state()),
+        atol=1e-5,
+    )
+
+
+@pytest.mark.parametrize("backend", [lf("npb"), lf("jaxb")])
+def test_dm_to_u1(backend):
+    n = 2
+    c_dm = tc.DMCircuit(n)
+    c_dm.rz(0, theta=0.5)
+    c_dm.cz(0, 1)
+    c_dm.cphase(1, 0, theta=-1.1)
+
+    qir = c_dm.to_qir()
+    c_u1 = U1Circuit(n, k=0)
+    c_u1.append_from_qir(qir)
+
+    dm = tc.backend.numpy(c_dm.state())
+    st = tc.backend.numpy(c_u1.to_dense())
+    np.testing.assert_allclose(dm, np.outer(st, np.conj(st)), atol=1e-5)
+
+
+@pytest.mark.parametrize("backend", [lf("npb")])
+def test_mps_to_stabilizer(backend):
+    n = 2
+    c_mps = MPSCircuit(n)
+    c_mps.h(0)
+    c_mps.cnot(0, 1)
+    c_mps.s(1)
+
+    qir = c_mps.to_qir()
+    c_stab = StabilizerCircuit.from_qir(qir, circuit_params={"nqubits": n})
+
+    np.testing.assert_allclose(
+        tc.backend.numpy(c_mps.wavefunction().reshape([-1])),
+        tc.backend.numpy(c_stab.state()),
+        atol=1e-5,
+    )