bloqade-circuit 0.6.4__py3-none-any.whl → 0.9.1__py3-none-any.whl

bloqade/stim/rewrite/set_observable_to_stim.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+
+from kirin import ir
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from bloqade.stim.dialects import auxiliary
+from bloqade.annotate.stmts import SetObservable
+from bloqade.analysis.measure_id import MeasureIDFrame
+from bloqade.stim.dialects.auxiliary import ObservableInclude
+from bloqade.analysis.measure_id.lattice import MeasureIdTuple
+
+from ..rewrite.get_record_util import insert_get_records
+
+
+@dataclass
+class SetObservableToStim(RewriteRule):
+    """
+    Rewrite SetObservable to GetRecord and ObservableInclude in the stim dialect
+    """
+
+    measure_id_frame: MeasureIDFrame
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+        match node:
+            case SetObservable():
+                return self.rewrite_SetObservable(node)
+            case _:
+                return RewriteResult()
+
+    def rewrite_SetObservable(self, node: SetObservable) -> RewriteResult:
+
+        # set idx to 0 for now, but this
+        # should be something that a user can set on their own.
+        # SetObservable needs to accept an int.
+
+        idx_stmt = auxiliary.ConstInt(value=0)
+        idx_stmt.insert_before(node)
+
+        measure_ids = self.measure_id_frame.entries[node.measurements]
+        assert isinstance(measure_ids, MeasureIdTuple)
+
+        get_record_list = insert_get_records(
+            node, measure_ids, self.measure_id_frame.num_measures_at_stmt[node]
+        )
+
+        observable_include_stmt = ObservableInclude(
+            idx=idx_stmt.result, targets=tuple(get_record_list)
+        )
+
+        node.replace_by(observable_include_stmt)
+
+        return RewriteResult(has_done_something=True)

bloqade/stim/rewrite/squin_measure.py

@@ -5,11 +5,10 @@ from kirin import ir
 from kirin.dialects import py
 from kirin.rewrite.abc import RewriteRule, RewriteResult
 
-from bloqade.squin import wire, qubit
+from bloqade import qubit
 from bloqade.squin.rewrite import AddressAttribute
 from bloqade.stim.dialects import collapse
 from bloqade.stim.rewrite.util import (
-    is_measure_result_used,
     insert_qubit_idx_from_address,
 )
 
@@ -23,14 +22,12 @@ class SquinMeasureToStim(RewriteRule):
     def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
 
         match node:
-            case qubit.MeasureQubit() | qubit.MeasureQubitList() | wire.Measure():
+            case qubit.stmts.Measure():
                 return self.rewrite_Measure(node)
             case _:
                 return RewriteResult()
 
-    def rewrite_Measure(
-        self, measure_stmt: qubit.MeasureQubit | qubit.MeasureQubitList | wire.Measure
-    ) -> RewriteResult:
+    def rewrite_Measure(self, measure_stmt: qubit.stmts.Measure) -> RewriteResult:
 
         qubit_idx_ssas = self.get_qubit_idx_ssas(measure_stmt)
         if qubit_idx_ssas is None:
@@ -44,27 +41,21 @@ class SquinMeasureToStim(RewriteRule):
         prob_noise_stmt.insert_before(measure_stmt)
         stim_measure_stmt.insert_before(measure_stmt)
 
-        if not is_measure_result_used(measure_stmt):
+        # if the measurement is not being used anywhere
+        # we can safely get rid of it. Measure cannot be DCE'd because
+        # it is not pure.
+        if not bool(measure_stmt.result.uses):
             measure_stmt.delete()
 
         return RewriteResult(has_done_something=True)
 
     def get_qubit_idx_ssas(
-        self, measure_stmt: qubit.MeasureQubit | qubit.MeasureQubitList | wire.Measure
+        self, measure_stmt: qubit.stmts.Measure
     ) -> tuple[ir.SSAValue, ...] | None:
         """
         Extract the address attribute and insert qubit indices for the given measure statement.
         """
