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

bloqade/analysis/address/impls.py

@@ -75,6 +75,7 @@ class PyIndexing(interp.MethodTable):
     def getitem(self, interp: AddressAnalysis, frame: interp.Frame, stmt: py.GetItem):
         # Integer index into the thing being indexed
         idx = interp.get_const_value(int, stmt.index)
+
         # The object being indexed into
         obj = frame.get(stmt.obj)
         # The `data` attributes holds onto other Address types
@@ -144,13 +145,13 @@ class Scf(scf.absint.Methods):
         # NOTE: we need to actually run iteration in case there are
         # new allocations/re-assign in the loop body.
         for _ in iterable:
-            with interp_.state.new_frame(interp_.new_frame(stmt)) as body_frame:
+            with interp_.new_frame(stmt) as body_frame:
                 body_frame.entries.update(frame.entries)
                 body_frame.set_values(
                     block_args,
                     (NotQubit(),) + loop_vars,
                 )
-                loop_vars = interp_.run_ssacfg_region(body_frame, stmt.body)
+                loop_vars = interp_.run_ssacfg_region(body_frame, stmt.body, ())
 
             if loop_vars is None:
                 loop_vars = ()
@@ -206,20 +207,6 @@ class SquinWireMethodTable(interp.MethodTable):
     ):
         return frame.get_values(stmt.inputs)
 
-    @interp.impl(squin.wire.MeasureAndReset)
-    def measure_and_reset(
-        self,
-        interp_: AddressAnalysis,
-        frame: ForwardFrame[Address],
-        stmt: squin.wire.MeasureAndReset,
-    ):
-
-        # take the address data from the incoming wire
-        # and propagate that forward to the new wire generated.
-        # The first entry can safely be NotQubit because
-        # it's an integer
-        return (NotQubit(), frame.get(stmt.wire))
-
 
 @squin.qubit.dialect.register(key="qubit.address")
 class SquinQubitMethodTable(interp.MethodTable):

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/pyqrack/noise/native.py

@@ -2,11 +2,11 @@ from typing import List
 
 from kirin import interp
 
-from bloqade.noise import native
 from bloqade.pyqrack import PyQrackInterpreter, reg
