bloqade-circuit 0.2.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

bloqade/squin/rewrite/stim_rewrite_util.py

@@ -0,0 +1,153 @@
+from kirin import ir
+from kirin.dialects import py
+from kirin.rewrite.abc import RewriteResult
+
+from bloqade.squin import op, wire, qubit
+from bloqade.stim.dialects import gate, collapse
+from bloqade.analysis.address import AddressWire, AddressQubit, AddressTuple
+from bloqade.squin.rewrite.wrap_analysis import AddressAttribute
+
+SQUIN_STIM_GATE_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.Identity: gate.Identity,
+    op.stmts.Reset: collapse.RZ,
+}
+
+
+def insert_qubit_idx_from_address(
+    address: AddressAttribute, stmt_to_insert_before: ir.Statement
+) -> tuple[ir.SSAValue, ...] | None:
+    """
+    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
+            qubit_idx = address_qubit.data
+            qubit_idx_stmt = py.Constant(qubit_idx)
+            qubit_idx_stmt.insert_before(stmt_to_insert_before)
+            qubit_idx_ssas.append(qubit_idx_stmt.result)
+    elif isinstance(address_data, AddressWire):
+        address_qubit = address_data.origin_qubit
+        qubit_idx = address_qubit.data
+        qubit_idx_stmt = py.Constant(qubit_idx)
+        qubit_idx_stmt.insert_before(stmt_to_insert_before)
+        qubit_idx_ssas.append(qubit_idx_stmt.result)
+    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)
+
+    supported_gate_mapping = {
+        op.stmts.X: gate.CX,
+        op.stmts.Y: gate.CY,
+        op.stmts.Z: gate.CZ,
+    }
+
+    stim_gate = supported_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)):
+        # have to "reroute" the input of these statements to directly plug in
+        # to subsequent statements, remove dependency on the current statement
+        for input_wire, output_wire in zip(
+            stmt_with_ctrl.inputs, stmt_with_ctrl.results
+        ):
+            output_wire.replace_by(input_wire)
+
+    stmt_with_ctrl.replace_by(stim_stmt)
+
+    return RewriteResult(has_done_something=True)
+
+
+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)

bloqade/squin/rewrite/wire_identity_elimination.py

@@ -0,0 +1,24 @@
+from kirin import ir
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from bloqade.squin import wire
+
+
+class SquinWireIdentityElimination(RewriteRule):
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+        """
+        Handle the case where an unwrap feeds a wire directly into a wrap,
+        equivalent to nothing happening/identity operation
+
+        w = unwrap(qubit)
+        wrap(qubit, w)
+        """
+        if isinstance(node, wire.Wrap):
+            wire_origin_stmt = node.wire.owner
+            if isinstance(wire_origin_stmt, wire.Unwrap):
+                node.delete()  # get rid of wrap
+                wire_origin_stmt.delete()  # get rid of the unwrap
+                return RewriteResult(has_done_something=True)
+
+        return RewriteResult()

bloqade/squin/rewrite/wire_to_stim.py

@@ -0,0 +1,52 @@
+from kirin import ir
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from bloqade.squin import op, wire
+from bloqade.squin.rewrite.stim_rewrite_util import (
+    SQUIN_STIM_GATE_MAPPING,
+    rewrite_Control,
+    insert_qubit_idx_from_wire_ssa,
+)
+
+
+class SquinWireToStim(RewriteRule):
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+        match node:
+            case wire.Apply() | wire.Broadcast():
+                return self.rewrite_Apply_and_Broadcast(node)
+            case _:
+                return RewriteResult()
+
+    def rewrite_Apply_and_Broadcast(
+        self, stmt: wire.Apply | wire.Broadcast
+    ) -> RewriteResult:
+
+        # this is an SSAValue, need it to be the actual operator
+        applied_op = stmt.operator.owner
+        assert isinstance(applied_op, op.stmts.Operator)
+
+        if isinstance(applied_op, op.stmts.Control):
+            return rewrite_Control(stmt)
+
+        stim_1q_op = SQUIN_STIM_GATE_MAPPING.get(type(applied_op))
+        if stim_1q_op is None:
+            return RewriteResult()
+
+        qubit_idx_ssas = insert_qubit_idx_from_wire_ssa(
+            wire_ssas=stmt.inputs, stmt_to_insert_before=stmt
+        )
+        if qubit_idx_ssas is None:
+            return RewriteResult()
+
+        stim_1q_stmt = stim_1q_op(targets=tuple(qubit_idx_ssas))
+
+        # Get the wires from the inputs of Apply or Broadcast,
+        # then put those as the result of the current stmt
+        # before replacing it entirely
+        for input_wire, output_wire in zip(stmt.inputs, stmt.results):
+            output_wire.replace_by(input_wire)
+
+        stmt.replace_by(stim_1q_stmt)
+
+        return RewriteResult(has_done_something=True)

bloqade/squin/rewrite/wrap_analysis.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+
+from kirin import ir
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+from kirin.print.printer import Printer
+
+from bloqade.squin import op, wire
+from bloqade.analysis.address import Address
+from bloqade.squin.analysis.nsites import Sites
+
+
+@wire.dialect.register
+@dataclass
+class AddressAttribute(ir.Attribute):
+
+    name = "Address"
+    address: Address
+
+    def __hash__(self) -> int:
+        return hash(self.address)
+
+    def print_impl(self, printer: Printer) -> None:
+        # Can return to implementing this later
+        printer.print(self.address)
+
+
+@op.dialect.register
+@dataclass
+class SitesAttribute(ir.Attribute):
+
+    name = "Sites"
+    sites: Sites
+
+    def __hash__(self) -> int:
+        return hash(self.sites)
+
+    def print_impl(self, printer: Printer) -> None:
+        # Can return to implementing this later
+        printer.print(self.sites)
+
+
+@dataclass
+class WrapSquinAnalysis(RewriteRule):
+
+    address_analysis: dict[ir.SSAValue, Address]
+    op_site_analysis: dict[ir.SSAValue, Sites]
+
+    def wrap(self, value: ir.SSAValue) -> bool:
+        address_analysis_result = self.address_analysis[value]
+        op_site_analysis_result = self.op_site_analysis[value]
+
+        if value.hints.get("address") and value.hints.get("sites"):
+            return False
+        else:
+            value.hints["address"] = AddressAttribute(address_analysis_result)
+            value.hints["sites"] = SitesAttribute(op_site_analysis_result)
+
+        return True
+
+    def rewrite_Block(self, node: ir.Block) -> RewriteResult:
+        has_done_something = False
+        for arg in node.args:
+            if self.wrap(arg):
+                has_done_something = True
+        return RewriteResult(has_done_something=has_done_something)
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+        has_done_something = False
+        for result in node.results:
+            if self.wrap(result):
+                has_done_something = True
+        return RewriteResult(has_done_something=has_done_something)

bloqade/squin/wire.py

@@ -6,7 +6,7 @@ circuits. Thus we do not define wrapping functions for the statements in this
 dialect.
 """
 