-        match measure_stmt:
-            case qubit.MeasureQubit():
-                address_attr = measure_stmt.qubit.hints.get("address")
-            case qubit.MeasureQubitList():
-                address_attr = measure_stmt.qubits.hints.get("address")
-            case wire.Measure():
-                address_attr = measure_stmt.wire.hints.get("address")
-            case _:
-                return None
-
+        address_attr = measure_stmt.qubits.hints.get("address")
         if address_attr is None:
             return None
 

bloqade/stim/rewrite/squin_noise.py

@@ -1,17 +1,17 @@
+import itertools
 from typing import Tuple
 from dataclasses import dataclass
 
+from kirin import types
 from kirin.ir import SSAValue, Statement
-from kirin.dialects import py, ilist
+from kirin.dialects import py
 from kirin.rewrite.abc import RewriteRule, RewriteResult
 
-from bloqade.squin import op, wire, noise as squin_noise, qubit
+from bloqade.squin import noise as squin_noise
 from bloqade.stim.dialects import noise as stim_noise
-from bloqade.stim.rewrite.util import (
-    get_const_value,
-    create_wire_passthrough,
-    insert_qubit_idx_after_apply,
-)
+from bloqade.stim.rewrite.util import insert_qubit_idx_from_address
+from bloqade.analysis.address.lattice import AddressReg, PartialIList
+from bloqade.squin.rewrite.wrap_analysis import AddressAttribute
 
 
 @dataclass
@@ -19,157 +19,183 @@ class SquinNoiseToStim(RewriteRule):
 
     def rewrite_Statement(self, node: Statement) -> RewriteResult:
         match node:
-            case qubit.Apply() | qubit.Broadcast():
-                return self.rewrite_Apply_and_Broadcast(node)
+            case squin_noise.stmts.NoiseChannel():
+                return self.rewrite_NoiseChannel(node)
             case _:
                 return RewriteResult()
 
