bloqade-circuit 0.7.13__py3-none-any.whl → 0.8.0__py3-none-any.whl

bloqade/cirq_utils/emit/gate.py

@@ -0,0 +1,104 @@
+import math
+
+import cirq
+from kirin.interp import MethodTable, impl
+
+from bloqade.squin import gate
+
+from .base import EmitCirq, EmitCirqFrame
+
+
+@gate.dialect.register(key="emit.cirq")
+class __EmitCirqGateMethods(MethodTable):
+
+    @impl(gate.stmts.X)
+    @impl(gate.stmts.Y)
+    @impl(gate.stmts.Z)
+    @impl(gate.stmts.H)
+    def hermitian(
+        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: gate.stmts.SingleQubitGate
+    ):
+        qubits = frame.get(stmt.qubits)
+        cirq_op = getattr(cirq, stmt.name.upper())
+        frame.circuit.append(cirq_op.on_each(qubits))
+        return ()
+
+    @impl(gate.stmts.S)
+    @impl(gate.stmts.T)
+    def unitary(
+        self,
+        emit: EmitCirq,
+        frame: EmitCirqFrame,
+        stmt: gate.stmts.SingleQubitNonHermitianGate,
+    ):
+        qubits = frame.get(stmt.qubits)
+        cirq_op = getattr(cirq, stmt.name.upper())
+        if stmt.adjoint:
+            cirq_op = cirq_op ** (-1)
+
+        frame.circuit.append(cirq_op.on_each(qubits))
+        return ()
+
+    @impl(gate.stmts.SqrtX)
+    @impl(gate.stmts.SqrtY)
+    def sqrt(
+        self,
+        emit: EmitCirq,
+        frame: EmitCirqFrame,
+        stmt: gate.stmts.SqrtX | gate.stmts.SqrtY,
+    ):
+        qubits = frame.get(stmt.qubits)
+
+        exponent = 0.5
+        if stmt.adjoint:
+            exponent *= -1
+
+        if isinstance(stmt, gate.stmts.SqrtX):
+            cirq_op = cirq.XPowGate(exponent=exponent)
+        else:
+            cirq_op = cirq.YPowGate(exponent=exponent)
+
+        frame.circuit.append(cirq_op.on_each(qubits))
+        return ()
+
+    @impl(gate.stmts.CX)
+    @impl(gate.stmts.CY)
+    @impl(gate.stmts.CZ)
+    def control(
+        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: gate.stmts.ControlledGate
+    ):
+        controls = frame.get(stmt.controls)
+        targets = frame.get(stmt.targets)
+        cirq_op = getattr(cirq, stmt.name.upper())
+        cirq_qubits = [(ctrl, target) for ctrl, target in zip(controls, targets)]
+        frame.circuit.append(cirq_op.on_each(cirq_qubits))
+        return ()
+
+    @impl(gate.stmts.Rx)
+    @impl(gate.stmts.Ry)
+    @impl(gate.stmts.Rz)
+    def rot(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: gate.stmts.RotationGate):
+        qubits = frame.get(stmt.qubits)
+
+        turns = frame.get(stmt.angle)
+        angle = turns * 2 * math.pi
+        cirq_op = getattr(cirq, stmt.name.title())(rads=angle)
+
+        frame.circuit.append(cirq_op.on_each(qubits))
+        return ()
+
+    @impl(gate.stmts.U3)
+    def u3(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: gate.stmts.U3):
+        qubits = frame.get(stmt.qubits)
+
+        theta = frame.get(stmt.theta) * 2 * math.pi
+        phi = frame.get(stmt.phi) * 2 * math.pi
+        lam = frame.get(stmt.lam) * 2 * math.pi
+
+        frame.circuit.append(cirq.Rz(rads=lam).on_each(*qubits))
+
+        frame.circuit.append(cirq.Ry(rads=theta).on_each(*qubits))
+
+        frame.circuit.append(cirq.Rz(rads=phi).on_each(*qubits))
+
+        return ()

bloqade/cirq_utils/emit/noise.py