-from kirin import ir, types, interp, lowering
+from kirin import ir, types, lowering
 from kirin.decl import info, statement
 from kirin.lowering import wraps
 
@@ -95,35 +95,18 @@ class Broadcast(ir.Statement):
 class Measure(ir.Statement):
     traits = frozenset({lowering.FromPythonCall(), WireTerminator()})
     wire: ir.SSAValue = info.argument(WireType)
+    qubit: ir.SSAValue = info.argument(QubitType)
     result: ir.ResultValue = info.result(types.Int)
 
 
 @statement(dialect=dialect)
-class MeasureAndReset(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall(), WireTerminator()})
-    wire: ir.SSAValue = info.argument(WireType)
+class NonDestructiveMeasure(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall()})
+    input_wire: ir.SSAValue = info.argument(WireType)
     result: ir.ResultValue = info.result(types.Int)
     out_wire: ir.ResultValue = info.result(WireType)
 
 
-@statement(dialect=dialect)
-class Reset(ir.Statement):
-    traits = frozenset({lowering.FromPythonCall(), WireTerminator()})
-    wire: ir.SSAValue = info.argument(WireType)
-
-
-# Issue where constant propagation can't handle
-# multiple return values from Apply properly
-@dialect.register(key="constprop")
-class ConstPropWire(interp.MethodTable):
-
-    @interp.impl(Apply)
-    @interp.impl(Broadcast)
-    def apply(self, interp, frame, stmt: Apply):
-
-        return frame.get_values(stmt.inputs)
-
-
 @wraps(Unwrap)
 def unwrap(qubit: Qubit) -> Wire: ...
 

