Pauli Propagation in Quantum Simulation

• Pauli propagation is a simulation method that represents operators as sums of Pauli strings, updated sequentially by applying local gate rules.
• It leverages simple algebraic rules—such as 1-branching for Clifford and 2-branching for Pauli rotations—to control operator growth and enable efficient merging and truncation.
• Recent developments extend the framework to include symmetry adaptation, truncation strategies, and hybrid error-mitigation protocols for both real-time and imaginary-time dynamics.

Searching arXiv for papers on Pauli Propagation and closely related variants. Pauli propagation is a family of classical simulation methods that evolve operators in the Pauli basis, typically in the Heisenberg picture, by expanding an observable as a sum of Pauli strings and updating those strings gate by gate or layer by layer under circuit or Hamiltonian dynamics. In this framework, Clifford operations are $1$-branching, Pauli rotations are typically $2$-branching, and noise channels that are diagonal in the Pauli basis act by coefficient rescaling rather than by changing Pauli support (Rudolph et al., 27 May 2025). The basic appeal is that many quantum processes act simply on Pauli strings, while expectation values can be recovered from overlaps of the propagated operator with an initial state or another operator (Rall et al., 2019). Recent work has broadened the framework from qubit-circuit estimation and real-time dynamics to symmetry reduction, symbolic parameter dependence, imaginary-time evolution, thermal-state simulation, and hybrid error-mitigation protocols (Gómez-Lurbe et al., 20 Jan 2026).

1. Foundational formulation

Pauli propagation represents an operator $O$ as a Pauli expansion,

$O=\sum_{i=1}^{N_O} c_i P_i,$

and repeatedly applies local update rules for each gate or channel to each Pauli term (Rudolph et al., 27 May 2025). In unitary Heisenberg evolution, the propagated observable is

$O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$

with each Pauli string propagated independently through a circuit or Trotterized Hamiltonian term-by-term (Gómez-Lurbe et al., 20 Jan 2026).

A central local rule is the Pauli-rotation update. For a Pauli-string generator $G$,

$R_G(\theta)=e^{-i\theta G/2},$

the propagated Pauli $P$ obeys

$R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$

where $P'=\frac{i[G,P]}{2}$ in one common formulation (Li et al., 8 Aug 2025). Equivalent gate rules are given in several papers with differing sign conventions but the same structural content: commuting terms remain unchanged, while noncommuting terms branch into two Pauli strings (Teng et al., 12 Dec 2025). This branching is the core source of computational growth.

The framework is commonly interpreted as a Pauli-path expansion. One explicit expression writes the Heisenberg-evolved observable as a sum over sequences of intermediate Pauli strings,

$2$0

making clear that each path through Pauli space contributes to the final operator (Teng et al., 12 Dec 2025). This path viewpoint underlies both exact propagation and truncation-based approximations.

Expectation values are then obtained from overlaps such as

$2$1

so the method is especially effective when overlaps with the initial state are easy to compute, as for computational-basis states, stabilizer states, or other classically represented states (Rudolph et al., 27 May 2025). A separate Monte Carlo line of work uses random Pauli-string estimators and the stabilizer norm $2$2 to sample Pauli expansions rather than enumerate them, yielding unbiased Schrödinger- and Heisenberg-propagation estimators (Rall et al., 2019).

2. Algebraic update rules and operator growth

Pauli propagation relies on the fact that many elementary gates have simple action in the Pauli basis. Clifford gates map Pauli strings to Pauli strings up to sign and are therefore $2$3-branching (Rudolph et al., 27 May 2025). Pauli rotations are $2$4-branching when the current Pauli string fails to commute with the generator (Li et al., 8 Aug 2025). Pauli noise channels are diagonal in the Pauli basis and rescale coefficients without branching (Rudolph et al., 27 May 2025).

For real-time Pauli propagation generated by a Pauli string $2$5,

$2$6

one explicit rule is

$2$7

This compactly encodes the difference between commuting and anticommuting sectors (Gómez-Lurbe et al., 20 Jan 2026).

