Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

Beyond the Dense Ceiling: VRAM-Resident Tiered Compression for Quantum Circuit Simulation on Consumer GPUs

Piero Jose Alarcon Dueñas

Published Jul 22, 2026• 0 citations
Publisher

Abstract

State-vector simulation of n qubits requires 2^n complex amplitudes, capping a 6 GB consumer GPU at 29 qubits. We present qubit, a quantum circuit simulator whose state vector is partitioned into blocks, each stored in one of three tiers (ZERO with no storage, COMPRESSED as block-scaled int16 at 4 B/amplitude, or FULL as complex64) and resident entirely in GPU memory: promotion and demotion are kernels, and the only host traffic is scheduling metadata and measurement scalars, in contrast to prior compression frameworks that stage compressed state in host memory. Quantization error is accumulated exactly on-device; because unitaries preserve norms, per-event errors compose linearly in L2 norm, giving a conservative a-priori fidelity bound F ≥ (1−D)²/(1+D)² for total injected error D. The bound is tight at low circuit depth and becomes loose as errors accumulate, so we pair it with a random-walk estimate and direct measurement, and use its inverse to turn a user-specified fidelity target into a compression budget the runtime never exceeds. Unlike structure-aware simulators (matrix product states, stabilizer methods, or Qrack), which shrink only low-entanglement states, this compresses the genuinely dense states that have no structure to exploit: on an RTX 3060 Laptop GPU (6 GB, dense complex64 ceiling 29 qubits) qubit holds a 29-qubit fully-dense state in half its footprint at measured fidelity 0.9998, and is 3.5–6× faster than Qrack on dense circuits on the same card, while the ZERO tier still captures sparse states exactly (a 31-qubit GHZ circuit in 1 MB). An automatic planner chooses among dense, entanglement-factorized, and tiered representations from a static analysis of the circuit, so the user declares qubits, gates, and a fidelity target, and nothing else. Code and data: https://github.com/ArubikU/qubit

DOI
10.5281/zenodo.21483389

Related papers

EdgeQuantum: Quantum Circuit Simulation Framework for Resource-Constrained Edge Devices

Changjong Kim, Ehan Sohn, Yongseok Son +1 more

This paper presents EdgeQuantum, a tiered-memory quantum circuit simulator designed to overcome the memory wall of resource-constrained edge devices. As quantum algorithms scale toward dozens of qubits for on-device NISQ workloads, simulating their state vectors demands coordinated multi-tier memory management beyond the device’s physical DRAM capacity. EdgeQuantum introduces a unified storage hierarchy that integrates unified DRAM and commodity NVMe storage into a 2-tier memory architecture. With this design, EdgeQuantum achieves zero-copy data movement through UVM visibility control, hides write latency through a 4-buffer asynchronous pipeline with serialized NVMe access, and expands capacity via ping-pong mantissa-truncated LZ4 compression. Our evaluation across six quantum circuits on an 8 GB NVIDIA Jetson Orin Nano shows that EdgeQuantum enables up to 40-qubit (8 TB) simulation for high-compression circuits and 36 qubits for dense circuits, while expanding effective memory capacity by up to 1024×. Without compression, EdgeQuantum outperforms the blocking I/O baseline by up to 1.64×. With compression, overlapping CPU compression and storage I/O with GPU computation improves end-to-end pipeline efficiency by 1.40× to 1.60×.

IEEE Internet of Things Journal•Jan 1, 2026•0 citations

Breaking the Quantum Memory Wall on Consumer Silicon: Exact 28-to-53 Qubit Sub-Manifold Contraction and Paraconsistent Thermodynamics on a Single 4GB GPU

Maycol Jhonatan Benavides Sánchez

