Coherent vs Incoherent Errors

Every quantum gate misses its target unitary $U$ a little, and the character of that miss — not just its size — decides whether a deep circuit survives. At one extreme the implemented map is still unitary, $\tilde U = E\,U$ with $E$ a small rotation close to the identity. These coherent errors are the deterministic residue of control: a miscalibrated pulse amplitude, a leftover detuning, static ZZ crosstalk. Being phase-preserving, they add in amplitude — two over-rotations by $\theta$ make one by $2\theta$ — so their damage can grow as the square of the circuit depth. At the other extreme the map is genuinely non-unitary, an open-system CPTP channel that entangles the qubit with an untracked environment: relaxation ( $T_1$ ), dephasing ( $T_2$ ), stochastic Pauli noise. These incoherent errors add in probability, random-walk against themselves, and average benignly. The reason this dichotomy is more than a taxonomy is a mismatch between two figures of merit. The average gate fidelity $\bar F$ — what randomized benchmarking reports — is blind to coherence: it sees only the mean infidelity $r=1-\bar F$ . The diamond distance $\tfrac12\lVert\tilde{\mathcal E}-\mathcal U\rVert_\diamond$ , the worst-case error an adversary can provoke, is what fault-tolerance thresholds are written in. For stochastic noise the two track each other, $\epsilon_\diamond\sim r$ ; for coherent noise they diverge by a square root, $\epsilon_\diamond\sim\sqrt r$ — a trap in which a gate that looks well inside threshold by $\bar F$ fails by $\epsilon_\diamond$ . This article makes the gap quantitative: the over-rotation model, the unitarity that isolates the coherent part, the average-to-worst-case bounds, and randomized compiling. Underneath sits one framework — the Kraus representation — in which a single Kraus operator is the coherent limit.

Key takeaways

Coherent errors are unitary (near-unitary) deviations — a systematic over-rotation, miscalibration, or unwanted Hamiltonian term — whose amplitudes add in lockstep, so $N$ repetitions can build a worst-case error scaling as $N^2$ .
Incoherent errors are stochastic decohering processes — relaxation, dephasing, random Pauli noise — described by non-unitary CPTP maps; their probabilities add roughly linearly in $N$ and partially cancel.
The average gate fidelity $\bar F$ depends only on the mean rate $r$ , but the worst-case diamond error can exceed $r$ by as much as its square root when the noise is coherent.
For an over-rotation by $\theta$ , $r\approx\theta^2/6$ while $\epsilon_\diamond\approx\theta/2$ , so $\epsilon_\diamond\approx\sqrt{\tfrac32 r}$ — a small measured infidelity can hide a much larger worst-case error.
The unitarity $u$ is the second-moment quantity that does see coherence ( $u=1$ for a unitary); randomized compiling (Pauli twirling) converts coherent error into a stochastic Pauli channel with the same $r$ but $\epsilon_\diamond$ pulled back to $\sim r$ , at no cost in physical gates.
Key idea: Coherent errors add in amplitude (ε◊ ~ θ, r ~ θ², so ε◊ ~ √r); incoherent errors add in probability (ε◊ ~ r). The gap between average fidelity and diamond distance is the operational signature that separates them.

The core insight

Coherent errors add in amplitude (worst-case error $\sim\theta$ , infidelity $\sim\theta^2$ , so $\epsilon_\diamond\sim\sqrt r$ ); incoherent errors add in probability ( $\epsilon_\diamond\sim r$ ). The gap between average fidelity and diamond distance is the operational signature distinguishing them.

Where this lives today

The coherent/incoherent split is front-line engineering on every superconducting and trapped-ion processor. Randomized compiling is on by default in production stacks: random single-qubit Pauli frames wrap each hard two-qubit gate and the compensating Paulis are classically absorbed into neighbours, so no physical operations are added and the over-rotations and ZZ crosstalk that would otherwise accumulate become a stochastic Pauli channel. Characterization has kept pace: unitarity randomized benchmarking estimates $u$ alongside $r$ to bound the $\sqrt r$ gap, while gate-set tomography reads $\epsilon_\diamond$ directly — the two often disagree by an order of magnitude when coherent errors dominate. On the theory frontier, coherent errors are the hard case for fault-tolerance proofs, since their amplitudes can add constructively across a code block. The doctrine is settled — never trust an average alone; measure the coherence, and twirl it away when you can.

