bloqade-circuit 0.7.5__tar.gz → 0.7.6__tar.gz

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.7.5
+Version: 0.7.6
 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

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bloqade-circuit"
-version = "0.7.5"
+version = "0.7.6"
 description = "The software development toolkit for neutral atom arrays."
 readme = "README.md"
 authors = [

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.6}/src/bloqade/pyqrack/device.py

@@ -1,4 +1,4 @@
-from typing import Any, TypeVar, ParamSpec
+from typing import Any, TypeVar, ParamSpec, NamedTuple
 from dataclasses import field, dataclass
 
 import numpy as np
@@ -28,9 +28,99 @@ RetType = TypeVar("RetType")
 Params = ParamSpec("Params")
 
 
+class QuantumState(NamedTuple):
+    """
+    A representation of a quantum state as a density matrix, where the density matrix is
+    rho = sum_i eigenvalues[i] |eigenvectors[:,i]><eigenvectors[:,i]|.
+
+    This reprsentation is efficient for low-rank density matrices by only storing
+    the non-zero eigenvalues and corresponding eigenvectors of the density matrix.
+    For example, a pure state has only one non-zero eigenvalue equal to 1.0.
+
+    Endianness and qubit ordering of the state vector is consistent with Cirq, where
+    eigenvectors[0,0] corresponds to the amplitude of the |00..000> element of the zeroth eigenvector;
+    eigenvectors[1,0] corresponds to the amplitude of the |00..001> element of the zeroth eigenvector;
+    eigenvectors[3,0] corresponds to the amplitude of the |00..011> element of the zeroth eigenvector;
+    eigenvectors[-1,0] corresponds to the amplitude of the |11..111> element of the zeroth eigenvector.
+    A flip of the LAST bit |00..000><00..001| corresponds to applying a PauliX gate to the FIRST qubit.
+    A flip of the FIRST bit |00..000><10..000| corresponds to applying a PauliX gate to the LAST qubit.
+
+    Attributes:
+        eigenvalues (1d np.ndarray):
+            The non-zero eigenvalues of the density matrix.
+        eigenvectors (2d np.ndarray):
+            The corresponding eigenvectors of the density matrix,
+            where eigenvectors[:,i] is the i-th eigenvector.
+    Methods:
+        Not Implemented, pending https://github.com/QuEraComputing/bloqade-circuit/issues/447
+    """
+
+    eigenvalues: np.ndarray
+    eigenvectors: np.ndarray
+
+    def canonicalize(self, tol: float = 1e-12) -> "QuantumState":
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+    def __add__(self, other: "QuantumState") -> "QuantumState":
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+    def __mul__(self, scalar: float) -> "QuantumState":
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+    @property
+    def dense(self) -> np.ndarray[tuple[int, int], np.complexfloating]:
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+    def __matmul__(self, right: "cirq.Circuit") -> "QuantumState":  # noqa: F821
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+    def expect(self, operator: Any) -> float:
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+    def probability(self) -> np.ndarray[tuple[int], np.floating]:
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+    def von_neumann_entropy(self) -> float:
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+    @property
+    def qubit_basis(self) -> list[PyQrackQubit]:
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+    def reduced_density_matrix(
+        self, qubits: list[PyQrackQubit], tol: float = 1e-12
+    ) -> "QuantumState":
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+    def overlap(self, other: "QuantumState") -> complex:
+        raise NotImplementedError(
+            "https://github.com/QuEraComputing/bloqade-circuit/issues/447"
+        )
+
+
 def _pyqrack_reduced_density_matrix(
     inds: tuple[int, ...], sim_reg: QrackSimulator, tol: float = 1e-12
-) -> "np.linalg._linalg.EighResult":
+) -> QuantumState:
     """
     Extract the reduced density matrix representing the state of a list
     of qubits from a PyQRack simulator register.
@@ -73,7 +163,7 @@ def _pyqrack_reduced_density_matrix(
     s = s[:, nonzero_inds]
     v = v[nonzero_inds] ** 2
     # Forge into the correct result type
-    result = np.linalg._linalg.EighResult(eigenvalues=v, eigenvectors=s)
+    result = QuantumState(eigenvalues=v, eigenvectors=s)
     return result
 
 
@@ -165,7 +255,7 @@ class PyQrackSimulatorBase(AbstractSimulatorDevice[PyQrackSimulatorTask]):
     @staticmethod
     def quantum_state(
         qubits: list[PyQrackQubit] | IList[PyQrackQubit, Any], tol: float = 1e-12
-    ) -> "np.linalg._linalg.EighResult":
+    ) -> "QuantumState":
         """
         Extract the reduced density matrix representing the state of a list
         of qubits from a PyQRack simulator register.