-    def rewrite_Apply_and_Broadcast(
-        self, stmt: qubit.Apply | qubit.Broadcast
+    def rewrite_NoiseChannel(
+        self, stmt: squin_noise.stmts.NoiseChannel
     ) -> RewriteResult:
-        """Rewrite Apply and Broadcast to their stim statements."""
+        """Rewrite NoiseChannel statements to their stim equivalents."""
 
-        # this is an SSAValue, need it to be the actual operator
-        applied_op = stmt.operator.owner
+        rewrite_method = getattr(self, f"rewrite_{type(stmt).__name__}", None)
 
-        if isinstance(applied_op, squin_noise.stmts.QubitLoss):
+        # No rewrite method exists and the rewrite should stop
+        if rewrite_method is None:
             return RewriteResult()
+        if isinstance(stmt, squin_noise.stmts.CorrelatedQubitLoss):
+            # CorrelatedQubitLoss represents a broadcast operation, but Stim does not
+            # support broadcasting for multi-qubit noise channels.
+            # Therefore, we must expand the broadcast into individual stim statements.
+            qubit_address_attr = stmt.qubits.hints.get("address", None)
 
-        if isinstance(applied_op, squin_noise.stmts.NoiseChannel):
+            if not isinstance(qubit_address_attr, AddressAttribute):
+                return RewriteResult()
+
+            if not isinstance(address := qubit_address_attr.address, PartialIList):
+                return RewriteResult()
 
-            qubit_idx_ssas = insert_qubit_idx_after_apply(stmt=stmt)
-            if qubit_idx_ssas is None:
+            if not types.is_tuple_of(data := address.data, AddressReg):
                 return RewriteResult()
 
-            rewrite_method = getattr(self, f"rewrite_{type(applied_op).__name__}")
-            stim_stmt = rewrite_method(stmt, qubit_idx_ssas)
+            for address_reg in data:
 
-            if isinstance(stmt, (wire.Apply, wire.Broadcast)):
-                create_wire_passthrough(stmt)
+                qubit_idx_ssas = insert_qubit_idx_from_address(
+                    AddressAttribute(address_reg), stmt
+                )
 
-            if stim_stmt is not None:
-                stmt.replace_by(stim_stmt)
-            if len(stmt.operator.owner.result.uses) == 0:
-                stmt.operator.owner.delete()
+                stim_stmt = rewrite_method(stmt, qubit_idx_ssas)
+                stim_stmt.insert_before(stmt)
+
+            stmt.delete()
 
             return RewriteResult(has_done_something=True)
-        return RewriteResult()
 
-    def rewrite_PauliError(
-        self,
-        stmt: qubit.Apply | qubit.Broadcast | wire.Broadcast | wire.Apply,
-        qubit_idx_ssas: Tuple[SSAValue],
-    ) -> Statement:
-        """Rewrite squin.noise.PauliError to XError, YError, ZError."""
-        squin_channel = stmt.operator.owner
-        assert isinstance(squin_channel, squin_noise.stmts.PauliError)
-        basis = squin_channel.basis.owner
-        assert isinstance(basis, op.stmts.PauliOp)
-        p = get_const_value(float, squin_channel.p)
-
-        p_stmt = py.Constant(p)
-        p_stmt.insert_before(stmt)
-
-        if isinstance(basis, op.stmts.X):
-            stim_stmt = stim_noise.XError(targets=qubit_idx_ssas, p=p_stmt.result)
-        elif isinstance(basis, op.stmts.Y):
-            stim_stmt = stim_noise.YError(targets=qubit_idx_ssas, p=p_stmt.result)
+        if isinstance(stmt, squin_noise.stmts.SingleQubitNoiseChannel):
+            qubit_address_attr = stmt.qubits.hints.get("address", None)
+            if qubit_address_attr is None:
+                return RewriteResult()
+            qubit_idx_ssas = insert_qubit_idx_from_address(qubit_address_attr, stmt)
+
+        elif isinstance(stmt, squin_noise.stmts.TwoQubitNoiseChannel):
+            control_address_attr = stmt.controls.hints.get("address", None)
+            target_address_attr = stmt.targets.hints.get("address", None)
+            if control_address_attr is None or target_address_attr is None:
+                return RewriteResult()
+            control_qubit_idx_ssas = insert_qubit_idx_from_address(
+                control_address_attr, stmt
+            )
+            target_qubit_idx_ssas = insert_qubit_idx_from_address(
+                target_address_attr, stmt
+            )
+            if control_qubit_idx_ssas is None or target_qubit_idx_ssas is None:
+                return RewriteResult()
+
+            # For stim statements you want to interleave the control and target qubit indices:
+            # ex: CX controls = (0,1) targets = (2,3) in stim is: CX 0 2 1 3
+            qubit_idx_ssas = list(
+                itertools.chain.from_iterable(
+                    zip(control_qubit_idx_ssas, target_qubit_idx_ssas)
+                )
+            )
         else:
-            stim_stmt = stim_noise.ZError(targets=qubit_idx_ssas, p=p_stmt.result)
-        return stim_stmt
+            return RewriteResult()
+
+        # guaranteed that you have a valid stim_stmt to plug in
+        stim_stmt = rewrite_method(stmt, tuple(qubit_idx_ssas))
+        stmt.replace_by(stim_stmt)
+
+        return RewriteResult(has_done_something=True)
 
     def rewrite_SingleQubitPauliChannel(
         self,
-        stmt: qubit.Apply | qubit.Broadcast | wire.Broadcast | wire.Apply,
+        stmt: squin_noise.stmts.SingleQubitPauliChannel,
         qubit_idx_ssas: Tuple[SSAValue],
     ) -> Statement:
         """Rewrite squin.noise.SingleQubitPauliChannel to stim.PauliChannel1."""
 
-        squin_channel = stmt.operator.owner
-        assert isinstance(squin_channel, squin_noise.stmts.SingleQubitPauliChannel)
-
-        params = get_const_value(ilist.IList, squin_channel.params)
-        new_stmts = [
-            p_x := py.Constant(params[0]),
-            p_y := py.Constant(params[1]),
-            p_z := py.Constant(params[2]),
-        ]
-        for new_stmt in new_stmts:
-            new_stmt.insert_before(stmt)
-
         stim_stmt = stim_noise.PauliChannel1(
             targets=qubit_idx_ssas,
-            px=p_x.result,
-            py=p_y.result,
-            pz=p_z.result,
+            px=stmt.px,
+            py=stmt.py,
+            pz=stmt.pz,
         )
         return stim_stmt
 
-    def rewrite_TwoQubitPauliChannel(
+    def rewrite_QubitLoss(
         self,
-        stmt: qubit.Apply | qubit.Broadcast | wire.Broadcast | wire.Apply,
+        stmt: squin_noise.stmts.QubitLoss,
         qubit_idx_ssas: Tuple[SSAValue],
     ) -> Statement:
-        """Rewrite squin.noise.SingleQubitPauliChannel to stim.PauliChannel1."""
+        """Rewrite squin.noise.QubitLoss to stim.TrivialError."""
 
-        squin_channel = stmt.operator.owner
-        assert isinstance(squin_channel, squin_noise.stmts.TwoQubitPauliChannel)
+        stim_stmt = stim_noise.QubitLoss(
+            targets=qubit_idx_ssas,
+            probs=(stmt.p,),
+        )
 
-        params = get_const_value(ilist.IList, squin_channel.params)
-        param_stmts = [py.Constant(p) for p in params]
-        for param_stmt in param_stmts:
-            param_stmt.insert_before(stmt)
+        return stim_stmt
 
-        stim_stmt = stim_noise.PauliChannel2(
+    def rewrite_CorrelatedQubitLoss(
+        self,
+        stmt: squin_noise.stmts.CorrelatedQubitLoss,
+        qubit_idx_ssas: Tuple[SSAValue],
+    ) -> Statement:
+        """Rewrite squin.noise.CorrelatedQubitLoss to stim.CorrelatedQubitLoss."""
+        stim_stmt = stim_noise.CorrelatedQubitLoss(
             targets=qubit_idx_ssas,
-            pix=param_stmts[0].result,
-            piy=param_stmts[1].result,
-            piz=param_stmts[2].result,
-            pxi=param_stmts[3].result,
-            pxx=param_stmts[4].result,
-            pxy=param_stmts[5].result,
-            pxz=param_stmts[6].result,
-            pyi=param_stmts[7].result,
-            pyx=param_stmts[8].result,
-            pyy=param_stmts[9].result,
-            pyz=param_stmts[10].result,
-            pzi=param_stmts[11].result,
-            pzx=param_stmts[12].result,
-            pzy=param_stmts[13].result,
-            pzz=param_stmts[14].result,
+            probs=(stmt.p,),
         )
+
         return stim_stmt
 
-    def rewrite_Depolarize2(
+    def rewrite_Depolarize(
         self,
-        stmt: qubit.Apply | qubit.Broadcast | wire.Broadcast | wire.Apply,
+        stmt: squin_noise.stmts.Depolarize,
         qubit_idx_ssas: Tuple[SSAValue],
     ) -> Statement:
-        """Rewrite squin.noise.Depolarize2 to stim.Depolarize2."""
-
-        squin_channel = stmt.operator.owner
-        assert isinstance(squin_channel, squin_noise.stmts.Depolarize2)
+        """Rewrite squin.noise.Depolarize to stim.Depolarize1."""
 
-        p = get_const_value(float, squin_channel.p)
-        p_stmt = py.Constant(p)
-        p_stmt.insert_before(stmt)
+        stim_stmt = stim_noise.Depolarize1(
+            targets=qubit_idx_ssas,
+            p=stmt.p,
+        )
 
-        stim_stmt = stim_noise.Depolarize2(targets=qubit_idx_ssas, p=p_stmt.result)
         return stim_stmt
 
-    def rewrite_Depolarize(
+    def rewrite_TwoQubitPauliChannel(
         self,
-        stmt: qubit.Apply | qubit.Broadcast | wire.Broadcast | wire.Apply,
+        stmt: squin_noise.stmts.TwoQubitPauliChannel,
         qubit_idx_ssas: Tuple[SSAValue],
     ) -> Statement:
-        """Rewrite squin.noise.Depolarize to stim.Depolarize1."""
+        """Rewrite squin.noise.TwoQubitPauliChannel to stim.PauliChannel2."""
+
+        params = stmt.probabilities
+        prob_ssas = []
+        for idx in range(15):
+            idx_stmt = py.Constant(value=idx)
+            idx_stmt.insert_before(stmt)
+            getitem_stmt = py.GetItem(obj=params, index=idx_stmt.result)
+            getitem_stmt.insert_before(stmt)
+            prob_ssas.append(getitem_stmt.result)
 
-        squin_channel = stmt.operator.owner
-        assert isinstance(squin_channel, squin_noise.stmts.Depolarize)
+        stim_stmt = stim_noise.PauliChannel2(
+            targets=qubit_idx_ssas,
+            pix=prob_ssas[0],
+            piy=prob_ssas[1],
+            piz=prob_ssas[2],
+            pxi=prob_ssas[3],
+            pxx=prob_ssas[4],
+            pxy=prob_ssas[5],
+            pxz=prob_ssas[6],
+            pyi=prob_ssas[7],
+            pyx=prob_ssas[8],
+            pyy=prob_ssas[9],
+            pyz=prob_ssas[10],
+            pzi=prob_ssas[11],
+            pzx=prob_ssas[12],
+            pzy=prob_ssas[13],
+            pzz=prob_ssas[14],
+        )
+        return stim_stmt
 
-        p = get_const_value(float, squin_channel.p)
-        p_stmt = py.Constant(p)
-        p_stmt.insert_before(stmt)
+    def rewrite_Depolarize2(
+        self,
+        stmt: squin_noise.stmts.Depolarize2,
+        qubit_idx_ssas: Tuple[SSAValue],
+    ) -> Statement:
+        """Rewrite squin.noise.Depolarize2 to stim.Depolarize2."""
 
-        stim_stmt = stim_noise.Depolarize1(targets=qubit_idx_ssas, p=p_stmt.result)
+        stim_stmt = stim_noise.Depolarize2(targets=qubit_idx_ssas, p=stmt.p)
         return stim_stmt

bloqade/stim/rewrite/util.py

@@ -1,35 +1,8 @@
-from typing import TypeVar
-
-from kirin import ir, interp
-from kirin.analysis import const
+from kirin import ir
 from kirin.dialects import py
-from kirin.rewrite.abc import RewriteResult
 
-from bloqade.squin import op, wire, noise as squin_noise, qubit
 from bloqade.squin.rewrite import AddressAttribute
-from bloqade.stim.dialects import gate, noise as stim_noise, collapse
-from bloqade.analysis.address import AddressReg, AddressWire, AddressQubit, AddressTuple
-
-SQUIN_STIM_OP_MAPPING = {
-    op.stmts.X: gate.X,
-    op.stmts.Y: gate.Y,
-    op.stmts.Z: gate.Z,
-    op.stmts.H: gate.H,
-    op.stmts.S: gate.S,
-    op.stmts.SqrtX: gate.SqrtX,
-    op.stmts.SqrtY: gate.SqrtY,
-    op.stmts.Identity: gate.Identity,
-    op.stmts.Reset: collapse.RZ,
-    squin_noise.stmts.QubitLoss: stim_noise.QubitLoss,
-}
-
-# Squin allows creation of control gates where the gate can be any operator,
-# but Stim only supports CX, CY, and CZ as control gates.
-SQUIN_STIM_CONTROL_GATE_MAPPING = {
-    op.stmts.X: gate.CX,
-    op.stmts.Y: gate.CY,
-    op.stmts.Z: gate.CZ,
-}
+from bloqade.analysis.address import AddressReg, AddressQubit
 
 
 def create_and_insert_qubit_idx_stmt(
@@ -46,177 +19,17 @@ def insert_qubit_idx_from_address(
     """
     Extract qubit indices from an AddressAttribute and insert them into the SSA form.
     """
-    address_data = address.address
     qubit_idx_ssas = []
-
-    if isinstance(address_data, AddressTuple):
-        for address_qubit in address_data.data:
-            if not isinstance(address_qubit, AddressQubit):
-                return
+    if isinstance(address_data := address.address, AddressReg):
+        for qubit_idx in address_data.qubits:
             create_and_insert_qubit_idx_stmt(
-                address_qubit.data, stmt_to_insert_before, qubit_idx_ssas
-            )
-    elif isinstance(address_data, AddressReg):
-        for qubit_idx in address_data.data:
-            create_and_insert_qubit_idx_stmt(
-                qubit_idx, stmt_to_insert_before, qubit_idx_ssas
+                qubit_idx.data, stmt_to_insert_before, qubit_idx_ssas
             )
     elif isinstance(address_data, AddressQubit):
         create_and_insert_qubit_idx_stmt(
             address_data.data, stmt_to_insert_before, qubit_idx_ssas
         )
-    elif isinstance(address_data, AddressWire):
-        address_qubit = address_data.origin_qubit
-        create_and_insert_qubit_idx_stmt(
-            address_qubit.data, stmt_to_insert_before, qubit_idx_ssas
-        )
     else:
         return
 
     return tuple(qubit_idx_ssas)
-
-
-def insert_qubit_idx_from_wire_ssa(
-    wire_ssas: tuple[ir.SSAValue, ...], stmt_to_insert_before: ir.Statement
-) -> tuple[ir.SSAValue, ...] | None:
-    """
-    Extract qubit indices from wire SSA values and insert them into the SSA form.
-    """
-    qubit_idx_ssas = []
-    for wire_ssa in wire_ssas:
-        address_attribute = wire_ssa.hints.get("address")
-        if address_attribute is None:
-            return
-        assert isinstance(address_attribute, AddressAttribute)
-        wire_address = address_attribute.address
-        assert isinstance(wire_address, AddressWire)
-        qubit_idx = wire_address.origin_qubit.data
-        qubit_idx_stmt = py.Constant(qubit_idx)
-        qubit_idx_ssas.append(qubit_idx_stmt.result)
-        qubit_idx_stmt.insert_before(stmt_to_insert_before)
-
-    return tuple(qubit_idx_ssas)
-
-
-def insert_qubit_idx_after_apply(
-    stmt: wire.Apply | qubit.Apply | wire.Broadcast | qubit.Broadcast,
-) -> tuple[ir.SSAValue, ...] | None:
-    """
-    Extract qubit indices from Apply or Broadcast statements.
-    """
-    if isinstance(stmt, (qubit.Apply, qubit.Broadcast)):
-        qubits = stmt.qubits
-        address_attribute = qubits.hints.get("address")
-        if address_attribute is None:
-            return
-        assert isinstance(address_attribute, AddressAttribute)
-        return insert_qubit_idx_from_address(
-            address=address_attribute, stmt_to_insert_before=stmt
-        )
-    elif isinstance(stmt, (wire.Apply, wire.Broadcast)):
-        wire_ssas = stmt.inputs
-        return insert_qubit_idx_from_wire_ssa(
-            wire_ssas=wire_ssas, stmt_to_insert_before=stmt
-        )
-
-
-def rewrite_Control(
-    stmt_with_ctrl: qubit.Apply | wire.Apply | qubit.Broadcast | wire.Broadcast,
-) -> RewriteResult:
-    """
-    Handle control gates for Apply and Broadcast statements.
-    """
-    ctrl_op = stmt_with_ctrl.operator.owner
-    assert isinstance(ctrl_op, op.stmts.Control)
-
-    ctrl_op_target_gate = ctrl_op.op.owner
-    assert isinstance(ctrl_op_target_gate, op.stmts.Operator)
-
-    qubit_idx_ssas = insert_qubit_idx_after_apply(stmt=stmt_with_ctrl)
-    if qubit_idx_ssas is None:
-        return RewriteResult()
-
-    # Separate control and target qubits
-    target_qubits = []
-    ctrl_qubits = []
-    for i in range(len(qubit_idx_ssas)):
-        if (i % 2) == 0:
-            ctrl_qubits.append(qubit_idx_ssas[i])
-        else:
-            target_qubits.append(qubit_idx_ssas[i])
-
-    target_qubits = tuple(target_qubits)
-    ctrl_qubits = tuple(ctrl_qubits)
-
-    stim_gate = SQUIN_STIM_CONTROL_GATE_MAPPING.get(type(ctrl_op_target_gate))
-    if stim_gate is None:
-        return RewriteResult()
-
-    stim_stmt = stim_gate(controls=ctrl_qubits, targets=target_qubits)
-
-    if isinstance(stmt_with_ctrl, (wire.Apply, wire.Broadcast)):
-        create_wire_passthrough(stmt_with_ctrl)
-
-    stmt_with_ctrl.replace_by(stim_stmt)
-
-    return RewriteResult(has_done_something=True)
-
-
-def rewrite_QubitLoss(
-    stmt: qubit.Apply | qubit.Broadcast | wire.Broadcast | wire.Apply,
-) -> RewriteResult:
-    """
-    Rewrite QubitLoss statements to Stim's TrivialError.
-    """
-
-    squin_loss_op = stmt.operator.owner
-    assert isinstance(squin_loss_op, squin_noise.stmts.QubitLoss)
-
-    qubit_idx_ssas = insert_qubit_idx_after_apply(stmt=stmt)
-    if qubit_idx_ssas is None:
-        return RewriteResult()
-
-    stim_loss_stmt = stim_noise.QubitLoss(
-        targets=qubit_idx_ssas,
-        probs=(squin_loss_op.p,),
-    )
-
-    if isinstance(stmt, (wire.Apply, wire.Broadcast)):
-        create_wire_passthrough(stmt)
-
-    stmt.replace_by(stim_loss_stmt)
-
-    return RewriteResult(has_done_something=True)
-
-
-def create_wire_passthrough(stmt: wire.Apply | wire.Broadcast) -> None:
-
-    for input_wire, output_wire in zip(stmt.inputs, stmt.results):
-        # have to "reroute" the input of these statements to directly plug in
-        # to subsequent statements, remove dependency on the current statement
-        output_wire.replace_by(input_wire)
-
-
-def is_measure_result_used(
-    stmt: qubit.MeasureQubit | qubit.MeasureQubitList | wire.Measure,
-) -> bool:
-    """
-    Check if the result of a measure statement is used in the program.
-    """
-    return bool(stmt.result.uses)
-
-
-T = TypeVar("T")
-
-
-def get_const_value(typ: type[T], value: ir.SSAValue) -> T:
-    if isinstance(hint := value.hints.get("const"), const.Value):
-        data = hint.data
-        if isinstance(data, typ):
-            return hint.data
-        raise interp.InterpreterError(
-            f"Expected constant value <type = {typ}>, got {data}"
-        )
-    raise interp.InterpreterError(
-        f"Expected constant value <type = {typ}>, got {value}"
-    )

bloqade/test_utils.py

@@ -25,7 +25,7 @@ def print_diff(node: pprint.Printable, expected_node: pprint.Printable):
 
 def assert_nodes(node: ir.IRNode, expected_node: ir.IRNode):
     try:
-        assert node.is_equal(expected_node)
+        assert node.is_structurally_equal(expected_node)
     except AssertionError as e:
         print_diff(node, expected_node)
         raise e

bloqade/types.py

@@ -22,3 +22,13 @@ class Qubit(ABC):
 
 QubitType = types.PyClass(Qubit)
 """Kirin type for a qubit."""
+
+
+class MeasurementResult:
+    """Runtime representation of the result of a measurement on a qubit."""
+
+    pass
+
+
+MeasurementResultType = types.PyClass(MeasurementResult)
+"""Kirin type for a measurement result."""

bloqade/validation/__init__.py

@@ -0,0 +1,2 @@
+from . import analysis as analysis
+from .kernel_validation import KernelValidation as KernelValidation

bloqade/validation/analysis/__init__.py

@@ -0,0 +1,5 @@
+from . import lattice as lattice
+from .analysis import (
+    ValidationFrame as ValidationFrame,
+    ValidationAnalysis as ValidationAnalysis,
+)