bloqade-circuit 0.1.0__py3-none-any.whl

bloqade/noise/native/model.py

@@ -0,0 +1,347 @@
+import abc
+import math
+from typing import Dict, List, Tuple
+from dataclasses import field, dataclass
+from collections.abc import Sequence
+
+
+@dataclass(frozen=True)
+class GateNoiseParams:
+    """Parameters for gate noise."""
+
+    local_px: float = field(default=1e-3, kw_only=True)
+    """The error probability for a Pauli-X error during a local single qubit gate operation."""
+    local_py: float = field(default=1e-3, kw_only=True)
+    """The error probability for a Pauli-Y error during a local single qubit gate operation."""
+    local_pz: float = field(default=1e-3, kw_only=True)
+    """The error probability for a Pauli-Z error during a local single qubit gate operation."""
+    local_loss_prob: float = field(default=1e-4, kw_only=True)
+    """The error probability for a loss during a local single qubit gate operation."""
+
+    global_px: float = field(default=1e-3, kw_only=True)
+    """The error probability for a Pauli-X error during a global single qubit gate operation."""
+    global_py: float = field(default=1e-3, kw_only=True)
+    """The error probability for a Pauli-Y error during a global single qubit gate operation."""
+    global_pz: float = field(default=1e-3, kw_only=True)
+    """The error probability for a Pauli-Z error during a global single qubit gate operation."""
+    global_loss_prob: float = field(default=1e-3, kw_only=True)
+    """The error probability for a loss during a global single qubit gate operation."""
+
+    cz_paired_gate_px: float = field(default=1e-3, 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=1e-3, 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=1e-3, 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=1e-3, 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=1e-3, 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=1e-3, 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=1e-3, 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=1e-3, kw_only=True)
+    """The error probability for a loss during CZ gate operation when another qubit is not within blockade radius."""
+
+
+@dataclass(frozen=True)
+class MoveNoiseParams:
+    idle_px_rate: float = field(default=1e-6, kw_only=True)
+    """The error rate (prob/microsecond) for a Pauli-X error during an idle operation."""
+    idle_py_rate: float = field(default=1e-6, kw_only=True)
+    """The error rate (prob/microsecond) for a Pauli-Y error during an idle operation."""
+    idle_pz_rate: float = field(default=1e-6, kw_only=True)
+    """The error rate (prob/microsecond) for a Pauli-Z error during an idle operation."""
+    idle_loss_rate: float = field(default=1e-6, kw_only=True)
+    """The error rate (prob/microsecond) for a loss during an idle operation."""
+
+    move_px_rate: float = field(default=1e-6, kw_only=True)
+    """The error rate (prob/microsecond) for a Pauli-X error during a move operation."""
+    move_py_rate: float = field(default=1e-6, kw_only=True)
+    """The error rate e (prob/microsecond) for a Pauli-Y error during a move operation."""
+    move_pz_rate: float = field(default=1e-6, kw_only=True)
+    """The error rate e (prob/microsecond) for a Pauli-Z error during a move operation."""
+    move_loss_rate: float = field(default=1e-6, kw_only=True)
+    """The error rate e (prob/microsecond) for a loss during a move operation."""
+
+    pick_px: float = field(default=1e-3, kw_only=True)
+    """The error rate (prob per pick operation)  for a Pauli-X error during a pick operation."""
+    pick_py: float = field(default=1e-3, kw_only=True)
+    """The error rate (prob per pick operation) for a Pauli-Y error during a pick operation."""
+    pick_pz: float = field(default=1e-3, kw_only=True)
+    """The error rate (prob per pick operation) for a Pauli-Z error during a pick operation."""
+    pick_loss_prob: float = field(default=1e-4, kw_only=True)
+    """The error rate for a loss during a pick operation."""
+
+    move_speed: float = field(default=5e-1, kw_only=True)
+    """Maximum speed of the qubits during a move operation."""
+    storage_spacing: float = field(default=4.0, kw_only=True)
+    """Spacing between the qubits in the storage zone."""
+
+
+@dataclass
+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 form 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.
+
+    """
+
+    params: MoveNoiseParams = field(default_factory=MoveNoiseParams)
+    """Parameters for calculating move noise."""
+
+    @classmethod
+    @abc.abstractmethod
+    def parallel_cz_errors(
+        cls, 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
+
+    @staticmethod
+    def poisson_pauli_prob(rate: float, duration: float) -> float:
+        """Calculate the number of noise events and their probabilities for a given rate and duration."""
+        assert duration >= 0, "Duration must be non-negative"
+        assert rate >= 0, "Rate must be non-negative"
+        return 0.5 * (1 - math.exp(-2 * rate * duration))
+
+    @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 happen 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
+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 require
+    to do the move and entable the qubits. Not every pair can be entangled at the same time, so we first deconflict the qargs
+    assuming 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.
+
+    """
+
+    gate_zone_y_offset: float = 20.0
+    gate_spacing: float = 20.0
+
+    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 = []
+        # 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)])
+
+        return [tuple(zip(*group)) for group in groups]
+
+    def assign_gate_slots(
+        self, ctrls: Sequence[int], qargs: Sequence[int]
+    ) -> Dict[int, Tuple[int, int]]:
+        """Allocate slots for the qubits to move to. start from middle of atoms and move outwards
+        making sure to keep the ctrl qubits in ascending order.
+
+        Note that we can do this because the move strategy is to move the ctrl qubits separately
+        from the qarg qubits, thus we don't have to worry about qarg qubits crossing the ctrl qubits
+        and vice versa. We pick the median of all the atoms because it distributes the qubits
+        as evenly as possible over the gate zone.
+
+        """
+        assert len(ctrls) == len(qargs), "Number of ctrls and qargs must be equal"
+        addr_pairs = sorted(zip(ctrls, qargs), key=lambda x: x[0])
+        # sort by the distance between the ctrl and qarg qubits
+
+        ctrls, qargs = list(zip(*addr_pairs))
+
+        n_ctrls = len(ctrls)
+
+        ctrl_median = (
+            ctrls[n_ctrls // 2]
+            if n_ctrls % 2 == 1
+            else (ctrls[n_ctrls // 2 - 1] + ctrls[n_ctrls // 2]) / 2
+        )
+
+        all_addr = sorted(ctrls + qargs)
+        spatial_median = self.params.storage_spacing * (all_addr[0] + all_addr[-1]) / 2
+
+        addr_pairs.sort(key=lambda x: abs(x[0] - ctrl_median))
+
+        slots = {}
+        med_slot = round(spatial_median / self.gate_spacing)
+
+        left_slot = med_slot
+        right_slot = med_slot
+        slots[med_slot] = addr_pairs.pop(0)
+        while addr_pairs:
+            ctrl, qarg = addr_pairs.pop(0)
+
+            if ctrl < ctrl_median:
+                slots[left_slot := left_slot - 1] = (ctrl, qarg)
+            else:
+                slots[right_slot := right_slot + 1] = (ctrl, qarg)
+
+        return slots
+
+    def calculate_move_duration(self, slots: Dict[int, Tuple[int, int]]) -> float:
+        """Calculate the time it takes to move the qubits from the ctrl to the qarg qubits."""
+
+        qarg_x_distance = float("-inf")
+        ctrl_x_distance = float("-inf")
+
+        for slot, (ctrl, qarg) in slots.items():
+            qarg_x_distance = max(
+                qarg_x_distance,
+                abs(qarg * self.params.storage_spacing - slot * self.gate_spacing),
+            )
+            ctrl_x_distance = max(
+                ctrl_x_distance,
+                abs(ctrl * self.params.storage_spacing - slot * self.gate_spacing),
+            )
+
+        qarg_max_distance = math.sqrt(qarg_x_distance**2 + self.gate_zone_y_offset**2)
+        ctrl_max_distance = math.sqrt(
+            ctrl_x_distance**2 + (self.gate_zone_y_offset - 3) ** 2
+        )
+
+        return (qarg_max_distance + ctrl_max_distance) / self.params.move_speed
+
+    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)
+        slots = [self.assign_gate_slots(*group) for group in groups]
+
+        move_duration = sum(map(self.calculate_move_duration, slots))
+
+        px_time = self.poisson_pauli_prob(self.params.move_px_rate, move_duration)
+        py_time = self.poisson_pauli_prob(self.params.move_py_rate, move_duration)
+        px_time = self.poisson_pauli_prob(self.params.move_pz_rate, move_duration)
+        move_p_loss_time = self.poisson_pauli_prob(
+            self.params.move_loss_rate, move_duration
+        )
+
+        errors = {(px_time, py_time, px_time, move_p_loss_time): rest}
+
+        px_moved = self.join_binary_probs(self.params.pick_px, px_time)
+        py_moved = self.join_binary_probs(self.params.pick_py, py_time)
+        pz_moved = self.join_binary_probs(self.params.pick_pz, px_time)
+        p_loss_moved = self.join_binary_probs(
+            self.params.pick_loss_prob, move_p_loss_time
+        )
+
+        errors[(px_moved, py_moved, pz_moved, p_loss_moved)] = sorted(ctrls + qargs)
+
+        return errors
+
+
+@dataclass
+class SingleZoneLayoutABC(MoveNoiseModelABC):
+    gate_noise_params: GateNoiseParams = field(
+        default_factory=GateNoiseParams, kw_only=True
+    )
+
+    @abc.abstractmethod
+    def calculate_move_duration(self, ctrls: List[int], qargs: List[int]) -> float:
+        """Calculate the time it takes to reconfigure the atom for executing the CZ gates."""
+
+    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."""
+
+        move_duration = self.calculate_move_duration(ctrls, qargs)
+
+        # idle errors during atom moves
+        idle_px_time = self.poisson_pauli_prob(self.params.idle_px_rate, move_duration)
+        idle_py_time = self.poisson_pauli_prob(self.params.idle_py_rate, move_duration)
+        idle_pz_time = self.poisson_pauli_prob(self.params.idle_pz_rate, move_duration)
+        idle_p_loss_time = self.poisson_pauli_prob(
+            self.params.idle_loss_rate, move_duration
+        )
+
+        # even qubits not involved in the gate can still experience unpaired errors
+        idle_px = self.join_binary_probs(
+            self.gate_noise_params.cz_unpaired_gate_px, idle_px_time
+        )
+        idle_py = self.join_binary_probs(
+            self.gate_noise_params.cz_unpaired_gate_py, idle_py_time
+        )
+        idle_pz = self.join_binary_probs(
+            self.gate_noise_params.cz_unpaired_gate_pz, idle_pz_time
+        )
+        idle_p_loss = self.join_binary_probs(
+            self.gate_noise_params.cz_unpaired_loss_prob, idle_p_loss_time
+        )
+
+        errors = {(idle_px, idle_py, idle_pz, idle_p_loss): rest}
+
+        # error during the move
+        move_px_time = self.poisson_pauli_prob(self.params.move_px_rate, move_duration)
+        move_py_time = self.poisson_pauli_prob(self.params.move_py_rate, move_duration)
+        move_pz_time = self.poisson_pauli_prob(self.params.move_pz_rate, move_duration)
+        move_p_loss_time = self.poisson_pauli_prob(
+            self.params.move_loss_rate, move_duration
+        )
+        # error coming from picking up the qubits
+        px_moved = self.join_binary_probs(self.params.pick_px, move_px_time)
+        py_moved = self.join_binary_probs(self.params.pick_py, move_py_time)
+        pz_moved = self.join_binary_probs(self.params.pick_pz, move_pz_time)
+        p_loss_moved = self.join_binary_probs(
+            self.params.pick_loss_prob, move_p_loss_time
+        )
+
+        errors[(px_moved, py_moved, pz_moved, p_loss_moved)] = sorted(ctrls + qargs)
+
+        return errors

bloqade/noise/native/rewrite.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass
+
+from kirin import ir
+from kirin.rewrite import abc, dce, walk, result, fixpoint
+from kirin.passes.abc import Pass
+
+from .stmts import PauliChannel, CZPauliChannel, AtomLossChannel
+from ._dialect import dialect
+
+
+class RemoveNoiseRewrite(abc.RewriteRule):
+    def rewrite_Statement(self, node: ir.Statement) -> result.RewriteResult:
+        if isinstance(node, (AtomLossChannel, PauliChannel, CZPauliChannel)):
+            node.delete()
+            return result.RewriteResult(has_done_something=True)
+
+        return result.RewriteResult()
+
+
+@dataclass
+class RemoveNoisePass(Pass):
+    name = "remove-noise"
+
+    def unsafe_run(self, mt: ir.Method) -> result.RewriteResult:
+        delete_walk = walk.Walk(RemoveNoiseRewrite())
+        dce_walk = fixpoint.Fixpoint(walk.Walk(dce.DeadCodeElimination()))
+
+        result = delete_walk.rewrite(mt.code)
+
+        mt.dialects = ir.DialectGroup(mt.dialects.data.symmetric_difference([dialect]))
+
+        if result.has_done_something:
+            result = dce_walk.rewrite(mt.code)
+
+        return result

bloqade/noise/native/stmts.py

@@ -0,0 +1,46 @@
+from kirin import ir, types, lowering
+from kirin.decl import info, statement
+from kirin.dialects import ilist
+
+from bloqade.qasm2.types import QubitType
+
+from ._dialect import dialect
+
+
+@statement(dialect=dialect)
+class PauliChannel(ir.Statement):
+
+    traits = frozenset({lowering.FromPythonCall()})
+
+    px: float = info.attribute(types.Float)
+    py: float = info.attribute(types.Float)
+    pz: float = info.attribute(types.Float)
+    qargs: ir.SSAValue = info.argument(ilist.IListType[QubitType])
+
+
+NumQubits = types.TypeVar("NumQubits")
+
+
+@statement(dialect=dialect)
+class CZPauliChannel(ir.Statement):
+
+    traits = frozenset({lowering.FromPythonCall()})
+
+    paired: bool = info.attribute(types.Bool)
+    px_ctrl: float = info.attribute(types.Float)
+    py_ctrl: float = info.attribute(types.Float)
+    pz_ctrl: float = info.attribute(types.Float)
+    px_qarg: float = info.attribute(types.Float)
+    py_qarg: float = info.attribute(types.Float)
+    pz_qarg: float = info.attribute(types.Float)
+    ctrls: ir.SSAValue = info.argument(ilist.IListType[QubitType, NumQubits])
+    qargs: ir.SSAValue = info.argument(ilist.IListType[QubitType, NumQubits])
+
+
+@statement(dialect=dialect)
+class AtomLossChannel(ir.Statement):
+
+    traits = frozenset({lowering.FromPythonCall()})
+
+    prob: float = info.attribute(types.Float)
+    qargs: ir.SSAValue = info.argument(ilist.IListType[QubitType])

bloqade/pyqrack/__init__.py

@@ -0,0 +1,18 @@
+from .reg import (
+    CBitRef as CBitRef,
+    CRegister as CRegister,
+    PyQrackReg as PyQrackReg,
+    QubitState as QubitState,
+    Measurement as Measurement,
+    PyQrackQubit as PyQrackQubit,
+)
+from .base import (
+    StackMemory as StackMemory,
+    DynamicMemory as DynamicMemory,
+    PyQrackInterpreter as PyQrackInterpreter,
+)
+
+# 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, parallel as parallel
+from .target import PyQrack as PyQrack

bloqade/pyqrack/base.py

@@ -0,0 +1,131 @@
+import abc
+import typing
+from dataclasses import field, dataclass
+from unittest.mock import Mock
+
+import numpy as np
+from kirin.interp import Interpreter
+from typing_extensions import Self
+from kirin.interp.exceptions import InterpreterError
+
+from bloqade.pyqrack.reg import Measurement
+
+if typing.TYPE_CHECKING:
+    from pyqrack import QrackSimulator
+
+
+class PyQrackOptions(typing.TypedDict):
+    qubitCount: int
+    isTensorNetwork: bool
+    isSchmidtDecomposeMulti: bool
+    isSchmidtDecompose: bool
+    isStabilizerHybrid: bool
+    isBinaryDecisionTree: bool
+    isPaged: bool
+    isCpuGpuHybrid: bool
+    isOpenCL: bool
+
+
+def _default_pyqrack_args() -> PyQrackOptions:
+    return PyQrackOptions(
+        qubitCount=-1,
+        isTensorNetwork=False,
+        isSchmidtDecomposeMulti=True,
+        isSchmidtDecompose=True,
+        isStabilizerHybrid=True,
+        isBinaryDecisionTree=True,
+        isPaged=True,
+        isCpuGpuHybrid=True,
+        isOpenCL=True,
+    )
+
+
+@dataclass
+class MemoryABC(abc.ABC):
+    pyqrack_options: PyQrackOptions = field(default_factory=_default_pyqrack_args)
+    sim_reg: "QrackSimulator" = field(init=False)
+
+    @abc.abstractmethod
+    def allocate(self, n_qubits: int) -> tuple[int, ...]:
+        """Allocate `n_qubits` qubits and return their ids."""
+        ...
+
+    def reset(self):
+        """Reset the memory, releasing all qubits."""
+        from pyqrack import QrackSimulator
+
+        # do not reset the simulator it might be used by
+        # results of the simulation
+        self.sim_reg = QrackSimulator(**self.pyqrack_options)
+
+
+@dataclass
+class MockMemory(MemoryABC):
+    """Mock memory for testing purposes."""
+
+    allocated: int = field(init=False, default=0)
+
+    def allocate(self, n_qubits: int):
+        allocated = self.allocated + n_qubits
+        result = tuple(range(self.allocated, allocated))
+        self.allocated = allocated
+        return result
+
+    def reset(self):
+        self.allocated = 0
+        self.sim_reg = Mock()
+
+
+@dataclass
+class StackMemory(MemoryABC):
+    total: int = field(kw_only=True)
+    allocated: int = field(init=False, default=0)
+
+    def allocate(self, n_qubits: int):
+        curr_allocated = self.allocated
+        self.allocated += n_qubits
+
+        if self.allocated > self.total:
+            raise InterpreterError(
+                f"qubit allocation exceeds memory, "
+                f"{self.total} qubits, "
+                f"{self.allocated} allocated"
+            )
+
+        return tuple(range(curr_allocated, self.allocated))
+
+    def reset(self):
+        super().reset()
+        self.allocated = 0
+
+
+@dataclass
+class DynamicMemory(MemoryABC):
+    def __post_init__(self):
+        self.reset()
+
+        if self.sim_reg.is_tensor_network:
+            raise ValueError("DynamicMemory does not support tensor networks")
+
+    def allocate(self, n_qubits: int):
+        start = self.sim_reg.num_qubits()
+        for i in range(start, start + n_qubits):
+            self.sim_reg.allocate_qubit(i)
+
+        return tuple(range(start, start + n_qubits))
+
+
+@dataclass
+class PyQrackInterpreter(Interpreter):
+    keys = ["pyqrack", "main"]
+    memory: MemoryABC = field(kw_only=True)
+    rng_state: np.random.Generator = field(
+        default_factory=np.random.default_rng, kw_only=True
+    )
+    loss_m_result: Measurement = field(default=Measurement.One, kw_only=True)
+    """The value of a measurement result when a qubit is lost."""
+
+    def initialize(self) -> Self:
+        super().initialize()
+        self.memory.reset()  # reset allocated qubits
+        return self

bloqade/pyqrack/noise/native.py

@@ -0,0 +1,100 @@
+from typing import List
+
+from kirin import interp
+
+from bloqade.noise import native
+from bloqade.pyqrack import PyQrackInterpreter, reg
+
+
+@native.dialect.register(key="pyqrack")
+class PyQrackMethods(interp.MethodTable):
+    def apply_pauli_error(
+        self,
+        interp: PyQrackInterpreter,
+        qarg: reg.PyQrackQubit,
+        px: float,
+        py: float,
+        pz: float,
+    ):
+        p = [1 - (px + py + pz), px, py, pz]
+
+        assert all(0 <= x <= 1 for x in p), "Invalid Pauli error probabilities"
+
+        which = interp.rng_state.choice(["i", "x", "y", "z"], p=p)
+
+        if which == "i":
+            return
+
+        getattr(qarg.sim_reg, which)(qarg.addr)
+
+    @interp.impl(native.PauliChannel)
+    def single_qubit_error_channel(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: native.PauliChannel,
+    ):
+        qargs: List[reg.PyQrackQubit] = frame.get(stmt.qargs)
+
+        active_qubits = (qarg for qarg in qargs if qarg.is_active())
+
+        for qarg in active_qubits:
+            self.apply_pauli_error(interp, qarg, stmt.px, stmt.py, stmt.pz)
+
+        return ()
+
+    @interp.impl(native.CZPauliChannel)
+    def cz_pauli_channel(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: native.CZPauliChannel,
+    ):
+
+        qargs: List[reg.PyQrackQubit] = frame.get(stmt.qargs)
+        ctrls: List[reg.PyQrackQubit] = frame.get(stmt.ctrls)
+
+        if stmt.paired:
+            valid_pairs = (
+                (ctrl, qarg)
+                for ctrl, qarg in zip(ctrls, qargs)
+                if ctrl.is_active() and qarg.is_active()
+            )
+        else:
+            valid_pairs = (
+                (ctrl, qarg)
+                for ctrl, qarg in zip(ctrls, qargs)
+                if ctrl.is_active() ^ qarg.is_active()
+            )
+
+        for ctrl, qarg in valid_pairs:
+            if ctrl.is_active():
+                self.apply_pauli_error(
+                    interp, ctrl, stmt.px_ctrl, stmt.py_ctrl, stmt.pz_ctrl
+                )
+
+            if qarg.is_active():
+                self.apply_pauli_error(
+                    interp, qarg, stmt.px_qarg, stmt.py_qarg, stmt.pz_qarg
+                )
+
+        return ()
+
+    @interp.impl(native.AtomLossChannel)
+    def atom_loss_channel(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: native.AtomLossChannel,
+    ):
+        qargs: List[reg.PyQrackQubit] = frame.get(stmt.qargs)
+
+        active_qubits = (qarg for qarg in qargs if qarg.is_active())
+
+        for qarg in active_qubits:
+            if interp.rng_state.uniform() <= stmt.prob:
+                sim_reg = qarg.ref.sim_reg
+                sim_reg.force_m(qarg.addr, 0)
+                qarg.drop()
+
+        return ()