Shot Noise as Free Dithering: When Low-Precision Phase Updates Stall on Noisy Quantum Hardware

Many learning problems in physics come down to adjusting phases, meaning angles that control how two or more waves add together or cancel. In a parameterized quantum circuit, which is a quantum program whose gate rotation angles are tuned by a classical optimizer, every trainable parameter is such an angle. The classical model particle physicists use to describe how a heavy meson decays through short-lived intermediate particles is built the same way: a sum of interfering amplitudes, each with a fitted magnitude and a "strong phase". In both settings, the gradient with respect to a phase is proportional to how coherent the interference is. Hardware noise lowers that coherence on a quantum processor. Broad, overlapping intermediate states lower it in a decay. We propose to study what happens when these already-small phase gradients have to be applied through finite-precision arithmetic. This is the situation in closed training loops that run on fixed-point control electronics beside the quantum processor, and in executed angles that the hardware can only set to a grid of values.

The central prediction is counterintuitive. The random error in each gradient estimate, which comes from averaging a finite number of measurement repetitions ("shots"), plays the role of stochastic rounding for free. Low-precision updates therefore stay unbiased until the experimenter takes enough shots to remove that noise. Past a computable shot count, spending more shots can make training stall. If this holds, some of the training plateaus seen on noisy hardware are caused by the arithmetic rather than by the noise-induced flattening of the landscape. It also gives a simple rule for choosing shots and bit width together.

Core Claim

Let $\Delta$ be the spacing of the representable parameter grid; for a $b$-bit fixed-point angle, $\Delta = 2\pi/2^b$. Let $u = \eta\,\mathbb{E}[\hat g]$ be the intended update, where $\eta$ is the learning rate and $\hat g$ is the shot-estimated gradient. Let $\sigma = \eta\,\sigma_g$ be the update's standard deviation, where $\sigma_g \propto 1/\sqrt{N}$ for $N$ shots, from the central limit theorem applied to the parameter-shift estimator. Standard dithering arguments say that round-to-nearest applied to $u$ plus Gaussian noise is nearly unbiased once $\sigma \gtrsim \Delta/2$. We therefore predict that deterministic rounding stalls exactly in the region

$$|u| < \Delta/2 \quad\text{and}\quad \eta\,\sigma_g(N) < \Delta/2 .$$

Under local Pauli noise, $|u|$ shrinks like $2^{-\alpha L}$ in the circuit depth $L$, as proven in Noise-Induced Barren Plateaus in Variational Quantum Algorithms. Deeper or noisier circuits therefore push $u$ under the grid step while shot noise stays constant. This defines a critical shot count $N^\*$, the point where $\eta\,\sigma_g(N^\*) = \Delta/2$. Below $N^\*$, low precision is harmless. Above it, progress should stop unless rounding is made stochastic or rounding error is fed back into the optimizer.

A second claim concerns the number format. Floating-point formats spend their resolution near zero. For an angle that wraps around a circle, that allocation is wasteful: bfloat16 has 8 significant bits, so its step near $\pi$ is roughly $0.025$ rad while its step near $0.01$ rad is far finer. We hypothesize that uniform fixed-point storage modulo $2\pi$ strictly dominates floating point at equal bit width for phase parameters.

Research Program

The work connects three literatures, each playing a different role.

The precision literature supplies the mechanism. On the theoretical limit of gradient descent for Simple Recurrent Neural Networks with finite precision proves that "dead zones" exist around good parameters, where $\text{round}(w-\eta g)=w$. Towards Cheaper Inference in Deep Networks with Lower Bit-Width Accumulators documents stuck states when accumulators are cut to 12 bits. The fixes also come from this literature. ECO folds the rounding residual into the momentum buffer but assumes stochastic rounding. M+Adam shows that additive updates fail at large weight magnitudes because small updates are lost relative to the weight. None of these papers considers a setting where the gradient noise is set by a physical measurement budget, and that is the variable we manipulate.

The quantum hardware literature supplies the regime and motivates the question. Noise-Induced Barren Plateaus treats shot noise purely as a floor that hides the gradient. We treat shot noise as a resource that keeps rounding unbiased, which is a different view of the same quantity. QuantumNAT and RoQNN quantize measurement outputs to suppress noise but keep the parameter updates in high precision. We quantize the opposite side of the loop.

