WorksPhysics and Astronomy
Accelerating auxiliary-field quantum Monte Carlo with mixed-precision random propagators
Abstract
We develop an algorithm to propagate auxiliary-field quantum Monte Carlo (AFQMC) wavefunctions in mixed precision. We target NVIDIA Tensor Cores using the TensorFloat-32 (TF32) format. We approximate each full-precision array by a TF32 leading term and a TF32 residual, and each full-precision matrix product by three TF32 products accumulated in full precision. Benchmarks on hydrogen chains show that mixed-precision propagation is consistently faster than double-precision GPU propagation, with an increasing advantage as the system size grows. The resulting local-energy deviations remain small over the propagation windows considered here. These results identify the stochastic two-body propagator as a particularly effective target for reduced precision, while our method allows higher precision to be retained for accuracy-sensitive operations. Hence, our algorithm provides a practical way to speed up AFQMC calculations and demonstrates where reduced precision can be applied without adverse effects on the method's accuracy.
Introduction
The electronic structure problem—accurately computing the energy and other ground-state properties of correlated electronic systems—is a critical part of modern chemistry and materials science research[1, 2]. The scale of its impact is difficult to overstate; as of 2025, three of the ten most cited papers of all time[3] describe electronic structure theory methods[4, 5, 6]. All three apply density functional theory (DFT), known as the “workhorse of quantum chemistry"[7], but methods beyond DFT are required to describe strongly correlated systems accurately enough for cases like (nearly) degenerate spin configurations in transition metals[8] and Mott insulators[9]. Their usefulness is due in large part to the robust ecosystem of electronic structure software, especially when coupled with high-performance computing (HPC) hardware[10]. Looking forward, it is crucial that electronic structure codes and algorithms are tailored to the fastest HPC hardware available. This hardware is increasingly shaped by the unique requirements of machine learning (ML) methods. On one hand, an increasing fraction of HPC time is spent on ML computation[11]; on the other, many cutting-edge HPC systems are now purpose-built for ML[12]. ML models are often run in reduced-precision arithmetic[13] on graphics processing units (GPUs) or specialized hardware accelerators with exceptional performance in low precision[14]. It is therefore important to update electronic structure algorithms to use mixed-precision arithmetic to take full advantage of modern HPC and ML hardware[15].
Auxiliary-field quantum Monte Carlo (AFQMC) is a promising method to accurately calculate electronic structure calculations on correlated systems[16, 17], and is ideally suited for the heterogeneous hardware architectures likely to dominate the HPC ecosystem in the near- and medium-term future. AFQMC transforms the two-body interaction term of the Hamiltonian into an ensemble of one-body potentials weighted by probabilistic auxiliary fields. The auxiliary fields are sampled stochastically, and each realization is used to propagate an independent random walker through imaginary time. AFQMC can recover energetics with accuracy approaching that of “gold-standard” coupled-cluster theory, with improved asymptotic efficiency[17, 18]. However, AFQMC still suffers significant bottlenecks in practice; for systems of moderate size, propagating random walkers through imaginary time dominates the computational cost. We address this bottleneck by applying the auxiliary-field propagators on GPUs in mixed precision.
AFQMC is embarrassingly parallel[18, 19] and naturally suited for execution on GPUs[20]; each random walker can be allocated to a separate processor if necessary. In addition, replacing the two-body interaction by fluctuating auxiliary fields induces statistical uncertainty, so reduced precision may have a smaller effect on propagation under the auxiliary fields than on deterministic operations. Indeed, the electron–electron interaction is typically approximated by a Cholesky decomposition[21, 22] even before it is recast into a sum of fluctuating fields, mitigating the impact of reduced precision for the two-body propagation further. We note that Shee et al. [20] have already investigated the use of reduced (single) precision propagation, obtaining a substantial speedup, with errors of roughly . Here, we approximate full-precision operations by several low-precision operations to exploit the higher throughput of Tensor Cores while recovering much of the precision lost in direct TF32 propagation.
We introduce the AFQMC algorithm and present our mixed-precision propagation scheme in Section II; demonstrate its accuracy–speed tradeoff in Section III; and discuss future directions in Section IV.
Methodology
Auxiliary-field quantum Monte Carlo
We here describe (phaseless) auxiliary-field quantum Monte Carlo, or (ph-)AFQMC, briefly. For a more detailed discussion, we refer the reader to previous reviews[16, 23]. AFQMC projects an initial trial state through imaginary time , obtaining the true ground state
as long as the trial and ground states are not orthogonal. It exploits the Hubbard–Stratonovich transformation[24, 25] to transform the electron–electron interaction into many fluctuating one-body potentials, thus changing the many-body problem into a sum of probabilistic one-body auxiliary fields, which admits a mean-field imaginary time evolution. The total AFQMC wavefunction is a weighted sum of walker wavefunctions that evolve under independent realizations of the auxiliary fields,
In this work, we take , which doubles as the initial state of each walker, as a single Slater determinant. In this setting, Thouless’ theorem[26] guarantees that the walkers remain single Slater determinants throughout propagation, allowing use of efficient numerical routines very similar to those for Hartree–Fock or Kohn–Sham density functional theory. The many-body correlations are recovered in expectation by the ensemble average in .
The AFQMC Hamiltonian
The electronic structure Hamiltonian in second quantization is
where is the one-body term, is the electron–electron interaction, and is a constant energy shift. We take the Born–Oppenheimer approximation, so includes for example the electrostatic repulsion between nuclei.
In order to apply the Hubbard–Stratonovich transformation and use the machinery of AFQMC, we recast into a sum of squared one-body terms,
where . Since the Coulomb operator is positive semidefinite, this can be accomplished by the (modified) Cholesky decomposition[27, 28, 29, 30, 31]:
A low-rank approximation is then introduced, neglecting the eigenvalues less than a cutoff . Unless otherwise indicated, we set . The number of Cholesky matrices required to represent to a fixed accuracy is linear in the number of basis functions[21, 22], reducing the total storage required for the electron repulsion integrals from to . It can be further reduced to by leveraging tensor hypercontraction[32, 33, 34] or mixed sparsity–double factorization methods[35]. Using the Cholesky decomposition, the Hamiltonian can be expressed in the so-called MC form, with a one-body operator and a sum of squared one-body operators,
where
is the shifted kinetic operator.
Discretization of imaginary time propagation
In order to implement numerically, we fix a maximum imaginary time and discretize the propagation into steps of size ():
Performing a symmetric second-order Lie–Suzuki–Trotter decomposition[36, 37] on , we have
incurring error cubic in .
Propagation and Monte Carlo sampling
Once is cast into the Monte Carlo form in Eq. (6), its corresponding propagator can be decomposed into an integral over one-body propagators by the Hubbard–Stratonovich (HS) transformation[24, 25] as
where each is an auxiliary field, here taking the form of a standard normal random variable (so that the probability of taking the value is ). Performing this transformation on , we obtain one auxiliary field per Cholesky matrix; the operator that propagates the wavefunction by is
By placing the sum in one exponential, we incur an increase in the Trotter error from cubic to quadratic in .
Now expressed as a high-dimensional stochastic integral, imaginary-time propagation is amenable to Monte Carlo sampling. We sample one independent realization of each at each time step on an ensemble of walker wavefunctions . Each walker starts in the trial state , but evolves differently from the others due to the randomness in . Averaging over the walker ensemble recovers the many-body correlation: that is, we replace many-body dynamics by a fluctuating ensemble of one-body propagations. Observable estimates have a standard deviation proportional to the inverse square root of the number of random walkers[23].
In order to improve the efficiency of sampling with respect to a given trial wavefunction , a kind of importance sampling is introduced[38]. Importance sampling biases the auxiliary fields depending on the expected value of with respect to ,
where the so-called dynamic force
The latter term, , is a normalization factor. We apply this bias in our mixed-precision propagation, but to save space we write for the biased realizations.
The phaseless constraint
In practice, AFQMC incurs a phase problem, akin to but even more severe than the sign problem[39, 40] of other QMC methods. The complex propagators cause the walker wavefunctions to accumulate fluctuating phases, with variances increasing exponentially with the number of steps . To remedy this, we apply the phaseless constraint of Zhang and Krakauer[41], which uses two strategies to mitigate the phase problem. First, the importance-sampling transformation described above shifts the auxiliary fields using the trial wavefunction. Second, the complex weights of each walker wavefunction are projected to the positive real axis at each step. Together, the phaseless constraint controls the phase problem to , but introduces a fundamental constraint on the accuracy. Unless is the many-body ground state, phaseless AFQMC is no longer exact, even in the limit . Furthermore, because of the bias induced by the trial wavefunction, the energy of ph-AFQMC is no longer variational[41]. Extensive research efforts have focused on developing improved trial wavefunctions for AFQMC[16, 20, 42, 43, 44, 45, 46, 47, 48]; in this work, we take to be a restricted Hartree–Fock wavefunction.
Measuring the energy
One-body operators that commute with the Hamiltonian (including, of course, the one-particle energy operator ) are measured by the mixed estimator
where is known as a (per-walker) local observable[16]. This estimator is exact when commutes with the Hamiltonian; otherwise, it generally retains a bias from the trial state. Two-body operators like require the use of the generalized Wick theorem[49, 50]: since and each walker wavefunction are Slater determinants, the per-walker equal-time two-body Green’s function
decomposes in terms of the one-body Green’s functions
as
can be computed efficiently in terms of the Slater determinant matrices of and .
Thus the local two-body energy of walker is
and the mixed estimator is
The first term on the right-hand side of (18) corresponds to the Hartree energy and is easy to compute. The second term corresponds to exchange. Requiring operations asymptotically,[23, 35, 51] it becomes the bottleneck of AFQMC. However, the energy does not need to be computed at every propagation step. For systems of moderate size, the propagation (and in particular the memory overhead for storing the Cholesky matrices ) are the practical bottlenecks.
Reduced-precision arithmetic
Typical scientific computation workflows store real numbers, or the real and imaginary parts of complex numbers, as 64-bit binary floating-point numbers (FP64). According to the IEEE 754 standard[52], a floating-point number is expressed as
It is stored on a computer in binary as . The first bit encodes the sign; an -bit exponent is encoded in , noting that the offset in the exponent allows both positive and negative exponents up to to be represented; and the significand is encoded in bits , where biasing the exponent yields one additional significand bit implicitly. FP64 is defined by setting and . It represents numbers up to with a relative precision (the 64-bit machine epsilon) of .
FP64 has enjoyed decades of algorithmic development since its standardization in 1985[53]. It is a battle-tested data structure for numerical and scientific computing, especially on central processing units (CPUs). Recent years have seen a boom in graphics processing unit (GPU) computing, especially ML applications, that favor reduced-precision floating-point numbers. For example, IEEE 754 also defines the 32-bit FP32, which has , ; FP32 can represent numbers up to about , and . More recently, NVIDIA introduced the TensorFloat-32 (TF32) format for its Ampere series GPUs[54], with , . TF32 represents the same exponent range as FP32, but with precision further reduced to .
A naïve estimate, roughly correct for the NVIDIA A100 GPU, is that double-precision (FP64) floating-point operations (FLOPs) take twice as long as single-precision (FP32) ones. The A100’s architecture, however, is designed around the TF32 format, executing operations in TF32 eight times faster, at floating-point operations per second ( TFLOP s), than in FP32 ( TFLOP s), and sixteen times faster than in FP64 ( TFLOP s)[55].
Mixed-precision arithmetic, in which some operations are computed at less than FP64 precision, has been used with success in quantum chemical calculations, from density matrix purification for semiempirical[56] and density functional[57] calculations to many-body methods like Møller–Plesset and coupled-cluster theory[58, 59] and the density matrix renormalization group[60]. Accelerating AFQMC on graphics processing units has been investigated in double (FP64)[61] and single (FP32) precision[20], producing substantial speedups and (for FP32) errors below the threshold of chemical accuracy. Our mixed-precision algorithm uses two TF32 numbers to represent one full-precision number. We can recover accuracy close to the single-precision propagation of Shee et al. [20] while improving speed even further on GPUs with Tensor Cores.
Thall[62] discusses bitwise operations for adding and multiplying an FP64 number represented as two FP32 numbers, with an effective precision of roughly 48 bits. We use a similar splitting technique, Algorithm 1, to approximate an FP64 number with two TF32 floats, ; the same algorithm would work for FP32. For TF32, with 10 significant bits, the effective precision of Algorithm 1 is about 20 bits, nearly the 23 bits of FP32. (We implicitly assume that lies in the exponent range expressible by TF32.)
Neglecting under- and overflow, adding two numbers represented in this fashion is simply adding the components,
Algorithm 1. Approximate an FP64 float as two TF32 floats.
1: procedure SplitPrecision() 2: ▷ Or FP32, throughout 3: 4: return 5: end procedure
Following Valero-Lara et al. [63], we approximate (matrix) multiplication by three reduced-precision multiplications (Algorithm 2). This extends the multiword algorithm of Fasi et al. [64] to the TF32 datatype and is similar to the Ozaki scheme for exact emulation of higher-precision arithmetic[65], while neglecting the product of the low bits in the spirit of a first-order Taylor expansion. As the exponent ranges of TF32 and FP32 are smaller than that of FP64, we assume that the product can be represented in reduced precision; our numerical tests have not yielded over- or underflow errors.
Algorithm 2. Approximately multiply two FP64 structures using TF32 operations.
1: procedure MixPrecMult() 2: 3: 4: return 5: end procedure
Mixed-precision AFQMC propagation
We approximate the Monte Carlo propagation on each walker,
with Algorithms 1 and 2, representing high and low bits of , , and optionally in reduced precision.
We note that, while and the trial wavefunction are purely real for molecular systems, the mean-field shift means that the modified two-body propagator is complex, so acquires an imaginary component. Nevertheless, we can batch and into a single real array and multiply both by , inserting the imaginary unit afterward. We thus save time relative to a naïvely complex matrix multiplication, which requires four real matrix-matrix multiplications. If , , or are intrinsically complex, as is the case in periodic boundary conditions, this decomposition is required:
Since each term in (23) is approximated by Algorithm 2 by three reduced-precision multiplications, the complex product requires twelve real matrix products (and two real accumulations in full precision). We leave this fully complex implementation for future work.
We further approximate the action of the two-body propagator on by a recursive procedure implementing the Taylor expansion of the exponential, Algorithm 3. This is to avoid having to compute an expensive matrix exponential for every walker at every timestep; while the Cholesky matrices do not change, a different realization of each is required for each propagation step and each independent walker. ( has to be exponentiated only once, at the start of propagation; we thus exponentiate it exactly.)
Algorithm 3. approximated by order- Taylor expansion.
1: procedure ExpTaylor() 2: ▷ Product accumulator 3: ▷ Sum accumulator; 4: for from 1 to do 5: 6: 7: end for 8: return 9: end procedure
We apply the two-body propagator in mixed precision, accumulating the real and imaginary components of the updated in full FP64 precision. As we show in Section III below, one-body propagation can also be computed in mixed precision, with little more loss in accuracy in the total energy and modest additional speedup. Our mixed-precision algorithm parallelizes over walkers even more efficiently than AFQMC’s typical embarrassingly parallel construction suggests, as long as the set of walkers, trial wavefunction, and propagators fit in the memory of one GPU. Since the auxiliary field realizations differ, each walker in the batch assigned to one GPU requires its own distinct two-body propagator, but they can be saved contiguously in memory and all the matrix multiplications computed at once with the cuBLAS 12.9[66] routine GEMMStridedBatchedEx[67].
We still sample the auxiliary fields, construct the two-body propagation operator , accumulate , and compute the energy in full precision; only the actual propagation step, which for these systems constitutes the major part of the total computing time, makes use of mixed-precision arithmetic.
Results and Discussion
We propagate one-dimensional chains of hydrogen atoms for 200 AFQMC steps with a.u. We use the minimal STO-3G basis[68], with one contracted Gaussian-type orbital per hydrogen atom. Figure 1 shows a chain of 20 atoms rendered with the Raymol[69] fork of PyMOL[70].

