Pauli Propagation: The Method That Simulated IBM's 127-Qubit Experiment on a Laptop

When IBM published its 127-qubit utility beyond classical experiment in Nature in 2023, the most consequential rebuttal did not come from a supercomputer. It came from a laptop, running a technique much of the field had not yet encountered directly: Pauli propagation.

The change of picture

The method is a change of perspective rather than a faster implementation of the usual one. Standard simulation evolves the state forward through the circuit, the Schrodinger picture, at a cost of 2^n memory. Pauli propagation evolves the observable backward instead, the Heisenberg picture: start from the quantity to be measured, for example the Z operator on qubit 60, and track how each gate transforms it while walking from the end of the circuit to the beginning.

The two pictures are formally equivalent. The expectation value of observable O after unitary U applied to state |psi> can be written either as the expectation of O in U|psi>, or as the expectation of U-dagger O U in |psi>. The second form is preferable here for a specific reason: the initial state is almost always the all-zeros state, whose expectation against any Pauli string is either zero or one and is read off by inspection. All the work moves into transforming the observable, and none remains for the state.

Any observable can be written as a weighted sum of Pauli strings, tensor products of I, X, Y and Z, and this decomposition is unique. Gates map Pauli strings to Pauli strings. The simulation is bookkeeping over an evolving sum, and the answer is the coefficient of the identity term once the beginning of the circuit is reached.

Where the cost comes from

Clifford gates map one Pauli string to exactly one Pauli string, by definition of the Clifford group. A CNOT sends the string with X on the control to the string with X on both control and target; the term count does not change. Clifford gates are therefore free in this method, however many there are.

Non-Clifford rotations are what cost. A rotation Rz(theta) sends a Pauli string that anticommutes with Z into a combination of two strings, weighted by cos(theta) and sin(theta). Each such gate can double the term count, so the cost is exponential in the number of non-Clifford rotations rather than in the qubit count.

This inverts the usual scaling in a useful way. A 200-qubit circuit with few rotations is cheap; a 30-qubit circuit with many is expensive. Qubit count barely enters, which is why the method reaches widths no statevector simulator approaches.

The truncation argument

Left unchecked the term count grows exponentially with non-Clifford depth. The method's operative assumption is that most terms do not matter: coefficients spread thin across the sum, and strings carrying small weight contribute negligibly to the final expectation value. Discarding terms below a cutoff bounds the count and collapses the cost.

The essential property is that the discarded coefficient mass is computable, so truncation yields a bound on the error in the expectation value rather than an unquantified approximation. A run that discards nothing carries a bound of exactly zero and is therefore exact, not merely accurate.

Physical noise strengthens this argument rather than weakening it, which is the counterintuitive part. Noise damps precisely the long, high-weight Pauli strings that are expensive to track, because a string of weight w decays roughly as (1 - p)^w under depolarizing noise at rate p. A noisier target device makes truncation a better approximation of that device, not a worse one. A classical method aimed at matching real hardware output therefore becomes more accurate as the hardware becomes noisier, which is a structural reason beyond-classical claims on noisy devices have repeatedly failed to hold. The broader pattern is documented in Quantum supremacy claims that fell to classical simulation.

Regime                        Pauli propagation behaviour
Shallow, structured circuit   few high-weight strings, fast, accurate
Many Clifford gates           free, no term growth
Deep, many rotations          term count grows sharply, cost rises
Noisy hardware target         noise damps long strings, truncation improves

Where the method fits, and where it does not

Pauli propagation suits expectation values of shallow to moderate-depth circuits at large qubit counts, the 100 to 200-qubit regime frequently cited in hardware announcements. Its limits are equally specific and worth stating without hedging.

It estimates observables rather than full output distributions, so a question about a sampled bitstring distribution is outside its scope. Deep circuits with many rotations cause the term count to grow sharply, and past that point the bound widens until it admits any answer, at which point the correct response is refusal rather than a number. And every accuracy claim must be reported alongside the truncated-mass accounting, since the method's value lies in the bound as much as in the estimate.

The word Pauli attaches to three separate ideas that are routinely conflated, of which this method is one; the other two are the operator basis and the noise channel. They are separated in Pauli strings, channels and propagation.

The method is also comparatively young. Reference implementations are research code only a few years old, with substantial room for engineering improvement, which is the motivation for productizing it here under the same convergence discipline applied to the tensor-network engine.

Reproducing a 192-qubit result for a tenth of a cent

The claim is straightforward to check. A 192-qubit GHZ state measured with an all-Z observable has an analytically exact expectation value of +1, far past the roughly 32-qubit ceiling of any statevector simulator. The circuit is Clifford, so no rotation splits any term, nothing is truncated, and the bound is exactly zero. The engine returns exactly +1.

import qsim_sdk
from qiskit import QuantumCircuit

n = 192
qc = QuantumCircuit(n)
qc.h(0)
for i in range(n - 1):
    qc.cx(i, i + 1)               # a 192-qubit GHZ state

client = qsim_sdk.Client(token="YOUR_TOKEN")
job = client.run(qc, engine="pauli.cpu", observable=[[1.0, "Z" * n]])
print(job["result"]["expectation"])   # 1.0, certified error bound 0

The run finishes in under a minute and costs $0.001 at the standard rate. It carries a public certificate, verifiable without an account at api.zksf.org/certify/5b8b2c4309d44d41.

The example is deliberately one where the exact answer is known independently, because that is what makes it a check rather than a demonstration. A method that returns the right answer on a case with a known answer, and a computed bound on cases without one, is usable as an instrument.