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

bloqade/pyqrack/squin/op.py

@@ -96,10 +96,15 @@ class PyQrackMethods(interp.MethodTable):
         return (PhaseOpRuntime(theta, global_=global_),)
 
     @interp.impl(op.stmts.Reset)
+    @interp.impl(op.stmts.ResetToOne)
     def reset(
-        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Reset
+        self,
+        interp: PyQrackInterpreter,
+        frame: interp.Frame,
+        stmt: op.stmts.Reset | op.stmts.ResetToOne,
     ) -> tuple[OperatorRuntimeABC]:
-        return (ResetRuntime(),)
+        target_state = isinstance(stmt, op.stmts.ResetToOne)
+        return (ResetRuntime(target_state=target_state),)
 
     @interp.impl(op.stmts.X)
     @interp.impl(op.stmts.Y)

bloqade/pyqrack/squin/runtime.py

@@ -43,7 +43,9 @@ class OperatorRuntimeABC:
 
 @dataclass(frozen=True)
 class ResetRuntime(OperatorRuntimeABC):
-    """Reset the qubit to |0> state"""
+    """Reset the qubit to the target state"""
+
+    target_state: bool
 
     @property
     def n_sites(self) -> int:
@@ -55,7 +57,7 @@ class ResetRuntime(OperatorRuntimeABC):
                 continue
 
             res: bool = qubit.sim_reg.m(qubit.addr)
-            if res:
+            if res != self.target_state:
                 qubit.sim_reg.x(qubit.addr)
 
 

bloqade/qasm2/dialects/expr/stmts.py

@@ -1,34 +1,16 @@
 from kirin import ir, types, lowering
 from kirin.decl import info, statement
+from kirin.dialects import func
 from kirin.print.printer import Printer
-from kirin.dialects.func.attrs import Signature
 
 from ._dialect import dialect
 
 
-class GateFuncOpCallableInterface(ir.CallableStmtInterface["GateFunction"]):
-
-    @classmethod
-    def get_callable_region(cls, stmt: "GateFunction") -> ir.Region:
-        return stmt.body
-
-
 @statement(dialect=dialect)
-class GateFunction(ir.Statement):
+class GateFunction(func.Function):
     """Special Function for qasm2 gate subroutine."""
 
     name = "gate.func"
-    traits = frozenset(
-        {
-            ir.IsolatedFromAbove(),
-            ir.SymbolOpInterface(),
-            ir.HasSignature(),
-            GateFuncOpCallableInterface(),
-        }
-    )
-    sym_name: str = info.attribute()
-    signature: Signature = info.attribute()
-    body: ir.Region = info.region(multi=True)
 
     def print_impl(self, printer: Printer) -> None:
         with printer.rich(style="red"):

bloqade/qasm2/parse/lowering.py

@@ -36,6 +36,7 @@ class QASM2(lowering.LoweringABC[ast.Node]):
             file=file,
             lineno_offset=lineno_offset,
             col_offset=col_offset,
+            compactify=compactify,
         )
 
         return frame.curr_region

bloqade/qasm2/passes/parallel.py

@@ -26,6 +26,7 @@ from bloqade.qasm2.rewrite import (
     ParallelToUOpRule,
     RaiseRegisterRule,
     UOpToParallelRule,
+    ParallelToGlobalRule,
     SimpleOptimalMergePolicy,
     RydbergGateSetRewriteRule,
 )
@@ -183,3 +184,20 @@ class UOpToParallel(Pass):
             CommonSubexpressionElimination(),
         )
         return Fixpoint(Walk(rule)).rewrite(mt.code).join(result)
+
+
+@dataclass
+class ParallelToGlobal(Pass):
+
+    def generate_rule(self, mt: ir.Method) -> ParallelToGlobalRule:
+        address_analysis = address.AddressAnalysis(mt.dialects)
+        frame, _ = address_analysis.run_analysis(mt)
+        return ParallelToGlobalRule(frame.entries)
+
+    def unsafe_run(self, mt: ir.Method) -> abc.RewriteResult:
+        rule = self.generate_rule(mt)
+
+        result = Walk(rule).rewrite(mt.code)
+        result = Walk(DeadCodeElimination()).rewrite(mt.code).join(result)
+
+        return result

bloqade/qasm2/rewrite/__init__.py

