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

bloqade/analysis/address/impls.py

@@ -75,6 +75,7 @@ class PyIndexing(interp.MethodTable):
     def getitem(self, interp: AddressAnalysis, frame: interp.Frame, stmt: py.GetItem):
         # Integer index into the thing being indexed
         idx = interp.get_const_value(int, stmt.index)
+
         # The object being indexed into
         obj = frame.get(stmt.obj)
         # The `data` attributes holds onto other Address types
@@ -144,13 +145,13 @@ class Scf(scf.absint.Methods):
         # NOTE: we need to actually run iteration in case there are
         # new allocations/re-assign in the loop body.
         for _ in iterable:
-            with interp_.state.new_frame(interp_.new_frame(stmt)) as body_frame:
+            with interp_.new_frame(stmt) as body_frame:
                 body_frame.entries.update(frame.entries)
                 body_frame.set_values(
                     block_args,
                     (NotQubit(),) + loop_vars,
                 )
-                loop_vars = interp_.run_ssacfg_region(body_frame, stmt.body)
+                loop_vars = interp_.run_ssacfg_region(body_frame, stmt.body, ())
 
             if loop_vars is None:
                 loop_vars = ()

bloqade/pyqrack/device.py

@@ -64,9 +64,7 @@ class PyQrackSimulatorBase(AbstractSimulatorDevice[PyQrackSimulatorTask]):
         kwargs: dict[str, Any] | None = None,
     ) -> list[complex]:
         """Runs task and returns the state vector."""
-        task = self.task(kernel, args, kwargs)
-        task.run()
-        return task.state.sim_reg.out_ket()
+        return self.task(kernel, args, kwargs).state_vector()
 
     @staticmethod
     def pauli_expectation(pauli: list[Pauli], qubits: list[PyQrackQubit]) -> float:

bloqade/pyqrack/noise/native.py

@@ -2,11 +2,11 @@ from typing import List
 
 from kirin import interp
 
-from bloqade.noise import native
 from bloqade.pyqrack import PyQrackInterpreter, reg