The principal computational obstacle is operator growth. Because each nontrivial branching step can double the number of terms, a sum with $2$8 terms can become a sum with $2$9 terms after one non-Clifford gate in the worst case (Krötz, 25 May 2026). In the language of tree search, a circuit with $O$0 $O$1-branching gates can produce up to $O$2 Pauli paths, although many paths may merge to the same Pauli string (Rudolph et al., 27 May 2025). Practical algorithms therefore depend on merging duplicate strings and truncating small or structurally unimportant terms.

This branching phenomenon is closely tied to operator complexity. One recent formulation makes this explicit using the Operator Stabilizer Rényi entropy $O$3, which quantifies how spread out an operator is in the Pauli basis and yields tail bounds for Top-$O$4 coefficient truncation (Shao et al., 25 Oct 2025). In that framework, the cost of simulation is governed by operator complexity rather than by state entanglement.

3. Algorithmic realizations and low-level implementation

A general Pauli-propagation workflow repeatedly propagates all current Pauli terms, merges identical strings, truncates, and finally computes the desired overlap or expectation value (Rudolph et al., 27 May 2025). Breadth-first traversal with merging is a standard practical strategy because many distinct Pauli paths collapse to the same string; depth-first traversal uses less memory but cannot merge duplicates early (Rudolph et al., 27 May 2025).

At the representation level, a standard implementation encodes each qubit by two bits using a binary symplectic map,

$O$5

so an $O$6-qubit Pauli string is stored as $O$7 with one bit per qubit for the $O$8 and $O$9 parts (Krötz, 25 May 2026). In compact form, an $O=\sum_{i=1}^{N_O} c_i P_i,$0-qubit string fits into $O=\sum_{i=1}^{N_O} c_i P_i,$1 64-bit words for each of the $O=\sum_{i=1}^{N_O} c_i P_i,$2 and $O=\sum_{i=1}^{N_O} c_i P_i,$3 halves, plus a small phase field (Krötz, 25 May 2026). Multiplication becomes word-level XOR together with a phase computed from overlaps of $O=\sum_{i=1}^{N_O} c_i P_i,$4 and $O=\sum_{i=1}^{N_O} c_i P_i,$5 bits using population counts (Krötz, 25 May 2026).

The commutation test is likewise reduced to the binary symplectic inner product,

$O=\sum_{i=1}^{N_O} c_i P_i,$6

which determines whether two strings commute or anticommute (Krötz, 25 May 2026). This is exactly the primitive needed for deciding whether a Pauli rotation branches, and for reordering identities such as

$O=\sum_{i=1}^{N_O} c_i P_i,$7

in propagation-style compilation (Krötz, 25 May 2026).

The PauliPropagation.jl framework presents this stack end to end, from bit-level integer encodings and hash-table storage of Pauli sums to user-level simulation of circuits and dynamics (Rudolph et al., 27 May 2025). The package emphasizes Dict-based merging, bitwise Pauli arithmetic, and truncation rules such as min_abs_coeff, max_weight, and custom truncation functions (Rudolph et al., 27 May 2025). At larger scale, the C++ library PauLIB was introduced as a backend for the same algebraic bottlenecks, using bit-packed symplectic representation, sorted contiguous arrays instead of hash maps, and a struct-of-arrays layout for SIMD vectorization (Krötz, 25 May 2026). At 500 qubits, PauLIB reports 25 ns per multiplication, 14× faster than PauliEngine and 660× faster than Qiskit, Hamiltonian outer-product multiplication approximately 10 times faster than PauliEngine and 45 times faster than Qiskit, greedy commutation grouping up to 21,000× speedup over PennyLane, and a reduction of one-million-term Hamiltonian storage at 500 qubits from 1,036 MB in Qiskit to 142 MB (Krötz, 25 May 2026). These results do not alter the mathematics of Pauli propagation, but they directly address its dominant arithmetic costs.

4. Truncation, error control, and compressibility

Because exact Pauli propagation is usually infeasible beyond modest branching depth, truncation is intrinsic to most practical variants. Common truncation rules include small-coefficient truncation, Pauli-weight truncation, path-weight truncation, frequency truncation, Top-$O=\sum_{i=1}^{N_O} c_i P_i,$8 truncation, and fixed-$O=\sum_{i=1}^{N_O} c_i P_i,$9 budget schemes (Rudolph et al., 27 May 2025).