+from bloqade.qasm2.dialects import noise
 
 
-@native.dialect.register(key="pyqrack")
+@noise.dialect.register(key="pyqrack")
 class PyQrackMethods(interp.MethodTable):
     def apply_pauli_error(
         self,
@@ -27,12 +27,12 @@ class PyQrackMethods(interp.MethodTable):
 
         getattr(qarg.sim_reg, which)(qarg.addr)
 
-    @interp.impl(native.PauliChannel)
+    @interp.impl(noise.PauliChannel)
     def single_qubit_error_channel(
         self,
         interp: PyQrackInterpreter,
         frame: interp.Frame,
-        stmt: native.PauliChannel,
+        stmt: noise.PauliChannel,
     ):
         qargs: List[reg.PyQrackQubit] = frame.get(stmt.qargs)
 
@@ -43,12 +43,12 @@ class PyQrackMethods(interp.MethodTable):
 
         return ()
 
-    @interp.impl(native.CZPauliChannel)
+    @interp.impl(noise.CZPauliChannel)
     def cz_pauli_channel(
         self,
         interp: PyQrackInterpreter,
         frame: interp.Frame,
-        stmt: native.CZPauliChannel,
+        stmt: noise.CZPauliChannel,
     ):
 
         qargs: List[reg.PyQrackQubit] = frame.get(stmt.qargs)
@@ -80,12 +80,12 @@ class PyQrackMethods(interp.MethodTable):
 
         return ()
 
-    @interp.impl(native.AtomLossChannel)
+    @interp.impl(noise.AtomLossChannel)
     def atom_loss_channel(
         self,
         interp: PyQrackInterpreter,
         frame: interp.Frame,
-        stmt: native.AtomLossChannel,
+        stmt: noise.AtomLossChannel,
     ):
         qargs: List[reg.PyQrackQubit] = frame.get(stmt.qargs)
 

bloqade/pyqrack/squin/noise/__init__.py

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

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/pyqrack/squin/op.py

@@ -10,6 +10,7 @@ from .runtime import (
     RotRuntime,
     KronRuntime,
     MultRuntime,
+    ResetRuntime,
     ScaleRuntime,
     AdjointRuntime,
     ControlRuntime,
@@ -94,6 +95,12 @@ class PyQrackMethods(interp.MethodTable):
         global_ = isinstance(stmt, op.stmts.PhaseOp)
         return (PhaseOpRuntime(theta, global_=global_),)
 
+    @interp.impl(op.stmts.Reset)
+    def reset(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Reset
+    ) -> tuple[OperatorRuntimeABC]:
+        return (ResetRuntime(),)
+
     @interp.impl(op.stmts.X)
     @interp.impl(op.stmts.Y)
     @interp.impl(op.stmts.Z)

bloqade/pyqrack/squin/qubit.py

@@ -61,32 +61,3 @@ class PyQrackMethods(interp.MethodTable):
         qbit: PyQrackQubit = frame.get(stmt.qubit)
         result = self._measure_qubit(qbit, interp)
         return (result,)
-
-    @interp.impl(qubit.MeasureAndReset)
-    def measure_and_reset(
-        self,
-        interp: PyQrackInterpreter,
-        frame: interp.Frame,
-        stmt: qubit.MeasureAndReset,
-    ):
-        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
-        result = []
-        for qbit in qubits:
-            qbit_result = self._measure_qubit(qbit, interp)
-
-            if qbit_result:
-                qbit.sim_reg.x(qbit.addr)
-
-            result.append(qbit_result)
-
-        return (ilist.IList(result),)
-
-    @interp.impl(qubit.Reset)
-    def reset(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.Reset):
-        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
-        for qbit in qubits:
-            if not qbit.is_active():
-                continue
-
-            if bool(qbit.sim_reg.m(qbit.addr)):
-                qbit.sim_reg.x(qbit.addr)

bloqade/pyqrack/squin/runtime.py

@@ -41,6 +41,24 @@ class OperatorRuntimeABC:
             self.apply(*targets, **kwargs)
 
 
+@dataclass(frozen=True)
+class ResetRuntime(OperatorRuntimeABC):
+    """Reset the qubit to |0> state"""
+
+    @property
+    def n_sites(self) -> int:
+        return 1
+
+    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
+        for qubit in qubits:
+            if not qubit.is_active():
+                continue
+
+            res: bool = qubit.sim_reg.m(qubit.addr)
+            if res:
+                qubit.sim_reg.x(qubit.addr)
+
+
 @dataclass(frozen=True)
 class OperatorRuntime(OperatorRuntimeABC):
     method_name: str

bloqade/pyqrack/squin/wire.py

@@ -49,39 +49,3 @@ class PyQrackMethods(interp.MethodTable):
 
         res: bool = bool(qbit.sim_reg.m(qbit.addr))
         return (res,)
-
-    @interp.impl(wire.MeasureAndReset)
-    def measure_and_reset(
-        self,
-        interp: PyQrackInterpreter,
-        frame: interp.Frame,
-        stmt: wire.MeasureAndReset,
-    ):
-        w: PyQrackWire = frame.get(stmt.wire)
-        qbit = w.qubit
-
-        if not qbit.is_active():
-            return (w, interp.loss_m_result)
-
-        res: bool = bool(qbit.sim_reg.m(qbit.addr))
-
-        if res:
-            qbit.sim_reg.x(qbit.addr)
-
-        # TODO: do we need to rewrap this here? The qbit changed in-place
-        new_w = PyQrackWire(qbit)
-        return (new_w, res)
-
-    @interp.impl(wire.Reset)
-    def reset(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: wire.Reset):
-        w: PyQrackWire = frame.get(stmt.wire)
-        qbit = w.qubit
-
-        if not qbit.is_active():
-            return (w,)
-
-        if bool(qbit.sim_reg.m(qbit.addr)):
-            qbit.sim_reg.x(qbit.addr)
-
-        new_w = PyQrackWire(qbit)
-        return (new_w,)

bloqade/{noise/native → qasm2/dialects/noise}/__init__.py

@@ -2,7 +2,6 @@
 moving towards a more general approach to noise modeling in the future."""
 
 from .model import (
-    GateNoiseParams as GateNoiseParams,
     TwoRowZoneModel as TwoRowZoneModel,
     MoveNoiseModelABC as MoveNoiseModelABC,
 )
@@ -11,10 +10,5 @@ from .stmts import (
     CZPauliChannel as CZPauliChannel,
     AtomLossChannel as AtomLossChannel,
 )
-from .rewrite import RemoveNoisePass as RemoveNoisePass
 from ._dialect import dialect as dialect
-from ._wrappers import (
-    pauli_channel as pauli_channel,
-    cz_pauli_channel as cz_pauli_channel,
-    atom_loss_channel as atom_loss_channel,
-)
+from .fidelity import FidelityMethodTable as FidelityMethodTable

bloqade/qasm2/dialects/noise/_dialect.py

@@ -0,0 +1,3 @@
+from kirin import ir
+
+dialect = ir.Dialect("qasm2.noise")

bloqade/{noise → qasm2/dialects/noise}/fidelity.py

@@ -4,8 +4,8 @@ from kirin.lattice import EmptyLattice
 from bloqade.analysis.address import AddressQubit, AddressTuple
 from bloqade.analysis.fidelity import FidelityAnalysis
 
-from .native import dialect
-from .native.stmts import PauliChannel, CZPauliChannel, AtomLossChannel
+from .stmts import PauliChannel, CZPauliChannel, AtomLossChannel
+from ._dialect import dialect
 
 
 @dialect.register(key="circuit.fidelity")

bloqade/qasm2/dialects/noise/model.py

@@ -0,0 +1,278 @@
+import abc
+from dataclasses import field, dataclass
+
+
+@dataclass(frozen=True)
+class MoveNoiseModelABC(abc.ABC):
+    """Abstract base class for noise based on atom movement.
+
+    This class defines the interface for a noise model. The gate noise is calculated from the parameters
+    provided in this dataclass which can be updated when inheriting from this class. The move error is
+    calculated by implementing the parallel_cz_errors method which takes a set of ctrl and qarg qubits
+    and returns a noise model for all the qubits. The noise model is a dictionary with the keys being the
+    error rates for the qubits and the values being the list of qubits that the error rate applies to.
+
+    Once implemented the class can be used with the NoisePass to analyze a circuit and apply the noise
+    model to the circuit.
+
+    NOTE: This model is not guaranteed to be supported long-term in bloqade. We will be
+    moving towards a more general approach to noise modeling in the future.
+
+    """
+
+    # parameters for gate noise
+
+    local_px: float = field(default=4.102e-04, kw_only=True)
+    """The error probability for a Pauli-X error during a local single qubit gate operation."""
+    local_py: float = field(default=4.102e-04, kw_only=True)
+    """The error probability for a Pauli-Y error during a local single qubit gate operation."""
+    local_pz: float = field(default=4.112e-04, kw_only=True)
+    """The error probability for a Pauli-Z error during a local single qubit gate operation."""
+    local_loss_prob: float = field(default=0.0, kw_only=True)
+    """The error probability for a loss during a local single qubit gate operation."""
+
+    local_unaddressed_px: float = field(default=2.000e-07, kw_only=True)
+    """The error probability for a Pauli-X error during a local single qubit gate operation when the qubit is not addressed."""
+    local_unaddressed_py: float = field(default=2.000e-07, kw_only=True)
+    """The error probability for a Pauli-Y error during a local single qubit gate operation when the qubit is not addressed."""
+    local_unaddressed_pz: float = field(default=1.200e-06, kw_only=True)
+    """The error probability for a Pauli-Z error during a local single qubit gate operation when the qubit is not addressed."""
+    local_unaddressed_loss_prob: float = field(default=0.0, kw_only=True)
+    """The error probability for a loss during a local single qubit gate operation when the qubit is not addressed."""
+
+    global_px: float = field(default=6.500e-05, kw_only=True)
+    """The error probability for a Pauli-X error during a global single qubit gate operation."""
+    global_py: float = field(default=6.500e-05, kw_only=True)
+    """The error probability for a Pauli-Y error during a global single qubit gate operation."""
+    global_pz: float = field(default=6.500e-05, kw_only=True)
+    """The error probability for a Pauli-Z error during a global single qubit gate operation."""
+    global_loss_prob: float = field(default=0.0, kw_only=True)
+    """The error probability for a loss during a global single qubit gate operation."""
+
+    cz_paired_gate_px: float = field(default=6.549e-04, kw_only=True)
+    """The error probability for a Pauli-X error during CZ gate operation when two qubits are within blockade radius."""
+    cz_paired_gate_py: float = field(default=6.549e-04, kw_only=True)
+    """The error probability for a Pauli-Y error during CZ gate operation when two qubits are within blockade radius."""
+    cz_paired_gate_pz: float = field(default=3.184e-03, kw_only=True)
+    """The error probability for a Pauli-Z error during CZ gate operation when two qubits are within blockade radius."""
+    cz_gate_loss_prob: float = field(default=0.0, kw_only=True)
+    """The error probability for a loss during CZ gate operation when two qubits are within blockade radius."""
+
+    cz_unpaired_gate_px: float = field(default=5.149e-04, kw_only=True)
+    """The error probability for Pauli-X error during CZ gate operation when another qubit is not within blockade radius."""
+    cz_unpaired_gate_py: float = field(default=5.149e-04, kw_only=True)
+    """The error probability for Pauli-Y error during CZ gate operation when another qubit is not within blockade radius."""
+    cz_unpaired_gate_pz: float = field(default=2.185e-03, kw_only=True)
+    """The error probability for Pauli-Z error during CZ gate operation when another qubit is not within blockade radius."""
+    cz_unpaired_loss_prob: float = field(default=0.0, kw_only=True)
+    """The error probability for a loss during CZ gate operation when another qubit is not within blockade radius."""
+
+    # parameters for move noise
+
+    mover_px: float = field(default=8.060e-04, kw_only=True)
+    """Probability of X error occurring on a moving qubit during a move operation"""
+    mover_py: float = field(default=8.060e-04, kw_only=True)
+    """Probability of Y error occurring on a moving qubit during a move operation"""
+    mover_pz: float = field(default=2.458e-03, kw_only=True)
+    """Probability of Z error occurring on a moving qubit during a move operation"""
+    move_loss_prob: float = field(default=0.0, kw_only=True)
+    """Probability of loss occurring on a moving qubit during a move operation"""
+
+    sitter_px: float = field(default=3.066e-04, kw_only=True)
+    """Probability of X error occurring on a stationary qubit during a move operation"""
+    sitter_py: float = field(default=3.066e-04, kw_only=True)
+    """Probability of Y error occurring on a stationary qubit during a move operation"""
+    sitter_pz: float = field(default=4.639e-04, kw_only=True)
+    """Probability of Z error occurring on a stationary qubit during a move operation"""
+    sit_loss_prob: float = field(default=0.0, kw_only=True)
+    """Probability of loss occurring on a stationary qubit during a move operation"""
+
+    @property
+    def cz_paired_errors(
+        self,
+    ) -> tuple[float, float, float, float]:
+        """Returns the error rates for a CZ gate."""
+        return (
+            self.cz_paired_gate_px,
+            self.cz_paired_gate_py,
+            self.cz_paired_gate_pz,
+            self.cz_gate_loss_prob,
+        )
+
+    @property
+    def cz_unpaired_errors(
+        self,
+    ) -> tuple[float, float, float, float]:
+        """Returns the error rates for a CZ gate."""
+        return (
+            self.cz_unpaired_gate_px,
+            self.cz_unpaired_gate_py,
+            self.cz_unpaired_gate_pz,
+            self.cz_unpaired_loss_prob,
+        )
+
+    @property
+    def local_errors(
+        self,
+    ) -> tuple[float, float, float, float]:
+        """Returns the error rates for a local single qubit gate."""
+        return (
+            self.local_px,
+            self.local_py,
+            self.local_pz,
+            self.local_loss_prob,
+        )
+
+    @property
+    def local_unaddressed_errors(
+        self,
+    ) -> tuple[float, float, float, float]:
+        """Returns the error rates for a local single qubit gate."""
+        return (
+            self.local_unaddressed_px,
+            self.local_unaddressed_py,
+            self.local_unaddressed_pz,
+            self.local_unaddressed_loss_prob,
+        )
+
+    @property
+    def global_errors(
+        self,
+    ) -> tuple[float, float, float, float]:
+        """Returns the error rates for a global single qubit gate."""
+        return (
+            self.global_px,
+            self.global_py,
+            self.global_pz,
+            self.global_loss_prob,
+        )
+
+    @property
+    def sitter_errors(
+        self,
+    ) -> tuple[float, float, float, float]:
+        """Returns the error rates for a move operation."""
+        return (
+            self.sitter_px,
+            self.sitter_py,
+            self.sitter_pz,
+            self.sit_loss_prob,
+        )
+
+    @abc.abstractmethod
+    def parallel_cz_errors(
+        self, ctrls: list[int], qargs: list[int], rest: list[int]
+    ) -> dict[tuple[float, float, float, float], list[int]]:
+        """Takes a set of ctrls and qargs and returns a noise model for all qubits."""
+        pass
+
+    @classmethod
+    def join_binary_probs(cls, p1: float, *args: float) -> float:
+        """Merge the probabilities of an event happening if the event can only happen once.
+
+        For example, finding the effective probability of losing an atom from multiple sources, since
+        a qubit can only be lost once. This is done by using the formula:
+
+        p = p1 * (1 - p2) + p2 * (1 - p1)
+
+        applied recursively to all the probabilities in the list.
+
+        Args:
+            p1 (float): The probability of the event happening.
+            arg (float): The probabilities of the event happening from other sources.
+
+        Returns:
+            float: The effective probability of the event happening.
+
+        """
+        if len(args) == 0:
+            return p1
+        else:
+            p2 = cls.join_binary_probs(*args)
+            return p1 * (1 - p2) + p2 * (1 - p1)
+
+
+@dataclass(frozen=True)
+class TwoRowZoneModel(MoveNoiseModelABC):
+    """This model assumes that the qubits are arranged in a single storage row with a row corresponding to a gate zone below it.
+
+    The CZ gate noise is calculated using the following heuristic: The idle error is calculated by the total duration required
+    to do the move and entangle the qubits. Not every pair can be entangled at the same time, so we first deconflict the qargs
+    by finding subsets in which both the ctrl and the qarg qubits are in ascending order. This breaks the pairs into
+    groups that can be moved and entangled separately. We then take each group and assign each pair to a gate zone slot. The
+    slots are allocated by starting from the middle of the atoms and moving outwards making sure to keep the ctrl qubits in
+    ascending order. The time to move a group is calculated by finding the maximum travel distance of the qarg and ctrl qubits
+    and dviding by the move speed. The total move time is the sum of all the group move times. The error rate for all the qubits
+    is then calculated by using the poisson_pauli_prob function. An additional error for the pick operation is calculated by
+    joining the binary probabilities of the pick operation and the move operation.
+
+    """
+
+    @property
+    def move_errors(
+        self,
+    ) -> tuple[float, float, float, float]:
+        """Returns the error rates for a move operation."""
+        return (
+            self.mover_px / 2,
+            self.mover_py / 2,
+            self.mover_pz / 2,
+            self.move_loss_prob / 2,
+        )
+
+    def deconflict(
+        self, ctrls: list[int], qargs: list[int]
+    ) -> list[tuple[tuple[int, ...], tuple[int, ...]]]:
+        """Return a list of groups of ctrl and qarg qubits that can be moved and entangled separately."""
+        # sort by ctrl qubit first to guarantee that they will be in ascending order
+        sorted_pairs = sorted(zip(ctrls, qargs))
+
+        groups: list[list[tuple[int, int]]] = []
+        # group by qarg only putting it in a group if the qarg is greater than the last qarg in the group
+        # thus ensuring that the qargs are in ascending order
+        while len(sorted_pairs) > 0:
+            ctrl, qarg = sorted_pairs.pop(0)
+
+            found = False
+            for group in groups:
+                if group[-1][1] < qarg:
+                    group.append((ctrl, qarg))
+                    found = True
+                    break
+            if not found:
+                groups.append([(ctrl, qarg)])
+
+        new_groups: list[tuple[tuple[int, ...], tuple[int, ...]]] = []
+
+        for group in groups:
+            ctrl, qarg = zip(*group)
+            ctrl = tuple(ctrl)
+            qarg = tuple(qarg)
+            new_groups.append((ctrl, qarg))
+
+        return new_groups
+
+    def parallel_cz_errors(
+        self, ctrls: list[int], qargs: list[int], rest: list[int]
+    ) -> dict[tuple[float, float, float, float], list[int]]:
+        """Apply parallel gates by moving ctrl qubits to qarg qubits."""
+        groups = self.deconflict(ctrls, qargs)
+        movers = ctrls + qargs
+        num_moves = len(groups)
+        # ignore order O(p^2) errors since they are small
+        effective_move_errors = (
+            self.move_errors[0] + self.sitter_errors[0] * (num_moves - 1),
+            self.move_errors[1] + self.sitter_errors[1] * (num_moves - 1),
+            self.move_errors[2] + self.sitter_errors[2] * (num_moves - 1),
+            self.move_errors[3] + self.sitter_errors[3] * (num_moves - 1),
+        )
+        effective_sitter_errors = (
+            self.sitter_errors[0] * num_moves,
+            self.sitter_errors[1] * num_moves,
+            self.sitter_errors[2] * num_moves,
+            self.sitter_errors[3] * num_moves,
+        )
+        result = {effective_move_errors: list(movers)}
+        result.setdefault(effective_sitter_errors, []).extend(rest)
+
+        return result

bloqade/qasm2/emit/impls/__init__.py

@@ -1 +1 @@
-from . import noise_native as noise_native
+from .noise import NativeNoise as NativeNoise