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

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.7}/.github/workflows/ci.yml

@@ -24,13 +24,13 @@ jobs:
         uses: astral-sh/setup-uv@v6
         with:
           # Install a specific version of uv.
-          version: "0.5.1"
+          version: "0.8.4"
           enable-cache: true
           cache-dependency-glob: "uv.lock"
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
       - name: Install the project
-        run: uv sync --upgrade --dev --group dev-linux
+        run: uv sync --dev --all-extras --no-extra pyqrack-cuda
       - name: Run tests
         # For example, using `pytest`
         run: uv run just coverage

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bloqade-circuit
-Version: 0.7.5
+Version: 0.7.7
 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
@@ -9,8 +9,8 @@ Requires-Dist: kirin-toolchain~=0.17.23
 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.41,>=1.38.2; sys_platform != 'darwin'
-Requires-Dist: pyqrack<1.41,>=1.38.2; sys_platform == 'darwin'
+Requires-Dist: pyqrack-cpu>=1.69.0; sys_platform != 'darwin-arm64'
+Requires-Dist: pyqrack>=1.69.0; sys_platform == 'darwin-arm64'
 Requires-Dist: rich>=13.9.4
 Requires-Dist: scipy>=1.13.1
 Provides-Extra: cirq
@@ -18,9 +18,9 @@ Requires-Dist: cirq-core>=1.4.1; extra == 'cirq'
 Requires-Dist: cirq-core[contrib]>=1.4.1; extra == 'cirq'
 Requires-Dist: qpsolvers[clarabel]>=4.7.0; extra == 'cirq'
 Provides-Extra: pyqrack-cuda
-Requires-Dist: pyqrack-cuda>=1.38.2; extra == 'pyqrack-cuda'
+Requires-Dist: pyqrack-cuda>=1.69.0; extra == 'pyqrack-cuda'
 Provides-Extra: pyqrack-opencl
-Requires-Dist: pyqrack>=1.38.2; (sys_platform != 'darwin') and extra == 'pyqrack-opencl'
+Requires-Dist: pyqrack>=1.69.0; (sys_platform == 'darwin-arm64') and extra == 'pyqrack-opencl'
 Provides-Extra: qasm2
 Requires-Dist: lark>=1.2.2; extra == 'qasm2'
 Provides-Extra: qbraid

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

@@ -1,6 +1,6 @@
 [project]
 name = "bloqade-circuit"
-version = "0.7.5"
+version = "0.7.7"
 description = "The software development toolkit for neutral atom arrays."
 readme = "README.md"
 authors = [
@@ -17,8 +17,8 @@ dependencies = [
     "rich>=13.9.4",
     "pydantic>=1.3.0,<2.11.0",
     "pandas>=2.2.3",
-    "pyqrack>=1.38.2,<1.41; sys_platform == 'darwin'",
-    "pyqrack-cpu>=1.38.2,<1.41 ; sys_platform != 'darwin'",
+    "pyqrack>=1.69.0; sys_platform == 'darwin-arm64'",
+    "pyqrack-cpu>=1.69.0; sys_platform != 'darwin-arm64'",
 ]
 
 [project.optional-dependencies]
@@ -41,10 +41,10 @@ cirq = [
     "qpsolvers[clarabel]>=4.7.0",
 ]
 pyqrack-opencl = [
-    "pyqrack>=1.38.2 ; sys_platform != 'darwin'",
+    "pyqrack>=1.69.0; sys_platform == 'darwin-arm64'",
 ]
 pyqrack-cuda = [
-    "pyqrack-cuda>=1.38.2",
+    "pyqrack-cuda>=1.69.0",
 ]
 stim = [
     "stim>=1.15.0",
@@ -75,34 +75,6 @@ dev = [
     "rust-just>=1.36.0",
     "tomlkit>=0.13.2",
 ]
-dev-linux = [
-    "cirq-core[contrib]>=1.4.1",
-    "lark>=1.2.2",
-    "pyqrack-cpu>=1.38.2",
-    "qbraid>=0.9.5",
-    "ffmpeg>=1.4",
-    "matplotlib>=3.9.2",
-    "pyqt5>=5.15.11",
-    "tqdm>=4.67.1",
-    "stim>=1.15.0",
-    "cirq-core>=1.4.1",
-    "cirq-core[contrib]>=1.4.1",
-    "qpsolvers[clarabel]>=4.7.0",
-]
-dev-mac-arm = [
-    "cirq-core[contrib]>=1.4.1",
-    "ffmpeg>=1.4",
-    "lark>=1.2.2",
-    "matplotlib>=3.9.2",
-    "pyqrack>=1.38.2",
-    "pyqt5>=5.15.11",
-    "qbraid>=0.9.5",
-    "tqdm>=4.67.1",
-    "stim>=1.15.0",
-    "cirq-core>=1.4.1",
-    "cirq-core[contrib]>=1.4.1",
-    "qpsolvers[clarabel]>=4.7.0",
-]
 
 [tool.isort]
 profile = "black"

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.7}/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.7/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.7}/test/cirq_utils/noise/test_noise_models.py

