⚛️ quantum physics

phase2: Full-State Vector Simulation of Quantum Time Evolution at Scale

This paper presents a highly scalable full-state vector simulation algorithm and software implementation that leverages up to 16,384 CPU cores and 512 NVIDIA H100 GPUs to efficiently simulate quantum time evolution, demonstrating significant performance gains over existing libraries and enabling precise Trotter error analysis for 40-qubit quantum chemistry problems.

Original authors: Marek Miller, Jakob Günther, Freek Witteveen, Matthew S. Teynor, Mihael Erakovic, Markus Reiher, Gemma C. Solomon, Matthias Christandl

Published 2026-07-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Marek Miller, Jakob Günther, Freek Witteveen, Matthew S. Teynor, Mihael Erakovic, Markus Reiher, Gemma C. Solomon, Matthias Christandl

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Quantum Playground and the Ultimate Stopwatch

Imagine a world where computers don't just crunch numbers one by one, but explore a vast, shimmering landscape of possibilities all at once. This is the realm of quantum computing. Instead of a simple light switch that is either off or on, a quantum bit (or "qubit") is like a spinning coin that is both heads and tails simultaneously. When you have just a few of these spinning coins, a regular computer can keep track of them. But as you add more coins, the number of possible states explodes. With 40 coins, the number of possibilities is so huge that it would take a library of books larger than the entire Earth just to write them all down.

Because building these magical quantum machines is incredibly difficult and expensive, scientists need a way to test them before they are finished. They use "classical simulators"—super-powerful regular computers that try to mimic what a quantum computer would do. Think of it like a flight simulator for pilots; before a real plane takes off, you test the software to see if it crashes. However, simulating a quantum computer is like trying to record a movie of every single atom in a hurricane at the same time. It requires massive amounts of memory and processing power. The big question scientists have been asking is: "How big a quantum system can we actually simulate on our best supercomputers, and how accurate are our predictions?"

The Paper: A Supercharged Simulator for the Quantum Age

In this paper, a team of researchers introduces a new, highly optimized software tool called phase2. Think of phase2 as a high-speed, super-efficient camera designed specifically to film the complex dance of quantum particles. While other simulators are like standard cameras that might struggle to keep up with a fast-moving dancer, phase2 is built to capture every single step of the dance, even when the dancer is spinning at incredible speeds.

The researchers focused on a specific type of quantum movement called "Pauli rotations." If you imagine a quantum state as a giant, multi-dimensional Rubik's Cube, these rotations are the specific twists and turns the cube makes. The team realized that by focusing on these specific twists, they could build a much faster engine. They didn't just write code; they built a system that can run on thousands of computer processors at once, splitting the giant Rubik's Cube into tiny pieces and handing each piece to a different worker (a CPU core or a GPU) to solve simultaneously.

What they found:
The team put phase2 to the test on some of the world's most powerful supercomputers. They managed to simulate a quantum system with 40 qubits using 512 NVIDIA H100 GPUs and 32 terabytes of memory. To put that in perspective, 32 terabytes is enough memory to store millions of high-definition movies. They also ran simulations on 16,384 CPU cores.

The results were impressive. When they compared phase2 to other top-tier simulation software (like QuEST), phase2 was 10 to 100 times faster for large tasks. In the most extreme test case, it was over 800 times faster. This speedup is crucial because it allows scientists to simulate larger systems and run more tests in the same amount of time.

The Big Experiment: Checking the "Trotter" Error
One of the main reasons to simulate these systems is to check the accuracy of quantum algorithms used in chemistry. Imagine you want to predict how a drug molecule interacts with a protein. You can't just guess; you need to simulate the molecule's energy. A common method to do this is called "Trotterization," which breaks a long, complex journey into many tiny steps. However, every time you take a tiny step, you introduce a tiny bit of error (like a GPS that is slightly off every mile).

The researchers used phase2 to simulate a real-world chemical problem: a ruthenium-based drug complex (NKP-1339) interacting with a protein. They simulated the time evolution of this system with up to 40 qubits (representing 20 orbitals). By running these simulations, they could measure exactly how much error the "Trotter" method introduced.

