{"id":"f4f4fbf7-9048-4b4a-9186-ef2a8a36622e","arxiv_id":"2505.03755","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":2,"one_line_summary":"A multi-GPU, density-fitted LASSCF implementation achieves 5-13x speedups on realistic multimetallic systems up to about 1200 basis functions and (22e,40o) active spaces, with comparable performance on NVIDIA and Intel GPUs.","lead":"This paper reports a GPU-accelerated implementation of the multireference LASSCF method, using density fitting and multiple GPUs, and measures speedups of about 5 to 13x on iron-sulfur, MOF, and nickel catalyst systems. A generalist should read it because it makes expensive quantum chemistry calculations on multi-metal catalysts practical enough to guide materials and catalyst design.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"No final-energy comparison between CPU and GPU runs means the headline speedups may include convergence-path differences, not just GPU acceleration.","rationale":"The reader identified the same load-bearing assumption: CPU and GPU runs may not represent comparable workloads, and the absence of energy comparisons leaves the speedup claim incompletely supported. The manuscript is otherwise credible: it gives detailed profiling, controlled fixed-cycle unit runs, and archived data, and it is transparent about convergence instability. The SI's explicit warning that irregular convergence patterns can distort performance metrics strengthens the concern. The most decisive single missing piece is a comparison of final converged energies between CPU and GPU runs; that would establish that the accelerated runs solve the same electronic-structure problem. Because this is exactly the reader's conditional gap and the concern is not resolved by the current text, the conditional verdict should remain unchanged rather than being strengthened to rejection or relaxed to acceptance.","tokens_in":20667,"tokens_out":3640,"duration_ms":37517,"concrete_test":"Download the archived outputs (Zenodo ref. 83); extract final LASSCF/CASSCF total energies and gradient norms from the CPU-only and GPU (Polaris/Aurora) runs in Table I for systems A, B, and D. Verify that the GPU final energies match CPU to the SCF convergence tolerance (e.g., 1e-6 Hartree) and that the same stationary point is reached. In addition, rerun system B three times with identical inputs and report wall-time medians and energy spread. If energies match, the speedup claim survives; if they differ, recompute speedups on matched-cycle or matched-gradient runs rather than end-to-end wall times.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim is that the GPU implementation reduces end-to-end LASSCF/CASSCF time-to-solution by 5-13x on realistic multimetallic systems. The load-bearing condition is that CPU and GPU runs are solving the same electronic-structure problem to the same tolerance. This is never directly demonstrated: no converged total energies are reported for any system, and the SI (Sec. II.B) itself states that identical inputs can take different convergence paths, with system B stuck in a local minimum until iteration 27, and concludes 'Irregular convergence patterns can distort performance metrics. Stable convergence tests are required.' The fixed-cycle unit runs in Sec. 4.C reduce but do not eliminate this problem, because CASSCF and recombination can still converge early and the number of internal SCF cycles differs across runs (system C: 37 CPU vs 51/55 GPU recombination cycles). Because the GPU path replaces JK and AO2MO kernels that change floating-point evaluation order, convergence-path divergence is expected, not hypothetical. If GPU runs happen to follow easier convergence paths or terminate at different stationary points, the wall-time ratios in Tables I-III measure a mixture of hardware speed and algorithmic path differences, not pure acceleration. The paper mentions 'testing accuracy' on polyacetylenes but presents no numerical comparison, so this gap remains unaddressed.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The manuscript reports an initial GPU-accelerated implementation of LASSCF (and, as a byproduct, CASSCF) within the mrh/PySCF framework, using density fitting and a portable C++ library (libgpu) with CUDA, SYCL, and HIP backends. The authors profile CPU-only LASSCF, identify the JK (effective potential) and AO2MO (CASSCF ERI) kernels as dominant bottlenecks, offload these to GPUs, and benchmark end-to-end convergence runs and controlled-workload 'unit' runs on Polaris (NVIDIA A100) and Aurora (Intel Max Series) nodes. They report 5–13x speedups for LASSCF on multimetallic systems with up to about 1200 atomic orbitals and an active space of (22e,40o), a 21.4x speedup for a CASSCF benchmark, and multi-GPU scaling experiments. The companion data repository provides input files, output files, and analysis scripts.","tokens_in":20889,"tokens_out":2590,"duration_ms":24389,"significance":"If the performance claims are verified, this is a useful contribution: it brings GPU acceleration to a multireference method that is otherwise severely limited for multi-metallic systems, demonstrates multi-GPU use for LASSCF, and shows performance portability to Intel GPUs without vendor-specific rewrites. The paper's strengths include detailed bottleneck profiling (Sec. 2.C), a clear description of the software design (Sec. 3), controlled-workload unit runs (Sec. 4.C), open data (ref. 83), and an honest discussion of convergence-path variability in the SI. The central claim—that end-to-end LASSCF time-to-solution is reduced by roughly one order of magnitude on realistic systems—is plausible but, as detailed below, is not yet established because the CPU and GPU runs are not directly shown to solve the same electronic-structure problem to the same tolerance.","major_comments":[{"comment":"The paper never reports a converged total-energy comparison between CPU and GPU runs. Section 4.A says polyacetylenes were used for 'testing accuracy' but no numerical results are given, and the SI (Sec. II.B) states that identical inputs can take different convergence paths, with a GPU run stuck in a local minimum until iteration 27, concluding 'Irregular convergence patterns can distort performance metrics. Stable convergence tests are required.' Since the GPU path replaces JK and AO2MO kernels that change floating-point evaluation order, convergence-path divergence is expected, not hypothetical. Therefore the wall-time ratios in Tables I and II may include algorithmic workload differences (number of LASSCF cycles, CASSCF iterations, recombination cycles) rather than pure GPU acceleration. The authors should report final converged energies (or equivalent convergence diagnostics such as final orbital gradients and CI gradients) for every CPU and GPU run in Tables I–III, and show that they reach the same stationary point to the same tolerance. Without this, the headline speedups are not fully supported.","section":"Sec. 4.A, Sec. 4.C, SI Sec. II.B"},{"comment":"The speedups are based on single runs without error bars or repeat measurements, and the authors themselves document workload variability that directly affects the reported numbers. For the system C unit run, the CPU run performs 37 recombination SCF cycles while the Polaris and Aurora runs perform 51 and 55 cycles, respectively (Sec. 4.C); Table I reports 8.0x and 10.5x speedups for system C, yet the per-cycle recombination speedup is stated to be about 8x, closer to system B. This means the apparent 10.5x figure is partly a workload artifact. The authors should provide multiple repeats (or cycle-resolved timings) for at least the systems with unstable convergence (B and C), and report speedups as mean and spread. A single run is insufficient for a performance claim whose own SI says the metric is distorted by convergence patterns.","section":"Sec. 4.C, Table I, system C"},{"comment":"The multi-GPU scaling results do not support a strong scaling claim. For LASSCF on system A with Polaris, the wall time decreases from 685 s (1 GPU) to 488 s (4 GPUs), but GPU active time drops from 47% to 26%; on Aurora, the time decreases from 722 s (1 GPU) to 565 s (4 GPUs) and then increases to 587 s at 6 GPUs. The authors correctly attribute the 6-GPU degradation to serialized accumulation, but the lack of repeat measurements makes it impossible to distinguish genuine scaling from run-to-run variability, which the SI shows is substantial for these systems. Please provide repeated scaling runs or per-phase timing breakdowns with uncertainties so that the 'fully utilize multi-GPU compute nodes' claim can be assessed.","section":"Sec. 4.D, Table III"}],"minor_comments":[{"comment":"The abstract states '5-10x in total application runtime', but Table I reports 12.6x for system B on both architectures; the body also says '7-10x' in the introduction. Please reconcile these numbers, e.g., by saying 'up to 13x' or by restricting the abstract claim to the systems summarized there.","section":"Abstract vs. Sec. 4.C, Table I"},{"comment":"The caption of Fig. 8(c) says system C has a (11e,10o) active space, but the text in Sec. 4.A describes system C as two Ni+2 centers with (8e,10o) each, giving a total (16e,20o) active space. Please correct the typo.","section":"Fig. 8(c) caption and Sec. 4.A"},{"comment":"The statement that 'most modern software, including PySCF, perform this calculation in blocks of size Nblk' would benefit from a brief explanation of how Nblk affects load balance and memory, and whether the PySCF default of 240 is optimal for the GPU versions; the authors note this as future work, which is fine.","section":"Sec. 2.D.i"},{"comment":"There is a typo in the SI: 'Iron Sulfur cluster (or sytem A)' should read 'system A'.","section":"SI Sec. II.A"},{"comment":"The phrase 'Subsection 2 2.C' should be 'Subsection 2.C', and 'atleast' should be 'at least' in the conclusions section.","section":"Sec. 4.C"}],"recommendation":"major_revision","confidential_remarks":"The stress-test concern about missing energy validation is on point and is the main reason for major revision. The authors themselves appear aware of the convergence-path issue in the SI, yet they do not supply the energy comparison needed to close it. This is fixable within the manuscript's scope by reporting final energies and repeated runs; it is not a fundamental flaw in the implementation. I also note that the manuscript's title and abstract slightly oversell multi-GPU utilization given the serialized accumulation and low GPU active times; the authors should either temper the claims or add scaling evidence."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Colleague,\n\nThis is a genuine first: a working multi-GPU LASSCF implementation, built by monkey-patching PySCF/mrh and offloading JK and AO2MO kernels to a small standalone library (libgpu) that talks CUDA, SYCL, and HIP. The authors benchmark it on realistic multimetallic systems up to ~1400 AOs and (22e,40o) active spaces and report 5-13x end-to-end speedups on NVIDIA A100s, with comparable runs on Intel Max Series GPUs. That is new and useful. The paper does the right things: it profiles where time goes, isolates individual kernels, runs capped-cycle 'unit' workloads to reduce convergence-path noise, includes the honest SI discussion where system B gets stuck in a local minimum for 27 iterations, and posts data and scripts on Zenodo. The engineering is credible and the speedups are plausible given the profiling.\n\nThe soft spot is real and named by the authors themselves: they never compare converged total energies between CPU and GPU runs. Sec. 4.A says they used polyacetylenes for 'testing accuracy' but gives no numbers. That matters because the GPU path changes floating-point evaluation order, so the two runs can take different convergence paths. The SI shows exactly that for system B, and in the unit runs the CPU and GPU runs of system C do 37 vs 51/55 recombination SCF cycles. So the wall-time ratios in Tables I-III are a mixture of hardware speedup and workload differences. The authors are up front about this; the SI even concludes 'Irregular convergence patterns can distort performance metrics.' But the paper's headline claim, time-to-solution reduction, needs the energy check to be fully supported.\n\nMinor points: the abstract says 5-10x while Table I shows 12.6x for system B and 21.4x for CASSCF on D; the conclusion says 'upto 10x' but also 'upto 30x.' Some typos (dramtic, polyacytelene, atleast). Timing tables are single runs with no error bars; for an initial port that is acceptable, but a repeated-run median would help.\n\nOverall, this is a solid, honest engineering report. The central claim is directionally correct; the missing energy comparison is a moderate gap, not a fatal flaw. It deserves a serious referee. I'd send it to peer review with a request for CPU-vs-GPU converged energies, a reconciliation of speedup numbers, and ideally repeated timings.","headline":"First credible GPU-accelerated LASSCF with real speedups on multimetallic systems, but the headline numbers need an energy-consistency check before they're fully load-bearing.","tokens_in":21459,"tokens_out":2451,"would_cite":true,"duration_ms":21441,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"GPU acceleration makes converged LASSCF multireference calculations practical for multimetallic catalysts, cutting time-to-solution by roughly 6-13x on a single node.","keywords":["GPU acceleration","LASSCF","multireference methods","density fitting","multimetallic catalysts","performance portability","Coulomb and exchange kernels","active space"],"falsifier":"Take one of the reported systems, for example the iron-sulfur cluster, and run the same converged LASSCF calculation on CPU and GPU from identical initial guesses while recording final total electronic energies and iteration counts; if the GPU run reaches the same energy through a different path with far fewer iterations, the claimed speedup would not be pure kernel acceleration.","tokens_in":20439,"feed_emoji":"⚡","tokens_out":7855,"duration_ms":66734,"temperature":0.7,"pith_summary":"The paper reports an initial GPU implementation of localized active space self-consistent field (LASSCF), a multireference method that fragments a large active space into local pieces. The implementation uses density fitting to replace four-center electron repulsion integrals with cheaper three-center Cholesky vectors, and offloads the two dominant kernels — effective Coulomb/exchange potentials (JK) and orbital-transformed integrals (AO2MO) — to multiple GPUs. On realistic iron-sulfur, MOF-node, and dinickel catalyst systems, total time-to-solution drops by roughly 6-13x for LASSCF and about 15-21x for a comparison CASSCF run, on one node with up to four NVIDIA A100 GPUs, with comparable early results on Intel Max Series GPUs. A sympathetic reader would care because multimetallic systems are exactly where multireference methods are needed and previously too slow.","feed_headline":"Multimetallic quantum chemistry up to 13x faster on GPUs","feed_subtitle":"Density fitting and multi-GPU nodes make (22e,40o) active-space catalyst calculations feasible on one node.","key_machinery":"The load-bearing mechanism is density fitting (Cholesky decomposition) plus a lightweight, portable C++ GPU library that implements two kernels. Density fitting writes the four-center two-electron integral as a contraction of three-center Cholesky vectors with the inverse of a two-center matrix, reducing memory from O($Nao^{4}$) to O(Naux $Nao^{2}$). The JK kernel builds Coulomb and exchange effective potentials by contracting Cholesky vectors with one- and two-particle density matrices; the AO2MO kernel transforms Cholesky vectors from the atomic-orbital basis to the fragment embedding basis and forms the specific integral classes the CASSCF micro-solver needs. Cholesky vectors are cached on the GPUs with a hashing scheme, transfers use pinned memory, and GPU work is launched asynchronously across all devices on a node, so the costliest operations overlap and run in parallel.","core_discovery":"The paper's central claim is that the bottleneck of LASSCF on realistic multimetallic systems is not the fragment full-CI active-space solves but a small set of linear-algebra kernels — the JK effective potentials and the AO2MO integral transformations — and that accelerating just these kernels on GPUs is enough to make converged LASSCF calculations practical at roughly 660-1380 atomic orbitals. Concretely, converged LASSCF on the iron-sulfur tetramer with a (22e,40o) active space runs in about 27 minutes with 4 GPUs versus about 3.3 hours on CPU-only (7.3x), and on a MIL-127 MOF node with 1164 orbitals and an (18e,30o) active space in about 1.4 hours versus about 17.8 hours (12.6x). The same kernels make a standalone CASSCF on an aluminum-diiron cluster run 21.4x faster, showing the acceleration is not LASSCF-specific.","pith_inferences":["If the kernel-centric strategy is as general as the CASSCF result suggests, post-LASSCF methods that reuse the same effective-potential machinery should inherit much of the speedup with little extra implementation effort.","A natural next test is whether the JK and AO2MO kernels remain the bottleneck once the exact full-CI solver moves to GPUs; the paper itself flags the CI solver and Cholesky-vector memory as future bottlenecks.","The single-node, multi-GPU design points to fragment-level distributed parallelism as the straightforward way to scale beyond one node, since fragment CASSCF tasks are independent.","The portability claim could be tested further by running the same kernels on AMD GPUs; the paper mentions that a translated HIP version exists but results are deferred."],"forward_implications":["Converged LASSCF runs on realistic catalyst models with 660-1380 atomic orbitals and active spaces up to (22e,40o) become feasible on a single multi-GPU node.","Because only the JK and AO2MO kernels are accelerated, the speedup carries over to plain CASSCF runs without extra user code changes.","As basis sets grow, the cost balance shifts further toward the accelerated kernels, so the speedup is expected to grow rather than shrink with system size.","The same code runs without tuning on NVIDIA and Intel GPUs, though multi-GPU scaling efficiency above four GPUs is not yet ideal."],"supporting_citations":[{"why":"Defines the LASSCF algorithm and its second-order orbital/CI optimization equations that the accelerated implementation drives.","marker":"[23]"},{"why":"Supplies the embedding-space Hamiltonian and effective potential expressions that the JK kernel must evaluate.","marker":"[24]"},{"why":"Introduces the Cholesky density-fitting decomposition that the whole implementation relies on to reduce integral storage and cost.","marker":"[63]"},{"why":"Derives the CASSCF orbital-optimization integral classes that the AO2MO kernel forms on GPUs.","marker":"[66]"},{"why":"Provides the companion CASSCF derivative expressions needed for the fragment micro-solver integrals.","marker":"[67]"},{"why":"The base quantum-chemistry package that supplies the SCF/CASSCF drivers and JK engine the implementation extends.","marker":"[59]"},{"why":"Demonstrates the runtime monkey-patching approach for GPU-accelerated quantum chemistry that this work adapts.","marker":"[38]"},{"why":"Shows a prior GPU-accelerated density-fitted multireference implementation, establishing feasibility and context for the present kernels.","marker":"[60]"}],"fun_headline_variants":["GPU-accelerated kernels make LASSCF practical for 1200-orbital catalysts","13x faster multimetallic quantum chemistry with multi-GPU nodes","Multireference calculations go multi-GPU: 13x speedup on catalysts","From 17.8 hours to 1.4: GPU LASSCF for multimetallic MOFs"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The CPU and GPU runs are doing essentially the same numerical work, so the wall-clock ratios measure speed rather than different convergence paths or iteration counts; the supporting information shows identical inputs can converge differently between runs.","fun_headline_variants_meta":{"raw":{"variants":["GPU-accelerated kernels make LASSCF practical for 1200-orbital catalysts","13x faster multimetallic quantum chemistry with multi-GPU nodes","Multireference calculations go multi-GPU: 13x speedup on catalysts","From 17.8 hours to 1.4: GPU LASSCF for multimetallic MOFs"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000924,"raw_usage":{"total_tokens":3941,"prompt_tokens":905,"completion_tokens":3036,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":521,"completion_tokens_details":{"reasoning_tokens":2953}},"tokens_in":521,"tokens_out":3036,"duration_ms":21836,"temperature":1.0,"reasoning_tokens":2953,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T11:58:12.136770+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take one of the reported systems, for example the iron-sulfur cluster, and run the same converged LASSCF calculation on CPU and GPU from identical initial guesses while recording final total electronic energies and iteration counts; if the GPU run reaches the same energy through a different path with far fewer iterations, the claimed speedup would not be pure kernel acceleration.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Defines the LASSCF algorithm and its second-order orbital/CI optimization equations that the accelerated implementation drives."},{"cited_title":"Koch , author A","cited_arxiv_id":null,"evidence_quote":"Introduces the Cholesky density-fitting decomposition that the whole implementation relies on to reduce integral storage and cost."},{"cited_title":"\\ Werner \\ and\\ author P","cited_arxiv_id":null,"evidence_quote":"Derives the CASSCF orbital-optimization integral classes that the AO2MO kernel forms on GPUs."},{"cited_title":"\\ Werner \\ and\\ author W","cited_arxiv_id":null,"evidence_quote":"Provides the companion CASSCF derivative expressions needed for the fragment micro-solver integrals."},{"cited_title":"Sun , author X","cited_arxiv_id":null,"evidence_quote":"The base quantum-chemistry package that supplies the SCF/CASSCF drivers and JK engine the implementation extends."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Shows a prior GPU-accelerated density-fitted multireference implementation, establishing feasibility and context for the present kernels."}],"review_version":1}