⚛️ quantum physics

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

PADO-Pauli is a GPU-accelerated framework that significantly accelerates and reduces the memory footprint of training variational quantum algorithms by compiling circuits into reusable sparse matrices for efficient batched Pauli propagation, automatic differentiation, and noise simulation.

Original authors: Hyunwoo Kim, Youngseok Lee

Published 2026-10-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Hyunwoo Kim, Youngseok Lee

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

In the race to build useful quantum computers, scientists face a paradox. The very machines they hope to build are so complex that even the world's most powerful supercomputers struggle to predict what they will do. To understand a quantum system, researchers usually try to simulate it on a classical computer, tracking the state of every single particle. But as the number of particles grows, the memory required to hold that information explodes, doubling with each new addition. A system with just a few dozen particles becomes impossible to track this way. To move forward, scientists need a different approach: a way to predict the behavior of these machines without simulating every single detail. They need a shortcut that keeps the essential physics while discarding the noise.

This is the challenge addressed by a new tool called PADO-Pauli, developed by researchers at NORMA, Inc. in Seoul. The team created a specialized software engine that runs on graphics processing units, the same powerful chips found in high-end video cards. Instead of trying to simulate the entire quantum state, PADO-Pauli focuses on the specific questions a user wants to ask the quantum computer. It works by tracking how a measurement, or an observable, changes as it moves backward through the circuit's logic gates. Imagine trying to figure out why a light turned on by tracing the electricity back from the bulb to the switch, rather than simulating the flow of every electron in the entire grid. This method, known as Pauli propagation, allows the researchers to calculate the expected outcome of a quantum experiment without needing to store the impossible amount of data required for a full simulation.

The core innovation of PADO-Pauli lies in how it handles the repetitive nature of training quantum algorithms. In many quantum applications, such as machine learning, the same circuit structure is tested thousands of times with slightly different settings. Previous methods often recalculated the entire path for every single test, wasting time and computing power. PADO-Pauli changes this by compiling the circuit once into a streamlined program. It analyzes the circuit and the measurement goal, then strips away any mathematical branches that would inevitably result in zero contribution to the final answer. This process, which the authors call zero-filtering, removes dead ends before the calculation even begins. Once this clean, sparse program is built, it can be reused instantly for hundreds or thousands of different parameter sets. The software evaluates these batches of settings simultaneously, leveraging the parallel processing power of the GPU to achieve speeds that were previously unattainable.

The results of this approach are striking. When tested against other leading simulation engines, PADO-Pauli proved to be significantly faster and more memory-efficient. On circuits with between four and twelve qubits, the new engine evaluated results up to ten times faster than a comparable GPU-based tool. Perhaps more importantly, it managed to handle larger systems that other tools could not. On a sixteen-qubit circuit, PADO-Pauli used up to 3.1 times less memory than its competitor, allowing it to complete simulations that caused the other engine to run out of memory entirely. The researchers verified that these speedups did not come at the cost of accuracy, checking their results against exact simulations on systems up to twenty-eight qubits and finding the values matched closely.

The tool is not just a theoretical exercise; it has already been applied to real-world problems. The team successfully used it to simulate a 127-qubit experiment, a scale that is currently beyond the reach of exact simulation methods. They also demonstrated its utility in training variational quantum algorithms, which are used to solve complex optimization problems and model chemical molecules. In one test, the software helped train a model to solve a graph problem known as MaxCut, finding better solutions faster than traditional methods. In another, it accurately modeled the energy states of a hydrogen molecule, a standard benchmark for quantum chemistry. The ability to train these models efficiently is crucial because it allows researchers to find the best settings for quantum computers without needing to run the physical hardware for every single trial.

While the tool is powerful, the researchers are careful to note its boundaries. The method relies on a form of approximation where less significant terms are discarded to keep the calculation manageable. This works exceptionally well for circuits with noise or those that do not spread information too widely, but it is not a universal solution for every type of quantum circuit. The accuracy depends on the specific structure of the problem being solved. However, for the specific regime of training quantum machine learning models and optimizing quantum algorithms, PADO-Pauli offers a practical and highly efficient path forward. It transforms the process of testing quantum circuits from a slow, memory-hungry slog into a rapid, batched operation, bringing the training of these complex systems closer to reality.

The development of PADO-Pauli represents a significant step in the toolkit available to quantum scientists. By combining a clever mathematical shortcut with modern hardware acceleration, the team has created a system that can handle the repetitive, data-heavy tasks required to teach quantum computers how to learn. As quantum hardware continues to grow in size, tools that can simulate and train these systems efficiently will become increasingly vital. This new engine provides a way to explore the behavior of large quantum systems and refine their algorithms, helping to bridge the gap between theoretical potential and practical application.

Technical Summary: PADO-Pauli

Problem Statement

Variational quantum algorithms (VQAs) and quantum machine learning (QML) models require the repeated evaluation of parameterized quantum circuits to compute expectation values and gradients. Classical simulation of this training loop has traditionally relied on Schrödinger picture methods (full statevector simulation), which are exact but incur memory and runtime costs exponential in the system size. While Pauli propagation offers a Heisenberg picture alternative that evolves observables rather than states, existing implementations face limitations in throughput, memory efficiency, and integration with modern machine learning workflows. Specifically, many tools re-propagate circuits for every parameter query, lack native GPU acceleration with differentiable backward passes, or do not efficiently handle batched data inputs common in QML.

Methodology

PADO-Pauli is a GPU-accelerated engine that implements the Pauli propagation surrogate (PPS) with a "single compilation, multiple evaluations" architecture. The core methodology involves separating the structural propagation of the circuit from the evaluation of specific parameter values.