The Surprise:
The team discovered that the error bounds (the "worst-case scenario" predictions) used by mathematicians are often extremely conservative. In their simulations, the actual error was about 100 times smaller than the theoretical upper bounds suggested. This is a big deal because it suggests that quantum computers might be able to solve these chemistry problems with fewer resources and less complexity than previously thought. The "worst-case" fears might be overblown, and the path to useful quantum chemistry might be clearer than we expected.

How they did it:
The secret sauce of phase2 was a clever trick involving how they organized the data. Instead of treating every rotation as a unique, difficult task, they found a way to group similar rotations together. Imagine if you had to move 1,000 boxes, and 500 of them were identical. Instead of moving them one by one, you could move them all at once. phase2 does this mathematically, reducing the amount of data that needs to be shuffled between the thousands of processors. This "grouping" strategy is what allowed them to achieve such massive speedups.

The Bottom Line:
This paper doesn't claim to have built a perfect quantum computer or solved all of chemistry. Instead, it provides a powerful new tool (phase2) that lets scientists simulate quantum systems with unprecedented scale and precision. By showing that the errors in these simulations are much smaller than the strict theoretical limits, the authors suggest that we might be able to run useful quantum chemistry experiments on future quantum hardware sooner and more reliably than the conservative math predicted. It's a reminder that sometimes, the "impossible" is just a matter of finding a faster way to count.

Technical Summary: Full-State Vector Simulation of Quantum Time Evolution at Scale

Problem Statement

The field of quantum computation is approaching an era where practical quantum computations may outperform classical hardware. However, validating these computations and benchmarking quantum advantage requires optimized classical high-performance simulators. While approximate methods (e.g., tensor networks, stabilizer decompositions) exist, they introduce uncontrolled errors or scale exponentially, making them unsuitable for rigorous validation of unknown errors in quantum algorithms. Full-state vector simulation, which stores all non-zero amplitudes of a quantum state, offers numerical precision but suffers from exponential memory scaling ( $2^n$ for $n$ qubits). Existing simulators (e.g., Qiskit, QuEST, cuQuantum) struggle to efficiently handle large-scale, distributed simulations of specific circuit structures common in quantum chemistry and physics, particularly those involving sequences of Pauli rotations.

Methodology

The authors present phase2, a full-state vector simulation algorithm and software implementation designed for High-Performance Computing (HPC) environments. The method targets the simulation of time evolution under Hamiltonians represented as linear combinations of Pauli operators, a structure ubiquitous in quantum chemistry (e.g., VQE, ADAPT-VQE) and optimization (e.g., QAOA).

Core Algorithm and Optimizations

The simulator represents the $n$ -qubit state $|\psi\rangle$ as a contiguous array of $2^n$ complex amplitudes. The algorithm applies unitaries of the form $e^{i\phi \tilde{P}}$ , where $\tilde{P}$ is a Pauli string. Key optimizations include:

Distributed Memory Architecture: The state array is divided evenly among $M = 2^m$ MPI tasks (CPU cores or GPUs). The Hilbert space is split into "lower" qubits (local to each task) and "upper" qubits (distributed across tasks).
Efficient Pauli Rotation Implementation:
- Local Operations: Pauli strings acting on lower qubits are represented as two 64-bit integers. Their action is computed using minimal logical instructions (AND, XOR, bit parity), making processing speed comparable to memory access time.
- Distributed Operations: Operations involving upper qubits require data exchange between MPI tasks. The authors exploit the structure of Pauli rotations ( $e^{i\phi \tilde{P}} = \cos\phi I + i\sin\phi \tilde{P}$ ) to reduce distributed updates to pairwise exchanges of local array partitions.
Grouping of Rotations (Eq. 1): A critical optimization groups $L$ Pauli rotations sharing a common suffix $\tilde{Q}$ on the upper qubits. Using the identity:
$\prod_{l=1}^L e^{i\phi_l \tilde{P}_l \otimes \tilde{Q}} = \left(\prod_{l=1}^L e^{i\phi_l \tilde{P}_l} \otimes \frac{I + \tilde{Q}}{2}\right) + \left(\prod_{l=1}^L e^{-i\phi_l \tilde{P}_l} \otimes \frac{I - \tilde{Q}}{2}\right)$
This allows multiple rotations to be applied with a single pairwise data exchange between MPI tasks, drastically reducing communication overhead.
Hardware Implementation: The software is written in standard C with MPI for inter-process communication and HDF5 for I/O. The GPU version utilizes custom CUDA kernels optimized for the NVIDIA Hopper architecture (sm 90a), employing the CUDA Unified Memory Model for direct GPU-to-GPU communication.

