bloqade-circuit 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

bloqade/{noise/native/_wrappers.py → qasm2/noise.py}

@@ -3,11 +3,15 @@ from typing import Any
 from kirin.dialects import ilist
 from kirin.lowering import wraps
 
-from bloqade.noise import native
-from bloqade.qasm2.types import Qubit
+from .types import Qubit
+from .dialects import noise
+from .dialects.noise import (
+    TwoRowZoneModel as TwoRowZoneModel,
+    MoveNoiseModelABC as MoveNoiseModelABC,
+)
 
 
-@wraps(native.AtomLossChannel)
+@wraps(noise.AtomLossChannel)
 def atom_loss_channel(qargs: ilist.IList[Qubit, Any] | list, *, prob: float) -> None:
     """Apply an atom loss channel to a list of qubits.
 
@@ -18,7 +22,7 @@ def atom_loss_channel(qargs: ilist.IList[Qubit, Any] | list, *, prob: float) ->
     ...
 
 
-@wraps(native.PauliChannel)
+@wraps(noise.PauliChannel)
 def pauli_channel(
     qargs: ilist.IList[Qubit, Any] | list, *, px: float, py: float, pz: float
 ) -> None:
@@ -32,7 +36,7 @@ def pauli_channel(
     """
 
 
-@wraps(native.CZPauliChannel)
+@wraps(noise.CZPauliChannel)
 def cz_pauli_channel(
     ctrls: ilist.IList[Qubit, Any] | list,
     qargs: ilist.IList[Qubit, Any] | list,

bloqade/qasm2/passes/glob.py

@@ -58,13 +58,15 @@ class GlobalToUOP(Pass):
         rewriter = walk.Walk(self.generate_rule(mt))
         result = rewriter.rewrite(mt.code)
 
-        result = walk.Walk(dce.DeadCodeElimination()).rewrite(mt.code)
-        result = Fixpoint(walk.Walk(rule=cse.CommonSubexpressionElimination())).rewrite(
-            mt.code
+        result = walk.Walk(dce.DeadCodeElimination()).rewrite(mt.code).join(result)
+        result = (
+            Fixpoint(walk.Walk(rule=cse.CommonSubexpressionElimination()))
+            .rewrite(mt.code)
+            .join(result)
         )
 
         # do fold again to get proper hint for inserted const
-        result = Fold(mt.dialects)(mt)
+        result = Fold(mt.dialects)(mt).join(result)
         return result
 
 
@@ -110,10 +112,12 @@ class GlobalToParallel(Pass):
         rewriter = walk.Walk(self.generate_rule(mt))
         result = rewriter.rewrite(mt.code)
 
-        result = walk.Walk(dce.DeadCodeElimination()).rewrite(mt.code)
-        result = Fixpoint(walk.Walk(rule=cse.CommonSubexpressionElimination())).rewrite(
-            mt.code
+        result = walk.Walk(dce.DeadCodeElimination()).rewrite(mt.code).join(result)
+        result = (
+            Fixpoint(walk.Walk(rule=cse.CommonSubexpressionElimination()))
+            .rewrite(mt.code)
+            .join(result)
         )
         # do fold again to get proper hint
-        result = Fold(mt.dialects)(mt)
+        result = Fold(mt.dialects)(mt).join(result)
         return result

bloqade/qasm2/passes/noise.py

@@ -8,10 +8,10 @@ from kirin.rewrite import (
     DeadCodeElimination,
 )
 
-from bloqade.noise import native
+from bloqade.qasm2 import noise
 from bloqade.analysis import address
+from bloqade.qasm2.rewrite import NoiseRewriteRule
 from bloqade.qasm2.passes.lift_qubits import LiftQubits
-from bloqade.qasm2.rewrite.heuristic_noise import NoiseRewriteRule
 
 
 @dataclass
@@ -25,12 +25,9 @@ class NoisePass(Pass):
 
     ```
     from bloqade import qasm2
-    from bloqade.noise import native
-    from bloqade.qasm2.passes.noise import NoisePass
+    from bloqade.qasm2.passes import NoisePass
 
-    noise_main = qasm2.extended.add(native.dialect)
-
-    @noise_main
+    @qasm2.extended
     def main():
         q = qasm2.qreg(2)
         qasm2.h(q[0])
@@ -51,12 +48,7 @@ class NoisePass(Pass):
 
     """
 
-    noise_model: native.MoveNoiseModelABC = field(
-        default_factory=native.TwoRowZoneModel
-    )
-    gate_noise_params: native.GateNoiseParams = field(
-        default_factory=native.GateNoiseParams
-    )
+    noise_model: noise.MoveNoiseModelABC = field(default_factory=noise.TwoRowZoneModel)
     address_analysis: address.AddressAnalysis = field(init=False)
 
     def __post_init__(self):
@@ -89,7 +81,6 @@ class NoisePass(Pass):
                     qubit_ssa_value=qubit_ssa_value,
                     address_analysis=address_analysis,
                     noise_model=self.noise_model,
-                    gate_noise_params=self.gate_noise_params,
                 ),
                 reverse=True,
             )

bloqade/qasm2/rewrite/__init__.py

@@ -11,3 +11,5 @@ from .uop_to_parallel import (
     SimpleGreedyMergePolicy as SimpleGreedyMergePolicy,
     SimpleOptimalMergePolicy as SimpleOptimalMergePolicy,
 )
+from .noise.remove_noise import RemoveNoisePass as RemoveNoisePass
+from .noise.heuristic_noise import NoiseRewriteRule as NoiseRewriteRule

bloqade/qasm2/rewrite/{heuristic_noise.py → noise/heuristic_noise.py}

@@ -5,9 +5,8 @@ from kirin import ir
 from kirin.rewrite import abc as rewrite_abc
 from kirin.dialects import ilist
 
-from bloqade.noise import native
 from bloqade.analysis import address
-from bloqade.qasm2.dialects import uop, glob, parallel
+from bloqade.qasm2.dialects import uop, glob, noise, parallel
 
 
 @dataclass
@@ -19,12 +18,7 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
 
     address_analysis: Dict[ir.SSAValue, address.Address]
     qubit_ssa_value: Dict[int, ir.SSAValue]
-    gate_noise_params: native.GateNoiseParams = field(
-        default_factory=native.GateNoiseParams
-    )
-    noise_model: native.MoveNoiseModelABC = field(
-        default_factory=native.TwoRowZoneModel
-    )
+    noise_model: noise.MoveNoiseModelABC = field(default_factory=noise.TwoRowZoneModel)
 
     def rewrite_Statement(self, node: ir.Statement) -> rewrite_abc.RewriteResult:
         if isinstance(node, uop.SingleQubitGate):
@@ -46,22 +40,18 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
         qargs: ir.SSAValue,
         probs: Tuple[float, float, float, float],
     ):
-        native.PauliChannel(qargs, px=probs[0], py=probs[1], pz=probs[2]).insert_before(
+        noise.PauliChannel(qargs, px=probs[0], py=probs[1], pz=probs[2]).insert_before(
             node
         )
-        native.AtomLossChannel(qargs, prob=probs[3]).insert_before(node)
+        noise.AtomLossChannel(qargs, prob=probs[3]).insert_before(node)
 
         return rewrite_abc.RewriteResult(has_done_something=True)
 
     def rewrite_single_qubit_gate(self, node: uop.SingleQubitGate):
-        probs = (
-            self.gate_noise_params.local_px,
-            self.gate_noise_params.local_py,
-            self.gate_noise_params.local_pz,
-            self.gate_noise_params.local_loss_prob,
-        )
         (qargs := ilist.New(values=(node.qarg,))).insert_before(node)
-        return self.insert_single_qubit_noise(node, qargs.result, probs)
+        return self.insert_single_qubit_noise(
+            node, qargs.result, self.noise_model.local_errors
+        )
 
     def rewrite_global_single_qubit_gate(self, node: glob.UGate):
         addrs = self.address_analysis[node.registers]
@@ -77,14 +67,10 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
             for qid in addr.data:
                 qargs.append(self.qubit_ssa_value[qid])
 
-        probs = (
-            self.gate_noise_params.global_px,
-            self.gate_noise_params.global_py,
-            self.gate_noise_params.global_pz,
-            self.gate_noise_params.global_loss_prob,
-        )
         (qargs := ilist.New(values=tuple(qargs))).insert_before(node)
-        return self.insert_single_qubit_noise(node, qargs.result, probs)
+        return self.insert_single_qubit_noise(
+            node, qargs.result, self.noise_model.global_errors
+        )
 
     def rewrite_parallel_single_qubit_gate(self, node: parallel.RZ | parallel.UGate):
         addrs = self.address_analysis[node.qargs]
@@ -94,15 +80,11 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
         if not all(isinstance(addr, address.AddressQubit) for addr in addrs.data):
             return rewrite_abc.RewriteResult()
 
-        probs = (
-            self.gate_noise_params.local_px,
-            self.gate_noise_params.local_py,
-            self.gate_noise_params.local_pz,
-            self.gate_noise_params.local_loss_prob,
-        )
         assert isinstance(node.qargs, ir.ResultValue)
         assert isinstance(node.qargs.stmt, ilist.New)
-        return self.insert_single_qubit_noise(node, node.qargs, probs)
+        return self.insert_single_qubit_noise(
+            node, node.qargs, self.noise_model.local_errors
+        )
 
     def move_noise_stmts(
         self,
@@ -118,9 +100,9 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
             nodes.append(
                 qargs := ilist.New(tuple(self.qubit_ssa_value[q] for q in qubits))
             )
-            nodes.append(native.AtomLossChannel(qargs.result, prob=probs[3]))
+            nodes.append(noise.AtomLossChannel(qargs.result, prob=probs[3]))
             nodes.append(
-                native.PauliChannel(qargs.result, px=probs[0], py=probs[1], pz=probs[2])
+                noise.PauliChannel(qargs.result, px=probs[0], py=probs[1], pz=probs[2])
             )
 
         return nodes
@@ -131,34 +113,30 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
         qargs: ir.SSAValue,
     ) -> list[ir.Statement]:
         return [
-            native.CZPauliChannel(
+            noise.CZPauliChannel(
                 ctrls,
                 qargs,
-                px_ctrl=self.gate_noise_params.cz_paired_gate_px,
-                py_ctrl=self.gate_noise_params.cz_paired_gate_py,
-                pz_ctrl=self.gate_noise_params.cz_paired_gate_pz,
-                px_qarg=self.gate_noise_params.cz_paired_gate_px,
-                py_qarg=self.gate_noise_params.cz_paired_gate_py,
-                pz_qarg=self.gate_noise_params.cz_paired_gate_pz,
+                px_ctrl=self.noise_model.cz_paired_gate_px,
+                py_ctrl=self.noise_model.cz_paired_gate_py,
+                pz_ctrl=self.noise_model.cz_paired_gate_pz,
+                px_qarg=self.noise_model.cz_paired_gate_px,
+                py_qarg=self.noise_model.cz_paired_gate_py,
+                pz_qarg=self.noise_model.cz_paired_gate_pz,
                 paired=True,
             ),
-            native.CZPauliChannel(
+            noise.CZPauliChannel(
                 ctrls,
                 qargs,
-                px_ctrl=self.gate_noise_params.cz_unpaired_gate_px,
-                py_ctrl=self.gate_noise_params.cz_unpaired_gate_py,
-                pz_ctrl=self.gate_noise_params.cz_unpaired_gate_pz,
-                px_qarg=self.gate_noise_params.cz_unpaired_gate_px,
-                py_qarg=self.gate_noise_params.cz_unpaired_gate_py,
-                pz_qarg=self.gate_noise_params.cz_unpaired_gate_pz,
+                px_ctrl=self.noise_model.cz_unpaired_gate_px,
+                py_ctrl=self.noise_model.cz_unpaired_gate_py,
+                pz_ctrl=self.noise_model.cz_unpaired_gate_pz,
+                px_qarg=self.noise_model.cz_unpaired_gate_px,
+                py_qarg=self.noise_model.cz_unpaired_gate_py,
+                pz_qarg=self.noise_model.cz_unpaired_gate_pz,
                 paired=False,
             ),
-            native.AtomLossChannel(
-                ctrls, prob=self.gate_noise_params.cz_gate_loss_prob
-            ),
-            native.AtomLossChannel(
-                qargs, prob=self.gate_noise_params.cz_gate_loss_prob
-            ),
+            noise.AtomLossChannel(ctrls, prob=self.noise_model.cz_gate_loss_prob),
+            noise.AtomLossChannel(qargs, prob=self.noise_model.cz_gate_loss_prob),
         ]
 
     def rewrite_cz_gate(self, node: uop.CZ):

bloqade/{noise/native/rewrite.py → qasm2/rewrite/noise/remove_noise.py}

@@ -4,8 +4,8 @@ from kirin import ir
 from kirin.rewrite import abc, dce, walk, fixpoint
 from kirin.passes.abc import Pass
 
-from .stmts import PauliChannel, CZPauliChannel, AtomLossChannel
-from ._dialect import dialect
+from ...dialects.noise.stmts import PauliChannel, CZPauliChannel, AtomLossChannel
+from ...dialects.noise._dialect import dialect
 
 
 class RemoveNoiseRewrite(abc.RewriteRule):

bloqade/qbraid/lowering.py

@@ -4,13 +4,13 @@ from dataclasses import field, dataclass
 from kirin import ir, types, passes
 from kirin.dialects import func, ilist
 
-from bloqade import noise, qasm2
+from bloqade import qasm2
 from bloqade.qbraid import schema
-from bloqade.qasm2.dialects import glob, parallel
+from bloqade.qasm2.dialects import glob, noise, parallel
 
 
 @ir.dialect_group(
-    [func, qasm2.core, qasm2.uop, parallel, glob, qasm2.expr, noise.native, ilist]
+    [func, qasm2.core, qasm2.uop, parallel, glob, qasm2.expr, noise, ilist]
 )
 def qbraid_noise(
     self,
@@ -192,7 +192,7 @@ class Lowering:
                 qargs := ilist.New(values=tuple(self.qubit_id_map[q] for q in qubits))
             )
             self.block_list.append(
-                noise.native.PauliChannel(px=px, py=py, pz=pz, qargs=qargs.result)
+                noise.PauliChannel(px=px, py=py, pz=pz, qargs=qargs.result)
             )
 
         for (p_ctrl, p_qarg), qubits in paired_layers.items():
@@ -204,7 +204,7 @@ class Lowering:
                 qargs := ilist.New(values=tuple(self.qubit_id_map[q] for q in qargs))
             )
             self.block_list.append(
-                noise.native.CZPauliChannel(
+                noise.CZPauliChannel(
                     paired=True,
                     px_ctrl=p_ctrl[0],
                     py_ctrl=p_ctrl[1],
@@ -226,7 +226,7 @@ class Lowering:
                 qargs := ilist.New(values=tuple(self.qubit_id_map[q] for q in qargs))
             )
             self.block_list.append(
-                noise.native.CZPauliChannel(
+                noise.CZPauliChannel(
                     paired=False,
                     px_ctrl=p_ctrl[0],
                     py_ctrl=p_ctrl[1],
@@ -285,7 +285,7 @@ class Lowering:
                 qargs := ilist.New(values=tuple(self.qubit_id_map[q] for q in qubits))
             )
             self.block_list.append(
-                noise.native.PauliChannel(px=px, py=py, pz=pz, qargs=qargs.result)
+                noise.PauliChannel(px=px, py=py, pz=pz, qargs=qargs.result)
             )
 
     def lower_measurement(self, operation: schema.Measurement):
@@ -303,7 +303,7 @@ class Lowering:
         for survival_prob, qubits in layers.items():
             self.block_list.append(qargs := ilist.New(values=qubits))
             self.block_list.append(
-                noise.native.AtomLossChannel(prob=survival_prob, qargs=qargs.result)
+                noise.AtomLossChannel(prob=survival_prob, qargs=qargs.result)
             )
 
     def lower_number(self, value: float | int) -> ir.SSAValue:

bloqade/squin/__init__.py

@@ -1,2 +1,8 @@
-from . import op as op, wire as wire, noise as noise, qubit as qubit
+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

bloqade/squin/analysis/nsites/impls.py

@@ -23,15 +23,6 @@ class SquinWire(interp.MethodTable):
 
         return tuple(frame.get(input) for input in stmt.inputs)
 
-    @interp.impl(wire.MeasureAndReset)
-    def measure_and_reset(
-        self, interp: NSitesAnalysis, frame: interp.Frame, stmt: wire.MeasureAndReset
-    ):
-
-        # MeasureAndReset produces both a new wire
-        # and an integer which don't have any sites at all
-        return (NoSites(), NoSites())
-
 
 @op.dialect.register(key="op.nsites")
 class SquinOp(interp.MethodTable):

bloqade/squin/groups.py

@@ -1,11 +1,11 @@
 from kirin import ir, passes
 from kirin.prelude import structural_no_opt
+from kirin.rewrite import Walk, Chain
 from kirin.dialects import ilist
-from kirin.rewrite.walk import Walk
 
 from . import op, wire, qubit
 from .op.rewrite import PyMultToSquinMult
-from .rewrite.measure_desugar import MeasureDesugarRule
+from .rewrite.desugar import ApplyDesugarRule, MeasureDesugarRule
 
 
 @ir.dialect_group(structural_no_opt.union([op, qubit]))
@@ -13,7 +13,7 @@ def kernel(self):
     fold_pass = passes.Fold(self)
     typeinfer_pass = passes.TypeInfer(self)
     ilist_desugar_pass = ilist.IListDesugar(self)
-    measure_desugar_pass = Walk(MeasureDesugarRule())
+    desugar_pass = Walk(Chain(MeasureDesugarRule(), ApplyDesugarRule()))
     py_mult_to_mult_pass = PyMultToSquinMult(self)
 
     def run_pass(method: ir.Method, *, fold=True, typeinfer=True):
@@ -25,7 +25,7 @@ def kernel(self):
 
         if typeinfer:
             typeinfer_pass(method)
-            measure_desugar_pass.rewrite(method.code)
+            desugar_pass.rewrite(method.code)
 
         ilist_desugar_pass(method)
 

bloqade/squin/lowering.py

@@ -0,0 +1,27 @@
+import ast
+from dataclasses import dataclass
+
+from kirin import lowering
+
+from . import qubit
+
+
+@dataclass(frozen=True)
+class ApplyAnyCallLowering(lowering.FromPythonCall["qubit.ApplyAny"]):
+    """
+    Custom lowering for ApplyAny that collects vararg qubits into a single tuple argument
+    """
+
+    def lower(
+        self, stmt: type["qubit.ApplyAny"], state: lowering.State, node: ast.Call
+    ):
+        if len(node.args) < 2:
+            raise lowering.BuildError(
+                "Apply requires at least one operator and one qubit as arguments!"
+            )
+        op, *qubits = node.args
+        op_ssa = state.lower(op).expect_one()
+        qubits_lowered = [state.lower(qbit).expect_one() for qbit in qubits]
+
+        s = stmt(op_ssa, tuple(qubits_lowered))
+        return state.current_frame.push(s)

bloqade/squin/op/__init__.py

@@ -25,6 +25,7 @@ from ._wrapper import (
     kron as kron,
     mult as mult,
     phase as phase,
+    reset as reset,
     scale as scale,
     shift as shift,
     spin_n as spin_n,

bloqade/squin/op/_wrapper.py

@@ -37,6 +37,10 @@ def control(op: types.Op, *, n_controls: int) -> types.Op:
     ...
 
 
+@wraps(stmts.Reset)
+def reset() -> types.Op: ...
+
+
 @wraps(stmts.Identity)
 def identity(*, sites: int) -> types.Op: ...
 

bloqade/squin/op/stmts.py

@@ -142,6 +142,16 @@ class ShiftOp(PrimitiveOp):
     result: ir.ResultValue = info.result(OpType)
 
 
+@statement(dialect=dialect)
+class Reset(PrimitiveOp):
+    """
+    Reset operator for qubits or wires.
+    """
+
+    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), FixedSites(1)})
+    result: ir.ResultValue = info.result(OpType)
+
+
 @statement
 class PauliOp(ConstantUnitary):
     pass

bloqade/squin/qubit.py

@@ -17,6 +17,8 @@ from kirin.lowering import wraps
 from bloqade.types import Qubit, QubitType
 from bloqade.squin.op.types import Op, OpType
 
+from .lowering import ApplyAnyCallLowering
+
 dialect = ir.Dialect("squin.qubit")
 
 
@@ -34,6 +36,14 @@ class Apply(ir.Statement):
     qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType])
 
 
+@statement(dialect=dialect)
+class ApplyAny(ir.Statement):
+    # NOTE: custom lowering to deal with vararg calls
+    traits = frozenset({ApplyAnyCallLowering()})
+    operator: ir.SSAValue = info.argument(OpType)
+    qubits: tuple[ir.SSAValue, ...] = info.argument()
+
+
 @statement(dialect=dialect)
 class Broadcast(ir.Statement):
     traits = frozenset({lowering.FromPythonCall()})
@@ -68,19 +78,6 @@ class MeasureQubitList(ir.Statement):
     result: ir.ResultValue = info.result(ilist.IListType[types.Bool])
 
 
-@statement(dialect=dialect)
-class MeasureAndReset(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall()})
-    qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType])
-    result: ir.ResultValue = info.result(ilist.IListType[types.Bool])
-
-
-@statement(dialect=dialect)
-class Reset(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall()})
-    qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType])
-
-
 # NOTE: no dependent types in Python, so we have to mark it Any...
 @wraps(New)
 def new(n_qubits: int) -> ilist.IList[Qubit, Any]:
@@ -95,7 +92,7 @@ def new(n_qubits: int) -> ilist.IList[Qubit, Any]:
     ...
 
 
-@wraps(Apply)
+@overload
 def apply(operator: Op, qubits: ilist.IList[Qubit, Any] | list[Qubit]) -> None:
     """Apply an operator to a list of qubits.
 
@@ -112,6 +109,27 @@ def apply(operator: Op, qubits: ilist.IList[Qubit, Any] | list[Qubit]) -> None:
     ...
 
 
+@overload
+def apply(operator: Op, *qubits: Qubit) -> None:
+    """Apply and operator to any number of qubits.
+
+    Note, that when considering atom loss, lost qubits will be skipped.
+
+    Args:
+        operator: The operator to apply.
+        *qubits: The qubits to apply the operator to. The number of qubits must
+            match the size of the operator.
+
+    Returns:
+        None
+    """
+    ...
+
+
+@wraps(ApplyAny)
+def apply(operator: Op, *qubits) -> None: ...
+
+
 @overload
 def measure(input: Qubit) -> bool: ...
 @overload
@@ -161,26 +179,3 @@ def broadcast(operator: Op, qubits: ilist.IList[Qubit, Any] | list[Qubit]) -> No
         None
     """
     ...
-
-
-@wraps(MeasureAndReset)
-def measure_and_reset(qubits: ilist.IList[Qubit, Any]) -> ilist.IList[bool, Any]:
-    """Measure the qubits in the list and reset them."
-
-    Args:
-        qubits: The list of qubits to measure and reset.
-
-    Returns:
-        list[bool]: The result of the measurement.
-    """
-    ...
-
-
-@wraps(Reset)
-def reset(qubits: ilist.IList[Qubit, Any]) -> None:
-    """Reset the qubits in the list."
-
-    Args:
-        qubits: The list of qubits to reset.
-    """
-    ...

bloqade/squin/rewrite/desugar.py

@@ -0,0 +1,65 @@
+from kirin import ir, types
+from kirin.dialects import ilist
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from bloqade.squin.qubit import (
+    Apply,
+    ApplyAny,
+    QubitType,
+    MeasureAny,
+    MeasureQubit,
+    MeasureQubitList,
+)
+
+
+class MeasureDesugarRule(RewriteRule):
+    """
+    Desugar measure operations in the circuit.
+    """
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+
+        if not isinstance(node, MeasureAny):
+            return RewriteResult()
+
+        if node.input.type.is_subseteq(QubitType):
+            node.replace_by(
+                MeasureQubit(
+                    qubit=node.input,
+                )
+            )
+            return RewriteResult(has_done_something=True)
+        elif node.input.type.is_subseteq(ilist.IListType[QubitType, types.Any]):
+            node.replace_by(
+                MeasureQubitList(
+                    qubits=node.input,
+                )
+            )
+            return RewriteResult(has_done_something=True)
+
+        return RewriteResult()
+
+
+class ApplyDesugarRule(RewriteRule):
+    """
+    Desugar apply operators in the kernel.
+    """
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+
+        if not isinstance(node, ApplyAny):
+            return RewriteResult()
+
+        op = node.operator
+        qubits = node.qubits
+
+        if len(qubits) == 1 and qubits[0].type.is_subseteq(ilist.IListType):
+            # NOTE: already calling with just a single argument that is already an ilist
+            qubits_ilist = qubits[0]
+        else:
+            (qubits_ilist_stmt := ilist.New(values=qubits)).insert_before(node)
+            qubits_ilist = qubits_ilist_stmt.result
+
+        stmt = Apply(operator=op, qubits=qubits_ilist)
+        node.replace_by(stmt)
+        return RewriteResult(has_done_something=True)