@@ -11,5 +11,6 @@ from .uop_to_parallel import (
     SimpleGreedyMergePolicy as SimpleGreedyMergePolicy,
     SimpleOptimalMergePolicy as SimpleOptimalMergePolicy,
 )
+from .parallel_to_glob import ParallelToGlobalRule as ParallelToGlobalRule
 from .noise.remove_noise import RemoveNoisePass as RemoveNoisePass
 from .noise.heuristic_noise import NoiseRewriteRule as NoiseRewriteRule

bloqade/qasm2/rewrite/parallel_to_glob.py

@@ -0,0 +1,82 @@
+from typing import Dict
+from dataclasses import dataclass
+
+from kirin import ir
+from kirin.rewrite import abc
+from kirin.analysis import const
+from kirin.dialects import ilist
+
+from bloqade.analysis import address
+
+from ..dialects import core, glob, parallel
+
+
+@dataclass
+class ParallelToGlobalRule(abc.RewriteRule):
+    address_analysis: Dict[ir.SSAValue, address.Address]
+
+    def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
+        if not isinstance(node, parallel.UGate):
+            return abc.RewriteResult()
+
+        qargs = node.qargs
+        qarg_addresses = self.address_analysis.get(qargs, None)
+
+        if isinstance(qarg_addresses, address.AddressReg):
+            # NOTE: we only have an AddressReg if it's an entire register, definitely rewrite that
+            return self._rewrite_parallel_to_glob(node)
+
+        if not isinstance(qarg_addresses, address.AddressTuple):
+            return abc.RewriteResult()
+
+        idxs, qreg = self._find_qreg(qargs.owner, set())
+
+        if qreg is None:
+            # NOTE: no unique register found
+            return abc.RewriteResult()
+
+        if not isinstance(hint := qreg.n_qubits.hints.get("const"), const.Value):
+            # NOTE: non-constant number of qubits
+            return abc.RewriteResult()
+
+        n = hint.data
+        if len(idxs) != n:
+            # NOTE: not all qubits of the register are there
+            return abc.RewriteResult()
+
+        return self._rewrite_parallel_to_glob(node)
+
+    @staticmethod
+    def _rewrite_parallel_to_glob(node: parallel.UGate) -> abc.RewriteResult:
+        theta, phi, lam = node.theta, node.phi, node.lam
+        global_u = glob.UGate(node.qargs, theta=theta, phi=phi, lam=lam)
+        node.replace_by(global_u)
+        return abc.RewriteResult(has_done_something=True)
+
+    @staticmethod
+    def _find_qreg(
+        qargs_owner: ir.Statement | ir.Block, idxs: set
+    ) -> tuple[set, core.stmts.QRegNew | None]:
+
+        if isinstance(qargs_owner, core.stmts.QRegGet):
+            idxs.add(qargs_owner.idx)
+            qreg = qargs_owner.reg.owner
+            if not isinstance(qreg, core.stmts.QRegNew):
+                # NOTE: this could potentially be casted
+                qreg = None
+            return idxs, qreg
+
+        if isinstance(qargs_owner, ilist.New):
+            vals = qargs_owner.values
+            if len(vals) == 0:
+                return idxs, None
+
+            idxs, first_qreg = ParallelToGlobalRule._find_qreg(vals[0].owner, idxs)
+            for val in vals[1:]:
+                idxs, qreg = ParallelToGlobalRule._find_qreg(val.owner, idxs)
+                if qreg != first_qreg:
+                    return idxs, None
+
+            return idxs, first_qreg
+
+        return idxs, None

bloqade/squin/__init__.py

@@ -4,6 +4,7 @@ from . import (
     noise as noise,
     qubit as qubit,
     lowering as lowering,
+    _typeinfer as _typeinfer,
 )
 from .groups import wired as wired, kernel as kernel
 

bloqade/squin/_typeinfer.py

@@ -0,0 +1,20 @@
+from kirin import types, interp
+from kirin.analysis import TypeInference, const
+from kirin.dialects import ilist
+
+from bloqade import squin
+
+
+@squin.qubit.dialect.register(key="typeinfer")
+class TypeInfer(interp.MethodTable):
+    @interp.impl(squin.qubit.New)
+    def _call(self, interp: TypeInference, frame: interp.Frame, stmt: squin.qubit.New):
+        # based on Xiu-zhe (Roger) Luo's get_const_value function
+
+        if (hint := stmt.n_qubits.hints.get("const")) is None:
+            return (ilist.IListType[squin.qubit.QubitType, types.Any],)
+
+        if isinstance(hint, const.Value) and isinstance(hint.data, int):
+            return (ilist.IListType[squin.qubit.QubitType, types.Literal(hint.data)],)
+
+        return (ilist.IListType[squin.qubit.QubitType, types.Any],)

