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

bloqade/analysis/address/impls.py

@@ -206,6 +206,20 @@ class SquinWireMethodTable(interp.MethodTable):
     ):
         return frame.get_values(stmt.inputs)
 
+    @interp.impl(squin.wire.MeasureAndReset)
+    def measure_and_reset(
+        self,
+        interp_: AddressAnalysis,
+        frame: ForwardFrame[Address],
+        stmt: squin.wire.MeasureAndReset,
+    ):
+
+        # take the address data from the incoming wire
+        # and propagate that forward to the new wire generated.
+        # The first entry can safely be NotQubit because
+        # it's an integer
+        return (NotQubit(), frame.get(stmt.wire))
+
 
 @squin.qubit.dialect.register(key="qubit.address")
 class SquinQubitMethodTable(interp.MethodTable):

bloqade/analysis/fidelity/analysis.py

@@ -13,22 +13,47 @@ from ..address import AddressAnalysis
 class FidelityAnalysis(Forward):
     """
     This analysis pass can be used to track the global addresses of qubits and wires.
+
+    ## Usage examples
+
+    ```
+    from bloqade import qasm2
+    from bloqade.noise import native
+    from bloqade.analysis.fidelity import FidelityAnalysis
+    from bloqade.qasm2.passes.noise import NoisePass
+
+    noise_main = qasm2.extended.add(native.dialect)
+
+    @noise_main
+    def main():
+        q = qasm2.qreg(2)
+        qasm2.x(q[0])
+        return q
+
+    NoisePass(main.dialects)(main)
+
+    fid_analysis = FidelityAnalysis(main.dialects)
+    fid_analysis.run_analysis(main, no_raise=False)
+
+    gate_fidelity = fid_analysis.gate_fidelity
+    atom_survival_probs = fid_analysis.atom_survival_probability
+    ```
     """
 
     keys = ["circuit.fidelity"]
     lattice = EmptyLattice
 
+    gate_fidelity: float = 1.0
     """
     The fidelity of the gate set described by the analysed program. It reduces whenever a noise channel is encountered.
     """
-    gate_fidelity: float = 1.0
 
     _current_gate_fidelity: float = field(init=False)
 
+    atom_survival_probability: list[float] = field(init=False)
     """
     The probabilities that each of the atoms in the register survive the duration of the analysed program. The order of the list follows the order they are in the register.
     """
-    atom_survival_probability: list[float] = field(init=False)
 
     _current_atom_survival_probability: list[float] = field(init=False)
 

bloqade/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 import dialect
 from .native.stmts import PauliChannel, CZPauliChannel, AtomLossChannel
-from ..analysis.address import AddressQubit, AddressTuple
 
 
-@native.register(key="circuit.fidelity")
+@dialect.register(key="circuit.fidelity")
 class FidelityMethodTable(interp.MethodTable):
 
     @interp.impl(PauliChannel)

bloqade/noise/native/_dialect.py

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

bloqade/noise/native/_wrappers.py

@@ -8,21 +8,34 @@ from bloqade.qasm2.types import Qubit
 
 
 @wraps(native.AtomLossChannel)
-def atom_loss_channel(
-    qargs: ilist.IList[Qubit, Any] | list, *, prob: float
-) -> None: ...
+def atom_loss_channel(qargs: ilist.IList[Qubit, Any] | list, *, prob: float) -> None:
+    """Apply an atom loss channel to a list of qubits.
+
+    Args:
+        qargs (ilist.IList[Qubit, Any] | list): List of qubits to apply the noise to.
+        prob (float): The loss probability.
+    """
+    ...
 
 
 @wraps(native.PauliChannel)
 def pauli_channel(
     qargs: ilist.IList[Qubit, Any] | list, *, px: float, py: float, pz: float
-) -> None: ...
+) -> None:
+    """Apply a Pauli channel to a list of qubits.
+
+    Args:
+        qargs (ilist.IList[Qubit, Any] | list): List of qubits to apply the noise to.
+        px (float): Probability of X error.
+        py (float): Probability of Y error.
+        pz (float): Probability of Z error.
+    """
 
 
 @wraps(native.CZPauliChannel)
 def cz_pauli_channel(
     ctrls: ilist.IList[Qubit, Any] | list,
-    qarg2: ilist.IList[Qubit, Any] | list,
+    qargs: ilist.IList[Qubit, Any] | list,
     *,
     px_ctrl: float,
     py_ctrl: float,
@@ -31,4 +44,20 @@ def cz_pauli_channel(
     py_qarg: float,
     pz_qarg: float,
     paired: bool,
-) -> None: ...
+) -> None:
+    """Insert noise for a CZ gate with a Pauli channel on qubits.
+
+    Args:
+        ctrls: List of control qubits.
+        qarg2: List of target qubits.
+        px_ctrl: Probability of X error on control qubits.
+        py_ctrl: Probability of Y error on control qubits.
+        pz_ctrl: Probability of Z error on control qubits.
+        px_qarg: Probability of X error on target qubits.
+        py_qarg: Probability of Y error on target qubits.
+        pz_qarg: Probability of Z error on target qubits.
+        paired: If True, the noise is applied to both control and target qubits
+            are not lost otherwise skip this error. If False Apply the noise on
+            the whatever qubit is not lost.
+    """
+    ...

