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:2610.17755

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

Hyunwoo Kim, Youngseok Lee

quant-phcs.ETcs.MSSubmitted Oct 13, 2026• Announced Oct 14, 2026• 0 citations
arXivHTMLPDF

Abstract

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.

AI Summary

Pauli propagation approximates circuit expectation values by evolving observables as truncated Pauli sums. This paper addresses repeated evaluations during variational optimization and quantum machine learning, where parameters and embedded data change but circuit structure remains fixed. PADO-Pauli compiles circuits and observables into per-gate sparse maps, separating fixed structure from angle-dependent $\cos\theta$ and $\sin\theta$ factors. Evaluation supports GPU batching and a custom vector–Jacobian product integrated with PyTorch. Compilation includes Pauli-weight truncation, optional coefficient truncation at a fixed build point, and exact backward pruning of branches that cannot contribute in $|0\rangle^{\otimes n}$. Depolarizing and amplitude-damping channels are supported. On NVIDIA A100 benchmarks, warm evaluations are up to $10.1\times$ faster than cuPauliProp on 4–12-qubit instances. At 16 qubits and $w_{\max}=6$, forward-plus-backward memory occupancy is $3.1\times$ smaller, although cuPauliProp uses complex rather than real coefficients. An internal ablation attributes approximately $1.5\times$ batched-forward acceleration to zero-filtering. Exact statevector checks reach 28 qubits; on small-angle QAOA instances, $w_{\max}=5$ gives absolute observable errors below $9.74\times10^{-4}$. Truncation accuracy remains instance-dependent: a random-circuit test reaches worst-case error $0.204$ at 20 qubits with $w_{\max}=9$. Compilation and initial backward-cache construction impose upfront costs, coefficient-truncated programs remain tied to their build point, and branching can exhaust memory. The 127-qubit kicked-Ising demonstration lacks an exact reference; apparent convergence under relaxed truncation can be misleading. The paper reports no new general simulation guarantee.

Little sign of AI-generated textIncremental

Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.

Comments
42 pages, 13 figures, 10 tables. Code available at https://github.com/Norma-Q/PADO-Pauli

Related papers

Backpropagating Pauli Propagation

Sheng-Hsuan Lin, Etienne Granet, Kevin Hémery +1 more

We develop a backpropagation algorithm for evaluating parameter gradients in quantum circuits using Pauli propagation simulation. The method has computational complexity comparable to that of standard sparse Pauli simulation techniques, while producing gradients whose accuracy is of the same order as the corresponding observable expectation values. By exploiting the reversibility of quantum circuits, the algorithm reduces the memory cost by a factor of $\mathcal{O}(n_\text{param})$ compared with conventional reverse-mode automatic differentiation, where $n_\text{param}$ denotes the number of parameters in the circuit. Compared with finite difference methods, the algorithm is $\mathcal{O}(n_\text{param})$ more efficient in function evaluations. These features enable efficient and accurate classical optimization of quantum circuits for applications such as state preparation and time-evolution compression, while also allowing operator-complexity measures such as the operator stabilizer Rényi entropy to be monitored and regularized during optimization. We demonstrate the method by optimizing low-energy state-preparation circuits for transverse-field Ising models in one, two, and three dimensions and for the three-dimensional Heisenberg model, and by compressing two-dimensional time-evolution circuits.

quant-pharXiv:2607.15184•Jul 17, 2026•5 citations

Symbolic Pauli Propagation for Gradient-Enabled Pre-Training of Quantum Circuits

Saverio Monaco, Jamal Slim, Florian Rehm +2 more