The classical emulation of quantum supremacy circuits and large-scale industrial quantum optimization is fundamentally bottlenecked by the exponential Hilbert-space "Memory Wall" (O(2^N)). Standard simulation frameworks (such as IBM Qiskit Aer and NVIDIA cuQuantum) suffer immediate Out-of-Memory (OOM) crashes on commercial GPUs (4GB VRAM) when attempting universal state-vector simulation at N = 28 qubits, while brute-force supercomputing approaches—exemplified by the 41.9-million-core New Sunway system—require 1.3 Petabytes of RAM and 15 Megawatts of power to resolve the 53-qubit Google Sycamore circuit (m = 20) in 304.4 seconds. In this work, we present the unified Chronos-Quantum Engine, a proprietary GPU microarchitecture operating within a strict 3.58 GB VRAM ceiling on a single 60W laptop GPU (NVIDIA RTX 3050 Ti). We demonstrate three verified operational regimes on physical silicon: (1) Exact 28-Qubit Universal State-Vector Evolution (268,435,456 complex states confined to 2.147 GB VRAM) achieving IEEE-754 exactness (L2 error = 8.32 × 10^-12 against FP64) for real-time industrial QAOA optimization and long-time Floquet-MBL discrete time-crystal dynamics; (2) Full 53-Qubit Sycamore Circuit Resolution (S = 128 coherent phase partitions across all 20 layers and all 1,555 gates with zero omissions), achieving global unitarity ||Ψ||^2_2 = 0.99998384, unbiased Porter-Thomas second moment ⟨u2⟩/⟨u⟩2 = 2.014852 (0.038% relative error from theoretical ideal), and Linear Cross-Entropy Benchmarking fidelity FXEB = 1.014852 (1.039321 under Born quantile sampling) in 372.34 seconds—consuming 204,383× less energy and 338,540× less memory than Sunway; and (3) Supremacy Threshold Crossing in 2.96 seconds (Slice 1, FXEB = 0.0235 > 0.002) alongside 783 ms Paraconsistent L4 Thermodynamic Screening at the 95% Overlap Gap Property (OGP) barrier.

•Oct 9, 2026•0 citations

Overcoming Memory Constraints in Quantum Circuit Simulation with a High-Fidelity Compression Framework

Boyuan Zhang, Bo Fang, Fanjiang Ye +4 more

Full-state quantum circuit simulation requires exponentially increased memory size to store the state vector as the number of qubits scales, presenting significant limitations in classical computing systems. Our paper introduces BMQSim, a novel state vector quantum simulation framework that employs lossy compression to address the memory constraints on graphics processing unit (GPU) machines. BMQSim effectively tackles four major challenges for state-vector simulation with compression: frequent compression/decompression, high memory movement overhead, lack of dedicated error control, and unpredictable memory space requirements. Our work proposes an innovative strategy of circuit partitioning to significantly reduce the frequency of compression occurrences. We introduce a pipeline that seamlessly integrates compression with data movement while concealing its overhead. Additionally, BMQSim incorporates the first GPU-based lossy compression technique with point-wise error control. Furthermore, BMQSim features a two-level memory management system, ensuring efficient and stable execution. Our evaluations demonstrate that BMQSim can simulate the same circuit with over 10 times less memory usage on average, achieving fidelity over 0.99 and maintaining comparable simulation time to other state-of-the-art simulators.

arXiv:2410.14088•Oct 17, 2024•6 citations

GPU-Accelerated Quantum Simulation: Empirical Backend Selection, Gate Fusion, and Adaptive Precision

Poornima Kumaresan, Pavithra Muruganantham, Lakshmi Rajendran +1 more

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.

quant-pharXiv:2604.03816•Apr 7, 2026•3 citations

HQ-Sim: High-performance State Vector Simulation of Quantum Circuits on Heterogeneous HPC Systems

Boyuan Zhang, Bo Fang, Qiang Guan +2 more

