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

bloqade/squin/qubit.py

@@ -7,7 +7,7 @@ Depends on:
 - `kirin.dialects.ilist`: provides the `ilist.IListType` type for lists of qubits.
 """
 
-from typing import Any
+from typing import Any, overload
 
 from kirin import ir, types, lowering
 from kirin.decl import info, statement
@@ -35,21 +35,49 @@ class Apply(ir.Statement):
 
 
 @statement(dialect=dialect)
-class Measure(ir.Statement):
+class Broadcast(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall()})
+    operator: ir.SSAValue = info.argument(OpType)
+    qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType])
+
+
+@statement(dialect=dialect)
+class MeasureAny(ir.Statement):
+    name = "measure"
+
+    traits = frozenset({lowering.FromPythonCall()})
+    input: ir.SSAValue = info.argument(types.Any)
+    result: ir.ResultValue = info.result(types.Any)
+
+
+@statement(dialect=dialect)
+class MeasureQubit(ir.Statement):
+    name = "measure.qubit"
+
+    traits = frozenset({lowering.FromPythonCall()})
+    qubit: ir.SSAValue = info.argument(ilist.IListType[QubitType])
+    result: ir.ResultValue = info.result(ilist.IListType[types.Bool])
+
+
+@statement(dialect=dialect)
+class MeasureQubitList(ir.Statement):
+    name = "measure.qubit.list"
+
     traits = frozenset({lowering.FromPythonCall()})
     qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType])
-    result: ir.ResultValue = info.result(types.Int)
+    result: ir.ResultValue = info.result(ilist.IListType[types.Bool])
 
 
 @statement(dialect=dialect)
 class MeasureAndReset(ir.Statement):
     traits = frozenset({lowering.FromPythonCall()})
     qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType])
-    result: ir.ResultValue = info.result(types.Int)
+    result: ir.ResultValue = info.result(ilist.IListType[types.Bool])
 
 
 @statement(dialect=dialect)
 class Reset(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall()})
     qubits: ir.SSAValue = info.argument(ilist.IListType[QubitType])
 
 
@@ -71,6 +99,8 @@ def new(n_qubits: int) -> ilist.IList[Qubit, Any]:
 def apply(operator: Op, qubits: ilist.IList[Qubit, Any] | list[Qubit]) -> None:
     """Apply an operator to a list of qubits.
 
+    Note, that when considering atom loss, lost qubits will be skipped.
+
     Args:
         operator: The operator to apply.
         qubits: The list of qubits to apply the operator to. The size of the list
@@ -82,28 +112,66 @@ def apply(operator: Op, qubits: ilist.IList[Qubit, Any] | list[Qubit]) -> None:
     ...
 
 
-@wraps(Measure)
-def measure(qubits: ilist.IList[Qubit, Any]) -> int:
-    """Measure the qubits in the list."
+@overload
+def measure(input: Qubit) -> bool: ...
+@overload
+def measure(input: ilist.IList[Qubit, Any] | list[Qubit]) -> ilist.IList[bool, Any]: ...
+
+
+@wraps(MeasureAny)
+def measure(input: Any) -> Any:
+    """Measure a qubit or qubits in the list.
 
     Args:
-        qubits: The list of qubits to measure.
+        input: A qubit or a list of qubits to measure.
 
     Returns:
-        int: The result of the measurement.
+        bool | list[bool]: The result of the measurement. If a single qubit is measured,
+            a single boolean is returned. If a list of qubits is measured, a list of booleans
+            is returned.
+    """
+    ...
+
+
+@wraps(Broadcast)
+def broadcast(operator: Op, qubits: ilist.IList[Qubit, Any] | list[Qubit]) -> None:
+    """Broadcast and apply an operator to a list of qubits. For example, an operator
+    that expects 2 qubits can be applied to a list of 2n qubits, where n is an integer > 0.
+
+    For controlled operators, the list of qubits is interpreted as sets of (controls, targets).
+    For example
+
+    ```
+    apply(CX, [q0, q1, q2, q3])
+    ```
+
+    is equivalent to
+
+    ```
+    apply(CX, [q0, q1])
+    apply(CX, [q2, q3])
+    ```
+
+    Args:
+        operator: The operator to broadcast and apply.
+        qubits: The list of qubits to broadcast and apply the operator to. The size of the list
+            must be inferable and match the number of qubits expected by the operator.
+
+    Returns:
+        None
     """
     ...
 
 
 @wraps(MeasureAndReset)
-def measure_and_reset(qubits: ilist.IList[Qubit, Any]) -> int:
+def measure_and_reset(qubits: ilist.IList[Qubit, Any]) -> ilist.IList[bool, Any]:
     """Measure the qubits in the list and reset them."
 
     Args:
         qubits: The list of qubits to measure and reset.
 
     Returns:
