bloqade-circuit 0.4.0__tar.gz → 0.4.2__tar.gz

{bloqade_circuit-0.4.0 → bloqade_circuit-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.4.0
+Version: 0.4.2
 Summary: The software development toolkit for neutral atom arrays.
 Author-email: Roger-luo <rluo@quera.com>, kaihsin <khwu@quera.com>, weinbe58 <pweinberg@quera.com>, johnzl-777 <jlong@quera.com>
 License-File: LICENSE

{bloqade_circuit-0.4.0 → bloqade_circuit-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bloqade-circuit"
-version = "0.4.0"
+version = "0.4.2"
 description = "The software development toolkit for neutral atom arrays."
 readme = "README.md"
 authors = [

{bloqade_circuit-0.4.0 → bloqade_circuit-0.4.2}/src/bloqade/pyqrack/__init__.py

@@ -16,7 +16,7 @@ from .task import PyQrackSimulatorTask as PyQrackSimulatorTask
 # NOTE: The following import is for registering the method tables
 from .noise import native as native
 from .qasm2 import uop as uop, core as core, glob as glob, parallel as parallel
-from .squin import op as op, qubit as qubit
+from .squin import op as op, noise as noise, qubit as qubit
 from .device import (
     StackMemorySimulator as StackMemorySimulator,
     DynamicMemorySimulator as DynamicMemorySimulator,

bloqade_circuit-0.4.2/src/bloqade/pyqrack/squin/noise/__init__.py

@@ -0,0 +1 @@
+from . import native as native

bloqade_circuit-0.4.2/src/bloqade/pyqrack/squin/noise/native.py

@@ -0,0 +1,72 @@
+import random
+import typing
+from dataclasses import dataclass
+
+from kirin import interp
+from kirin.dialects import ilist
+
+from bloqade.pyqrack import QubitState, PyQrackQubit, PyQrackInterpreter
+from bloqade.squin.noise.stmts import QubitLoss, StochasticUnitaryChannel
+from bloqade.squin.noise._dialect import dialect as squin_noise_dialect
+
+from ..runtime import OperatorRuntimeABC
+
+
+@dataclass(frozen=True)
+class StochasticUnitaryChannelRuntime(OperatorRuntimeABC):
+    operators: ilist.IList[OperatorRuntimeABC, typing.Any]
+    probabilities: ilist.IList[float, typing.Any]
+
+    @property
+    def n_sites(self) -> int:
+        n = self.operators[0].n_sites
+        for op in self.operators[1:]:
+            assert (
+                op.n_sites == n
+            ), "Encountered a stochastic unitary channel with operators of different size!"
+        return n
+
+    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
+        # NOTE: probabilities don't necessarily sum to 1; could be no noise event should occur
+        p_no_op = 1 - sum(self.probabilities)
+        if random.uniform(0.0, 1.0) < p_no_op:
+            return
+
+        selected_ops = random.choices(self.operators, weights=self.probabilities)
+        for op in selected_ops:
+            op.apply(*qubits, adjoint=adjoint)
+
+
+@dataclass(frozen=True)
+class QubitLossRuntime(OperatorRuntimeABC):
+    p: float
+
+    @property
+    def n_sites(self) -> int:
+        return 1
+
+    def apply(self, qubit: PyQrackQubit, adjoint: bool = False) -> None:
+        if random.uniform(0.0, 1.0) < self.p:
+            qubit.state = QubitState.Lost
+
+
+@squin_noise_dialect.register(key="pyqrack")
+class PyQrackMethods(interp.MethodTable):
+    @interp.impl(StochasticUnitaryChannel)
+    def stochastic_unitary_channel(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: StochasticUnitaryChannel,
+    ):
+        operators = frame.get(stmt.operators)
+        probabilities = frame.get(stmt.probabilities)
+
+        return (StochasticUnitaryChannelRuntime(operators, probabilities),)
+
+    @interp.impl(QubitLoss)
+    def qubit_loss(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: QubitLoss
+    ):
+        p = frame.get(stmt.p)
+        return (QubitLossRuntime(p),)

{bloqade_circuit-0.4.0 → bloqade_circuit-0.4.2}/src/bloqade/qasm2/parse/lowering.py

@@ -2,9 +2,9 @@ from typing import Any
 from dataclasses import field, dataclass
 
 from kirin import ir, types, lowering
-from kirin.dialects import cf, func, ilist
+from kirin.dialects import cf, scf, func, ilist
 
-from bloqade.qasm2.types import CRegType, QRegType
+from bloqade.qasm2.types import CRegType, QRegType, QubitType
 from bloqade.qasm2.dialects import uop, core, expr, glob, noise, parallel
 
 from . import ast
@@ -101,6 +101,13 @@ class QASM2(lowering.LoweringABC[ast.Node]):
     def lower_global(
         self, state: lowering.State[ast.Node], node: ast.Node
     ) -> lowering.LoweringABC.Result:
+        if isinstance(node, ast.Name):
+            # NOTE: might be a lookup for a gate function invoke
+            try:
+                return lowering.LoweringABC.Result(state.current_frame.globals[node.id])
+            except KeyError:
+                pass
+
         raise lowering.BuildError("Global variables are not supported in QASM 2.0")
 
     def visit_MainProgram(self, state: lowering.State[ast.Node], node: ast.MainProgram):
@@ -171,7 +178,6 @@ class QASM2(lowering.LoweringABC[ast.Node]):
     def visit_Reset(self, state: lowering.State[ast.Node], node: ast.Reset):
         state.current_frame.push(core.Reset(qarg=state.lower(node.qarg).expect_one()))
 
-    # TODO: clean this up? copied from cf dialect with a small modification
     def visit_IfStmt(self, state: lowering.State[ast.Node], node: ast.IfStmt):
         cond_stmt = core.CRegEq(
             lhs=state.lower(node.cond.lhs).expect_one(),
@@ -179,84 +185,23 @@ class QASM2(lowering.LoweringABC[ast.Node]):
         )
         cond = state.current_frame.push(cond_stmt).result
         frame = state.current_frame
-        before_block = frame.curr_block
 
-        with state.frame(node.body, region=frame.curr_region) as if_frame:
+        with state.frame(node.body) as if_frame:
             true_cond = if_frame.entr_block.args.append_from(types.Bool, cond.name)
             if cond.name:
                 if_frame.defs[cond.name] = true_cond
 
+            # NOTE: pass in definitions from outer scope (usually just for the qreg)
+            if_frame.defs.update(frame.defs)
+
             if_frame.exhaust()
-            self.branch_next_if_not_terminated(if_frame)
 
-        with state.frame([], region=frame.curr_region) as else_frame:
-            true_cond = else_frame.entr_block.args.append_from(types.Bool, cond.name)
-            if cond.name:
-                else_frame.defs[cond.name] = true_cond
-            else_frame.exhaust()
-            self.branch_next_if_not_terminated(else_frame)
-
-        with state.frame(frame.stream.split(), region=frame.curr_region) as after_frame:
-            after_frame.defs.update(frame.defs)
-            phi: set[str] = set()
-            for name in if_frame.defs.keys():
-                if frame.get(name):
-                    phi.add(name)
-                elif name in else_frame.defs:
-                    phi.add(name)
-
-            for name in else_frame.defs.keys():
-                if frame.get(name):  # not defined in if_frame
-                    phi.add(name)
-
-            for name in phi:
-                after_frame.defs[name] = after_frame.entr_block.args.append_from(
-                    types.Any, name
-                )
+            # NOTE: qasm2 can never yield anything from if
+            if_frame.push(scf.Yield())
 
-            after_frame.exhaust()
-            self.branch_next_if_not_terminated(after_frame)
-            after_frame.next_block.stmts.append(
-                cf.Branch(arguments=(), successor=frame.next_block)
-            )
+            then_body = if_frame.curr_region
 
-        if_args = []
-        for name in phi:
-            if value := if_frame.get(name):
-                if_args.append(value)
-            else:
-                raise lowering.BuildError(f"undefined variable {name} in if branch")
-
-        else_args = []
-        for name in phi:
-            if value := else_frame.get(name):
-                else_args.append(value)
-            else:
-                raise lowering.BuildError(f"undefined variable {name} in else branch")
-
-        if_frame.next_block.stmts.append(
-            cf.Branch(
-                arguments=tuple(if_args),
-                successor=after_frame.entr_block,
-            )
-        )
-        else_frame.next_block.stmts.append(
-            cf.Branch(
-                arguments=tuple(else_args),
-                successor=after_frame.entr_block,
-            )
-        )
-        before_block.stmts.append(
-            cf.ConditionalBranch(
-                cond=cond,
-                then_arguments=(cond,),
-                then_successor=if_frame.entr_block,
-                else_arguments=(cond,),
-                else_successor=else_frame.entr_block,
-            )
-        )
-        frame.defs.update(after_frame.defs)
-        frame.jump_next_block()
+        state.current_frame.push(scf.IfElse(cond, then_body=then_body))
 
     def branch_next_if_not_terminated(self, frame: lowering.Frame):
         """Branch to the next block if the current block is not terminated.
@@ -430,7 +375,56 @@ class QASM2(lowering.LoweringABC[ast.Node]):
             raise lowering.BuildError(f"Include {node.filename} not found")
 
     def visit_Gate(self, state: lowering.State[ast.Node], node: ast.Gate):
-        raise NotImplementedError("Gate lowering not supported")
+        arg_names = node.cparams + node.qparams
+        arg_types = [types.Float for _ in node.cparams] + [
+            QubitType for _ in node.qparams
+        ]
+
+        with state.frame(
+            stmts=node.body,
+            finalize_next=False,
+        ) as body_frame:
+            # NOTE: insert _self as arg
+            body_frame.curr_block.args.append_from(
+                types.Generic(
+                    ir.Method, types.Tuple.where(tuple(arg_types)), types.NoneType
+                ),
+                name=node.name + "_self",
+            )
+
+            for arg_type, arg_name in zip(arg_types, arg_names):
+                # NOTE: append args as block arguments
+                block_arg = body_frame.curr_block.args.append_from(
+                    arg_type, name=arg_name
+                )
+
+                # NOTE: add arguments as definitions to frame
+                body_frame.defs[arg_name] = block_arg
+
+            body_frame.exhaust()
+
+            # NOTE: append none as return value
+            return_val = func.ConstantNone()
+            body_frame.push(return_val)
+            body_frame.push(func.Return(return_val))
+
+            body = body_frame.curr_region
+
+        gate_func = expr.GateFunction(
+            sym_name=node.name,
+            signature=func.Signature(inputs=tuple(arg_types), output=types.NoneType),
+            body=body,
+        )
+
+        mt = ir.Method(
+            mod=None,
+            py_func=None,
+            sym_name=node.name,
+            dialects=self.dialects,
+            arg_names=[*node.cparams, *node.qparams],
+            code=gate_func,
+        )
+        state.current_frame.globals[node.name] = mt
 
     def visit_Instruction(self, state: lowering.State[ast.Node], node: ast.Instruction):
         params = [state.lower(param).expect_one() for param in node.params]

bloqade_circuit-0.4.2/src/bloqade/squin/__init__.py

@@ -0,0 +1,17 @@
+from . import (
+    op as op,
+    wire as wire,
+    noise as noise,
+    qubit as qubit,
+    lowering as lowering,
+)
+from .groups import wired as wired, kernel as kernel
+
+try:
+    # NOTE: make sure optional cirq dependency is installed
+    import cirq as cirq_package  # noqa: F401
+except ImportError:
+    pass
+else:
+    from . import cirq as cirq
+    from .cirq import load_circuit as load_circuit

bloqade_circuit-0.4.2/src/bloqade/squin/cirq/__init__.py

@@ -0,0 +1,89 @@
+from typing import Any
+
+import cirq
+from kirin import ir, types
+from kirin.dialects import func
+
+from . import lowering as lowering
+from .. import kernel
+from .lowering import Squin
+
+
+def load_circuit(
+    circuit: cirq.Circuit,
+    kernel_name: str = "main",
+    dialects: ir.DialectGroup = kernel,
+    globals: dict[str, Any] | None = None,
+    file: str | None = None,
+    lineno_offset: int = 0,
+    col_offset: int = 0,
+    compactify: bool = True,
+):
+    """Converts a cirq.Circuit object into a squin kernel.
+
+    Args:
+        circuit (cirq.Circuit): The circuit to load.
+
+    Keyword Args:
+        kernel_name (str): The name of the kernel to load. Defaults to "main".
+        dialects (ir.DialectGroup | None): The dialects to use. Defaults to `squin.kernel`.
+        globals (dict[str, Any] | None): The global variables to use. Defaults to None.
+        file (str | None): The file name for error reporting. Defaults to None.
+        lineno_offset (int): The line number offset for error reporting. Defaults to 0.
+        col_offset (int): The column number offset for error reporting. Defaults to 0.
+        compactify (bool): Whether to compactify the output. Defaults to True.
+
+    Example:
+
+    ```python
+    # from cirq's "hello qubit" example
+    import cirq
+    from bloqade import squin
+
+    # Pick a qubit.
+    qubit = cirq.GridQubit(0, 0)
+
+    # Create a circuit.
+    circuit = cirq.Circuit(
+        cirq.X(qubit)**0.5,  # Square root of NOT.
+        cirq.measure(qubit, key='m')  # Measurement.
+    )
+
+    # load the circuit as squin
+    main = squin.load_circuit(circuit)
+
+    # print the resulting IR
+    main.print()
+    ```
+    """
+
+    target = Squin(dialects=dialects, circuit=circuit)
+    body = target.run(
+        circuit,
+        source=str(circuit),  # TODO: proper source string
+        file=file,
+        globals=globals,
+        lineno_offset=lineno_offset,
+        col_offset=col_offset,
+        compactify=compactify,
+    )
+
+    # NOTE: no return value
+    return_value = func.ConstantNone()
+    body.blocks[0].stmts.append(return_value)
+    body.blocks[0].stmts.append(func.Return(value_or_stmt=return_value))
+
+    code = func.Function(
+        sym_name=kernel_name,
+        signature=func.Signature((), types.NoneType),
+        body=body,
+    )
+
+    return ir.Method(
+        mod=None,
+        py_func=None,
+        sym_name=kernel_name,
+        arg_names=[],
+        dialects=dialects,
+        code=code,
+    )

bloqade_circuit-0.4.2/src/bloqade/squin/cirq/lowering.py

@@ -0,0 +1,303 @@
+import math
+from typing import Any
+from dataclasses import field, dataclass
+
+import cirq
+from kirin import ir, lowering
+from kirin.rewrite import Walk, CFGCompactify
+from kirin.dialects import py, ilist
+
+from .. import op, noise, qubit
+
+CirqNode = cirq.Circuit | cirq.Moment | cirq.Gate | cirq.Qid | cirq.Operation
+
+DecomposeNode = (
+    cirq.SwapPowGate
+    | cirq.ISwapPowGate
+    | cirq.PhasedXPowGate
+    | cirq.PhasedXZGate
+    | cirq.CSwapGate
+)
+
+
+@dataclass
+class Squin(lowering.LoweringABC[CirqNode]):
+    """Lower a cirq.Circuit object to a squin kernel"""
+
+    circuit: cirq.Circuit
+    qreg: qubit.New = field(init=False)
+    qreg_index: dict[cirq.Qid, int] = field(init=False, default_factory=dict)
+    next_qreg_index: int = field(init=False, default=0)
+
+    def lower_qubit_getindex(self, state: lowering.State[CirqNode], qid: cirq.Qid):
+        index = self.qreg_index.get(qid)
+
+        if index is None:
+            index = self.next_qreg_index
+            self.qreg_index[qid] = index
+            self.next_qreg_index += 1
+
+        index_ssa = state.current_frame.push(py.Constant(index)).result
+        qbit_getitem = state.current_frame.push(py.GetItem(self.qreg.result, index_ssa))
+        return qbit_getitem.result
+
+    def lower_qubit_getindices(
+        self, state: lowering.State[CirqNode], qids: list[cirq.Qid]
+    ):
+        qbits_getitem = [self.lower_qubit_getindex(state, qid) for qid in qids]
+        qbits_stmt = ilist.New(values=qbits_getitem)
+        qbits_result = state.current_frame.get(qbits_stmt.name)
+
+        if qbits_result is not None:
+            return qbits_result
+
+        state.current_frame.push(qbits_stmt)
+        return qbits_stmt.result
+
+    def run(
+        self,
+        stmt: CirqNode,
+        *,
+        source: str | None = None,
+        globals: dict[str, Any] | None = None,
+        file: str | None = None,
+        lineno_offset: int = 0,
+        col_offset: int = 0,
+        compactify: bool = True,
+    ) -> ir.Region:
+
+        state = lowering.State(
+            self,
+            file=file,
+            lineno_offset=lineno_offset,
+            col_offset=col_offset,
+        )
+
+        with state.frame(
+            [stmt],
+            globals=globals,
+            finalize_next=False,
+        ) as frame:
+            # NOTE: create a global register of qubits first
+            # TODO: can there be a circuit without qubits?
+            n_qubits = cirq.num_qubits(self.circuit)
+            n = frame.push(py.Constant(n_qubits))
+            self.qreg = frame.push(qubit.New(n_qubits=n.result))
+
+            self.visit(state, stmt)
+
+            if compactify:
+                Walk(CFGCompactify()).rewrite(frame.curr_region)
+
+            region = frame.curr_region
+
+        return region
+
+    def visit(self, state: lowering.State[CirqNode], node: CirqNode) -> lowering.Result:
+        name = node.__class__.__name__
+        return getattr(self, f"visit_{name}", self.generic_visit)(state, node)
+
+    def generic_visit(self, state: lowering.State[CirqNode], node: CirqNode):
+        if isinstance(node, CirqNode):
+            raise lowering.BuildError(
+                f"Cannot lower {node.__class__.__name__} node: {node}"
+            )
+        raise lowering.BuildError(
+            f"Unexpected `{node.__class__.__name__}` node: {repr(node)} is not an AST node"
+        )
+
+    def lower_literal(self, state: lowering.State[CirqNode], value) -> ir.SSAValue:
+        raise lowering.BuildError("Literals not supported in cirq circuit")
+
+    def lower_global(
+        self, state: lowering.State[CirqNode], node: CirqNode
+    ) -> lowering.LoweringABC.Result:
+        raise lowering.BuildError("Literals not supported in cirq circuit")
+
+    def visit_Circuit(
+        self, state: lowering.State[CirqNode], node: cirq.Circuit
+    ) -> lowering.Result:
+        for moment in node:
+            state.lower(moment)
+
+    def visit_Moment(
+        self, state: lowering.State[CirqNode], node: cirq.Moment
+    ) -> lowering.Result:
+        for op_ in node.operations:
+            state.lower(op_)
+
+    def visit_GateOperation(
+        self, state: lowering.State[CirqNode], node: cirq.GateOperation
+    ):
+        if isinstance(node.gate, cirq.MeasurementGate):
+            # NOTE: special dispatch here, since measurement is a gate + a qubit in cirq,
+            # but a single statement in squin
+            return self.lower_measurement(state, node)
+
+        if isinstance(node.gate, DecomposeNode):
+            # NOTE: easier to decompose these, but for that we need the qubits too,
+            # so we need to do this within this method
+            for subnode in cirq.decompose_once(node):
+                state.lower(subnode)
+            return
+
+        op_ = state.lower(node.gate).expect_one()
+        qbits = self.lower_qubit_getindices(state, node.qubits)
+        return state.current_frame.push(qubit.Apply(operator=op_, qubits=qbits))
+
+    def lower_measurement(
+        self, state: lowering.State[CirqNode], node: cirq.GateOperation
+    ):
+        if len(node.qubits) == 1:
+            qbit = self.lower_qubit_getindex(state, node.qubits[0])
+            return state.current_frame.push(qubit.MeasureQubit(qbit))
+
+        qbits = self.lower_qubit_getindices(state, node.qubits)
+        return state.current_frame.push(qubit.MeasureQubitList(qbits))
+
+    def visit_SingleQubitPauliStringGateOperation(
+        self,
+        state: lowering.State[CirqNode],
+        node: cirq.SingleQubitPauliStringGateOperation,
+    ):
+
+        match node.pauli:
+            case cirq.X:
+                op_ = op.stmts.X()
+            case cirq.Y:
+                op_ = op.stmts.Y()
+            case cirq.Z:
+                op_ = op.stmts.Z()
+            case cirq.I:
+                op_ = op.stmts.Identity(sites=1)
+            case _:
+                raise lowering.BuildError(f"Unexpected Pauli operation {node.pauli}")
+
+        state.current_frame.push(op_)
+        qargs = self.lower_qubit_getindices(state, [node.qubit])
+        return state.current_frame.push(qubit.Apply(op_.result, qargs))
+
+    def visit_HPowGate(self, state: lowering.State[CirqNode], node: cirq.HPowGate):
+        if node.exponent == 1:
+            return state.current_frame.push(op.stmts.H())
+
+        return state.lower(node.in_su2())
+
+    def visit_XPowGate(self, state: lowering.State[CirqNode], node: cirq.XPowGate):
+        if node.exponent == 1:
+            return state.current_frame.push(op.stmts.X())
+
+        return self.visit(state, node.in_su2())
+
+    def visit_YPowGate(self, state: lowering.State[CirqNode], node: cirq.YPowGate):
+        if node.exponent == 1:
+            return state.current_frame.push(op.stmts.Y())
+
+        return self.visit(state, node.in_su2())
+
+    def visit_ZPowGate(self, state: lowering.State[CirqNode], node: cirq.ZPowGate):
+        if node.exponent == 0.5:
+            return state.current_frame.push(op.stmts.S())
+
+        if node.exponent == 0.25:
+            return state.current_frame.push(op.stmts.T())
+
+        if node.exponent == 1:
+            return state.current_frame.push(op.stmts.Z())
+
+        # NOTE: just for the Z gate, an arbitrary exponent is equivalent to the ShiftOp
+        t = node.exponent
+        theta = state.current_frame.push(py.Constant(math.pi * t))
+        return state.current_frame.push(op.stmts.ShiftOp(theta=theta.result))
+
+    def visit_Rx(self, state: lowering.State[CirqNode], node: cirq.Rx):
+        x = state.current_frame.push(op.stmts.X())
+        angle = state.current_frame.push(py.Constant(value=math.pi * node.exponent))
+        return state.current_frame.push(op.stmts.Rot(axis=x.result, angle=angle.result))
+
+    def visit_Ry(self, state: lowering.State[CirqNode], node: cirq.Ry):
+        y = state.current_frame.push(op.stmts.Y())
+        angle = state.current_frame.push(py.Constant(value=math.pi * node.exponent))
+        return state.current_frame.push(op.stmts.Rot(axis=y.result, angle=angle.result))
+
+    def visit_Rz(self, state: lowering.State[CirqNode], node: cirq.Rz):
+        z = state.current_frame.push(op.stmts.Z())
+        angle = state.current_frame.push(py.Constant(value=math.pi * node.exponent))
+        return state.current_frame.push(op.stmts.Rot(axis=z.result, angle=angle.result))
+
+    def visit_CXPowGate(self, state: lowering.State[CirqNode], node: cirq.CXPowGate):
+        x = state.lower(cirq.XPowGate(exponent=node.exponent)).expect_one()
+        return state.current_frame.push(op.stmts.Control(x, n_controls=1))
+
+    def visit_CZPowGate(self, state: lowering.State[CirqNode], node: cirq.CZPowGate):
+        z = state.lower(cirq.ZPowGate(exponent=node.exponent)).expect_one()
+        return state.current_frame.push(op.stmts.Control(z, n_controls=1))
+
+    def visit_ControlledOperation(
+        self, state: lowering.State[CirqNode], node: cirq.ControlledOperation
+    ):
+        return self.visit_GateOperation(state, node)
+
+    def visit_ControlledGate(
+        self, state: lowering.State[CirqNode], node: cirq.ControlledGate
+    ):
+        op_ = state.lower(node.sub_gate).expect_one()
+        n_controls = node.num_controls()
+        return state.current_frame.push(op.stmts.Control(op_, n_controls=n_controls))
+
+    def visit_XXPowGate(self, state: lowering.State[CirqNode], node: cirq.XXPowGate):
+        x = state.lower(cirq.XPowGate(exponent=node.exponent)).expect_one()
+        return state.current_frame.push(op.stmts.Kron(x, x))
+
+    def visit_YYPowGate(self, state: lowering.State[CirqNode], node: cirq.YYPowGate):
+        y = state.lower(cirq.YPowGate(exponent=node.exponent)).expect_one()
+        return state.current_frame.push(op.stmts.Kron(y, y))
+
+    def visit_ZZPowGate(self, state: lowering.State[CirqNode], node: cirq.ZZPowGate):
+        z = state.lower(cirq.ZPowGate(exponent=node.exponent)).expect_one()
+        return state.current_frame.push(op.stmts.Kron(z, z))
+
+    def visit_CCXPowGate(self, state: lowering.State[CirqNode], node: cirq.CCXPowGate):
+        x = state.lower(cirq.XPowGate(exponent=node.exponent)).expect_one()
+        return state.current_frame.push(op.stmts.Control(x, n_controls=2))
+
+    def visit_CCZPowGate(self, state: lowering.State[CirqNode], node: cirq.CCZPowGate):
+        z = state.lower(cirq.ZPowGate(exponent=node.exponent)).expect_one()
+        return state.current_frame.push(op.stmts.Control(z, n_controls=2))
+
+    def visit_BitFlipChannel(
+        self, state: lowering.State[CirqNode], node: cirq.BitFlipChannel
+    ):
+        x = state.current_frame.push(op.stmts.X())
+        p = state.current_frame.push(py.Constant(node.p))
+        return state.current_frame.push(
+            noise.stmts.PauliError(basis=x.result, p=p.result)
+        )
+
+    def visit_AmplitudeDampingChannel(
+        self, state: lowering.State[CirqNode], node: cirq.AmplitudeDampingChannel
+    ):
+        r = state.current_frame.push(op.stmts.Reset())
+        p = state.current_frame.push(py.Constant(node.gamma))
+
+        # TODO: do we need a dedicated noise stmt for this? Using PauliError
+        # with this basis feels like a hack
+        noise_channel = state.current_frame.push(
+            noise.stmts.PauliError(basis=r.result, p=p.result)
+        )
+
+        return noise_channel
+
+    def visit_GeneralizedAmplitudeDampingChannel(
+        self,
+        state: lowering.State[CirqNode],
+        node: cirq.GeneralizedAmplitudeDampingChannel,
+    ):
+        raise NotImplementedError("TODO: needs a new operator statement")
+        # p = state.current_frame.push(py.Constant(node.p))
+        # gamma = state.current_frame.push(py.Constant(node.gamma))
+
+        # p1 =
+
+        # x = state.current_frame.push(op.stmts.X())
+        # noise_channel1 = noise.stmts.PauliError(basis=x.result, p=)