Quantum Machine Learning models typically require expensive on-chip training procedures and often lack efficient gradient estimation methods. By employing Pauli propagation, it is possible to derive a symbolic representation of observables as analytic functions of a circuit's parameters. Although the number of terms in such functional representations grows rapidly with circuit depth, suitable choices of ansatz and controlled truncations on Pauli weights and trigonometric degree components yield accurate yet tractable estimators of the target observables. With the right ansatz design, this approach can be extended to system sizes beyond the reach of classical statevector simulation, enabling scalable training for larger quantum systems. This also enables a form of classical pre-training through gradient-based optimization prior to deployment on quantum hardware. The proposed approach is demonstrated on the Variational Quantum Eigensolver for obtaining the ground state of the ANNNI spin model on 32 qubits, showing that accurate results can be achieved with a scalable and computationally efficient procedure.

quant-pharXiv:2512.16674•Dec 19, 2025•5 citations

Classical Pre-Training of Large Shallow Parametrized Quantum Circuits through Pauli Propagation and deployment on Quantum Hardware

Saverio Monaco, Jamal Slim, Ran Xue +2 more

Scaling parametrized quantum circuits to a larger number of qubits is a central challenge in Quantum Machine Learning: gradient estimation via the parameter-shift rule quickly becomes prohibitively expensive, while gradient-free optimizers offer limited convergence guarantees. We apply the Pauli propagation framework to a broad class of Quantum Machine Learning problems in which the loss is expressed as a function of expectation values of the circuit's observables, while keeping the relevant quantity of interest, such as the quantum state or its samples, classically intractable to compute. By propagating the observables backward through the circuit, we obtain an explicit parametric expression for the loss that can be minimized entirely on classical hardware. We also present complementary strategies to make propagation tractable at large scale, including weight-based and degree-based truncations and pruning heuristics. We demonstrate the approach on two benchmarks run on 64-qubit circuits: Variational Quantum Eigensolver on a two-dimensional Ising model, and training of a discrete-type generative model for binary images. In both cases, the classically pre-trained parameters are deployed on the IBM quantum processor ibm_berlin. For generative learning, we additionally show that the circuits considered here require substantially fewer parametrized gates than IQP-style ansätze, reducing transpilation overhead and making deployment on current quantum hardware feasible.

quant-pharXiv:2610.32571•Oct 26, 2026•0 citations

A High-Performance Pauli-Algebra Framework for Large-Scale Quantum Simulations

Xiaopeng Li, Zhijie Sun, Yi Fan +3 more

Efficient manipulation of Pauli-algebraic objects is a key bottleneck in the classical emulation and benchmarking of quantum algorithms for chemistry and many-body physics. This bottleneck appears in Hamiltonian construction, variational ansatz preparation, expectation-value and gradient evaluation, and real-time propagation, all of which require repeated Pauli-algebra operations. Here, we present a high-performance Pauli-algebra framework tailored to quantum many-body and quantum-chemical simulations. The framework combines compact binary symplectic encoding, canonical coefficient reduction, and grouped sparse operator representations that exploit shared bit-flip patterns among Pauli strings. The resulting Julia/C\texttt{++} implementation accelerates Pauli multiplication, Hamiltonian construction, and operator--state multiplication in sparse and symmetry-adapted many-electron spaces. Benchmarks demonstrate efficient Hamiltonian construction, large-active-space VQE and ADAPT-VQE calculations, and real-time variational dynamics on modern multicore CPU and GPU architectures. These results show that structure-aware Pauli-algebra engines provide a scalable classical backend for developing and benchmarking quantum algorithms in quantum chemistry and many-body simulation.

quant-pharXiv:2606.28952•Jun 30, 2026•1 citation

Generative quantum extreme learning machines

Marcin Płodzień

