When Pauli Twirling Lies: The Hidden Cost of Coherent Errors

Quantum error correction is frequently benchmarked by pretending that every imperfect gate produces a random Pauli error. But a miscalibrated control pulse does not necessarily flip a qubit at random; it can rotate its state systematically, preserving amplitudes that interfere during decoding. Surface-code research has revealed an unsettling possibility: the stochastic approximation may predict nearly the correct threshold while substantially understating logical failure beneath it. The issue is not whether Pauli twirling is always wrong, but exactly what it preserves, what it discards and which logical observable we hope to protect.

A surface code stores a logical quantum state across a two-dimensional array of physical qubits. Repeated stabilizer measurements reveal syndromes, the local signs that indicate where errors may have appeared, without directly measuring the encoded amplitudes. A classical decoder identifies a likely correction, and the combination suppresses logical failures when physical noise is sufficiently weak. This basic architecture is often studied using stochastic Pauli noise because stabilizer simulation then becomes dramatically easier. [1][2]

Real devices also suffer systematic coherent errors. A pulse may rotate each qubit through an unwanted angle, a two-qubit gate may over-rotate its interaction, or a stable calibration offset may persist over many cycles. Such faults can constructively or destructively interfere. In 2018, Bravyi, Englbrecht, König and Peard used a Majorana-fermion simulation method to study surface codes under coherent single-qubit rotations. They found that physical Pauli twirling gave a useful threshold estimate but significantly underestimated logical failure below threshold. Márton and Asbóth extended coherent-noise simulations to phenomenological syndrome-readout errors in 2023. More recently, Behrends and Béri showed how even a small incoherent component can suppress logical-channel coherence with increasing distance. These findings demand an unusually precise distinction between the noise at the physical and logical levels. [3][4][5]

Why a small unitary rotation is not a rare Pauli flip

Take an unwanted $Z$ rotation on one qubit, using the convention $U_\theta=\exp(-i\theta Z)$ . Because $Z^2=I$ , this rotation has the exact expansion

U_\theta=\cos\theta\,I-i\sin\theta\,Z.

Unlike a classical random variable that selects either $I$ or $Z$ , the unitary is a coherent sum of the two operators. Applied to a density matrix, it generates $I\rho I$ , $Z\rho Z$ and two off-diagonal cross terms that depend on their relative phase. Those cross terms are not merely small corrections to a probability table; they describe the rotation of phase information.

Pauli twirling averages a channel over conjugations by the Pauli group. For this example the twirled noise is exactly a stochastic dephasing channel:

\mathcal T(\mathcal U_\theta)(\rho)=(1-p)\rho+pZ\rho Z,\qquad p=\sin^2\theta.

The coherent unitary and this dephasing channel have the same average gate infidelity to the identity: $r=2\sin^2\theta/3$ . But they differ under more demanding operational measures. With the conventional factor of one-half in front of the diamond norm, and for a rotation in the small-angle regime,

\frac12\|\mathcal U_\theta-\mathcal I\|_\diamond=|\sin\theta|,\qquad\frac12\|\mathcal T(\mathcal U_\theta)-\mathcal I\|_\diamond=\sin^2\theta.

At small angles these distances scale as $|\theta|$ and $\theta^2$ respectively, even though average infidelity matches. The reason is simple: averaging a unitary error over all input states is not the same task as asking for the worst possible input and measurement. Furthermore, replacing a noise model by its twirl in software is not the same as applying randomized compiling to actual gates. Carefully designed randomizations can sometimes tailor physical noise toward stochastic channels, but that is a protocol whose implementation and assumptions require validation. [6][7]

Syndromes measure constraints, not entire error histories

Surface-code $X$ - and $Z$ -type stabilizers test local parity. An individual Pauli error changes specific stabilizer outcomes, but different error chains can have identical endpoints and hence identical syndromes. Two chains may also differ by a stabilizer or by a logical operator spanning the code. Measuring the syndrome distinguishes broad classes of faults rather than identifying one microscopic string with certainty. [1][2]

Planar distance three and five surface code stabilizer patches and noncontractible logical strings — Rotated surface-code stabilizers and logical operators. Bravyi et al., *npj Quantum Information* 4, 55 (2018), Figure 1, CC BY 4.0.

This ambiguity is where coherent noise can affect logical decoding. A syndrome measurement separates amplitudes associated with distinct syndrome outcomes; it need not decohere all amplitudes associated with the same outcome. Let $V$ encode the logical state, $\Pi_s$ project onto syndrome $s$ , and $C_s$ be the decoder's correction for that syndrome. For a physical unitary $U$ , the recovered logical channel has Kraus operators