The physical picture

Picture rotating a spin toward a target and always overshooting by the same tiny $\theta$ . Every gate adds the identical kick, so after $N$ gates the deviation is $N\theta$ — the errors march in lockstep and never cancel, which is why a $0.1\%$ amplitude miscalibration, invisible on any single gate, can wreck a thousand-gate circuit. Now make each kick random — sometimes $+\theta$ , sometimes $-\theta$ , sometimes a phase flip from the environment. The kicks random-walk and partially cancel, so the typical deviation grows only like $\sqrt N\,\theta$ : noise that forgets its own phase is far gentler over depth. The first figure is that race between $N\theta$ and $\sqrt N\,\theta$ .

Figure

Error accumulation over N gates at fixed per-gate angle θ = 0.01 rad: a coherent over-rotation marches in lockstep to Nθ = 1.0 rad after N = 100 gates, while incoherent random kicks walk to only √N θ = 0.1 rad — a tenfold gap that widens with depth

The same split governs how honestly a benchmark reports the danger. Average fidelity is like your mean distance from a bullseye over many shots — it cannot distinguish a tight cluster sitting systematically off-center (coherent bias) from a symmetric scatter (incoherent spread). The diamond distance is the adversary who picks the input that most exposes that bias, which is why it sees coherent error so much more harshly. Plotted against each other the two noise types fall on different power laws: coherent noise on the steep $\epsilon_\diamond=\sqrt{\tfrac32 r}$ branch, stochastic on the gentle $\epsilon_\diamond=\tfrac32 r$ branch. The second figure is that punchline.

Figure

The metric gap on log–log axes: diamond error ε◊ versus average infidelity r. Coherent noise follows ε◊ = √(1.5 r), stochastic noise ε◊ = 1.5 r. For an over-rotation with r = 1.7×10⁻⁵ the coherent worst case is ε◊ = 5×10⁻³ but the stochastic one only 2.5×10⁻⁵ — a ~200× spread at identical average fidelity

The core equations

A coherent error is, by definition, still a unitary — the intended gate dressed with a small rotation. Modelling that rotation by an angle $\theta$ about a Bloch axis $\hat n$ captures every systematic control fault — amplitude error, detuning, crosstalk — with one parameter.

\tilde U = E\,U,\qquad E = \exp\!\big(-i\,\theta\,\hat n\!\cdot\!\vec\sigma/2\big) \qquad (1)

where: $U$ — intended (target) gate unitary; $\tilde U$ — actually implemented unitary; $E$ — coherent error unitary, close to the identity; $\theta$ — systematic over-rotation angle; $\hat n\!\cdot\!\vec\sigma$ — Pauli operator along the unwanted rotation axis. The whole error is one number $\theta$ , and because $E$ is unitary it preserves purity and phase. The general error, coherent or not, is a CPTP map in Kraus form. The number of independent Kraus operators — the Kraus rank — is the sharp diagnostic: rank one is exactly the coherent case.

\mathcal E(\rho) = \sum_k K_k\,\rho\,K_k^\dagger,\qquad \sum_k K_k^\dagger K_k = I \qquad (2)

where: $\mathcal E$ — noisy channel implementing the gate; $K_k$ — Kraus operators; $\rho$ — input density operator. One Kraus operator forces $K_0$ unitary (a pure rotation, no entropy gain); two or more let the environment record which branch occurred, and that record is decoherence. The average gate fidelity is the overlap of the noisy output with the ideal one, Haar-averaged over all pure inputs. Its complement $r=1-\bar F$ is the single number randomized benchmarking returns.

\bar F(\mathcal E,U) = \int\! \mathrm d\psi\;\langle\psi|\,U^\dagger\,\mathcal E(|\psi\rangle\langle\psi|)\,U\,|\psi\rangle,\qquad r = 1-\bar F \qquad (3)

