Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2605.20491

A Simple GPU-Accelerated Solver for the Schrödinger Operator with Applications to Ground States and Hamiltonian Simulation

Xinyu Liu, Xiangxiong Zhang

math.NAphysics.comp-phquant-phSubmitted May 19, 2026• Announced May 21, 2026
arXivHTMLPDF

Abstract

We extend the tensor-product direct solver from the Laplacian to the Schrödinger operator $-Δ+ V$. When the potential $V_1$ is separable, the operator $-Δ+ V_1$ is inverted or exponentiated at cost $O(N^{1+1/d})$ in $d$ dimensions via per-axis eigendecomposition. On a single NVIDIA A100 GPU, this costs less than one second for $10^9$ degrees of freedom in 3D. For non-separable potentials $V = V_1 + V_2$, the same solver provides a preconditioner $(-Δ+ V_1)^{-1}$ for the preconditioned conjugate gradient (PCG) method and a propagator for operator-splitting time integrators. For bounded $V_2$, we prove that the preconditioned operator has a bounded condition number and a clustered spectrum with at most finitely many outlier eigenvalues, independently of the mesh size, and also independently of the domain size when $V_1$ is a confining potential. This explains the mesh- and domain-independent PCG iteration counts observed in practice. We apply this method to ground state computation via inverse iteration for linear problems and via the $a_u$ gradient flow for Gross--Pitaevskii energy in 3D, and also Hamiltonian simulation via the approximated qHOP and Magnus-2 splitting methods from 3D to 9D on a single NVIDIA GH200 GPU.

Related papers

GaDE -- GPU-acceleration of time-dependent Dirac Equation for exascale

Johanne Elise Vembe, Marcin Krotkiewski, Magnar Bjørgve +2 more

Modern heterogeneous high-performance computing (HPC) systems powered by advanced graphics processing unit (GPU) architectures enable accelerating computing with unprecedented performance and scalability. Here, we present a GPU-accelerated solver for the three-dimensional (3D) time-dependent Dirac equation optimized for distributed HPC systems. The solver named GaDE is designed to simulate the electron dynamics in atoms induced by electromagnetic fields in the relativistic regime. It combines MPI with CUDA/HIP to target both NVIDIA and AMD GPU architectures. We discuss our implementation strategies in which most of the computations are carried out on GPUs, taking advantage of the GPU-aware MPI feature to optimize communication performance. We evaluate GaDE on the pre-exascale supercomputer LUMI, powered by AMD MI250X GPUs and HPE's Slingshot interconnect. Single-GPU performance on NVIDIA A100, GH200, and AMD MI250X shows comparable performance between A100 and MI250X in compute and memory bandwidth, with GH200 delivering higher performance. Weak scaling on LUMI demonstrates exceptional scalability, achieving 85% parallel efficiency across 2048 GPUs, while strong scaling delivers a 16x speedup on 32 GPUs - 50% efficiency for a communication-intensive, time-dependent Dirac equation solver. These results demonstrate GaDE's high scalability, making it suitable for exascale systems and enabling predictive simulations for ultra-intense laser experiments probing relativistic quantum effects.

physics.comp-phCross-listedarXiv:2512.21697•Dec 26, 2025

A Python GPU-accelerated solver for the Gross-Pitaevskii equation and applications to many-body cavity QED

Lorenzo Fioroni, Luca Gravina, Justyna Stefaniak +4 more

TorchGPE is a general-purpose Python package developed for solving the Gross-Pitaevskii equation (GPE). This solver is designed to integrate wave functions across a spectrum of linear and non-linear potentials. A distinctive aspect of TorchGPE is its modular approach, which allows the incorporation of arbitrary self-consistent and time-dependent potentials, e.g., those relevant in many-body cavity QED models. The package employs a symmetric split-step Fourier propagation method, effective in both real and imaginary time. In our work, we demonstrate a significant improvement in computational efficiency by leveraging GPU computing capabilities. With the integration of the latter technology, TorchGPE achieves a substantial speed-up with respect to conventional CPU-based methods, greatly expanding the scope and potential of research in this field.

arXiv:2404.14401•SciPost Physics Codebases•Nov 6, 2024•8 citations

Quantum-accelerated conjugate gradient method via spectral initialization

Shigetora Miyashita, Yoshi-aki Shimada