bloqade/stim/__init__.py

@@ -1,6 +1,41 @@
+from . import emit as emit, parse as parse, dialects as dialects
 from .groups import main as main
-from ._wrappers import *  # noqa: F403
-from .dialects.aux import *  # noqa F403
-from .dialects.gate import *  # noqa F403
-from .dialects.noise import *  # noqa F403
-from .dialects.collapse import *  # noqa F403
+from ._wrappers import (
+    h as h,
+    s as s,
+    x as x,
+    y as y,
+    z as z,
+    cx as cx,
+    cy as cy,
+    cz as cz,
+    mx as mx,
+    my as my,
+    mz as mz,
+    rx as rx,
+    ry as ry,
+    rz as rz,
+    mpp as mpp,
+    mxx as mxx,
+    myy as myy,
+    mzz as mzz,
+    rec as rec,
+    spp as spp,
+    swap as swap,
+    tick as tick,
+    sqrt_x as sqrt_x,
+    sqrt_y as sqrt_y,
+    sqrt_z as sqrt_z,
+    x_error as x_error,
+    y_error as y_error,
+    z_error as z_error,
+    detector as detector,
+    identity as identity,
+    depolarize1 as depolarize1,
+    depolarize2 as depolarize2,
+    pauli_string as pauli_string,
+    qubit_coords as qubit_coords,
+    pauli_channel1 as pauli_channel1,
+    pauli_channel2 as pauli_channel2,
+    observable_include as observable_include,
+)

bloqade/stim/_wrappers.py

@@ -2,7 +2,7 @@ from typing import Union
 
 from kirin.lowering import wraps
 
-from .dialects import aux, gate, noise, collapse
+from .dialects import gate, noise, collapse, auxiliary
 
 
 # dialect:: gate
@@ -69,32 +69,38 @@ def cz(
 
 ## pp
 @wraps(gate.SPP)
-def spp(targets: tuple[aux.PauliString, ...], dagger=False) -> None: ...
+def spp(targets: tuple[auxiliary.PauliString, ...], dagger=False) -> None: ...
 
 
 # dialect:: aux
-@wraps(aux.GetRecord)
-def rec(id: int) -> aux.RecordResult: ...
+@wraps(auxiliary.GetRecord)
+def rec(id: int) -> auxiliary.RecordResult: ...
 
 
-@wraps(aux.Detector)
+@wraps(auxiliary.Detector)
 def detector(
-    coord: tuple[Union[int, float], ...], targets: tuple[aux.RecordResult, ...]
+    coord: tuple[Union[int, float], ...], targets: tuple[auxiliary.RecordResult, ...]
 ) -> None: ...
 
 
-@wraps(aux.ObservableInclude)
-def observable_include(idx: int, targets: tuple[aux.RecordResult, ...]) -> None: ...
+@wraps(auxiliary.ObservableInclude)
+def observable_include(
+    idx: int, targets: tuple[auxiliary.RecordResult, ...]
+) -> None: ...
 
 
-@wraps(aux.Tick)
+@wraps(auxiliary.Tick)
 def tick() -> None: ...
 
 
-@wraps(aux.NewPauliString)
+@wraps(auxiliary.NewPauliString)
 def pauli_string(
     string: tuple[str, ...], flipped: tuple[bool, ...], targets: tuple[int, ...]
-) -> aux.PauliString: ...
+) -> auxiliary.PauliString: ...
+
+
+@wraps(auxiliary.QubitCoordinates)
+def qubit_coords(coord: tuple[Union[int, float], ...], target: int) -> None: ...
 
 
 # dialect:: collapse
@@ -123,7 +129,7 @@ def mxx(p: float, targets: tuple[int, ...]) -> None: ...
 
 
 @wraps(collapse.PPMeasurement)
-def mpp(p: float, targets: tuple[aux.PauliString, ...]) -> None: ...
+def mpp(p: float, targets: tuple[auxiliary.PauliString, ...]) -> None: ...
 
 
 @wraps(collapse.RZ)

bloqade/stim/dialects/__init__.py

@@ -1,5 +1 @@
-from . import aux as aux, gate as gate, noise as noise, collapse as collapse
-from .aux.stmts import *  # noqa F403
-from .gate.stmts import *  # noqa F403
-from .noise.stmts import *  # noqa F403
-from .collapse.stmts import *  # noqa F403
+from . import gate as gate, noise as noise, collapse as collapse, auxiliary as auxiliary

