JAX Quantum Research Suite: A Unified, Hardware-Accelerated, Differentiable Simulator for NISQ-Era Algorithm Research Across GPU and Cloud TPU Clusters
We present the JAX Quantum Research Suite, a high-performance, differentiable quantum circuit simulator spanning two co-existing hardware acceleration layers: a GPU division targeting NVIDIA RTX-class consumer GPUs via CUDA and a Cloud TPU division distributed across Google Cloud TPU v5e-16 and v6e-64 VM clusters. The suite is implemented in pure JAX (jax.numpy, jax.lax) for all statevector primitives, enabling seamless composition with jax.grad, jax.vmap, and jax.sharding.Positional Sharding.
We present the JAX Quantum Research Suite, a high-performance, differentiable quantum circuit simulator spanning two co-existing hardware acceleration layers: a GPU division targeting NVIDIA RTX-class consumer GPUs via CUDA and a Cloud TPU division distributed across Google Cloud TPU v5e-16 and v6e-64 VM clusters. The suite is implemented in pure JAX (jax.numpy, jax.lax) for all statevector primitives, enabling seamless composition with jax.grad, jax.vmap, and jax.sharding.Positional Sharding.
qujax is a pure JAX (Bradbury et al., 2018), purely functional Python package for the classical simulation of quantum circuits.A JAX implementation of quantum circuits inherits benefits such as seamless automatic differentiation, support for GPUs/TPUs as well as integration with a host of other tools within the JAX ecosystem.qujax is hosted on PyPI for easy installation and comes with detailed documentation and a suite of example notebooks.qujax represents a quantum circuit as a collection of three equal length Python iterables:
Classical simulation of quantum circuits scales exponentially: an n-qubit state vector requires 2n complex amplitudes, consuming 2n×8 bytes of memory for single-precision complex numbers. On a single accelerator this wall is typically hit at 29-30 qubits (≈4.3 GB). We describe an architecture built entirely in pure JAX with zero dependency on Qiskit, PennyLane, Cirq, or any classical quantum framework that scales quantum state-vector simulation to 36 qubits (549.76 GB state-vector footprint) across a 64-chip Google Cloud TPU v6e mesh, and to 33 qubits (64 GB) across a 16-chip TPU v5e cluster. The key insight is that JAX's PositionalSharding distributes the 2n-amplitude state vector uniformly across chip HBM pools as a first-class XLA buffer, while jax.lax.fori_loop keeps the XLA computation graph at O(1) size regardless of circuit depth, preventing the host-side Out-of-Memory (OOM) errors that plague compiler-unrolled deep circuits. We demonstrate five experiments (GHZ state preparation, VQC, VQE H2, QAOA MaxCut, Monte Carlo noise simulation) running at sub-millisecond gate latency after JIT compilation, with full reverse-mode automatic differentiation through the entire circuit.
Classical simulation of quantum circuits remains indispensable for algorithm development, hardware validation, and error analysis in the noisy intermediate-scale quantum (NISQ) era. However, state-vector simulation faces exponential memory scaling, with an n-qubit system requiring O(2^n) complex amplitudes, and existing simulators often lack the flexibility to exploit heterogeneous computing resources at runtime. This paper presents a GPU-accelerated quantum circuit simulation framework that introduces three contributions: (1) an empirical backend selection algorithm that benchmarks CuPy, PyTorch-CUDA, and NumPy-CPU backends at runtime and selects the optimal execution path based on measured throughput; (2) a directed acyclic graph (DAG) based gate fusion engine that reduces circuit depth through automated identification of fusible gate sequences, coupled with adaptive precision switching between complex64 and complex128 representations; and (3) a memory-aware fallback mechanism that monitors GPU memory consumption and gracefully degrades to CPU execution when resources are exhausted. The framework integrates with Qiskit, Cirq, PennyLane, and Amazon Braket through a unified adapter layer. Benchmarks on an NVIDIA A100-SXM4 (40 GiB) GPU demonstrate speedups of 64x to 146x over NumPy CPU execution for state-vector simulation of circuits with 20 to 28 qubits, with speedups exceeding 5x from 16 qubits onward. Hardware validation on an IBM quantum processing unit (QPU) confirms Bell state fidelity of 0.939, a five-qubit Greenberger-Horne-Zeilinger (GHZ) state fidelity of 0.853, and circuit depth reduction from 42 to 14 gates through the fusion pipeline. The system is designed for portability across NVIDIA consumer and data-center GPUs, requiring no vendor-specific compilation steps.
We present jQMC, a Python-based computational package for {\it ab initio} Quantum Monte Carlo (QMC) simulations, designed for modern GPU-accelerated computing environments. jQMC implements two well-established QMC algorithms: Variational Monte Carlo (VMC) and the lattice-regularized variant of Diffusion Monte Carlo (LRDMC). The employed wave function is a Jastrow factor combined with the antisymmetrized geminal power with spin-singlet and spin-triplet pairings, which contains the single Slater determinant as its special lowest-rank case. The wave function can be initialized from external Hartree-Fock/Density Functional Theory calculations through the TREX-IO library (a common wave-function format across electronic-structure packages) and optimized by stochastic reconfiguration and linear-method energy minimization. One of the prominent features of jQMC is its use of JAX, which enables automatic differentiation for wave function optimization and atomic force calculations, and allows the main QMC algorithms to be Just-In-Time (JIT) compiled and portable across CPU and GPU. jQMC is vectorized over walkers at the top level of the QMC algorithms, providing efficient intra-GPU~(CPU) vectorization. The multi-GPU~(CPU) parallelization is also supported through MPI and JAX sharding. To assess the practical performance of this implementation, we benchmarked jQMC performance on NVIDIA GPUs (A100 and H100) and analyzed CUDA kernels. For the test cases analyzed here, with system sizes up to 160 electrons, the current version of jQMC is faster than TurboRVB, a Fortran90 code implementing the same algorithms and wave functions, once jQMC is run on GPUs. In terms of wall-time, the gain can reach an order of magnitude for VMC, while it is more moderate for LRDMC.
This work presents a portable, modular quantumcircuit emulator designed to accelerate algorithm prototyping by leveraging Central Processing Unit (CPU) and Compute Unified Device Architecture (CUDA)-enabled Graphic Processing Unit (GPU) backends for dense linearalgebra workloads.The emulator provides a lightweight backend abstraction that unifies NumPy and CuPy, supports both statevector and density-matrix representations, and implements efficient multi-target unitary embedding and Kraus-map noise channels.These capabilities enable rapid exploration of quantum algorithms that require full 2 n × 2 n operators, such as quantum phase estimation, full Quantum Fourier Transform (QFT), and noise-aware variational circuits, while minimizing host/device transfer and preserving numerical parity between backends.Implementation strategies are described for embedding single-and multi-qubit gates, parameterized rotations, and controlled unitaries, along with an "apply_unitary_on_targets" routine that employs reshape/matrix-multiply/reshape patterns to map arbitrary target sets to dense GPU kernels for high throughput.Using a curated benchmark suite of dense quantum workloads and microbenchmarks, including large matrix multiplies and Fast Fourier Transforms (FFT), performance is quantified across a range of qubit counts and precisions.The results demonstrate substantial speedups on modern NVIDIA GPUs for workloads dominated by dense linear algebra, identify cross-over points where GPU acceleration becomes beneficial, and analyse memory/precision trade-offs for complex64 versus complex128.The presented emulator lowers the barrier for noise-aware algorithm prototyping by combining practical software ergonomics with GPU performance, enabling faster iteration on algorithm design and noise-mitigation strategies on commodity single-node hardware.While the abstraction layer ensures portability, achieving peak performance currently requires hardwarespecific tuning-a limitation we address through future automation strategies.
We present the NVIDIA cuQuantum SDK [1], a state-of-the-art library of composable primitives for GPU-accelerated quantum circuit simulations. As the size of quantum devices continues to increase, making their classical simulation progressively more difficult, the availability of fast and scalable quantum circuit simulators becomes vital for quantum algorithm developers, as well as quantum hardware engineers focused on the validation and optimization of quantum devices. The cuQuantum SDK was created to accelerate and scale up quantum circuit simulators developed by the quantum information science community by enabling them to utilize efficient scalable software building blocks optimized for NVIDIA GPU-based platforms. The functional building blocks provided cover the needs of both state vector- and tensor network- based simulators, including approximate tensor network simulation methods based on matrix product state, projected entangled pair state, and other factorized tensor representations. By leveraging the enormous computing power of the latest NVIDIA GPU architectures, quantum circuit simulators that have adopted the cuQuantum SDK demonstrate significant acceleration, compared to CPU-only execution, for both the state vector and tensor network simulation methods. Furthermore, by utilizing the parallel primitives available in the cuQuantum SDK, one can easily transition to distributed GPU-accelerated platforms, including those furnished by cloud service providers and high-performance computing systems deployed by supercomputing centers, extending the scale of possible quantum circuit simulations. The rich capabilities provided by the cuQuantum SDK are conveniently made available via both Python and C application programming interfaces, where the former is directly targeting a broad Python quantum community and the latter allows tight integration with simulators written in any programming language.