bloqade-circuit 0.3.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

bloqade/qasm2/emit/impls/{noise_native.py → noise.py}

@@ -3,12 +3,12 @@ from typing import Any
 from kirin import interp
 from kirin.dialects import ilist
 
-from bloqade.noise import native
 from bloqade.qasm2.parse import ast
+from bloqade.qasm2.dialects import noise
 from bloqade.qasm2.emit.gate import EmitQASM2Gate, EmitQASM2Frame
 
 
-@native.dialect.register(key="emit.qasm2.gate")
+@noise.dialect.register(key="emit.qasm2.gate")
 class NativeNoise(interp.MethodTable):
 
     def _convert(self, node: ast.Bit | ast.Name) -> str:
@@ -17,12 +17,12 @@ class NativeNoise(interp.MethodTable):
         else:
             return f"{node.id}"
 
-    @interp.impl(native.CZPauliChannel)
+    @interp.impl(noise.CZPauliChannel)
     def emit_czp(
         self,
         emit: EmitQASM2Gate,
         frame: EmitQASM2Frame,
-        stmt: native.CZPauliChannel,
+        stmt: noise.CZPauliChannel,
     ):
         paired: bool = stmt.paired
         px_ctrl: float = stmt.px_ctrl
@@ -35,7 +35,7 @@ class NativeNoise(interp.MethodTable):
         qargs: ilist.IList[ast.Bit, Any] = frame.get(stmt.qargs)
         frame.body.append(
             ast.Comment(
-                text=f"native.CZPauliChannel(paired={paired}, p_ctrl=[x:{px_ctrl}, y:{py_ctrl}, z:{pz_ctrl}], p_qarg[x:{px_qarg}, y:{py_qarg}, z:{pz_qarg}])"
+                text=f"noise.CZPauliChannel(paired={paired}, p_ctrl=[x:{px_ctrl}, y:{py_ctrl}, z:{pz_ctrl}], p_qarg[x:{px_qarg}, y:{py_qarg}, z:{pz_qarg}])"
             )
         )
         frame.body.append(
@@ -50,16 +50,16 @@ class NativeNoise(interp.MethodTable):
         )
         return ()
 
-    @interp.impl(native.AtomLossChannel)
+    @interp.impl(noise.AtomLossChannel)
     def emit_loss(
         self,
         emit: EmitQASM2Gate,
         frame: EmitQASM2Frame,
-        stmt: native.AtomLossChannel,
+        stmt: noise.AtomLossChannel,
     ):
         prob: float = stmt.prob
         qargs: ilist.IList[ast.Bit, Any] = frame.get(stmt.qargs)
