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

Scalable Pauli propagation through $\mathbb{F}_2$-linear partitioning

Alev Orfi, Andrew Kille, J. Clayton Peacock, Jack Dunham, Lukas Devos

Published Nov 12, 2026• 0 citations
arXivHTMLPDF

Abstract

Pauli propagation simulates quantum circuits and many-body dynamics by evolving observables in the Heisenberg picture as sparse sums of Pauli strings. As Pauli-string operations reduce to bit manipulations, its performance is limited by memory bandwidth and capacity rather than computational throughput. Pooling the memory of many cores and nodes is hindered by the deduplication step after every gate, which can require global synchronization. We avoid this bottleneck by partitioning the strings with an $\mathbb{F}_2$-linear hash function, which guarantees that a $k$-qubit channel couples each partition to at most $4^k$ partitions fixed by the gate, decomposing gate application into independent tasks with bounded communication. Benchmarks of our open-source implementation demonstrate efficient parallel scaling within and across compute nodes, enabling simulations with over $10^{11}$ Pauli strings and extending the accessible timescales of quantum many-body dynamics.

DOI
10.48550/arxiv.2611.17262

Related papers

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

Efficient computation of real-time correlators using Pauli Propagation

Alexander F. Kemper, Raghav G. Jha, Arnab Bachhar +3 more

Pauli propagation has shown promise for classically simulating quantum dynamics by evolving observables directly in the Heisenberg picture. In this work, we investigate its use for computing real-time two-point time-ordered correlators in one- and two-dimensional quantum systems. One major limitation of Pauli propagation is the rapid growth in the number of Pauli strings beyond short times. We overcome this limitation by combining accurate short-time Pauli-propagation data with time extension methods based on a positivity condition and the observation that the dynamics are often dominated by a small number of characteristic frequencies. This combined approach extends correlation functions far beyond the directly accessible time window while avoiding the exponential proliferation of Pauli operators. We demonstrate that the resulting correlators retain the relevant dynamical and spectral information. Our results broaden the regime in which classical methods can reliably probe the real-time dynamics of interacting quantum many-body systems.

quant-pharXiv:2607.24924•Jul 29, 2026•6 citations

PauLIB: HPC Strategies for Pauli-Arithmetic-Based Quantum Computing Workloads and Simulations

Florian Krötz

As quantum devices become accelerators within classical HPC deployments, the efficiency of the classical partition becomes critical. Workloads such as Hamiltonian manipulation, observable backpropagation, and Pauli-based compilation reduce to bulk arithmetic on Pauli strings and sums. We present HPC strategies for this arithmetic, demonstrated in PauLIB, a header-only C++20 library: a bit-packed binary symplectic representation reducing Pauli multiplication to a bitwise XOR and population count; a sorted, struct-of-arrays layout replacing hash maps and exposing contiguous word arrays to SIMD units and GPU warps; and deterministic OpenMP parallelism with race-free output partitioning. These strategies deliver orders-of-magnitude higher throughput and smaller memory footprint than Qiskit and PauliEngine, plus a speedup from a CUDA outer-product kernel on an H100. Two case studies, g-sim and truncated Pauli propagation, inherit these gains and scale unchanged from a desktop Arm CPU to a 72-core HPC Arm server. PauLIB is open source with C++ and Python interfaces.

quant-pharXiv:2605.25974•May 26, 2026•3 citations

Pushing beyond the memory barrier in propagation algorithms with randomization

Manuel S. Rudolph, Ricard Puig, Slimane Thabet +1 more

Performant classical tools for simulating quantum circuits are important for benchmarking and supporting upcoming quantum devices. Pauli propagation offers promising capabilities, but deep circuits usually cause a rapid growth in the number of Pauli strings and can quickly exhaust the available memory. In this work, we introduce a randomized protocol that combines a specialized resampling schedule, merging, and a controlled amount of bias to keep the propagating Pauli sum within any prescribed memory budget. Additional computational resources can then be spent on embarrassingly parallel repetitions that systematically improve the estimate. Building on the open-source library PauliPropagation.jl, we show that 1) increasing memory of each simulation reduces the error systematically more than outside averaging, 2) resampling just enough to apply the next gate delays variance accumulation and gives better error-per-time trade-offs than more aggressive resampling, and 3) a small, controlled bias is crucial in cutting down variance and pushing far beyond unbiased randomization. The resulting framework can reproduce deterministic calculations while requiring several orders of magnitude less memory.

