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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.3.0
+Version: 0.4.0
 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
@@ -24,6 +24,8 @@ Provides-Extra: qasm2
 Requires-Dist: lark>=1.2.2; extra == 'qasm2'
 Provides-Extra: qbraid
 Requires-Dist: qbraid>=0.9.3; extra == 'qbraid'
+Provides-Extra: stim
+Requires-Dist: stim>=1.15.0; extra == 'stim'
 Provides-Extra: vis
 Requires-Dist: ffmpeg>=1.4; extra == 'vis'
 Requires-Dist: matplotlib>=3.9.2; extra == 'vis'

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

@@ -1,6 +1,6 @@
 [project]
 name = "bloqade-circuit"
-version = "0.3.0"
+version = "0.4.0"
 description = "The software development toolkit for neutral atom arrays."
 readme = "README.md"
 authors = [
@@ -44,6 +44,9 @@ pyqrack-opencl = [
 pyqrack-cuda = [
     "pyqrack-cuda>=1.38.2",
 ]
+stim = [
+    "stim>=1.15.0",
+]
 
 [build-system]
 requires = ["hatchling"]
@@ -79,6 +82,7 @@ dev-linux = [
     "matplotlib>=3.9.2",
     "pyqt5>=5.15.11",
     "tqdm>=4.67.1",
+    "stim>=1.15.0",
 ]
 dev-mac-arm = [
     "cirq-core[contrib]>=1.4.1",
@@ -89,6 +93,7 @@ dev-mac-arm = [
     "pyqt5>=5.15.11",
     "qbraid>=0.9.5",
     "tqdm>=4.67.1",
+    "stim>=1.15.0",
 ]
 
 [tool.isort]

{bloqade_circuit-0.3.0 → bloqade_circuit-0.4.0}/src/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_circuit-0.3.0 → bloqade_circuit-0.4.0}/src/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_circuit-0.3.0 → bloqade_circuit-0.4.0}/src/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_circuit-0.3.0 → bloqade_circuit-0.4.0}/src/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_circuit-0.3.0 → bloqade_circuit-0.4.0}/src/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_circuit-0.3.0 → bloqade_circuit-0.4.0}/src/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_circuit-0.3.0/src/bloqade/noise/native → bloqade_circuit-0.4.0/src/bloqade/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_circuit-0.4.0/src/bloqade/qasm2/dialects/noise/_dialect.py

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

{bloqade_circuit-0.3.0/src/bloqade → bloqade_circuit-0.4.0/src/bloqade/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_circuit-0.4.0/src/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_circuit-0.4.0/src/bloqade/qasm2/emit/impls/__init__.py

@@ -0,0 +1 @@
+from .noise import NativeNoise as NativeNoise

bloqade_circuit-0.3.0/src/bloqade/qasm2/emit/impls/noise_native.py → bloqade_circuit-0.4.0/src/bloqade/qasm2/emit/impls/noise.py

@@ -3,12 +3,12 @@ from typing import Any
 from kirin import interp
 from kirin.dialects import ilist
 
-from bloqade.noise import native
 from bloqade.qasm2.parse import ast
+from bloqade.qasm2.dialects import noise
 from bloqade.qasm2.emit.gate import EmitQASM2Gate, EmitQASM2Frame
 
 
-@native.dialect.register(key="emit.qasm2.gate")
+@noise.dialect.register(key="emit.qasm2.gate")
 class NativeNoise(interp.MethodTable):
 
     def _convert(self, node: ast.Bit | ast.Name) -> str:
@@ -17,12 +17,12 @@ class NativeNoise(interp.MethodTable):
         else:
             return f"{node.id}"
 
-    @interp.impl(native.CZPauliChannel)
+    @interp.impl(noise.CZPauliChannel)
     def emit_czp(
         self,
         emit: EmitQASM2Gate,
         frame: EmitQASM2Frame,
-        stmt: native.CZPauliChannel,
+        stmt: noise.CZPauliChannel,
     ):
         paired: bool = stmt.paired
         px_ctrl: float = stmt.px_ctrl
@@ -35,7 +35,7 @@ class NativeNoise(interp.MethodTable):
         qargs: ilist.IList[ast.Bit, Any] = frame.get(stmt.qargs)
         frame.body.append(
             ast.Comment(
-                text=f"native.CZPauliChannel(paired={paired}, p_ctrl=[x:{px_ctrl}, y:{py_ctrl}, z:{pz_ctrl}], p_qarg[x:{px_qarg}, y:{py_qarg}, z:{pz_qarg}])"
+                text=f"noise.CZPauliChannel(paired={paired}, p_ctrl=[x:{px_ctrl}, y:{py_ctrl}, z:{pz_ctrl}], p_qarg[x:{px_qarg}, y:{py_qarg}, z:{pz_qarg}])"
             )
         )
         frame.body.append(
@@ -50,16 +50,16 @@ class NativeNoise(interp.MethodTable):
         )
         return ()
 
-    @interp.impl(native.AtomLossChannel)
+    @interp.impl(noise.AtomLossChannel)
     def emit_loss(
         self,
         emit: EmitQASM2Gate,
         frame: EmitQASM2Frame,
-        stmt: native.AtomLossChannel,
+        stmt: noise.AtomLossChannel,
     ):
         prob: float = stmt.prob
         qargs: ilist.IList[ast.Bit, Any] = frame.get(stmt.qargs)
-        frame.body.append(ast.Comment(text=f"native.Atomloss(p={prob})"))
+        frame.body.append(ast.Comment(text=f"noise.Atomloss(p={prob})"))
         frame.body.append(
             ast.Comment(
                 text=f" -: qargs: {', '.join([self._convert(q) for q in qargs])}"
@@ -67,19 +67,19 @@ class NativeNoise(interp.MethodTable):
         )
         return ()
 
-    @interp.impl(native.PauliChannel)
+    @interp.impl(noise.PauliChannel)
     def emit_pauli(
         self,
         emit: EmitQASM2Gate,
         frame: EmitQASM2Frame,
-        stmt: native.PauliChannel,
+        stmt: noise.PauliChannel,
     ):
         px: float = stmt.px
         py: float = stmt.py
         pz: float = stmt.pz
         qargs: ilist.IList[ast.Bit, Any] = frame.get(stmt.qargs)
         frame.body.append(
-            ast.Comment(text=f"native.PauliChannel(px={px}, py={py}, pz={pz})")
+            ast.Comment(text=f"noise.PauliChannel(px={px}, py={py}, pz={pz})")
         )
         frame.body.append(
             ast.Comment(