{"id":"4df7725a-3805-432e-b227-9a8ad42e8392","arxiv_id":"2607.13781","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":5,"one_line_summary":"A JAX-based GPU-accelerated QMC package implementing VMC, LRDMC, and JAGP wave functions claims up to 10x speedup over TurboRVB and exposes unresolved LRDMC-vs-CCSD(T) force disagreements.","lead":"jQMC is a new open-source Python/JAX package that runs variational and diffusion quantum Monte Carlo simulations on GPUs, reaching up to roughly 10x speedup over the Fortran TurboRVB code for tested molecules. It also computes atomic forces and reports a large, unresolved disagreement between LRDMC and CCSD(T) forces for malonaldehyde.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Speedup claim hinges on unchanged statistical efficiency; autocorrelation time is not reported, so the 10x/3x wall-time ratio may not reflect effective samples/sec.","rationale":"The reader's weakest assumption correctly identifies the head-to-head benchmark configuration as the load-bearing point for the paper's headline performance claim. The paper is otherwise thorough: it reports code/data availability, checks energies against other QMC codes (Sec. XIII), and discusses CPU slowdowns and force discrepancies honestly. The benchmark also includes cross-checks of energies and variances, which is real evidence that the mixed-precision/Cartesian implementation does not introduce large biases. However, the metric used to define 'faster' is wall time to a target statistical error, and that metric depends on the full statistical efficiency of the sampler, not just the variance of the local energy. Equal variance is necessary but not sufficient; equal integrated autocorrelation time is also required. Since the paper does not report this quantity for either code, the 10x/3x speedup cannot be fully assessed from the presented data. A focused test comparing effective independent samples per second under controlled settings would settle whether the speedup is genuine. Because this concern is already the basis of the reader's CONDITIONAL verdict, and because the paper's other supporting evidence is substantial, I do not recommend shifting the verdict further; the appropriate outcome is to keep the verdict unchanged pending the autocorrelation check.","tokens_in":45510,"tokens_out":12143,"duration_ms":135941,"concrete_test":"For (H2O)20 (Ne=160), run the Sec. XI MCMC benchmark with jQMC on the Genkai H100 node using (i) the paper's mixed-precision/Cartesian setup and (ii) full-precision/spherical GTOs, with the same number of walkers per GPU and the same MCMC parameters. For each run, compute the local-energy variance and the integrated autocorrelation time tau_int (e.g., via reblocking), then compute effective samples/sec = N_walkers*M_steps/(t_net*tau_int). Compare these effective rates to the same quantity measured for TurboRVB-CPU under its production configuration. If the ratio of effective samples/sec is close to the reported 10x, the headline speedup survives; if the ratio drops substantially, the speedup claim needs to be revised to account for statistical efficiency.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central quantitative claim—jQMC on GPUs being up to 10x faster than TurboRVB for VMC and 3x for LRDMC—rests on the Sec. XI benchmark in which jQMC runs in mixed precision with Cartesian GTOs while TurboRVB runs on CPUs in full precision with spherical GTOs. The paper states that parameters such as hopping distance, observable frequency, and LRDMC lattice spacing were set identically, and it reports agreement in total energies and variances. However, the time-to-target-error metric t_target=(sigma_run/sigma_target)^2 * t_net assumes that the statistical efficiency per unit wall time is determined by the single-sample variance and that the integrated autocorrelation time is either identical between codes or already reflected in sigma_run. The paper does not report integrated autocorrelation times for either code, nor does it demonstrate that mixed-precision/Cartesian sampling produces the same autocorrelation as full-precision/spherical sampling. If jQMC's mixed-precision MCMC has a longer autocorrelation time, its effective independent samples per second would be lower than the raw step throughput suggests, and the reported speedup could be overstated. Conversely, if TurboRVB's spherical/full-precision CPU sampling has a shorter autocorrelation time, the comparison would be biased in the opposite direction. The energies and variances being equal within error bars does not settle this, because autocorrelation time is a separate statistical property.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents jQMC, a JAX-based ab initio quantum Monte Carlo package implementing VMC and lattice-regularized DMC (LRDMC) with Jastrow–AGP/Jastrow–Slater wave functions, stochastic reconfiguration and linear-method optimization, automatic-differentiation forces, mixed-precision support, and GPU/CPU portability with MPI and JAX sharding. The authors benchmark jQMC on NVIDIA A100/H100 systems, report a head-to-head wall-time comparison with TurboRVB on small water clusters, validate total energies against other DMC codes for methane/water/methane–water, and demonstrate VMC/LRDMC atomic forces for ethanol and malonaldehyde versus CCSD(T). The central claims are that jQMC on GPUs is up to ~10x faster than TurboRVB for VMC and ~3x for LRDMC, and that LRDMC forces reach ~1.5 kcal/mol/Å MAE versus all-electron CCSD(T) for ethanol, while malonaldehyde shows a much larger discrepancy.","tokens_in":45867,"tokens_out":5582,"duration_ms":64254,"significance":"If the performance and force claims hold, jQMC is a valuable open, GPU-oriented QMC package with functionality closely matching TurboRVB, plus modern software engineering. The paper's strengths include: public code and data repositories; intra-software production/debug consistency tests; inter-software validation against CASINO, QMCPACK, CMQMC, and TurboRVB on total energies and binding energies; careful attention to benchmark setup (same Jastrow ansatz, matched proposal/observable parameters, energy and variance cross-checks); and a useful roofline/Nsight analysis of the GPU kernels. The force-analysis section also correctly accounts for the noise floor in MAE comparisons. However, the headline quantitative results are not fully supported as written: there is a direct abstract/body discrepancy in the ethanol LRDMC MAE, and the wall-time speedup claim relies on a time-to-target formula whose statistical-efficiency input is not reported or verified across the compared configurations.","major_comments":[{"comment":"The abstract states that LRDMC forces for ethanol achieve ~1.5 kcal/mol/Å MAE versus all-electron CCSD(T), while Sec. XIV and Fig. 11 report an MAE of 2.1 kcal/mol/Å for this quantity, and the text notes that this is close to the 2.0 value of Ref. 82. This is a direct quantitative inconsistency in a headline result. The abstract must be corrected to match the body, or the body/Fig. 11 must be reconciled if a different metric is intended.","section":"Abstract; Sec. XIV, Fig. 11"},{"comment":"The central performance claim—jQMC on GPUs is ~10x (MCMC) and ~3x (LRDMC) faster than TurboRVB—uses t_target=(σ_run/σ_target)^2·t_net. This formula is valid only if σ_run is the reblocked/jackknife standard error of the mean, which automatically incorporates autocorrelation. The manuscript does not state which σ_run is used, and it does not report integrated autocorrelation times or effective sample sizes for the jQMC and TurboRVB benchmark runs. Cross-checks of total energies and variances do not establish equal statistical efficiency per wall-time step. Please report reblocked standard errors, autocorrelation times, or a time-to-target-error comparison based on effective independent samples per second.","section":"Sec. XI, Fig. 8"},{"comment":"The speedup comparison simultaneously varies hardware (GPU vs CPU), precision (mixed vs full), and GTO representation (Cartesian vs spherical). The paper argues that total energies and variances agree, but this does not control for autocorrelation or for possible LRDMC-specific statistical-efficiency differences. In addition, Sec. VIII states that mixed precision is 'approximately twice as fast' as full precision, while Table II reports speedups of only 1.22–1.46x. The smaller actual gain should be stated, and the benchmark section should clarify whether the 10x/3x ratios would survive a same-precision, same-representation control.","section":"Sec. XI, Table IV, Fig. 8; Sec. VIII"}],"minor_comments":[{"comment":"The text says FP32/FP64 calculations are 'approximately twice as fast' as FP64, but Table II lists speedups of 1.22x–1.46x. Please correct the text or qualify the claim.","section":"Sec. VIII, Table II"},{"comment":"Typographical errors: 'repectively' (paragraph on malonaldehyde MAE floor) and 'instaibility' (Sec. VI B). Also, the force heat map caption should state explicitly which LRDMC estimator (Reynolds approximation with Pathak–Wagner regularization) is used for the displayed values.","section":"Sec. XIV"},{"comment":"The notation T(x→x') is clear in context, but labeling the conditional proposal density as T(x'|x) would avoid ambiguity with the reverse transition in Eq. (8).","section":"Sec. II, Eq. (7)"},{"comment":"The jQMC conventional and load-balanced LRDMC methane energies differ by 3x10^-5 Ha; this is presumably statistical, but a footnote stating the values are within error bars would help the reader.","section":"Sec. XIII, Table V"}],"recommendation":"major_revision","confidential_remarks":"The manuscript is a same-community benchmark by authors who are also TurboRVB developers; I do not see circularity, but an independent benchmark by a third party would strengthen the 10x/3x speedup claim given its prominence. The abstract/body MAE mismatch and the missing statistical-efficiency details for the wall-time comparison are the main blockers; both are fixable within a revision."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Quick take: this is a serious software paper with a plausible headline claim, but it has an internal inconsistency in the headline force number and one benchmark assumption that isn't documented. Worth referee time; needs a revision round.\n\nWhat's actually new: jQMC is a complete JAX-based ab initio QMC package — VMC and LRDMC (conventional plus load-balanced branching), JAGP wave functions, SR and linear-method optimization, forces via automatic differentiation, mixed precision, walker-level vectorization, MPI plus JAX sharding. Code and data are public. That artifact is genuinely useful: a GPU-native code with TurboRVB-level functionality that a group can pick up, extend, and run on current GPU machines. The benchmarking is a cut above the typical software paper: same Jastrow ansatz as TurboRVB, matched MCMC proposal parameters, energy and variance cross-checked between codes, inter-software validation against the water–methane reproducibility study, and kernel-level profiling with Nsight. The paper also reports its own weaknesses plainly — jQMC on CPU is about 10x slower than TurboRVB, and the malonaldehyde LRDMC force gap vs CCSD(T) is unexplained. That honesty is real credit.\n\nSoft spots, in proportion:\n\n— The abstract claims ethanol LRDMC forces agree with CCSD(T) to ~1.5 kcal/mol/Å; Sec XIV and Fig. 11 give 2.1. The body's 2.1 is the one consistent with the text comparing to Slootman et al. (2.0), so the abstract is wrong. A referee should require this fixed.\n\n— The 10x/3x speedup is computed via t_target = (sigma_run/sigma_target)^2 * t_net. That assumes statistical efficiency is fully captured by the single-sample variance. The paper matches energies and variances between codes but doesn't report integrated autocorrelation times. Since the two codes use identical proposal distributions and nearly identical wave-function evaluation, I suspect the autocorrelation difference is modest — but it's a measurable quantity, and it should be measured. Moderate, not fatal.\n\n— The LRDMC force section omits the lattice spacing and whether forces were extrapolated to a→0. Given forces are the physics headline, this is a reproducibility gap.\n\n— The 10x headline compares jQMC on GPU with TurboRVB on CPU. That's the paper's stated framing and it's fair, but the gap will narrow as TurboRVB-GPU becomes competitive on larger systems; the authors acknowledge this.\n\nWho it's for: QMC method developers, GPU HPC practitioners, and anyone considering adopting a JAX-based QMC code. The central performance claim probably survives review. Send it to a serious referee with requests for the abstract fix, autocorrelation data, and LRDMC force protocol details.","headline":"A real JAX-QMC software contribution with a plausible but under-documented GPU speedup claim over TurboRVB, plus an abstract/body inconsistency in the headline ethanol force number.","tokens_in":46332,"tokens_out":7566,"would_cite":true,"duration_ms":68979,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"A GPU-first, automatically differentiated Python quantum Monte Carlo package reaches an order-of-magnitude wall-time speedup for variational Monte Carlo while matching a mature Fortran code's algorithms and wave functions.","keywords":["quantum Monte Carlo","variational Monte Carlo","lattice-regularized diffusion Monte Carlo","GPU acceleration","automatic differentiation","atomic forces","Jastrow factor","stochastic reconfiguration"],"falsifier":"Measure, for the same trial wave function and system, the integrated autocorrelation time and local-energy variance in mixed-precision Cartesian-orbital sampling versus full-precision spherical-orbital sampling; if the mixed-precision runs have materially larger variance per accepted step or longer autocorrelation, the tenfold wall-time gain would not translate into a tenfold gain in statistical efficiency.","tokens_in":45401,"feed_emoji":"⚛️","tokens_out":10829,"duration_ms":95696,"temperature":0.7,"pith_summary":"This paper presents jQMC, a Python package that implements Variational Monte Carlo and lattice-regularized Diffusion Monte Carlo for ab initio molecular simulations, built on automatic differentiation and just-in-time compilation so the numerical kernels run on GPUs. The central claim is that this GPU-first design makes production QMC practical: for water clusters up to 160 electrons, the package reaches a target statistical error in total energy up to ten times faster in wall-clock time than a long-optimized Fortran code implementing the same algorithms and wave functions, with a more moderate gain for lattice-regularized DMC. The package also computes atomic forces by differentiating through the Monte Carlo estimator, and the authors benchmark LRDMC forces against all-electron coupled-cluster results: agreement within about 1.5 kcal/mol/Å mean absolute error for ethanol, but a roughly 5 kcal/mol/Å discrepancy for malonaldehyde that they leave unexplained. A reader should care because this is evidence that the core of ab initio QMC can be re-expressed in a GPU-first, automatically differentiated programming model without losing accuracy, and because the force results directly inform an open debate about QMC versus coupled-cluster forces.","feed_headline":"GPU-native quantum Monte Carlo runs 10x faster on test molecules","feed_subtitle":"Variational and diffusion Monte Carlo move to GPUs, with atomic forces checked against coupled-cluster results.","key_machinery":"The load-bearing mechanism is a numerical programming model that keeps the QMC inner loop on the GPU: vectorization over walkers at the top level, just-in-time compilation of the electron-move kernels, and automatic differentiation of the local energy with respect to wave-function parameters and nuclear coordinates. Around this core, the implementation uses the matrix-determinant lemma and its companion rank-one inverse update for fast single-electron wave-function ratios, mixed single/double precision to exploit GPU arithmetic units, a reweighting scheme that keeps force estimators finite near the nodal surface, and a load-balanced branching scheme for LRDMC that coordinates walker replicat","core_discovery":"On its own terms, the paper establishes that a quantum Monte Carlo code written from scratch around just-in-time compilation, walker-level vectorization, and automatic differentiation can match the functionality of an established Fortran90 QMC code — the same VMC and lattice-regularized DMC algorithms and the same Jastrow-plus-geminal wave functions — while delivering an order-of-magnitude wall-time speedup for VMC and a factor-of-three speedup for LRDMC on modern GPUs for systems with up to 160 electrons. The speedups are measured as node-hours to reach a 1 kcal/mol statistical error in the total energy, and the paper verifies that energies and variances agree with the reference code within","pith_inferences":["Beyond the paper: if the wall-time comparison holds under matched precision and basis settings, the practical cost of QMC force evaluations could drop enough to make routine geometry optimization and phonon calculations on molecules with 100 or more electrons feasible on GPU clusters — an extension the paper motivates but does not perform.","Beyond the paper: because automatic differentiation makes new derivatives of observables nearly free to implement, the same machinery should transfer to Hessians, dipole derivatives, and other response properties, though the paper only computes forces.","Beyond the paper: the malonaldehyde discrepancy leaves open the possibility that fixed-node LRDMC forces, the CCSD(T) reference, or both are less accurate than assumed for intramolecular hydrogen-bonded systems; a direct test would compare against multideterminant trial wave functions and complete-basis extrapolated coupled-cluster forces.","Beyond the paper: the roofline analysis identifies the atomic-orbital kernel as limited by L1 load/store wavefront throughput rather than memory bandwidth, suggesting that data-layout or orbital-screening changes could yield further speedups beyond those benchmarked."],"forward_implications":["GPU-first QMC can be a production tool: total energies for water clusters up to 160 electrons reach a 1 kcal/mol statistical error an order of magnitude faster in wall time than a mature CPU-based Fortran implementation for the same ansatz.","Atomic forces are obtainable without hand-derived analytical gradients: automatic differentiation supplies VMC and LRDMC forces, and the ethanol LRDMC forces agree with all-electron CCSD(T) to about 1.5 kcal/mol/Å mean absolute error.","The load-balanced LRDMC variant keeps near-ideal weak scaling up to about 1000 GPUs (102,400 walkers), so the GPU speedup is not confined to a single device.","The malonaldehyde result — roughly 5 kcal/mol/Å mean absolute error between LRDMC and CCSD(T) forces — implies the disagreement persists after VMC-level nodal optimization and needs further study from both sides.","Mixed precision changes total energies by less than the combined error bars for water clusters up to 160 electrons, supporting the use of mixed precision in production runs."],"fun_headline_variants":["JAX quantum Monte Carlo hits 10x GPU speedup","New GPU QMC code outruns Fortran by 10x","JAX-based QMC: 10x faster VMC on GPUs","Quantum Monte Carlo on GPUs: 10x speedup via JAX","JIT and autodiff power 10x faster GPU quantum Monte Carlo"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The headline speedup assumes that the two codes' different numerical settings — reduced precision, orbital format, and walker counts — produce the same statistical accuracy per accepted Monte Carlo step, so that faster wall time means faster science.","fun_headline_variants_meta":{"raw":{"variants":["JAX quantum Monte Carlo hits 10x GPU speedup","New GPU QMC code outruns Fortran by 10x","JAX-based QMC: 10x faster VMC on GPUs","Quantum Monte Carlo on GPUs: 10x speedup via JAX","JIT and autodiff power 10x faster GPU quantum Monte Carlo"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000305,"raw_usage":{"total_tokens":1665,"prompt_tokens":899,"completion_tokens":766,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":643,"completion_tokens_details":{"reasoning_tokens":669}},"tokens_in":643,"tokens_out":766,"duration_ms":19744,"temperature":1.0,"reasoning_tokens":669,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-02T03:43:25.119982+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Measure, for the same trial wave function and system, the integrated autocorrelation time and local-energy variance in mixed-precision Cartesian-orbital sampling versus full-precision spherical-orbital sampling; if the mixed-precision runs have materially larger variance per accepted step or longer autocorrelation, the tenfold wall-time gain would not translate into a tenfold gain in statistical efficiency.","supporting_citations":[],"review_version":1}