In one broad formulation, Top-$O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$0 truncation keeps the $O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$1 largest-magnitude Pauli coefficients after each elementary update and optionally rescales the final operator to preserve Hilbert-Schmidt norm (Shao et al., 25 Oct 2025). That work proves

$O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$2

where $O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$3 is the squared tail of discarded coefficients, and then bounds $O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$4 in terms of $O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$5, producing a sufficient $O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$6 for a target error $O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$7 (Shao et al., 25 Oct 2025). This yields an a priori link between operator compressibility and truncation accuracy.

Another line of theory concerns average-case simulation of noisy circuits. For random circuit layers with local incoherent noise, path-weight truncation yields inverse-polynomial error because large cumulative path weight is exponentially suppressed in expectation (Angrisani et al., 22 Jan 2025). In that setting, the mean squared contraction coefficient

$O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$8

governs the average damping of Pauli operators under arbitrary local incoherent noise, including non-unital channels such as amplitude damping (Angrisani et al., 22 Jan 2025). Under the stated assumptions, typical noisy circuits can be truncated to an effective logarithmic depth for observable estimation (Angrisani et al., 22 Jan 2025). This suggests that noise can simplify rather than complicate Pauli-path simulation in average-case regimes.

Symbolic Pauli propagation introduces a different pair of truncation axes: Pauli weight $O(t)=U^\dagger(t)\,O\,U(t), \qquad U(t)=e^{-itH},$9 and frequency $G$0, the latter counting sine and cosine factors in symbolic coefficients (Monaco et al., 18 Dec 2025). Under the assumption

$G$1

the resulting loss truncation error obeys an exponential tail bound in both $G$2 and $G$3 (Monaco et al., 18 Dec 2025). This supplies uniform control of both surrogate losses and surrogate gradients for parameterized circuits.

A recurring caveat is that truncation criteria can be structurally misleading. In imaginary-time propagation, early truncation may remove entire branches that become important only later (Gómez-Lurbe et al., 20 Jan 2026). In low-weight Pauli propagation for VQAs, weight truncation can make the energy estimator numerically unreliable even when the induced approximate landscape remains useful for optimization (Li et al., 8 Aug 2025). Truncation quality is therefore problem- and regime-dependent, and different applications have produced distinct heuristics and error theories rather than a single universal prescription.

5. Real-time dynamics, symmetry adaptation, and parameterized circuits

Pauli propagation has become an observable-centric alternative for simulating quantum dynamics in spin systems. A recent real-time formulation evolves local observables directly in the Heisenberg picture and uses Top-$G$4 truncation justified by Operator Stabilizer Rényi entropy (Shao et al., 25 Oct 2025). For the 1D Heisenberg model with $G$5, that work proves that the number of nonzero Pauli coefficients of the Heisenberg-evolved local $G$6 operator scales quadratically in Trotter steps,

$G$7

establishing exact compressibility in that free case (Shao et al., 25 Oct 2025). Numerically, on the XXZ chain with $G$8 and staggered magnetization, the method is accurate with relatively small $G$9 at $R_G(\theta)=e^{-i\theta G/2},$0 and remains competitive with TDVP at $R_G(\theta)=e^{-i\theta G/2},$1 (Shao et al., 25 Oct 2025).

Symmetry-merging Pauli propagation exploits discrete symmetries by propagating only a set of orbit representatives rather than all symmetry-related Pauli strings (Teng et al., 12 Dec 2025). If a circuit layer $R_G(\theta)=e^{-i\theta G/2},$2 and the state $R_G(\theta)=e^{-i\theta G/2},$3 satisfy

$R_G(\theta)=e^{-i\theta G/2},$4

then expectation values of symmetry-related Pauli strings coincide, and one may replace the full Pauli basis by a disjoint union of symmetry orbits (Teng et al., 12 Dec 2025). The correctness theorem states that if $R_G(\theta)=e^{-i\theta G/2},$5 and every layer commute with the symmetry action, then

