A cheap way to simulate high-frequency waves, such as seismic, optical or quantum waves, is to skip the fine grid. Instead, the wave is written as a sum of many small Gaussian "wave packets," each described by a handful of numbers: where it sits, which direction it moves, its phase, and its amplitude. This is the frozen Gaussian approximation (FGA). It becomes more accurate as the frequency rises, because each packet's parameters follow a simple set of ordinary differential equations. The bottleneck then moves from arithmetic to memory. Inverse problems like seismic tomography need millions of packets per source, stored across time so that gradients can be computed. Storing each packet's roughly eight numbers in lower precision, the way large language models (LLMs) are now stored in 2–4 bits, is the obvious remedy.
This note argues that the obvious remedy fails in an interesting way, and that it can be fixed. The phase of a packet is its stored action divided by a tiny wavelength parameter $\epsilon$, so rounding errors in position and phase are multiplied by $1/\epsilon$. Naive half precision therefore falls off a cliff at exactly the frequencies where FGA is supposed to shine. We claim this cliff is predictable in closed form. We further claim that one exact reparametrization, which moves the phase lost to rounding a packet's center into its stored phase and keeps that phase only modulo $2\pi$, halves the growth of required bits with frequency. That makes 16-bit and sub-16-bit FGA viable where naive casting breaks. The quantization literature for neural networks supplies the tools we reuse: sensitivity-weighted rounding, lattice codebooks and error-compensation ideas. The wave-packet setting supplies something that literature lacks, namely an accuracy cliff that can be derived rather than only observed.
Core Claim
Each discretized FGA packet has the form
$$G_j(x)=a_j\exp\!\Big(\tfrac{i}{\epsilon}\big[S_j+P_j\cdot(x-Q_j)\big]-\tfrac{1}{2\epsilon}|x-Q_j|^2\Big),$$
with symbols defined as follows. $Q_j$ is the packet's center and $P_j$ its momentum, both $d$-dimensional. $S_j$ is its accumulated action and $a_j$ its complex amplitude. $\epsilon$ is the wavelength scale. The packet has width about $\sqrt\epsilon$, and its parameters evolve by the Hamiltonian ODEs analyzed in Convergence of frozen Gaussian approximation for high‐frequency wave propagation.
Perturb each stored parameter by its rounding error, written $\delta Q$, $\delta P$, $\delta S$ and $\delta a$. A first-order expansion over the packet's support $|x-Q|\lesssim\sqrt\epsilon$ gives a relative $L^2$ error of roughly
$$\frac{\|\delta u\|}{\|u\|}\;\approx\;\frac{|P|\,\delta Q}{\epsilon}+\frac{\delta S}{\epsilon}+\frac{\delta Q+\delta P}{\sqrt\epsilon}+\frac{|\delta a|}{|a|}.$$
This holds when rounding is unbiased and independent across packets, so that errors add in quadrature and the relative error tracks the root-mean-square per-packet error. The first two terms are the dangerous ones.
They can be removed exactly. Round the center to $\tilde Q_j$ and store the gauged action
$$\tilde S_j=S_j+P_j\cdot(\tilde Q_j-Q_j).$$
The oscillatory part of $G_j$ is unchanged by this substitution. Only the Gaussian envelope moves, which costs $\delta Q/\sqrt\epsilon$. The phase $\tilde S_j/\epsilon$ is then stored as a fixed-point number on the circle, so its resolution does not depend on how large the action has grown along the trajectory.
The consequence is a bit-allocation law. To make quantization error no larger than the method's own asymptotic error $O(\epsilon^K)$ for a $K$-th order propagator, naive storage needs about $(K+1)\log_2(1/\epsilon)$ bits for each center coordinate, plus the log of the domain-to-wavelength ratio for the action. Gauged storage needs $(K+\tfrac12)\log_2(1/\epsilon)$ for centers and momenta and $K\log_2(1/\epsilon)$ for phase and amplitude.
A concrete case: at $\epsilon=10^{-3}$, FP16's 11-bit mantissa gives a naive center-induced phase error near half a radian, which is broken. The gauged error is a few percent, which is comparable to first-order FGA error. The main claim is therefore that half-precision FGA fails without the gauge and works with it, and that the crossover points follow the predicted exponents.
Research Program
The first component is analytical. It turns the expansion above into a bound that composes with Theorem 4.1 of Convergence of frozen Gaussian approximation for high‐frequency wave propagation, which proves $L^2$ error $C_{T,K}M\epsilon^K$ for linear strictly hyperbolic systems, and with Liu's manifold-superposition rate $O(k^{1-N/2-(d-m)/4})$ from General superpositions of Gaussian beams and propagation errors. We play both papers in the same role: they supply the "asymptotic error floor" that quantization error should not exceed.
The analysis has to cover three further effects. The first is how quantization errors injected at a stored time are carried forward by the Jacobian of the Hamiltonian flow when packets are re-propagated from checkpoints. That Jacobian is bounded on $[0,T]$ and symplectic, so we expect growth like the square root of the number of re-quantizations rather than exponential "snowballing." The second is when rounding stops behaving randomly and becomes coherent. This happens when many packets share grid cells, and we plan to test stochastic rounding as the cure. The third is whether the $L^2$ quantization error stays uniform through caustics, the focusing points where ray amplitudes diverge. Error estimates for Gaussian beam superpositions proves such uniformity for the unquantized method. Our per-packet error model predicts the same holds after quantization, while the $L^\infty$ non-uniformity Liu flags should persist.
The second component is the codec. It has three layers. The gauge transform comes first. Next, each variable is scaled by its sensitivity weight from the error expansion: $1/\sqrt\epsilon$ for $Q$ and $P$ after gauging, $1$ for phase, and $1/|a|$ for amplitude. This makes rounding error isotropic in the metric that governs wavefield error. The idea mirrors how QuIP: 2-Bit Quantization of Large Language Models With Guarantees weights rounding by a Hessian proxy for layer loss. The difference is that our metric is derived from the packet formula, not estimated from calibration data.
Finally, the whitened parameters are vector-quantized. In three dimensions a packet has exactly eight real parameters once the amplitude's phase is folded into $\tilde S$: three for $Q$, three for $P$, one for phase and one for log-amplitude. That matches the eight-dimensional $E_8$ lattice codebook used by QuIP#: Even Better LLM Quantization with Hadamard Incoherence and Lattice Codebooks. We reuse that codebook directly. We drop its randomized Hadamard rotation, because the sensitivity whitening plays the role of making errors isotropic. Whether the rotation still helps is tested as an ablation.
The third component is an application: the forward-wavefield storage behind adjoint gradients in FGA tomography. Seismic Tomography with Random Batch Gradient Reconstruction builds sensitivity kernels from FGA forward fields with randomized batching. A frozen Gaussian approximation-based multi-level particle swarm optimization for seismic inversion runs many FGA forward solves inside a population search. In both, packet memory and memory bandwidth limit problem size, so quantized packet storage directly raises the number of sources or particles per GPU.
One analogy from the language-model side is worth stating, though it stays secondary. CommVQ: Commutative Vector Quantization for KV Cache Compression designs codebooks that commute with rotary position phases. Our gauge exploits a similar phase symmetry, but ours is an exact invariance of the packet rather than a codebook constraint. We do not claim anything about LLMs here.
Baselines
The reference point is double-precision FGA with the same packet sampling. Every error is measured against both this reference and a fine-grid solver, so quantization error can be separated from asymptotic error.
The naive "do nothing" baselines are direct casts of all packet parameters to FP32, FP16 and BF16. These are what practitioners would try first. The theory predicts that the FP16 and BF16 casts break once the frequency exceeds a threshold set by mantissa length. Beating them means holding relative $L^2$ error within a factor of two of the FP64 asymptotic error at a frequency where the casts exceed it by an order of magnitude.
The strongest competitor is a tuned per-variable mixed-precision fixed-point scheme. Its bit widths per parameter come from a grid search against the FP64 reference at each $\epsilon$. This is the approach an engineer would reach for without any theory, and it is the baseline most likely to match our accuracy. It gets the same packets, the same total bit budget and a search budget of equal wall-clock. If it matches the gauged codec at equal bits, then our contribution reduces to predicting its result. That would still be useful, but it would be a weaker claim. Beating it requires the gauge's advantage: fewer bits for the same error, growing like $\tfrac12\log_2(1/\epsilon)$ bits per center coordinate plus the phase-range savings.
We also run two ports of LLM quantization methods under the same bit budget. The first is a dense-and-sparse split in the style of KVQuant: Towards 10 Million Context Length LLM Inference with KV Cache Quantization, which keeps the top one percent of outliers in full precision. Here the outliers are the largest-amplitude packets. The second is QuIP#-style randomized Hadamard rotation plus $E_8$ quantization applied to the raw eight parameters, without gauge or sensitivity weighting.
No reported result found on Lacuna for quantized or reduced-precision FGA on any benchmark. The only reported numbers for these ported methods are in-domain, for example QuIP#'s WikiText-2 perplexity of 4.16 on Llama 2 70B at 2 bits. They show the tools work on neural weights and say nothing about wave packets. All baselines here will therefore be run by us.
The key ablations isolate the two ingredients. Gauge without sensitivity weighting tests the phase-absorption identity alone. Sensitivity weighting without the gauge tests whether rescaling can substitute for it; the theory says it cannot, because the $|P|\delta Q/\epsilon$ term stays. Scalar versus $E_8$ quantization on the whitened parameters measures whether lattice packing adds anything beyond correct bit allocation.
Why not just…?
Why not just keep FP32 and accept the memory cost? For small two-dimensional problems this is the right answer, and we will say so. The expansion predicts that FP32's 24-bit mantissa stays safe down to about $\epsilon\sim10^{-4}$ even without the gauge. The case for the proposal rests on showing that packet storage is actually the binding constraint in three-dimensional adjoint tomography of the kind in Seismic Tomography with Random Batch Gradient Reconstruction. Our first measurement is peak memory and bandwidth profiles of the FP64 and FP32 pipelines on that task. If packets are not the bottleneck there, we will reframe the work as throughput-oriented, aimed at many forward solves in the particle-swarm setting, rather than claim a memory win.
Why not just recompute trajectories instead of storing them? The trajectories are cheap ODEs, so checkpointing and recomputing is a serious threat. We compare at matched memory: quantized storage of all time slices against sparse FP64 checkpoints with recomputation, measuring wall-clock per gradient and gradient cosine similarity. Recomputation will likely win when ODE steps are cheap relative to memory traffic, and quantization when the Hamiltonian is expensive, as in heterogeneous media. The experiment maps where that boundary sits instead of assuming it.
Why not just search bit widths empirically? A per-variable sweep will find a good allocation at any single $\epsilon$, which is why it is our strongest baseline. What it cannot find is the gauge, because no bit allocation removes the $1/\epsilon$ amplification of center rounding. A sweep also has to be rerun for every frequency, whereas the law predicts how the widths scale. The decisive comparison is the scaling of required bits with $\epsilon$ for sweep-without-gauge versus sweep-with-gauge.
Proposed Experiments
The test problems come from the cited FGA theory, since the file's language-model benchmarks (WikiText-2, GSM8K, LongBench) do not measure wavefields. The first is the linear acoustic wave equation and a strictly hyperbolic system from Convergence of frozen Gaussian approximation for high‐frequency wave propagation. This includes its Example 4.2, the low-frequency data on which FGA fails without a smooth cutoff; there we check that quantization does not interact with the cutoff. The second is Liu's three-dimensional superposition example with $m=2$ and $N=1$, where the energy-norm error decays as $k^{-3/4}$ (General superpositions of Gaussian beams and propagation errors). The third is the periodic-media setting of Frozen Gaussian approximation for high frequency wave propagation in periodic media, whose $O(\epsilon)$ bound gives a floor and whose Bloch-wave phases stress the gauge. The last is FGA gradient reconstruction for tomography, scored by gradient cosine similarity to FP64 and by final inversion misfit.
The decisive check uses Liu's example at fixed bit width $b$ while sweeping frequency $k=1/\epsilon$. The error model predicts total error follows the $k^{-3/4}$ decay until quantization error overtakes it. For naive storage, quantization error grows as $2^{-b}k$, so the crossover sits at $k^*\approx2^{4b/7}$. For gauged storage it grows as $2^{-b}k^{1/2}$, so $k^*\approx2^{4b/5}$.
The theory succeeds if measured crossovers across several $b$ follow these two exponents within fitting uncertainty. It fails if the gauged crossover scales like the naive one. That would mean envelope errors or coherent rounding dominate, and we would report it. Secondary checks cover three questions. Is quantized $L^2$ error flat across caustic crossing times? Does stochastic rounding remove any bias from packets sharing grid cells? Does $E_8$ quantization of the whitened eight-vector buy a measurable fraction of a bit over scalar rounding, or is correct allocation the whole story?
References
- Convergence of frozen Gaussian approximation for high‐frequency wave propagation
- General superpositions of Gaussian beams and propagation errors
- Error estimates for Gaussian beam superpositions
- QuIP: 2-Bit Quantization of Large Language Models With Guarantees
- QuIP$\#$: Even Better LLM Quantization with Hadamard Incoherence and Lattice Codebooks
- Seismic Tomography with Random Batch Gradient Reconstruction
- A frozen Gaussian approximation-based multi-level particle swarm optimization for seismic inversion
- CommVQ: Commutative Vector Quantization for KV Cache Compression
- KVQuant: Towards 10 Million Context Length LLM Inference with KV Cache Quantization
- Frozen Gaussian approximation for high frequency wave propagation in periodic media