bloqade/noise/native/stmts.py

@@ -4,7 +4,7 @@ from kirin import ir, types, lowering
 from kirin.decl import info, statement
 from kirin.dialects import ilist
 
-from bloqade.qasm2.types import QubitType
+from bloqade.types import QubitType
 
 from ._dialect import dialect
 

bloqade/pyqrack/device.py

@@ -25,7 +25,11 @@ Params = ParamSpec("Params")
 
 @dataclass
 class PyQrackSimulatorBase(AbstractSimulatorDevice[PyQrackSimulatorTask]):
+    """PyQrack simulation device base class."""
+
     options: PyQrackOptions = field(default_factory=_default_pyqrack_args)
+    """options (PyQrackOptions): options passed into the pyqrack simulator."""
+
     loss_m_result: Measurement = field(default=Measurement.One, kw_only=True)
     rng_state: np.random.Generator = field(
         default_factory=np.random.default_rng, kw_only=True
@@ -60,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:
@@ -96,12 +98,48 @@ class PyQrackSimulatorBase(AbstractSimulatorDevice[PyQrackSimulatorTask]):
         if len(qubit_ids) != len(set(qubit_ids)):
             raise ValueError("Qubits must be unique.")
 
-        return sim_reg.pauli_expectation(pauli, qubit_ids)
+        return sim_reg.pauli_expectation(qubit_ids, pauli)
 
 
 @dataclass
 class StackMemorySimulator(PyQrackSimulatorBase):
-    """PyQrack simulator device with precalculated stack of qubits."""
+    """
+    PyQrack simulator device with preallocated stack of qubits.
+
+    This can be used to simulate kernels where the number of qubits is known
+    ahead of time.
+
+    ## Usage examples
+
+    ```
+    # Define a kernel
+    @qasm2.main
+    def main():
+        q = qasm2.qreg(2)
+        c = qasm2.creg(2)
+
+        qasm2.h(q[0])
+        qasm2.cx(q[0], q[1])
+
+        qasm2.measure(q, c)
+        return q
+
+    # Create the simulator object
+    sim = StackMemorySimulator(min_qubits=2)
+
+    # Execute the kernel
+    qubits = sim.run(main)
+    ```
+
+    You can also obtain other information from it, such as the state vector:
+
+    ```
+    ket = sim.state_vector(main)
+
+    from pyqrack.pauli import Pauli
+    expectation_vals = sim.pauli_expectation([Pauli.PauliX, Pauli.PauliI], qubits)
+    ```
+    """
 
     min_qubits: int = field(default=0, kw_only=True)
 
@@ -111,6 +149,20 @@ class StackMemorySimulator(PyQrackSimulatorBase):
         args: tuple[Any, ...] = (),
         kwargs: dict[str, Any] | None = None,
     ):
+        """
+        Args:
+            kernel (ir.Method):
+                The kernel method to run.
+            args (tuple[Any, ...]):
+                Positional arguments to pass to the kernel method.
+            kwargs (dict[str, Any] | None):
+                Keyword arguments to pass to the kernel method.
+
+        Returns:
+            PyQrackSimulatorTask:
+                The task object used to track execution.
+
+        """
         if kwargs is None:
             kwargs = {}
 
