bloqade-circuit 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

bloqade/squin/analysis/nsites/impls.py

@@ -1,4 +1,6 @@
 from kirin import interp
+from kirin.dialects import scf
+from kirin.dialects.scf.typeinfer import TypeInfer as ScfTypeInfer
 
 from bloqade.squin import op, wire
 
@@ -78,3 +80,8 @@ class SquinOp(interp.MethodTable):
     def scale(self, interp: NSitesAnalysis, frame: interp.Frame, stmt: op.stmts.Scale):
         op_sites = frame.get(stmt.op)
         return (op_sites,)
+
+
+@scf.dialect.register(key="op.nsites")
+class ScfSquinOp(ScfTypeInfer):
+    pass

bloqade/squin/cirq/__init__.py

@@ -9,8 +9,9 @@ from . import lowering as lowering
 from .. import kernel
 
 # NOTE: just to register methods
-from .emit import op as op, qubit as qubit
+from .emit import op as op, noise as noise, qubit as qubit
 from .lowering import Squin
+from ..noise.rewrite import RewriteNoiseStmts
 from .emit.emit_circuit import EmitCirq
 
 
@@ -18,6 +19,9 @@ def load_circuit(
     circuit: cirq.Circuit,
     kernel_name: str = "main",
     dialects: ir.DialectGroup = kernel,
+    register_as_argument: bool = False,
+    return_register: bool = False,
+    register_argument_name: str = "q",
     globals: dict[str, Any] | None = None,
     file: str | None = None,
     lineno_offset: int = 0,
@@ -32,13 +36,23 @@ def load_circuit(
     Keyword Args:
         kernel_name (str): The name of the kernel to load. Defaults to "main".
         dialects (ir.DialectGroup | None): The dialects to use. Defaults to `squin.kernel`.
+        register_as_argument (bool): Determine whether the resulting kernel function should accept
+            a single `ilist.IList[Qubit, Any]` argument that is a list of qubits used within the
+            function. This allows you to compose kernel functions generated from circuits.
+            Defaults to `False`.
+        return_register (bool): Determine whether the resulting kernel functionr returns a
+            single value of type `ilist.IList[Qubit, Any]` that is the list of qubits used
+            in the kernel function. Useful when you want to compose multiple kernel functions
+            generated from circuits. Defaults to `False`.
+        register_argument_name (str): The name of the argument that represents the qubit register.
+            Only used when `register_as_argument=True`. Defaults to "q".
         globals (dict[str, Any] | None): The global variables to use. Defaults to None.
         file (str | None): The file name for error reporting. Defaults to None.
         lineno_offset (int): The line number offset for error reporting. Defaults to 0.
         col_offset (int): The column number offset for error reporting. Defaults to 0.
         compactify (bool): Whether to compactify the output. Defaults to True.
 
-    Example:
+    ## Usage Examples:
 
     ```python
     # from cirq's "hello qubit" example
@@ -60,6 +74,30 @@ def load_circuit(
     # print the resulting IR
     main.print()
     ```
+
+    You can also compose kernel functions generated from circuits by passing in
+    and / or returning the respective quantum registers:
+
+    ```python
+    q = cirq.LineQubit.range(2)
+    circuit = cirq.Circuit(cirq.H(q[0]), cirq.CX(*q))
+
+    get_entangled_qubits = squin.cirq.load_circuit(
+        circuit, return_register=True, kernel_name="get_entangled_qubits"
+    )
+    get_entangled_qubits.print()
+
+    entangle_qubits = squin.cirq.load_circuit(
+        circuit, register_as_argument=True, kernel_name="entangle_qubits"
+    )
+
+    @squin.kernel
+    def main():
+        qreg = get_entangled_qubits()
+        qreg2 = squin.qubit.new(1)
+        entangle_qubits([qreg[1], qreg2[0]])
+        return squin.qubit.measure(qreg2)
+    ```
     """
 
     target = Squin(dialects=dialects, circuit=circuit)
@@ -71,16 +109,38 @@ def load_circuit(
         lineno_offset=lineno_offset,
         col_offset=col_offset,
         compactify=compactify,
+        register_as_argument=register_as_argument,
+        register_argument_name=register_argument_name,
     )
 
-    # NOTE: no return value
-    return_value = func.ConstantNone()
-    body.blocks[0].stmts.append(return_value)
-    body.blocks[0].stmts.append(func.Return(value_or_stmt=return_value))
+    if return_register:
+        return_value = target.qreg
+    else:
+        return_value = func.ConstantNone()
+        body.blocks[0].stmts.append(return_value)
+
+    return_node = func.Return(value_or_stmt=return_value)
+    body.blocks[0].stmts.append(return_node)
+
+    self_arg_name = kernel_name + "_self"
+    arg_names = [self_arg_name]
+    if register_as_argument:
+        args = (target.qreg.type,)
+        arg_names.append(register_argument_name)
+    else:
+        args = ()
+
+    # NOTE: add _self as argument; need to know signature before so do it after lowering
+    signature = func.Signature(args, return_node.value.type)
+    body.blocks[0].args.insert_from(
+        0,
+        types.Generic(ir.Method, types.Tuple.where(signature.inputs), signature.output),
+        self_arg_name,
+    )
 
     code = func.Function(
         sym_name=kernel_name,
-        signature=func.Signature((), types.NoneType),
+        signature=signature,
         body=body,
     )
 
@@ -88,7 +148,7 @@ def load_circuit(
         mod=None,
         py_func=None,
         sym_name=kernel_name,
-        arg_names=[],
+        arg_names=arg_names,
         dialects=dialects,
         code=code,
     )
@@ -176,7 +236,12 @@ def emit_circuit(
         )
 
     emitter = EmitCirq(qubits=qubits)
-    return emitter.run(mt, args=())
+
+    # Rewrite noise statements
+    mt_ = mt.similar(mt.dialects)
+    RewriteNoiseStmts(mt_.dialects)(mt_)
+
+    return emitter.run(mt_, args=())
 
 
 def dump_circuit(mt: ir.Method, qubits: Sequence[cirq.Qid] | None = None, **kwargs):

bloqade/squin/cirq/emit/noise.py

@@ -0,0 +1,49 @@
+import cirq
+from kirin.emit import EmitError
+from kirin.interp import MethodTable, impl
+
+from ... import noise
+from .runtime import (
+    KronRuntime,
+    BasicOpRuntime,
+    OperatorRuntimeABC,
+    PauliStringRuntime,
+)
+from .emit_circuit import EmitCirq, EmitCirqFrame
+
+
+@noise.dialect.register(key="emit.cirq")
+class EmitCirqNoiseMethods(MethodTable):
+
+    @impl(noise.stmts.StochasticUnitaryChannel)
+    def stochastic_unitary_channel(
+        self,
+        emit: EmitCirq,
+        frame: EmitCirqFrame,
+        stmt: noise.stmts.StochasticUnitaryChannel,
+    ):
+        ops = frame.get(stmt.operators)
+        ps = frame.get(stmt.probabilities)
+
+        error_probabilities = {self._op_to_key(op_): p for op_, p in zip(ops, ps)}
+        cirq_op = cirq.asymmetric_depolarize(error_probabilities=error_probabilities)
+        return (BasicOpRuntime(cirq_op),)
+
+    @staticmethod
+    def _op_to_key(operator: OperatorRuntimeABC) -> str:
+        match operator:
+            case KronRuntime():
+                key_lhs = EmitCirqNoiseMethods._op_to_key(operator.lhs)
+                key_rhs = EmitCirqNoiseMethods._op_to_key(operator.rhs)
+                return key_lhs + key_rhs
+
+            case BasicOpRuntime():
+                return str(operator.gate)
+
+            case PauliStringRuntime():
+                return operator.string
+
+            case _:
+                raise EmitError(
+                    f"Unexpected operator runtime in StochasticUnitaryChannel of type {type(operator).__name__} encountered!"
+                )

bloqade/squin/cirq/emit/runtime.py

@@ -21,7 +21,10 @@ class OperatorRuntimeABC:
 
     def unsafe_apply(
         self, qubits: Sequence[cirq.Qid], adjoint: bool = False
-    ) -> list[cirq.Operation]: ...
+    ) -> list[cirq.Operation]:
+        raise NotImplementedError(
+            f"Apply method needs to be implemented in {self.__class__.__name__}"
+        )
 
 
 @dataclass
@@ -38,6 +41,11 @@ class BasicOpRuntime(UnsafeOperatorRuntimeABC):
     def num_qubits(self) -> int:
         return self.gate.num_qubits()
 
+    def unsafe_apply(
+        self, qubits: Sequence[cirq.Qid], adjoint: bool = False
+    ) -> list[cirq.Operation]:
+        return [self.gate(*qubits)]
+
 
 @dataclass
 class UnitaryRuntime(BasicOpRuntime):

bloqade/squin/cirq/lowering.py

@@ -3,7 +3,7 @@ from typing import Any
 from dataclasses import field, dataclass
 
 import cirq
-from kirin import ir, lowering
+from kirin import ir, types, lowering
 from kirin.rewrite import Walk, CFGCompactify
 from kirin.dialects import py, scf, ilist
 
@@ -25,27 +25,26 @@ class Squin(lowering.LoweringABC[CirqNode]):
     """Lower a cirq.Circuit object to a squin kernel"""
 
     circuit: cirq.Circuit
-    qreg: qubit.New = field(init=False)
+    qreg: ir.SSAValue = field(init=False)
     qreg_index: dict[cirq.Qid, int] = field(init=False, default_factory=dict)
     next_qreg_index: int = field(init=False, default=0)
 
-    def lower_qubit_getindex(self, state: lowering.State[CirqNode], qid: cirq.Qid):
-        index = self.qreg_index.get(qid)
-
-        if index is None:
-            index = self.next_qreg_index
-            self.qreg_index[qid] = index
-            self.next_qreg_index += 1
+    def __post_init__(self):
+        # TODO: sort by cirq ordering
+        qbits = sorted(self.circuit.all_qubits())
+        self.qreg_index = {qid: idx for (idx, qid) in enumerate(qbits)}
 
+    def lower_qubit_getindex(self, state: lowering.State[CirqNode], qid: cirq.Qid):
+        index = self.qreg_index[qid]
         index_ssa = state.current_frame.push(py.Constant(index)).result
-        qbit_getitem = state.current_frame.push(py.GetItem(self.qreg.result, index_ssa))
+        qbit_getitem = state.current_frame.push(py.GetItem(self.qreg, index_ssa))
         return qbit_getitem.result
 
     def lower_qubit_getindices(
         self, state: lowering.State[CirqNode], qids: list[cirq.Qid]
     ):
         qbits_getitem = [self.lower_qubit_getindex(state, qid) for qid in qids]
-        qbits_stmt = ilist.New(values=qbits_getitem)
+        qbits_stmt = ilist.New(values=qbits_getitem, elem_type=qubit.QubitType)
         qbits_result = state.current_frame.get(qbits_stmt.name)
 
         if qbits_result is not None:
@@ -64,6 +63,8 @@ class Squin(lowering.LoweringABC[CirqNode]):
         lineno_offset: int = 0,
         col_offset: int = 0,
         compactify: bool = True,
+        register_as_argument: bool = False,
+        register_argument_name: str = "q",
     ) -> ir.Region:
 
         state = lowering.State(
@@ -73,16 +74,21 @@ class Squin(lowering.LoweringABC[CirqNode]):
             col_offset=col_offset,
         )
 
-        with state.frame(
-            [stmt],
-            globals=globals,
-            finalize_next=False,
-        ) as frame:
-            # NOTE: create a global register of qubits first
-            # TODO: can there be a circuit without qubits?
-            n_qubits = cirq.num_qubits(self.circuit)
-            n = frame.push(py.Constant(n_qubits))
-            self.qreg = frame.push(qubit.New(n_qubits=n.result))
+        with state.frame([stmt], globals=globals, finalize_next=False) as frame:
+
+            # NOTE: need a register of qubits before lowering statements
+            if register_as_argument:
+                # NOTE: register as argument to the kernel; we have freedom of choice for the name here
+                frame.curr_block.args.append_from(
+                    ilist.IListType[qubit.QubitType, types.Any],
+                    name=register_argument_name,
+                )
+                self.qreg = frame.curr_block.args[0]
+            else:
+                # NOTE: create a new register of appropriate size
+                n_qubits = len(self.qreg_index)
+                n = frame.push(py.Constant(n_qubits))
+                self.qreg = frame.push(qubit.New(n_qubits=n.result)).result
 
             self.visit(state, stmt)
 

bloqade/squin/noise/_wrapper.py

@@ -1,3 +1,6 @@
+from typing import Literal
+
+from kirin.dialects import ilist
 from kirin.lowering import wraps
 
 from bloqade.squin.op.types import Op
@@ -18,11 +21,15 @@ def depolarize(p: float) -> Op: ...
 
 
 @wraps(stmts.SingleQubitPauliChannel)
-def single_qubit_pauli_channel(params: tuple[float, float, float]) -> Op: ...
+def single_qubit_pauli_channel(
+    params: ilist.IList[float, Literal[3]] | list[float] | tuple[float, float, float],
+) -> Op: ...
 
 
 @wraps(stmts.TwoQubitPauliChannel)
-def two_qubit_pauli_channel(params: tuple[float, ...]) -> Op: ...
+def two_qubit_pauli_channel(
+    params: ilist.IList[float, Literal[15]] | list[float] | tuple[float, ...],
+) -> Op: ...
 
 
 @wraps(stmts.QubitLoss)

bloqade/squin/noise/rewrite.py

@@ -58,12 +58,12 @@ class _RewriteNoiseStmts(RewriteRule):
     def rewrite_two_qubit_pauli_channel(
         self, node: TwoQubitPauliChannel
     ) -> RewriteResult:
-        paulis = (X(), Y(), Z(), Identity(sites=1))
+        paulis = (Identity(sites=1), X(), Y(), Z())
         for op in paulis:
             op.insert_before(node)
 
-        # NOTE: collect list so we can skip the last entry, which will be two identities
-        combinations = list(itertools.product(paulis, repeat=2))[:-1]
+        # NOTE: collect list so we can skip the first entry, which will be two identities
+        combinations = list(itertools.product(paulis, repeat=2))[1:]
         operators: list[ir.SSAValue] = []
         for pauli_1, pauli_2 in combinations:
             op = Kron(pauli_1.result, pauli_2.result)

bloqade/squin/op/__init__.py

@@ -30,6 +30,9 @@ from ._wrapper import (
     shift as shift,
     spin_n as spin_n,
     spin_p as spin_p,
+    sqrt_x as sqrt_x,
+    sqrt_y as sqrt_y,
+    sqrt_z as sqrt_z,
     adjoint as adjoint,
     control as control,
     identity as identity,

bloqade/squin/op/_wrapper.py

@@ -69,6 +69,18 @@ def y() -> types.Op: ...
 def z() -> types.Op: ...
 
 
+@wraps(stmts.SqrtX)
+def sqrt_x() -> types.Op: ...
+
+
+@wraps(stmts.SqrtY)
+def sqrt_y() -> types.Op: ...
+
+
+@wraps(stmts.S)
+def sqrt_z() -> types.Op: ...
+
+
 @wraps(stmts.H)
 def h() -> types.Op: ...
 

bloqade/squin/op/stmts.py

@@ -142,7 +142,12 @@ class Reset(PrimitiveOp):
 
 
 @statement
-class PauliOp(ConstantUnitary):
+class CliffordOp(ConstantUnitary):
+    pass
+
+
+@statement
+class PauliOp(CliffordOp):
     pass
 
 
@@ -173,6 +178,19 @@ class Z(PauliOp):
     pass
 
 
+@statement(dialect=dialect)
+class SqrtX(ConstantUnitary):
+    pass
+
+
+@statement(dialect=dialect)
+class SqrtY(ConstantUnitary):
+    pass
+
+
+# NOTE no SqrtZ since its equal to S
+
+
 @statement(dialect=dialect)
 class H(ConstantUnitary):
     pass

bloqade/squin/rewrite/U3_to_clifford.py

@@ -0,0 +1,149 @@
+# create rewrite rule name SquinMeasureToStim using kirin
+import math
+from typing import List, Tuple, Callable
+
+import numpy as np
+from kirin import ir
+from kirin.dialects import py
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from bloqade.squin import op, qubit
+
+
+def sdag() -> list[ir.Statement]:
+    return [_op := op.stmts.S(), op.stmts.Adjoint(op=_op.result, is_unitary=True)]
+
+
+# (theta, phi, lam)
+U3_HALF_PI_ANGLE_TO_GATES: dict[
+    tuple[int, int, int], Callable[[], Tuple[List[ir.Statement], ...]]
+] = {
+    (0, 0, 0): lambda: ([op.stmts.Identity(sites=1)],),
+    (0, 0, 1): lambda: ([op.stmts.S()],),
+    (0, 0, 2): lambda: ([op.stmts.Z()],),
+    (0, 0, 3): lambda: (sdag(),),
+    (1, 0, 0): lambda: ([op.stmts.SqrtY()],),
+    (1, 0, 1): lambda: ([op.stmts.S()], [op.stmts.SqrtY()]),
+    (1, 0, 2): lambda: ([op.stmts.H()],),
+    (1, 0, 3): lambda: (sdag(), [op.stmts.SqrtY()]),
+    (1, 1, 0): lambda: ([op.stmts.SqrtY()], [op.stmts.S()]),
+    (1, 1, 1): lambda: ([op.stmts.S()], [op.stmts.SqrtY()], [op.stmts.S()]),
+    (1, 1, 2): lambda: ([op.stmts.Z()], [op.stmts.SqrtY()], [op.stmts.S()]),
+    (1, 1, 3): lambda: (sdag(), [op.stmts.SqrtY()], [op.stmts.S()]),
+    (1, 2, 0): lambda: ([op.stmts.SqrtY()], [op.stmts.Z()]),
+    (1, 2, 1): lambda: ([op.stmts.S()], [op.stmts.SqrtY()], [op.stmts.Z()]),
+    (1, 2, 2): lambda: ([op.stmts.Z()], [op.stmts.SqrtY()], [op.stmts.Z()]),
+    (1, 2, 3): lambda: (sdag(), [op.stmts.SqrtY()], [op.stmts.Z()]),
+    (1, 3, 0): lambda: ([op.stmts.SqrtY()], sdag()),
+    (1, 3, 1): lambda: ([op.stmts.S()], [op.stmts.SqrtY()], sdag()),
+    (1, 3, 2): lambda: ([op.stmts.Z()], [op.stmts.SqrtY()], sdag()),
+    (1, 3, 3): lambda: (sdag(), [op.stmts.SqrtY()], sdag()),
+    (2, 0, 0): lambda: ([op.stmts.Y()],),
+    (2, 0, 1): lambda: ([op.stmts.S()], [op.stmts.Y()]),
+    (2, 0, 2): lambda: ([op.stmts.Z()], [op.stmts.Y()]),
+    (2, 0, 3): lambda: (sdag(), [op.stmts.Y()]),
+}
+
+
+def equivalent_u3_para(
+    theta_half_pi: int, phi_half_pi: int, lam_half_pi: int
+) -> tuple[int, int, int]:
+    """
+    1. Assume all three angles are in the range [0, 4].
+    2. U3(theta, phi, lam) = -U3(2pi-theta, phi+pi, lam+pi).
+    """
+    return ((4 - theta_half_pi) % 4, (phi_half_pi + 2) % 4, (lam_half_pi + 2) % 4)
+
+
+class SquinU3ToClifford(RewriteRule):
+    """
+    Rewrite squin U3 statements to clifford when possible.
+    """
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+        if isinstance(node, (qubit.Apply, qubit.Broadcast)):
+            return self.rewrite_ApplyOrBroadcast_onU3(node)
+        else:
+            return RewriteResult()
+
+    def get_constant(self, node: ir.SSAValue) -> float | None:
+        if isinstance(node.owner, py.Constant):
+            # node.value is a PyAttr, need to get the wrapped value out
+            return node.owner.value.unwrap()
+        else:
+            return None
+
+    def resolve_angle(self, angle: float) -> int | None:
+        """
+        Normalize the angle to be in the range [0, 2π).
+        """
+        # convert to 0.0~1.0, in unit of pi/2
+        angle_half_pi = angle / math.pi * 2.0
+
+        mod = angle_half_pi % 1.0
+        if not (np.isclose(mod, 0.0) or np.isclose(mod, 1.0)):
+            return None
+
+        else:
+            return round((angle / math.tau) % 1 * 4) % 4
+
+    def rewrite_ApplyOrBroadcast_onU3(
+        self, node: qubit.Apply | qubit.Broadcast
+    ) -> RewriteResult:
+        """
+        Rewrite Apply and Broadcast nodes to their clifford equivalent statements.
+        """
+        if not isinstance(node.operator.owner, op.stmts.U3):
+            return RewriteResult()
+
+        gates = self.decompose_U3_gates(node.operator.owner)
+
+        if len(gates) == 0:
+            return RewriteResult()
+
+        for stmt_list in gates:
+            for gate_stmt in stmt_list[:-1]:
+                gate_stmt.insert_before(node)
+
+            oper = stmt_list[-1]
+            oper.insert_before(node)
+            new_node = node.__class__(operator=oper.result, qubits=node.qubits)
+            new_node.insert_before(node)
+
+        node.delete()
+
+        # rewrite U3 to clifford gates
+        return RewriteResult(has_done_something=True)
+
+    def decompose_U3_gates(self, node: op.stmts.U3) -> Tuple[List[ir.Statement], ...]:
+        """
+        Rewrite U3 statements to clifford gates if possible.
+        """
+        theta = self.get_constant(node.theta)
+        phi = self.get_constant(node.phi)
+        lam = self.get_constant(node.lam)
+
+        if theta is None or phi is None or lam is None:
+            return ()
+
+        theta_half_pi: int | None = self.resolve_angle(theta)
+        phi_half_pi: int | None = self.resolve_angle(phi)
+        lam_half_pi: int | None = self.resolve_angle(lam)
+
+        if theta_half_pi is None or phi_half_pi is None or lam_half_pi is None:
+            return ()
+
+        angles_key = (theta_half_pi, phi_half_pi, lam_half_pi)
+        if angles_key not in U3_HALF_PI_ANGLE_TO_GATES:
+            angles_key = equivalent_u3_para(*angles_key)
+            if angles_key not in U3_HALF_PI_ANGLE_TO_GATES:
+                return ()
+
+        gates_stmts = U3_HALF_PI_ANGLE_TO_GATES.get(angles_key)
+
+        # no consistent gates, then:
+        assert (
+            gates_stmts is not None
+        ), "internal error, U3 gates not found for angles: {}".format(angles_key)
+
+        return gates_stmts()

bloqade/squin/rewrite/__init__.py

@@ -1,11 +1,7 @@
-from .wire_to_stim import SquinWireToStim as SquinWireToStim
-from .qubit_to_stim import SquinQubitToStim as SquinQubitToStim
-from .squin_measure import SquinMeasureToStim as SquinMeasureToStim
 from .wrap_analysis import (
     SitesAttribute as SitesAttribute,
     AddressAttribute as AddressAttribute,
-    WrapSquinAnalysis as WrapSquinAnalysis,
-)
-from .wire_identity_elimination import (
-    SquinWireIdentityElimination as SquinWireIdentityElimination,
+    WrapOpSiteAnalysis as WrapOpSiteAnalysis,
+    WrapAddressAnalysis as WrapAddressAnalysis,
 )
+from .remove_dangling_qubits import RemoveDeadRegister as RemoveDeadRegister

bloqade/squin/rewrite/remove_dangling_qubits.py

@@ -0,0 +1,19 @@
+from kirin import ir
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from bloqade.squin import qubit
+
+
+class RemoveDeadRegister(RewriteRule):
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+
+        if not isinstance(node, qubit.New):
+            return RewriteResult()
+
+        if bool(node.result.uses):
+            return RewriteResult()
+        else:
+            node.delete()
+
+        return RewriteResult(has_done_something=True)

bloqade/squin/rewrite/wrap_analysis.py

@@ -1,3 +1,4 @@
+from abc import abstractmethod
 from dataclasses import dataclass
 
 from kirin import ir
@@ -40,33 +41,47 @@ class SitesAttribute(ir.Attribute):
 
 
 @dataclass
-class WrapSquinAnalysis(RewriteRule):
+class WrapAnalysis(RewriteRule):
 
+    @abstractmethod
+    def wrap(self, value: ir.SSAValue) -> bool:
+        pass
+
+    def rewrite_Block(self, node: ir.Block) -> RewriteResult:
+        has_done_something = any(self.wrap(arg) for arg in node.args)
+        return RewriteResult(has_done_something=has_done_something)
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+        has_done_something = any(self.wrap(result) for result in node.results)
+        return RewriteResult(has_done_something=has_done_something)
+
+
+@dataclass
+class WrapAddressAnalysis(WrapAnalysis):
     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"):
+        if value.hints.get("address") is not None:
             return False
-        else:
-            value.hints["address"] = AddressAttribute(address_analysis_result)
-            value.hints["sites"] = SitesAttribute(op_site_analysis_result)
+
+        value.hints["address"] = AddressAttribute(address_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)
+@dataclass
+class WrapOpSiteAnalysis(WrapAnalysis):
+
+    op_site_analysis: dict[ir.SSAValue, Sites]
+
+    def wrap(self, value: ir.SSAValue) -> bool:
+        op_site_analysis_result = self.op_site_analysis[value]
+
+        if value.hints.get("sites") is not None:
+            return False
+
+        value.hints["sites"] = SitesAttribute(op_site_analysis_result)
+
+        return True

bloqade/stim/__init__.py

@@ -1,4 +1,4 @@
-from . import emit as emit, parse as parse, dialects as dialects
+from . import emit as emit, parse as parse, passes as passes, dialects as dialects
 from .groups import main as main
 from ._wrappers import (
     h as h,

bloqade/stim/dialects/auxiliary/stmts/const.py

@@ -47,7 +47,7 @@ class ConstFloat(ir.Statement):
 
 @statement(dialect=dialect)
 class ConstBool(ir.Statement):
-    """IR Statement representing a constant float value."""
+    """IR Statement representing a constant boolean value."""
 
     name = "constant.bool"
     traits = frozenset({ir.Pure(), ir.ConstantLike(), lowering.FromPythonCall()})

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

@@ -1,4 +1,10 @@
 from .pp import SPP as SPP
+from .base import (
+    Gate as Gate,
+    TwoQubitGate as TwoQubitGate,
+    SingleQubitGate as SingleQubitGate,
+    ControlledTwoQubitGate as ControlledTwoQubitGate,
+)
 from .control_2q import CX as CX, CY as CY, CZ as CZ
 from .clifford_1q import (
     H as H,

bloqade/stim/passes/__init__.py

@@ -0,0 +1 @@
+from .squin_to_stim import SquinToStim as SquinToStim

bloqade/stim/passes/squin_to_stim.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+
+from kirin.passes import Fold
+from kirin.rewrite import (
+    Walk,
+    Chain,
+    Fixpoint,
+    DeadCodeElimination,
+    CommonSubexpressionElimination,
+)
+from kirin.ir.method import Method
+from kirin.passes.abc import Pass
+from kirin.rewrite.abc import RewriteResult
+
+from bloqade.stim.groups import main as stim_main_group
+from bloqade.stim.rewrite import (
+    SquinWireToStim,
+    PyConstantToStim,
+    SquinQubitToStim,
+    SquinMeasureToStim,
+    SquinWireIdentityElimination,
+)
+from bloqade.squin.rewrite import RemoveDeadRegister
+
+
+@dataclass
+class SquinToStim(Pass):
+
+    def unsafe_run(self, mt: Method) -> RewriteResult:
+        fold_pass = Fold(mt.dialects)
+        # propagate constants
+        rewrite_result = fold_pass(mt)
+
+        # Assume that address analysis and
+        # wrapping has been done before this pass!
+
+        # Wrap Rewrite + SquinToStim can happen w/ standard walk
+        rewrite_result = (
+            Walk(
+                Chain(
+                    SquinQubitToStim(),
+                    SquinWireToStim(),
+                    SquinMeasureToStim(),  # reduce duplicated logic, can split out even more rules later
+                    SquinWireIdentityElimination(),
+                )
+            )
+            .rewrite(mt.code)
+            .join(rewrite_result)
+        )
+
+        # Convert all PyConsts to Stim Constants
+        rewrite_result = (
+            Walk(Chain(PyConstantToStim())).rewrite(mt.code).join(rewrite_result)
+        )
+
+        # remove any squin.qubit.new that's left around
+        ## Not considered pure so DCE won't touch it but
+        ## it isn't being used anymore considering everything is a
+        ## stim dialect statement
+        rewrite_result = (
+            Fixpoint(
+                Walk(
+                    Chain(
+                        DeadCodeElimination(),
+                        CommonSubexpressionElimination(),
+                        RemoveDeadRegister(),
+                    )
+                )
+            )
+            .rewrite(mt.code)
+            .join(rewrite_result)
+        )
+
+        # do program verification here,
+        # ideally use built-in .verify() to catch any
+        # incompatible statements as the full rewrite process should not
+        # leave statements from any other dialects (other than the stim main group)
+        mt_verification_clone = mt.similar(stim_main_group)
+
+        # suggested by Kai, will work for now
+        for stmt in mt_verification_clone.code.walk():
+            assert (
+                stmt.dialect in stim_main_group
+            ), "Statements detected that are not part of the stim dialect, please verify the original code is valid for rewrite!"
+
+        return rewrite_result

bloqade/stim/rewrite/__init__.py

@@ -0,0 +1,7 @@
+from .wire_to_stim import SquinWireToStim as SquinWireToStim
+from .qubit_to_stim import SquinQubitToStim as SquinQubitToStim
+from .squin_measure import SquinMeasureToStim as SquinMeasureToStim
+from .py_constant_to_stim import PyConstantToStim as PyConstantToStim
+from .wire_identity_elimination import (
+    SquinWireIdentityElimination as SquinWireIdentityElimination,
+)

bloqade/stim/rewrite/py_constant_to_stim.py

@@ -0,0 +1,42 @@
+from kirin import ir
+from kirin.dialects import py
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from bloqade.stim.dialects import auxiliary
+
+# py.constant.int -> stim.const.ConstInt
+# py.constant.float -> stimt.const.ConstFloat
+# py.constant -> stim.const.ConstBool
+#
+
+
+class PyConstantToStim(RewriteRule):
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+
+        match node:
+            case py.constant.Constant():
+                return self.rewrite_PyConstant(node)
+            case _:
+                return RewriteResult()
+
+    def rewrite_PyConstant(self, node: py.constant.Constant) -> RewriteResult:
+
+        # node.value is a PyAttr, need to get the
+        # wrapped value out
+        wrapped_value = node.value.unwrap()
+
+        if isinstance(wrapped_value, int):
+            stim_const = auxiliary.ConstInt(value=wrapped_value)
+        elif isinstance(wrapped_value, float):
+            stim_const = auxiliary.ConstFloat(value=wrapped_value)
+        elif isinstance(wrapped_value, bool):
+            stim_const = auxiliary.ConstBool(value=wrapped_value)
+        elif isinstance(wrapped_value, str):
+            stim_const = auxiliary.ConstStr(value=wrapped_value)
+        else:
+            return RewriteResult()
+
+        node.replace_by(stim_const)
+
+        return RewriteResult(has_done_something=True)

bloqade/{squin → stim}/rewrite/qubit_to_stim.py

@@ -2,8 +2,9 @@ from kirin import ir
 from kirin.rewrite.abc import RewriteRule, RewriteResult
 
 from bloqade.squin import op, qubit
-from bloqade.squin.rewrite.wrap_analysis import AddressAttribute
-from bloqade.squin.rewrite.stim_rewrite_util import (
+from bloqade.squin.rewrite import AddressAttribute
+from bloqade.stim.dialects import gate
+from bloqade.stim.rewrite.util import (
     SQUIN_STIM_GATE_MAPPING,
     rewrite_Control,
     insert_qubit_idx_from_address,
@@ -34,6 +35,15 @@ class SquinQubitToStim(RewriteRule):
         if isinstance(applied_op, op.stmts.Control):
             return rewrite_Control(stmt)
 
+        # check if its adjoint, assume its canonicalized so no nested adjoints.
+        is_conj = False
+        if isinstance(applied_op, op.stmts.Adjoint):
+            if not applied_op.is_unitary:
+                return RewriteResult()
+
+            is_conj = True
+            applied_op = applied_op.op.owner
+
         # need to handle Control through separate means
         # but we can handle X, Y, Z, H, and S here just fine
         stim_1q_op = SQUIN_STIM_GATE_MAPPING.get(type(applied_op))
@@ -41,9 +51,11 @@ class SquinQubitToStim(RewriteRule):
             return RewriteResult()
 
         address_attr = stmt.qubits.hints.get("address")
+
         if address_attr is None:
             return RewriteResult()
 
+        # sometimes you can get a whole AddressReg...
         assert isinstance(address_attr, AddressAttribute)
         qubit_idx_ssas = insert_qubit_idx_from_address(
             address=address_attr, stmt_to_insert_before=stmt
@@ -52,7 +64,10 @@ class SquinQubitToStim(RewriteRule):
         if qubit_idx_ssas is None:
             return RewriteResult()
 
-        stim_1q_stmt = stim_1q_op(targets=tuple(qubit_idx_ssas))
+        if isinstance(stim_1q_op, gate.stmts.Gate):
+            stim_1q_stmt = stim_1q_op(targets=tuple(qubit_idx_ssas), dagger=is_conj)
+        else:
+            stim_1q_stmt = stim_1q_op(targets=tuple(qubit_idx_ssas))
         stmt.replace_by(stim_1q_stmt)
 
         return RewriteResult(has_done_something=True)

bloqade/{squin → stim}/rewrite/squin_measure.py

@@ -4,9 +4,9 @@ from kirin.dialects import py
 from kirin.rewrite.abc import RewriteRule, RewriteResult
 
 from bloqade.squin import wire, qubit
+from bloqade.squin.rewrite import AddressAttribute
 from bloqade.stim.dialects import collapse
-from bloqade.squin.rewrite.wrap_analysis import AddressAttribute
-from bloqade.squin.rewrite.stim_rewrite_util import (
+from bloqade.stim.rewrite.util import (
     is_measure_result_used,
     insert_qubit_idx_from_address,
 )

bloqade/{squin/rewrite/stim_rewrite_util.py → stim/rewrite/util.py}

@@ -3,9 +3,9 @@ from kirin.dialects import py
 from kirin.rewrite.abc import RewriteResult
 
 from bloqade.squin import op, wire, qubit
+from bloqade.squin.rewrite import AddressAttribute
 from bloqade.stim.dialects import gate, collapse
-from bloqade.analysis.address import AddressWire, AddressQubit, AddressTuple
-from bloqade.squin.rewrite.wrap_analysis import AddressAttribute
+from bloqade.analysis.address import AddressReg, AddressWire, AddressQubit, AddressTuple
 
 SQUIN_STIM_GATE_MAPPING = {
     op.stmts.X: gate.X,
@@ -13,10 +13,28 @@ SQUIN_STIM_GATE_MAPPING = {
     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 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,
+}
+
+
+def create_and_insert_qubit_idx_stmt(
+    qubit_idx, stmt_to_insert_before: ir.Statement, qubit_idx_ssas: list
+):
+    qubit_idx_stmt = py.Constant(qubit_idx)
+    qubit_idx_stmt.insert_before(stmt_to_insert_before)
+    qubit_idx_ssas.append(qubit_idx_stmt.result)
+
 
 def insert_qubit_idx_from_address(
     address: AddressAttribute, stmt_to_insert_before: ir.Statement
@@ -31,16 +49,23 @@ def insert_qubit_idx_from_address(
         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)
+            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
+            )
+    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
-        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)
+        create_and_insert_qubit_idx_stmt(
+            address_qubit.data, stmt_to_insert_before, qubit_idx_ssas
+        )
     else:
         return
 
@@ -119,13 +144,7 @@ def rewrite_Control(
     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))
+    stim_gate = SQUIN_STIM_CONTROL_GATE_MAPPING.get(type(ctrl_op_target_gate))
     if stim_gate is None:
         return RewriteResult()
 

bloqade/{squin → stim}/rewrite/wire_to_stim.py

@@ -2,7 +2,7 @@ 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 (
+from bloqade.stim.rewrite.util import (
     SQUIN_STIM_GATE_MAPPING,
     rewrite_Control,
     insert_qubit_idx_from_wire_ssa,

{bloqade_circuit-0.4.3.dist-info → bloqade_circuit-0.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.4.3
+Version: 0.4.5
 Summary: The software development toolkit for neutral atom arrays.
 Author-email: Roger-luo <rluo@quera.com>, kaihsin <khwu@quera.com>, weinbe58 <pweinberg@quera.com>, johnzl-777 <jlong@quera.com>
 License-File: LICENSE

{bloqade_circuit-0.4.3.dist-info → bloqade_circuit-0.4.5.dist-info}/RECORD

@@ -115,39 +115,35 @@ bloqade/squin/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 bloqade/squin/analysis/schedule.py,sha256=buuC4bFuLuaSDK2BZfkRkh8ZdNicz9HkEv3FAnsDViE,7880
 bloqade/squin/analysis/nsites/__init__.py,sha256=RlQg7ivczXCXG5lMeL3ipYKj2oJKC4THu8orYf5PBYs,263
 bloqade/squin/analysis/nsites/analysis.py,sha256=rIe1RU1MZRItcE2aB8DYahLrv73HfD3IHCX3E_EGQ1c,1773
-bloqade/squin/analysis/nsites/impls.py,sha256=OaKuAoZ0EAorStYDZxzgc6Dk42kuj19MLkqHWG1MEQM,2592
+bloqade/squin/analysis/nsites/impls.py,sha256=Q2buVBmUX1ghj48_SoMO-_0BASGkfnILZZOOFRnwzIQ,2772
 bloqade/squin/analysis/nsites/lattice.py,sha256=ruh0808SHtj3ecuT-C3AZTsLY2j3DRhtezGiTZvcuVs,942
-bloqade/squin/cirq/__init__.py,sha256=AptJlelH-KJoFKLnq6phq68SrV785zWzi2NOfLH62ms,5994
-bloqade/squin/cirq/lowering.py,sha256=4-kZFH_qbBbV-c3-C9KhIB5o_cp_D8oxJrS8KicD_A8,14382
+bloqade/squin/cirq/__init__.py,sha256=fxvBvwX5VNfDmqkeM4GHguLQh53k-PJVsz89Eu0wRXw,8552
+bloqade/squin/cirq/lowering.py,sha256=ZrdulFJgzuOJHunCmPn9mpUEO1U2xq4gDTTNgSA4cSU,14914
 bloqade/squin/cirq/emit/emit_circuit.py,sha256=7puJ3eCFwE9VdPb9NAiSdyRNkoQPwo_uVykz9Yv7c14,3761
+bloqade/squin/cirq/emit/noise.py,sha256=rESjGC_66s2Y4FwwYda4rY3mYHYjbqLlKE_vnqpZDYI,1534
 bloqade/squin/cirq/emit/op.py,sha256=z54NP5KqMxffXeFGWamEzvunpTNrxmYuluurk4j2-ps,4000
 bloqade/squin/cirq/emit/qubit.py,sha256=Z2HUsZmJ5F2uHCPGru81ux2usoX77KwtS97_cgeJRMI,1910
-bloqade/squin/cirq/emit/runtime.py,sha256=6_oHod-WK5yv0ae9xziQn-eh4Hn3MZNNqu4kJtOzPeY,6543
+bloqade/squin/cirq/emit/runtime.py,sha256=dH7JSMt2mALPhVFjmZETQzvnTUQ3BFY5poe0YZpM5vQ,6819
 bloqade/squin/noise/__init__.py,sha256=HQl3FE0SZAGEX3qdveapCaMX391lgLvWeWnoE6Z2pYw,332
 bloqade/squin/noise/_dialect.py,sha256=2IR98J-lXm5Y3srP9g-FD4JC-qTq2seureM6mKKq1xg,63
-bloqade/squin/noise/_wrapper.py,sha256=0jD5va_go9jEW5rC6bZSWU30kjCha2-axFogPON3-V0,580
-bloqade/squin/noise/rewrite.py,sha256=SxIHgMDqYJXepiZDyukHWpe5yaFDSTG-yJ4JONNVr0o,3917
+bloqade/squin/noise/_wrapper.py,sha256=b2HymlFi1BTgAZRaXvRnujJsoXkowmxQFPRBgZso82g,750
+bloqade/squin/noise/rewrite.py,sha256=-IqFfDGnhuaFI-9b6PXjhSuiXFM1C5Qu0ibL5GvZldI,3917
 bloqade/squin/noise/stmts.py,sha256=rktxkIdjdPUYek0MYh9uh83otkl-7UoADCoWHWf57J8,1678
-bloqade/squin/op/__init__.py,sha256=5OBgT4E44Cy0DNF3yRbXGXkiB8VAJtr48x8hDQEquH4,741
+bloqade/squin/op/__init__.py,sha256=QLlvZlb2nDq-RTalRp7xe0v82YgXURsvyovvMA6j2mw,807
 bloqade/squin/op/_dialect.py,sha256=66G1IYqmsqUEaCTyUqn2shSHmGYduiTU8GfDXcoMvw4,55
-bloqade/squin/op/_wrapper.py,sha256=5pqbKGeNWoYQIPa1xkKBr8z5waxwmAm3AV4efGSRT_s,1714
+bloqade/squin/op/_wrapper.py,sha256=rmQHXjRHFEr-bATbKEKL30w1wlDB7vmrQzDDRoLhRVw,1866
 bloqade/squin/op/number.py,sha256=yujWUqLrOAr8i8OBDsiS5M882wV7t08u345NgNA6TUc,95
 bloqade/squin/op/rewrite.py,sha256=Itxz_hTAPNLyLYeLS0PCVk143J1Z558UR7N9-urbnoU,1327
 bloqade/squin/op/stdlib.py,sha256=4UFK3wKImpums2v5a9OFKuVvz2TLYbYwidg3JYYEi2o,1073
-bloqade/squin/op/stmts.py,sha256=uBQeCWc1JjMTIVcssWkLWi6MyTLtQMoqTWoKgLsYgWQ,5262
+bloqade/squin/op/stmts.py,sha256=atPrr12Bc7D5xu_xavVgME3FBNqHQXQSAtMuh7xL0Dw,5491
 bloqade/squin/op/traits.py,sha256=jjsnzWtPtmQK7K3H_D2fvc8XiW1Y3EMBcgeyPax2sjc,1065
 bloqade/squin/op/types.py,sha256=ozUT0Bv9NuUxPjB2vAeqJ9cpdvUaBfP9trB5mybYxgc,663
-bloqade/squin/passes/__init__.py,sha256=Bhog-wZBtToNJXfhlYa6S7tE6OoppyRibjMl5JBfY58,45
-bloqade/squin/passes/stim.py,sha256=VWv3hhfizCWz5sIwwdFt3flWHLzG428evLGIcX8E36Y,1992
-bloqade/squin/rewrite/__init__.py,sha256=0-9m1cbvFRgjZpQ700NEjW1uKvwZPPbrmUwylhgOjUw,457
+bloqade/squin/rewrite/U3_to_clifford.py,sha256=HpkFTqe-J0macb_aNs1QNs8wJDoUsmwf9Mtb0I3ZepI,5377
+bloqade/squin/rewrite/__init__.py,sha256=mxP01A2IeOT5HKHKBRRMCIPN4BPKfpYSlQkSjY78ugQ,282
 bloqade/squin/rewrite/desugar.py,sha256=fnxchVHIbLx96cv-g_jK7NCVV8t8mo52rs00JaPG7FM,1846
-bloqade/squin/rewrite/qubit_to_stim.py,sha256=fZC9voSAgjNwZv4wYdJ1Qkd55049n8rc7gpujvdQHEc,1976
-bloqade/squin/rewrite/squin_measure.py,sha256=E5HVkLaBcsT-4dy1MN3BjdkOmqXzeTO4clZcwKRd66k,2494
-bloqade/squin/rewrite/stim_rewrite_util.py,sha256=y6CsosZXgAXc0enWPcRUt1uwxm09LBoR6mvl2Y5bHbs,5161
-bloqade/squin/rewrite/wire_identity_elimination.py,sha256=Cscu8yaSslPuW04HvbXx4HJ3JzdUZNUMyFqcvuc4sxY,795
-bloqade/squin/rewrite/wire_to_stim.py,sha256=PbXjwaF-Z2JioXALKx76uGkYr6-xy20zZFotPeDX-lY,1699
-bloqade/squin/rewrite/wrap_analysis.py,sha256=OoKoS0zFLjfCnn4_fK4bgpQ_ueAEiHl1UmfNWhruxMc,2069
-bloqade/stim/__init__.py,sha256=BbMeLjeIW29xuD6JB0cWG_g0qaYIy4xXbloDqvqbT7A,887
+bloqade/squin/rewrite/remove_dangling_qubits.py,sha256=iTuWV-03YW5wtYbSeKMlnnWjNzDj9SmflyqYPgoYGy8,469
+bloqade/squin/rewrite/wrap_analysis.py,sha256=JUPS4OAYbDHOK0VIrdz1pprSizISUfN7osuoP_P-bIo,2256
+bloqade/stim/__init__.py,sha256=-TkpVoISvZ-HERL2LJfIMHs3Y4k-WdrGWM-_Rwe9q0o,905
 bloqade/stim/_wrappers.py,sha256=KBIIOaeYPnhR3SJSNHcEzihLMcph2tL2mRKhEH47Je8,3939
 bloqade/stim/groups.py,sha256=Fx8G698BGO7hR8OwpPXGUEYdW4uCCPwbMp_3fJAqa8M,585
 bloqade/stim/dialects/__init__.py,sha256=A1Sq0jg8wi6MjRkzmuSBnHmO3EraD0pDFWz-dO6c6v8,89
@@ -159,7 +155,7 @@ bloqade/stim/dialects/auxiliary/lowering.py,sha256=4dxRZHGp_18EMVlYuZQFSzg4MIOBr
 bloqade/stim/dialects/auxiliary/types.py,sha256=1l2YdJ-u9y0wpBfxh4OAlvmRAUnrmcDjDagoW2GyVaQ,314
 bloqade/stim/dialects/auxiliary/stmts/__init__.py,sha256=VxLBnqlZngabs5vn3PiRNRXBBDueTCTmJ2wgWEertrA,371
 bloqade/stim/dialects/auxiliary/stmts/annotate.py,sha256=NZT4AAW0lmwyHR31cmZI8aQNRsp5soeE36s9nBrcOmU,1759
-bloqade/stim/dialects/auxiliary/stmts/const.py,sha256=nfx2aFTPBTCfKriANbzDUWjP9wgnWC5Phkfl2aUPyXY,3296
+bloqade/stim/dialects/auxiliary/stmts/const.py,sha256=nxcpVylgjfKt8pDkcMzVBMGLjON2bQb99WSLv7frvkI,3298
 bloqade/stim/dialects/collapse/__init__.py,sha256=MhlEWJR_mJI3teoip1N8MlHk2C68seJELXwmyjyx_ns,305
 bloqade/stim/dialects/collapse/_dialect.py,sha256=F5uplH7WL9ZQatEp0ZMvgLWX1k9moAWW879LTNwnHH0,60
 bloqade/stim/dialects/collapse/emit_str.py,sha256=4Vlhtq8BKMMuZLQ-ayUGJTuOs4YJ1rGurPZBZxBQJcU,1879
@@ -170,7 +166,7 @@ bloqade/stim/dialects/collapse/stmts/reset.py,sha256=4fPSdM_ZiivuUn4uiZGiZQ9swol
 bloqade/stim/dialects/gate/__init__.py,sha256=5Y0BTlLOuW-Ud4LwAC_CUuMwxa04LKj4CTKgQbiL8yg,347
 bloqade/stim/dialects/gate/_dialect.py,sha256=78_dThliFZG9xSwYhTdibxP3vefHpEDUawtZqb9X3uA,56
 bloqade/stim/dialects/gate/emit.py,sha256=HGnko9_nV6jl0kOI_dBWWNQDjySo14jAFBsg-2lTVOU,2869
-bloqade/stim/dialects/gate/stmts/__init__.py,sha256=QJgmpArJwM9TXgB95AsEvet630gITtYOwRptnhj9a8U,293
+bloqade/stim/dialects/gate/stmts/__init__.py,sha256=TbXjWYfCbZNuGEehvtF75LELLJJo_GzoXWRnuVZphv8,461
 bloqade/stim/dialects/gate/stmts/base.py,sha256=MK7Zu-Kys_64O0nXAkPzlHEnWYevBGm3FRHhJw33rrE,748
 bloqade/stim/dialects/gate/stmts/clifford_1q.py,sha256=Sj1Nf9AA_WWazGTg5kzFRTaLRIj3Edj657j0B8dybdI,896
 bloqade/stim/dialects/gate/stmts/clifford_2q.py,sha256=cb3BVSkOt5SiRq4D4WkbuUbEouK3MwDxQIhAF0cvZbo,239
@@ -184,6 +180,15 @@ bloqade/stim/emit/__init__.py,sha256=N2dPQY7OyqPwHAStDeOgYg2yfxqxMOz-N7pD5Z4JwlI
 bloqade/stim/emit/stim_str.py,sha256=JyEBoIhLQASogZcUWHI9tMD4JoXYrEqUr2qaZ30gZdc,1491
 bloqade/stim/parse/__init__.py,sha256=l2DjReB2KkgrDjP_4nP6RnoziiOewoSeZfTno1sVYTw,59
 bloqade/stim/parse/lowering.py,sha256=L-IcR_exlxsTVv4SQ0bhzIF4_L82P-GEdK6qRd6B86Y,23723
+bloqade/stim/passes/__init__.py,sha256=KAWJPhZHf0cVDmr9o9LNRfZU8G9aS4adGC4EC7ci_E8,54
+bloqade/stim/passes/squin_to_stim.py,sha256=4CSWAevECGxYgtojzlH92YwRUlz_lDtedWNEylXKd0A,2752
+bloqade/stim/rewrite/__init__.py,sha256=S2sKUKtX4EGofhZRbewvyHN5s-CavPzseYufij3R5SQ,372
+bloqade/stim/rewrite/py_constant_to_stim.py,sha256=PV8bHvn759-d_0JW4akaGSORW_oxigrlUBhAC51PJAU,1354
+bloqade/stim/rewrite/qubit_to_stim.py,sha256=VggIAS6EQ4a01YplDGJUMDpQ_q-UYD8C4g1xMC_zbcY,2509
+bloqade/stim/rewrite/squin_measure.py,sha256=1X3rcfGvVDSEXmvqlw4T0LQu2A8LFeNeqz1_zf_I8vA,2466
+bloqade/stim/rewrite/util.py,sha256=vpBbTv00odpnnyHTMJZRStb1ZQYfcgbOW5PT5Frf4jw,5847
+bloqade/stim/rewrite/wire_identity_elimination.py,sha256=Cscu8yaSslPuW04HvbXx4HJ3JzdUZNUMyFqcvuc4sxY,795
+bloqade/stim/rewrite/wire_to_stim.py,sha256=vHtktd9pfjlEpInwN7pPhsIHCxTtHJJqJJhYpy0kIGg,1685
 bloqade/visual/__init__.py,sha256=Y7d0YgovKhUFzjMeDvt0wGRUZ3re3SY6iO3e8xHXrr4,37
 bloqade/visual/animation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bloqade/visual/animation/animate.py,sha256=NSKs3YDWgTZH2-Tpx3cP1bBcIEWTEPqK5UFkY_IF_3k,8927
@@ -195,7 +200,7 @@ bloqade/visual/animation/runtime/atoms.py,sha256=EmjxhujLiHHPS_HtH_B-7TiqeHgvW5u
 bloqade/visual/animation/runtime/ppoly.py,sha256=JB9IP53N1w6adBJEue6J5Nmj818Id9JvrlgrmiQTU1I,1385
 bloqade/visual/animation/runtime/qpustate.py,sha256=rlmxQeJSvaohXrTpXQL5y-NJcpvfW33xPaYM1slv7cc,4270
 bloqade/visual/animation/runtime/utils.py,sha256=ju9IzOWX-vKwfpqUjlUKu3Ssr_UFPFFq-tzH_Nqyo_c,1212
-bloqade_circuit-0.4.3.dist-info/METADATA,sha256=ZBwC4D0_sLjDceh6og0S4tzzFghL5gTxP76QQrMsvv4,3683
-bloqade_circuit-0.4.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-bloqade_circuit-0.4.3.dist-info/licenses/LICENSE,sha256=S5GIJwR6QCixPA9wryYb44ZEek0Nz4rt_zLUqP05UbU,13160
-bloqade_circuit-0.4.3.dist-info/RECORD,,
+bloqade_circuit-0.4.5.dist-info/METADATA,sha256=8glVTUO-kiKWRlb-6bKJBAf--1A6rjOJgI6o1BJGL6w,3683
+bloqade_circuit-0.4.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+bloqade_circuit-0.4.5.dist-info/licenses/LICENSE,sha256=S5GIJwR6QCixPA9wryYb44ZEek0Nz4rt_zLUqP05UbU,13160
+bloqade_circuit-0.4.5.dist-info/RECORD,,

bloqade/squin/passes/__init__.py

@@ -1 +0,0 @@
-from .stim import SquinToStim as SquinToStim

bloqade/squin/passes/stim.py

@@ -1,68 +0,0 @@
-from dataclasses import dataclass
-
-from kirin.passes import Fold
-from kirin.rewrite import (
-    Walk,
-    Chain,
-    Fixpoint,
-    DeadCodeElimination,
-    CommonSubexpressionElimination,
-)
-from kirin.ir.method import Method
-from kirin.passes.abc import Pass
-from kirin.rewrite.abc import RewriteResult
-
-from bloqade.squin.rewrite import (
-    SquinWireToStim,
-    SquinQubitToStim,
-    WrapSquinAnalysis,
-    SquinMeasureToStim,
-    SquinWireIdentityElimination,
-)
-from bloqade.analysis.address import AddressAnalysis
-from bloqade.squin.analysis.nsites import (
-    NSitesAnalysis,
-)
-
-
-@dataclass
-class SquinToStim(Pass):
-
-    def unsafe_run(self, mt: Method) -> RewriteResult:
-        fold_pass = Fold(mt.dialects)
-        # propagate constants
-        rewrite_result = fold_pass(mt)
-
-        # Get necessary analysis results to plug into hints
-        address_analysis = AddressAnalysis(mt.dialects)
-        address_frame, _ = address_analysis.run_analysis(mt)
-        site_analysis = NSitesAnalysis(mt.dialects)
-        sites_frame, _ = site_analysis.run_analysis(mt)
-
-        # Wrap Rewrite + SquinToStim can happen w/ standard walk
-        rewrite_result = (
-            Walk(
-                Chain(
-                    WrapSquinAnalysis(
-                        address_analysis=address_frame.entries,
-                        op_site_analysis=sites_frame.entries,
-                    ),
-                    SquinQubitToStim(),
-                    SquinWireToStim(),
-                    SquinMeasureToStim(),  # reduce duplicated logic, can split out even more rules later
-                    SquinWireIdentityElimination(),
-                )
-            )
-            .rewrite(mt.code)
-            .join(rewrite_result)
-        )
-
-        rewrite_result = (
-            Fixpoint(
-                Walk(Chain(DeadCodeElimination(), CommonSubexpressionElimination()))
-            )
-            .rewrite(mt.code)
-            .join(rewrite_result)
-        )
-
-        return rewrite_result