quant-pharXiv:2610.28845•Oct 22, 2026•1 citation

monoprop: Scaling Pauli and Majorana propagation via Anticommutation Indices

Aaron Miller

We introduce monoprop, an open-source, massively parallel operator-propagation framework for fermion and qubit bases. For $N$ qubits or modes, existing codes represent each of the $K$ tracked operator terms (Pauli strings or products of Majorana operators) as a $2N$-bit string, testing each for anticommutation with the gate at $O(KN)$ cost per gate. Here, we introduce the anticommutation index which rapidly looks up the terms anticommuting with a gate. A local gate changes only the terms that touch its sites, and when terms are truncated to act on few sites, only a fraction $\sim1/N$ touch any given qubit or mode, and we use this to prove the time per gate scales as $O(K/N)$. This counterintuitive result tells us that for a fixed number of terms, increasing the number of sites can make things faster. We demonstrate this numerically, and show monoprop scales almost ideally to 8192 cores, tracking $9.5\times10^{10}$ terms. Beyond propagation, we present memory-efficient surrogate graphs, which record one propagation and replay it at new angles, for fast energy re-estimation and parameter gradients, and an efficient method for finding energy-minimising gates and optimal angles for simulating adaptive quantum-chemistry circuits.

quant-pharXiv:2610.21000•Oct 16, 2026•1 citation

Optimised Baranyai partitioning of the second quantised Hamiltonian

Bence Csakany, Alex J. W. Thom

Simultaneous measurement of multiple Pauli strings (tensor products of Pauli matrices) is the basis for efficient measurement of observables on quantum computers by partitioning the observable into commuting sets of Pauli strings. We present the implementation and optimisation of the Baranyai grouping method for second quantised Hamiltonian partitioning in molecules up to CH$_4$ (cc-pVDZ, 68 qubits) and efficient construction of the diagonalisation circuit in $O(N)$ quantum gates, compared to $O(N^2)$, where $N$ is the number of qubits. We show that this method naturally handles sparsity in the Hamiltonian and produces a $O(1)$ number of groups for linearly scaling Hamiltonians, such as those formed by molecules in a line; rising to $O(N^3)$ for fully connected two-body Hamiltonians. While this is more measurements than some other schemes it allows for the flexibility to move Pauli strings and optimise the variance. We also present an explicit optimisation for spin-symmetry which reduces the number of groups by a factor of $8$, without extra computational effort.