Figure 1. A short chain of 20 hydrogen atoms. We propagate chains up to H₆₄₀ in the minimal STO-3G basis on a 40 GB NVIDIA A100 GPU.
We use Los Alamos National Laboratory’s Chicoma cluster[71], which has 40 and 80 GB A100 GPUs. We implement our algorithm in a development version of the OpenMS code[72]. The initial state of the walkers is the restricted Hartree–Fock wavefunction computed with PySCF[73, 74, 75]. Propagation on the CPU is accelerated with in-house C++ code, and GPU acceleration is achieved with the CuPy library[76]. For each comparison, we fix the same seed in the pseudorandom number generator that realizes the values of . Within each seed, every precision scheme therefore uses the same auxiliary-field samples. For the purposes of timing, we warm up the propagation kernel by running 10 warmup propagation steps before timing begins.
In the legends of the figures below, we use as a shorthand for the one-body propagation (which is applied twice per propagation step) and as a shorthand for the two-body propagation . We propagate the random walkers with five different methods:
Both the one- and two-body terms propagated in FP64 (black line with round markers).
One-body terms propagated in FP64, two-body terms in FP32 (reduced, not mixed, precision; green line with pentagonal markers).
One- and two-body terms propagated in FP32 reduced precision (yellow line with square markers).
One-body terms propagated with FP64, two-body terms in mixed-precision TF32 (Algorithm 2; blue line with octagonal markers).
One- and two-body terms propagated in mixed-precision TF32 (purple line with triangular markers).
In addition, we average GPU error metrics (Figure 4–Figure 6) over five random seeds.
Figure 4. The maximum value of the absolute error in the local energy, , in , of 100 walkers propagated over 200 AFQMC propagation steps and averaged over five random seeds. In larger systems, we observe some cancellation in the energy error when both one- and two-body terms are propagated in mixed-precision TF32 (purple line) compared to using double precision for the one-body propagator. However, the mixed-precision propagation has a less favorable scaling with system size. For 240 or more orbitals, the maximum error scales quadratically with the number of orbitals, while it is sub-quadratic or linear with other methods. Extrapolating each trendline suggests that the error could remain below beyond 1500 orbitals.
Figure 6. Maximum error in the local energy of 320 orbitals propagated for 200 AFQMC steps relative to FP64 as a function of the number of walkers, averaged over five random seeds and on a logarithmic scale. Regardless of the propagation method, the error saturates in the number of walkers rather than increasing monotonically. Mixed precision incurs more error than single precision, but we observe modest error cancellation when propagating both one- and two-body terms in mixed precision (purple triangles) relative to propagating in double precision (blue octagons).
Setting the CuPy environment variable CUPY_TF32 forces single-precision (FP32) arithmetic to be routed through the Tensor Core accelerators and performed in TF32 instead, albeit without the error mitigation our mixed-precision algorithm provides. As seen in the Supplementary Information, propagation with this naïve TF32 arithmetic is as fast as our mixed-precision scheme (compare Figure 3 to Figure S1), but substantially less accurate (compare Figure 4–Figure 6 against Figure S2–Figure S3).
Figure 3. Left axis, solid lines and markers: Wall time required to propagate 100 walkers along 200 AFQMC steps on the GPU in full, reduced, and mixed precision, plotted on a log-log scale. Right axis, dashed lines and open markers: Speedup relative to double precision. Both are averaged over the five random seeds. Note that we do not optimize the single-precision propagation, so on this GPU it is not much faster than double precision; mixed precision is faster in all systems. For 640 orbitals, propagating both one- and two-body terms in mixed precision is more than twice as fast as double-precision propagation.
Figure S1. The time for propagating 640 walkers 200 AFQMC steps on the GPU. Compare with Figure 3 in the main text.
Figure S2. The maximum error in the walker norm of 100 walkers over 200 propagation steps, as a function of the number of orbitals. Compared with Figure 5 in the main text, propagating both and in mixed precision (purple triangles) introduces more error than even the naïve TF32 propagation schemes (yellow squares, green pentagons). The dominant additional error is associated with reducing the precision of : as propagating in double precision while using mixed precision for (blue octagons) has the lowest error relative to double-precision propagation.
Figure 5. The maximum relative error in the norm of the walker wavefunctions, , for 100 walkers propagated over 200 AFQMC propagation steps and averaged over five random seeds. Unlike the local energy, the relative error in does not increase monotonically with the system size. In particular, when both and are propagated with Algorithm 2, the error saturates in the number of orbitals at . Nevertheless, using TF32 for incurs more than an order of magnitude of additional error relative to propagating in FP64.