-        frame.body.append(ast.Comment(text=f"native.Atomloss(p={prob})"))
+        frame.body.append(ast.Comment(text=f"noise.Atomloss(p={prob})"))
         frame.body.append(
             ast.Comment(
                 text=f" -: qargs: {', '.join([self._convert(q) for q in qargs])}"
@@ -67,19 +67,19 @@ class NativeNoise(interp.MethodTable):
         )
         return ()
 
-    @interp.impl(native.PauliChannel)
+    @interp.impl(noise.PauliChannel)
     def emit_pauli(
         self,
         emit: EmitQASM2Gate,
         frame: EmitQASM2Frame,
-        stmt: native.PauliChannel,
+        stmt: noise.PauliChannel,
     ):
         px: float = stmt.px
         py: float = stmt.py
         pz: float = stmt.pz
         qargs: ilist.IList[ast.Bit, Any] = frame.get(stmt.qargs)
         frame.body.append(
-            ast.Comment(text=f"native.PauliChannel(px={px}, py={py}, pz={pz})")
+            ast.Comment(text=f"noise.PauliChannel(px={px}, py={py}, pz={pz})")
         )
         frame.body.append(
             ast.Comment(

bloqade/qasm2/emit/main.py

@@ -25,12 +25,10 @@ class Func(interp.MethodTable):
     def emit_func(
         self, emit: EmitQASM2Main, frame: EmitQASM2Frame, stmt: func.Function
     ):
-        from bloqade.qasm2.dialects import glob, noise, parallel
+        from bloqade.qasm2.dialects import glob, parallel
 
         emit.run_ssacfg_region(frame, stmt.body, ())
-        if emit.dialects.data.intersection(
-            (parallel.dialect, glob.dialect, noise.dialect)
-        ):
+        if emit.dialects.data.intersection((parallel.dialect, glob.dialect)):
             header = ast.Kirin([dialect.name for dialect in emit.dialects])
         else:
             header = ast.OPENQASM(ast.Version(2, 0))

bloqade/qasm2/emit/target.py

@@ -57,7 +57,7 @@ class QASM2:
 
 
         """
-        from bloqade import noise, qasm2
+        from bloqade import qasm2
 
         self.main_target = qasm2.main
         self.gate_target = qasm2.gate
@@ -77,8 +77,8 @@ class QASM2:
             self.gate_target = self.gate_target.add(qasm2.dialects.glob)
 
         if allow_noise:
-            self.main_target = self.main_target.add(noise.native)
-            self.gate_target = self.gate_target.add(noise.native)
+            self.main_target = self.main_target.add(qasm2.dialects.noise)
+            self.gate_target = self.gate_target.add(qasm2.dialects.noise)
 
         if allow_global or allow_parallel or allow_noise:
             self.main_target = self.main_target.add(ilist)

bloqade/qasm2/groups.py

@@ -2,7 +2,6 @@ from kirin import ir, passes
 from kirin.prelude import structural_no_opt
 from kirin.dialects import scf, func, ilist, lowering
 
-from bloqade.noise import native
 from bloqade.qasm2.dialects import (
     uop,
     core,
@@ -91,7 +90,6 @@ def main(self):
             noise,
             parallel,
             core,
-            native,
         ]
     )
 )

bloqade/{noise/native/_wrappers.py → qasm2/noise.py}

@@ -3,11 +3,15 @@ from typing import Any
 from kirin.dialects import ilist
 from kirin.lowering import wraps
 
-from bloqade.noise import native
-from bloqade.qasm2.types import Qubit
+from .types import Qubit
+from .dialects import noise
+from .dialects.noise import (
+    TwoRowZoneModel as TwoRowZoneModel,
+    MoveNoiseModelABC as MoveNoiseModelABC,
+)
 
 
-@wraps(native.AtomLossChannel)
+@wraps(noise.AtomLossChannel)
 def atom_loss_channel(qargs: ilist.IList[Qubit, Any] | list, *, prob: float) -> None:
     """Apply an atom loss channel to a list of qubits.
 
@@ -18,7 +22,7 @@ def atom_loss_channel(qargs: ilist.IList[Qubit, Any] | list, *, prob: float) ->
     ...
 
 
-@wraps(native.PauliChannel)
+@wraps(noise.PauliChannel)
 def pauli_channel(
     qargs: ilist.IList[Qubit, Any] | list, *, px: float, py: float, pz: float
 ) -> None:
@@ -32,7 +36,7 @@ def pauli_channel(
     """
 
 
-@wraps(native.CZPauliChannel)
+@wraps(noise.CZPauliChannel)
 def cz_pauli_channel(
     ctrls: ilist.IList[Qubit, Any] | list,
     qargs: ilist.IList[Qubit, Any] | list,

bloqade/qasm2/passes/glob.py

@@ -58,13 +58,15 @@ class GlobalToUOP(Pass):
         rewriter = walk.Walk(self.generate_rule(mt))
         result = rewriter.rewrite(mt.code)
 
-        result = walk.Walk(dce.DeadCodeElimination()).rewrite(mt.code)
-        result = Fixpoint(walk.Walk(rule=cse.CommonSubexpressionElimination())).rewrite(
-            mt.code
+        result = walk.Walk(dce.DeadCodeElimination()).rewrite(mt.code).join(result)
+        result = (
+            Fixpoint(walk.Walk(rule=cse.CommonSubexpressionElimination()))
+            .rewrite(mt.code)
+            .join(result)
         )
 
         # do fold again to get proper hint for inserted const
-        result = Fold(mt.dialects)(mt)
+        result = Fold(mt.dialects)(mt).join(result)
         return result
 
 
@@ -110,10 +112,12 @@ class GlobalToParallel(Pass):
         rewriter = walk.Walk(self.generate_rule(mt))
         result = rewriter.rewrite(mt.code)
 
-        result = walk.Walk(dce.DeadCodeElimination()).rewrite(mt.code)
-        result = Fixpoint(walk.Walk(rule=cse.CommonSubexpressionElimination())).rewrite(
-            mt.code
+        result = walk.Walk(dce.DeadCodeElimination()).rewrite(mt.code).join(result)
+        result = (
+            Fixpoint(walk.Walk(rule=cse.CommonSubexpressionElimination()))
+            .rewrite(mt.code)
+            .join(result)
         )
         # do fold again to get proper hint
-        result = Fold(mt.dialects)(mt)
+        result = Fold(mt.dialects)(mt).join(result)
         return result

bloqade/qasm2/passes/noise.py

@@ -8,10 +8,10 @@ from kirin.rewrite import (
     DeadCodeElimination,
 )
 
-from bloqade.noise import native
+from bloqade.qasm2 import noise
 from bloqade.analysis import address
+from bloqade.qasm2.rewrite import NoiseRewriteRule
 from bloqade.qasm2.passes.lift_qubits import LiftQubits
-from bloqade.qasm2.rewrite.heuristic_noise import NoiseRewriteRule
 
 
 @dataclass
@@ -25,12 +25,9 @@ class NoisePass(Pass):
 
     ```
     from bloqade import qasm2
-    from bloqade.noise import native
-    from bloqade.qasm2.passes.noise import NoisePass
+    from bloqade.qasm2.passes import NoisePass
 
-    noise_main = qasm2.extended.add(native.dialect)
-
-    @noise_main
+    @qasm2.extended
     def main():
         q = qasm2.qreg(2)
         qasm2.h(q[0])
@@ -51,12 +48,7 @@ class NoisePass(Pass):
 
     """
 
-    noise_model: native.MoveNoiseModelABC = field(
-        default_factory=native.TwoRowZoneModel
-    )
-    gate_noise_params: native.GateNoiseParams = field(
-        default_factory=native.GateNoiseParams
-    )
+    noise_model: noise.MoveNoiseModelABC = field(default_factory=noise.TwoRowZoneModel)
     address_analysis: address.AddressAnalysis = field(init=False)
 
     def __post_init__(self):
@@ -89,7 +81,6 @@ class NoisePass(Pass):
                     qubit_ssa_value=qubit_ssa_value,
                     address_analysis=address_analysis,
                     noise_model=self.noise_model,
-                    gate_noise_params=self.gate_noise_params,
                 ),
                 reverse=True,
             )

bloqade/qasm2/rewrite/__init__.py

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

bloqade/qasm2/rewrite/{heuristic_noise.py → noise/heuristic_noise.py}

@@ -5,9 +5,8 @@ from kirin import ir
 from kirin.rewrite import abc as rewrite_abc
 from kirin.dialects import ilist
 
-from bloqade.noise import native
 from bloqade.analysis import address
-from bloqade.qasm2.dialects import uop, glob, parallel
+from bloqade.qasm2.dialects import uop, glob, noise, parallel
 
 
 @dataclass
@@ -19,12 +18,7 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
 
     address_analysis: Dict[ir.SSAValue, address.Address]
     qubit_ssa_value: Dict[int, ir.SSAValue]
-    gate_noise_params: native.GateNoiseParams = field(
-        default_factory=native.GateNoiseParams
-    )
-    noise_model: native.MoveNoiseModelABC = field(
-        default_factory=native.TwoRowZoneModel
-    )
+    noise_model: noise.MoveNoiseModelABC = field(default_factory=noise.TwoRowZoneModel)
 
     def rewrite_Statement(self, node: ir.Statement) -> rewrite_abc.RewriteResult:
         if isinstance(node, uop.SingleQubitGate):
@@ -46,22 +40,18 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
         qargs: ir.SSAValue,
         probs: Tuple[float, float, float, float],
     ):
-        native.PauliChannel(qargs, px=probs[0], py=probs[1], pz=probs[2]).insert_before(
+        noise.PauliChannel(qargs, px=probs[0], py=probs[1], pz=probs[2]).insert_before(
             node
         )
-        native.AtomLossChannel(qargs, prob=probs[3]).insert_before(node)
+        noise.AtomLossChannel(qargs, prob=probs[3]).insert_before(node)
 
         return rewrite_abc.RewriteResult(has_done_something=True)
 
     def rewrite_single_qubit_gate(self, node: uop.SingleQubitGate):
-        probs = (
-            self.gate_noise_params.local_px,
-            self.gate_noise_params.local_py,
-            self.gate_noise_params.local_pz,
-            self.gate_noise_params.local_loss_prob,
-        )
         (qargs := ilist.New(values=(node.qarg,))).insert_before(node)
-        return self.insert_single_qubit_noise(node, qargs.result, probs)
+        return self.insert_single_qubit_noise(
+            node, qargs.result, self.noise_model.local_errors
+        )
 
     def rewrite_global_single_qubit_gate(self, node: glob.UGate):
         addrs = self.address_analysis[node.registers]
@@ -77,14 +67,10 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
             for qid in addr.data:
                 qargs.append(self.qubit_ssa_value[qid])
 
-        probs = (
-            self.gate_noise_params.global_px,
-            self.gate_noise_params.global_py,
-            self.gate_noise_params.global_pz,
-            self.gate_noise_params.global_loss_prob,
-        )
         (qargs := ilist.New(values=tuple(qargs))).insert_before(node)
-        return self.insert_single_qubit_noise(node, qargs.result, probs)
+        return self.insert_single_qubit_noise(
+            node, qargs.result, self.noise_model.global_errors
+        )
 
     def rewrite_parallel_single_qubit_gate(self, node: parallel.RZ | parallel.UGate):
         addrs = self.address_analysis[node.qargs]
@@ -94,15 +80,11 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
         if not all(isinstance(addr, address.AddressQubit) for addr in addrs.data):
             return rewrite_abc.RewriteResult()
 
-        probs = (
-            self.gate_noise_params.local_px,
-            self.gate_noise_params.local_py,
-            self.gate_noise_params.local_pz,
-            self.gate_noise_params.local_loss_prob,
-        )
         assert isinstance(node.qargs, ir.ResultValue)
         assert isinstance(node.qargs.stmt, ilist.New)
-        return self.insert_single_qubit_noise(node, node.qargs, probs)
+        return self.insert_single_qubit_noise(
+            node, node.qargs, self.noise_model.local_errors
+        )
 
     def move_noise_stmts(
         self,
@@ -118,9 +100,9 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
             nodes.append(
                 qargs := ilist.New(tuple(self.qubit_ssa_value[q] for q in qubits))
             )
-            nodes.append(native.AtomLossChannel(qargs.result, prob=probs[3]))
+            nodes.append(noise.AtomLossChannel(qargs.result, prob=probs[3]))
             nodes.append(
-                native.PauliChannel(qargs.result, px=probs[0], py=probs[1], pz=probs[2])
+                noise.PauliChannel(qargs.result, px=probs[0], py=probs[1], pz=probs[2])
             )
 
         return nodes
@@ -131,34 +113,30 @@ class NoiseRewriteRule(rewrite_abc.RewriteRule):
         qargs: ir.SSAValue,
     ) -> list[ir.Statement]:
         return [
-            native.CZPauliChannel(
+            noise.CZPauliChannel(
                 ctrls,
                 qargs,
-                px_ctrl=self.gate_noise_params.cz_paired_gate_px,
-                py_ctrl=self.gate_noise_params.cz_paired_gate_py,
-                pz_ctrl=self.gate_noise_params.cz_paired_gate_pz,
-                px_qarg=self.gate_noise_params.cz_paired_gate_px,
-                py_qarg=self.gate_noise_params.cz_paired_gate_py,
-                pz_qarg=self.gate_noise_params.cz_paired_gate_pz,
+                px_ctrl=self.noise_model.cz_paired_gate_px,
+                py_ctrl=self.noise_model.cz_paired_gate_py,
+                pz_ctrl=self.noise_model.cz_paired_gate_pz,
+                px_qarg=self.noise_model.cz_paired_gate_px,
+                py_qarg=self.noise_model.cz_paired_gate_py,
+                pz_qarg=self.noise_model.cz_paired_gate_pz,
                 paired=True,
             ),
-            native.CZPauliChannel(
+            noise.CZPauliChannel(
                 ctrls,
                 qargs,
-                px_ctrl=self.gate_noise_params.cz_unpaired_gate_px,
-                py_ctrl=self.gate_noise_params.cz_unpaired_gate_py,
-                pz_ctrl=self.gate_noise_params.cz_unpaired_gate_pz,
-                px_qarg=self.gate_noise_params.cz_unpaired_gate_px,
-                py_qarg=self.gate_noise_params.cz_unpaired_gate_py,
-                pz_qarg=self.gate_noise_params.cz_unpaired_gate_pz,
+                px_ctrl=self.noise_model.cz_unpaired_gate_px,
+                py_ctrl=self.noise_model.cz_unpaired_gate_py,
+                pz_ctrl=self.noise_model.cz_unpaired_gate_pz,
+                px_qarg=self.noise_model.cz_unpaired_gate_px,
+                py_qarg=self.noise_model.cz_unpaired_gate_py,
+                pz_qarg=self.noise_model.cz_unpaired_gate_pz,
                 paired=False,
             ),
-            native.AtomLossChannel(
-                ctrls, prob=self.gate_noise_params.cz_gate_loss_prob
-            ),
-            native.AtomLossChannel(
-                qargs, prob=self.gate_noise_params.cz_gate_loss_prob
-            ),
+            noise.AtomLossChannel(ctrls, prob=self.noise_model.cz_gate_loss_prob),
+            noise.AtomLossChannel(qargs, prob=self.noise_model.cz_gate_loss_prob),
         ]
 
     def rewrite_cz_gate(self, node: uop.CZ):

bloqade/{noise/native/rewrite.py → qasm2/rewrite/noise/remove_noise.py}

@@ -4,8 +4,8 @@ from kirin import ir
 from kirin.rewrite import abc, dce, walk, fixpoint
 from kirin.passes.abc import Pass
 
-from .stmts import PauliChannel, CZPauliChannel, AtomLossChannel
-from ._dialect import dialect
+from ...dialects.noise.stmts import PauliChannel, CZPauliChannel, AtomLossChannel
+from ...dialects.noise._dialect import dialect
 
 
 class RemoveNoiseRewrite(abc.RewriteRule):

bloqade/qbraid/lowering.py

@@ -4,13 +4,13 @@ from dataclasses import field, dataclass
 from kirin import ir, types, passes
 from kirin.dialects import func, ilist
 
-from bloqade import noise, qasm2
+from bloqade import qasm2
 from bloqade.qbraid import schema
-from bloqade.qasm2.dialects import glob, parallel
+from bloqade.qasm2.dialects import glob, noise, parallel
 
 
 @ir.dialect_group(
-    [func, qasm2.core, qasm2.uop, parallel, glob, qasm2.expr, noise.native, ilist]
+    [func, qasm2.core, qasm2.uop, parallel, glob, qasm2.expr, noise, ilist]
 )
 def qbraid_noise(
     self,
@@ -192,7 +192,7 @@ class Lowering:
                 qargs := ilist.New(values=tuple(self.qubit_id_map[q] for q in qubits))
             )
             self.block_list.append(
-                noise.native.PauliChannel(px=px, py=py, pz=pz, qargs=qargs.result)
+                noise.PauliChannel(px=px, py=py, pz=pz, qargs=qargs.result)
             )
 
         for (p_ctrl, p_qarg), qubits in paired_layers.items():
@@ -204,7 +204,7 @@ class Lowering:
                 qargs := ilist.New(values=tuple(self.qubit_id_map[q] for q in qargs))
             )
             self.block_list.append(
-                noise.native.CZPauliChannel(
+                noise.CZPauliChannel(
                     paired=True,
                     px_ctrl=p_ctrl[0],
                     py_ctrl=p_ctrl[1],
@@ -226,7 +226,7 @@ class Lowering:
                 qargs := ilist.New(values=tuple(self.qubit_id_map[q] for q in qargs))
             )
             self.block_list.append(
-                noise.native.CZPauliChannel(
+                noise.CZPauliChannel(
                     paired=False,
                     px_ctrl=p_ctrl[0],
                     py_ctrl=p_ctrl[1],
@@ -285,7 +285,7 @@ class Lowering:
                 qargs := ilist.New(values=tuple(self.qubit_id_map[q] for q in qubits))
             )
             self.block_list.append(
-                noise.native.PauliChannel(px=px, py=py, pz=pz, qargs=qargs.result)
+                noise.PauliChannel(px=px, py=py, pz=pz, qargs=qargs.result)
             )
 
     def lower_measurement(self, operation: schema.Measurement):
@@ -303,7 +303,7 @@ class Lowering:
         for survival_prob, qubits in layers.items():
             self.block_list.append(qargs := ilist.New(values=qubits))
             self.block_list.append(
-                noise.native.AtomLossChannel(prob=survival_prob, qargs=qargs.result)
+                noise.AtomLossChannel(prob=survival_prob, qargs=qargs.result)
             )
 
     def lower_number(self, value: float | int) -> ir.SSAValue:

bloqade/squin/__init__.py

@@ -1,2 +1,17 @@
-from . import op as op, wire as wire, noise as noise, qubit as qubit
+from . import (
+    op as op,
+    wire as wire,
+    noise as noise,
+    qubit as qubit,
+    lowering as lowering,
+)
 from .groups import wired as wired, kernel as kernel
+
+try:
+    # NOTE: make sure optional cirq dependency is installed
+    import cirq as cirq_package  # noqa: F401
+except ImportError:
+    pass
+else:
+    from . import cirq as cirq
+    from .cirq import load_circuit as load_circuit

bloqade/squin/analysis/nsites/impls.py

@@ -23,15 +23,6 @@ class SquinWire(interp.MethodTable):
 
         return tuple(frame.get(input) for input in stmt.inputs)
 
-    @interp.impl(wire.MeasureAndReset)
-    def measure_and_reset(
-        self, interp: NSitesAnalysis, frame: interp.Frame, stmt: wire.MeasureAndReset
-    ):
-
-        # MeasureAndReset produces both a new wire
-        # and an integer which don't have any sites at all
-        return (NoSites(), NoSites())
-
 
 @op.dialect.register(key="op.nsites")
 class SquinOp(interp.MethodTable):

bloqade/squin/cirq/__init__.py

@@ -0,0 +1,89 @@
+from typing import Any
+
+import cirq
+from kirin import ir, types
+from kirin.dialects import func
+
+from . import lowering as lowering
+from .. import kernel
+from .lowering import Squin
+
+
+def load_circuit(
+    circuit: cirq.Circuit,
+    kernel_name: str = "main",
+    dialects: ir.DialectGroup = kernel,
+    globals: dict[str, Any] | None = None,
+    file: str | None = None,
+    lineno_offset: int = 0,
+    col_offset: int = 0,
+    compactify: bool = True,
+):
+    """Converts a cirq.Circuit object into a squin kernel.
+
+    Args:
+        circuit (cirq.Circuit): The circuit to load.
+
+    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`.
+        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:
+
+    ```python
+    # from cirq's "hello qubit" example
+    import cirq
+    from bloqade import squin
+
+    # Pick a qubit.
+    qubit = cirq.GridQubit(0, 0)
+
+    # Create a circuit.
+    circuit = cirq.Circuit(
+        cirq.X(qubit)**0.5,  # Square root of NOT.
+        cirq.measure(qubit, key='m')  # Measurement.
+    )
+
+    # load the circuit as squin
+    main = squin.load_circuit(circuit)
+
+    # print the resulting IR
+    main.print()
+    ```
+    """
+
+    target = Squin(dialects=dialects, circuit=circuit)
+    body = target.run(
+        circuit,
+        source=str(circuit),  # TODO: proper source string
+        file=file,
+        globals=globals,
+        lineno_offset=lineno_offset,
+        col_offset=col_offset,
+        compactify=compactify,
+    )
+
+    # 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))
+
+    code = func.Function(
+        sym_name=kernel_name,
+        signature=func.Signature((), types.NoneType),
+        body=body,
+    )
+
+    return ir.Method(
+        mod=None,
+        py_func=None,
+        sym_name=kernel_name,
+        arg_names=[],
+        dialects=dialects,
+        code=code,
+    )