bloqade/squin/analysis/nsites/impls.py

@@ -1,5 +1,5 @@
 from kirin import interp
-from kirin.dialects import scf
+from kirin.dialects import scf, func
 from kirin.dialects.scf.typeinfer import TypeInfer as ScfTypeInfer
 
 from bloqade.squin import op, wire
@@ -85,3 +85,8 @@ class SquinOp(interp.MethodTable):
 @scf.dialect.register(key="op.nsites")
 class ScfSquinOp(ScfTypeInfer):
     pass
+
+
+@func.dialect.register(key="op.nsites")
+class FuncSquinOp(func.typeinfer.TypeInfer):
+    pass

bloqade/squin/cirq/lowering.py

@@ -368,11 +368,24 @@ class Squin(lowering.LoweringABC[CirqNode]):
         state: lowering.State[CirqNode],
         node: cirq.GeneralizedAmplitudeDampingChannel,
     ):
-        raise NotImplementedError("TODO: needs a new operator statement")
-        # p = state.current_frame.push(py.Constant(node.p))
-        # gamma = state.current_frame.push(py.Constant(node.gamma))
+        p = state.current_frame.push(py.Constant(node.p)).result
+        gamma = state.current_frame.push(py.Constant(node.gamma)).result
 
-        # p1 =
+        # NOTE: cirq has a weird convention here: if p == 1, we have AmplitudeDampingChannel,
+        # which basically means p is the probability of the environment being in the vacuum state
+        prob0 = state.current_frame.push(py.binop.Mult(p, gamma)).result
+        one_ = state.current_frame.push(py.Constant(1)).result
+        p_minus_1 = state.current_frame.push(py.binop.Sub(one_, p)).result
+        prob1 = state.current_frame.push(py.binop.Mult(p_minus_1, gamma)).result
 
-        # x = state.current_frame.push(op.stmts.X())
-        # noise_channel1 = noise.stmts.PauliError(basis=x.result, p=)
+        r0 = state.current_frame.push(op.stmts.Reset()).result
+        r1 = state.current_frame.push(op.stmts.ResetToOne()).result
+
+        probs = state.current_frame.push(ilist.New(values=(prob0, prob1))).result
+        ops = state.current_frame.push(ilist.New(values=(r0, r1))).result
+
+        noise_channel = state.current_frame.push(
+            noise.stmts.StochasticUnitaryChannel(probabilities=probs, operators=ops)
+        )
+
+        return noise_channel

bloqade/squin/op/__init__.py

@@ -37,4 +37,5 @@ from ._wrapper import (
     control as control,
     identity as identity,
     pauli_string as pauli_string,
+    reset_to_one as reset_to_one,
 )

bloqade/squin/op/_wrapper.py

@@ -41,6 +41,10 @@ def control(op: types.Op, *, n_controls: int) -> types.Op:
 def reset() -> types.Op: ...
 
 
+@wraps(stmts.ResetToOne)
+def reset_to_one() -> types.Op: ...
+
+
 @wraps(stmts.Identity)
 def identity(*, sites: int) -> types.Op: ...
 

bloqade/squin/op/stmts.py

@@ -98,6 +98,15 @@ class ConstantUnitary(ConstantOp):
 
 @statement(dialect=dialect)
 class U3(PrimitiveOp):
+    """
+    The rotation operator U3(theta, phi, lam).
+    Note that we use the convention from the QASM2 specification, namely
+
+    $$
+    U_3(\theta, \phi, \lambda) = R_z(\phi) R_y(\theta) R_z(\lambda)
+    $$
+    """
+
     traits = frozenset({ir.Pure(), lowering.FromPythonCall(), Unitary(), FixedSites(1)})
     theta: ir.SSAValue = info.argument(types.Float)
     phi: ir.SSAValue = info.argument(types.Float)
@@ -110,7 +119,7 @@ class PhaseOp(PrimitiveOp):
     A phase operator.
 
     $$