K_s=V^\dagger C_s\Pi_sUV,\qquad\mathcal L(\rho)=\sum_sK_s\rho K_s^\dagger.

Expanding $U$ as a sum of Pauli strings reveals coherent sums within each $K_s$ . The stochastic model instead adds the probabilities of the corresponding Pauli events. Those procedures do not generally commute with recovery. The discrepancy depends on the physical rotation axis, patch geometry, code distance, measurement schedule and decoder. There is no single constant by which stochastic twirling underestimates the error of every surface code.

A three-qubit calculation that exposes the missing phase

The essential phenomenon can be calculated without a computer on a three-qubit phase-flip repetition code. This is an analytical illustration, not a surface-code simulation. Its stabilizers are $X_1X_2$ and $X_2X_3$ , and its logical phase operator is $Z_L=Z_1Z_2Z_3$ . Apply the same $U_\theta$ to all three physical qubits, measure both stabilizers ideally and use a minimum-weight $Z$ recovery. Let $c=\cos\theta$ and $s=\sin\theta$ . The trivial syndrome receives contributions from both identity and weight-three phase errors; each nontrivial syndrome receives a weight-one and a complementary weight-two contribution. The resulting syndrome-conditioned logical Kraus operators are

K_{00}=c^3I+i s^3 Z_L,\qquad K_j=-i s c^2 I-s^2cZ_L\quad(j=1,2,3).

Summing the branches gives the exact recovered channel,

\mathcal L_\theta(\rho)=(1-q)\rho+qZ_L\rho Z_L-2ic^3s^3[Z_L,\rho],\qquad q=3p^2-2p^3.

The probability $q$ is precisely the classical majority-vote failure probability for three independent phase flips of probability $p=\sin^2\theta$ . Pauli-twirling the physical unitary before correction produces exactly the stochastic part of this channel, with the same $q$ , but it removes the remaining commutator. The coherent term begins at order $\theta^3$ while $q$ begins at order $\theta^4$ . Thus one perfectly legitimate “logical error probability” is equal between the models, even though their full logical channels differ at leading order.

For an encoded $|+_L\rangle$ input, the trace distance between the corrected output and the ideal output is

D_{\mathrm{coh}}=\sqrt{q^2+4c^6s^6},\qquad D_{\mathrm{twirl}}=q.

At $\theta=0.1$ radians, these exact expressions give $q\approx2.96\times10^{-4}$ and $D_{\mathrm{coh}}\approx1.98\times10^{-3}$ , a ratio of about $6.7$ . These values come from the simple repetition-code calculation, not from new measurements or unpublished surface-code simulations. Their significance lies in what they demonstrate rigorously: equal logical Pauli probabilities do not imply equal quantum memory channels. A finite-size study must declare the metric before declaring Pauli twirling accurate or inaccurate.

What large surface-code simulations found

The 2018 study simulated coherent physical $Z$ rotations on planar surface-code memories and compared the recovered logical behavior with an identically parameterized stochastic model. The fermionic representation enabled code distances far beyond what brute-force state-vector propagation could reach. In that model, the coherent threshold appeared near $\theta\approx0.10\pi$ , consistent with mapping the usual stochastic dephasing threshold through $p=\sin^2\theta$ . A threshold is a statement about scaling under a specified noise model, however, not a complete prediction of how often a finite code fails at a particular physical error rate. [3]

Logical failure error under coherent Z rotations versus the corresponding Pauli-twirled reference for different surface code distances — Comparing actual coherent logical errors with a physical Pauli-twirl model: the latter can underestimate failure below threshold. Bravyi et al., *npj Quantum Information* 4, 55 (2018), Figure 3, CC BY 4.0.

Below threshold, the paper's simulations revealed that the physical Pauli-twirl surrogate could substantially underpredict the studied logical error probability. The authors used minimum-weight matching decoding and compared the true coherent process with its stochastic reference. The result is directly relevant to resource estimates. A code can be in the correct scaling regime and still be less reliable than its simplified physical noise model predicts. A discrepancy can therefore affect the chosen code distance even if the critical threshold itself barely changes.

There is another important finding. For larger code distances, the distribution of syndrome-conditioned logical rotations concentrated increasingly near Pauli-like outcomes $I_L$ and $Z_L$ . In other words, coherent physical noise can produce nearly stochastic logical noise after error correction. But the logical Pauli probability generated by the coherent physical channel need not match the probability obtained by twirling the physical channel first. The emergence of logical stochasticity does not validate every approximate physical noise model. [3]

