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

How Few Bits Per Amplitude? A Rate–Distortion Floor for Quantum State-Vector Formats, and Where Per-Block Scaling Wins

Christopher K Merrill

Published Sep 5, 2026• 0 citations
Publisher

Abstract

Full state-vector simulation of quantum circuits is limited by the memory and bandwidth needed to hold 2^n complex amplitudes. Two published simulators store amplitudes in two bytes rather than sixteen: JUQCS-A (De Raedt et al., 2019), which uses a global linear magnitude grid with an eight-bit phase, and the polar-logarithmic format of Betelú (2020). Betelú closes by asking whether any format uses less storage for a given error. We answer that question. We first establish an information-theoretic floor. The amplitudes of a maximally entangled random state are independent complex Gaussians, so the Shannon rate-distortion bound applies and no format can achieve squared error below 2^-B at B bits per amplitude. Measured against it, JUQCS-A sits 2.17 bits above the floor and Betelú's format 4.21 bits. Block floating point with a shared power-of-two exponent per 32 amplitudes — the MXINT8 layout that current machine-learning hardware executes natively — sits 2.24 bits above it, and 1.20 bits with an exact scale. Block floating point beats JUQCS-A by 1.95x at an exact scale, sits within 17% of it at a power-of-two scale with the ordering set by qubit parity, and beats it on every concentrated state we tested on both metrics. Against Betelú it splits along a boundary we locate and explain. It wins on random states by 3.90x in squared error, a margin that grows as ln N because a global scale is set by an extreme value of the sample. It loses above three or four spikes spread across distinct blocks — the output shape of Shor's algorithm — and it loses the quantum Fourier transform by 2.16x, where Betelú's phase field renders most controlled rotations exact. But the choice of metric decides the winner: across every concentrated state we tested, total variation distance between measurement distributions reverses each squared-error loss, because a block scale flattens amplitudes carrying O(1/N) of the norm that no measurement resolves. All results are at 16-24 qubits on a single core. Every number is produced by a released script. v2 — 2026-09-04 No results or numbers changed from v1. Figure 1: legend moved clear of the curves it was overlapping, and the "Betelú" label in both figure legends corrected — a LaTeX escape had been rendering literally as Betel\'u. Section 4: replaced "per-block scaling recovers most of the remaining gap" with the measured fractions (71% with an exact scale, 47% with a power-of-two scale), which the following paragraph contradicted. Source archive now includes LICENSE and CORRECTIONS.md, so the deposit carries the license it names and the corrections record its README points at.

DOI
10.5281/zenodo.22314204

Related papers

What Determines an Amplitude Format's Error: Closed-Form Predictors for Quantum State-Vector Storage

Christopher K Merrill

Two published simulators store quantum amplitudes in two bytes rather than sixteen, and a third layout, block floating point, is what current machine-learning hardware executes natively. A companion paper measured all three against a rate-distortion floor and asked which is best. This paper asks what each one's error is a function of, and answers it in closed form. We first show that the error of Betelú's polar-logarithmic format is a constant of the format. His Eq. 10 is derived for maximally entangled random states, but its hypothesis is only that the fractional parts of the scaled log-modulus and phase are equidistributed; where they are, the amplitude distribution cancels out of the sum. Across 280 snapshots spanning a random circuit from two starting states at 18, 20 and 22 qubits, the measured error departs from that constant by at most 2.06%, 0.95% and 0.27%, the residual falling as 1/sqrt(N) while the other formats move by 29 bits. Regressed on the log-variance of the moduli, on the entanglement entropy, and on both, its R^2 is 0.000. That is the extreme case of a general result: every format here has an error that is a closed-form functional of the state, computable without running the conversion. We give seven such predictors, none fitted, with a median measured-to-derived ratio of 1.000 where each applies, and we name the three ways the underlying model fails, each with a test evaluable in advance. A correction to our own earlier model follows from one of them. We then use the seven to answer the question the companion paper could not pose. There is no crossover between block floating point and either competitor along circuit depth or amplitude spread. Randomly permuting a state's amplitudes preserves its histogram and destroys block locality, and doing so multiplies block floating point's losses to polar-log from 8 in 451 states to 60 in 451. How much of its advantage is structural depends on the state: none of it on random states, where permuting changes nothing, and up to a factor of 3.6 at moderate spread. It also shows that permutation invariance follows from having one parameter per state rather than from being per-amplitude, so a global scale has it. Finally, we record that the single state property we preregistered as the predictor is the right answer for none of the seven formats, and that after a single conversion the total variation distance cannot see phase error at all. All results are at 18 to 22 qubits on a single core. Every number is produced by a released script from released data.