where: $\bar F$ — average gate fidelity; $r$ — average gate infidelity; $\mathrm d\psi$ — Haar (Fubini–Study) measure over pure states. The average washes over input directions, so $\bar F$ is a first-moment quantity that cannot feel coherence. The diamond distance is the worst-case error: maximize the trace-distance between noisy and ideal outputs over all inputs, including half of an entangled pair on an ancilla — the metric fault-tolerance thresholds are quoted in.

\epsilon_\diamond = \tfrac12\,\lVert \mathcal E - \mathcal U\rVert_\diamond = \tfrac12\,\max_{\rho}\,\big\lVert (\mathcal E\otimes\mathbb 1)(\rho) - (\mathcal U\otimes\mathbb 1)(\rho)\big\rVert_1 \qquad (4)

where: $\epsilon_\diamond$ — worst-case error; $\lVert\cdot\rVert_1$ — trace norm; $\mathbb 1$ — identity on an ancilla of equal dimension (stabilizes the maximum); $\mathcal U$ — ideal channel $\rho\mapsto U\rho U^\dagger$ . The maximization is an adversary hunting the input that most exposes systematic bias — why coherent error hurts $\epsilon_\diamond$ far more than $r$ . The unitarity is the second-moment partner of the infidelity: it measures how much purity the traceless part of the output retains. It equals one for any unitary and drops toward zero for depolarizing noise — precisely the coherence dial.