Training the circuit of a quantum generative model is hampered by barren plateaus, where gradients vanish exponentially with the number of qubits. In the present work we propose a generative protocol based on the paradigm of quantum extreme learning machines, in which the circuit is never trained. A random latent vector is encoded into a quantum state, evolved with a fixed unitary and measured, and only a linear output layer is trained. The encoding of the latent variable determines the functions available to the model, while the unitary decides which combinations of them are seen by the trained layer. With the help of Pauli propagation we show that for a Clifford unitary each feature is a single product of sines and cosines of the encoded angles, so that a Clifford circuit, even a strongly entangling one, does not create new functions. Doping the circuit with $T$ gates mixes these products and changes the nonstabilizerness of the state, but the space of functions remains the one fixed by the encoding. For brickworks of Haar-random two-qubit gates the features are no longer single products, and their variation with the latent variable decreases with the depth of the circuit. For the proposed encoding and for one- and two-dimensional distributions, generated both from expectation values and from single measurements, neither the entanglement produced by a Clifford reservoir nor the additional nonstabilizerness of Haar-random brickworks systematically improves the generator, and a reservoir with no gates at all is competitive with entangling circuits.

quant-pharXiv:2610.37116•Oct 28, 2026•0 citations

GPU-Accelerated Quantum Simulation: Empirical Backend Selection, Gate Fusion, and Adaptive Precision

Poornima Kumaresan, Pavithra Muruganantham, Lakshmi Rajendran +1 more

Classical simulation of quantum circuits remains indispensable for algorithm development, hardware validation, and error analysis in the noisy intermediate-scale quantum (NISQ) era. However, state-vector simulation faces exponential memory scaling, with an n-qubit system requiring O(2^n) complex amplitudes, and existing simulators often lack the flexibility to exploit heterogeneous computing resources at runtime. This paper presents a GPU-accelerated quantum circuit simulation framework that introduces three contributions: (1) an empirical backend selection algorithm that benchmarks CuPy, PyTorch-CUDA, and NumPy-CPU backends at runtime and selects the optimal execution path based on measured throughput; (2) a directed acyclic graph (DAG) based gate fusion engine that reduces circuit depth through automated identification of fusible gate sequences, coupled with adaptive precision switching between complex64 and complex128 representations; and (3) a memory-aware fallback mechanism that monitors GPU memory consumption and gracefully degrades to CPU execution when resources are exhausted. The framework integrates with Qiskit, Cirq, PennyLane, and Amazon Braket through a unified adapter layer. Benchmarks on an NVIDIA A100-SXM4 (40 GiB) GPU demonstrate speedups of 64x to 146x over NumPy CPU execution for state-vector simulation of circuits with 20 to 28 qubits, with speedups exceeding 5x from 16 qubits onward. Hardware validation on an IBM quantum processing unit (QPU) confirms Bell state fidelity of 0.939, a five-qubit Greenberger-Horne-Zeilinger (GHZ) state fidelity of 0.853, and circuit depth reduction from 42 to 14 gates through the fusion pipeline. The system is designed for portability across NVIDIA consumer and data-center GPUs, requiring no vendor-specific compilation steps.

