Pauli Propagation: A Computational Framework for Simulating Quantum Systems

TL;DR

Pauli propagation offers a complementary classical framework for simulating quantum circuits by tracking evolved Pauli strings under a circuit in the Heisenberg picture, using Pauli transfer matrices and truncation-based approximations. The paper presents a thorough end-to-end account—from high-level theory to low-level implementation in PauliPropagation.jl—detailing truncation strategies, tree traversal algorithms, and efficient bitwise encoding that enable fast, scalable simulations of large circuits and dynamics. It discusses error estimation, surrogates for repeated evaluations, and the relation to existing methods like stabilizer/tensor-network approaches, while outlining practical considerations for topology, noise, and open-system dynamics. The work positions PP as a versatile tool for obtaining rough yet useful insights into operator dynamics and expectation values, with potential for hybrid quantum-classical workflows and future performance optimizations. Its open-source Julia package provides a concrete platform for researchers to explore PP across a broad range of quantum architectures and circuit regimes.

Abstract

Classical methods to simulate quantum systems are not only a key element of the physicist's toolkit for studying many-body models but are also increasingly important for verifying and challenging upcoming quantum computers. Pauli propagation has recently emerged as a promising new family of classical algorithms for simulating digital quantum systems. Here we provide a comprehensive account of Pauli propagation, tracing its algorithmic structure from its bit-level implementation and formulation as a tree-search problem, all the way to its high-level user applications for simulating quantum circuits and dynamics. Utilising these observations, we present PauliPropagation.jl, a Julia software package that can perform rapid Pauli propagation simulation straight out-of-the-box and can be used more generally as a building block for novel simulation algorithms.

Figures (8)

• Figure 1: Pauli propagation: Applications and Related methods. Quantum systems can be tackled via various classical simulations methods, each for different applications and systems of interest. Pauli propagation (PP) is a recent computational framework computing the evolution of Pauli strings under quantum dynamics or arbitrary quantum circuits. Often but not necessarily, PP involves Heisenberg-picture backpropagation of an observable. This evolved observable can be utilized for applications ranging from transparently studying operator dynamics, expectation values with states encoded on classical or quantum hardware, or operator correlation functions. Its placement in the classical simulation toolbox with other, more established methods is not fully known, but within few years, this approach has already shown promise. PP is most closely related to stabilizer simulation and its extensions for general gates, but it is fundamentally different to, e.g., tensor network approaches. Our library PauliPropagation.jl provides state-of-the-art PP techniques, and can be used for large-scale quantum simulation or as a building block in larger algorithmic frameworks.
• Figure 2: Potential advantage of a Pauli propagation surrogate. A Pauli propagation surrogate invests time and especially memory in an initial surrogation stage, then repeated evaluations can be significantly faster than running conventional Pauli propagation over and over for different parameters. This is demonstrated on a 20-qubit example with 10 layers and random correlated parameters within each brickwork layer. We estimate the operator correlation value of Pauli Z in the middle of the qubit chain, which represents one of the strongest sparsifications of the surrogate relative to conventional PP. The truncation parameters are chosen such that both models achieve approximately $0.005 - 0.010$ average absolute error compared to statevector simulation, and both simulations use a single CPU thread for a fairer comparison. We emphasize that this setup is chosen to demonstrate the potential advantages of surrogates, but our current surrogate implementation may not scale to the most interesting cases.
• Figure 3: Truncations during Pauli propagation. A tree graph illustrates the evolution of Pauli strings (nodes) and their associated coefficients (edges) under a unitary circuit, applied in sequence from right to left along the bottom axis. The shade of the edges indicates the magnitude of the coefficient size and the size of the node the weight of the corresponding Pauli string. The first three gates are illustrated in Theory Box \ref{['box:MergeExample']}. In the worst case, the leaves of the tree will grow exponentially with the number of gates, leading to an intractable tree. However, for many simulation tasks, this growth can be controlled using systematic truncation strategies described in Section \ref{['sec:truncations']}. Two types of truncations are depicted: weight truncation, which discards Pauli strings with weight above a chosen threshold (e.g., weight $4$), and coefficient truncation, which prunes strings with small coefficients (e.g., $-0.01$). Custom truncations are also supported by PauliPropagation.jl.
• Figure 4: Traversing the Pauli propagation tree. Repeated application of a gate to an observable represented as a sum of Pauli strings can cause repeated branching of Pauli strings into other Pauli strings with new coefficients. The exact branching pattern depends on the type of gate, but here we explore 2-branching gates (e.g., Pauli rotations) for simplicity. The nodes in the trees represent Pauli strings at different positions in the circuit, and the strength of the arrows and the numbers on the nodes denote the order in which the algorithm visits the nodes. Depth-first search (DFS) is a strategy that fully propagates a Pauli string through the entire circuit before returning to propagating the next. This is very light on memory. Breadth-first search (BFS) instead evolves Pauli strings gate-by-gate, consequently being heavier in memory. However, knowledge about all Pauli strings after each gate allows for merging of identical Pauli strings. This merging BFS approach is asymptotically faster than DFS or BFS, and its memory requirements are in between the other two.
• Figure 5: The importance of merging Pauli paths. We consider a 16-qubit quantum circuit consisting of layers of RX, RZ and RZZ Pauli rotations on a periodic bricklayer topology and compare the number of Pauli paths to the number of unique Pauli strings in the simulation. This can be understood as the comparison between DFS or BFS, and the merging-BFS approach. The initial observable is the sum of single-qubit Z Pauli strings, which initially gives rise to operator lightcone effects. After the initial stages, the number of paths scales with a stronger exponential in the number of Pauli rotations, which translates into a relative slowdown of pure DFS/BFS approaches without merging. No truncations are employed here.