Experimental Setup

The authors applied phase2 to simulate Hamiltonian dynamics for a ruthenium complex (NKP-1339) in a drug-protein binding pocket.

Hamiltonian Preparation: The system was modeled using a hybrid QM/QM/MM embedding protocol. Active orbital spaces ranging from 5 to 20 orbitals (10 to 40 qubits) were selected. The Hamiltonians contained up to ~229,000 terms.
Simulation Strategy: To manage the large number of terms, a partially randomized product formula was used. High-weight terms were treated deterministically, while low-weight terms were sampled randomly.
Hardware: Simulations were run on two HPC facilities:
- Euler (ETH Zürich): Up to 16,384 AMD EPYC CPU cores and 8 TB memory (used for 36-qubit simulations).
- Gefion (DCAI): Up to 512 NVIDIA H100 GPUs across 64 DGX nodes and 32 TB memory (used for 40-qubit simulations).

Key Results

Scalability and Performance

Weak Scaling: The simulation speed (rotations per second per core) scales inversely proportional to the problem size ( $2^n$ ), indicating efficient state distribution up to the largest simulated systems.
Strong Scaling: For fixed problem sizes, increasing resources yields near-linear speedup on log-log scales.
Comparison with QuEST: phase2 significantly outperforms the QuEST library (version 3.7.0).
- For single rotations ( $L=1$ ), speedups range from 1x to 10x.
- For grouped rotations ( $L=100$ ), speedups range from 10x to over 800x (e.g., 801.95x for 29 qubits on 8 GPUs).
- The performance gap is attributed to phase2's specific optimizations for grouped Pauli rotations and efficient multi-GPU synchronization, which QuEST lacks.

Trotter Error Analysis

The primary scientific application was to empirically bound the Trotter error ( $C_{gs}$ ) for Hamiltonian simulation in quantum chemistry.

Empirical vs. Theoretical Bounds: The study computed the Trotter error factor $C_{gs}$ for systems up to 32 qubits (16 orbitals). The empirically derived values were found to be approximately 100 times smaller than the rigorous analytical upper bounds.
Implication: This suggests that the cost estimates for quantum algorithms based on rigorous bounds are overly conservative.
Large-Scale Validation: The authors successfully simulated time evolution for a 40-qubit system (20 orbitals) using 512 H100 GPUs. While full phase estimation was computationally infeasible at this scale, the simulation of time evolution produced non-zero, physically consistent amplitudes, validating the correctness of the implementation for the largest analyzed case.

Significance and Claims

The paper claims that phase2 represents a significant advancement in classical simulation capabilities for quantum time evolution:

Benchmarking Capability: It provides a tool for rigorous benchmarking of quantum algorithms and approximate classical simulators by offering numerical precision without the errors inherent in approximate methods.
Scalability: It demonstrates that full-state vector simulation can be extended to 40 qubits using modern HPC resources (32 TB RAM, 512 GPUs), a regime previously inaccessible for exact simulations of complex chemical Hamiltonians.
Optimization of Quantum Chemistry Algorithms: By empirically showing that Trotter errors are significantly lower than theoretical bounds, the work suggests that the resource requirements for quantum chemistry simulations (specifically ground-state energy estimation) may be lower than currently predicted by worst-case analysis.
Software Contribution: The release of phase2 (open-source under BSD-3-Clause) and the associated data provides a specialized, high-performance library for simulating circuits dominated by Pauli rotations, filling a gap between general-purpose simulators and the specific needs of variational and Hamiltonian simulation algorithms.

The authors conclude that while the number of qubits for state vector simulation remains limited by exponential scaling, optimized implementations like phase2 are crucial tools for validating quantum algorithms and exploring the boundaries of quantum advantage in the near term.