Solving large-scale linear systems problems is a cornerstone in scientific and industrial computing. Classical iterative solvers face increasing difficulty as the number of unknowns becomes large, while fully quantum linear solvers require fault-tolerant resources that remain far beyond near-term feasibility. Here we propose a quantum-accelerated conjugate gradient (QACG) method in which a fault-tolerant quantum algorithm is used exclusively to construct a spectrally informed initial guess for a classical conjugate gradient (CG) solver. We estimate the total runtime and resource requirements of an integrated quantum-HPC platform for the 3D Poisson equation. A central feature of QACG is the controllable decomposition of the condition number between the quantum and the classical solver, enabling flexible allocation of computational effort. Under explicit architectural assumptions, we identify regimes in which QACG yields a runtime advantage over purely classical approaches while requiring substantially fewer quantum resources than end-to-end quantum linear solvers. These results illustrate a concrete pathway toward the scientific and industrial use of early-stage fault-tolerant quantum computing and point to a integrated paradigm in which quantum devices act as accelerators within high-performance computing workflows.

quant-pharXiv:2602.09696•Feb 11, 2026•0 citations

An HPC Approach to Accelerate Tensor Computations in Quantum Physics

Markus Hellgren

Quantum systems grow in complexity so rapidly that even modest models become difficult to simulate, creating a strong need for methods that can handle high-dimensional data. In this work, we investigate a Jacobi-type tensor algorithm in this context and develop a CUDA implementation that supports tensors of arbitrary order on a single GPU. We test the implementation on NVIDIA H100 hardware and show that the algorithm converges correctly for diagonalizable tensors up to nine dimensions, with runtime increasing in a predictable way as tensor order grows.We also apply the method to Heisenberg spin chains and show that it can operate on tensors corresponding to systems of up to N=15 spins, that is, tensors with up to 30 dimensions, which correspond to Hamiltonian matrices of dimension 2N by 2N (for N=15, this is 32768 by 32768). In addition, we demonstrate that the implementation can be used to approximate eigenvalues of the corresponding Hamiltonian matrices. These results confirm that the method scales to high-dimensional problems and is applicable to spectral analysis in quantum physics settings.

•Jan 1, 2026•0 citations

Parallel iQCC Enables 200 Qubit Scale Quantum Chemistry on Accelerated Computing Platforms Surpassing Classical Benchmarks in Ruthenium Catalysts

Seyyed Mehdi Hosseini Jenab, Brandon Henderson, Scott N. Genin

We introduce a parallel, GPU-accelerated implementation of the iterative qubit coupled cluster (iQCC) method that overcomes the exponential growth of the transformed Hamiltonian -- the principal bottleneck for classical emulation of quantum chemistry circuits. By distributing Hamiltonian terms across compute nodes via bit-wise partitioning and offloading Pauli contractions to GPUs, we achieve speedups exceeding two orders of magnitude over the serial CPU approach. Crucially, iQCC confines the variational evolution to a classically simulable operator subspace by selecting entanglers exclusively from the Direct Interaction Space, which guarantees non-vanishing energy gradients at every iteration and thereby naturally avoids the barren-plateau phenomenon that renders highly expressive quantum circuits untrainable. Leveraging these algorithmic and hardware advances, we simulate electronic-structure Hamiltonians for industrially relevant ruthenium catalysts in the 100--124 qubit regime, completing full ground-state calculations on NVIDIA GPUs in the ranges of 1.2 - 45 hrs and surpassing the accuracy of Density Matrix Renormalization Group. These results effectively de-quantize a significant portion of the NISQ roadmap: quantum advantage for chemistry is often assumed to emerge beyond ${\sim}50$ qubits, yet our work demonstrates that this frontier lies significantly further -- potentially past 200 qubits -- reshaping expectations for where genuine quantum advantage may first appear.

quant-pharXiv:2603.08883•Mar 11, 2026•0 citations

PADO-Pauli: A GPU-Accelerated Implementation of Pauli Propagation

Hyunwoo Kim, Youngseok Lee

