Migrate over pyqrack interpreter. (#8)

* adding pyqrack impl into circuits repo

* updating workflows to work with pyqrack

* updating ci

* removing dependencies from main list

Author: weinbe58

.github/workflows/ci.yml

@@ -30,7 +30,7 @@ jobs:
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
       - name: Install the project
-        run: uv sync --all-extras --dev
+        run: uv sync --upgrade --dev --group dev-linux
       - name: Run tests
         # For example, using `pytest`
         run: uv run just coverage

.github/workflows/devdoc.yml

@@ -24,7 +24,7 @@ jobs:
           enable-cache: true
           cache-dependency-glob: "uv.lock"
       - name: Install Documentation dependencies
-        run: uv sync --group doc
+        run: uv sync --upgrade --dev --group doc --group dev-linux
       - name: Set up build cache
         uses: actions/cache@v4
         id: cache

.github/workflows/doc.yml

@@ -24,7 +24,7 @@ jobs:
           enable-cache: true
           cache-dependency-glob: "uv.lock"
       - name: Install Documentation dependencies
-        run: uv sync --group doc
+        run: uv sync --upgrade --dev --group doc --group dev-linux
       - name: Set up build cache
         uses: actions/cache@v4
         id: cache

.github/workflows/pub_doc.yml

@@ -24,7 +24,7 @@ jobs:
           enable-cache: true
           cache-dependency-glob: "uv.lock"
       - name: Install Documentation dependencies
-        run: uv sync --group doc
+        run: uv sync --upgrade --dev --group doc --group dev-linux
       - name: Set up build cache
         uses: actions/cache@v4
         id: cache

.github/workflows/release.yml

@@ -15,7 +15,7 @@ jobs:
         # Install a specific version of uv.
         version: "0.5.5"
     - name: Install the project
-      run: uv sync --all-extras --dev
+      run: uv sync --all-extras
     - name: Build distribution 📦
       run: uv build
     - name: Store the distribution packages

_typos.toml

@@ -12,3 +12,4 @@ AttributeIDSupressMenu = "AttributeIDSupressMenu"
 Braket = "Braket"
 mch = "mch"
 IY = "IY"
+ket = "ket"

pyproject.toml

@@ -76,6 +76,26 @@ doc = [
 examples = [
     "networkx>=3.4.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.10.0",
+    "pyqt5>=5.15.11",
+    "tqdm>=4.67.1",
+]
+dev-mac-arm = [
+    "cirq-core[contrib]>=1.4.1",
+    "ffmpeg>=1.4",
+    "lark>=1.2.2",
+    "matplotlib>=3.10.0",
+    "pyqrack>=1.38.2",
+    "pyqt5>=5.15.11",
+    "qbraid>=0.9.5",
+    "tqdm>=4.67.1",
+]
 
 [tool.isort]
 profile = "black"

src/bloqade/pyqrack/__init__.py

@@ -0,0 +1,18 @@
+from .reg import (
+    CBitRef as CBitRef,
+    CRegister as CRegister,
+    PyQrackReg as PyQrackReg,
+    QubitState as QubitState,
+    Measurement as Measurement,
+    PyQrackQubit as PyQrackQubit,
+)
+from .base import (
+    StackMemory as StackMemory,
+    DynamicMemory as DynamicMemory,
+    PyQrackInterpreter as PyQrackInterpreter,
+)
+
+# NOTE: The following import is for registering the method tables
+from .noise import native as native
+from .qasm2 import uop as uop, core as core, parallel as parallel
+from .target import PyQrack as PyQrack

src/bloqade/pyqrack/base.py

@@ -0,0 +1,131 @@
+import abc
+import typing
+from dataclasses import field, dataclass
+from unittest.mock import Mock
+
+import numpy as np
+from kirin.interp import Interpreter
+from typing_extensions import Self
+from kirin.interp.exceptions import InterpreterError
+
+from bloqade.pyqrack.reg import Measurement
+
+if typing.TYPE_CHECKING:
+    from pyqrack import QrackSimulator
+
+
+class PyQrackOptions(typing.TypedDict):
+    qubitCount: int
+    isTensorNetwork: bool
+    isSchmidtDecomposeMulti: bool
+    isSchmidtDecompose: bool
+    isStabilizerHybrid: bool
+    isBinaryDecisionTree: bool
+    isPaged: bool
+    isCpuGpuHybrid: bool
+    isOpenCL: bool
+
+
+def _default_pyqrack_args() -> PyQrackOptions:
+    return PyQrackOptions(
+        qubitCount=-1,
+        isTensorNetwork=False,
+        isSchmidtDecomposeMulti=True,
+        isSchmidtDecompose=True,
+        isStabilizerHybrid=True,
+        isBinaryDecisionTree=True,
+        isPaged=True,
+        isCpuGpuHybrid=True,
+        isOpenCL=True,
+    )
+
+
+@dataclass
+class MemoryABC(abc.ABC):
+    pyqrack_options: PyQrackOptions = field(default_factory=_default_pyqrack_args)
+    sim_reg: "QrackSimulator" = field(init=False)
+
+    @abc.abstractmethod
+    def allocate(self, n_qubits: int) -> tuple[int, ...]:
+        """Allocate `n_qubits` qubits and return their ids."""
+        ...
+
+    def reset(self):
+        """Reset the memory, releasing all qubits."""
+        from pyqrack import QrackSimulator
+
+        # do not reset the simulator it might be used by
+        # results of the simulation
+        self.sim_reg = QrackSimulator(**self.pyqrack_options)
+
+
+@dataclass
+class MockMemory(MemoryABC):
+    """Mock memory for testing purposes."""
+
+    allocated: int = field(init=False, default=0)
+
+    def allocate(self, n_qubits: int):
+        allocated = self.allocated + n_qubits
+        result = tuple(range(self.allocated, allocated))
+        self.allocated = allocated
+        return result
+
+    def reset(self):
+        self.allocated = 0
+        self.sim_reg = Mock()
+
+
+@dataclass
+class StackMemory(MemoryABC):
+    total: int = field(kw_only=True)
+    allocated: int = field(init=False, default=0)
+
+    def allocate(self, n_qubits: int):
+        curr_allocated = self.allocated
+        self.allocated += n_qubits
+
+        if self.allocated > self.total:
+            raise InterpreterError(
+                f"qubit allocation exceeds memory, "
+                f"{self.total} qubits, "
+                f"{self.allocated} allocated"
+            )
+
+        return tuple(range(curr_allocated, self.allocated))
+
+    def reset(self):
+        super().reset()
+        self.allocated = 0
+
+
+@dataclass
+class DynamicMemory(MemoryABC):
+    def __post_init__(self):
+        self.reset()
+
+        if self.sim_reg.is_tensor_network:
+            raise ValueError("DynamicMemory does not support tensor networks")
+
+    def allocate(self, n_qubits: int):
+        start = self.sim_reg.num_qubits()
+        for i in range(start, start + n_qubits):
+            self.sim_reg.allocate_qubit(i)
+
+        return tuple(range(start, start + n_qubits))
+
+
+@dataclass
+class PyQrackInterpreter(Interpreter):
+    keys = ["pyqrack", "main"]
+    memory: MemoryABC = field(kw_only=True)
+    rng_state: np.random.Generator = field(
+        default_factory=np.random.default_rng, kw_only=True
+    )
+    loss_m_result: Measurement = field(default=Measurement.One, kw_only=True)
+    """The value of a measurement result when a qubit is lost."""
+
+    def initialize(self) -> Self:
+        super().initialize()
+        self.memory.reset()  # reset allocated qubits
+        return self