Compilation and Sparse Representation:
- The engine propagates the observable through the circuit in the Heisenberg picture (reverse gate order) once.
- During propagation, Pauli strings are represented using binary symplectic bitmasks (two bits per qubit).
- When a rotation gate $R_G(\theta)$ acts on a Pauli string $P$ , the engine applies the conjugation rule: if $P$ commutes with $G$ , it passes unchanged; otherwise, it splits into $\cos(\theta)P + \sin(\theta)P'$ .
- Crucially, the engine compiles the circuit into a sequence of sparse linear maps (matrices). The rotation angles $\theta$ enter these maps only as scalar coefficients ( $\cos \theta$ and $\sin \theta$ ). The matrix structure itself is fixed after compilation, independent of the parameter values.
Truncation and Zero-Filtering:
- Truncation: To manage the exponential growth of Pauli strings, the engine employs two truncation strategies:
  - Max-weight truncation: Discards strings where the number of non-identity Pauli factors exceeds a threshold $w_{max}$ .
  - Coefficient truncation: Discards terms with coefficients below a threshold $\epsilon$ at a specific "build point" parameter vector.
- Zero-Filtering: A compile-time pass that removes any Pauli string branch that cannot contribute to the expectation value in the reference state $|0\rangle^{\otimes n}$ . Since $\langle 0|P|0\rangle = 0$ for any string containing $X$ or $Y$ , only strings in $\{I, Z\}^{\otimes n}$ survive. This pruning is exact (introduces no approximation error) and significantly reduces the working set size.
Differentiable Execution and Batching:
- The compiled program is executed within PyTorch. The sparse matrix-vector products are performed as tensor operations.
- Automatic Differentiation: The engine registers a custom vector-Jacobian product (VJP) with PyTorch. The backward pass reuses the same sparse matrices, swapping the scalar factors ( $\cos \to -\sin$ , $\sin \to \cos$ ) to compute gradients with respect to rotation angles. This avoids re-propagating the circuit or using parameter-shift rules.
- Batching: The engine supports batched evaluation of both trainable parameters and data inputs (embedding angles). It evaluates the Cartesian product of parameter and data batches in a single pass, leveraging GPU parallelism.

Key Contributions

Single Compilation, Multiple Evaluations: The circuit and observables are compiled once into a reusable program of sparse matrices. Every subsequent query (forward pass or gradient) reuses this program, amortizing the compilation cost over hundreds of training steps.
Exact Zero-Filtering: A compile-time pruning mechanism that removes non-contributing terms without approximation, reducing the evaluation working set by one to three orders of magnitude on QAOA instances.
Native Differentiability on GPU: Unlike previous engines that rely on parameter-shift re-evaluation or CPU-based backward passes, PADO-Pauli provides a native backward pass registered with PyTorch's autograd, enabling end-to-end training of hybrid quantum-classical models.
Composable Truncation: The engine supports both max-weight and coefficient truncation, allowing users to trade accuracy for computational cost.
Batched Embedding: The ability to process batches of data inputs (embedding angles) and parameters simultaneously, which is critical for training quantum machine learning models.

Results

The paper presents benchmarks comparing PADO-Pauli against cuPauliProp (NVIDIA), Qiskit pauli-prop (CPU), and PauliPropagation.jl (CPU).

Performance: On 4 to 12 qubits, PADO-Pauli evaluates up to 10 times faster than cuPauliProp on an NVIDIA A100. On a 16-qubit instance, it uses up to 3.1 times less GPU memory (74.4 GB vs. 119.8 GB peak for unfiltered forward-backward) and completes evaluations where cuPauliProp runs out of memory (OOM).
Throughput: For batched inputs, PADO-Pauli achieves throughput in the tens of thousands of evaluations per second (e.g., ~17,700 eval/s for batch size 512 on 20 qubits), significantly outperforming statevector simulators which process samples sequentially.
Accuracy: The engine's accuracy was verified against exact statevector simulations (up to 28 qubits) and density matrix simulators. Truncation errors were shown to be controllable; for example, on a 16-qubit MaxCut-QAOA instance, coefficient truncation achieved errors of $10^{-6}$ with fewer retained terms than max-weight truncation.
Scalability: The compiled program successfully handled a 127-qubit kicked Ising model (IBM Eagle lattice) with $w_{max}=8$ , matching hardware results within a deviation of 0.076 at $w_{max}=8$ .
Applications: The engine was demonstrated in:
- VQE: Accurately reproducing the H2 dissociation curve with double-precision accuracy.
- MaxCut-QAOA: Training a 15-vertex graph instance, improving the cut value from 19.57 to 20.52.
- SAFE ma-QAOA: Using a truncated PADO-Pauli surrogate to warm-start an exact optimizer, reducing the number of exact optimization steps required by 1.6x.

Significance and Claims

The paper positions PADO-Pauli as a practical toolkit specifically designed for the training regime of variational quantum algorithms and quantum machine learning, where the same circuit is queried repeatedly with gradients and batched data.

Efficiency: By decoupling the structural propagation from parameter evaluation, PADO-Pauli achieves significant speedups and memory savings compared to engines that re-propagate or lack GPU-native differentiation.
Practicality: The combination of zero-filtering, sparse tensor execution, and PyTorch integration makes it feasible to train models on systems (e.g., 16–100 qubits) that are otherwise intractable for exact simulation or slow for existing Pauli propagation tools.
Limitations: The authors modestly note that the approach is not a general-purpose simulator. Truncation is not universally safe for deep circuits with large angles and many non-Clifford gates, and the method relies on the "surrogate" assumption that the discarded coefficient mass is small. The compilation cost is a fixed upfront overhead, making it less suitable for single-query tasks.

In summary, PADO-Pauli provides a high-performance, differentiable infrastructure that enables the classical simulation of variational quantum circuits at scales and speeds previously difficult to achieve, facilitating the development and training of quantum machine learning models.