@@ -136,7 +188,44 @@ class StackMemorySimulator(PyQrackSimulatorBase):
 
 @dataclass
 class DynamicMemorySimulator(PyQrackSimulatorBase):
-    """PyQrack simulator device with dynamic qubit allocation."""
+    """
+
+    PyQrack simulator device with dynamic qubit allocation.
+
+    This can be used to simulate kernels where the number of qubits is not known
+    ahead of time.
+
+    ## Usage examples
+
+    ```
+    # Define a kernel
+    @qasm2.main
+    def main():
+        q = qasm2.qreg(2)
+        c = qasm2.creg(2)
+
+        qasm2.h(q[0])
+        qasm2.cx(q[0], q[1])
+
+        qasm2.measure(q, c)
+        return q
+
+    # Create the simulator object
+    sim = DynamicMemorySimulator()
+
+    # Execute the kernel
+    qubits = sim.run(main)
+    ```
+
+    You can also obtain other information from it, such as the state vector:
+
+    ```
+    ket = sim.state_vector(main)
+
+    from pyqrack.pauli import Pauli
+    expectation_vals = sim.pauli_expectation([Pauli.PauliX, Pauli.PauliI], qubits)
+
+    """
 
     def task(
         self,
@@ -144,23 +233,22 @@ class DynamicMemorySimulator(PyQrackSimulatorBase):
         args: tuple[Any, ...] = (),
         kwargs: dict[str, Any] | None = None,
     ):
+        """
+        Args:
+            kernel (ir.Method):
+                The kernel method to run.
+            args (tuple[Any, ...]):
+                Positional arguments to pass to the kernel method.
+            kwargs (dict[str, Any] | None):
+                Keyword arguments to pass to the kernel method.
+
+        Returns:
+            PyQrackSimulatorTask:
+                The task object used to track execution.
+
+        """
         if kwargs is None:
             kwargs = {}
 
         memory = DynamicMemory(self.options.copy())
         return self.new_task(kernel, args, kwargs, memory)
-
-
-def test():
-    from bloqade.qasm2 import extended
-
-    @extended
-    def main():
-        return 1
-
-    @extended
-    def obs(result: int) -> int:
-        return result
-
-    res = DynamicMemorySimulator().task(main)
-    return res.run()

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/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,7 +59,7 @@ 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)
@@ -70,11 +72,12 @@ class PyQrackMethods(interp.MethodTable):
         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)
+            qbit_result = self._measure_qubit(qbit, interp)
+
+            if qbit_result:
+                qbit.sim_reg.x(qbit.addr)
+
+            result.append(qbit_result)
 
         return (ilist.IList(result),)
 
@@ -82,4 +85,8 @@ class PyQrackMethods(interp.MethodTable):
     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)
+            if not qbit.is_active():
+                continue
+
+            if bool(qbit.sim_reg.m(qbit.addr)):
+                qbit.sim_reg.x(qbit.addr)

bloqade/pyqrack/squin/wire.py

@@ -43,7 +43,11 @@ class PyQrackMethods(interp.MethodTable):
     ):
         w: PyQrackWire = frame.get(stmt.wire)
         qbit = w.qubit
-        res: int = qbit.sim_reg.m(qbit.addr)
+
+        if not qbit.is_active():
+            return (interp.loss_m_result,)
+
+        res: bool = bool(qbit.sim_reg.m(qbit.addr))
         return (res,)
 
     @interp.impl(wire.MeasureAndReset)
@@ -55,8 +59,16 @@ class PyQrackMethods(interp.MethodTable):
     ):
         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)
+
+        if not qbit.is_active():
+            return (w, interp.loss_m_result)
+
+        res: bool = bool(qbit.sim_reg.m(qbit.addr))
+
+        if res:
+            qbit.sim_reg.x(qbit.addr)
+
+        # TODO: do we need to rewrap this here? The qbit changed in-place
         new_w = PyQrackWire(qbit)
         return (new_w, res)
 
@@ -64,6 +76,12 @@ class PyQrackMethods(interp.MethodTable):
     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)
+
+        if not qbit.is_active():
+            return (w,)
+
+        if bool(qbit.sim_reg.m(qbit.addr)):
+            qbit.sim_reg.x(qbit.addr)
+
         new_w = PyQrackWire(qbit)
         return (new_w,)

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