bloqade-circuit 0.2.3__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/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

@@ -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/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

bloqade/qasm2/dialects/noise.py

@@ -1,7 +1,9 @@
-from kirin import ir, types, lowering
+from kirin import ir, types, interp, lowering
 from kirin.decl import info, statement
 
+from bloqade.qasm2.parse import ast
 from bloqade.qasm2.types import QubitType
+from bloqade.qasm2.emit.gate import EmitQASM2Gate, EmitQASM2Frame
 
 dialect = ir.Dialect("qasm2.noise")
 
@@ -14,3 +16,33 @@ class Pauli1(ir.Statement):
     py: ir.SSAValue = info.argument(types.Float)
     pz: ir.SSAValue = info.argument(types.Float)
     qarg: ir.SSAValue = info.argument(QubitType)
+
+
+@dialect.register(key="emit.qasm2.gate")
+class NoiseEmit(interp.MethodTable):
+
+    @interp.impl(Pauli1)
+    def emit_pauli(
+        self,
+        emit: EmitQASM2Gate,
+        frame: EmitQASM2Frame,
+        stmt: Pauli1,
+    ):
+
+        px: ast.Number = frame.get(stmt.px)
+        py: ast.Number = frame.get(stmt.py)
+        pz: ast.Number = frame.get(stmt.pz)
+        qarg: ast.Bit | ast.Name = frame.get(stmt.qarg)
+
+        qarg_str = (
+            f"{qarg.name.id}[{qarg.addr}]"
+            if isinstance(qarg, ast.Bit)
+            else f"{qarg.id}"
+        )
+
+        frame.body.append(
+            ast.Comment(
+                text=f"noise.Pauli1({px.value}, {py.value}, {pz.value}) {qarg_str}]"
+            )
+        )
+        return ()

bloqade/qasm2/dialects/uop/__init__.py

@@ -1,4 +1,40 @@
-from . import _emit as _emit, stmts as stmts
-from .stmts import *  # noqa: F403
+from . import _emit as _emit, stmts as stmts, schedule as schedule
+from .stmts import (
+    CH as CH,
+    CU as CU,
+    CX as CX,
+    CY as CY,
+    CZ as CZ,
+    RX as RX,
+    RY as RY,
+    RZ as RZ,
+    SX as SX,
+    U1 as U1,
+    U2 as U2,
+    CCX as CCX,
+    CRX as CRX,
+    CRY as CRY,
+    CRZ as CRZ,
+    CSX as CSX,
+    CU1 as CU1,
+    CU3 as CU3,
+    RXX as RXX,
+    RZZ as RZZ,
+    H as H,
+    S as S,
+    T as T,
+    X as X,
+    Y as Y,
+    Z as Z,
+    Id as Id,
+    Sdag as Sdag,
+    Swap as Swap,
+    Tdag as Tdag,
+    CSwap as CSwap,
+    SXdag as SXdag,
+    UGate as UGate,
+    Barrier as Barrier,
+    SingleQubitGate as SingleQubitGate,
+    TwoQubitCtrlGate as TwoQubitCtrlGate,
+)
 from ._dialect import dialect as dialect
-from .schedule import *  # noqa: F403

bloqade/qasm2/dialects/uop/schedule.py

@@ -8,7 +8,7 @@ from ._dialect import dialect
 
 
 @dialect.register(key="qasm2.schedule.dag")
-class UOp(interp.MethodTable):
+class UOpSchedule(interp.MethodTable):
 
     @interp.impl(stmts.Id)
     @interp.impl(stmts.SXdag)

bloqade/qasm2/emit/impls/__init__.py

@@ -0,0 +1 @@
+from . import noise_native as noise_native

bloqade/qasm2/emit/impls/noise_native.py

@@ -0,0 +1,89 @@
+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.emit.gate import EmitQASM2Gate, EmitQASM2Frame
+
+
+@native.dialect.register(key="emit.qasm2.gate")
+class NativeNoise(interp.MethodTable):
+
+    def _convert(self, node: ast.Bit | ast.Name) -> str:
+        if isinstance(node, ast.Bit):
+            return f"{node.name.id}[{node.addr}]"
+        else:
+            return f"{node.id}"
+
+    @interp.impl(native.CZPauliChannel)
+    def emit_czp(
+        self,
+        emit: EmitQASM2Gate,
+        frame: EmitQASM2Frame,
+        stmt: native.CZPauliChannel,
+    ):
+        paired: bool = stmt.paired
+        px_ctrl: float = stmt.px_ctrl
+        py_ctrl: float = stmt.py_ctrl
+        pz_ctrl: float = stmt.pz_ctrl
+        px_qarg: float = stmt.pz_qarg
+        py_qarg: float = stmt.py_qarg
+        pz_qarg: float = stmt.pz_qarg
+        ctrls: ilist.IList[ast.Bit, Any] = frame.get(stmt.ctrls)
+        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}])"
+            )
+        )
+        frame.body.append(
+            ast.Comment(
+                text=f" -: ctrls: {', '.join([self._convert(q) for q in ctrls])}"
+            )
+        )
+        frame.body.append(
+            ast.Comment(
+                text=f" -: qargs: {', '.join([self._convert(q) for q in qargs])}"
+            )
+        )
+        return ()
+
+    @interp.impl(native.AtomLossChannel)
+    def emit_loss(
+        self,
+        emit: EmitQASM2Gate,
+        frame: EmitQASM2Frame,
+        stmt: native.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" -: qargs: {', '.join([self._convert(q) for q in qargs])}"
+            )
+        )
+        return ()
+
+    @interp.impl(native.PauliChannel)
+    def emit_pauli(
+        self,
+        emit: EmitQASM2Gate,
+        frame: EmitQASM2Frame,
+        stmt: native.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})")
+        )
+        frame.body.append(
+            ast.Comment(
+                text=f" -: qargs: {', '.join([self._convert(q) for q in qargs])}"
+            )
+        )
+        return ()