$R_G(\theta)=e^{-i\theta G/2},$6

Explicit orbit-count formulas show linear reduction under translation symmetry, exponential reduction under full permutation symmetry, and $R_G(\theta)=e^{-i\theta G/2},$7 scaling under dihedral symmetry (Teng et al., 12 Dec 2025). Benchmarks indicate improved stability under truncation and noise, with merging tending to increase coefficient magnitudes and thereby helping important terms survive threshold truncation (Teng et al., 12 Dec 2025).

For parameterized quantum circuits, symbolic Pauli propagation turns the propagated observable into an analytic function of the parameters,

$R_G(\theta)=e^{-i\theta G/2},$8

where the $R_G(\theta)=e^{-i\theta G/2},$9 are products of sines and cosines (Monaco et al., 18 Dec 2025). Because the expectation value on $P$0 is obtained by trimming away Pauli words containing $P$1 or $P$2, the final loss is an explicit trigonometric polynomial (Monaco et al., 18 Dec 2025). This makes gradients available analytically or via parameter shift on the surrogate. In VQE for the 18-qubit, 4-layer local entangler ansatz on the ANNNI model, cutoffs $P$3 and $P$4 produce propagated energies very close to exact values over most of the phase diagram (Monaco et al., 18 Dec 2025). A related study of low-weight Pauli propagation found a different role: as a direct energy estimator it is unreliable, with the approximation often collapsing toward near zero along VQA trajectories, but as a pre-optimizer it can guide parameters into good basins and improve both convergence speed and final accuracy, typically by an order of magnitude on Heisenberg-model benchmarks (Li et al., 8 Aug 2025).

6. Imaginary-time evolution, thermal states, and hybrid quantum-classical extensions

A major recent extension generalizes Pauli propagation from real-time unitary dynamics to imaginary-time evolution. For a Pauli generator $P$5, the non-unitary gate

$P$6

induces the update

$P$7

Thus, compared with real-time propagation, commutation and anticommutation exchange roles and trigonometric functions are replaced by hyperbolic functions (Gómez-Lurbe et al., 20 Jan 2026). This defines Imaginary Time Pauli Propagation (ITPP), which approximates thermal and ground-state observables by evolving the identity operator in the Pauli basis (Gómez-Lurbe et al., 20 Jan 2026).

For a Hamiltonian $P$8, ITPP uses first-order Trotterization,

$P$9

and for thermal states initializes from $R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$0 (Gómez-Lurbe et al., 20 Jan 2026). On the open-boundary 1D transverse-field Ising model,

$R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$1

the method exactly matches Trotterized imaginary-time evolution for $R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$2, $R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$3, $R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$4, and $R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$5, as expected from the derivation (Gómez-Lurbe et al., 20 Jan 2026). With coefficient-threshold truncation on $R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$6, thresholds from $R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$7 to $R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$8 were tested; around threshold $R_G(\theta)[P] = \begin{cases} P, & [P,G]=0,\[4pt] \cos(\theta)P + \sin(\theta)P', & [P,G]\neq 0, \end{cases}$9, the method reaches relative energy error $P'=\frac{i[G,P]}{2}$0 while retaining only $P'=\frac{i[G,P]}{2}$1 Pauli terms compared with $P'=\frac{i[G,P]}{2}$2 in the untruncated evolution (Gómez-Lurbe et al., 20 Jan 2026). Fixed-$P'=\frac{i[G,P]}{2}$3 truncation with $P'=\frac{i[G,P]}{2}$4 remains reasonably accurate only up to about $P'=\frac{i[G,P]}{2}$5, after which the approximation breaks down, suggesting rapidly growing operator support requirements (Gómez-Lurbe et al., 20 Jan 2026).

A closely related Schrödinger-picture formulation for thermal-state simulation observes that high-temperature Gibbs states are sparse in the Pauli basis because they approach the identity at $P'=\frac{i[G,P]}{2}$6 (Rudolph et al., 4 Feb 2026). There, the Gibbs state is written as

$P'=\frac{i[G,P]}{2}$7