quant-pharXiv:2604.03816•Apr 7, 2026•3 citations
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.
Pauli propagation approximates circuit expectation values by evolving observables as truncated Pauli sums. This paper addresses repeated evaluations during variational optimization and quantum machine learning, where parameters and embedded data change but circuit structure remains fixed.
PADO-Pauli compiles circuits and observables into per-gate sparse maps, separating fixed structure from angle-dependent cos⁡θ\cos\thetacosθ and sin⁡θ\sin\thetasinθ factors. Evaluation supports GPU batching and a custom vector–Jacobian product integrated with PyTorch. Compilation includes Pauli-weight truncation, optional coefficient truncation at a fixed build point, and exact backward pruning of branches that cannot contribute in ∣0⟩⊗n|0\rangle^{\otimes n}∣0⟩⊗n. Depolarizing and amplitude-damping channels are supported.
On NVIDIA A100 benchmarks, warm evaluations are up to 10.1×10.1\times10.1× faster than cuPauliProp on 4–12-qubit instances. At 16 qubits and wmax⁡=6w_{\max}=6wmax​=6, forward-plus-backward memory occupancy is 3.1×3.1\times3.1× smaller, although cuPauliProp uses complex rather than real coefficients. An internal ablation attributes approximately 1.5×1.5\times1.5× batched-forward acceleration to zero-filtering. Exact statevector checks reach 28 qubits; on small-angle QAOA instances, wmax⁡=5w_{\max}=5wmax​=5 gives absolute observable errors below 9.74×10−49.74\times10^{-4}9.74×10−4.
Truncation accuracy remains instance-dependent: a random-circuit test reaches worst-case error 0.2040.2040.204 at 20 qubits with wmax⁡=9w_{\max}=9wmax​=9. Compilation and initial backward-cache construction impose upfront costs, coefficient-truncated programs remain tied to their build point, and branching can exhaust memory. The 127-qubit kicked-Ising demonstration lacks an exact reference; apparent convergence under relaxed truncation can be misleading. The paper reports no new general simulation guarantee.
We develop a backpropagation algorithm for evaluating parameter gradients in quantum circuits using Pauli propagation simulation. The method has computational complexity comparable to that of standard sparse Pauli simulation techniques, while producing gradients whose accuracy is of the same order as the corresponding observable expectation values. By exploiting the reversibility of quantum circuits, the algorithm reduces the memory cost by a factor of O(nparam)\mathcal{O}(n_\text{param})O(nparam​) compared with conventional reverse-mode automatic differentiation, where nparamn_\text{param}nparam​ denotes the number of parameters in the circuit. Compared with finite difference methods, the algorithm is O(nparam)\mathcal{O}(n_\text{param})O(nparam​) more efficient in function evaluations. These features enable efficient and accurate classical optimization of quantum circuits for applications such as state preparation and time-evolution compression, while also allowing operator-complexity measures such as the operator stabilizer Rényi entropy to be monitored and regularized during optimization. We demonstrate the method by optimizing low-energy state-preparation circuits for transverse-field Ising models in one, two, and three dimensions and for the three-dimensional Heisenberg model, and by compressing two-dimensional time-evolution circuits.
Quantum Machine Learning models typically require expensive on-chip training procedures and often lack efficient gradient estimation methods. By employing Pauli propagation, it is possible to derive a symbolic representation of observables as analytic functions of a circuit's parameters. Although the number of terms in such functional representations grows rapidly with circuit depth, suitable choices of ansatz and controlled truncations on Pauli weights and trigonometric degree components yield accurate yet tractable estimators of the target observables. With the right ansatz design, this approach can be extended to system sizes beyond the reach of classical statevector simulation, enabling scalable training for larger quantum systems. This also enables a form of classical pre-training through gradient-based optimization prior to deployment on quantum hardware. The proposed approach is demonstrated on the Variational Quantum Eigensolver for obtaining the ground state of the ANNNI spin model on 32 qubits, showing that accurate results can be achieved with a scalable and computationally efficient procedure.
Scaling parametrized quantum circuits to a larger number of qubits is a central challenge in Quantum Machine Learning: gradient estimation via the parameter-shift rule quickly becomes prohibitively expensive, while gradient-free optimizers offer limited convergence guarantees. We apply the Pauli propagation framework to a broad class of Quantum Machine Learning problems in which the loss is expressed as a function of expectation values of the circuit's observables, while keeping the relevant quantity of interest, such as the quantum state or its samples, classically intractable to compute. By propagating the observables backward through the circuit, we obtain an explicit parametric expression for the loss that can be minimized entirely on classical hardware. We also present complementary strategies to make propagation tractable at large scale, including weight-based and degree-based truncations and pruning heuristics. We demonstrate the approach on two benchmarks run on 64-qubit circuits: Variational Quantum Eigensolver on a two-dimensional Ising model, and training of a discrete-type generative model for binary images. In both cases, the classically pre-trained parameters are deployed on the IBM quantum processor ibm_berlin. For generative learning, we additionally show that the circuits considered here require substantially fewer parametrized gates than IQP-style ansätze, reducing transpilation overhead and making deployment on current quantum hardware feasible.
Efficient manipulation of Pauli-algebraic objects is a key bottleneck in the classical emulation and benchmarking of quantum algorithms for chemistry and many-body physics. This bottleneck appears in Hamiltonian construction, variational ansatz preparation, expectation-value and gradient evaluation, and real-time propagation, all of which require repeated Pauli-algebra operations. Here, we present a high-performance Pauli-algebra framework tailored to quantum many-body and quantum-chemical simulations. The framework combines compact binary symplectic encoding, canonical coefficient reduction, and grouped sparse operator representations that exploit shared bit-flip patterns among Pauli strings. The resulting Julia/C\texttt{++} implementation accelerates Pauli multiplication, Hamiltonian construction, and operator--state multiplication in sparse and symmetry-adapted many-electron spaces. Benchmarks demonstrate efficient Hamiltonian construction, large-active-space VQE and ADAPT-VQE calculations, and real-time variational dynamics on modern multicore CPU and GPU architectures. These results show that structure-aware Pauli-algebra engines provide a scalable classical backend for developing and benchmarking quantum algorithms in quantum chemistry and many-body simulation.
Training the circuit of a quantum generative model is hampered by barren plateaus, where gradients vanish exponentially with the number of qubits. In the present work we propose a generative protocol based on the paradigm of quantum extreme learning machines, in which the circuit is never trained. A random latent vector is encoded into a quantum state, evolved with a fixed unitary and measured, and only a linear output layer is trained. The encoding of the latent variable determines the functions available to the model, while the unitary decides which combinations of them are seen by the trained layer. With the help of Pauli propagation we show that for a Clifford unitary each feature is a single product of sines and cosines of the encoded angles, so that a Clifford circuit, even a strongly entangling one, does not create new functions. Doping the circuit with TTT gates mixes these products and changes the nonstabilizerness of the state, but the space of functions remains the one fixed by the encoding. For brickworks of Haar-random two-qubit gates the features are no longer single products, and their variation with the latent variable decreases with the depth of the circuit. For the proposed encoding and for one- and two-dimensional distributions, generated both from expectation values and from single measurements, neither the entanglement produced by a Clifford reservoir nor the additional nonstabilizerness of Haar-random brickworks systematically improves the generator, and a reservoir with no gates at all is competitive with entangling circuits.
Classical simulation of quantum circuits remains indispensable for algorithm development, hardware validation, and error analysis in the noisy intermediate-scale quantum (NISQ) era. However, state-vector simulation faces exponential memory scaling, with an n-qubit system requiring O(2^n) complex amplitudes, and existing simulators often lack the flexibility to exploit heterogeneous computing resources at runtime. This paper presents a GPU-accelerated quantum circuit simulation framework that introduces three contributions: (1) an empirical backend selection algorithm that benchmarks CuPy, PyTorch-CUDA, and NumPy-CPU backends at runtime and selects the optimal execution path based on measured throughput; (2) a directed acyclic graph (DAG) based gate fusion engine that reduces circuit depth through automated identification of fusible gate sequences, coupled with adaptive precision switching between complex64 and complex128 representations; and (3) a memory-aware fallback mechanism that monitors GPU memory consumption and gracefully degrades to CPU execution when resources are exhausted. The framework integrates with Qiskit, Cirq, PennyLane, and Amazon Braket through a unified adapter layer. Benchmarks on an NVIDIA A100-SXM4 (40 GiB) GPU demonstrate speedups of 64x to 146x over NumPy CPU execution for state-vector simulation of circuits with 20 to 28 qubits, with speedups exceeding 5x from 16 qubits onward. Hardware validation on an IBM quantum processing unit (QPU) confirms Bell state fidelity of 0.939, a five-qubit Greenberger-Horne-Zeilinger (GHZ) state fidelity of 0.853, and circuit depth reduction from 42 to 14 gates through the fusion pipeline. The system is designed for portability across NVIDIA consumer and data-center GPUs, requiring no vendor-specific compilation steps.