@@ -177,7 +267,7 @@ class PyQrackSimulatorBase(AbstractSimulatorDevice[PyQrackSimulatorTask]):
             An eigh result containing the eigenvalues and eigenvectors of the reduced density matrix.
         """
         if len(qubits) == 0:
-            return np.linalg._linalg.EighResult(
+            return QuantumState(
                 eigenvalues=np.array([]), eigenvectors=np.array([]).reshape(0, 0)
             )
         sim_reg = qubits[0].sim_reg

bloqade_circuit-0.7.6/src/bloqade/pyqrack/task.py

@@ -0,0 +1,147 @@
+from typing import TypeVar, ParamSpec, cast
+from collections import Counter
+from dataclasses import dataclass
+
+import numpy as np
+from kirin.dialects.ilist import IList
+
+from bloqade.task import AbstractSimulatorTask
+from bloqade.pyqrack.reg import QubitState, PyQrackQubit
+from bloqade.pyqrack.base import (
+    MemoryABC,
+    PyQrackInterpreter,
+)
+
+RetType = TypeVar("RetType")
+Param = ParamSpec("Param")
+MemoryType = TypeVar("MemoryType", bound=MemoryABC)
+
+
+@dataclass
+class PyQrackSimulatorTask(AbstractSimulatorTask[Param, RetType, MemoryType]):
+    """PyQrack simulator task for Bloqade."""
+
+    pyqrack_interp: PyQrackInterpreter[MemoryType]
+
+    def run(self) -> RetType:
+        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()
+
+    def qubits(self) -> list[PyQrackQubit]:
+        """Returns the qubits in the simulator."""
+        try:
+            N = self.state.sim_reg.num_qubits()
+            return [
+                PyQrackQubit(
+                    addr=i, sim_reg=self.state.sim_reg, state=QubitState.Active
+                )
+                for i in range(N)
+            ]
+        except AttributeError:
+            Warning("Task has not been run, there are no qubits!")
+            return []
+
+    def batch_run(self, shots: int = 1) -> dict[RetType, float]:
+        """
+        Repeatedly run the task to collect statistics on the shot outcomes.
+        The average is done over [shots] repetitions and thus is frequentist
+        and converges to exact only in the shots -> infinity limit.
+
+        Args:
+            shots (int):
+                the number of repetitions of the task
+        Returns:
+            dict[RetType, float]:
+                a dictionary mapping outcomes to their probabilities,
+                as estimated from counting the shot outcomes. RetType must be hashable.
+        """
+
+        results: list[RetType] = [self.run() for _ in range(shots)]
+
+        # Convert IList to tuple so that it is hashable by Counter
+        def convert(data):
+            if isinstance(data, (list, IList)):
+                return tuple(convert(item) for item in data)
+            return data
+
+        results = convert(results)
+
+        data = {
+            key: value / len(results) for key, value in Counter(results).items()
+        }  # Normalize to probabilities
+        return data
+
+    def batch_state(
+        self, shots: int = 1, qubit_map: None = None
+    ) -> "QuantumState":  # noqa: F821
+        """
+        Repeatedly run the task to extract the averaged quantum state.
+        The average is done over [shots] repetitions and thus is frequentist
+        and converges to exact only in the shots -> infinity limit.
+
+        Args:
+            shots (int):
+                the number of repetitions of the task
+            qubit_map (callable | None):
+                an optional callable that takes the output of self.run() and extract
+                the [returned] qubits to be used for the quantum state.
+                If None, all qubits in the simulator are used, in the order set by the simulator.
+                If callable, qubit_map must have the signature
+                > qubit_map(output:RetType) -> list[PyQrackQubit]
+                and the averaged state is
+                > quantum_state(qubit_map(self.run())).
+                If qubit_map is not None, self.run() must return qubit(s).
+                Two common patterns here are:
+                 > qubit_map = lambda qubits: qubits
+                for the case where self.run() returns a list of qubits, or
+                 > qubit_map = lambda qubit: [qubits]
+                for the case where self.run() returns a single qubit.
+        Returns:
+            QuantumState:
+                the averaged quantum state as a density matrix,
+                represented in its eigenbasis.
+        """
+        # Import here to avoid circular dependencies.
+        from bloqade.pyqrack.device import QuantumState, PyQrackSimulatorBase
+
+        states: list[QuantumState] = []
+        for _ in range(shots):
+            res = self.run()
+            if callable(qubit_map):
+                qbs = qubit_map(res)
+            else:
+                qbs = self.qubits()
+            states.append(PyQrackSimulatorBase.quantum_state(qbs))
+
+        state = QuantumState(
+            eigenvectors=np.concatenate(
+                [state.eigenvectors for state in states], axis=1
+            ),
+            eigenvalues=np.concatenate([state.eigenvalues for state in states], axis=0)
+            / len(states),
+        )
+
+        # Canonicalize the state by orthoganalizing the basis vectors.
+        tol = 1e-7
+        s, v, d = np.linalg.svd(
+            state.eigenvectors * np.sqrt(state.eigenvalues), full_matrices=False
+        )
+        mask = v > tol
+        v = v[mask] ** 2
+        s = s[:, mask]
+        return QuantumState(eigenvalues=v, eigenvectors=s)

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.6}/test/pyqrack/runtime/test_qrack.py

@@ -366,3 +366,89 @@ def test_get_qubits():
 
     qubits2 = task.qubits()
     assert len(qubits2) == 6
+
+
+def test_batch_run():
+    @squin.kernel
+    def coinflip():
+        qubit = squin.qubit.new(1)[0]
+        squin.gate.h(qubit)
+        return squin.qubit.measure(qubit)
+
+    emulator = StackMemorySimulator()
+    task = emulator.task(coinflip)
+    results: dict = task.batch_run(1000)
+    assert len(set(results.keys()).symmetric_difference({False, True})) == 0
+    assert results[True] + results[False] == 1.0
+    assert abs(results[True] - 0.5) < 0.1
+    assert abs(results[False] - 0.5) < 0.1
+
+
+def test_batch_run_IList_converter():
+    @squin.kernel
+    def coinflip():
+        qubit = squin.qubit.new(1)[0]
+        squin.gate.h(qubit)
+        return [squin.qubit.measure(qubit)]
+
+    emulator = StackMemorySimulator()
+    task = emulator.task(coinflip)
+    results: dict = task.batch_run(1000)
+    assert len(set(results.keys()).symmetric_difference({(False,), (True,)})) == 0
+
+
+def test_batch_state1():
+    """
+    Averaging with no selector function
+    """
+
+    @squin.kernel
+    def coinflip():
+        qubit = squin.qubit.new(1)[0]
+        squin.gate.h(qubit)
+        return squin.qubit.measure(qubit)
+
+    emulator = StackMemorySimulator()
+    task = emulator.task(coinflip)
+    results = task.batch_state(1000)
+    assert results.eigenvalues.shape == (2,)
+    assert results.eigenvectors.shape == (2, 2)
+    assert np.isclose(sum(results.eigenvalues), 1)
+    assert abs(results.eigenvalues[0] - 0.5) < 0.1
+    assert abs(results.eigenvalues[1] - 0.5) < 0.1
+
+
+def test_batch_state2():
+    """
+    Averaging with a qubit_map function
+    """
+
+    @squin.kernel
+    def coinflip2():
+        qubit = squin.qubit.new(2)
+        squin.gate.h(qubit[0])
+        bit = squin.qubit.measure(
+            qubit[0]
+        )  # Other (pythonic) sources of randomness are not possible, so some duct tape is required
+        if bit:
+            squin.gate.h(qubit[1])
+        return qubit[1]
+
+    emulator = StackMemorySimulator(min_qubits=2)
+    task = emulator.task(coinflip2)
+
+    results1 = task.batch_state(1000)
+
+    assert results1.eigenvalues.shape == (2,)
+    assert results1.eigenvectors.shape == (4, 2)
+    assert np.isclose(sum(results1.eigenvalues), 1)
+    assert abs(results1.eigenvalues[0] - 0.5) < 0.05
+    assert abs(results1.eigenvalues[1] - 0.5) < 0.05
+
+    results2 = task.batch_state(1000, qubit_map=lambda q: [q])
+
+    assert results2.eigenvalues.shape == (2,)
+    assert results2.eigenvectors.shape == (2, 2)
+    assert np.isclose(sum(results1.eigenvalues), 1)
+    assert abs(results2.eigenvalues[0] - 0.85355339) < 0.05
+    assert abs(results2.eigenvalues[1] - 0.14644661) < 0.05

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.6}/uv.lock

@@ -102,7 +102,7 @@ wheels = [
 
 [[package]]
 name = "bloqade-circuit"
-version = "0.7.5"
+version = "0.7.6"
 source = { editable = "." }
 dependencies = [
     { name = "kirin-toolchain" },

bloqade_circuit-0.7.5/src/bloqade/pyqrack/task.py

@@ -1,53 +0,0 @@
-from typing import TypeVar, ParamSpec, cast
-from dataclasses import dataclass
-
-from bloqade.task import AbstractSimulatorTask
-from bloqade.pyqrack.reg import QubitState, PyQrackQubit
-from bloqade.pyqrack.base import (
-    MemoryABC,
-    PyQrackInterpreter,
-)
-
-RetType = TypeVar("RetType")
-Param = ParamSpec("Param")
-MemoryType = TypeVar("MemoryType", bound=MemoryABC)
-
-
-@dataclass
-class PyQrackSimulatorTask(AbstractSimulatorTask[Param, RetType, MemoryType]):
-    """PyQrack simulator task for Bloqade."""
-
-    pyqrack_interp: PyQrackInterpreter[MemoryType]
-
-    def run(self) -> RetType:
-        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()
-
-    def qubits(self) -> list[PyQrackQubit]:
-        """Returns the qubits in the simulator."""
-        try:
-            N = self.state.sim_reg.num_qubits()
-            return [
-                PyQrackQubit(
-                    addr=i, sim_reg=self.state.sim_reg, state=QubitState.Active
-                )
-                for i in range(N)
-            ]
-        except AttributeError:
-            Warning("Task has not been run, there are no qubits!")
-            return []