Intermediate resonance decomposition supplies a benchmark in which the true phases are known and coherence can be adjusted directly. The isobar model, as used in the Dalitz-plot analysis of $D^\pm \to [K^+K^-\pi^\pm$](/work/search-for-mml-math-xmlns-mml-http-www-gs27), writes a decay amplitude as a coherent sum $\sum_i a_i e^{i\phi_i}\mathcal{A}_i$ over resonances such as $\phi(1020)$, $K^*(892)^0$ and the broad $\kappa(800)$. The quantum-correlated measurements in Determination of the $D^0 \to K^-\pi^+\pi^0$ and $D^0\to K^-\pi^+\pi^+\pi^-$ coherence factors show that coherence ranges from high ($R\approx 0.84$ for $K\pi\pi^0$) to much lower in the four-body channel. That range maps directly onto the damping that hardware noise imposes.

We will build three things.

The first is a classical isobar fitter with phases stored in $b$-bit fixed-point or float formats. It is trained on synthetic Dalitz events generated from a known isobar model. Varying how much the resonances overlap sweeps the coherence without any quantum hardware, and so tests the stall-region prediction in a purely classical setting.

The second is a small "isobar circuit". Each resonance amplitude is carried on a separate basis-state path, strong phases are implemented as rotation angles, and interference at readout reproduces the Dalitz density. The circuit is trained in TorchQuantum under calibrated IBM noise models and on available IBM devices, with the optimizer and its state held in emulated fixed-point registers.

The third is the analysis: measured stall boundaries in the space of shots, bit width and depth, compared against the predicted $N^\*$. To test generality beyond the physics task, the same analysis is repeated on the QuantumNAT MNIST-4 and Fashion-MNIST-4 circuits and on the QAOA MaxCut setting of the barren-plateau paper.

Baselines

The naive reference point is round-to-nearest $b$-bit parameters with a fixed shot budget and no correction. This is what a controller-resident loop does by default, and it is the configuration our theory says should stall above $N^\*$.

The upper bound is an FP32 optimizer with FP32 master parameters, where only the executed angle is quantized to hardware resolution. This is what nearly everyone does today, because a circuit has only tens of parameters. On QuantumNAT's own benchmarks, the strongest reported full-stack reference is the noise-aware training result of 80% accuracy on 4-class problems on real hardware, reported in QuantumNAT. On MNIST-4 without mitigation, the gap between noise-free simulation and IBMQ-Yorktown exceeds 60%. For the isobar-circuit task, no reported result was found on Lacuna, so the FP32 run serves as the internal ceiling.

The strongest low-precision competitor is ECO-style error feedback combined with explicit hardware stochastic rounding. It is run at the same bit width, the same shot budget, the same number of circuit executions, and an equal tuning budget over learning rate and momentum. The comparison uses the same data splits and the same noise-model snapshots.

Two ablations isolate the proposed ingredient. The first adjusts shots per step so that $\eta\sigma_g \approx \Delta/2$, with no pseudo-random rounding at all. The second holds $N$ fixed and changes only the number format, fixed-point versus float at the same bit width.

The proposal counts as winning if two things hold. First, its accuracy or phase-recovery error comes within statistical error of FP32 master weights at 8 bits or fewer. Second, it matches or beats ECO with stochastic rounding while using no random-number generator. It also needs the naive baseline to degrade measurably as $N$ grows past $N^\*$.

Why not just…?

Why not just keep FP32 master weights, since circuits have few parameters? This is the most serious objection. For a laptop driving a cloud processor it is correct, and the proposal does not claim memory savings there. The argument for low precision rests on loops that close on the control hardware itself, where angles live in fixed-point registers, and on the fact that executed angles are always quantized. The diagnostic result still matters even if nobody adopts low-precision training: it tells experimenters whether an observed plateau comes from arithmetic or from noise. If FP32 master weights with quantized execution show no stall anywhere in our sweep, the practical claim narrows to the controller-resident case, and we will say so.

