add from_cirq

Author: refraction-ray

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### Added
 
+- Add `from_cirq` method for `Circuit` and `DMCircuit` to support translation from Cirq.
+
 - Add `tc.AnalogCircuit` for digital-analog hybrid simulation.
 
 - Add sparse matrix related methods for pytorch backend.

llm_experience.md

@@ -51,3 +51,24 @@ This document records specific technical protocols, lessons learned, and advance
 
 2.  **Fair Comparison**:
     *   Ensure "apples-to-apples" settings (e.g., same precision `complex128`) to support valid performance claims.
+
+## Noise Modeling and Mitigation
+
+1.  **Readout Error Handling**:
+    *   The `circuit_with_noise(c, noise_conf)` function internally applies general quantum noise (Kraus channels specified in `nc`) to gates, but it does **not** automatically apply readout error configuration (`readout_error`) encoded in `NoiseConf`.
+    *   **Protocol**: You must **explicitly** pass the readout error when calling `circuit.sample()`. Example: 
+        ```python
+        c_noisy.sample(..., readout_error=noise_conf.readout_error)
+        ```
+    *   Failing to do so will result in noiseless measurements even if `readout_error` is present in `NoiseConf`.
+
+2.  **Readout Error Format**:
+    *   When adding readout noise via `NoiseConf.add_noise("readout", errors)`, the expected format for each qubit's error is `[p(0|0), p(1|1)]` (a list of two probabilities), **not** the full $2 \times 2$ confusion matrix.
+    *   **Pitfall**: Passing a full matrix like `[[0.9, 0.1], [0.1, 0.9]]` can cause unexpected `TypeError` during internal matrix construction (e.g., `1 - list` error).
+    *   **Protocol**: Specify readout error as `[0.9, 0.9]` which implies $p(0|0)=0.9$ and $p(1|1)=0.9$.
+
+3.  **Circuit Expectation with Noise**:
+    *   The `Circuit.expectation` method supports `noise_conf` as a keyword argument (e.g., `c.expectation(..., noise_conf=conf, nmc=1000)`). This is often cleaner than calling `tc.noisemodel.expectation_noisfy(c, ...)` directly.
+
+4.  **Multi-Qubit Thermal Noise**:
+    *   The `thermalrelaxationchannel` returns single-qubit Kraus operators. To apply thermal noise to multi-qubit gates (like CNOT), you generally cannot simply pass the single-qubit channel to `add_noise("cnot", ...)` because of dimension mismatch.

tensorcircuit/abstractcircuit.py

@@ -916,6 +916,47 @@ def from_qiskit(
             binding_params=binding_params,
         )
 
+    @classmethod
+    def from_cirq(
+        cls,
+        qc: Any,
+        n: Optional[int] = None,
+        inputs: Optional[List[float]] = None,
+        circuit_params: Optional[Dict[str, Any]] = None,
+    ) -> "AbstractCircuit":
+        """
+        Import Cirq Circuit object as a ``tc.Circuit`` object.
+
+        :Example:
+
+        >>> import cirq
+        >>> c = cirq.Circuit()
+        >>> q = cirq.LineQubit.range(3)
+        >>> c.append(cirq.H(q[0]))
+        >>> c.append(cirq.CNOT(q[0], q[1]))
+        >>> tc_c = tc.Circuit.from_cirq(c)
+
+        :param qc: Cirq Circuit object
+        :type qc: cirq.Circuit
+        :param n: The number of qubits for the circuit
+        :type n: int
+        :param inputs: possible input wavefunction for ``tc.Circuit``, defaults to None
+        :type inputs: Optional[List[float]], optional
+        :param circuit_params: kwargs given in Circuit.__init__ construction function, default to None.
+        :type circuit_params: Optional[Dict[str, Any]]
+        :return: The same circuit but as tensorcircuit object
+        :rtype: Circuit
+        """
+        from .translation import cirq2tc
+
+        return cirq2tc(  # type: ignore
+            qc,
+            n,
+            inputs,
+            circuit_constructor=cls,
+            circuit_params=circuit_params,
+        )
+
     def vis_tex(self, **kws: Any) -> str:
         """
         Generate latex string based on quantikz latex package

tensorcircuit/analogcircuit.py

@@ -169,7 +169,7 @@ def wrapper(*args, **kwargs):  # type: ignore
                 f"object has no attribute '{name}'."
             )
 
-    def state(self) -> Tensor:
+    def state(self, form: str = "default") -> Tensor:
         """
         Executes the full digital-analog sequence.
 
@@ -209,8 +209,13 @@ def state(self) -> Tensor:
         else:
             psi = self.digital_circuits[-1].wavefunction()
         self._effective_circuit = Circuit(self.num_qubits, inputs=psi)