•Sep 9, 2026•0 citations

Lossy Compression for Schrödinger-style Quantum Simulations

Noah Huffman, Dmitri S. Pavlichin, Tsachy Weissman

Simulating quantum circuits on classical hardware is a powerful and necessary tool for developing and testing quantum algorithms and hardware as well as evaluating claims of quantum supremacy in the Noisy Intermediate-Scale Quantum (NISQ) regime. Schrödinger-style simulations are limited by the exponential growth of the number of state amplitudes which need to be stored. In this work, we apply scalar and vector quantization to Schrödinger-style quantum circuit simulations as lossy compression schemes to reduce the number of bits needed to simulate quantum circuits. Using quantization, we can maintain simulation fidelities $>0.99$ when simulating the Quantum Fourier Transform, while using only 7 significand bits in a floating-point number to characterize the real and imaginary components of each amplitude. Furthermore, using vector quantization, we propose a method to bound the number of bits/amplitude needed to store state vectors in a simulation of a circuit that achieves a desired fidelity, and show that for a 6 qubit simulation of the Quantum Fourier Transform, 15 bits/amplitude is sufficient to maintain fidelity $>0.9$ at $10^4$ depth.

arXiv:2401.11088•Jan 20, 2024•3 citations

Why large-scale quantum computing faces hard physical limits: a source-loss balance tested against measured data

Oleg Arnold

This note applies a single first-order source-loss balance, C dθ/dt = A − ρθ, to systems across many scales — from a planetary surface to a qubit register — and reports, with exact numbers, where the balance reproduces measured values and where it does not. The central quantitative result concerns quantum error correction. Using published surface-code and trapped-ion data (Google Quantum AI, Nature 638, 920 (2024); Quantinuum Helios colour-code results, 2026), the note shows that the logical error per cycle falls by a constant factor Λ only while errors are independent. Correlated bursts act as a common loss channel whose rate does not fall with code distance; the quoted floor is about 3×10⁻¹⁰ per cycle, reached at distance about 46 for Λ = 2.17. For factoring a 2048-bit integer (about 1.4×10³ logical qubits, 6.5×10⁹ Toffoli gates, 4.96 days at a 1 μs cycle), the permitted logical error is 1.7×10⁻¹⁵ per qubit per cycle. At measured suppression factors this requires code distances of about 78 (Λ = 2.17) or about 24 (Λ = 12), while the published design uses 25 — and the correlated-error floor is not removed by increasing distance. This is a quantitative statement about where the scaling of error suppression stops matching the requirements of large computations, not a claim that small-scale quantum devices cannot work. The note also lists, separately and with exact values, the tests the balance fails: quark mass-step prediction (T6), gas/solid classification (T8, p = 0.81), nuclear count with A = 3, 4, prediction SP1 (−11.8% against a 10% threshold), coupling versus number of doors (T10, p = 0.015), width-to-cosmological-scale mapping (q₀ = −0.528 ± 0.011 against 0), human loss-rate estimates (11.1 and 15.3 W/K), critical Q₁₀ = 3.03 against measured 2.0–2.3, Higgs width from the b-quark exit alone (13.7% residual), shell boundaries (13 of 18), and several time constants. Of nine tests where the balance gives a value different from the standard one, one agreed with measurement and eight did not; the rules and thresholds were written before the data were examined. Successful checks include: photosynthesis stage efficiencies (0.487 × 0.094 = 0.0458 against 0.046 reported), a three-stage 2.45 GHz rectenna chain (0.906³ = 0.744), closure of the lunar surface energy budget to a ratio of 1.005, mode quality factors Q = m/Γ for the τ lepton (7.84×10¹¹), the Z boson (36.5) and the Higgs boson (3.38×10⁴), the Higgs lifetime from its width (290.87 fs against 290.3 ± 0.5 fs, a consistency check of standard formulas), and the proton-decay bound ρ < 1.3×10⁻⁴² s⁻¹. The complete theory, tests, scripts and the list of open items are maintained at https://zenodo.org/records/23812417. This note is a standalone publication; readers are invited to report measured values that disagree.