Why not just use stochastic rounding, as ECO assumes? Stochastic rounding works, but ECO itself notes that hardware support is uneven and that generating the random numbers costs compute and latency. Our claim is that the measurement already supplies the needed randomness. The head-to-head experiment described under Baselines settles this directly: if shot-matched round-to-nearest equals stochastic rounding, the random-number generator is unnecessary.

Why not just take more shots or apply error mitigation? The barren-plateau analysis already shows that inference-time mitigation does not restore gradients during training. Our theory adds that more shots can actively hurt under deterministic rounding. The shot sweep tests this directly by looking for non-monotone accuracy in $N$ at fixed $b$.

Why not just use QuantumNAT's noise-aware training? It targets output noise and is complementary. We run it with and without our parameter-side changes to check that the gains add up rather than overlap.

Decisive Experiments

The first check is the phase diagram. We sweep $b \in \{6,8,10,12,16\}$, $N$ from $10^2$ to $10^5$, and depth or noise strength. The measured stall boundary, defined as the point where loss improvement per step falls below a fixed threshold, is fitted against the predicted $N^\*(\eta,b)$. Agreement within a factor of two across the classical isobar fitter, the isobar circuit and MNIST-4 would confirm the mechanism.

The second check is non-monotonicity. Naive round-to-nearest must lose accuracy as shots increase beyond $N^\*$, while stochastic rounding and FP32 must not.

The third check is the number format. Fixed-point angles should beat floating-point angles at equal bit width, with the largest gap for parameters that drift toward $\pm\pi$.

The fourth check is the coherence mapping. In the classical isobar fitter, lowering the effective coherence by increasing resonance overlap should move the stall boundary exactly as lowering the noise-damping factor does in the circuit. This would confirm that one quantity, the coherence of the interference, controls both.

Hardware runs on IBM devices reproduce the first two checks at small width, around $n \le 6$, which stays below the $n\approx 9$ shot floor reported for ibmq_montreal. Staying below that width keeps landscape flattening from confounding the arithmetic effect.

References

  1. Noise-induced barren plateaus in variational quantum algorithms
  2. On the theoretical limit of gradient descent for Simple Recurrent Neural Networks with finite precision
  3. Towards Cheaper Inference in Deep Networks with Lower Bit-Width Accumulators
  4. ECO: Quantized Training without Full-Precision Master Weights
  5. M+Adam: Low-Precision Training via Additive–Multiplicative Optimization
  6. QuantumNAT: Quantum Noise-Aware Training with Noise Injection, Quantization and Normalization
  7. Search for<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML" display="inline"><mml:mi>C</mml:mi><mml:mi>P</mml:mi></mml:math>violation in the Dalitz-plot analysis of<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML" display="inline"><mml:msup><mml:mi>D</mml:mi><mml:mo>±</mml:mo></mml:msup><mml:mo>→</mml:mo><mml:msup><mml:mi>K</mml:mi><mml:mo>+</mml:mo></mml:msup><mml:msup><mml:mi>K</mml:mi><mml:mo>−</mml:mo></mml:msup><mml:msup><mml:mi>π</mml:mi><mml:mo>±</mml:mo></mml:msup></mml:math>
  8. Determination of the<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML" display="inline"><mml:msup><mml:mi>D</mml:mi><mml:mn>0</mml:mn></mml:msup><mml:mo>→</mml:mo><mml:msup><mml:mi>K</mml:mi><mml:mo>−</mml:mo></mml:msup><mml:msup><mml:mi>π</mml:mi><mml:mo>+</mml:mo></mml:msup><mml:msup><mml:mi>π</mml:mi><mml:mn>0</mml:mn></mml:msup></mml:math>and<mml:math xmlns:mml="http://www.w3.org/1998/Math/MathML" display="inline"><mml:msup><mml:mi>D</mml:mi><mml:mn>0</mml:mn></mml:msup><mml:mo>→</mml:mo><mml:msup><mml:mi>K</mml:mi><mml:mo>−</mml:mo></mml:msup><mml:msup><mml:mi>π</mml:mi><mml:mo>+</mml:mo></mml:msup><mml:msup><mml:mi>π</mml:mi><mml:mo>+</mml:mo></mml:msup><mml:msup><mml:mi>π</mml:mi><mml:mo>−</mml:mo></mml:msup></mml:math>coherence factors and average strong-phase differences using quantum-correlated measurements