arXiv:2311.11826•Nov 20, 2023•3 citations
Scalable Pauli propagation through F2\mathbb{F}_2F2​-linear partitioning
Pauli propagation simulates quantum circuits and many-body dynamics by evolving observables in the Heisenberg picture as sparse sums of Pauli strings. As Pauli-string operations reduce to bit manipulations, its performance is limited by memory bandwidth and capacity rather than computational throughput. Pooling the memory of many cores and nodes is hindered by the deduplication step after every gate, which can require global synchronization. We avoid this bottleneck by partitioning the strings with an F2\mathbb{F}_2F2​-linear hash function, which guarantees that a kkk-qubit channel couples each partition to at most 4k4^k4k partitions fixed by the gate, decomposing gate application into independent tasks with bounded communication. Benchmarks of our open-source implementation demonstrate efficient parallel scaling within and across compute nodes, enabling simulations with over 101110^{11}1011 Pauli strings and extending the accessible timescales of quantum many-body dynamics.
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.
Pauli propagation has shown promise for classically simulating quantum dynamics by evolving observables directly in the Heisenberg picture. In this work, we investigate its use for computing real-time two-point time-ordered correlators in one- and two-dimensional quantum systems. One major limitation of Pauli propagation is the rapid growth in the number of Pauli strings beyond short times. We overcome this limitation by combining accurate short-time Pauli-propagation data with time extension methods based on a positivity condition and the observation that the dynamics are often dominated by a small number of characteristic frequencies. This combined approach extends correlation functions far beyond the directly accessible time window while avoiding the exponential proliferation of Pauli operators. We demonstrate that the resulting correlators retain the relevant dynamical and spectral information. Our results broaden the regime in which classical methods can reliably probe the real-time dynamics of interacting quantum many-body systems.
As quantum devices become accelerators within classical HPC deployments, the efficiency of the classical partition becomes critical. Workloads such as Hamiltonian manipulation, observable backpropagation, and Pauli-based compilation reduce to bulk arithmetic on Pauli strings and sums. We present HPC strategies for this arithmetic, demonstrated in PauLIB, a header-only C++20 library: a bit-packed binary symplectic representation reducing Pauli multiplication to a bitwise XOR and population count; a sorted, struct-of-arrays layout replacing hash maps and exposing contiguous word arrays to SIMD units and GPU warps; and deterministic OpenMP parallelism with race-free output partitioning. These strategies deliver orders-of-magnitude higher throughput and smaller memory footprint than Qiskit and PauliEngine, plus a speedup from a CUDA outer-product kernel on an H100. Two case studies, g-sim and truncated Pauli propagation, inherit these gains and scale unchanged from a desktop Arm CPU to a 72-core HPC Arm server. PauLIB is open source with C++ and Python interfaces.
Performant classical tools for simulating quantum circuits are important for benchmarking and supporting upcoming quantum devices. Pauli propagation offers promising capabilities, but deep circuits usually cause a rapid growth in the number of Pauli strings and can quickly exhaust the available memory. In this work, we introduce a randomized protocol that combines a specialized resampling schedule, merging, and a controlled amount of bias to keep the propagating Pauli sum within any prescribed memory budget. Additional computational resources can then be spent on embarrassingly parallel repetitions that systematically improve the estimate. Building on the open-source library PauliPropagation.jl, we show that 1) increasing memory of each simulation reduces the error systematically more than outside averaging, 2) resampling just enough to apply the next gate delays variance accumulation and gives better error-per-time trade-offs than more aggressive resampling, and 3) a small, controlled bias is crucial in cutting down variance and pushing far beyond unbiased randomization. The resulting framework can reproduce deterministic calculations while requiring several orders of magnitude less memory.
We introduce monoprop, an open-source, massively parallel operator-propagation framework for fermion and qubit bases. For NNN qubits or modes, existing codes represent each of the KKK tracked operator terms (Pauli strings or products of Majorana operators) as a 2N2N2N-bit string, testing each for anticommutation with the gate at O(KN)O(KN)O(KN) cost per gate. Here, we introduce the anticommutation index which rapidly looks up the terms anticommuting with a gate. A local gate changes only the terms that touch its sites, and when terms are truncated to act on few sites, only a fraction ∼1/N\sim1/N∼1/N touch any given qubit or mode, and we use this to prove the time per gate scales as O(K/N)O(K/N)O(K/N). This counterintuitive result tells us that for a fixed number of terms, increasing the number of sites can make things faster. We demonstrate this numerically, and show monoprop scales almost ideally to 8192 cores, tracking 9.5×10109.5\times10^{10}9.5×1010 terms. Beyond propagation, we present memory-efficient surrogate graphs, which record one propagation and replay it at new angles, for fast energy re-estimation and parameter gradients, and an efficient method for finding energy-minimising gates and optimal angles for simulating adaptive quantum-chemistry circuits.
Simultaneous measurement of multiple Pauli strings (tensor products of Pauli matrices) is the basis for efficient measurement of observables on quantum computers by partitioning the observable into commuting sets of Pauli strings. We present the implementation and optimisation of the Baranyai grouping method for second quantised Hamiltonian partitioning in molecules up to CH4_44​ (cc-pVDZ, 68 qubits) and efficient construction of the diagonalisation circuit in O(N)O(N)O(N) quantum gates, compared to O(N2)O(N^2)O(N2), where NNN is the number of qubits. We show that this method naturally handles sparsity in the Hamiltonian and produces a O(1)O(1)O(1) number of groups for linearly scaling Hamiltonians, such as those formed by molecules in a line; rising to O(N3)O(N^3)O(N3) for fully connected two-body Hamiltonians. While this is more measurements than some other schemes it allows for the flexibility to move Pauli strings and optimise the variance. We also present an explicit optimisation for spin-symmetry which reduces the number of groups by a factor of 888, without extra computational effort.