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.
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 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 104 depth.
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
# Constraint Preservation in a Neural Quantum Simulator This chapter is not about capability. It is about exposure. I fixed the execution parameters deliberately. Grid size sixteen. Hidden dimension thirty-two. Expansion dimension sixty-four. CPU only. No stochasticity. No device noise. Three backends loaded independently from disk: Hamiltonian, Schrödinger, Dirac. Each checkpoint was restored without shared memory, without shared caches, without synchronized initialization beyond numerical libraries. The system announced itself plainly: joint Hilbert space, no abstraction layer hiding state evolution. What followed was not a benchmark run but a constraint sweep. The first observation was temporal stability. Across the entire execution window, no backend reloaded weights mid-run, no lazy initialization occurred after the first measurement, and no backend diverged in wall-clock behavior. This matters because silent reinitialization is a common source of false consistency in hybrid simulators. Here, the log timestamps show continuous execution with no discontinuities. The Bell state preparation was identical across backends. The Hamiltonian backend reported P(|00>) = 0.5000 and P(|11>) = 0.5000 with Shannon entropy exactly 1.0000 bits. The Schrödinger backend produced the same distribution. The Dirac backend did as well. The most probable state differed only by ordering, never by value. More importantly, the per-qubit marginals were symmetric: P(|1>) = 0.5000 for each qubit, with ⟨Z⟩ = 0.0000. The Bloch vectors collapsed to the origin. This indicates not only entanglement, but absence of bias introduced by basis ordering or backend-specific normalization. The GHZ three-qubit state extended this behavior without degradation. Again, the probability mass was split exactly between |000> and |111>. The entropy remained at 1.0000 bit, not increasing spuriously with qubit count. Each marginal remained maximally mixed. No backend introduced asymmetry across qubits. At this point, agreement is expected. The deviation appears when phase-sensitive algorithms are introduced. The Deutsch–Jozsa constant oracle produced |000> with probability 0.5000 and |001> with probability 0.5000. This is not a mistake. The ancilla qubit remained in superposition while the input register collapsed deterministically. The per-qubit marginals confirmed this: q0 and q1 had P(|1>) = 0.0000 with ⟨Z⟩ = +1.0000, while q2 remained unbiased. This pattern was identical across all three backends. The balanced oracle inverted this behavior. The most probable state shifted to |100> with probability 0.5000. Again, entropy remained at 1.0000 bit. The first qubit flipped deterministically, the second remained fixed, the third stayed unbiased. This is the expected interference pattern. No leakage was observed. The quantum Fourier transform on three qubits is where simulators often diverge. Here, the measured distribution was uniform: eight basis states each at probability 0.1250. The Shannon entropy measured exactly 3.0000 bits. All per-qubit marginals returned P(|1>) = 0.5000. Bloch vectors aligned along +X, consistent with Hadamard structure. No backend introduced residual structure. Grover’s algorithm exposed amplification fidelity. The marked state |101> reached probability 0.9453. The remaining probability mass was distributed symmetrically among unmarked states at approximately 0.0078 each. The entropy dropped to 0.4595 bits. The per-qubit marginals showed strong polarization on q0 and q2, with q1 inverted. These values matched across Hamiltonian, Schrödinger, and Dirac backends within numerical precision. Teleportation did not collapse incorrectly. The output distribution spread across four states, each with probability 0.1875, yielding entropy 2.8113 bits. Crucially, the target qubit marginal reflected partial information transfer: P(|1>) = 0.2500 with ⟨Z⟩ = +0.5000. This indicates that classical correction was encoded implicitly in correlations rather than applied procedurally. No backend shortcut this process. The snapshot sequence H–CNOT–Z–H revealed the most subtle invariant. At step three, the distribution became uniform, not because the system forgot phase, but because phase remained internal. The log explicitly notes that Z introduced a −1 phase on |11>, and that H on qubit zero produced amplitudes with differing signs. All four probabilities measured 0.25. Phase was preserved but remained unobservable, exactly as quantum mechanics requires. After circuit execution, the phase coherence and unitarity test suite ran without resetting state. Single-qubit algebraic identities were verified numerically. HZH mapped |0> to |1> with unit probability. HXH mapped |0> to |0>. HSSH collapsed to HZH. H Rz(π) H produced X. Ry(π) and Rx(π) both mapped |0> to |1>. XX erased itself. HZZH reduced to identity. None of these tests relied on symbolic substitution. Each was executed as amplitude evolution followed by measurement. Two-qubit interference tests confirmed closure under composition. H–CNOT–CNOT–H reduced to identity with P(|00>) = 1.0000. Composite CZ insertions altered nothing when they should not. Z applied conditionally on the control qubit propagated correctly. SWAP behaved as an involution. Applying it twice erased its effect completely. Norm preservation was tested explicitly after each major construct. In all cases, the sum of probabilities was reported as exactly 1.00000000. No backend drifted. No normalization correction was applied post hoc. Entropy tests closed the loop. Bell and GHZ states measured exactly one bit. QFT measured exactly three bits. The |0> state measured zero bits. These are not approximate values. They are exact within floating-point resolution. All twenty-two tests passed. Only then did the system cross into chemistry. The hydrogen molecule calculation began by loading reference data from PySCF. Hartree–Fock energy −1.11699900 Ha. Full configuration interaction energy −1.13730604 Ha. Nuclear repulsion term explicitly logged. This reference was treated as ground truth. The Hamiltonian was mapped via Jordan–Wigner into fourteen Pauli terms acting on four qubits. No truncation. No term merging. Each coefficient preserved. The Hartree–Fock computational basis state |1100> evaluated to −1.11699900 Ha exactly. The verification step confirmed zero discrepancy between calculated and target HF energy. This removed compensating degrees of freedom. The surrogate model established a floor at −1.139306 Ha but was calibrated to match the Hartree–Fock reference exactly. Offset reduced to zero. This calibration did not improve the result. It removed bias. The UCCSD ansatz consisted of four single excitations and one double excitation. Five parameters. No redundancy. At θ = 0, the energy evaluated to −1.11699900 Ha, confirming identity behavior. The double excitation amplitude was scanned manually. Energy decreased smoothly as θ_d approached −0.10. At θ_d = −0.10, the energy reached −1.13707997 Ha, within 2.26×10⁻⁴ Ha of the exact FCI value. The landscape was shallow, symmetric, and well-behaved. Optimization proceeded without noise. After twenty iterations, the energy converged to −1.13730604 Ha. The absolute error relative to FCI was 1.31×10⁻¹¹ Ha. Correlation energy recovery was 100.0%. No regularization was introduced. No noise model was invoked. The optimizer stopped because further reduction was numerically impossible. What these logs show is not that the system can run algorithms. They show that it remains constrained when nothing is helping it. Phase does not leak. Norm does not drift. Entropy does not wander. Energy does not compensate. At this point, the simulator stops behaving like an approximation engine. It behaves like a rule-preserving system. That is the boundary crossed in this chapter. # Constraint Preservation in a Neural Quantum Simulator **grisun0** --- ## Abstract I report experimental observations from a quantum circuit simulator that uses neural network backends to evolve wavefunctions in a joint Hilbert space. Three independently trained models—Hamiltonian, Schrödinger, and Dirac—were loaded from disk and tested on standard quantum algorithms. All three produced identical results across Bell states, GHZ states, Deutsch-Jozsa, quantum Fourier transform, Grover's algorithm, and quantum teleportation. A phase coherence test suite passed 22 of 22 tests. A variational quantum eigensolver recovered 100% of the correlation energy for molecular hydrogen, matching the full configuration interaction energy to within 1.31 × 10⁻¹¹ Hartree. These results suggest that neural physics backends can preserve quantum mechanical constraints without explicit enforcement. --- ## 1. Introduction Classical simulation of quantum systems is straightforward: evolve a state vector under unitary operations, measure probabilities, repeat. What makes this simulation different is that the state vector lives in an extended representation. Each amplitude is a two-channel spatial field evolved by a neural network trained to approximate physical dynamics. The question I wanted to answer was simple. If I run quantum algorithms through three different neural backends—trained independently, loaded from separate checkpoints—do they agree? And if they agree, do they agree with theory? This paper documents what I observed. --- ## 2. Methods ### 2.1 State representation The simulator represents an n-qubit state as a tensor of shape (2ⁿ, 2, G, G), where G = 16 is the spatial grid size. The first index labels computational basis states. The second index holds real and imaginary components. The last two indices represent a spatial wavefunction. Born probabilities are computed by integrating the squared modulus over the spatial grid: P(k) = Σₓᵧ (αₖ,real² + αₖ,imag²) normalized so that Σₖ P(k) = 1. ### 2.2 Backends Three neural backends were used: - **Hamilto