bloqade-circuit 0.7.13__py3-none-any.whl → 0.8.0__py3-none-any.whl

bloqade/pyqrack/squin/noise/native.py

@@ -1,72 +1,138 @@
-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.pyqrack import PyQrackQubit, PyQrackInterpreter
+from bloqade.squin.noise.stmts import (
+    QubitLoss,
+    Depolarize,
+    Depolarize2,
+    CorrelatedQubitLoss,
+    TwoQubitPauliChannel,
+    SingleQubitPauliChannel,
+)
 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
+@squin_noise_dialect.register(key="pyqrack")
+class PyQrackMethods(interp.MethodTable):
 
-    def apply(self, qubit: PyQrackQubit, adjoint: bool = False) -> None:
-        if random.uniform(0.0, 1.0) <= self.p:
-            qubit.state = QubitState.Lost
+    single_pauli_choices = ("i", "x", "y", "z")
+    two_pauli_choices = (
+        "ii",
+        "ix",
+        "iy",
+        "iz",
+        "xi",
+        "xx",
+        "xy",
+        "xz",
+        "yi",
+        "yx",
+        "yy",
+        "yz",
+        "zi",
+        "zx",
+        "zy",
+        "zz",
+    )
+
+    @interp.impl(Depolarize)
+    def depolarize(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: Depolarize
+    ):
+        p = frame.get(stmt.p)
+        ps = [p / 3.0] * 3
+        qubits = frame.get(stmt.qubits)
+        self.apply_single_qubit_pauli_error(interp, ps, qubits)
 
+    @interp.impl(Depolarize2)
+    def depolarize2(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: Depolarize2
+    ):
+        p = frame.get(stmt.p)
+        ps = [p / 15.0] * 15
+        controls = frame.get(stmt.controls)
+        targets = frame.get(stmt.targets)
+        self.apply_two_qubit_pauli_error(interp, ps, controls, targets)
 