-        int: The result of the measurement.
+        list[bool]: The result of the measurement.
     """
     ...
 

bloqade/squin/rewrite/measure_desugar.py

@@ -0,0 +1,33 @@
+from kirin import ir, types
+from kirin.dialects import ilist
+from kirin.rewrite.abc import RewriteRule, RewriteResult
+
+from bloqade.squin.qubit import QubitType, MeasureAny, MeasureQubit, MeasureQubitList
+
+
+class MeasureDesugarRule(RewriteRule):
+    """
+    Desugar measure operations in the circuit.
+    """
+
+    def rewrite_Statement(self, node: ir.Statement) -> RewriteResult:
+
+        if not isinstance(node, MeasureAny):
+            return RewriteResult()
+
+        if node.input.type.is_subseteq(QubitType):
+            node.replace_by(
+                MeasureQubit(
+                    qubit=node.input,
+                )
+            )
+            return RewriteResult(has_done_something=True)
+        elif node.input.type.is_subseteq(ilist.IListType[QubitType, types.Any]):
+            node.replace_by(
+                MeasureQubitList(
+                    qubits=node.input,
+                )
+            )
+            return RewriteResult(has_done_something=True)
+
+        return RewriteResult()

bloqade/squin/wire.py

@@ -8,10 +8,11 @@ dialect.
 
 from kirin import ir, types, interp, lowering
 from kirin.decl import info, statement
+from kirin.lowering import wraps
 
-from bloqade.types import QubitType
+from bloqade.types import Qubit, QubitType
 
-from .op.types import OpType
+from .op.types import Op, OpType
 
 # from kirin.lowering import wraps
 
@@ -68,6 +69,25 @@ class Apply(ir.Statement):  # apply(op, w1, w2, ...)
         )  # custom lowering required for wrapper to work here
 
 
+# Carry over from Qubit dialect
+@statement(dialect=dialect)
+class Broadcast(ir.Statement):
+    traits = frozenset({lowering.FromPythonCall(), ir.Pure()})
+    operator: ir.SSAValue = info.argument(OpType)
+    inputs: tuple[ir.SSAValue, ...] = info.argument(WireType)
+
+    def __init__(self, operator: ir.SSAValue, *args: ir.SSAValue):
+        result_types = tuple(WireType for _ in args)
+        super().__init__(
+            args=(operator,) + args,
+            result_types=result_types,
+            args_slice={
+                "operator": 0,
+                "inputs": slice(1, None),
+            },  # pretty printing + syntax sugar
+        )  # custom lowering required for wrapper to work here
+
+
 # NOTE: measurement cannot be pure because they will collapse the state
 #       of the qubit. The state is a hidden state that is not visible to
 #      the user in the wire dialect.
@@ -98,6 +118,15 @@ class Reset(ir.Statement):
 class ConstPropWire(interp.MethodTable):
 
     @interp.impl(Apply)
+    @interp.impl(Broadcast)
     def apply(self, interp, frame, stmt: Apply):
 
         return frame.get_values(stmt.inputs)
+
+
+@wraps(Unwrap)
+def unwrap(qubit: Qubit) -> Wire: ...
+
+
+@wraps(Apply)
+def apply(op: Op, w: Wire) -> Wire: ...

bloqade/stim/emit/stim.py

@@ -49,6 +49,6 @@ class FuncEmit(interp.MethodTable):
 
     @interp.impl(func.Function)
     def emit_func(self, emit: EmitStimMain, frame: EmitStrFrame, stmt: func.Function):
-        _ = emit.run_ssacfg_region(frame, stmt.body)
+        _ = emit.run_ssacfg_region(frame, stmt.body, ())
         # emit.output = "\n".join(frame.body)
         return ()

bloqade/task.py

@@ -0,0 +1,94 @@
+import abc
+from typing import Any, Generic, Literal, TypeVar, ParamSpec
+from dataclasses import dataclass
+
+from kirin import ir
+
+Params = ParamSpec("Params")
+RetType = TypeVar("RetType")
+
+
+class BatchFuture(abc.ABC, Generic[RetType]):
+    """Protocol for future objects that can be awaited."""
+
+    MISSING_RESULT = Literal[None]
+
+    @abc.abstractmethod
+    def result(self, timeout: float | None) -> list[RetType]:
+        """Returns the result of the future, blocking until it is available or the timeout expires."""
+
+    @abc.abstractmethod
+    def partial_result(self) -> list[RetType | MISSING_RESULT]:
+        """Return all results that are available so far, or MISSING_RESULT for those that are not yet available."""
+
+    @abc.abstractmethod
+    def fetch(self) -> None:
+        """Fetches the result of the future that are currently available."""
+
+    def cancel(self):
+        """Attempts to cancel the execution of the future."""
+        raise NotImplementedError(
+            f"cancel method not implemented for {self.__class__.__name__}"
+        )
+
+    def cancelled(self) -> bool:
+        """Returns True if the future was cancelled, False otherwise."""
+        raise NotImplementedError(
+            f"cancelled method not implemented for {self.__class__.__name__}"
+        )
+
+    def done(self) -> bool:
+        self.fetch()
+        return not any(
+            result is self.MISSING_RESULT for result in self.partial_result()
+        )
+
+
+ClassRetType = TypeVar("ClassRetType")
+
+
+@dataclass
+class AbstractTask(abc.ABC, Generic[Params, RetType]):
+    kernel: ir.Method[Params, RetType]
+    args: tuple[Any, ...]
+    kwargs: dict[str, Any]
+
+
+class DeviceTaskExpectMixin(AbstractTask):
+
+    ObsType = TypeVar("ObsType")
+
+    @abc.abstractmethod
+    def expect(self, observable: ir.Method[[RetType], ObsType], shots: int) -> ObsType:
+        """Returns the expectation value of the given observable after running the task."""
+
+
+@dataclass
+class AbstractRemoteTask(AbstractTask[Params, RetType]):
+    """Base class for tasks generated by the devices."""
+
+    def run(self, *, shots: int = 1, timeout: float | None = None) -> list[RetType]:
+        return self.run_async(shots=shots).result(timeout=timeout)
+
+    @abc.abstractmethod
+    def run_async(self, *, shots: int = 1) -> BatchFuture[RetType]:
+        """Executes the kernel asynchronously and returns a Future object."""
+
+
+StateType = TypeVar("StateType")
+
+
+@dataclass
+class AbstractSimulatorTask(
+    AbstractTask[Params, RetType], Generic[Params, RetType, StateType]
+):
+    """Base class for tasks generated by local simulators."""
+
+    @abc.abstractmethod
+    def run(self) -> RetType:
+        """Executes the kernel and returns the result."""
+
+    @property
+    @abc.abstractmethod
+    def state(self) -> StateType:
+        """Returns the state of the simulator after running the task."""

bloqade/visual/animation/base.py

@@ -45,10 +45,12 @@ class GateArtist:
 class GlobalGateArtist(GateArtist):
     mpl_obj: mpatches.Rectangle
 
-    def __init__(self, mpl_ax: Any, xmin, ymin, width, height, color):
+    def __init__(
+        self, mpl_ax: Any, xmin: float, ymin: float, width: float, height: float, color
+    ):
         super().__init__(mpl_ax)
         rc = mpatches.Rectangle(
-            [xmin, ymin], width, height, color=color, alpha=0.6, visible=False
+            (xmin, ymin), width, height, color=color, alpha=0.6, visible=False
         )
         mpl_ax.add_patch(rc)
         self.mpl_obj = rc
@@ -56,7 +58,7 @@ class GlobalGateArtist(GateArtist):
     def clear_data(self) -> None:
         self.mpl_obj.set_width(0)
         self.mpl_obj.set_height(0)
-        self.mpl_obj.set_xy([0, 0])
+        self.mpl_obj.set_xy((0, 0))
 
     def get_artists(self) -> Tuple[Any]:
         return (self.mpl_obj,)
@@ -86,7 +88,7 @@ class RowRegionGateArtist(GateArtist):
         self.width = width
         self.xmin = xmin
         rc_btm = mpatches.Rectangle(
-            [xmin, ymin_keepout],
+            (xmin, ymin_keepout),
             width,
             ymin - ymin_keepout,
             color=color,
@@ -97,13 +99,13 @@ class RowRegionGateArtist(GateArtist):
         self.mpl_obj_keepout_btm = rc_btm
 
         rc = mpatches.Rectangle(
-            [xmin, ymin], width, ymax - ymin, color=color, alpha=0.6, visible=False
+            (xmin, ymin), width, ymax - ymin, color=color, alpha=0.6, visible=False
         )
         mpl_ax.add_patch(rc)
         self.mpl_obj = rc
 
         rc_top = mpatches.Rectangle(
-            [xmin, ymax],
+            (xmin, ymax),
             width,
             ymax_keepout - ymax,
             color=color,
@@ -116,31 +118,31 @@ class RowRegionGateArtist(GateArtist):
     def clear_data(self) -> None:
         self.mpl_obj.set_width(0)
         self.mpl_obj.set_height(0)
-        self.mpl_obj.set_xy([0, 0])
+        self.mpl_obj.set_xy((0, 0))
 
         self.mpl_obj_keepout_top.set_width(0)
         self.mpl_obj_keepout_top.set_height(0)
-        self.mpl_obj_keepout_top.set_xy([0, 0])
+        self.mpl_obj_keepout_top.set_xy((0, 0))
 
         self.mpl_obj_keepout_btm.set_width(0)
         self.mpl_obj_keepout_btm.set_height(0)
-        self.mpl_obj_keepout_btm.set_xy([0, 0])
+        self.mpl_obj_keepout_btm.set_xy((0, 0))
 
-    def get_artists(self) -> Tuple[Any]:
+    def get_artists(self) -> Tuple[Any, ...]:
         return (self.mpl_obj, self.mpl_obj_keepout_top, self.mpl_obj_keepout_btm)
 
     def update_data(self, ymin, ymax, ymin_keepout, ymax_keepout):
         self.mpl_obj.set_height(ymax - ymin)
         self.mpl_obj.set_width(self.width)
-        self.mpl_obj.set_xy([self.xmin, ymin])
+        self.mpl_obj.set_xy((self.xmin, ymin))
 
         self.mpl_obj_keepout_top.set_height(ymax_keepout - ymax)
         self.mpl_obj_keepout_top.set_width(self.width)
-        self.mpl_obj_keepout_top.set_xy([self.xmin, ymax])
+        self.mpl_obj_keepout_top.set_xy((self.xmin, ymax))
 
         self.mpl_obj_keepout_btm.set_height(ymin - ymin_keepout)
         self.mpl_obj_keepout_btm.set_width(self.width)
-        self.mpl_obj_keepout_btm.set_xy([self.xmin, ymin_keepout])
+        self.mpl_obj_keepout_btm.set_xy((self.xmin, ymin_keepout))
 
     def set_visible(self, visible: bool):
         self.mpl_obj.set_visible(visible)
@@ -194,11 +196,19 @@ class FieldOfView:
         )
 
     @property
-    def width(self):
+    def width(self) -> float:
+        if self.xmax is None or self.xmin is None:
+            raise ValueError(
+                "Can't return width of FOV as either xmin or xmax are undefined"
+            )
         return self.xmax - self.xmin
 
     @property
-    def height(self):
+    def height(self) -> float:
+        if self.ymax is None or self.ymin is None:
+            raise ValueError(
+                "Can't return width of FOV as either ymin or ymax are undefined"
+            )
         return self.ymax - self.ymin
 
     def to_json(self):

{bloqade_circuit-0.1.0.dist-info → bloqade_circuit-0.2.0.dist-info}/METADATA

@@ -1,19 +1,25 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.1.0
+Version: 0.2.0
 Summary: The software development toolkit for neutral atom arrays.
 Author-email: Roger-luo <rluo@quera.com>, kaihsin <khwu@quera.com>, weinbe58 <pweinberg@quera.com>, johnzl-777 <jlong@quera.com>
 License-File: LICENSE
 Requires-Python: >=3.10
-Requires-Dist: kirin-toolchain~=0.16.0
+Requires-Dist: kirin-toolchain~=0.17.0
 Requires-Dist: numpy>=1.22.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pydantic<2.11.0,>=1.3.0
+Requires-Dist: pyqrack-cpu>=1.38.2; sys_platform != 'darwin'
+Requires-Dist: pyqrack>=1.38.2; sys_platform == 'darwin'
 Requires-Dist: rich>=13.9.4
 Requires-Dist: scipy>=1.13.1
 Provides-Extra: cirq
 Requires-Dist: cirq-core>=1.4.1; extra == 'cirq'
 Requires-Dist: cirq-core[contrib]>=1.4.1; extra == 'cirq'
+Provides-Extra: pyqrack-cuda
+Requires-Dist: pyqrack-cuda>=1.38.2; extra == 'pyqrack-cuda'
+Provides-Extra: pyqrack-opencl
+Requires-Dist: pyqrack>=1.38.2; (sys_platform != 'darwin') and extra == 'pyqrack-opencl'
 Provides-Extra: qasm2
 Requires-Dist: lark>=1.2.2; extra == 'qasm2'
 Provides-Extra: qbraid