bloqade-circuit 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

bloqade/qasm2/rewrite/uop_to_parallel.py

@@ -3,8 +3,8 @@ from typing import Dict, List, Tuple, Iterable
 from dataclasses import field, dataclass
 
 from kirin import ir
-from kirin.rewrite import abc as rewrite_abc
 from kirin.dialects import py, ilist
+from kirin.rewrite.abc import RewriteRule, RewriteResult
 from kirin.analysis.const import lattice
 
 from bloqade.analysis import address
@@ -14,7 +14,7 @@ from bloqade.squin.analysis.schedule import StmtDag
 
 class MergePolicyABC(abc.ABC):
     @abc.abstractmethod
-    def __call__(self, node: ir.Statement) -> rewrite_abc.RewriteResult:
+    def __call__(self, node: ir.Statement) -> RewriteResult:
         pass
 
     @classmethod
@@ -141,10 +141,10 @@ class SimpleMergePolicy(MergePolicyABC):
             group_numbers=group_numbers,
         )
 
-    def __call__(self, node: ir.Statement) -> rewrite_abc.RewriteResult:
+    def __call__(self, node: ir.Statement) -> RewriteResult:
 
         if node not in self.group_numbers:
-            return rewrite_abc.RewriteResult()
+            return RewriteResult()
 
         group_number = self.group_numbers[node]
         group = self.merge_groups[group_number]
@@ -154,12 +154,10 @@ class SimpleMergePolicy(MergePolicyABC):
             self.group_has_merged[group_number] = result.has_done_something
             return result
 
-        if self.group_has_merged[group_number]:
+        if self.group_has_merged.setdefault(group_number, False):
             node.delete()
 
