Pauli Strings, Pauli Channels and Pauli Propagation: A Working Reference

The word Pauli attaches to at least three separate ideas in quantum computing, and they are routinely conflated. A Pauli string is a basis element. A Pauli channel is a noise model. Pauli propagation is a simulation algorithm. They share a mathematical object and nothing else, and confusing them produces reasoning errors that survive a long way into a project.

This reference separates them.

The object they share

The single-qubit Pauli matrices are I, X, Y and Z. They are Hermitian, unitary, and square to the identity. Any two of them either commute or anticommute, never anything in between, and their products close: XY = iZ, and so on around the cycle.

On n qubits, the tensor products of these four matrices form a set of 4^n operators. They are orthogonal under the trace inner product and they span the full space of n-qubit operators, so any observable or any Hamiltonian can be written as a weighted sum of them and the weights are unique. That is the entire foundation. Everything below is a different use of the same decomposition.

1. Pauli strings: the operator basis

A Pauli string is one element of that set, written as a word: `XZIY` means X on qubit 0, Z on qubit 1, identity on qubit 2, Y on qubit 3. The identity positions are written explicitly, so the string length always equals the qubit count. Off-by-one errors in string length are the most common validation failure in observable submission, and a service that checks length at submit time rather than mid-run is doing you a favour.

An observable is a list of coefficient and string pairs. The transverse-field Ising Hamiltonian on four qubits, for example:

H = [[-1.0, "ZZII"], [-1.0, "IZZI"], [-1.0, "IIZZ"],
     [-0.5, "XIII"], [-0.5, "IXII"], [-0.5, "IIXI"], [-0.5, "IIIX"]]

Two properties make this representation the working format for nearly all quantum software. Expectation values are linear, so the expectation of the whole Hamiltonian is the weighted sum of the expectations of the individual strings, each of which is a single measurement in a rotated basis. And the number of terms, not the number of qubits, is what determines cost: a 200-qubit Hamiltonian with 400 terms is cheaper to evaluate than a 20-qubit Hamiltonian with 40,000.

That second property is worth dwelling on, because it inverts the intuition that larger systems are harder. Local Hamiltonians, meaning those whose terms each act on a bounded number of neighbouring qubits, have a term count that grows linearly with qubit count. Hamiltonians derived from dense data, such as an electronic-structure problem in a large basis or a fully connected optimisation instance, have term counts that grow as the fourth power or the square. The physics of the system is irrelevant to this; the sparsity of the coefficient matrix decides it.

2. Pauli channels: the noise model

A Pauli channel is a completely different use of the same operators. Instead of expanding an observable, it expands a *noise process*: the channel applies Pauli operator P with probability p_P, leaving the state alone with the remaining probability.

The depolarizing channel is the familiar special case, applying X, Y and Z with equal probability p/3 each. Representative gate error rates by device class, which is what our noisy simulator uses:

Device class          1-qubit gate error   2-qubit gate error
Superconducting                    0.001                0.01
Trapped ion                       0.0005               0.005

Two-qubit gate error dominates by an order of magnitude on both platforms, which is why circuit depth in two-qubit gates, rather than total gate count or qubit count, is the number that predicts whether a hardware run will return anything meaningful.

Pauli channels matter disproportionately because they are the noise model that classical simulation handles efficiently. A general noise process requires the full density matrix, costing 2^n x 2^n. A Pauli channel acting on a stabilizer circuit can instead be sampled: draw which Paulis fired, propagate them through the circuit as ordinary gates, and repeat. This is why error-correction studies at thousands of qubits are computationally feasible while general noisy simulation stalls near twenty.

The practice of Pauli twirling exists to exploit exactly this. Randomly conjugating each gate by Pauli operators converts an arbitrary, poorly characterised noise process into an effective Pauli channel, at the cost of some fidelity. The resulting noise is worse in magnitude and far better in structure, which makes it both simulable and correctable. Trading a small amount of accuracy for a large amount of tractability is the same bargain that appears throughout this field.

3. Pauli propagation: the simulation method

The third use is an algorithm, and it inverts the usual direction of simulation. Rather than evolving the state forward through the circuit and measuring an observable at the end, Pauli propagation evolves the *observable* backward through the circuit and evaluates it against the initial state. This is the Heisenberg picture rather than the Schrodinger picture, and for this purpose it is the better one.

The advantage is that the initial state is usually trivial. Circuits typically start in 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.

Each gate in the circuit maps a Pauli string to a combination of Pauli strings. Clifford gates map one string to exactly one string, so they cost nothing: a CNOT sends `IX` to `IX`, `XI` to `XX`, and so forth, and the count of terms is unchanged. Non-Clifford rotations are what create the difficulty, splitting one string into two with cosine and sine weights. Under a deep circuit the term count therefore grows exponentially, and the method would be no better than any other were it not for truncation.

Truncation is the whole method. Terms whose accumulated coefficient falls below a cutoff are discarded, the count stays bounded, and the algorithm completes. Critically, the discarded coefficient mass is a computable quantity, and it bounds the error in the final expectation value directly. The method therefore returns an approximation together with a rigorous statement of how wrong it can be, which is a property most approximate methods lack.

This is what makes 100-qubit and 200-qubit expectation values routine on ordinary hardware. The cost scales with the number of retained Pauli terms, which depends on circuit depth and on how much coefficient mass the cutoff is permitted to discard, and not on 2^n. Shallow circuits on many qubits, which describes most variational ansatze and most Trotterised dynamics, are exactly the favourable case.

The limitation is symmetric and should be stated plainly. Deep circuits with many non-Clifford rotations spread coefficient mass across exponentially many strings, and no cutoff both keeps the count bounded and keeps the bound tight. When that happens the method reports a wide bound rather than a wrong answer, which is the correct behaviour but is not a result.

Distinguishing them in practice

                  What it is           Where it appears
Pauli string      A basis operator     Observables, Hamiltonians
Pauli channel     A noise process      Error models, twirling, QEC
Pauli propagation A simulation method  Expectation values, 100+ qubits

The practical test is what the object is standing in for. A string used to *specify what you want measured* is an observable. A string used to *describe what went wrong* is noise. A string being *pushed backward through gates* is the propagation algorithm at work. All three appear in a single VQE run on noisy hardware, which is why the vocabulary collapses so readily.

Our `pauli.cpu` engine implements the third of these and reports the discarded coefficient mass on every run, so the bound is available rather than inferred. The certification argument is set out in How we certify simulation error; the practical constraints on which circuits it accepts are in Why your circuit was rejected.