+from bloqade.qasm2.dialects import noise
 
 
-@native.dialect.register(key="pyqrack")
+@noise.dialect.register(key="pyqrack")
 class PyQrackMethods(interp.MethodTable):
     def apply_pauli_error(
         self,
@@ -27,12 +27,12 @@ class PyQrackMethods(interp.MethodTable):
 
         getattr(qarg.sim_reg, which)(qarg.addr)
 
-    @interp.impl(native.PauliChannel)
+    @interp.impl(noise.PauliChannel)
     def single_qubit_error_channel(
         self,
         interp: PyQrackInterpreter,
         frame: interp.Frame,
-        stmt: native.PauliChannel,
+        stmt: noise.PauliChannel,
     ):
         qargs: List[reg.PyQrackQubit] = frame.get(stmt.qargs)
 
@@ -43,12 +43,12 @@ class PyQrackMethods(interp.MethodTable):
 
         return ()
 
-    @interp.impl(native.CZPauliChannel)
+    @interp.impl(noise.CZPauliChannel)
     def cz_pauli_channel(
         self,
         interp: PyQrackInterpreter,
         frame: interp.Frame,
-        stmt: native.CZPauliChannel,
+        stmt: noise.CZPauliChannel,
     ):
 
         qargs: List[reg.PyQrackQubit] = frame.get(stmt.qargs)
@@ -80,12 +80,12 @@ class PyQrackMethods(interp.MethodTable):
 
         return ()
 
-    @interp.impl(native.AtomLossChannel)
+    @interp.impl(noise.AtomLossChannel)
     def atom_loss_channel(
         self,
         interp: PyQrackInterpreter,
         frame: interp.Frame,
-        stmt: native.AtomLossChannel,
+        stmt: noise.AtomLossChannel,
     ):
         qargs: List[reg.PyQrackQubit] = frame.get(stmt.qargs)
 

bloqade/pyqrack/qasm2/core.py

@@ -80,7 +80,10 @@ class PyQrackMethods(interp.MethodTable):
     @interp.impl(core.Reset)
     def reset(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: core.Reset):
         qarg: PyQrackQubit = frame.get(stmt.qarg)
-        qarg.sim_reg.force_m(qarg.addr, 0)
+
+        if bool(qarg.sim_reg.m(qarg.addr)):
+            qarg.sim_reg.x(qarg.addr)
+
         return ()
 
     @interp.impl(core.CRegEq)

bloqade/pyqrack/squin/op.py

@@ -10,6 +10,7 @@ from .runtime import (
     RotRuntime,
     KronRuntime,
     MultRuntime,
+    ResetRuntime,
     ScaleRuntime,
     AdjointRuntime,
     ControlRuntime,
@@ -94,6 +95,12 @@ class PyQrackMethods(interp.MethodTable):
         global_ = isinstance(stmt, op.stmts.PhaseOp)
         return (PhaseOpRuntime(theta, global_=global_),)
 
+    @interp.impl(op.stmts.Reset)
+    def reset(
+        self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: op.stmts.Reset
+    ) -> tuple[OperatorRuntimeABC]:
+        return (ResetRuntime(),)
+
     @interp.impl(op.stmts.X)
     @interp.impl(op.stmts.Y)
     @interp.impl(op.stmts.Z)

bloqade/pyqrack/squin/qubit.py

@@ -37,9 +37,11 @@ class PyQrackMethods(interp.MethodTable):
         qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
         operator.broadcast_apply(qubits)
 
-    def _measure_qubit(self, qbit: PyQrackQubit):
+    def _measure_qubit(self, qbit: PyQrackQubit, interp: PyQrackInterpreter):
         if qbit.is_active():
             return bool(qbit.sim_reg.m(qbit.addr))
+        else:
+            return interp.loss_m_result
 
     @interp.impl(qubit.MeasureQubitList)
     def measure_qubit_list(
@@ -49,7 +51,7 @@ class PyQrackMethods(interp.MethodTable):
         stmt: qubit.MeasureQubitList,
     ):
         qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
-        result = ilist.IList([self._measure_qubit(qbit) for qbit in qubits])
+        result = ilist.IList([self._measure_qubit(qbit, interp) for qbit in qubits])
         return (result,)
 
     @interp.impl(qubit.MeasureQubit)
@@ -57,29 +59,5 @@ class PyQrackMethods(interp.MethodTable):
         self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.MeasureQubit
     ):
         qbit: PyQrackQubit = frame.get(stmt.qubit)
-        result = self._measure_qubit(qbit)
+        result = self._measure_qubit(qbit, interp)
         return (result,)
-
-    @interp.impl(qubit.MeasureAndReset)
-    def measure_and_reset(
-        self,
-        interp: PyQrackInterpreter,
-        frame: interp.Frame,
-        stmt: qubit.MeasureAndReset,
-    ):
-        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
-        result = []
-        for qbit in qubits:
-            if qbit.is_active():
-                result.append(qbit.sim_reg.m(qbit.addr))
-            else:
-                result.append(None)
-            qbit.sim_reg.force_m(qbit.addr, 0)
-
-        return (ilist.IList(result),)
-
-    @interp.impl(qubit.Reset)
-    def reset(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: qubit.Reset):
-        qubits: ilist.IList[PyQrackQubit, Any] = frame.get(stmt.qubits)
-        for qbit in qubits:
-            qbit.sim_reg.force_m(qbit.addr, 0)

bloqade/pyqrack/squin/runtime.py

@@ -41,6 +41,24 @@ class OperatorRuntimeABC:
             self.apply(*targets, **kwargs)
 
 
+@dataclass(frozen=True)
+class ResetRuntime(OperatorRuntimeABC):
+    """Reset the qubit to |0> state"""
+
+    @property
+    def n_sites(self) -> int:
+        return 1
+
+    def apply(self, *qubits: PyQrackQubit, adjoint: bool = False) -> None:
+        for qubit in qubits:
+            if not qubit.is_active():
+                continue
+
+            res: bool = qubit.sim_reg.m(qubit.addr)
+            if res:
+                qubit.sim_reg.x(qubit.addr)
+
+
 @dataclass(frozen=True)
 class OperatorRuntime(OperatorRuntimeABC):
     method_name: str

bloqade/pyqrack/squin/wire.py

@@ -43,27 +43,9 @@ class PyQrackMethods(interp.MethodTable):
     ):
         w: PyQrackWire = frame.get(stmt.wire)
         qbit = w.qubit
-        res: int = qbit.sim_reg.m(qbit.addr)
-        return (res,)
 
-    @interp.impl(wire.MeasureAndReset)
-    def measure_and_reset(
-        self,
-        interp: PyQrackInterpreter,
-        frame: interp.Frame,
-        stmt: wire.MeasureAndReset,
-    ):
-        w: PyQrackWire = frame.get(stmt.wire)
-        qbit = w.qubit
-        res: int = qbit.sim_reg.m(qbit.addr)
-        qbit.sim_reg.force_m(qbit.addr, False)
-        new_w = PyQrackWire(qbit)
-        return (new_w, res)
+        if not qbit.is_active():
+            return (interp.loss_m_result,)
 