Quantum circuit simulations are applied in more and more circumstances as the quantum computing community becomes broader. It helps researchers to evaluate the quantum algorithms and relieve the burden of limited quantum computing resources. However, most of the state-of-the-art quantum simulators utilizes either CPU or GPU to store and calculate the state vector, which results in resources stravation. Morever, the mamximum number of qubits supported by simulator is bounded by the memory, since the memory utilization increases exponentially with the number of qubits. In this study, we leverage Heterogeneous computing to utilize both CPU and GPU to store and update state vectors. We also integrate lossy data compression to reduce memory requirements. Specifically, we develop a heterogeous framework that has a dynamic scheduler to fully utilize the computing resources. We apply lossy compression to chunked state vector to make the maximum number of qubits higher than the regular simulators, the compression also benifits the data movement between CPU and GPU.

•Aug 10, 2023•7 citations

Matrix Product State Engine for FPGA QuantumCircuit Simulation Beyond Five Hundred Qubits.

Nasir Ali Nasir Ali

Abstract Statevector simulation of quantum circuits is fundamentally bounded by an expo-nential in the qubit count, which caps single-device simulation at around thirtyqubits regardless of how the arithmetic is laid out in hardware. The matrixproduct state (MPS) representation breaks that ceiling for circuits of boundedentanglement: its memory and time cost grow only linearly in the number ofqubits and polynomially in a single control parameter, the bond dimension χ.This paper presents a quantum circuit simulator built around an MPS engine thatruns its most expensive primitive, the two-site tensor contraction, on a XilinxAlveo U55C FPGA, with the numerically delicate singular value decomposition(SVD) executed by the host. We describe the engine end to end: an eight-bank,modulo-eight interleaved high-bandwidth-memory (HBM) tensor layout that fitswithin a strict nine-AXI-master routing budget; a double-precision HLS contrac-tion kernel that streams complex amplitudes directly from HBM; a co-designsplit that keeps every floating-point divide and square root off the FPGA crit-ical path, motivated by a concrete timing-closure failure we document; a hostbackend that performs SWAP routing, host-side SVD truncation, a bank-alignedallocator, and sequential conditional sampling in O(nχ2) per shot; and a four-card distributed mode that partitions the chain across devices with an O(χ2)boundary-tensor exchange. We then report what the system actually does. Forshallow, low-entanglement circuits the FPGA contraction is a negligible fractionof wall-clock time and classical measurement sampling on the host dominates;we show this directly rather than hiding it. As the bond dimension grows thepicture inverts, and at χ = 64 the FPGA contraction accounts for roughly sev-enty percent of the run, confirming that bond dimension, not qubit count, is theaxis on which this kind of accelerator earns its place. We push circuit width tofive hundred qubits, validate correctness against an independent Qiskit statevector oracle, and include a deliberate falsification experiment: zeroing the kernel output collapses the measured fidelity from above 0.99 to well below the threshold, demonstrating that the FPGA result is load-bearing and not decorative. Weclose with an honest account of the host-sampling bottleneck and the concretekernel and host changes it motivates.