bloqade/stim/dialects/{aux → auxiliary}/__init__.py

@@ -1,6 +1,18 @@
 from . import lowering as lowering
 from .emit import EmitStimAuxMethods as EmitStimAuxMethods
-from .stmts import *  # noqa F403
+from .stmts import (
+    Neg as Neg,
+    Tick as Tick,
+    ConstInt as ConstInt,
+    ConstStr as ConstStr,
+    Detector as Detector,
+    ConstBool as ConstBool,
+    GetRecord as GetRecord,
+    ConstFloat as ConstFloat,
+    NewPauliString as NewPauliString,
+    QubitCoordinates as QubitCoordinates,
+    ObservableInclude as ObservableInclude,
+)
 from .types import (
     RecordType as RecordType,
     PauliString as PauliString,

bloqade/stim/dialects/{aux → auxiliary}/emit.py

@@ -1,7 +1,7 @@
 from kirin.emit import EmitStrFrame
 from kirin.interp import MethodTable, impl
 
-from bloqade.stim.emit.stim import EmitStimMain
+from bloqade.stim.emit.stim_str import EmitStimMain
 
 from . import stmts
 from ._dialect import dialect
@@ -69,8 +69,10 @@ class EmitStimAuxMethods(MethodTable):
 
         coord_str: str = ", ".join(coords)
         target_str: str = " ".join(targets)
-        emit.writeln(frame, f"DETECTOR({coord_str}) {target_str}")
-
+        if len(coords):
+            emit.writeln(frame, f"DETECTOR({coord_str}) {target_str}")
+        else:
+            emit.writeln(frame, f"DETECTOR {target_str}")
         return ()
 
     @impl(stmts.ObservableInclude)
@@ -100,3 +102,16 @@ class EmitStimAuxMethods(MethodTable):
         )
 
         return (out,)
+
+    @impl(stmts.QubitCoordinates)
+    def qubit_coordinates(
+        self, emit: EmitStimMain, frame: EmitStrFrame, stmt: stmts.QubitCoordinates
+    ):
+
+        coords: tuple[str, ...] = frame.get_values(stmt.coord)
+        target: str = frame.get(stmt.target)
+
+        coord_str: str = ", ".join(coords)
+        emit.writeln(frame, f"QUBIT_COORDS({coord_str}) {target}")
+
+        return ()

bloqade/stim/dialects/{aux → auxiliary}/stmts/__init__.py

@@ -10,5 +10,6 @@ from .annotate import (
     Detector as Detector,
     GetRecord as GetRecord,
     NewPauliString as NewPauliString,
+    QubitCoordinates as QubitCoordinates,
     ObservableInclude as ObservableInclude,
 )

bloqade/stim/dialects/{aux → auxiliary}/stmts/annotate.py

@@ -45,3 +45,11 @@ class NewPauliString(ir.Statement):
     flipped: tuple[ir.SSAValue, ...] = info.argument(types.Bool)
     targets: tuple[ir.SSAValue, ...] = info.argument(types.Int)
     result: ir.ResultValue = info.result(type=PauliStringType)
+
+
+@statement(dialect=dialect)
+class QubitCoordinates(ir.Statement):
+    name = "qubit_coordinates"
+    traits = frozenset({lowering.FromPythonCall()})
+    coord: tuple[ir.SSAValue, ...] = info.argument(PyNum)
+    target: ir.SSAValue = info.argument(types.Int)

bloqade/stim/dialects/collapse/__init__.py

@@ -1,3 +1,14 @@
-from .emit import EmitStimCollapseMethods as EmitStimCollapseMethods
-from .stmts import *  # noqa F403
+from .stmts import (
+    MX as MX,
+    MY as MY,
+    MZ as MZ,
+    RX as RX,
+    RY as RY,
+    RZ as RZ,
+    MXX as MXX,
+    MYY as MYY,
+    MZZ as MZZ,
+    PPMeasurement as PPMeasurement,
+)
 from ._dialect import dialect as dialect
+from .emit_str import EmitStimCollapseMethods as EmitStimCollapseMethods

bloqade/stim/dialects/collapse/{emit.py → emit_str.py}