-
-        return psi
+        if form == "default":
+            shape = [-1]
+        elif form == "ket":
+            shape = [-1, 1]
+        elif form == "bra":  # no conj here
+            shape = [1, -1]
+        return backend.reshape(psi, shape=shape)
 
     wavefunction = state
 

tensorcircuit/translation.py

@@ -792,3 +792,124 @@ def qiskit_from_qasm_str_ordered_measure(qasm_str: str) -> Any:
     for qid, cid in measure_sequence:
         qc.measure(qid, cid)
     return qc
+
+
+def cirq2tc(
+    qc: Any,
+    n: Optional[int] = None,
+    inputs: Optional[List[float]] = None,
+    is_dm: bool = False,
+    circuit_constructor: Any = None,
+    circuit_params: Optional[Dict[str, Any]] = None,
+) -> Any:
+    """
+    Generate a tensorcircuit circuit from the cirq circuit.
+
+    :param qc: A quantum circuit in cirq
+    :type qc: cirq.Circuit
+    :param n: # of qubits, defaults to None
+    :type n: Optional[int], optional
+    :param inputs: Input state of the circuit, defaults to None
+    :type inputs: Optional[List[float]], optional
+    :param is_dm: whether to use DMCircuit, defaults to False
+    :type is_dm: bool, optional
+    :param circuit_constructor: _description_, defaults to None
+    :type circuit_constructor: Any, optional
+    :param circuit_params: _description_, defaults to None
+    :type circuit_params: Optional[Dict[str, Any]], optional
+    :return: _description_
+    :rtype: Any
+    """
+
+    if circuit_constructor is not None:
+        Circ = circuit_constructor
+    elif is_dm:
+        Circ = DMCircuit2
+    else:
+        Circ = Circuit
+
+    if n is None:
+        n = len(sorted(qc.all_qubits()))
+
+    if circuit_params is None:
+        circuit_params = {}
+    if "nqubits" not in circuit_params:
+        circuit_params["nqubits"] = n
+
+    if inputs is not None:
+        circuit_params["inputs"] = inputs
+
+    tc_circuit: Any = Circ(**circuit_params)
+
+    qubits = sorted(qc.all_qubits())
+    qubit_map = {q: i for i, q in enumerate(qubits)}
+
+    for op in qc.all_operations():
+        if isinstance(op.gate, cirq.MeasurementGate):
+            for q in op.qubits:
+                tc_circuit.measure_instruction(qubit_map[q])
+            continue
+
+        index = [qubit_map[q] for q in op.qubits]
+        gate = op.gate
+        # gate_name = str(gate)
+
+        if isinstance(gate, cirq.IdentityGate):
+            continue
+
+        # Standard Gates (and PowGates with exp=1)
+        if isinstance(gate, cirq.HPowGate) and np.isclose(gate.exponent, 1):
+            tc_circuit.h(*index)
+        elif isinstance(gate, cirq.XPowGate) and np.isclose(gate.exponent, 1):
+            tc_circuit.x(*index)
+        elif isinstance(gate, cirq.YPowGate) and np.isclose(gate.exponent, 1):
+            tc_circuit.y(*index)
+        elif isinstance(gate, cirq.ZPowGate) and np.isclose(gate.exponent, 1):
+            tc_circuit.z(*index)
+        elif isinstance(gate, cirq.SwapPowGate) and np.isclose(gate.exponent, 1):
+            tc_circuit.swap(*index)
+        elif isinstance(gate, cirq.ISwapPowGate) and np.isclose(gate.exponent, 1):
+            tc_circuit.iswap(*index)
+        elif isinstance(gate, cirq.CNotPowGate) and np.isclose(gate.exponent, 1):
+            tc_circuit.cnot(*index)
+        elif isinstance(gate, cirq.CZPowGate) and np.isclose(gate.exponent, 1):
+            tc_circuit.cz(*index)
+
+        # Variable Gates (X, Y, Z, ISWAP family)
+        elif isinstance(gate, cirq.XPowGate):
+            tc_circuit.rx(*index, theta=gate.exponent * np.pi)
+        elif isinstance(gate, cirq.YPowGate):
+            tc_circuit.ry(*index, theta=gate.exponent * np.pi)
+        elif isinstance(gate, cirq.ZPowGate):
+            if np.isclose(gate.exponent, 0.5):
+                tc_circuit.s(*index)
+            elif np.isclose(gate.exponent, 0.25):
+                tc_circuit.t(*index)
+            else:
+                tc_circuit.rz(*index, theta=gate.exponent * np.pi)
+        elif isinstance(gate, cirq.ISwapPowGate):
+            tc_circuit.iswap(*index, theta=gate.exponent)
+
+        elif isinstance(gate, cirq.FSimGate):
+            tc_circuit.iswap(*index, theta=-gate.theta * 2 / np.pi)
+            tc_circuit.cphase(*index, theta=-gate.phi)
+        elif isinstance(gate, cirq.PhasedXPowGate):
+            # Rz(phase_exponent * pi) Rx(exponent * pi) Rz(-phase_exponent * pi)
+            tc_circuit.rz(*index, theta=-gate.phase_exponent * np.pi)
+            tc_circuit.rx(*index, theta=gate.exponent * np.pi)
+            tc_circuit.rz(*index, theta=gate.phase_exponent * np.pi)
+        elif isinstance(gate, cirq.MatrixGate):
+            # Arbitrary unitary
+            m = cirq.unitary(gate)
+            tc_circuit.any(*index, unitary=m)
+        else:
+            # try to get unitary
+            try:
+                m = cirq.unitary(gate)
+                tc_circuit.any(*index, unitary=m)
+            except (TypeError, ValueError):
+                logger.warning(
+                    f"Cirq gate {gate} not supported in translation, skipping"
+                )
+
+    return tc_circuit