•Jul 2, 2026•0 citations
State-vector simulation of n qubits requires 2^n complex amplitudes, capping a 6 GB consumer GPU at 29 qubits. We present qubit, a quantum circuit simulator whose state vector is partitioned into blocks, each stored in one of three tiers (ZERO with no storage, COMPRESSED as block-scaled int16 at 4 B/amplitude, or FULL as complex64) and resident entirely in GPU memory: promotion and demotion are kernels, and the only host traffic is scheduling metadata and measurement scalars, in contrast to prior compression frameworks that stage compressed state in host memory. Quantization error is accumulated exactly on-device; because unitaries preserve norms, per-event errors compose linearly in L2 norm, giving a conservative a-priori fidelity bound F ≥ (1−D)²/(1+D)² for total injected error D. The bound is tight at low circuit depth and becomes loose as errors accumulate, so we pair it with a random-walk estimate and direct measurement, and use its inverse to turn a user-specified fidelity target into a compression budget the runtime never exceeds. Unlike structure-aware simulators (matrix product states, stabilizer methods, or Qrack), which shrink only low-entanglement states, this compresses the genuinely dense states that have no structure to exploit: on an RTX 3060 Laptop GPU (6 GB, dense complex64 ceiling 29 qubits) qubit holds a 29-qubit fully-dense state in half its footprint at measured fidelity 0.9998, and is 3.5–6× faster than Qrack on dense circuits on the same card, while the ZERO tier still captures sparse states exactly (a 31-qubit GHZ circuit in 1 MB). An automatic planner chooses among dense, entanglement-factorized, and tiered representations from a static analysis of the circuit, so the user declares qubits, gates, and a fidelity target, and nothing else. Code and data: https://github.com/ArubikU/qubit
This paper presents EdgeQuantum, a tiered-memory quantum circuit simulator designed to overcome the memory wall of resource-constrained edge devices. As quantum algorithms scale toward dozens of qubits for on-device NISQ workloads, simulating their state vectors demands coordinated multi-tier memory management beyond the device’s physical DRAM capacity. EdgeQuantum introduces a unified storage hierarchy that integrates unified DRAM and commodity NVMe storage into a 2-tier memory architecture. With this design, EdgeQuantum achieves zero-copy data movement through UVM visibility control, hides write latency through a 4-buffer asynchronous pipeline with serialized NVMe access, and expands capacity via ping-pong mantissa-truncated LZ4 compression. Our evaluation across six quantum circuits on an 8 GB NVIDIA Jetson Orin Nano shows that EdgeQuantum enables up to 40-qubit (8 TB) simulation for high-compression circuits and 36 qubits for dense circuits, while expanding effective memory capacity by up to 1024×. Without compression, EdgeQuantum outperforms the blocking I/O baseline by up to 1.64×. With compression, overlapping CPU compression and storage I/O with GPU computation improves end-to-end pipeline efficiency by 1.40× to 1.60×.
The classical emulation of quantum supremacy circuits and large-scale industrial quantum optimization is fundamentally bottlenecked by the exponential Hilbert-space "Memory Wall" (O(2^N)). Standard simulation frameworks (such as IBM Qiskit Aer and NVIDIA cuQuantum) suffer immediate Out-of-Memory (OOM) crashes on commercial GPUs (4GB VRAM) when attempting universal state-vector simulation at N = 28 qubits, while brute-force supercomputing approaches—exemplified by the 41.9-million-core New Sunway system—require 1.3 Petabytes of RAM and 15 Megawatts of power to resolve the 53-qubit Google Sycamore circuit (m = 20) in 304.4 seconds. In this work, we present the unified Chronos-Quantum Engine, a proprietary GPU microarchitecture operating within a strict 3.58 GB VRAM ceiling on a single 60W laptop GPU (NVIDIA RTX 3050 Ti). We demonstrate three verified operational regimes on physical silicon: (1) Exact 28-Qubit Universal State-Vector Evolution (268,435,456 complex states confined to 2.147 GB VRAM) achieving IEEE-754 exactness (L2 error = 8.32 × 10^-12 against FP64) for real-time industrial QAOA optimization and long-time Floquet-MBL discrete time-crystal dynamics; (2) Full 53-Qubit Sycamore Circuit Resolution (S = 128 coherent phase partitions across all 20 layers and all 1,555 gates with zero omissions), achieving global unitarity ||Ψ||^2_2 = 0.99998384, unbiased Porter-Thomas second moment ⟨u2⟩/⟨u⟩2 = 2.014852 (0.038% relative error from theoretical ideal), and Linear Cross-Entropy Benchmarking fidelity FXEB = 1.014852 (1.039321 under Born quantile sampling) in 372.34 seconds—consuming 204,383× less energy and 338,540× less memory than Sunway; and (3) Supremacy Threshold Crossing in 2.96 seconds (Slice 1, FXEB = 0.0235 > 0.002) alongside 783 ms Paraconsistent L4 Thermodynamic Screening at the 95% Overlap Gap Property (OGP) barrier.
Full-state quantum circuit simulation requires exponentially increased memory size to store the state vector as the number of qubits scales, presenting significant limitations in classical computing systems. Our paper introduces BMQSim, a novel state vector quantum simulation framework that employs lossy compression to address the memory constraints on graphics processing unit (GPU) machines. BMQSim effectively tackles four major challenges for state-vector simulation with compression: frequent compression/decompression, high memory movement overhead, lack of dedicated error control, and unpredictable memory space requirements. Our work proposes an innovative strategy of circuit partitioning to significantly reduce the frequency of compression occurrences. We introduce a pipeline that seamlessly integrates compression with data movement while concealing its overhead. Additionally, BMQSim incorporates the first GPU-based lossy compression technique with point-wise error control. Furthermore, BMQSim features a two-level memory management system, ensuring efficient and stable execution. Our evaluations demonstrate that BMQSim can simulate the same circuit with over 10 times less memory usage on average, achieving fidelity over 0.99 and maintaining comparable simulation time to other state-of-the-art simulators.
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.
Quantum circuit simulations are applied in more and more circumstances as the quantum computing community becomes broader. It helps researchers to evaluate the quantum algorithms and relieve the burden of limited quantum computing resources. However, most of the state-of-the-art quantum simulators utilizes either CPU or GPU to store and calculate the state vector, which results in resources stravation. Morever, the mamximum number of qubits supported by simulator is bounded by the memory, since the memory utilization increases exponentially with the number of qubits. In this study, we leverage Heterogeneous computing to utilize both CPU and GPU to store and update state vectors. We also integrate lossy data compression to reduce memory requirements. Specifically, we develop a heterogeous framework that has a dynamic scheduler to fully utilize the computing resources. We apply lossy compression to chunked state vector to make the maximum number of qubits higher than the regular simulators, the compression also benifits the data movement between CPU and GPU.
Abstract Statevector simulation of quantum circuits is fundamentally bounded by an expo-nential in the qubit count, which caps single-device simulation at around thirtyqubits regardless of how the arithmetic is laid out in hardware. The matrixproduct state (MPS) representation breaks that ceiling for circuits of boundedentanglement: its memory and time cost grow only linearly in the number ofqubits and polynomially in a single control parameter, the bond dimension χ.This paper presents a quantum circuit simulator built around an MPS engine thatruns its most expensive primitive, the two-site tensor contraction, on a XilinxAlveo U55C FPGA, with the numerically delicate singular value decomposition(SVD) executed by the host. We describe the engine end to end: an eight-bank,modulo-eight interleaved high-bandwidth-memory (HBM) tensor layout that fitswithin a strict nine-AXI-master routing budget; a double-precision HLS contrac-tion kernel that streams complex amplitudes directly from HBM; a co-designsplit that keeps every floating-point divide and square root off the FPGA crit-ical path, motivated by a concrete timing-closure failure we document; a hostbackend that performs SWAP routing, host-side SVD truncation, a bank-alignedallocator, and sequential conditional sampling in O(nχ2) per shot; and a four-card distributed mode that partitions the chain across devices with an O(χ2)boundary-tensor exchange. We then report what the system actually does. Forshallow, low-entanglement circuits the FPGA contraction is a negligible fractionof wall-clock time and classical measurement sampling on the host dominates;we show this directly rather than hiding it. As the bond dimension grows thepicture inverts, and at χ = 64 the FPGA contraction accounts for roughly sev-enty percent of the run, confirming that bond dimension, not qubit count, is theaxis on which this kind of accelerator earns its place. We push circuit width tofive hundred qubits, validate correctness against an independent Qiskit statevector oracle, and include a deliberate falsification experiment: zeroing the kernel output collapses the measured fidelity from above 0.99 to well below the threshold, demonstrating that the FPGA result is load-bearing and not decorative. Weclose with an honest account of the host-sampling bottleneck and the concretekernel and host changes it motivates.