-@squin_noise_dialect.register(key="pyqrack")
-class PyQrackMethods(interp.MethodTable):
-    @interp.impl(StochasticUnitaryChannel)
-    def stochastic_unitary_channel(
+    @interp.impl(SingleQubitPauliChannel)
+    def single_qubit_pauli_channel(
         self,
         interp: PyQrackInterpreter,
         frame: interp.Frame,
-        stmt: StochasticUnitaryChannel,
+        stmt: SingleQubitPauliChannel,
     ):
-        operators = frame.get(stmt.operators)
-        probabilities = frame.get(stmt.probabilities)
-
-        return (StochasticUnitaryChannelRuntime(operators, probabilities),)
+        px = frame.get(stmt.px)
+        py = frame.get(stmt.py)
+        pz = frame.get(stmt.pz)
+        qubits = frame.get(stmt.qubits)
+        self.apply_single_qubit_pauli_error(interp, [px, py, pz], qubits)
+
+    @interp.impl(TwoQubitPauliChannel)
+    def two_qubit_pauli_channel(
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: TwoQubitPauliChannel,
+    ):
+        ps = frame.get(stmt.probabilities)
+        controls = frame.get(stmt.controls)
+        targets = frame.get(stmt.targets)
+        self.apply_two_qubit_pauli_error(interp, ps, controls, targets)
 
     @interp.impl(QubitLoss)
     def qubit_loss(
         self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: QubitLoss
     ):
         p = frame.get(stmt.p)
-        return (QubitLossRuntime(p),)
+        qubits: list[PyQrackQubit] = frame.get(stmt.qubits)
+        for qbit in qubits:
+            if interp.rng_state.uniform(0.0, 1.0) <= p:
+                qbit.drop()
+
+    @interp.impl(CorrelatedQubitLoss)
+    def correlated_qubit_loss(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: CorrelatedQubitLoss
+    ):
+        p = frame.get(stmt.p)
+        qubits: list[list[PyQrackQubit]] = frame.get(stmt.qubits)
+        for qubit_group in qubits:
+            if interp.rng_state.uniform(0.0, 1.0) <= p:
+                for qbit in qubit_group:
+                    qbit.drop()
+
+    def apply_single_qubit_pauli_error(
+        self,
+        interp: PyQrackInterpreter,
+        ps: list[float],
+        qubits: list[PyQrackQubit],
+    ):
+        pi = 1 - sum(ps)
+        probs = [pi] + ps
+
+        assert all(0 <= x <= 1 for x in probs), "Invalid Pauli error probabilities"
+
+        for qbit in qubits:
+            which = interp.rng_state.choice(self.single_pauli_choices, p=probs)
+            self.apply_pauli_error(which, qbit)
+
+    def apply_two_qubit_pauli_error(
+        self,
+        interp: PyQrackInterpreter,
+        ps: list[float],
+        controls: list[PyQrackQubit],
+        targets: list[PyQrackQubit],
+    ):
+        pii = 1 - sum(ps)
+        probs = [pii] + ps
+        assert all(0 <= x <= 1 for x in probs), "Invalid Pauli error probabilities"
+
+        for control, target in zip(controls, targets):
+            which = interp.rng_state.choice(self.two_pauli_choices, p=probs)
+            self.apply_pauli_error(which[0], control)
+            self.apply_pauli_error(which[1], target)
+
+    def apply_pauli_error(self, which: str, qbit: PyQrackQubit):
+        if not qbit.is_active() or which == "i":
+            return
+
+        getattr(qbit.sim_reg, which)(qbit.addr)

bloqade/pyqrack/squin/qubit.py

@@ -3,41 +3,20 @@ from typing import Any
 from kirin import interp
 from kirin.dialects import ilist
 
-from bloqade.squin import qubit
+from bloqade.qubit import stmts as qubit
 from bloqade.pyqrack.reg import QubitState, Measurement, PyQrackQubit
 from bloqade.pyqrack.base import PyQrackInterpreter
 
-from .runtime import OperatorRuntimeABC
-
 
 @qubit.dialect.register(key="pyqrack")
 class PyQrackMethods(interp.MethodTable):
     @interp.impl(qubit.New)
-    def new(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.New):
-        n_qubits: int = frame.get(stmt.n_qubits)
-        qreg = ilist.IList(
-            [
-                PyQrackQubit(i, interp.memory.sim_reg, QubitState.Active)
-                for i in interp.memory.allocate(n_qubits=n_qubits)
-            ]
-        )
-        return (qreg,)
-
-    @interp.impl(qubit.Apply)
-    def apply(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.Apply):
-        qubits: list[PyQrackQubit] = [frame.get(qbit) for qbit in stmt.qubits]
-        operator: OperatorRuntimeABC = frame.get(stmt.operator)
-        operator.apply(*qubits)
-
-    @interp.impl(qubit.Broadcast)
-    def broadcast(
-        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.Broadcast
+    def new_qubit(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.New
     ):
-        operator: OperatorRuntimeABC = frame.get(stmt.operator)
-        qubits: list[ilist.IList[PyQrackQubit, Any]] = [
-            frame.get(qbit) for qbit in stmt.qubits
-        ]
-        operator.broadcast_apply(qubits)
+        (addr,) = interp.memory.allocate(1)
+        qb = PyQrackQubit(addr, interp.memory.sim_reg, QubitState.Active)
+        return (qb,)
 
     def _measure_qubit(self, qbit: PyQrackQubit, interp: PyQrackInterpreter):
         if qbit.is_active():
@@ -48,35 +27,40 @@ class PyQrackMethods(interp.MethodTable):
         interp.set_global_measurement_id(m)
         return m
 
-    @interp.impl(qubit.MeasureQubitList)
+    @interp.impl(qubit.Measure)
     def measure_qubit_list(
         self,
         interp: PyQrackInterpreter,
         frame: interp.Frame,
-        stmt: qubit.MeasureQubitList,
+        stmt: qubit.Measure,
     ):
         qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
         result = ilist.IList([self._measure_qubit(qbit, interp) for qbit in qubits])
         return (result,)
 
-    @interp.impl(qubit.MeasureQubit)
-    def measure_qubit(
-        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.MeasureQubit
-    ):
-        qbit: PyQrackQubit = frame.get(stmt.qubit)
-        result = self._measure_qubit(qbit, interp)
-        return (result,)
-
     @interp.impl(qubit.QubitId)
     def qubit_id(
         self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.QubitId
     ):
-        qbit: PyQrackQubit = frame.get(stmt.qubit)
-        return (qbit.addr,)
+        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
+        ids = ilist.IList([qbit.addr for qbit in qubits])
+        return (ids,)
 
     @interp.impl(qubit.MeasurementId)
     def measurement_id(
         self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.MeasurementId
     ):
-        measurement: Measurement = frame.get(stmt.measurement)
-        return (measurement.measurement_id,)
+        measurements: ilist.IList[Measurement, Any] = frame.get(stmt.measurements)
+        ids = ilist.IList([measurement.measurement_id for measurement in measurements])
+        return (ids,)
+
+    @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
+
+            m = qbit.sim_reg.m(qbit.addr)
+            if m == Measurement.One:
+                qbit.sim_reg.x(qbit.addr)

bloqade/pyqrack/target.py

@@ -12,7 +12,7 @@ from bloqade.pyqrack.base import (
     PyQrackInterpreter,
     _default_pyqrack_args,
 )
-from bloqade.analysis.address import AnyAddress, AddressAnalysis
+from bloqade.analysis.address import UnknownQubit, AddressAnalysis
 
 Params = ParamSpec("Params")
 RetType = TypeVar("RetType")
@@ -53,7 +53,7 @@ class PyQrack:
             address_analysis = AddressAnalysis(mt.dialects)
             frame, _ = address_analysis.run_analysis(mt)
             if self.min_qubits == 0 and any(
-                isinstance(a, AnyAddress) for a in frame.entries.values()
+                isinstance(a, UnknownQubit) for a in frame.entries.values()
             ):
                 raise ValueError(
                     "All addresses must be resolved. Or set min_qubits to a positive integer."

bloqade/qasm2/dialects/core/address.py

@@ -1,12 +1,14 @@
 from kirin import interp
+from kirin.analysis import const
 
 from bloqade.analysis.address import (
     Address,
-    NotQubit,
     AddressReg,
-    AddressQubit,
+    ConstResult,
+    UnknownQubit,
     AddressAnalysis,
 )
+from bloqade.analysis.address.lattice import UnknownReg
 
 from .stmts import QRegGet, QRegNew
 from ._dialect import dialect
@@ -22,17 +24,24 @@ class AddressMethodTable(interp.MethodTable):
         frame: interp.Frame[Address],
         stmt: QRegNew,
     ):
-        n_qubits = interp.get_const_value(int, stmt.n_qubits)
-        addr = AddressReg(range(interp.next_address, interp.next_address + n_qubits))
-        interp.next_address += n_qubits
-        return (addr,)
+        n_qubits = frame.get(stmt.n_qubits)
+        match n_qubits:
+            case ConstResult(const.Value(int() as n)):
+                addr = AddressReg(range(interp.next_address, interp.next_address + n))
+                interp.next_address += n
+                return (addr,)
+            case _:
+                return (UnknownReg(),)
 
     @interp.impl(QRegGet)
     def get(self, interp: AddressAnalysis, frame: interp.Frame[Address], stmt: QRegGet):
         addr = frame.get(stmt.reg)
-        pos = interp.get_const_value(int, stmt.idx)
-        if isinstance(addr, AddressReg):
-            global_idx = addr.data[pos]
-            return (AddressQubit(global_idx),)
-        else:  # this is not reachable
-            return (NotQubit(),)
+        idx = frame.get(stmt.idx)
+
+        typ, values = interp.unpack_iterable(addr)
+        idx_value = interp.get_const_value(idx, int)
+
+        if typ is not None and idx_value is not None:
+            return (values[idx_value],)
+
+        return (UnknownQubit(),)

bloqade/qasm2/dialects/noise/fidelity.py

@@ -1,7 +1,6 @@
 from kirin import interp
 from kirin.lattice import EmptyLattice
 
-from bloqade.analysis.address import AddressQubit, AddressTuple
 from bloqade.analysis.fidelity import FidelityAnalysis
 
 from .stmts import PauliChannel, CZPauliChannel, AtomLossChannel
@@ -42,10 +41,7 @@ class FidelityMethodTable(interp.MethodTable):
         stmt: AtomLossChannel,
     ):
         # NOTE: since AtomLossChannel acts on IList[Qubit], we know the assigned address is a tuple
-        addresses: AddressTuple = interp.addr_frame.get(stmt.qargs)
-
+        addresses = interp.addr_frame.get(stmt.qargs)
         # NOTE: get the corresponding index and reduce survival probability accordingly
-        for qbit_address in addresses.data:
-            assert isinstance(qbit_address, AddressQubit)
-            index = qbit_address.data
+        for index in addresses.data:
             interp._current_atom_survival_probability[index] *= 1 - stmt.prob

bloqade/qasm2/dialects/noise/model.py

@@ -1,4 +1,5 @@
 import abc
+from typing import Sequence
 from dataclasses import field, dataclass
 
 
@@ -161,7 +162,7 @@ class MoveNoiseModelABC(abc.ABC):
 
     @abc.abstractmethod
     def parallel_cz_errors(
-        self, ctrls: list[int], qargs: list[int], rest: list[int]
+        self, ctrls: Sequence[int], qargs: Sequence[int], rest: Sequence[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

bloqade/qasm2/passes/parallel.py

@@ -28,7 +28,6 @@ from bloqade.qasm2.rewrite import (
     UOpToParallelRule,
     ParallelToGlobalRule,
     SimpleOptimalMergePolicy,
-    RydbergGateSetRewriteRule,
 )
 from bloqade.squin.analysis import schedule
 
@@ -151,6 +150,9 @@ class UOpToParallel(Pass):
             return result
 
         if self.rewrite_to_native_first:
+            # NOTE: this import also imports cirq, so we do it locally here
+            from bloqade.qasm2.rewrite.native_gates import RydbergGateSetRewriteRule
+
             result = (
                 Fixpoint(Walk(RydbergGateSetRewriteRule(self.dialects)))
                 .rewrite(mt.code)

bloqade/qasm2/rewrite/__init__.py

@@ -3,7 +3,6 @@ from .glob import (
     GlobalToParallelRule as GlobalToParallelRule,
 )
 from .register import RaiseRegisterRule as RaiseRegisterRule
-from .native_gates import RydbergGateSetRewriteRule as RydbergGateSetRewriteRule
 from .parallel_to_uop import ParallelToUOpRule as ParallelToUOpRule
 from .uop_to_parallel import (
     MergePolicyABC as MergePolicyABC,

bloqade/qasm2/rewrite/noise/heuristic_noise.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Tuple, cast
+from typing import Dict, List, Tuple
 from dataclasses import field, dataclass
 
 from kirin import ir
@@ -55,7 +55,7 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
 
     def rewrite_global_single_qubit_gate(self, node: glob.UGate):
         addrs = self.address_analysis[node.registers]
-        if not isinstance(addrs, address.AddressTuple):
+        if not isinstance(addrs, address.PartialIList):
             return rewrite_abc.RewriteResult()
 
         qargs = []
@@ -74,10 +74,7 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
 
     def rewrite_parallel_single_qubit_gate(self, node: parallel.RZ | parallel.UGate):
         addrs = self.address_analysis[node.qargs]
-        if not isinstance(addrs, address.AddressTuple):
-            return rewrite_abc.RewriteResult()
-
-        if not all(isinstance(addr, address.AddressQubit) for addr in addrs.data):
+        if not isinstance(addrs, address.AddressReg):
             return rewrite_abc.RewriteResult()
 
         assert isinstance(node.qargs, ir.ResultValue)
@@ -178,18 +175,11 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
         qargs = self.address_analysis[node.qargs]
 
         has_done_something = False
-        if (
-            isinstance(ctrls, address.AddressTuple)
-            and all(isinstance(addr, address.AddressQubit) for addr in ctrls.data)
-            and isinstance(qargs, address.AddressTuple)
-            and all(isinstance(addr, address.AddressQubit) for addr in qargs.data)
+        if isinstance(ctrls, address.AddressReg) and isinstance(
+            qargs, address.AddressReg
         ):
-            ctrl_qubits = list(
-                map(lambda addr: cast(address.AddressQubit, addr).data, ctrls.data)
-            )
-            qarg_qubits = list(
-                map(lambda addr: cast(address.AddressQubit, addr).data, qargs.data)
-            )
+            ctrl_qubits = tuple(ctrls.data)
+            qarg_qubits = tuple(qargs.data)
             rest = sorted(
                 set(self.qubit_ssa_value.keys()) - set(ctrl_qubits + qarg_qubits)
             )

bloqade/qasm2/rewrite/parallel_to_glob.py

@@ -3,7 +3,6 @@ from dataclasses import dataclass
 
 from kirin import ir
 from kirin.rewrite import abc
-from kirin.analysis import const
 from kirin.dialects import ilist
 
 from bloqade.analysis import address
@@ -20,28 +19,24 @@ class ParallelToGlobalRule(abc.RewriteRule):
             return abc.RewriteResult()
 
         qargs = node.qargs
-        qarg_addresses = self.address_analysis.get(qargs, None)
+        qargs_address = self.address_analysis.get(qargs, address.Unknown())
 
-        if isinstance(qarg_addresses, address.AddressReg):
-            # NOTE: we only have an AddressReg if it's an entire register, definitely rewrite that
-            return self._rewrite_parallel_to_glob(node)
-
-        if not isinstance(qarg_addresses, address.AddressTuple):
+        if not isinstance(qargs_address, address.AddressReg):
             return abc.RewriteResult()
 
-        idxs, qreg = self._find_qreg(qargs.owner, set())
+        qregs = self._get_all_qreg(qargs.owner)
 
-        if qreg is None:
-            # NOTE: no unique register found
+        if len(qregs) != 1:
             return abc.RewriteResult()
 
-        if not isinstance(hint := qreg.n_qubits.hints.get("const"), const.Value):
-            # NOTE: non-constant number of qubits
+        qreg = next(iter(qregs))
+
+        qreg_address = self.address_analysis.get(qreg, address.Unknown())
+
+        if not isinstance(qreg_address, address.AddressReg):
             return abc.RewriteResult()
 
-        n = hint.data
-        if len(idxs) != n:
-            # NOTE: not all qubits of the register are there
+        if set(qargs_address.data) != set(qreg_address.data):
             return abc.RewriteResult()
 
         return self._rewrite_parallel_to_glob(node)
@@ -53,6 +48,24 @@ class ParallelToGlobalRule(abc.RewriteRule):
         node.replace_by(global_u)
         return abc.RewriteResult(has_done_something=True)
 
+    @staticmethod
+    def _get_all_qreg(owner: ir.Statement | ir.Block):
+        stack = [owner]
+        qregs: set[ir.SSAValue] = set()
+        while stack:
+            current = stack.pop()
+
+            if isinstance(current, core.stmts.QRegGet):
+                stack.append(current.reg.owner)
+            elif isinstance(current, ilist.New):
+                for val in current.values:
+                    stack.append(val.owner)
+
+            elif isinstance(current, core.QRegNew):
+                qregs.add(current.result)
+
+        return qregs
+
     @staticmethod
     def _find_qreg(
         qargs_owner: ir.Statement | ir.Block, idxs: set

bloqade/qasm2/rewrite/parallel_to_uop.py

@@ -21,16 +21,10 @@ class ParallelToUOpRule(abc.RewriteRule):
 
     def get_qubit_ssa(self, ilist_ref: ir.SSAValue) -> Optional[List[ir.SSAValue]]:
         addr = self.address_analysis.get(ilist_ref)
-        if not isinstance(addr, address.AddressTuple):
+        if not isinstance(addr, address.AddressReg):
             return None
 
-        ids = []
-        for ele in addr.data:
-            if not isinstance(ele, address.AddressQubit):
-                return None
-
-            ids.append(ele.data)
-
+        ids = addr.data
         return [self.id_map[ele] for ele in ids]
 
     def rewrite_cz(self, node: ir.Statement):

bloqade/qubit/__init__.py

@@ -0,0 +1,12 @@
+from bloqade.types import Qubit as Qubit, QubitType as QubitType
+
+from . import stmts as stmts, analysis as analysis
+from .stdlib import new as new, qalloc as qalloc, broadcast as broadcast
+from ._dialect import dialect as dialect
+from ._prelude import kernel as kernel
+from .stdlib.simple import (
+    reset as reset,
+    measure as measure,
+    get_qubit_id as get_qubit_id,
+    get_measurement_id as get_measurement_id,
+)

bloqade/qubit/_dialect.py

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

bloqade/qubit/_interface.py

@@ -0,0 +1,49 @@
+from typing import Any, TypeVar
+
+from kirin.dialects import ilist
+from kirin.lowering import wraps
+
+from bloqade.types import Qubit, MeasurementResult
+
+from .stmts import New, Reset, Measure, QubitId, MeasurementId
+
+
+@wraps(New)
+def new() -> Qubit:
+    """Create a new qubit.
+
+    Returns:
+        Qubit: A new qubit.
+    """
+    ...
+
+
+N = TypeVar("N", bound=int)
+
+
+@wraps(Measure)
+def measure(qubits: ilist.IList[Qubit, N]) -> ilist.IList[MeasurementResult, N]:
+    """Measure a list of qubits.
+
+    Args:
+        qubits (IList[Qubit, N]): The list of qubits to measure.
+
+    Returns:
+        IList[MeasurementResult, N]: The list containing the results of the measurements.
+            A MeasurementResult can represent both 0 and 1, but also atoms that are lost.
+    """
+    ...
+
+
+@wraps(QubitId)
+def get_qubit_id(qubits: ilist.IList[Qubit, N]) -> ilist.IList[int, N]: ...
+
+
+@wraps(MeasurementId)
+def get_measurement_id(
+    measurements: ilist.IList[MeasurementResult, N],
+) -> ilist.IList[int, N]: ...
+
+
+@wraps(Reset)
+def reset(qubits: ilist.IList[Qubit, Any]) -> None: ...