tests/test_circuit.py

@@ -1732,3 +1732,83 @@ def test_projected_subsystem(backend):
     )
     assert tc.backend.shape_tuple(s) == (4, 4)
     np.testing.assert_allclose(s[3, 3], 0.8108051, atol=1e-5)
+
+
+@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")])
+def test_cirq_translation(backend):
+    try:
+        import cirq
+    except ImportError:
+        pytest.skip("cirq is not installed")
+
+    n = 3
+    q = cirq.LineQubit.range(n)
+    c = cirq.Circuit()
+    c.append(cirq.H(q[0]))
+    c.append(cirq.H(q[1]))
+    c.append(cirq.CNOT(q[0], q[1]))
+    c.append(cirq.rx(0.5)(q[0]))
+    c.append(cirq.ry(0.2)(q[1]))
+    c.append(cirq.rz(0.5)(q[2]))
+    c.append(cirq.CNOT(q[1], q[2]))
+    c.append(cirq.CZ(q[1], q[0]))
+
+    c_tc = tc.Circuit.from_cirq(c)
+
+    # Validation via unitary
+    u_cirq = cirq.unitary(c)
+    u_tc = c_tc.matrix()
+
+    np.testing.assert_allclose(u_cirq, tc.backend.numpy(u_tc), atol=1e-5)
+
+
+def assert_allclose_up_to_global_phase(a, b, atol=1e-5):
+    a = np.array(a)
+    b = np.array(b)
+    flat_a = a.flatten()
+    flat_b = b.flatten()
+    idx = np.argmax(np.abs(flat_a))
+    if np.abs(flat_a[idx]) < 1e-10:
+        np.testing.assert_allclose(a, b, atol=atol)
+        return
+
+    phase_diff = flat_a[idx] / flat_b[idx]
+    b = b * phase_diff
+    np.testing.assert_allclose(a, b, atol=atol)
+
+
+@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")])
+def test_cirq_gates_translation(backend):
+    try:
+        import cirq
+    except ImportError:
+        pytest.skip("cirq is not installed")
+
+    n = 3
+    q = cirq.LineQubit.range(n)
+
+    # Test FSim and ISWAP
+    c2 = cirq.Circuit()
+    c2.append(cirq.ISWAP(q[0], q[1]))
+    c2.append(cirq.FSimGate(0.1, 0.2)(q[1], q[2]))
+
+    c2_tc = tc.Circuit.from_cirq(c2)
+    u_cirq2 = cirq.unitary(c2)
+    u_tc2 = c2_tc.matrix()
+    assert_allclose_up_to_global_phase(u_cirq2, tc.backend.numpy(u_tc2), atol=1e-5)
+
+    # Test PhasedXPow
+    c3 = cirq.Circuit()
+    c3.append(cirq.PhasedXPowGate(phase_exponent=0.1, exponent=0.2)(q[0]))
+    c3_tc = tc.Circuit.from_cirq(c3)
+    u_cirq3 = cirq.unitary(c3)
+    u_tc3 = c3_tc.matrix()
+    assert_allclose_up_to_global_phase(u_cirq3, tc.backend.numpy(u_tc3), atol=1e-5)
+
+    # Test random parameter ISWAP
+    c4 = cirq.Circuit()
+    c4.append(cirq.ISwapPowGate(exponent=0.3)(q[0], q[1]))
+    c4_tc = tc.Circuit.from_cirq(c4)
+    u_cirq4 = cirq.unitary(c4)
+    u_tc4 = c4_tc.matrix()
+    assert_allclose_up_to_global_phase(u_cirq4, tc.backend.numpy(u_tc4), atol=1e-5)