@@ -0,0 +1,90 @@
+import cirq
+from kirin.interp import MethodTable, impl
+
+from bloqade.squin import noise
+
+from .base import EmitCirq, EmitCirqFrame
+
+
+@noise.dialect.register(key="emit.cirq")
+class __EmitCirqNoiseMethods(MethodTable):
+
+    two_qubit_paulis = (
+        "IX",
+        "IY",
+        "IZ",
+        "XI",
+        "XX",
+        "XY",
+        "XZ",
+        "YI",
+        "YX",
+        "YY",
+        "YZ",
+        "ZI",
+        "ZX",
+        "ZY",
+        "ZZ",
+    )
+
+    @impl(noise.stmts.Depolarize)
+    def depolarize(
+        self, interp: EmitCirq, frame: EmitCirqFrame, stmt: noise.stmts.Depolarize
+    ):
+        p = frame.get(stmt.p)
+        qubits = frame.get(stmt.qubits)
+        cirfq_op = cirq.depolarize(p, n_qubits=1).on_each(qubits)
+        frame.circuit.append(cirfq_op)
+        return ()
+
+    @impl(noise.stmts.Depolarize2)
+    def depolarize2(
+        self, interp: EmitCirq, frame: EmitCirqFrame, stmt: noise.stmts.Depolarize2
+    ):
+        p = frame.get(stmt.p)
+        controls = frame.get(stmt.controls)
+        targets = frame.get(stmt.targets)
+        cirq_qubits = [(ctrl, target) for ctrl, target in zip(controls, targets)]
+        cirq_op = cirq.depolarize(p, n_qubits=2).on_each(cirq_qubits)
+        frame.circuit.append(cirq_op)
+        return ()
+
+    @impl(noise.stmts.SingleQubitPauliChannel)
+    def single_qubit_pauli_channel(
+        self,
+        interp: EmitCirq,
+        frame: EmitCirqFrame,
+        stmt: noise.stmts.SingleQubitPauliChannel,
+    ):
+        px = frame.get(stmt.px)
+        py = frame.get(stmt.py)
+        pz = frame.get(stmt.pz)
+        qubits = frame.get(stmt.qubits)
+
+        cirq_op = cirq.asymmetric_depolarize(px, py, pz).on_each(qubits)
+        frame.circuit.append(cirq_op)
+
+        return ()
+
+    @impl(noise.stmts.TwoQubitPauliChannel)
+    def two_qubit_pauli_channel(
+        self,
+        interp: EmitCirq,
+        frame: EmitCirqFrame,
+        stmt: noise.stmts.TwoQubitPauliChannel,
+    ):
+        ps = frame.get(stmt.probabilities)
+        error_probabilities = {
+            key: p for (key, p) in zip(self.two_qubit_paulis, ps) if p != 0
+        }
+
+        controls = frame.get(stmt.controls)
+        targets = frame.get(stmt.targets)
+        cirq_qubits = [(ctrl, target) for ctrl, target in zip(controls, targets)]
+
+        cirq_op = cirq.asymmetric_depolarize(
+            error_probabilities=error_probabilities
+        ).on_each(cirq_qubits)
+        frame.circuit.append(cirq_op)
+
+        return ()

bloqade/cirq_utils/emit/qubit.py

@@ -0,0 +1,35 @@
+import cirq
+from kirin.interp import MethodTable, impl
+
+from bloqade.qubit import stmts as qubit
+
+from .base import EmitCirq, EmitCirqFrame
+
+
+@qubit.dialect.register(key="emit.cirq")
+class EmitCirqQubitMethods(MethodTable):
+    @impl(qubit.New)
+    def new(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: qubit.New):
+        if frame.qubits is not None:
+            cirq_qubit = frame.qubits[frame.qubit_index]
+        else:
+            cirq_qubit = cirq.LineQubit(frame.qubit_index)
+
+        frame.qubit_index += 1
+        return (cirq_qubit,)
+
+    @impl(qubit.Measure)
+    def measure_qubit_list(
+        self, emit: EmitCirq, frame: EmitCirqFrame, stmt: qubit.Measure
+    ):
+        qbits = frame.get(stmt.qubits)
+        frame.circuit.append(cirq.measure(qbits))
+        return (emit.void,)
+
+    @impl(qubit.Reset)
+    def reset(self, emit: EmitCirq, frame: EmitCirqFrame, stmt: qubit.Reset):
+        qubits = frame.get(stmt.qubits)
+        frame.circuit.append(
+            cirq.ResetChannel().on_each(*qubits),
+        )
+        return ()