-    PhaseOp(theta) = e^{i \theta} I
+    PhaseOp(\theta) = e^{i \theta} I
     $$
     """
 
@@ -124,7 +133,7 @@ class ShiftOp(PrimitiveOp):
     A phase shift operator.
 
     $$
-    Shift(theta) = \\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i \\theta} \\end{bmatrix}
+    Shift(\theta) = \\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i \\theta} \\end{bmatrix}
     $$
     """
 
@@ -141,6 +150,15 @@ class Reset(PrimitiveOp):
     traits = frozenset({ir.Pure(), lowering.FromPythonCall(), FixedSites(1)})
 
 
+@statement(dialect=dialect)
+class ResetToOne(PrimitiveOp):
+    """
+    Reset qubits to the one state. Mainly needed to accommodate cirq's GeneralizedAmplitudeDampingChannel
+    """
+
+    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), FixedSites(1)})
+
+
 @statement
 class CliffordOp(ConstantUnitary):
     pass

bloqade/squin/qubit.py

@@ -17,6 +17,7 @@ from kirin.lowering import wraps
 from bloqade.types import Qubit, QubitType
 from bloqade.squin.op.types import Op, OpType
 
+from .types import MeasurementResult, MeasurementResultType
 from .lowering import ApplyAnyCallLowering
 
 dialect = ir.Dialect("squin.qubit")
@@ -65,8 +66,8 @@ class MeasureQubit(ir.Statement):
     name = "measure.qubit"
 
     traits = frozenset({lowering.FromPythonCall()})
-    qubit: ir.SSAValue = info.argument(ilist.IListType[QubitType])
-    result: ir.ResultValue = info.result(ilist.IListType[types.Bool])
+    qubit: ir.SSAValue = info.argument(QubitType)
+    result: ir.ResultValue = info.result(MeasurementResultType)
 
 
 @statement(dialect=dialect)
@@ -75,7 +76,7 @@ class MeasureQubitList(ir.Statement):
 
     traits = frozenset({lowering.FromPythonCall()})
     qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType])
-    result: ir.ResultValue = info.result(ilist.IListType[types.Bool])
+    result: ir.ResultValue = info.result(ilist.IListType[MeasurementResultType])
 
 
 # NOTE: no dependent types in Python, so we have to mark it Any...
@@ -131,9 +132,11 @@ def apply(operator: Op, *qubits) -> None: ...
 
 
 @overload
-def measure(input: Qubit) -> bool: ...
+def measure(input: Qubit) -> MeasurementResult: ...
 @overload
-def measure(input: ilist.IList[Qubit, Any] | list[Qubit]) -> ilist.IList[bool, Any]: ...
+def measure(
+    input: ilist.IList[Qubit, Any] | list[Qubit],
+) -> ilist.IList[MeasurementResult, Any]: ...
 
 
 @wraps(MeasureAny)

bloqade/squin/rewrite/__init__.py

@@ -4,4 +4,5 @@ from .wrap_analysis import (
     WrapOpSiteAnalysis as WrapOpSiteAnalysis,
     WrapAddressAnalysis as WrapAddressAnalysis,
 )
+from .U3_to_clifford import SquinU3ToClifford as SquinU3ToClifford
 from .remove_dangling_qubits import RemoveDeadRegister as RemoveDeadRegister

bloqade/squin/rewrite/canonicalize.py

@@ -0,0 +1,60 @@
+from typing import cast
+
+from kirin import ir
+from kirin.rewrite import abc
+from kirin.dialects import cf
+
+from .. import wire
+
+
+class CanonicalizeWired(abc.RewriteRule):
+    def rewrite_Statement(self, node: ir.Statement) -> abc.RewriteResult:
+
+        if (
+            not isinstance(node, wire.Wired)
+            or len(node.qubits) != 0
+            or (parent_region := node.parent_region) is None
+        ):
+            return abc.RewriteResult()
+
+        parent_block = cast(ir.Block, node.parent_block)
+
+        # the body doesn't contain any quantum operations so we can safely inline the
+        # body into the parent block
+
+        # move all statements after `node` in the current block into another block
+        after_block = ir.Block()
+
+        stmt = node.next_stmt
+        while stmt is not None:
+            stmt.detach()
+            after_block.stmts.append(stmt)
+            stmt = node.next_stmt
+
+        # remap all results of the node to the arguments of the after_block
+        for result in node.results:
+            arg = after_block.args.append_from(result.type, result.name)
+            result.replace_by(arg)
+
+        parent_block_idx = parent_region._block_idx[parent_block]
+        # insert goto of parent block to the body block of the node.
+        parent_region.blocks.insert(parent_block_idx + 1, after_block)
+        # insert all blocks of the body of the node after the parent region
+        # making sure to convert any yield statements to jump statements to the after_block
+        parent_block.stmts.append(
+            cf.Branch(
+                arguments=(),
+                successor=node.body.blocks[0],
+            )
+        )
+        for block in reversed(node.body.blocks):
+            block.detach()
+            if isinstance((yield_stmt := block.last_stmt), wire.Yield):
+                yield_stmt.replace_by(
+                    cf.Branch(yield_stmt.values, successor=after_block)
+                )
+
+            parent_region.blocks.insert(parent_block_idx + 1, block)
+
+        node.delete()
+        return abc.RewriteResult(has_done_something=True)