@@ -1,7 +1,7 @@
 from kirin.emit import EmitStrFrame
 from kirin.interp import MethodTable, impl
 
-from bloqade.stim.emit.stim import EmitStimMain
+from bloqade.stim.emit.stim_str import EmitStimMain
 
 from . import stmts
 from ._dialect import dialect
@@ -60,7 +60,9 @@ class EmitStimCollapseMethods(MethodTable):
         self, emit: EmitStimMain, frame: EmitStrFrame, stmt: stmts.PPMeasurement
     ):
         probability: str = frame.get(stmt.p)
-        targets: tuple[str, ...] = frame.get_values(stmt.targets)
+        targets: tuple[str, ...] = tuple(
+            targ.upper() for targ in frame.get_values(stmt.targets)
+        )
 
         out = f"MPP({probability}) " + " ".join(targets)
         emit.writeln(frame, out)

bloqade/stim/dialects/collapse/stmts/pp_measure.py

@@ -2,7 +2,7 @@ from kirin import ir, types, lowering
 from kirin.decl import info, statement
 
 from .._dialect import dialect
-from ...aux.types import PauliStringType
+from ...auxiliary.types import PauliStringType
 
 
 @statement(dialect=dialect)

bloqade/stim/dialects/gate/__init__.py

@@ -1,3 +1,18 @@
 from .emit import EmitStimGateMethods as EmitStimGateMethods
-from .stmts import *  # noqa F403
+from .stmts import (
+    CX as CX,
+    CY as CY,
+    CZ as CZ,
+    SPP as SPP,
+    H as H,
+    S as S,
+    X as X,
+    Y as Y,
+    Z as Z,
+    Swap as Swap,
+    SqrtX as SqrtX,
+    SqrtY as SqrtY,
+    SqrtZ as SqrtZ,
+    Identity as Identity,
+)
 from ._dialect import dialect as dialect

bloqade/stim/dialects/gate/emit.py

@@ -1,7 +1,7 @@
 from kirin.emit import EmitStrFrame
 from kirin.interp import MethodTable, impl
 
-from bloqade.stim.emit.stim import EmitStimMain
+from bloqade.stim.emit.stim_str import EmitStimMain
 
 from . import stmts
 from ._dialect import dialect
@@ -12,6 +12,7 @@ from .stmts.base import SingleQubitGate, ControlledTwoQubitGate
 class EmitStimGateMethods(MethodTable):
 
     gate_1q_map: dict[str, tuple[str, str]] = {
+        stmts.Identity.name: ("I", "I"),
         stmts.X.name: ("X", "X"),
         stmts.Y.name: ("Y", "Y"),
         stmts.Z.name: ("Z", "Z"),
@@ -22,6 +23,7 @@ class EmitStimGateMethods(MethodTable):
         stmts.SqrtZ.name: ("SQRT_Z", "SQRT_Z_DAG"),
     }
 
+    @impl(stmts.Identity)
     @impl(stmts.X)
     @impl(stmts.Y)
     @impl(stmts.Z)
@@ -80,8 +82,13 @@ class EmitStimGateMethods(MethodTable):
     @impl(stmts.SPP)
     def spp(self, emit: EmitStimMain, frame: EmitStrFrame, stmt: stmts.SPP):
 
-        targets: tuple[str, ...] = frame.get_values(stmt.targets)
-        res = "SPP " + " ".join(targets)
+        targets: tuple[str, ...] = tuple(
+            targ.upper() for targ in frame.get_values(stmt.targets)
+        )
+        if stmt.dagger:
+            res = "SPP_DAG " + " ".join(targets)
+        else:
+            res = "SPP " + " ".join(targets)
         emit.writeln(frame, res)
 
         return ()

bloqade/stim/dialects/gate/stmts/base.py

@@ -1,7 +1,7 @@
 from kirin import ir, types, lowering
 from kirin.decl import info, statement
 
-from bloqade.stim.dialects.aux import RecordType
+from bloqade.stim.dialects.auxiliary import RecordType
 
 
 @statement

bloqade/stim/dialects/gate/stmts/pp.py

@@ -2,7 +2,7 @@ from kirin import ir, types, lowering
 from kirin.decl import info, statement
 
 from .._dialect import dialect
-from ...aux.types import PauliStringType
+from ...auxiliary.types import PauliStringType
 
 
 # Generalized Pauli-product gates