and imaginary-time propagation starts from the single basis element $P'=\frac{i[G,P]}{2}$8 (Rudolph et al., 4 Feb 2026). The local branching rule again occurs on commutation rather than anticommutation, and two analytic truncation schemes are studied: small-angle truncation and Pauli-weight truncation with backflow bounds (Rudolph et al., 4 Feb 2026). Large-scale numerics on the 1D $P'=\frac{i[G,P]}{2}$9-$2$00 Heisenberg model and the triangular-lattice Hubbard model validate efficiency at high temperatures but also show that low temperatures remain difficult because the Pauli expansion becomes dense (Rudolph et al., 4 Feb 2026).

Several hybrid protocols integrate Pauli propagation with quantum hardware. Quantum Enhanced Pauli Propagation (QuEPP) uses low-order Clifford perturbation theory to construct a classically simulable ensemble of Clifford circuits corresponding to low-order Pauli paths, and then measures those circuits on hardware to infer a global rescaling factor for the missing higher-order tail (Majumder et al., 15 Mar 2026). The final estimator

$2$01

combines exact classical low-order CPT with noisy hardware estimation of the residual (Majumder et al., 15 Mar 2026). Experiments on IBM Heron hardware include 2D random mirror circuits up to 49 qubits and depth 80, as well as Trotterized Hamiltonian evolution, and show improvements over both truncated classical CPT and unmitigated hardware estimates (Majumder et al., 15 Mar 2026).

A different hybrid approach computes a noise-canceling observable $2$02 by classically propagating inverse noise channels through the circuit so that

$2$03

allowing the ideal expectation to be recovered from measurements of $2$04 on the noisy device (Eddins et al., 18 Jun 2026). Two implementations, Propagated Noise Absorption and Euclid, were benchmarked numerically and on a 56-qubit superconducting processor, revealing explicit tradeoffs between classical truncation error and quantum sampling overhead (Eddins et al., 18 Jun 2026).

7. Related generalizations, misconceptions, and scope

Pauli propagation is not a single algorithm but a broad computational framework. One source of confusion is the distinction between exact Pauli-basis evolution and approximate truncation-based propagation. The former is mathematically straightforward; the latter is where most research effort is concentrated, because operator growth is the dominant limitation in non-Clifford and interacting settings (Rudolph et al., 27 May 2025). Another common misconception is to equate Pauli propagation with stabilizer simulation. Clifford circuits are efficiently simulable because Clifford conjugation preserves the Pauli group, but Pauli propagation extends beyond purely Clifford settings through controlled branching, truncation, and sampling (Rall et al., 2019).

The framework also generalizes beyond qubit spin systems. Majorana Propagation adapts the same Heisenberg-picture philosophy to fermionic circuits by replacing Pauli strings with Majorana monomials and using monomial length rather than Pauli weight as the main truncation heuristic (Miller et al., 24 Mar 2025). The key propagation rule is structurally identical: commuting monomials remain unchanged, while anticommuting monomials branch into cosine and sine terms (Miller et al., 24 Mar 2025). This suggests that Pauli propagation is best understood as one member of a larger family of operator-basis propagation methods rather than as an isolated technique.

There is also a separate literature on Pauli error propagation rather than observable propagation. In Clifford circuits and Pauli-twirled noise models, Pauli errors can be propagated exactly through gates, enabling applications such as propagated PEC, gate rescheduling, and noise analysis (Scheiber et al., 2024). These works use the same algebraic primitives—Pauli multiplication, conjugation, and commutation—but their goal is mitigation or error bookkeeping rather than direct simulation of ideal observable dynamics.

The present literature converges on a consistent high-level picture. Pauli propagation is most effective when observables are sparse in the Pauli basis, when gate rules are algebraically simple, when duplicates can be merged aggressively, and when truncation errors are controlled by low operator complexity, symmetry, noise-induced damping, or favorable ansatz structure (Shao et al., 25 Oct 2025). It is least effective when operator support proliferates rapidly and no compressibility mechanism is available (Gómez-Lurbe et al., 20 Jan 2026). A plausible implication is that the long-term development of the field will continue along two coupled directions: sharper structural theories of operator complexity and more specialized systems software for high-throughput Pauli algebra.