bloqade/squin/rewrite/desugar.py

@@ -1,5 +1,5 @@
 from kirin import ir, types
-from kirin.dialects import ilist
+from kirin.dialects import py, ilist
 from kirin.rewrite.abc import RewriteRule, RewriteResult
 
 from bloqade.squin.qubit import (
@@ -53,12 +53,59 @@ class ApplyDesugarRule(RewriteRule):
         op = node.operator
         qubits = node.qubits
 
-        if len(qubits) == 1 and qubits[0].type.is_subseteq(ilist.IListType):
-            # NOTE: already calling with just a single argument that is already an ilist
+        if len(qubits) > 1 and all(q.type.is_subseteq(QubitType) for q in qubits):
+            (qubits_ilist_stmt := ilist.New(qubits)).insert_before(node)
+            qubits_ilist = qubits_ilist_stmt.result
+
+        elif len(qubits) == 1 and qubits[0].type.is_subseteq(QubitType):
+            (qubits_ilist_stmt := ilist.New(qubits)).insert_before(node)
+            qubits_ilist = qubits_ilist_stmt.result
+
+        elif len(qubits) == 1 and qubits[0].type.is_subseteq(
+            ilist.IListType[QubitType, types.Any]
+        ):
             qubits_ilist = qubits[0]
-        else:
-            (qubits_ilist_stmt := ilist.New(values=qubits)).insert_before(node)
+
+        elif len(qubits) == 1:
+            # TODO: remove this elif clause once we're at kirin v0.18
+            # NOTE: this is a temporary workaround for kirin#408
+            # currently type inference fails here in for loops since the loop var
+            # is an IList for some reason
+
+            if not isinstance(qubits[0], ir.ResultValue):
+                return RewriteResult()
+
+            is_ilist = isinstance(qbit_stmt := qubits[0].stmt, ilist.New)
+            if is_ilist:
+                if len(qbit_stmt.values) != 1:
+                    return RewriteResult()
+
+                if not isinstance(
+                    qbit_getindex_result := qbit_stmt.values[0], ir.ResultValue
+                ):
+                    return RewriteResult()
+
+                qbit_getindex = qbit_getindex_result.stmt
+            else:
+                qbit_getindex = qubits[0].stmt
+
+            if not isinstance(qbit_getindex, py.indexing.GetItem):
+                return RewriteResult()
+
+            if not qbit_getindex.obj.type.is_subseteq(
+                ilist.IListType[QubitType, types.Any]
+            ):
+                return RewriteResult()
+
+            if is_ilist:
+                values = qbit_stmt.values
+            else:
+                values = [qubits[0]]
+
+            (qubits_ilist_stmt := ilist.New(values=values)).insert_before(node)
             qubits_ilist = qubits_ilist_stmt.result
+        else:
+            return RewriteResult()
 
         stmt = Apply(operator=op, qubits=qubits_ilist)
         node.replace_by(stmt)

bloqade/squin/types.py

@@ -0,0 +1,8 @@
+from kirin import types
+
+
+class MeasurementResult:
+    pass
+
+
+MeasurementResultType = types.PyClass(MeasurementResult)

bloqade/squin/wire.py

@@ -6,12 +6,15 @@ circuits. Thus we do not define wrapping functions for the statements in this
 dialect.
 """
 
-from kirin import ir, types, lowering
+from kirin import ir, types, lowering, exception
 from kirin.decl import info, statement
+from kirin.dialects import func
 from kirin.lowering import wraps
+from kirin.ir.attrs.types import TypeAttribute
 
 from bloqade.types import Qubit, QubitType
 
+from .types import MeasurementResultType
 from .op.types import Op, OpType
 
 # from kirin.lowering import wraps
@@ -49,11 +52,87 @@ class Unwrap(ir.Statement):
     result: ir.ResultValue = info.result(WireType)
 
 
+@statement(dialect=dialect)
+class Wired(ir.Statement):
+    traits = frozenset()
+
+    qubits: tuple[ir.SSAValue, ...] = info.argument(QubitType)
+    memory_zone: str = info.attribute()
+    body: ir.Region = info.region(multi=True)
+
+    def __init__(
+        self,
+        body: ir.Region,
+        *qubits: ir.SSAValue,
+        memory_zone: str,
+        result_types: tuple[TypeAttribute, ...] | None = None,
+    ):
+        if result_types is None:
+            for block in body.blocks:
+                if isinstance(block.last_stmt, Yield):
+                    result_types = tuple(arg.type for arg in block.last_stmt.values)
+                    break
+
+        if result_types is None:
+            result_types = ()
+
+        super().__init__(
+            args=qubits,
+            args_slice={
+                "qubits": slice(0, None),
+            },
+            regions=[body],
+            attributes={
+                "memory_zone": ir.PyAttr(memory_zone)
+            },  # body of the wired statement
+            result_types=result_types,
+        )
+
+    def check(self):
+        entry_block = self.body.blocks[0]
+
+        if len(entry_block.args) != len(self.qubits):
+            raise exception.StaticCheckError(
+                f"Expected {len(self.qubits)} arguments, got {len(entry_block.args)}."
+            )
+        for arg in entry_block.args:
+            if not arg.type.is_subseteq(WireType):
+                raise exception.StaticCheckError(
+                    f"Expected argument of type {WireType}, got {arg.type}."
+                )
+        for block in self.body.blocks:
+            last_stmt = block.last_stmt
+            if isinstance(last_stmt, func.Return):
+                raise exception.StaticCheckError(
+                    "Return statements are not allowed in the body of a Wired statement."
+                )
+            elif isinstance(last_stmt, Yield) and len(last_stmt.values) != len(
+                self.results
+            ):
+                raise exception.StaticCheckError(
+                    f"Expected {len(self.results)} return values, got {len(last_stmt.values)}."
+                )
+
+
+@statement(dialect=dialect)
+class Yield(ir.Statement):
+    traits = frozenset({})
+    values: tuple[ir.SSAValue, ...] = info.argument(WireType)
+
+    def __init__(self, *args: ir.SSAValue):
+        super().__init__(
+            args=args,
+            args_slice={
+                "values": slice(0, None),
+            },
+        )
+
+
 # In Quake, you put a wire in and get a wire out when you "apply" an operator
 # In this case though we just need to indicate that an operator is applied to list[wires]
 @statement(dialect=dialect)
 class Apply(ir.Statement):  # apply(op, w1, w2, ...)
-    traits = frozenset({lowering.FromPythonCall(), ir.Pure()})
+    traits = frozenset({lowering.FromPythonCall()})
     operator: ir.SSAValue = info.argument(OpType)
     inputs: tuple[ir.SSAValue, ...] = info.argument(WireType)
 
@@ -88,6 +167,13 @@ class Broadcast(ir.Statement):
         )  # custom lowering required for wrapper to work here
 
 
+@statement(dialect=dialect)
+class RegionMeasure(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall(), WireTerminator()})
+    wire: ir.SSAValue = info.argument(WireType)
+    result: ir.ResultValue = info.result(MeasurementResultType)
+
+
 # NOTE: measurement cannot be pure because they will collapse the state
 #       of the qubit. The state is a hidden state that is not visible to
 #      the user in the wire dialect.
@@ -96,14 +182,14 @@ 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)
+    result: ir.ResultValue = info.result(MeasurementResultType)
 
 
 @statement(dialect=dialect)
-class NonDestructiveMeasure(ir.Statement):
+class LossResolvingMeasure(ir.Statement):
     traits = frozenset({lowering.FromPythonCall()})
     input_wire: ir.SSAValue = info.argument(WireType)
-    result: ir.ResultValue = info.result(types.Int)
+    result: ir.ResultValue = info.result(MeasurementResultType)
     out_wire: ir.ResultValue = info.result(WireType)