•Nov 13, 2026•0 citations

Exact Bounds on Exponential Concentration for Block-Product Quantum Fidelity Kernels

Mezbah Uddin Rafi

Abstract We characterize the achievable second-moment concentration exponent for block-product fidelity quantum kernels whose per-block ensembles have a maximally mixed first moment. For n = mb qubits partitioned into m independent b-qubit blocks, with no entangling gate crossing a block boundary, the exponent c, defined by E[κ²] = 2⁻ᶜⁿ, satisfies c ∈ [1, c(b)] for every finite b, where c(b) = [(b−1) + log₂(2ᵇ+1)]/b increases monotonically from log₂ 3 ≈ 1.585 at b=1 to 2 as b→∞. The lower endpoint is attained exactly by digitizing (basis-encoding) block ensembles, proved here; the upper endpoint follows from the optimal second frame potential of state 2-designs (Nakata et al.) [8], which we apply rather than re-derive. We validate the resulting scaling against idealized Haar-random blocks and finite-depth parameterized circuits, with propagated standard errors, obtaining relative error from −2.9% to +0.14% for block sizes b=2 through 6, tightening as b grows. We identify a structural limitation of single-qubit (b=1) blocks: a continuous data parameter spans only a one-dimensional subset of the Bloch sphere, which has zero measure with respect to the Haar measure, so no purely data-driven single-qubit encoding can realize an exact 2-design; a depth study shows the corresponding purity converging non-monotonically, consistent with this limitation. We further distinguish two notions of practical resolvability — the shot-noise threshold implied by the variance exponent, and the finite-shot consequence for pairwise similarity ranking — report each together with its associated agreement criterion, and calibrate the relationship between them on finite-depth circuits across a shot-budget-by-qubit-count grid (180 points, median heuristic error 0.017). Finally, we relate this result to adjacent constructions that also avoid concentration through different mechanisms — covariant kernels, permutation-equivariant barren-plateau-free kernels, and a Rydberg-blockade many-body kernel — each of which lies outside the hypothesis class considered here.

•Aug 18, 2026•0 citations

Multi-FPGA Quantum Circuit Simulation: ADistributed Statevector Architecture on FourXilinx Alveo U55C Accelerators

Nasir Ali Nasir Ali

Abstract This paper presents a distributed quantum circuit statevector simulator thatpartitions the full 2n-amplitude state vector across four Xilinx Alveo U55C field-programmable gate arrays, each equipped with eight gigabytes of HBM2. Thearchitecture assigns two top-index qubits as partition bits so that card j ownsall amplitudes whose binary index has bits [n − 2, n − 1] equal to j, givingeach card a local statevector of 2n−2 complex double-precision amplitudes inter-leaved across eight HBM banks under a modulo-eight scheme. Gate executionis divided into three paths: local gates (acting on qubit indices below n − 2)are dispatched directly to the on-card HLS kernel; diagonal gates acting on par-tition qubits (controlled-phase, RZ , phase, CZ) are applied as a scalar phasemultiply without any cross-card data movement; and non-diagonal partition-qubit gates (Hadamard, CNOT) are handled by a three-barrier, double-bufferedshared-memory exchange followed by vectorised host arithmetic. This diagonal-gate local path eliminates cross-card traffic for every controlled-phase gate ina Quantum Fourier Transform, which would otherwise constitute the dominantcommunication bottleneck in a distributed QFT implementation.We validate the system across five quantum algorithm families on real hardware.The Quantum Fourier Transform achieves state fidelity F = 1.000000000000against an independent Qiskit statevector reference for all circuit widths fromn = 4 to n = 18 qubits, with wall-clock times ranging from 0.96 s at fourqubits to 19.1 s at eighteen qubits. Grover search circuits on up to ten qubitsachieve target-state probability exceeding 99.9% in all cases, with measuredfidelity F = 1.0 confirming exact computation on the FPGA hardware. GHZstate preparation, Bell pair generation, QFT–IQFT round-trips, and a nine-qubitShor algorithm component all pass at F = 1.000000000000. At twenty qubits, where each card holds 218 = 262,144 amplitudes consuming four megabytes ofHBM per card, the simulation completes correctly in under two minutes.Compared with the prior single-FPGA 30-qubit statevector engine, the distributed architecture extends the qubit ceiling to 28 qubits (4 GB total HBM)with exact complex128 precision, and removes the routing failure that prevented a sixteen-bank single-kernel design from placing on the XCVU55C. Comparedwith the Matrix Product State engine at 500 qubits, the statevector approachremains exact for arbitrary entanglement, at the cost of exponential memoryscaling rather than polynomial. The companion real-time quantum error correc-tion kernels and the native RTL statevector design together constitutea complete FPGA quantum computing stack, and the multi-FPGA distributedarchitecture presented here occupies the high-fidelity large-scale simulation tierof that stack.