Syndrome-dependent logical rotation angle histograms at surface code distance nine and twenty five — Distribution of logical rotations after error correction: logical noise becomes increasingly Pauli-like with code distance, although its failure rate can remain mismatched. Bravyi et al., *npj Quantum Information* 4, 55 (2018), Figure 4, CC BY 4.0.

The measurement cycle changes the answer

In a functioning quantum computer, stabilizer readout is imperfect and must be repeated. A flipped ancilla report changes the apparent syndrome history, making time an additional decoding dimension. Márton and Asbóth incorporated phenomenological readout errors into coherent surface-code simulations, keeping projective stabilizer measurements ideal while permitting their recorded results to flip. That model is more realistic than flawless readout but does not constitute a fully noisy quantum circuit with imperfect entangling gates, leakage and correlated faults. [4]

Within the tested regime, they again observed thresholds near those of related stochastic models, but higher sub-threshold logical error for coherent rotations. Their worst-case-fidelity threshold estimate was around $2.6\%$ for the specified joint noise model. That value cannot be transferred to an unrelated processor or decoder without qualification. The work also showed that finite code performance was more sensitive to the coherent physical error rate than to the readout error rate over the investigated parameter range. [4]

These results suggest a systematic experiment: compare fixed and randomized coherent overrotations using the same extraction circuit and the same decoder, then evaluate both syndrome statistics and complete logical output states. A channel appearing stochastic in its marginal syndrome probabilities might still retain coherent logical transfer terms. Conversely, deliberately randomized controls might reduce those terms, in which case the mechanism should be demonstrated directly rather than attributed to a mathematical twirl that was never implemented.

Logical failure depends on the question being asked

The phrase “logical error rate” is used for several observables. One can measure the probability that an encoded $X$ or $Z$ eigenstate is decoded incorrectly, the average entanglement infidelity, the minimum fidelity over input states, or a channel norm sensitive to coherent rotations and entangled references. These quantities are related, but they need not scale identically with a systematic overrotation. In particular, an experiment that measures only the expected Pauli-basis failures may miss off-diagonal components of the effective logical channel. [5][8]

For a single logical qubit, those components can be diagnosed through a Pauli transfer matrix, defined by

R_{ij}=\frac12\operatorname{Tr}[P_i\mathcal L(P_j)],\qquad P_i\in\{I,X,Y,Z\}.

A purely stochastic Pauli channel has a diagonal action on the non-identity Pauli operators, whereas a coherent logical phase rotation couples the $X$ and $Y$ components. A complete comparison should include the matrix's coherent off-diagonal components or a channel-distance proxy, alongside logical Pauli failure probabilities. This makes explicit the difference between errors that affect a selected readout bit and errors that degrade arbitrary quantum information.

How 2025 changed the interpretation

In December 2025, Behrends and Béri examined surface codes under single-qubit noise channels combining coherent and incoherent components. Their simulations and statistical-mechanical analysis showed that with any nonzero incoherent component, the remaining logical-channel coherence was exponentially suppressed with increasing code distance within the studied model. They also demonstrated that information-theoretic indicators such as coherent information and quantum relative entropy can require this suppression to identify certain optimal recovery thresholds, and may become unreliable in the fully coherent limit. [5]

The result sharpens a central paradox. A larger code can make the logical channel more Pauli-like even when a physical Pauli-twirl surrogate predicts the wrong logical rate. These are two different comparisons. The first asks whether a corrected channel has coherent components. The second asks whether a physically different, twirled channel gives the right numerical failure probability after the entire correction procedure. Both can be tested independently.

Designing a finite-size comparison that does not hide the physics

A rigorous research program would hold code geometry, code distance, recovery algorithm and physical error probability fixed while changing the coherent component of the noise. One controlled family interpolates between a unitary rotation and its stochastic Pauli twirl:

\mathcal N_{\theta,\lambda}=(1-\lambda)\mathcal U_\theta+\lambda\mathcal T(\mathcal U_\theta),\qquad 0\leq\lambda\leq1.

Here $\lambda=0$ is a completely coherent rotation and $\lambda=1$ is its fully Pauli-twirled version. Both endpoints match average infidelity, and the intermediate channels enable a separation of coherent and incoherent contributions without trivially changing that physical benchmark. A rotated patch at distances such as $d=3,5,7$ would offer useful finite-size structure, but the reported data must make clear whether noise is applied only to stored data qubits or through a full repeated syndrome-extraction circuit. These are not interchangeable models.

For each distance, a benchmark should report the chosen logical Pauli error probability, a coherent-channel measure, and a discrepancy ratio with a denominator that is numerically resolvable:

R_M(d,\theta)=\frac{M[\mathcal L_{\mathrm{coh}}(d,\theta)]}{M[\mathcal L_{\mathrm{twirled}}(d,\theta)]}.

Even this ratio requires care. A large factor can be visually striking when both error rates are tiny; absolute differences and confidence intervals determine practical importance. For low-probability logical failures, naive Monte Carlo may be too expensive, and rare-event methods or special-purpose fermionic and tensor-network representations can become important. Results should distinguish mathematical exactness from Monte Carlo estimates and should never label data as simulated unless the simulation was actually executed. [3][9]

Comparing decoders matters too. Minimum-weight perfect matching is a reproducible and often strong baseline under stochastic assumptions, but a coherent-error-optimal recovery need not be an ordinary Pauli correction chosen through matching. Noise-aware decoding may change the magnitude or even the sign of the error discrepancy. Testing robustness across decoders avoids mistaking a weakness of a particular decoding objective for a universal property of the surface code.

What this means for physical quantum processors

Recent superconducting surface-code experiments now show logical memory errors decreasing as code patches grow. Google Quantum AI's Willow processor, for example, demonstrated below-threshold memory scaling in repeated syndrome-extraction cycles. Such experiments operate amid calibration drift, readout faults, leakage and occasionally correlated bursts. Their success does not imply that all physical errors are stochastic Pauli events or that one benchmark captures every failure channel. [10]

Experimental Google Quantum AI superconducting surface code layout and logical error per cycle — A superconducting surface-code benchmark, supplied as hardware context rather than a direct coherent-twirl comparison. Google Quantum AI and collaborators, *Nature* 638, 920–926 (2025), Figure 1, CC BY 4.0.

A twirled noise model remains a valuable tool when its assumptions are verified, and physical randomized compiling can sometimes engineer more stochastic behavior. The danger appears when matching an average error rate is treated as sufficient evidence that the model predicts the complete logical channel. A small residual logical rotation may matter over many fault-tolerant operations even if it is nearly invisible to a basis-specific syndrome benchmark. Whether that matters in practice depends on the full algorithmic error budget, not on the name of the approximation alone.

Pauli twirling is therefore neither a fraud nor a guarantee. It is a deliberate loss of information about phases. The difficult research question is precisely when the discarded phases alter the encoded channel enough to change a decoder choice, a code-distance estimate or a computation's final reliability. Finite-size surface codes provide a particularly rigorous setting in which to answer that question, because the relevant logical operators, syndrome projections and recovery maps can be specified explicitly and tested against both coherent and stochastic noise.

References

[1] Dennis, E., Kitaev, A., Landahl, A. and Preskill, J., Topological quantum memory, Journal of Mathematical Physics 43, 4452–4505 (2002). Foundational study.

[2] Fowler, A. G., Mariantoni, M., Martinis, J. M. and Cleland, A. N., Surface codes: Towards practical large-scale quantum computation, Physical Review A 86, 032324 (2012). Surface code overview.

[3] Bravyi, S., Englbrecht, M., König, R. and Peard, N., Correcting coherent errors with surface codes, npj Quantum Information 4, 55 (2018). Coherent error comparisons.

[4] Márton, Á. and Asbóth, J. K., Coherent errors and readout errors in the surface code, Quantum 7, 1116 (2023). Repeated readout study.

[5] Behrends, J. and Béri, B., The Surface Code beyond Pauli Channels: Logical Noise Coherence, Information-Theoretic Measures, and Errorfield-Double Phenomenology, PRX Quantum 6, 040350 (2025). Logical coherence study.

[6] Gutiérrez, M., Smith, C., Lulushi, L., Janardan, S. and Brown, K. R., Errors and pseudothresholds for incoherent and coherent noise, Physical Review A 94, 042338 (2016). Logical channel metrics.

[7] Wallman, J. J. and Emerson, J., Noise tailoring for scalable quantum computation via randomized compiling, Physical Review A 94, 052325 (2016). Randomized compiling.

[8] Iverson, J. K. and Preskill, J., Coherence in logical quantum channels, New Journal of Physics 22, 073066 (2020). Logical noise coherence.

[9] Bravyi, S. and Vargo, A., Simulation of rare events in quantum error correction, Physical Review A 88, 062308 (2013). Rare-event methods.

[10] Google Quantum AI and collaborators, Quantum error correction below the surface code threshold, Nature 638, 920–926 (2025). Experimental context.

Cover: graphical summary from Márton and Asbóth, Quantum 7, 1116 (2023), CC BY 4.0. Research figures are credited individually.