Variational quantum algorithms utilize parameterized circuits many times during training, at new parameter values, over batches of data, and with gradients. Pauli propagation approximates the expectation values of such circuits classically by evolving the observable in the Heisenberg picture as a truncated sum of Pauli strings. We present PADO-Pauli, a GPU engine for Pauli propagation that compiles a circuit and its observables once into sparse matrices in which each rotation angle contributes only a cosine and a sine factor, so every later evaluation reuses the compiled program. It evaluates batches of parameters and data inputs embedded as rotation angles. By default its gradients come from a vector-Jacobian product registered with PyTorch's automatic differentiation, so they flow through the angles to any classical layer that produces them. PADO-Pauli also provides truncation by Pauli weight and coefficient size, and noise channels. Zero-filtering removes terms that do not contribute to an expectation value in the all-zero reference state and makes the batched forward pass about 1.5 times faster. Compared to cuPauliProp on an NVIDIA A100, PADO-Pauli evaluates up to 10 times faster on 4 to 12 qubits and uses up to 3.1 times less memory on 16 qubits. We check its accuracy against exact statevector simulation up to 28 qubits. These features make PADO-Pauli a practical toolkit for training variational quantum algorithms, including quantum machine learning models.

quant-pharXiv:2610.17755•Oct 14, 2026•0 citations
We extend the tensor-product direct solver from the Laplacian to the Schrödinger operator −Δ+V-Δ+ V−Δ+V. When the potential V1V_1V1​ is separable, the operator −Δ+V1-Δ+ V_1−Δ+V1​ is inverted or exponentiated at cost O(N1+1/d)O(N^{1+1/d})O(N1+1/d) in ddd dimensions via per-axis eigendecomposition. On a single NVIDIA A100 GPU, this costs less than one second for 10910^9109 degrees of freedom in 3D. For non-separable potentials V=V1+V2V = V_1 + V_2V=V1​+V2​, the same solver provides a preconditioner (−Δ+V1)−1(-Δ+ V_1)^{-1}(−Δ+V1​)−1 for the preconditioned conjugate gradient (PCG) method and a propagator for operator-splitting time integrators. For bounded V2V_2V2​, we prove that the preconditioned operator has a bounded condition number and a clustered spectrum with at most finitely many outlier eigenvalues, independently of the mesh size, and also independently of the domain size when V1V_1V1​ is a confining potential. This explains the mesh- and domain-independent PCG iteration counts observed in practice. We apply this method to ground state computation via inverse iteration for linear problems and via the aua_uau​ gradient flow for Gross--Pitaevskii energy in 3D, and also Hamiltonian simulation via the approximated qHOP and Magnus-2 splitting methods from 3D to 9D on a single NVIDIA GH200 GPU.
Modern heterogeneous high-performance computing (HPC) systems powered by advanced graphics processing unit (GPU) architectures enable accelerating computing with unprecedented performance and scalability. Here, we present a GPU-accelerated solver for the three-dimensional (3D) time-dependent Dirac equation optimized for distributed HPC systems. The solver named GaDE is designed to simulate the electron dynamics in atoms induced by electromagnetic fields in the relativistic regime. It combines MPI with CUDA/HIP to target both NVIDIA and AMD GPU architectures. We discuss our implementation strategies in which most of the computations are carried out on GPUs, taking advantage of the GPU-aware MPI feature to optimize communication performance. We evaluate GaDE on the pre-exascale supercomputer LUMI, powered by AMD MI250X GPUs and HPE's Slingshot interconnect. Single-GPU performance on NVIDIA A100, GH200, and AMD MI250X shows comparable performance between A100 and MI250X in compute and memory bandwidth, with GH200 delivering higher performance. Weak scaling on LUMI demonstrates exceptional scalability, achieving 85% parallel efficiency across 2048 GPUs, while strong scaling delivers a 16x speedup on 32 GPUs - 50% efficiency for a communication-intensive, time-dependent Dirac equation solver. These results demonstrate GaDE's high scalability, making it suitable for exascale systems and enabling predictive simulations for ultra-intense laser experiments probing relativistic quantum effects.
TorchGPE is a general-purpose Python package developed for solving the Gross-Pitaevskii equation (GPE). This solver is designed to integrate wave functions across a spectrum of linear and non-linear potentials. A distinctive aspect of TorchGPE is its modular approach, which allows the incorporation of arbitrary self-consistent and time-dependent potentials, e.g., those relevant in many-body cavity QED models. The package employs a symmetric split-step Fourier propagation method, effective in both real and imaginary time. In our work, we demonstrate a significant improvement in computational efficiency by leveraging GPU computing capabilities. With the integration of the latter technology, TorchGPE achieves a substantial speed-up with respect to conventional CPU-based methods, greatly expanding the scope and potential of research in this field.
Solving large-scale linear systems problems is a cornerstone in scientific and industrial computing. Classical iterative solvers face increasing difficulty as the number of unknowns becomes large, while fully quantum linear solvers require fault-tolerant resources that remain far beyond near-term feasibility. Here we propose a quantum-accelerated conjugate gradient (QACG) method in which a fault-tolerant quantum algorithm is used exclusively to construct a spectrally informed initial guess for a classical conjugate gradient (CG) solver. We estimate the total runtime and resource requirements of an integrated quantum-HPC platform for the 3D Poisson equation. A central feature of QACG is the controllable decomposition of the condition number between the quantum and the classical solver, enabling flexible allocation of computational effort. Under explicit architectural assumptions, we identify regimes in which QACG yields a runtime advantage over purely classical approaches while requiring substantially fewer quantum resources than end-to-end quantum linear solvers. These results illustrate a concrete pathway toward the scientific and industrial use of early-stage fault-tolerant quantum computing and point to a integrated paradigm in which quantum devices act as accelerators within high-performance computing workflows.
Quantum systems grow in complexity so rapidly that even modest models become difficult to simulate, creating a strong need for methods that can handle high-dimensional data. In this work, we investigate a Jacobi-type tensor algorithm in this context and develop a CUDA implementation that supports tensors of arbitrary order on a single GPU. We test the implementation on NVIDIA H100 hardware and show that the algorithm converges correctly for diagonalizable tensors up to nine dimensions, with runtime increasing in a predictable way as tensor order grows.We also apply the method to Heisenberg spin chains and show that it can operate on tensors corresponding to systems of up to N=15 spins, that is, tensors with up to 30 dimensions, which correspond to Hamiltonian matrices of dimension 2N by 2N (for N=15, this is 32768 by 32768). In addition, we demonstrate that the implementation can be used to approximate eigenvalues of the corresponding Hamiltonian matrices. These results confirm that the method scales to high-dimensional problems and is applicable to spectral analysis in quantum physics settings.
We introduce a parallel, GPU-accelerated implementation of the iterative qubit coupled cluster (iQCC) method that overcomes the exponential growth of the transformed Hamiltonian -- the principal bottleneck for classical emulation of quantum chemistry circuits. By distributing Hamiltonian terms across compute nodes via bit-wise partitioning and offloading Pauli contractions to GPUs, we achieve speedups exceeding two orders of magnitude over the serial CPU approach. Crucially, iQCC confines the variational evolution to a classically simulable operator subspace by selecting entanglers exclusively from the Direct Interaction Space, which guarantees non-vanishing energy gradients at every iteration and thereby naturally avoids the barren-plateau phenomenon that renders highly expressive quantum circuits untrainable. Leveraging these algorithmic and hardware advances, we simulate electronic-structure Hamiltonians for industrially relevant ruthenium catalysts in the 100--124 qubit regime, completing full ground-state calculations on NVIDIA GPUs in the ranges of 1.2 - 45 hrs and surpassing the accuracy of Density Matrix Renormalization Group. These results effectively de-quantize a significant portion of the NISQ roadmap: quantum advantage for chemistry is often assumed to emerge beyond ∼50{\sim}50∼50 qubits, yet our work demonstrates that this frontier lies significantly further -- potentially past 200 qubits -- reshaping expectations for where genuine quantum advantage may first appear.
Variational quantum algorithms utilize parameterized circuits many times during training, at new parameter values, over batches of data, and with gradients. Pauli propagation approximates the expectation values of such circuits classically by evolving the observable in the Heisenberg picture as a truncated sum of Pauli strings. We present PADO-Pauli, a GPU engine for Pauli propagation that compiles a circuit and its observables once into sparse matrices in which each rotation angle contributes only a cosine and a sine factor, so every later evaluation reuses the compiled program. It evaluates batches of parameters and data inputs embedded as rotation angles. By default its gradients come from a vector-Jacobian product registered with PyTorch's automatic differentiation, so they flow through the angles to any classical layer that produces them. PADO-Pauli also provides truncation by Pauli weight and coefficient size, and noise channels. Zero-filtering removes terms that do not contribute to an expectation value in the all-zero reference state and makes the batched forward pass about 1.5 times faster. Compared to cuPauliProp on an NVIDIA A100, PADO-Pauli evaluates up to 10 times faster on 4 to 12 qubits and uses up to 3.1 times less memory on 16 qubits. We check its accuracy against exact statevector simulation up to 28 qubits. These features make PADO-Pauli a practical toolkit for training variational quantum algorithms, including quantum machine learning models.