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.
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.
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.
We derive a fundamental lower bound on the gate error rate of any quantum computing platform from the K-functional framework. Two irreducible error sources compete: K_rec record back-action (the environment acquires information about which gate was applied, corrupting the qubit) and K_ent thermal decoherence (the qubit thermalizes during the gate operation). The K_rec error decreases with weaker qubit-control coupling while the K_ent error increases, producing a U-shaped curve with a minimum at the optimal coupling g/w = (8pi/Q)^(1/3), where Q is the qubit quality factor. The minimum error rate is e_floor = 0.512 Q^(-2/3). At this minimum, K_rec contributes exactly one-third of the total error and K_ent contributes two-thirds, a ratio fixed by the cubic optimization and not adjustable by engineering. The floor scales as Q^(-2/3), not Q^(-1) as standard decoherence theory would suggest. This sub-linear scaling is a testable prediction: on a log-log plot of error rate versus quality factor across platforms, the K-functional predicts slope -2/3 rather than -1. The same one-loop factor 1/(16pi^2) that governs the chiral anomaly (Paper 12) and the cosmological constant (Paper 13) sets the K_rec back-action rate, connecting quantum computing errors to fundamental physics. The Bekenstein bound limits the maximum quality factor to Q_max = S_Bek = 2piER/(hbar c), giving an absolute error floor of 0.512 S_Bek^(-2/3). At the Planck scale (the monopole of Paper 3), S_Bek = 2pi, giving a 15% per-operation error rate, above the fault-tolerance threshold. The gauge algebra SU(3) x SU(2) x U(1) survives the cosmological bounce because 2pi bits is just sufficient to encode the algebra, and the bounce attractor (Paper 11, gain 0.23) provides cross-cycle error correction. The algebra is selected in a single bounce: it is the only key that fits a 2pi-bit lock.
Here's what this paper means for actual humans: WHAT THIS IS ABOUT. When you build or use a quantum device, everything rests on knowing what its parts are: which degrees of freedom are "qubit 1," which are "qubit 2." The companion paper ("Forged Frames") showed that simple mathematical criteria cannot certify this; convincing fakes exist. This paper answers the question that result leaves standing: what is the MINIMUM experimental information that genuinely pins down a system's subsystem structure, and when can that information silently fail? WHAT WE FOUND, IN PLAIN TERMS. Four things. (1) EXACT LAWS INSTEAD OF MEASUREMENTS. Any wrong choice of parts must visibly distort the family of unentangled states, and we derive exactly how much, at every system size: closed-form constants (verified to seven decimal places), an explicit error bound, and a surprise. The two natural ways to measure "wrongness" (state distortion versus operator scrambling) turn out to be literally the same measurement, up to a fixed number, whenever the two parts have equal size. Wrongness cannot hide. (2) THE TWO-OPERATION THRESHOLD. You can pin down what your subsystems are by implementing just TWO generic operations and checking their statistics, while a THOUSAND mutually commuting operations tell you nothing at all. Diversity of control, not volume of control, is what fixes what your qubits are. The residual uncertainty is proportional to your measurement tolerance, with a constant we derive exactly and show how to compute in advance, so an experimenter can screen candidate operation pairs and pick a strong one (random pairs are typically several times worse, occasionally catastrophically so). (3) THE ALIASING LIMIT: CERTIFICATION CAN PASS WHILE TELLING YOU NOTHING. If you sample your certification data at special "resonant" times (set by the operations' energy scales), a maximally wrong assignment of subsystems passes the test perfectly. What your qubits are depends on when you looked. We characterize these blind spots exactly (for qubits they are universal and computable in advance; the danger windows shrink with the square root of your tolerance), and the fix costs almost nothing: sample at two different times, at least one away from the resonant set. With that, certification is restored; we prove it exactly and measure it. (4) REAL-LAB BUDGETS. We work out what certification costs in actual measurement shots (the error falls off unusually fast, inversely with the total number of shots rather than with its square root), how hardware noise floors the procedure, and how a simple reference measurement removes that floor to first order. A single seven-row table in the paper is effectively a lab protocol: it shows, condition by condition, which kinds of experimental access identify the subsystem structure (two generic operations: yes; one operation, commuting operations, resonant sampling: no). WHY IT MATTERS. For quantum hardware: this is a concrete recipe for certifying that the qubits you think you have are the qubits you physically have, with explicit tolerances, a sampling-time warning that is a real failure mode on calibrated hardware, and shot budgets. For foundations: the contested question "does physics determine its own subsystems?" gets a quantitative operational answer. Physics determines an operational subsystem CLASS (not one preferred coordinate representation of it), and that class is fixed by two operations sampled at two times, and by nothing less that we tested. WHAT IT OPENS UP. The seven-row identifiability table is a blueprint for a tabletop experiment on any small quantum platform; running it on hardware would move this from simulation to laboratory fact. On the theory side the paper leaves sharply posed open problems: the exact global constants when the two parts differ in size, the number-theoretic structure of long-time sampling (the failure times form a small-divisor hierarchy), and the extension from two parts to many. METHODS NOTE, BECAUSE IT MATTERS FOR TRUST. Every quantitative claim was pre-registered in the companion scripts before its run. The full ledger, including predictions that failed and one published-in-note constant that our own later theory overturned, is an appendix of the paper. All code, data, and working notes are in the deposit, seeded for exact reproduction. WHO AND HOW. A human-AI collaboration: research direction and standards of evidence by Ryan Cardwell (Crystalline Labs); design, code, derivations, and drafting by Claude (Anthropic), including autonomous sessions under the program's pre-registration rules, with adversarial reviews by other AI models incorporated and credited.
We reexamine a non-Gaussian quantum error-correction code designed to protect optical coherent-state qubits against errors due to an amplitude-damping channel. We improve on a previous result [R. Wickert, N. K. Bernardes, and P. van Loock, Phys. Rev. A 81, 062344 (2010)] by providing a tighter upper bound on the performance attained when considering realistic assumptions, which constrain the operation of the gates employed in the scheme. The quantitative characterization is performed through measures of fidelity and concurrence, the latter obtained by employing the code as an entanglement distillation protocol. We find that, when running the code in fully deterministic error-correction mode, direct transmission can only be beaten for certain combinations of channel and input state parameters. In contrast, in error-detection mode, the usage of higher repetition encodings remains beneficial throughout, however, at the expense of diminishing success probabilities.
# 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
The algorithms discussed in Chapter 21 rely on having isolated systems to store information. In practical applications this is not possible, and the environment interacts with the systems causing decoherence. Suppose the data is contained in the state |x〉, and the environment is described by |E〉. The initial state of the entire system is described by the tensor product of the states |X〉⊗|E〉, which evolves according to some unitary operation U. The state |x〉 evolves according to the unitary operation U x which describes the algorithm. In classical error correction codes, all that needs to be corrected are bit flips (see Chapter 10). In the quantum case errors such as bit flips, phase changes and rotations complicate the error correction techniques. Since arbitrary errors in an encoding of information cannot be corrected, only certain types of errors are assumed to occur (this was also the case in classical error correction, where an upper bound in the number of bits that could be flipped in a transmission was assumed). The types of errors depend on the implementation. For example, suppose the types of errors (which we assume are distinguishable due to an encoding) are described by the unitary basis E 1,...E n , so that all errors are a linear combination [138] E = al.E 1 + ... + a n E n ,...E † E = I.