•Aug 25, 2026•0 citations

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

Piero Jose Alarcon Dueñas

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

•Jul 22, 2026•0 citations
Full state-vector simulation of quantum circuits is limited by the memory and bandwidth needed to hold 2^n complex amplitudes. Two published simulators store amplitudes in two bytes rather than sixteen: JUQCS-A (De Raedt et al., 2019), which uses a global linear magnitude grid with an eight-bit phase, and the polar-logarithmic format of Betelú (2020). Betelú closes by asking whether any format uses less storage for a given error. We answer that question. We first establish an information-theoretic floor. The amplitudes of a maximally entangled random state are independent complex Gaussians, so the Shannon rate-distortion bound applies and no format can achieve squared error below 2^-B at B bits per amplitude. Measured against it, JUQCS-A sits 2.17 bits above the floor and Betelú's format 4.21 bits. Block floating point with a shared power-of-two exponent per 32 amplitudes — the MXINT8 layout that current machine-learning hardware executes natively — sits 2.24 bits above it, and 1.20 bits with an exact scale. Block floating point beats JUQCS-A by 1.95x at an exact scale, sits within 17% of it at a power-of-two scale with the ordering set by qubit parity, and beats it on every concentrated state we tested on both metrics. Against Betelú it splits along a boundary we locate and explain. It wins on random states by 3.90x in squared error, a margin that grows as ln N because a global scale is set by an extreme value of the sample. It loses above three or four spikes spread across distinct blocks — the output shape of Shor's algorithm — and it loses the quantum Fourier transform by 2.16x, where Betelú's phase field renders most controlled rotations exact. But the choice of metric decides the winner: across every concentrated state we tested, total variation distance between measurement distributions reverses each squared-error loss, because a block scale flattens amplitudes carrying O(1/N) of the norm that no measurement resolves. All results are at 16-24 qubits on a single core. Every number is produced by a released script. v2 — 2026-09-04 No results or numbers changed from v1. Figure 1: legend moved clear of the curves it was overlapping, and the "Betelú" label in both figure legends corrected — a LaTeX escape had been rendering literally as Betel'u. Section 4: replaced "per-block scaling recovers most of the remaining gap" with the measured fractions (71% with an exact scale, 47% with a power-of-two scale), which the following paragraph contradicted. Source archive now includes LICENSE and CORRECTIONS.md, so the deposit carries the license it names and the corrections record its README points at.
Two published simulators store quantum amplitudes in two bytes rather than sixteen, and a third layout, block floating point, is what current machine-learning hardware executes natively. A companion paper measured all three against a rate-distortion floor and asked which is best. This paper asks what each one's error is a function of, and answers it in closed form. We first show that the error of Betelú's polar-logarithmic format is a constant of the format. His Eq. 10 is derived for maximally entangled random states, but its hypothesis is only that the fractional parts of the scaled log-modulus and phase are equidistributed; where they are, the amplitude distribution cancels out of the sum. Across 280 snapshots spanning a random circuit from two starting states at 18, 20 and 22 qubits, the measured error departs from that constant by at most 2.06%, 0.95% and 0.27%, the residual falling as 1/sqrt(N) while the other formats move by 29 bits. Regressed on the log-variance of the moduli, on the entanglement entropy, and on both, its R^2 is 0.000. That is the extreme case of a general result: every format here has an error that is a closed-form functional of the state, computable without running the conversion. We give seven such predictors, none fitted, with a median measured-to-derived ratio of 1.000 where each applies, and we name the three ways the underlying model fails, each with a test evaluable in advance. A correction to our own earlier model follows from one of them. We then use the seven to answer the question the companion paper could not pose. There is no crossover between block floating point and either competitor along circuit depth or amplitude spread. Randomly permuting a state's amplitudes preserves its histogram and destroys block locality, and doing so multiplies block floating point's losses to polar-log from 8 in 451 states to 60 in 451. How much of its advantage is structural depends on the state: none of it on random states, where permuting changes nothing, and up to a factor of 3.6 at moderate spread. It also shows that permutation invariance follows from having one parameter per state rather than from being per-amplitude, so a global scale has it. Finally, we record that the single state property we preregistered as the predictor is the right answer for none of the seven formats, and that after a single conversion the total variation distance cannot see phase error at all. All results are at 18 to 22 qubits on a single core. Every number is produced by a released script from released data.
Simulating quantum circuits on classical hardware is a powerful and necessary tool for developing and testing quantum algorithms and hardware as well as evaluating claims of quantum supremacy in the Noisy Intermediate-Scale Quantum (NISQ) regime. Schrödinger-style simulations are limited by the exponential growth of the number of state amplitudes which need to be stored. In this work, we apply scalar and vector quantization to Schrödinger-style quantum circuit simulations as lossy compression schemes to reduce the number of bits needed to simulate quantum circuits. Using quantization, we can maintain simulation fidelities >0.99>0.99>0.99 when simulating the Quantum Fourier Transform, while using only 7 significand bits in a floating-point number to characterize the real and imaginary components of each amplitude. Furthermore, using vector quantization, we propose a method to bound the number of bits/amplitude needed to store state vectors in a simulation of a circuit that achieves a desired fidelity, and show that for a 6 qubit simulation of the Quantum Fourier Transform, 15 bits/amplitude is sufficient to maintain fidelity >0.9>0.9>0.9 at 10410^4104 depth.
This note applies a single first-order source-loss balance, C dθ/dt = A − ρθ, to systems across many scales — from a planetary surface to a qubit register — and reports, with exact numbers, where the balance reproduces measured values and where it does not. The central quantitative result concerns quantum error correction. Using published surface-code and trapped-ion data (Google Quantum AI, Nature 638, 920 (2024); Quantinuum Helios colour-code results, 2026), the note shows that the logical error per cycle falls by a constant factor Λ only while errors are independent. Correlated bursts act as a common loss channel whose rate does not fall with code distance; the quoted floor is about 3×10⁻¹⁰ per cycle, reached at distance about 46 for Λ = 2.17. For factoring a 2048-bit integer (about 1.4×10³ logical qubits, 6.5×10⁹ Toffoli gates, 4.96 days at a 1 μs cycle), the permitted logical error is 1.7×10⁻¹⁵ per qubit per cycle. At measured suppression factors this requires code distances of about 78 (Λ = 2.17) or about 24 (Λ = 12), while the published design uses 25 — and the correlated-error floor is not removed by increasing distance. This is a quantitative statement about where the scaling of error suppression stops matching the requirements of large computations, not a claim that small-scale quantum devices cannot work. The note also lists, separately and with exact values, the tests the balance fails: quark mass-step prediction (T6), gas/solid classification (T8, p = 0.81), nuclear count with A = 3, 4, prediction SP1 (−11.8% against a 10% threshold), coupling versus number of doors (T10, p = 0.015), width-to-cosmological-scale mapping (q₀ = −0.528 ± 0.011 against 0), human loss-rate estimates (11.1 and 15.3 W/K), critical Q₁₀ = 3.03 against measured 2.0–2.3, Higgs width from the b-quark exit alone (13.7% residual), shell boundaries (13 of 18), and several time constants. Of nine tests where the balance gives a value different from the standard one, one agreed with measurement and eight did not; the rules and thresholds were written before the data were examined. Successful checks include: photosynthesis stage efficiencies (0.487 × 0.094 = 0.0458 against 0.046 reported), a three-stage 2.45 GHz rectenna chain (0.906³ = 0.744), closure of the lunar surface energy budget to a ratio of 1.005, mode quality factors Q = m/Γ for the τ lepton (7.84×10¹¹), the Z boson (36.5) and the Higgs boson (3.38×10⁴), the Higgs lifetime from its width (290.87 fs against 290.3 ± 0.5 fs, a consistency check of standard formulas), and the proton-decay bound ρ < 1.3×10⁻⁴² s⁻¹. The complete theory, tests, scripts and the list of open items are maintained at https://zenodo.org/records/23812417. This note is a standalone publication; readers are invited to report measured values that disagree.
Abstract We characterize the achievable second-moment concentration exponent for block-product fidelity quantum kernels whose per-block ensembles have a maximally mixed first moment. For n = mb qubits partitioned into m independent b-qubit blocks, with no entangling gate crossing a block boundary, the exponent c, defined by E[κ²] = 2⁻ᶜⁿ, satisfies c ∈ [1, c(b)] for every finite b, where c(b) = [(b−1) + log₂(2ᵇ+1)]/b increases monotonically from log₂ 3 ≈ 1.585 at b=1 to 2 as b→∞. The lower endpoint is attained exactly by digitizing (basis-encoding) block ensembles, proved here; the upper endpoint follows from the optimal second frame potential of state 2-designs (Nakata et al.) [8], which we apply rather than re-derive. We validate the resulting scaling against idealized Haar-random blocks and finite-depth parameterized circuits, with propagated standard errors, obtaining relative error from −2.9% to +0.14% for block sizes b=2 through 6, tightening as b grows. We identify a structural limitation of single-qubit (b=1) blocks: a continuous data parameter spans only a one-dimensional subset of the Bloch sphere, which has zero measure with respect to the Haar measure, so no purely data-driven single-qubit encoding can realize an exact 2-design; a depth study shows the corresponding purity converging non-monotonically, consistent with this limitation. We further distinguish two notions of practical resolvability — the shot-noise threshold implied by the variance exponent, and the finite-shot consequence for pairwise similarity ranking — report each together with its associated agreement criterion, and calibrate the relationship between them on finite-depth circuits across a shot-budget-by-qubit-count grid (180 points, median heuristic error 0.017). Finally, we relate this result to adjacent constructions that also avoid concentration through different mechanisms — covariant kernels, permutation-equivariant barren-plateau-free kernels, and a Rydberg-blockade many-body kernel — each of which lies outside the hypothesis class considered here.
Abstract This paper presents a distributed quantum circuit statevector simulator thatpartitions the full 2n-amplitude state vector across four Xilinx Alveo U55C field-programmable gate arrays, each equipped with eight gigabytes of HBM2. Thearchitecture assigns two top-index qubits as partition bits so that card j ownsall amplitudes whose binary index has bits [n − 2, n − 1] equal to j, givingeach card a local statevector of 2n−2 complex double-precision amplitudes inter-leaved across eight HBM banks under a modulo-eight scheme. Gate executionis divided into three paths: local gates (acting on qubit indices below n − 2)are dispatched directly to the on-card HLS kernel; diagonal gates acting on par-tition qubits (controlled-phase, RZ , phase, CZ) are applied as a scalar phasemultiply without any cross-card data movement; and non-diagonal partition-qubit gates (Hadamard, CNOT) are handled by a three-barrier, double-bufferedshared-memory exchange followed by vectorised host arithmetic. This diagonal-gate local path eliminates cross-card traffic for every controlled-phase gate ina Quantum Fourier Transform, which would otherwise constitute the dominantcommunication bottleneck in a distributed QFT implementation.We validate the system across five quantum algorithm families on real hardware.The Quantum Fourier Transform achieves state fidelity F = 1.000000000000against an independent Qiskit statevector reference for all circuit widths fromn = 4 to n = 18 qubits, with wall-clock times ranging from 0.96 s at fourqubits to 19.1 s at eighteen qubits. Grover search circuits on up to ten qubitsachieve target-state probability exceeding 99.9% in all cases, with measuredfidelity F = 1.0 confirming exact computation on the FPGA hardware. GHZstate preparation, Bell pair generation, QFT–IQFT round-trips, and a nine-qubitShor algorithm component all pass at F = 1.000000000000. At twenty qubits, where each card holds 218 = 262,144 amplitudes consuming four megabytes ofHBM per card, the simulation completes correctly in under two minutes.Compared with the prior single-FPGA 30-qubit statevector engine, the distributed architecture extends the qubit ceiling to 28 qubits (4 GB total HBM)with exact complex128 precision, and removes the routing failure that prevented a sixteen-bank single-kernel design from placing on the XCVU55C. Comparedwith the Matrix Product State engine at 500 qubits, the statevector approachremains exact for arbitrary entanglement, at the cost of exponential memoryscaling rather than polynomial. The companion real-time quantum error correc-tion kernels and the native RTL statevector design together constitutea complete FPGA quantum computing stack, and the multi-FPGA distributedarchitecture presented here occupies the high-fidelity large-scale simulation tierof that stack.
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