Figure S3. Error in the local energy relative to FP64 propagation as a function of (a) the number of orbitals, (b) the number of walkers, with naïve TF32 arithmetic for (green pentagons) or for both and (yellow squares). These runs are not averaged over different random seeds. Compare with Figure 4–Figure 6 in the main text: naïve TF32 propagation (green pentagons, yellow squares) is substantially less accurate than mixed-precision propagation (blue octagons, purple triangles).
Efficiency
Figure 2 compares FP64 propagation on the CPU and GPU. The GPU is faster at every system size for which both measurements are available, and the performance gap widens as the number of orbitals increases. The CPU kernel takes more than 5000 s to propagate 480 H with 100 walkers atoms for 200 AFQMC steps; the same propagation on the GPU takes 8 s, a speedup of 650x. Note that FP64 propagation on the GPU does not use our mixed-precision algorithm; we simply route walkers and propagator matrices to the GPU and replace the propagation routines with CuPy equivalents.
Figure 2. The time required to propagate 100 walkers along 200 AFQMC steps in double (FP64) precision on the CPU (red) and the GPU (black), on a log-log scale. Error bars are the sample standard deviation after averaging five runs (in this case, all with the same random seed). The GPU is about two orders of magnitude faster than the CPU. Note that the time to propagate 40 orbitals on the GPU is about the same as required to propagate 80, because the overhead of launching the GPU kernels is the bottleneck for small systems.
We compare the five GPU propagation schemes in Figure 3. The solid curves and filled markers represent the total time required to propagate 100 walkers along 200 AFQMC steps, shown on the left axis. The dashed lines and open markers show the speedup relative to double-precision propagation on the right axis. Single-precision (FP32) propagation, in yellow squares (both one- and two-body terms propagated in FP32) and green pentagons (one-body terms remain in FP64), is implemented naïvely: it calls the same routines as the FP64 GPU propagation, but with a 32-bit datatype (or its 64-bit complex equivalent). It is included for comparing accuracy against our mixed-precision algorithm, so we do not optimize it for speed, and, indeed, it is not noticeably faster than FP64 propagation. Our mixed-precision algorithm, in any case, is faster than FP64 or FP32 propagation for systems of moderate size. For small systems, there is little practical benefit to mixed-precision propagation, as the computational kernels are bottlenecked by communication overhead; by 120 orbitals, the speedup is about 20%. As with converting double-precision propagation to the GPU, however, the benefit of propagating in mixed precision grows as the number of orbitals increases. By 640 orbitals, propagating both one- and two-body terms in mixed precision (purple triangles) is twice as fast as using double precision. This improvement, even relative to FP64 propagation on the GPU, is expected to continue until the size of exceeds the memory available on the GPU.
Accuracy
Propagating in reduced precision, whether casting directly to FP32 or using Algorithm 2 in TF32, incurs an accuracy penalty relative to FP64 propagation greater than the FP32 machine epsilon . In Figure 4, we show the maximum error in the local energy
of each propagation algorithm over the 200 propagation steps , relative to propagating in double precision. We take the geometric mean of over five random seeds. Propagating the two-body terms in single precision while keeping the one-body term in double precision (green pentagons) incurs error little larger than . This error increases sublinearly with system size. Averaging over the five random seeds, the fitted line scales as . Propagating both one- and two-body terms in FP32 incurs a larger error, which scales roughly linearly () with the number of orbitals but remains below at 640 orbitals, the largest system we studied. Mixed-precision arithmetic incurs a greater error than FP32 propagation.
This cancellation of error is not observed in the error in the norm of the walker wavefunction,
is typically 1–2 orders of magnitude greater when both and are propagated in mixed precision (purple triangles) than when either alone (green pentagons) or both and (yellow squares) are propagated in single precision. The dominant contribution instead comes from reducing the precision of . Propagating in FP64 lowers the error in the walker norm by one to two orders of magnitude in both the FP32 and mixed-precision TF32 schemes. We see a monotone increase in the error with system size only when propagating in mixed precision and in double precision (blue octagons); otherwise, the error is nonmonotone and indeed appears to saturate at roughly for full mixed-precision propagation. Note that, to allow exact comparison over more propagation steps, we do not orthonormalize the walker wavefunctions in any of these schemes. In a production-ready code, the walkers would be normalized every few propagation steps, which controls norm growth but does not, in general, make the reduced-precision and FP64 walkers identical. The faster drift in the walker norms with our mixed-precision scheme is still worth noting.
Finally, we observe in Figure 6 that does not increase with the number of random walkers when the number of orbitals (320) and number of propagation steps (200) are held fixed. The stochastic dependence on the random seed is, as expected, larger for fewer walkers; the apparently larger error bars for propagating in double and in single precision (green pentagons) is due to the logarithmic scale of . For these seeds, we observe again the error cancellation of Figure 4 when both one- and two-body terms are propagated with our mixed-precision algorithm relative to full-precision propagation of .
Summary
We have developed an efficient mixed-precision propagation scheme for AFQMC. Utilizing NVIDIA GPUs’ Tensor Cores, which compute TF32-precision arithmetic extremely efficiently, we substantially exceed the performance of propagating in either single (FP32) or double (FP64) precision on the same GPU. While our mixed-precision scheme suffers modest loss in the accuracy of the local energy and does not maintain the norm of the walker wavefunctions as well as propagating in single precision, it remains well within the stochastic error inherent to AFQMC and below the threshold of chemical accuracy for systems of moderate size.
The bottleneck for this method on GPUs is memory; the entire set of Cholesky matrices , in addition to a collection of Slater determinant walker wavefunctions, must fit into the main memory of the GPU. Different walkers can be distributed to different GPUs as needed, although the batched strided matrix multiplication available on Tensor Cores means that the advantages of our mixed-precision algorithm are maximized when as many walkers as possible are placed on one GPU. However, the memory requirement for storing is since there are Cholesky matrices, each of size [16]. We note that the ipie software[77] alleviates the memory bottleneck by structuring the Cholesky matrices hierarchically, sharing a copy of among a small group of GPUs instead of distributing it separately to each[78]. In future work, we plan to investigate this and other schemes for parallelizing over multiple GPUs.
Acknowledgments
We acknowledge support from the U.S. Department of Energy, Office of Science, Basic Energy Sciences, Chemical Sciences, Geosciences, and Biosciences Division under Triad National Security, LLC (“Triad”) contract Grant 89233218CNA000001 (FWP: LANLECF7). This research used computational resources provided by the Institutional Computing (IC) Program at Los Alamos National Laboratory (LANL), which is funded by the Computational Systems and Software Environments subprogram of LANL’s Advanced Simulation and Computing program. LANL is operated by Triad National Security, LLC, for the National Nuclear Security Administration of the U.S. Department of Energy (Contract No. 89233218CNA000001).
References
Naïve Tensor Core arithmetic
On NVIDIA A100 machines, setting the environment variable CUPY_TF32 to 1 automatically routes single-precision arithmetic through the Tensor Cores in TF32 precision. This naïve implementation is almost as fast as our mixed-precision propagator on the systems tested (Figure S1).
The mixed-precision algorithm still induces the largest error in the norm of the walker wavefunctions. This could be because, when we split into high and low bits, there is more systematic drift relative even to setting the low bits to zero.
Naïve Tensor Core propagation does not ameliorate the reduced accuracy of TF32 relative to FP32 as our mixed-precision algorithm does. Therefore, its error in the local energy is worse than our algorithm, by roughly an order of magnitude up to 640 orbitals, as seen in Figure S3. Note, however, that increases more steeply with the number of walkers when both and are propagated in mixed precision.
References
- [1]J. Greeley, J. K. Nørskov, and M. Mavrikakis, Annual Review of Physical Chemistry 53, 319 (2002).
- [2]N. Marzari, A. Ferretti, and C. Wolverton, Nature Materials 20, 736 (2021).
- [3]R. Van Noorden, Nature 640, 591 (2025).
- [4]C. Lee, W. Yang, and R. G. Parr, Physical Review B 37, 785 (1988).
- [5]J. P. Perdew, K. Burke, and M. Ernzerhof, Physical Review Letters 77, 3865 (1996).
- [6]G. Kresse and J. Furthmüller, Physical Review B 54, 11169 (1996).
- [7]A. M. Teale, T. Helgaker, A. Savin, C. Adamo, B. Aradi, A. V. Arbuznikov, P. W. Ayers, E. J. Baerends, V. Barone, P. Calaminici, E. Cancès, E. A. Carter, P. K. Chattaraj, H. Chernette, I. Ciofini, T. D. Crawford, F. De Proft, J. F. Dobson, C. Draxl, T. Frauenheim, E. Fromager, P. Fuentealba, L. Gagliardi, G. Galli, J. Gao, P. Geerlings, N. Gidopoulos, P. M. W. Gill, P. Gori-Giorgi, A. Görling, T. Gould, S. Grimme, O. Gritsenko, H. J. A. Jensen, E. R. Johnson, R. O. Jones, M. Kaupp, A. M. Köster, L. Kronik, A. I. Krylov, S. Kvaal, A. Laestadius, M. Levy, M. Lewin, S. Liu, P.-F. Loos, N. T. Maitra, F. Neese, J. P. Perdew, K. Pernal, P. Pernot, P. Piecuch, E. Rebolini, L. Reining, P. Romaniello, A. Ruzsinszky, D. R. Salahub, M. Scheffler, P. Schwerdtfeger, V. N. Staroverov, J. Sun, E. Tellgren, D. J. Tozer, S. B. Trickey, C. A. Ullrich, A. Vela, G. Vignale, T. A. Wesolowski, X. Xu, and W. Yang, Physical Chemistry Chemical Physics 24, 28700 (2022).
- [8]F. Neese, JBIC Journal of Biological Inorganic Chemistry 11, 702 (2006).
- [9]E. Pavarini, La Rivista del Nuovo Cimento 44, 597 (2021).
- [10]V. Gavin, S. Baroni, V. Blum, D. R. Bowler, A. Buccheri, J. R. Chelikowsky, S. Das, W. Dawson, P. Delugas, M. Dogan, C. Draxl, G. Galli, L. Genovese, P. Giannozzi, M. Giantomassi, X. Gonze, M. Govoni, F. Gygi, A. Gulans, J. M. Herbert, S. Kokott, T. D. Kühne, K.-H. Liou, T. Miyazaki, P. Motamarri, A. Nakata, J. E. Pask, C. Plessl, L. E. Ratcliff, R. M. Richard, M. Rossi, R. Schade, M. Scheffler, O. Schütt, P. Suryanarayana, M. Torrent, L. Truflandier, T. L. Windus, Q. Xu, V. W.-Z. Yu, and D. Perez, Modelling and Simulation in Materials Science and Engineering 31, 063301 (2023).
- [11]S. Bianchini, A. Geuna, and F. Shermatov, Scientific Reports 10.1038/s41598-026-63438-7 (2026).
- [12]M. M. Resch, J. Gebert, and D. Hoppe, in 2025 International Conference on Intelligent Control, Computing and Communications (IC3) (2025) pp. 897–904.
- [13]S. Gupta, A. Agrawal, K. Gopalakrishnan, and P. Narayanan, in Proceedings of the 32nd International Conference on Machine Learning (PMLR, 2015) pp. 1737–1746.
- [14]J. Dean, in 2020 IEEE International Solid-State Circuits Conference - (ISSCC) (2020) pp. 8–14.DOI
- [15]R. Shinde, C. Filippi, A. Scemama, and W. Jalby, Nature Reviews Physics 7, 378 (2025).
- [16]H. Shi and S. Zhang, The Journal of Chemical Physics 154, 024107 (2021).
- [17]J. Lee, H. Q. Pham, and D. R. Reichman, Journal of Chemical Theory and Computation 18, 7024 (2022).
- [18]J. Shee, J. L. Weber, D. R. Reichman, R. A. Friesner, and S. Zhang, The Journal of Chemical Physics 158, 140901 (2023).
- [19]M. S. Church and B. M. Rubenstein, The Journal of Chemical Physics 154, 184103 (2021).
- [20]J. Shee, E. J. Arthur, S. Zhang, D. R. Reichman, and R. A. Friesner, Journal of Chemical Theory and Computation 14, 4109 (2018).
- [21]I. Røggen and E. Wisløff-Nilssen, Chemical Physics Letters 132, 154 (1986).
- [22]T. B. Pedersen, S. Lehtola, I. Fdez. Galván, and R. Lindh, WIREs Computational Molecular Science 14, e1692 (2024).
- [23]M. Motta and S. Zhang, WIREs Computational Molecular Science 8, e1364 (2018).
- [24]R. L. Stratonovich, Soviet Physics Doklady 2, 416 (1957).
- [25]J. Hubbard, Physical Review Letters 3, 77 (1959).
- [26]D. J. Thouless, Nuclear Physics 21, 225 (1960).
- [27]A.-L. Cholesky, Bulletin géodésique 2, 67 (1924).
- [28]N. H. F. Beebe and J. Linderberg, International Journal of Quantum Chemistry 12, 683 (1977).
- [29]H. Koch, A. Sánchez de Merás, and T. B. Pedersen, The Journal of Chemical Physics 118, 9481 (2003).
- [30]I. Røggen and T. Johansen, The Journal of Chemical Physics 128, 194107 (2008).
- [31]F. Aquilante, L. De Vico, N. Ferré, G. Ghigo, P.-å. Malmqvist, P. Neogrády, T. B. Pedersen, M. Pitonák, M. Reiher, B. O. Roos, L. Serrano-Andrés, M. Urban, V. Veryazov, and R. Lindh, Journal of Computational Chemistry 31, 224 (2010).
- [32]E. G. Hohenstein, R. M. Parrish, and T. J. Martínez, The Journal of Chemical Physics 137, 044103 (2012).
- [33]R. M. Parrish, E. G. Hohenstein, T. J. Martínez, and C. D. Sherrill, The Journal of Chemical Physics 137, 224106 (2012).
- [34]E. G. Hohenstein, R. M. Parrish, C. D. Sherrill, and T. J. Martínez, The Journal of Chemical Physics 137, 221101 (2012).
- [35]Y. Zhang, Journal of Chemical Theory and Computation 22, 1770 (2026).
- [36]H. F. Trotter, Proceedings of the American Mathematical Society 10, 545 (1959).
- [37]M. Suzuki, Progress of Theoretical Physics 56, 1454 (1976).
- [38]S. Zhang, J. Carlson, and J. E. Gubernatis, Physical Review B 55, 7464 (1997).
- [39]E. Y. Loh, J. E. Gubernatis, R. T. Scalettar, S. R. White, D. J. Scalapino, and R. L. Sugar, Physical Review B 41, 9301 (1990).
- [40]D. M. Ceperley, Journal of Statistical Physics 63, 1237 (1991).
- [41]S. Zhang and H. Krakauer, Physical Review Letters 90, 136401 (2003).
- [42]D. Danilov, B. Ganoe, M. Munyi, and J. Shee, Journal of Chemical Theory and Computation 21, 1136 (2025).
- [43]T. Jiang, B. O’Gorman, A. Mahajan, and J. Lee, Physical Review Research 7, 013038 (2025).
- [44]A. Mahajan, J. H. Thorpe, J. S. Kurian, D. R. Reichman, D. A. Matthews, and S. Sharma, Journal of Chemical Theory and Computation 21, 1626 (2025).
- [45]Z.-Y. Xiao, T. Xiang, Z. Lu, Y. Chen, and S. Zhang, The Journal of Chemical Physics 163, 164109 (2025).
- [46]Z.-Y. Xiao, B. Kan, H. Ma, B. Zhao, and H. Shang, Journal of Chemical Theory and Computation 21, 9587 (2025).
- [47]Y. Yoshida, L. Erhart, T. Murokoshi, R. Nakagawa, C. Mori, H. Tagami, and W. Mizukami, Journal of Chemical Theory and Computation 21, 9404 (2025).
- [48]J. Z. Williams and Y. Zhang, Differentiated determinant graphs enable large-scale multideterminant auxiliary-field quantum monte carlo (2026), arXiv:2610.29851 [physics.chem-ph].arxiv.org/abs/2610.29851
- [49]G. C. Wick, Physical Review 80, 268 (1950).
- [50]R. Balian and E. Brezin, Il Nuovo Cimento B (1965-1970) 64, 37 (1969).
- [51]M. Motta, J. Shee, S. Zhang, and G. K.-L. Chan, Journal of Chemical Theory and Computation 15, 3510 (2019).
- [52]IEEE, IEEE Standard for Floating-Point Arithmetic (2019).
- [53]IEEE, IEEE Standard for Binary Floating-Point Arithmetic (1985).
- [54]D. Stosic and P. Micikevicius, Accelerating AI Training with NVIDIA TF32 Tensor Cores, https://developer.nvidia.com/blog/accelerating-ai-training-with-tf32-tensor-cores/ (2021).
- [55]NVIDIA A100 GPUs Power the Modern Data Center, https://www.nvidia.com/en-us/data-center/a100/ (2022).
- [56]P. Steinbach and C. Bannwarth, Journal of Chemical Theory and Computation 21, 7335 (2025).
- [57]J. Woo and S. Choi, Journal of Chemical Theory and Computation 22, 1687 (2026).
- [58]R. Olivares-Amaya, M. A. Watson, R. G. Edgar, L. Vogt, Y. Shao, and A. Aspuru-Guzik, Journal of Chemical Theory and Computation 6, 135 (2010).
- [59]J. J. Eriksen, Molecular Physics 115, 2086 (2017).
- [60]Y. Tian, Z. Xie, Z. Luo, and H. Ma, Journal of Chemical Theory and Computation 18, 7260 (2022).
- [61]Y. Huang, Z. Guo, H. Q. Pham, and D. Lv, GPU-accelerated Auxiliary-field quantum Monte Carlo with multi-Slater determinant trial states (2024), arXiv:2406.08314.arxiv.org/abs/2406.08314
- [62]A. Thall, in ACM SIGGRAPH 2006 Research Posters, SIGGRAPH ’06 (Association for Computing Machinery, New York, NY, USA, 2006) pp. 52–es.
- [63]P. Valero-Lara, I. Jorquera, F. Lui, and J. Vetter, in Proceedings for the SC ’23 Workshops of the International Conference on High Performance Computing, Network, Storage, and Analysis, SC-W ’23 (Association for Computing Machinery, New York, NY, USA, 2023) pp. 179–186.
- [64]M. Fasi, N. J. Higham, F. Lopez, T. Mary, and M. Mikkaitis, SIAM Journal on Scientific Computing 45, C1 (2023).
- [65]K. Ozaki, T. Ogita, S. Oishi, and S. M. Rump, Numerical Algorithms 59, 95 (2012).
- [66]https://docs.nvidia.com/cuda/archive/12.9.0/cublas/index.html.
- [67]See https://developer.nvidia.com/blog/cublas-strided-batched-matrix-multiply/ and https://docs.nvidia.com/cuda/archive/12.9.0/cublas/index.html#cublasgemmstridedbatchedex; the moniker Ex indicates that we can specify the precision.
- [68]W. J. Hehre, R. F. Stewart, and J. A. Pople, The Journal of Chemical Physics 51, 2657 (1969).
- [69]J. Castellanos, RayMol (2026), https://raymol.io.
- [70]Schrödinger, LLC, The PyMOL molecular graphics system, version 3.1.0 (2025), https://pymol.org.
- [71]J. K. Green, N. C. Sly, M. F. T. R. Lapid, J. A. Ogas, K. J. Everson, D. J. Magee, C. D. Seamons, and P. S. Ferrell, in CUG’21 (Cray User Group, Los Alamos, New Mexico, 2021).
- [72]A stable version of OpenMS is available at https://github.com/alan/openMS.
- [73]Q. Sun, T. C. Berkelbach, N. S. Blunt, G. H. Booth, S. Guo, Z. Li, J. Liu, J. D. McClain, E. R. Sayfutyatova, S. Sharma, S. Wouters, and G. K.-L. Chan, WIREs Computational Molecular Science 8, e1340 (2018).
- [74]Q. Sun, X. Zhang, S. Banerjee, P. Bao, M. Barbry, N. S. Blunt, N. A. Bogdanov, G. H. Booth, J. Chen, Z.-H. Cui, J. J. Eriksen, Y. Gao, S. Guo, J. Hermann, M. R. Hermes, K. Koh, P. Koval, S. Lehtola, Z. Li, J. Liu, N. Mardrossian, J. D. McClain, M. Motta, B. Mussard, H. Q. Pham, A. Pulkin, W. Purwanto, P. J. Robinson, E. Ronca, E. R. Sayfutyrova, M. Scherer, H. F. Schurkus, J. E. T. Smith, C. Sun, S.-N. Sun, S. Upadhyay, L. K. Wagner, X. Wang, A. White, J. D. Whitfield, M. J. Williamson, S. Wouters, J. Yang, J. M. Yu, T. Zhu, T. C. Berkelbach, S. Sharma, A. Y. Sokolov, and G. K.-L. Chan, The Journal of Chemical Physics 153, 024109 (2020).
- [75]Q. Sun, M. R. Hermes, X. Wu, H. Zhai, X. Zhang, A. M. Ahmed, J. J. Aucar, O. J. Backhouse, S. Banerjee, P. Bao, N. A. Bogdanov, K. Bystrom, F. Chapoton, N.-Y. Chen, T. Y. Chernyshev, H. S. Clifford, S. Cohen-Jones, Z.-H. Cui, Y. D. Damour, N. Dattani, L. B. Dittmer, S. Ehlert, J. J. Eriksen, F. A. Evangelista, S. A. Ewing, A. Farahvash, K. Focke, Y. Gao, K. E. Gasperich, N. Gillispie, J. Greiner, M. R. Hennefarth, J. Hermann, C. Hillenbrand, J. H. L. Huthasalo, B. Ibrahim, B. Jangid, A. N. Javaremi, A. J. Jenkins, Y. Jin, D. S. King, D. P. Kooi, J. S. Kurian, H. R. Larsson, B. T. G. Lau, S. Lee, S. Lehtola, C. Li, H. Li, J. Li, R. Li, S. Li, A. O. Lykhin, A. Mahajan, N. Mauger, P. del Mazo-Sevillano, J. Moussa, K. Nakanо, V. A. Neufeld, L. Peng, H. Q. Pham, P. Pinski, P. Pokhilko, Z. Pu, Y. Qian, S. J. Quiton, W. T. Schulze, T. R. Scott, A. Seal, J. D. Serna, J. E. T. Smith, K. E. Smyser, T. Stahl, C. Sun, K. J. Sung, E. Trushin, S. Upadhyay, E. A. Vo, T. Vogels, S. Wang, T. Wang, X. Wang, X. Wang, Y. Wang, M. Williamson, J. Yang, H.-Z. Ye, C.-N. Yeh, H. Yu, J. Yu, V. W.-z. Yu, C. Zhang, D. Zhang, Y. Zhang, Z. Zhao, Z. Zhou, A. J. Zhu, T. Zhu, T. C. Berkelbach, L. Gagliardi, S. Sharma, A. Sokolov, and G. K.-L. Chan, The Python Simulations of Chemistry Framework: 10 years of an open-source quantum chemistry project (2026), arXiv:2603.14155 [physics.chem-ph].
- [76]R. Okuta, Y. Unno, D. Nishino, S. Hido, and C. Loomis, in Proceedings of Workshop on Machine Learning Systems (LearningSys) in The Thirty-first Annual Conference on Neural Information Processing Systems (NIPS) (2017).
- [77]F. D. Mahajan, A. Mahajan, J. S. Spencer, and J. Lee, Journal of Chemical Theory and Computation 19, 109 (2023).
- [78]T. Jiang, M. K. A. Baumgarten, P.-F. Loos, A. Mahajan, A. Scemama, S. F. Ung, J. Zhang, F. D. Malone, and J. Lee, The Journal of Chemical Physics 161, 162502 (2024).