-    @interp.impl(wire.Reset)
-    def reset(self, interp: PyQrackInterpreter, frame: interp.Frame, stmt: wire.Reset):
-        w: PyQrackWire = frame.get(stmt.wire)
-        qbit = w.qubit
-        qbit.sim_reg.force_m(qbit.addr, False)
-        new_w = PyQrackWire(qbit)
-        return (new_w,)
+        res: bool = bool(qbit.sim_reg.m(qbit.addr))
+        return (res,)

bloqade/pyqrack/task.py

@@ -1,4 +1,4 @@
-from typing import TypeVar, ParamSpec
+from typing import TypeVar, ParamSpec, cast
 from dataclasses import dataclass
 
 from bloqade.task import AbstractSimulatorTask
@@ -19,12 +19,20 @@ class PyQrackSimulatorTask(AbstractSimulatorTask[Param, RetType, MemoryType]):
     pyqrack_interp: PyQrackInterpreter[MemoryType]
 
     def run(self) -> RetType:
-        return self.pyqrack_interp.run(
-            self.kernel,
-            args=self.args,
-            kwargs=self.kwargs,
+        return cast(
+            RetType,
+            self.pyqrack_interp.run(
+                self.kernel,
+                args=self.args,
+                kwargs=self.kwargs,
+            ),
         )
 
     @property
     def state(self) -> MemoryType:
         return self.pyqrack_interp.memory
+
+    def state_vector(self) -> list[complex]:
+        """Returns the state vector of the simulator."""
+        self.run()
+        return self.state.sim_reg.out_ket()

bloqade/qasm2/__init__.py

@@ -17,3 +17,4 @@ from .types import (
 )
 from .groups import gate as gate, main as main, extended as extended
 from ._wrappers import *  # noqa: F403
+from ._qasm_loading import loads as loads, loadfile as loadfile

bloqade/qasm2/_qasm_loading.py

@@ -0,0 +1,151 @@
+import os
+import logging
+import pathlib
+from typing import Any
+
+from kirin import ir, lowering
+from kirin.dialects import func
+
+from . import parse
+from .groups import main
+from .parse.lowering import QASM2
+
+
+def loads(
+    qasm: str,
+    *,
+    kernel_name: str = "main",
+    dialects: ir.DialectGroup | None = None,
+    returns: str | None = None,
+    globals: dict[str, Any] | None = None,
+    file: str | None = None,
+    lineno_offset: int = 0,
+    col_offset: int = 0,
+    compactify: bool = True,
+) -> ir.Method[[], None]:
+    """Loads a QASM2 string and returns the corresponding kernel object.
+
+    Args:
+        qasm (str): The QASM2 string 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 `qasm2.main`.
+        returns (str | None): The return type of the kernel. Defaults to None.
+        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 bloqade import qasm2
+    method = qasm2.loads('''
+    OPENQASM 2.0;
+    qreg q[2];
+    creg c[2];
+    h q[0];
+    cx q[0], q[1];
+    measure q[0] -> c[0];
+    ''')
+    ```
+    """
+    # TODO: add source info
+    stmt = parse.loads(qasm)
+    qasm2_lowering = QASM2(dialects or main)
+    frame = qasm2_lowering.get_frame(
+        stmt,
+        source=qasm,
+        file=file,
+        globals=globals,
+        lineno_offset=lineno_offset,
+        col_offset=col_offset,
+        compactify=compactify,
+    )
+
+    if returns is not None:
+        return_value = frame.get(returns)
+        if return_value is None:
+            raise lowering.BuildError(f"Cannot find return value {returns}")
+    else:
+        return_value = func.ConstantNone()
+        frame.push(return_value)
+
+    return_node = frame.push(func.Return(value_or_stmt=return_value))
+
+    body = frame.curr_region
+    code = func.Function(
+        sym_name=kernel_name,
+        signature=func.Signature((), return_node.value.type),
+        body=body,
+    )
+
+    return ir.Method(
+        mod=None,
+        py_func=None,
+        sym_name=kernel_name,
+        arg_names=[],
+        dialects=qasm2_lowering.dialects,
+        code=code,
+    )
+
+
+def loadfile(
+    qasm_file: str | pathlib.Path,
+    *,
+    kernel_name: str = "main",
+    dialects: ir.DialectGroup | None = None,
+    returns: str | None = None,
+    globals: dict[str, Any] | None = None,
+    file: str | None = None,
+    lineno_offset: int = 0,
+    col_offset: int = 0,
+    compactify: bool = True,
+) -> ir.Method[[], None]:
+    """Loads a QASM2 file and returns the corresponding kernel object. See also `loads`.
+
+    Args:
+        qasm_file (str): The QASM2 file 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 `qasm2.main`.
+        returns (str | None): The return type of the kernel. Defaults to None.
+        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.
+    """
+    if isinstance(file, pathlib.Path):
+        qasm_file_: pathlib.Path = qasm_file  # type: ignore
+    else:
+        qasm_file_ = pathlib.Path(*os.path.split(qasm_file))
+
+    if not qasm_file_.is_file():
+        raise FileNotFoundError(f"File {qasm_file_} does not exist")
+
+    if not qasm_file_.name.endswith(".qasm") or not qasm_file_.name.endswith(".qasm2"):
+        logging.warning(
+            f"File {qasm_file_} does not end with .qasm or .qasm2. "
+            "This may cause issues with loading the file."
+        )
+
+    kernel_name = file.name.replace(".qasm", "") if kernel_name is None else kernel_name
+
+    with qasm_file_.open("r") as f:
+        source = f.read()
+
+    return loads(
+        source,
+        kernel_name=kernel_name,
+        dialects=dialects,
+        returns=returns,
+        globals=globals,
+        file=file,
+        lineno_offset=lineno_offset,
+        col_offset=col_offset,
+        compactify=compactify,
+    )

bloqade/qasm2/dialects/core/__init__.py

@@ -1,3 +1,11 @@
 from . import _emit as _emit, address as address, _typeinfer as _typeinfer
-from .stmts import *  # noqa: F403
+from .stmts import (
+    Reset as Reset,
+    CRegEq as CRegEq,
+    CRegGet as CRegGet,
+    CRegNew as CRegNew,
+    Measure as Measure,
+    QRegGet as QRegGet,
+    QRegNew as QRegNew,
+)
 from ._dialect import dialect as dialect

bloqade/qasm2/dialects/expr/__init__.py

@@ -1,3 +1,20 @@
 from . import _emit as _emit, _interp as _interp, _from_python as _from_python
-from .stmts import *  # noqa: F403
+from .stmts import (
+    Add as Add,
+    Cos as Cos,
+    Div as Div,
+    Exp as Exp,
+    Log as Log,
+    Mul as Mul,
+    Neg as Neg,
+    Pow as Pow,
+    Sin as Sin,
+    Sub as Sub,
+    Tan as Tan,
+    Sqrt as Sqrt,
+    ConstPI as ConstPI,
+    ConstInt as ConstInt,
+    ConstFloat as ConstFloat,
+    GateFunction as GateFunction,
+)
 from ._dialect import dialect as dialect

bloqade/{noise/native → qasm2/dialects/noise}/__init__.py

@@ -2,7 +2,6 @@
 moving towards a more general approach to noise modeling in the future."""
 
 from .model import (
-    GateNoiseParams as GateNoiseParams,
     TwoRowZoneModel as TwoRowZoneModel,
     MoveNoiseModelABC as MoveNoiseModelABC,
 )
@@ -11,10 +10,5 @@ from .stmts import (
     CZPauliChannel as CZPauliChannel,
     AtomLossChannel as AtomLossChannel,
 )
-from .rewrite import RemoveNoisePass as RemoveNoisePass
 from ._dialect import dialect as dialect
-from ._wrappers import (
-    pauli_channel as pauli_channel,
-    cz_pauli_channel as cz_pauli_channel,
-    atom_loss_channel as atom_loss_channel,
-)
+from .fidelity import FidelityMethodTable as FidelityMethodTable

bloqade/qasm2/dialects/noise/_dialect.py

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

bloqade/{noise → qasm2/dialects/noise}/fidelity.py

@@ -1,14 +1,14 @@
 from kirin import interp
 from kirin.lattice import EmptyLattice
 
+from bloqade.analysis.address import AddressQubit, AddressTuple
 from bloqade.analysis.fidelity import FidelityAnalysis
 
-from .native import dialect as native
-from .native.stmts import PauliChannel, CZPauliChannel, AtomLossChannel
-from ..analysis.address import AddressQubit, AddressTuple
+from .stmts import PauliChannel, CZPauliChannel, AtomLossChannel
+from ._dialect import dialect
 
 
-@native.register(key="circuit.fidelity")
+@dialect.register(key="circuit.fidelity")
 class FidelityMethodTable(interp.MethodTable):
 
     @interp.impl(PauliChannel)