-        return rewrite_abc.RewriteResult(
-            has_done_something=self.group_has_merged[group_number]
-        )
+        return RewriteResult(has_done_something=self.group_has_merged[group_number])
 
     def move_and_collect_qubit_list(
         self, qargs: List[ir.SSAValue], node: ir.Statement
@@ -219,14 +217,14 @@ class SimpleMergePolicy(MergePolicyABC):
                 ctrls.append(stmt.ctrls)
                 qargs.append(stmt.qargs)
             else:
-                return rewrite_abc.RewriteResult(has_done_something=False)
+                return RewriteResult(has_done_something=False)
 
         ctrls_values = self.move_and_collect_qubit_list(ctrls, node)
         qargs_values = self.move_and_collect_qubit_list(qargs, node)
 
         if ctrls_values is None or qargs_values is None:
             # give up if we cannot determine the address or cannot move the qubits
-            return rewrite_abc.RewriteResult(has_done_something=False)
+            return RewriteResult(has_done_something=False)
 
         new_ctrls = ilist.New(values=ctrls_values)
         new_qargs = ilist.New(values=qargs_values)
@@ -238,7 +236,7 @@ class SimpleMergePolicy(MergePolicyABC):
 
         node.delete()
 
-        return rewrite_abc.RewriteResult(has_done_something=True)
+        return RewriteResult(has_done_something=True)
 
     def rewrite_group_U(self, node: ir.Statement, group: List[ir.Statement]):
         return self.rewrite_group_u(node, group)
@@ -252,13 +250,13 @@ class SimpleMergePolicy(MergePolicyABC):
             elif isinstance(stmt, parallel.UGate):
                 qargs.append(stmt.qargs)
             else:
-                return rewrite_abc.RewriteResult(has_done_something=False)
+                return RewriteResult(has_done_something=False)
 
         assert isinstance(node, (uop.UGate, parallel.UGate))
         qargs_values = self.move_and_collect_qubit_list(qargs, node)
 
         if qargs_values is None:
-            return rewrite_abc.RewriteResult(has_done_something=False)
+            return RewriteResult(has_done_something=False)
 
         new_qargs = ilist.New(values=qargs_values)
         new_gate = parallel.UGate(
@@ -271,7 +269,7 @@ class SimpleMergePolicy(MergePolicyABC):
         new_gate.insert_before(node)
         node.delete()
 
-        return rewrite_abc.RewriteResult(has_done_something=True)
+        return RewriteResult(has_done_something=True)
 
     def rewrite_group_rz(self, node: ir.Statement, group: List[ir.Statement]):
         qargs = []
@@ -282,14 +280,14 @@ class SimpleMergePolicy(MergePolicyABC):
             elif isinstance(stmt, parallel.RZ):
                 qargs.append(stmt.qargs)
             else:
-                return rewrite_abc.RewriteResult(has_done_something=False)
+                return RewriteResult(has_done_something=False)
 
         assert isinstance(node, (uop.RZ, parallel.RZ))
 
         qargs_values = self.move_and_collect_qubit_list(qargs, node)
 
         if qargs_values is None:
-            return rewrite_abc.RewriteResult(has_done_something=False)
+            return RewriteResult(has_done_something=False)
 
         new_qargs = ilist.New(values=qargs_values)
         new_gate = parallel.RZ(
@@ -300,7 +298,7 @@ class SimpleMergePolicy(MergePolicyABC):
         new_gate.insert_before(node)
         node.delete()
 
-        return rewrite_abc.RewriteResult(has_done_something=True)
+        return RewriteResult(has_done_something=True)
 
     def rewrite_group_barrier(self, node: uop.Barrier, group: List[uop.Barrier]):
         qargs = []
@@ -310,13 +308,13 @@ class SimpleMergePolicy(MergePolicyABC):
         qargs_values = self.move_and_collect_qubit_list(qargs, node)
 
         if qargs_values is None:
-            return rewrite_abc.RewriteResult(has_done_something=False)
+            return RewriteResult(has_done_something=False)
 
         new_node = uop.Barrier(qargs=qargs_values)
         new_node.insert_before(node)
         node.delete()
 
-        return rewrite_abc.RewriteResult(has_done_something=True)
+        return RewriteResult(has_done_something=True)
 
 
 class GreedyMixin(MergePolicyABC):
@@ -385,11 +383,11 @@ class SimpleOptimalMergePolicy(OptimalMixIn, SimpleMergePolicy):
 
 
 @dataclass
-class UOpToParallelRule(rewrite_abc.RewriteRule):
+class UOpToParallelRule(RewriteRule):
     merge_rewriters: Dict[ir.Block | None, MergePolicyABC]
 
-    def rewrite_Statement(self, node: ir.Statement) -> rewrite_abc.RewriteResult:
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
         merge_rewriter = self.merge_rewriters.get(
-            node.parent_block, lambda _: rewrite_abc.RewriteResult()
+            node.parent_block, lambda _: RewriteResult()
         )
         return merge_rewriter(node)

bloqade/qasm2/types.py

@@ -1,4 +1,5 @@
 from kirin import types
+from kirin.dialects import ilist
 
 from bloqade.types import Qubit as Qubit, QubitType as QubitType
 
@@ -15,11 +16,7 @@ class Bit:
     pass
 
 
-class QReg:
-    """Runtime representation of a quantum register."""
-
-    def __getitem__(self, index) -> Qubit:
-        raise NotImplementedError("cannot call __getitem__ outside of a kernel")
+QReg = ilist.IList[Qubit, types.Any]
 
 
 class CReg:
@@ -32,7 +29,7 @@ class CReg:
 BitType = types.PyClass(Bit)
 """Kirin type for a classical bit."""
 
-QRegType = types.PyClass(QReg)
+QRegType = ilist.IListType[QubitType, types.Any]
 """Kirin type for a quantum register."""
 
 CRegType = types.PyClass(CReg)

bloqade/qbraid/schema.py

@@ -9,7 +9,7 @@ class Operation(BaseModel, frozen=True, extra="forbid"):
     op_type: str = Field(init=False)
 
 
-class CZ(Operation):
+class CZ(Operation, frozen=True):
     """A CZ gate operation.
 
     Fields:
@@ -22,7 +22,7 @@ class CZ(Operation):
     participants: Tuple[Union[Tuple[int], Tuple[int, int]], ...]
 
 
-class GlobalRz(Operation):
+class GlobalRz(Operation, frozen=True):
     """GlobalRz operation.
 
     Fields:
@@ -34,7 +34,7 @@ class GlobalRz(Operation):
     phi: float
 
 
-class GlobalW(Operation):
+class GlobalW(Operation, frozen=True):
     """GlobalW operation.
 
     Fields:
@@ -48,7 +48,7 @@ class GlobalW(Operation):
     phi: float
 
 
-class LocalRz(Operation):
+class LocalRz(Operation, frozen=True):
     """LocalRz operation.
 
     Fields:
@@ -63,7 +63,7 @@ class LocalRz(Operation):
     phi: float
 
 
-class LocalW(Operation):
+class LocalW(Operation, frozen=True):
     """LocalW operation.
 
     Fields:
@@ -80,7 +80,7 @@ class LocalW(Operation):
     phi: float
 
 
-class Measurement(Operation):
+class Measurement(Operation, frozen=True):
     """Measurement operation.
 
     Fields:
@@ -95,9 +95,7 @@ class Measurement(Operation):
     participants: Tuple[int, ...]
 
 
-OperationType = TypeVar(
-    "OperationType", bound=Union[CZ, GlobalRz, GlobalW, LocalRz, LocalW, Measurement]
-)
+OperationType = CZ | GlobalRz | GlobalW | LocalRz | LocalW | Measurement
 
 
 class ErrorModel(BaseModel, frozen=True, extra="forbid"):
@@ -106,7 +104,7 @@ class ErrorModel(BaseModel, frozen=True, extra="forbid"):
     error_model_type: str = Field(init=False)
 
 
-class PauliErrorModel(ErrorModel):
+class PauliErrorModel(ErrorModel, frozen=True):
     """Pauli error model.
 
     Fields:
@@ -131,7 +129,7 @@ class ErrorOperation(BaseModel, Generic[ErrorModelType], frozen=True, extra="for
     survival_prob: Tuple[float, ...]
 
 
-class CZError(ErrorOperation[ErrorModelType]):
+class CZError(ErrorOperation[ErrorModelType], frozen=True):
     """CZError operation.
 
     Fields:
@@ -149,7 +147,7 @@ class CZError(ErrorOperation[ErrorModelType]):
     single_error: ErrorModelType
 
 
-class SingleQubitError(ErrorOperation[ErrorModelType]):
+class SingleQubitError(ErrorOperation[ErrorModelType], frozen=True):
     """SingleQubitError operation.
 
     Fields:

bloqade/squin/__init__.py

@@ -1,2 +1,2 @@
-from . import op as op, wire as wire, qubit as qubit
+from . import op as op, wire as wire, noise as noise, qubit as qubit
 from .groups import wired as wired, kernel as kernel

bloqade/squin/analysis/nsites/analysis.py

@@ -15,9 +15,7 @@ class NSitesAnalysis(Forward[Sites]):
     keys = ["op.nsites"]
     lattice = Sites
 
-    # Take a page from const prop in Kirin,
-    # I can get the data I want from the SizedTrait
-    # and go from there
+    # Take a page from how constprop works in Kirin
 
     ## This gets called before the registry look up
     def eval_stmt(self, frame: ForwardFrame, stmt: ir.Statement):
@@ -25,11 +23,11 @@ class NSitesAnalysis(Forward[Sites]):
         if method is not None:
             return method(self, frame, stmt)
         elif stmt.has_trait(HasSites):
-            has_sites_trait = stmt.get_trait(HasSites)
+            has_sites_trait = stmt.get_present_trait(HasSites)
             sites = has_sites_trait.get_sites(stmt)
             return (NumberSites(sites=sites),)
         elif stmt.has_trait(FixedSites):
-            sites_trait = stmt.get_trait(FixedSites)
+            sites_trait = stmt.get_present_trait(FixedSites)
             return (NumberSites(sites=sites_trait.data),)
         else:
             return (NoSites(),)
@@ -37,7 +35,7 @@ class NSitesAnalysis(Forward[Sites]):
     # For when no implementation is found for the statement
     def eval_stmt_fallback(
         self, frame: ForwardFrame[Sites], stmt: ir.Statement
-    ) -> tuple[Sites, ...]:  # some form of Shape will go back into the frame
+    ) -> tuple[Sites, ...]:  # some form of Sites will go back into the frame
         return tuple(
             (
                 self.lattice.top()

bloqade/squin/analysis/nsites/impls.py

@@ -1,6 +1,4 @@
-from typing import cast
-
-from kirin import ir, interp
+from kirin import interp
 
 from bloqade.squin import op
 
@@ -52,9 +50,7 @@ class SquinOp(interp.MethodTable):
 
         if isinstance(op_sites, NumberSites):
             n_sites = op_sites.sites
-            n_controls_attr = stmt.get_attr_or_prop("n_controls")
-            n_controls = cast(ir.PyAttr[int], n_controls_attr).data
-            return (NumberSites(sites=n_sites + n_controls),)
+            return (NumberSites(sites=n_sites + stmt.n_controls),)
         else:
             return (NoSites(),)
 

bloqade/squin/analysis/schedule.py

@@ -226,7 +226,7 @@ class DagScheduleAnalysis(Forward[GateSchedule]):
         if args is None:
             args = tuple(self.lattice.top() for _ in mt.args)
 
-        self.run(mt, args, kwargs).expect()
+        self.run(mt, args, kwargs)
         return self.stmt_dags
 
 

bloqade/squin/groups.py

@@ -1,10 +1,11 @@
 from kirin import ir, passes
 from kirin.prelude import structural_no_opt
 from kirin.dialects import ilist
-
-from bloqade.qasm2.rewrite.desugar import IndexingDesugarPass
+from kirin.rewrite.walk import Walk
 
 from . import op, wire, qubit
+from .op.rewrite import PyMultToSquinMult
+from .rewrite.measure_desugar import MeasureDesugarRule
 
 
 @ir.dialect_group(structural_no_opt.union([op, qubit]))
@@ -12,27 +13,34 @@ def kernel(self):
     fold_pass = passes.Fold(self)
     typeinfer_pass = passes.TypeInfer(self)
     ilist_desugar_pass = ilist.IListDesugar(self)
-    indexing_desugar_pass = IndexingDesugarPass(self)
+    measure_desugar_pass = Walk(MeasureDesugarRule())
+    py_mult_to_mult_pass = PyMultToSquinMult(self)
 
-    def run_pass(method, *, fold=True, typeinfer=True):
+    def run_pass(method: ir.Method, *, fold=True, typeinfer=True):
         method.verify()
         if fold:
             fold_pass.fixpoint(method)
 
+        py_mult_to_mult_pass(method)
+
         if typeinfer:
             typeinfer_pass(method)
+            measure_desugar_pass.rewrite(method.code)
+
         ilist_desugar_pass(method)
-        indexing_desugar_pass(method)
+
         if typeinfer:
             typeinfer_pass(method)  # fix types after desugaring
-            method.code.typecheck()
+            method.verify_type()
 
     return run_pass
 
 
 @ir.dialect_group(structural_no_opt.union([op, wire]))
 def wired(self):
+    py_mult_to_mult_pass = PyMultToSquinMult(self)
+
     def run_pass(method):
-        pass
+        py_mult_to_mult_pass(method)
 
     return run_pass

bloqade/squin/noise/__init__.py

@@ -0,0 +1,27 @@
+# Put all the proper wrappers here
+
+from kirin.lowering import wraps as _wraps
+
+from bloqade.squin.op.types import Op
+
+from . import stmts as stmts
+
+
+@_wraps(stmts.PauliError)
+def pauli_error(basis: Op, p: float) -> Op: ...
+
+
+@_wraps(stmts.PPError)
+def pp_error(op: Op, p: float) -> Op: ...
+
+
+@_wraps(stmts.Depolarize)
+def depolarize(n_qubits: int, p: float) -> Op: ...
+
+
+@_wraps(stmts.PauliChannel)
+def pauli_channel(n_qubits: int, params: tuple[float, ...]) -> Op: ...
+
+
+@_wraps(stmts.QubitLoss)
+def qubit_loss(p: float) -> Op: ...

bloqade/squin/noise/_dialect.py

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

bloqade/squin/noise/stmts.py

@@ -0,0 +1,59 @@
+from kirin import ir, types
+from kirin.decl import info, statement
+
+from bloqade.squin.op.types import OpType
+
+from ._dialect import dialect
+
+
+@statement
+class NoiseChannel(ir.Statement):
+    pass
+
+
+@statement(dialect=dialect)
+class PauliError(NoiseChannel):
+    basis: ir.SSAValue = info.argument(OpType)
+    p: ir.SSAValue = info.argument(types.Float)
+    result: ir.ResultValue = info.result(OpType)
+
+
+@statement(dialect=dialect)
+class PPError(NoiseChannel):
+    """
+    Pauli Product Error
+    """
+
+    op: ir.SSAValue = info.argument(OpType)
+    p: ir.SSAValue = info.argument(types.Float)
+    result: ir.ResultValue = info.result(OpType)
+
+
+@statement(dialect=dialect)
+class Depolarize(NoiseChannel):
+    """
+    Apply n-qubit depolaize error to qubits
+    NOTE For Stim, this can only accept 1 or 2 qubits
+    """
+
+    n_qubits: int = info.attribute(types.Int)
+    p: ir.SSAValue = info.argument(types.Float)
+    result: ir.ResultValue = info.result(OpType)
+
+
+@statement(dialect=dialect)
+class PauliChannel(NoiseChannel):
+    # NOTE:
+    # 1-qubit 3 params px, py, pz
+    # 2-qubit 15 params pix, piy, piz, pxi, pxx, pxy, pxz, pyi, pyx ..., pzz
+    # TODO add validation for params (maybe during lowering via custom lower?)
+    n_qubits: int = info.attribute()
+    params: ir.SSAValue = info.argument(types.Tuple[types.Vararg(types.Float)])
+    result: ir.ResultValue = info.result(OpType)
+
+
+@statement(dialect=dialect)
+class QubitLoss(NoiseChannel):
+    # NOTE: qubit loss error (not supported by Stim)
+    p: ir.SSAValue = info.argument(types.Float)
+    result: ir.ResultValue = info.result(OpType)

bloqade/squin/op/__init__.py

@@ -2,25 +2,47 @@ from kirin import ir as _ir
 from kirin.prelude import structural_no_opt as _structural_no_opt
 from kirin.lowering import wraps as _wraps
 
-from . import stmts as stmts, types as types
+from . import stmts as stmts, types as types, rewrite as rewrite
 from .traits import Unitary as Unitary, MaybeUnitary as MaybeUnitary
 from ._dialect import dialect as dialect
 
 
 @_wraps(stmts.Kron)
-def kron(lhs: types.Op, rhs: types.Op, *, is_unitary: bool = False) -> types.Op: ...
+def kron(lhs: types.Op, rhs: types.Op) -> types.Op: ...
+
+
+@_wraps(stmts.Mult)
+def mult(lhs: types.Op, rhs: types.Op) -> types.Op: ...
+
+
+@_wraps(stmts.Scale)
+def scale(op: types.Op, factor: complex) -> types.Op: ...
 
 
 @_wraps(stmts.Adjoint)
-def adjoint(op: types.Op, *, is_unitary: bool = False) -> types.Op: ...
+def adjoint(op: types.Op) -> types.Op: ...
 
 
 @_wraps(stmts.Control)
-def control(op: types.Op, *, n_controls: int, is_unitary: bool = False) -> types.Op: ...
+def control(op: types.Op, *, n_controls: int) -> types.Op:
+    """
+    Create a controlled operator.
+
+    Note, that when considering atom loss, the operator will not be applied if
+    any of the controls has been lost.
+
+    Args:
+        operator: The operator to apply under the control.
+        n_controls: The number qubits to be used as control.
+
+    Returns:
+        Operator
+    """
+    ...
 
 
 @_wraps(stmts.Identity)
-def identity(*, size: int) -> types.Op: ...
+def identity(*, sites: int) -> types.Op: ...
 
 
 @_wraps(stmts.Rot)
@@ -75,6 +97,14 @@ def spin_n() -> types.Op: ...
 def spin_p() -> types.Op: ...
 
 
+@_wraps(stmts.U3)
+def u(theta: float, phi: float, lam: float) -> types.Op: ...
+
+
+@_wraps(stmts.PauliString)
+def pauli_string(*, string: str) -> types.Op: ...
+
+
 # stdlibs
 @_ir.dialect_group(_structural_no_opt.add(dialect))
 def op(self):

bloqade/squin/op/number.py

@@ -0,0 +1,5 @@
+import numbers
+
+from kirin.ir.attrs.types import PyClass
+
+NumberType = PyClass(numbers.Number)

bloqade/squin/op/rewrite.py

@@ -0,0 +1,46 @@
+"""Rewrite py.binop.mult to Mult stmt"""
+
+from kirin import ir
+from kirin.passes import Pass
+from kirin.rewrite import Walk
+from kirin.dialects import py
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from .stmts import Mult, Scale
+from .types import OpType
+
+
+class _PyMultToSquinMult(RewriteRule):
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+        if not isinstance(node, py.Mult):
+            return RewriteResult()
+
+        lhs_is_op = node.lhs.type.is_subseteq(OpType)
+        rhs_is_op = node.rhs.type.is_subseteq(OpType)
+
+        if not lhs_is_op and not rhs_is_op:
+            return RewriteResult()
+
+        if lhs_is_op and rhs_is_op:
+            mult = Mult(node.lhs, node.rhs)
+            node.replace_by(mult)
+            return RewriteResult(has_done_something=True)
+
+        if lhs_is_op:
+            scale = Scale(node.lhs, node.rhs)
+            node.replace_by(scale)
+            return RewriteResult(has_done_something=True)
+
+        if rhs_is_op:
+            scale = Scale(node.rhs, node.lhs)
+            node.replace_by(scale)
+            return RewriteResult(has_done_something=True)
+
+        return RewriteResult()
+
+
+class PyMultToSquinMult(Pass):
+
+    def unsafe_run(self, mt: ir.Method) -> RewriteResult:
+        return Walk(_PyMultToSquinMult()).rewrite(mt.code)

bloqade/squin/op/stmts.py

@@ -2,8 +2,8 @@ from kirin import ir, types, lowering
 from kirin.decl import info, statement
 
 from .types import OpType
+from .number import NumberType
 from .traits import Unitary, HasSites, FixedSites, MaybeUnitary
-from .complex import Complex
 from ._dialect import dialect
 
 
@@ -54,7 +54,7 @@ class Scale(CompositeOp):
     traits = frozenset({ir.Pure(), lowering.FromPythonCall(), MaybeUnitary()})
     is_unitary: bool = info.attribute(default=False)
     op: ir.SSAValue = info.argument(OpType)
-    factor: ir.SSAValue = info.argument(Complex)
+    factor: ir.SSAValue = info.argument(NumberType)
     result: ir.ResultValue = info.result(OpType)
 
 
@@ -103,6 +103,15 @@ class ConstantUnitary(ConstantOp):
     )
 
 
+@statement(dialect=dialect)
+class U3(PrimitiveOp):
+    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), Unitary(), FixedSites(1)})
+    theta: ir.SSAValue = info.argument(types.Float)
+    phi: ir.SSAValue = info.argument(types.Float)
+    lam: ir.SSAValue = info.argument(types.Float)
+    result: ir.ResultValue = info.result(OpType)
+
+
 @statement(dialect=dialect)
 class PhaseOp(PrimitiveOp):
     """
@@ -138,6 +147,18 @@ class PauliOp(ConstantUnitary):
     pass
 
 
+@statement(dialect=dialect)
+class PauliString(ConstantUnitary):
+    traits = frozenset({ir.Pure(), lowering.FromPythonCall(), Unitary(), HasSites()})
+    string: str = info.attribute()
+
+    def verify(self) -> None:
+        if not set("XYZ").issuperset(self.string):
+            raise ValueError(
+                f"Invalid Pauli string: {self.string}. Must be a combination of 'X', 'Y', and 'Z'."
+            )
+
+
 @statement(dialect=dialect)
 class X(PauliOp):
     pass

bloqade/squin/op/types.py

@@ -1,3 +1,5 @@
+from typing import overload
+
 from kirin import types
 
 
@@ -6,5 +8,17 @@ class Op:
     def __matmul__(self, other: "Op") -> "Op":
         raise NotImplementedError("@ can only be used within a squin kernel program")
 
+    @overload
+    def __mul__(self, other: "Op") -> "Op": ...
+
+    @overload
+    def __mul__(self, other: complex) -> "Op": ...
+
+    def __mul__(self, other) -> "Op":
+        raise NotImplementedError("@ can only be used within a squin kernel program")
+
+    def __rmul__(self, other: complex) -> "Op":
+        raise NotImplementedError("@ can only be used within a squin kernel program")
+
 
 OpType = types.PyClass(Op)