@@ -64,7 +64,9 @@ def test_simple_model(model: cirq.NoiseModel, qubits):
 
     kernel = squin.cirq.load_circuit(noisy_circuit)
     RewriteNoiseStmts(kernel.dialects)(kernel)
-    pyqrack_sim = StackMemorySimulator(min_qubits=2)
+    pyqrack_sim = StackMemorySimulator(
+        min_qubits=2, rng_state=np.random.default_rng(1234)
+    )
 
     pops_bloqade = [0.0] * 4
 

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.7}/test/cirq_utils/noise/test_noisy_ghz.py

@@ -86,7 +86,9 @@ def test_noisy_ghz():
             # do the same in squin
             kernel = squin.cirq.load_circuit(noisy_circuit)
             RewriteNoiseStmts(kernel.dialects)(kernel)
-            sim = StackMemorySimulator(min_qubits=n)
+            sim = StackMemorySimulator(
+                min_qubits=n, rng_state=np.random.default_rng(1234)
+            )
             rho_squin = np.zeros((2**n, 2**n), dtype=np.complex128)
             nshots = 300
             for _ in range(nshots):

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.7}/test/cirq_utils/noise/test_one_zone_correlated_noise.py

@@ -51,7 +51,7 @@ def test_model_with_defaults():
 
     RewriteNoiseStmts(kernel.dialects)(kernel)
 
-    sim = StackMemorySimulator(min_qubits=2)
+    sim = StackMemorySimulator(min_qubits=2, rng_state=np.random.default_rng(1234))
     pops = [0.0] * 4
     nshots = 300
     for _ in range(nshots):

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.7}/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.7}/test/pyqrack/squin/test_kernel.py

@@ -1,5 +1,6 @@
 import math
 
+import numpy as np
 import pytest
 from kirin.dialects import ilist
 
@@ -22,7 +23,15 @@ def test_qubit():
     assert isinstance(qubit := result[0], PyQrackQubit)
 
     out = qubit.sim_reg.out_ket()
-    assert out == [1.0] + [0.0] * (2**3 - 1)
+    out = np.asarray(out)
+
+    i = np.abs(out).argmax()
+    out /= out[i] / np.abs(out[i])
+
+    expected = np.zeros_like(out)
+    expected[0] = 1.0
+
+    assert np.allclose(out, expected, atol=2.2e-7)
 
     @squin.kernel
     def m():

{bloqade_circuit-0.7.5 → bloqade_circuit-0.7.7}/test/pyqrack/test_target.py

@@ -1,6 +1,7 @@
 import math
 import textwrap
 
+import numpy as np
 import pytest
 from kirin import ir
 from kirin.dialects import ilist
@@ -115,11 +116,14 @@ def test_target_glob():
 
     out = qubit.sim_reg.out_ket()
 
-    assert out[0] == 1
-    for i in range(1, len(out)):
-        assert out[i] == 0
+    out = np.asarray(out)
+    i = np.abs(out).argmax()
+    out /= out[i] / np.abs(out[i])
 
-    assert True
+    expected = np.zeros_like(out)
+    expected[0] = 1.0
+
+    assert np.allclose(out, expected, atol=2.2e-7)
 
 
 def test_measurement():