u(\mathcal E) = \frac{d}{d-1}\int\! \mathrm d\psi\;\mathrm{Tr}\!\big[\mathcal E'(|\psi\rangle\langle\psi|)^2\big],\qquad \mathcal E'(\rho)=\mathcal E(\rho)-\mathrm{Tr}[\mathcal E(\rho)]\,\tfrac{I}{d} \qquad (5)

where: $u$ — unitarity ( $u=1$ coherent, small for depolarizing); $\mathcal E'$ — traceless (non-identity) part of the output; $d$ — Hilbert-space dimension. Subtracting the maximally-mixed component isolates purity loss — the fingerprint distinguishing a rotated pure state from a genuinely mixed one. Two inequalities turn "coherent" and "incoherent" into measurable statements: the unitarity is bounded below by the infidelity, and the diamond error sits between a linear floor and a square-root ceiling.

u \;\ge\; \Big(1-\tfrac{d}{d-1}\,r\Big)^2,\qquad \frac{d+1}{d}\,r \;\le\; \epsilon_\diamond \;\le\; \sqrt{d(d+1)}\;\sqrt{r} \qquad (6)

where: all symbols as above, with $d=2$ for one qubit. Saturating the left (unitarity floor, diamond floor) is the incoherent regime; riding the right (high unitarity, square-root ceiling) is the coherent regime — the two bounds are the operational split. Finally, randomized compiling averages the error over the Pauli group, projecting out every off-diagonal (coherent) term and leaving a stochastic Pauli mixture with the same $r$ .

\mathcal E_{\mathrm{RC}}(\rho)=\frac{1}{|\mathcal P|}\sum_{P\in\mathcal P} P^\dagger\,\mathcal E\big(P\rho P^\dagger\big)\,P = \sum_k p_k\,P_k\,\rho\,P_k^\dagger \qquad (7)

where: $\mathcal E_{\mathrm{RC}}$ — twirled channel (a stochastic Pauli channel); $\mathcal P$ — the $n$ -qubit Pauli group; $p_k$ — resulting Pauli error probabilities; $P_k$ — Pauli operators. The twirl keeps the diagonal Pauli-error probabilities but zeroes the coherences, converting $\sqrt r$ danger into $r$ safety.

Derivation AWhy a single Kraus operator means a purely coherent error

The goal is to prove the structural claim underlying the whole dichotomy: a channel is coherent exactly when it needs only one Kraus operator, and any genuine decoherence forces the rank to at least two — so the Kraus rank is a coherence counter. We start from trace preservation and show that a second independent operator is precisely a which-path record leaking to the environment.

Step 1. With a single Kraus operator $K_0$ , trace preservation $\sum_k K_k^\dagger K_k=I$ reads $K_0^\dagger K_0=I$ ; in finite dimension that makes $K_0$ unitary, so the map is the pure rotation $\rho\mapsto E\rho E^\dagger$ with $E=K_0$ . Why: unitarity is forced, not assumed — which makes "rank one" synonymous with "coherent".

Step 2. A unitary map takes pure states to pure states, $\mathrm{Tr}\big[(E|\psi\rangle\langle\psi|E^\dagger)^2\big]=1$ for every $\psi$ : no purity is lost and the Stinespring dilation needs only a trivial environment. Why: coherence is the survival of phase and purity, which a rank-one channel keeps.

Step 3. Now let $\mathcal E$ have two independent Kraus operators. Its dilation $U_{SE}|\psi\rangle_S|0\rangle_E=\sum_k K_k|\psi\rangle_S|k\rangle_E$ is entangled; tracing out $E$ leaves a mixed state whenever the branches are distinguishable, so the environment holds a which-branch record. Why: the second Kraus operator carries information to the environment — decoherence — so rank $\ge2$ is incoherent. *Verified: rank-one ⇒ unitary ⇒ purity-preserving ⇒ coherent; rank ≥ 2 ⇒ nontrivial environment ⇒ purity loss ⇒ incoherent. Consistent with Nielsen & Chuang Ch. 8 (operator-sum representation) and the Stinespring dilation theorem.*

Go deeper · Derivation B · 1 minThe over-rotation gap: infidelity scales as the square of the angle, diamond distance linearly

Derivation BThe over-rotation gap: infidelity scales as the square of the angle, diamond distance linearly

The goal is the sharpest quantitative statement in the subject — that a coherent error's worst case is the square root of its average — for a single-qubit over-rotation $E=e^{-i\theta Z/2}=\cos(\theta/2)\,I-i\sin(\theta/2)\,Z$ relative to the identity. We get $r$ from the entanglement fidelity, $\epsilon_\diamond$ from the eigenvalues, and combine them to expose the $\sqrt r$ scaling that makes benchmarking-by-average dangerous.

Step 1. For a unitary error $F_e=|\mathrm{Tr}\,E|^2/d^2$ and $\bar F=(d\,F_e+1)/(d+1)$ . With $d=2$ , $\mathrm{Tr}\,E=2\cos(\theta/2)$ : $F_e=\cos^2(\theta/2)$ , $\bar F=[2\cos^2(\theta/2)+1]/3$ . Why: the Haar average collapses onto a single trace, so $\bar F$ is fixed by $\mathrm{Tr}\,E$ — blind to phase coherence.

Step 2. The infidelity is $r=1-\bar F=\tfrac23\big(1-\cos^2\tfrac\theta2\big)=\tfrac23\sin^2\tfrac\theta2\approx\theta^2/6$ — quadratic in the error angle, and exactly what randomized benchmarking reports. Why: the leading behaviour is $\theta^2$ , so a $\theta=0.01$ over-rotation looks like a reassuringly tiny $r\approx1.7\times10^{-5}$ .

Step 3. For a unitary the diamond distance from the identity is $\sqrt{1-\nu^2}$ , where $\nu$ is the distance from the origin to the convex hull of $E$ 's eigenvalues on the unit circle. The eigenvalues $e^{\pm i\theta/2}$ give a chord at $\nu=\cos(\theta/2)$ , so $\epsilon_\diamond=|\sin(\theta/2)|\approx\theta/2$ . Why: the diamond norm reads the eigenphase spread directly, growing linearly in $\theta$ while $r$ grows quadratically.

Step 4. Eliminate $\theta$ : $\sin^2(\theta/2)=\tfrac32 r$ , hence $\epsilon_\diamond=|\sin(\theta/2)|=\sqrt{\tfrac32 r}$ — worst case is the square root of the average, the hallmark of coherent error. Numerically $\theta=0.01$ rad gives $r\approx1.7\times10^{-5}$ yet $\epsilon_\diamond\approx5\times10^{-3}$ , a factor of $300$ . Why: this single relation is why a gate can sail past a threshold stated in $r$ and still violate it in $\epsilon_\diamond$ . *Verified: at $\theta=\pi$ (a full $Z$ error) $r=2/3$ , $\bar F=1/3$ as expected for an orthogonal unitary in $d=2$ , and $\epsilon_\diamond=1$ , the maximal diamond distance. Cross-checks: Nielsen & Chuang Ch. 9; Kueng, Long, Doherty and Flammia, PRL 117, 170502 (2016).*

Go deeper · Derivation C · 1 minPauli twirling incoherentizes a coherent over-rotation

Derivation CPauli twirling incoherentizes a coherent over-rotation

The goal is to show by explicit computation that averaging a coherent error over the Pauli group deletes its coherent cross term, leaving a stochastic Pauli channel with unchanged infidelity but a diamond error pulled from $\sqrt r$ down to $r$ scaling. We expand the same channel $\mathcal E(\rho)=E\rho E^\dagger$ , twirl it over $\mathcal P=\{I,X,Y,Z\}$ , and read off the surviving channel and its metrics.

Step 1. Expanding gives $E\rho E^\dagger=\cos^2\tfrac\theta2\,\rho+\sin^2\tfrac\theta2\,Z\rho Z+i\sin\tfrac\theta2\cos\tfrac\theta2\,(\rho Z-Z\rho)$ . The first two terms are stochastic Pauli contributions; the last is the coherent cross term responsible for amplitude build-up. Why: this separation isolates exactly the object the twirl is designed to kill.

Step 2. Twirling averages $\tfrac14\sum_{P}P^\dagger(\rho Z-Z\rho)P$ . Each Pauli commutes with $Z$ ( $+$ , for $I,Z$ ) or anticommutes ( $-$ , for $X,Y$ ), so the four signed copies $+,-,-,+$ sum to zero: the coherent term twirls away exactly. Why: the Pauli commutation signs cancel every off-diagonal coherence while leaving the diagonal probabilities.

Step 3. What survives is $\mathcal E_{\mathrm{RC}}(\rho)=\cos^2\tfrac\theta2\,\rho+\sin^2\tfrac\theta2\,Z\rho Z$ — a phase-flip channel with $p=\sin^2(\theta/2)$ , Kraus rank two, fully incoherent. Why: the deterministic over-rotation has become a random phase flip the environment averages instead of accumulates.

Step 4. The average is unchanged, $r_{\mathrm{RC}}=r$ (twirling preserves the diagonal), but the worst case is now $\epsilon_\diamond^{\mathrm{RC}}=\sin^2(\theta/2)\approx\theta^2/4$ — linear in $r$ , not $\sqrt r$ . For $\theta=0.1$ the diamond error falls from $5\times10^{-2}$ to $2.5\times10^{-3}$ , a twentyfold gain at no gate cost. Why: it buys the benign $\epsilon_\diamond\sim r$ scaling with pure classical randomness — hence standard on hardware. *Verified: at $\theta\to\pi$ the twirled channel becomes $\rho\mapsto Z\rho Z$ (a deterministic phase flip) with $r=2/3$ , $\epsilon_\diamond=1$ — matching the untwirled worst case while strictly improving for small $\theta$ . See Wallman and Emerson, PRA 94, 052325 (2016).*

Limiting cases

How $r$ and $\epsilon_\diamond$ relate across the coherence spectrum ( $d=2$ ):

Case	Result	Meaning
Purely coherent (unitary)	$\epsilon_\diamond \simeq \sqrt{\tfrac{d+1}{d}\,r}\,\approx\,\sqrt{\tfrac32 r}$	Over-rotation by $\theta$ : $r=\tfrac23\sin^2(\theta/2)\approx\theta^2/6$ while $\epsilon_\diamond=\|\sin(\theta/2)\|\approx\theta/2$ . Worst case is the square root of the average — the danger zone.
Purely stochastic (Pauli / depolarizing)	$\epsilon_\diamond \simeq \tfrac{d+1}{d}\,r \approx \tfrac32 r$	Diamond error scales linearly with infidelity; average and worst case are tightly comparable. The fault-tolerance-friendly regime.
General mixed channel	$\tfrac{d+1}{d}\,r \;\le\; \epsilon_\diamond \;\le\; \sqrt{d(d+1)}\,\sqrt{r}$	The unitarity $u$ interpolates: high $u$ pushes toward the upper $\sqrt r$ ceiling, low $u$ toward the linear floor.
Full $Z$ error ( $\theta=\pi$ )	$r=2/3,\ \epsilon_\diamond=1$	Both metrics saturate; an orthogonal unitary is as bad as it gets in $d=2$ .
After Pauli twirl	$r$ unchanged, $\epsilon_\diamond\to\sin^2(\theta/2)\approx\tfrac{d+1}{d}r$	Randomized compiling maps any point onto the stochastic (linear) branch at fixed $r$ .

Worked examples

1 · The worst-case cost of a small over-rotation (fully worked)

A single-qubit gate has a systematic $Z$ -axis over-rotation of $\theta=0.01$ rad and no other error. Find the average infidelity randomized benchmarking would report, the true worst-case diamond error, and their ratio.

Step 1. Average infidelity (Derivation 2): $r=\tfrac23\sin^2(0.005)$ . With $\sin(0.005)=0.0049999$ , $r=\tfrac23(2.4999\times10^{-5})=\mathbf{1.67\times10^{-5}}$ — the reassuringly small number a benchmark prints.

Step 2. Worst-case diamond error: $\epsilon_\diamond=|\sin(\theta/2)|=|\sin(0.005)|=\mathbf{5.0\times10^{-3}}$ , linear in $\theta$ , not quadratic.

Step 3. Ratio: $\epsilon_\diamond/r=\mathbf{300}$ , consistent with $\epsilon_\diamond=\sqrt{\tfrac32 r}$ . A $0.01$ rad over-rotation reports $r\approx1.7\times10^{-5}$ but carries a worst-case error $\approx5\times10^{-3}$ — three hundred times larger, entirely hidden from the average.

2 · Same infidelity, opposite fate — coherent vs depolarizing (fully worked)

Two single-qubit gates are benchmarked to the identical average infidelity $r=10^{-4}$ . Gate A's noise is purely coherent; gate B's is purely depolarizing. Which gate is safe against a surface-code threshold of $\epsilon_\diamond^{\mathrm{th}}\approx10^{-2}$ (diamond distance)?

Step 1. Gate A (coherent): $\epsilon_\diamond=\sqrt{\tfrac32 r}=\sqrt{1.5\times10^{-4}}=\mathbf{1.22\times10^{-2}}$ — exceeding the $10^{-2}$ threshold despite the tiny infidelity.

Step 2. Gate B (depolarizing): $\epsilon_\diamond=\tfrac32 r=\mathbf{1.5\times10^{-4}}$ , two orders of magnitude below threshold.

Step 3. Interpretation: the two gates are indistinguishable by $\bar F$ yet on opposite sides of the fault-tolerance boundary. Twirling gate A (a Pauli invariant leaves $r=10^{-4}$ but moves it to the linear branch, $\epsilon_\diamond\to1.5\times10^{-4}$ ) rescues it — converting gate A into gate B without touching the hardware. Identical average fidelity, but coherent gate A fails the threshold ( $1.2\times10^{-2}>10^{-2}$ ) while gate B passes by $\sim70\times$ ; the coherent/incoherent split, not $r$ , decides fault tolerance.

Physics of the portrait

The coherent/incoherent distinction is a half-century braid: the algebra of open-system channels, a worst-case metric imported from complexity theory, and the benchmarking revolution that made the split measurable.

Origins · 1 mincoherent versus incoherent errors and how this was discovered

coherent versus incoherent errors

the unitary–stochastic dichotomy in noisy quantum gates · characterization theory of open quantum systems

The idea that a quantum error has a character, not just a size, grew out of the mathematics of open systems. Karl Kraus in 1971 cast any physical quantum operation as a completely positive trace-preserving map in operator-sum form, and in that language the coherent case is simply the one with a single Kraus operator — a unitary; the complementary incoherent generators were pinned down by Lindblad and, independently, Gorini, Kossakowski and Sudarshan in 1976. But the operational sharpness of the distinction came from an unexpected direction: Alexei Kitaev, studying the complexity of quantum algorithms in the late 1990s, imported the diamond norm as the worst-case distance between channels, giving fault tolerance its natural metric. The gap between that worst case and the average became urgent only when experimentalists needed to measure error on real qubits. Joseph Emerson and collaborators built randomized benchmarking (from around 2005, made scalable by Magesan, Gambetta and Emerson in 2011) into the standard tool for average infidelity — and precisely because it is an average, it is blind to coherence. That blindness was named when Wallman, Flammia, Wehner and Emerson introduced the unitarity in 2015, and made actionable in 2016 by Wallman and Emerson's randomized compiling, which twirls coherent error into benign stochastic error, and Kueng, Long, Doherty and Flammia's bounds relating benchmarked infidelity to the diamond distance. The modern picture — a gate reported by both $r$ and $u$ — completes what Kraus began: an error is now classified, measured, and if need be re-randomized.

History

1971

— Kraus casts quantum operations as completely positive trace-preserving maps in operator-sum form

1976

— Lindblad and GKSL fix the generator of Markovian, incoherent open-system dynamics

1997

— Kitaev introduces the diamond norm as the worst-case distance between quantum channels

2011

— Magesan, Gambetta and Emerson give scalable randomized benchmarking of the average infidelity

2016

— Wallman and Emerson introduce randomized compiling; Kueng and co-workers bound diamond distance from infidelity

Going further

Texts. Nielsen & Chuang, Quantum Computation and Quantum Information (2010), Ch. 8–9 (quantum operations, distance measures, fidelity) · Preskill, Lecture Notes on Quantum Computation, Ch. 3 and Ch. 7 · Watrous, The Theory of Quantum Information (2018), Ch. 3–4 (the diamond norm) · Wilde, Quantum Information Theory (2017), Ch. 4 & 9 · Wallman & Emerson, "Noise tailoring for scalable quantum computation via randomized compiling", Phys. Rev. A 94, 052325 (2016) · Kueng, Long, Doherty & Flammia, "Comparing experiments to the fault-tolerance threshold", Phys. Rev. Lett. 117, 170502 (2016) · Wallman, Barnhill, Emerson, "Robust characterization of loss rates" and Wallman et al., "Estimating the coherence of noise", New J. Phys. 17, 113020 (2015).

Provenance. A verifier should reconfirm: (1) $\bar F=(d\,F_e+1)/(d+1)$ with $F_e=|\mathrm{Tr}\,E|^2/d^2$ for unitary $E$ (Nielsen & Chuang Ch. 9); (2) the over-rotation results $r=\tfrac23\sin^2(\theta/2)$ , $\epsilon_\diamond=|\sin(\theta/2)|$ , hence $\epsilon_\diamond=\sqrt{\tfrac32 r}$ (Kueng et al. 2016; Watrous Ch. 3, diamond norm of a unitary as distance from the origin to the convex hull of its eigenvalues); (3) the bounds $\tfrac{d+1}{d}r\le\epsilon_\diamond\le\sqrt{d(d+1)}\,\sqrt r$ and $u\ge(1-\tfrac{d}{d-1}r)^2$ (Wallman et al. NJP 17, 113020, 2015; Kueng et al. 2016); (4) the Pauli-twirl reduction of the coherent cross term to a phase-flip channel with $p=\sin^2(\theta/2)$ (Wallman & Emerson PRA 94, 052325, 2016). Numerical examples recompute by direct substitution; the surface-code threshold is an order-of-magnitude figure ( $\sim10^{-2}$ ).

Prerequisites. Quantum Operations and CPTP Maps · Kraus Representation of Quantum Channels · Decoherence · Relaxation and Dephasing: T1 and T2 Times. Leads to. Depolarizing Channel · Pauli and Bit/Phase-Flip Channels · Markovian vs Non-Markovian Dynamics · Lindblad / GKSL Master Equation.

Ask the tutor: Want to see how the diamond-distance-versus-infidelity gap changes for two-qubit gates, or how randomized compiling is actually compiled into a real circuit without adding operations? Ask me to walk through either.

What is the one-sentence difference between a coherent and an incoherent error?

A coherent error is a deterministic, unitary deviation — the gate still rotates the state, just to the wrong place — so it preserves purity and phase and can in principle be calibrated away; an incoherent error is a stochastic, non-unitary process entangling the qubit with an untracked environment, losing purity, and can only be averaged over. Structurally, coherent = a single (rank-one) Kraus operator, incoherent = two or more. Operationally, coherent noise has $u\approx1$ and $\epsilon_\diamond\approx\sqrt r$ , incoherent noise low $u$ and $\epsilon_\diamond\sim r$ .

Why is average gate fidelity blind to coherence when the diamond distance is not?

The average fidelity integrates over all input directions, so it depends only on the channel's identity-overlap — $|\mathrm{Tr}\,E|^2$ for a unitary — and the phase information that makes coherent error dangerous, living in the off-diagonal Pauli-transfer-matrix elements, is washed out. The diamond distance instead maximizes over inputs (including entangled ancillas), seeking the worst direction — much worse for a coherent error. The unitarity $u$ is the second-moment quantity built to recover exactly the coherence $\bar F$ discards.

Where does the square-root relation ε◊ ≈ √r actually come from?

From the different powers of the error angle. For an over-rotation by $\theta$ the fidelity loses order $\theta^2$ , giving $r\approx\theta^2/6$ , while the diamond distance measures the geometric spread and grows at first order, $\epsilon_\diamond\approx\theta/2$ ; eliminating $\theta$ leaves $\epsilon_\diamond\propto\sqrt r$ . The deeper reason is that fidelity is a squared inner product (amplitudes quadratically) whereas trace distance is linear in the amplitude deviation — the same quadratic-versus-linear split that separates probabilities from amplitudes everywhere in quantum mechanics.

How can randomized compiling improve the worst case without adding any gates?

It inserts random Pauli operators before each hard gate and their inverses after, then classically compiles those inverses into the surrounding gates, so the net circuit is logically identical and no physical operations are added. Averaged over many random choices this conjugates the error by every Pauli: the off-diagonal coherences cancel while the diagonal Pauli-error probabilities survive — a stochastic Pauli channel with the same infidelity but a diamond error scaling linearly with $r$ instead of as $\sqrt r$ . The cost is only classical: you run many randomized instances and average, which you often do anyway for statistics.

Does randomized compiling reduce the error, or just relabel it?

It does not lower the average infidelity at all — $r$ is a twirl invariant. What it changes is the type of error and hence the worst case: it trades a coherent error (dangerous, $\epsilon_\diamond\sim\sqrt r$ , able to add constructively across a circuit) for a stochastic one (benign, $\epsilon_\diamond\sim r$ , additive in probability). That trade is decisive because thresholds are stated in the diamond norm and stochastic errors are what QEC codes correct. Randomized compiling does not make gates more accurate on average — it makes their errors well-behaved and predictable, often worth more.

If a gate has high unitarity, is that good or bad?

Bad, if it comes with non-negligible infidelity. High $u\approx1$ means the noise is mostly coherent — a systematic rotation, not genuine decoherence — which puts the diamond error near its $\sqrt r$ ceiling, so the gate may violate a threshold it appears to pass by $\bar F$ . The silver lining is that coherent error is fixable: recalibrate the amplitude, null the detuning, echo away the crosstalk, and twirl away what remains. A gate whose unitarity instead sits on the depolarizing floor $u\approx(1-\tfrac{d}{d-1}r)^2$ has genuinely incoherent, $T_1/T_2$ -limited noise that no recalibration removes.