Make your paper interactiveCreate

Text from the interactive explanation

Quantum Error Mitigation Relying on Permutation Filtering

Yifeng Xiong, Soon Xin Ng, Lajos Hanzo

Original paper

Quantum error mitigation · permutation filters

In today's quantum processors every operation carries a small chance of error, so long calculations blur. Xiong, Ng and Hanzo build a notch filter for a quantum computer's errors, and it works better the deeper the circuit gets.

intended answer (biggest ingredient)

63 error states

filter response (stalk tips sit on it)

3 copies alone

zeros of the filter

Stalk height shows how loudly each ingredient comes through the filter, relative to the answer, on a log (decibel) scale. Live simulation (6 qubits, the paper's circuit layout, depolarising noise) — it illustrates the mechanism; the paper's own results use 10 qubits.

Every step leaks

A quantum computer steers a handful of qubits through a sequence of operations called gates. The paper's test circuits repeat one building block, a stage: every pair of qubits is twisted together (a ZZ rotation), then every qubit is turned about two axes (Rx and Ry). Stack more stages and the circuit gets deeper.

Each gate has a small chance of going wrong. In the paper's model a two-qubit gate fails ten times more often than a single-qubit gate, and a failure scrambles the qubits it touched (depolarising noise).

So the machine does not output one wrong answer. It outputs a blend: mostly the intended state, mixed with many slightly wrong versions. Physicists call this a mixed state, written ρ. The share each ingredient gets is an eigenvalue of ρ, written λ₁ ≥ λ₂ ≥ … With 6 qubits there are 64 ingredients: the biggest one (λ₁), which is a close stand-in for the noise-free answer when the noise isn't extreme, and 63 error states.

Each stage: 15 ZZ links (one per qubit pair), then Rx and Ry on every qubit. Sparks illustrate where errors can strike; the simulation tracks every possibility at once.

Live simulation (6 qubits, the paper's circuit layout, depolarising noise): every number above is computed in your browser from the exact 64×64 density matrix.

At about 3 expected errors per run, is the intended answer still the single biggest ingredient?

Copies make the majority louder

Virtual distillation (prior work by Koczor, and by Huggins and colleagues, as cited in the paper) exploits that fact. Prepare n copies of the same noisy output, pass them through a cyclic-shift circuit Pₙ built from controlled-SWAP gates, and measure. The measured value equals Tr{ρⁿU}/Tr{ρⁿ}: it is as if every ingredient's share were raised to the n-th power and the blend renormalised.

Raising to a power favours the big. Take an answer at 60% and an error state at 0.6%: squared, they become 36% and 0.0036%. The gap between them grows from 100× to 10,000×.

n copies → cyclic shift → measure

Using your circuit from chapter 1.

The cost: n copies run side by side (n times the qubits), Nq(n−1) controlled-SWAP (Fredkin) gates for the shift, and more repetitions of the whole experiment.

The pink line is the filter's spectral response, h(λ) = λⁿ: on these log–log axes it is a straight line whose slope grows by 10 dB per decade with every copy (10 dB means 10×). The paper calls virtual distillation a high-pass filter in the spectral domain: big shares pass, small shares are pushed down.

The noise has a shape

Copies treat every error state the same way: smaller means quieter. But where do the 63 error states actually sit?

As the circuit gets deeper, do the 63 error states spread out or bunch together?

The error crowd, zoomed in

histogram of the 63 error-state shares

Pareto curve fitted from Tr ρ² and Tr ρ³ only

estimated centre μ̂ (from measurable traces)

The paper measures this with the relative noise bandwidth b: the standard deviation of the 63 error shares divided by their average. A b near 1 is a wide, ragged crowd; b = 0.05 means nearly every error state holds the same share.

Why does depth narrow the crowd? Each noisy stage scrambles the state a little more, nudging the blend towards “every error state equally likely”, the completely mixed state. The paper proves that b shrinks exponentially with gate error rate × depth (Proposition 4). It is like a crowd's chatter settling into a steady hum at one pitch.

On real hardware nobody can list these 63 numbers. But the copy circuits also measure Tr ρ² and Tr ρ³ (the 2- and 3-copy “purities”). From just those, the paper fits a smooth Pareto curve, f(λ) = kλₘᵏλ−(k+1), to the crowd, and estimates its centre μ̂ = (1 − λ̂₁)/(2Nq − 1), with λ̂₁ = (Tr ρ³)1/3.

Build a notch

Here is the paper's idea. Run the 3-copy circuit, the 2-copy circuit and the plain circuit one after another on the same qubits, then add their measured results with weights α. Together they act like a polynomial of the blend:

The β's are zeros: shares at which the filter outputs nothing, like an audio notch filter that removes a hum at one pitch. The weights follow from the zeros, α = [1, −(β₁+β₂), β₁β₂]. Copies alone is the special case β₁ = β₂ = 0. The quantum gates are the same as for distillation; what changes is the classical weighting, plus extra repetitions.

Your turn: drag the pink diamonds along the axis, tap the spectrum to place the two zeros one after the other, or use the sliders. Try to park the zeros inside the cyan crowd.

Live simulation (6 qubits, the paper's circuit layout, depolarising noise) — it illustrates the mechanism; the paper's own results use 10 qubits.

Noise left is the paper's design metric, ε(β) = Σi≥2 |h(λᵢ)| / h(λ₁): everything that leaks through the filter, relative to the answer. It is an upper bound on the error of any Pauli measurement (eq. 20), so a smaller ε protects every such measurement at once.

Every valley leads to the same floor

Type-2 needs a search: find the pair of zeros that minimises the predicted leak. Searches often get stuck in a local dip that is not the deepest one. The paper proves this one cannot (Proposition 1). The landscape is not necessarily a simple bowl, yet every flat spot inside the allowed region is the global minimum. Mathematicians call such a function invex, and it means a simple downhill walk always finds the best filter.

Across: zero 1 (β₁) · Up: zero 2 (β₂) · both from 0 to —. The grey half repeats the coloured half with the zeros swapped.

Darker means less predicted leak (computed from the Pareto fit, log colour scale). Tap anywhere to drop a marble: it steps downhill, then the zeros are sorted back into order (the paper's projection step).

copies alone (both zeros at 0)

Type-1 (both zeros at μ̂)

marbles and their lowest point

Why depth helps

A notch only helps if the noise sits in the notch. Copies alone push the crowd down by a fixed 10 dB per decade per copy, whatever its shape; the notch gains when the crowd is narrow.

The paper makes this precise. The error ratio R = ε(filter) / ε(copies alone, same order) shrinks like bN−1: roughly 10 dB per decade of 1/b for a 2nd-order filter and 20 dB per decade for 3rd order (Propositions 2–3, Fig. 11). Test it on the live simulation: the sweep deepens the circuit from 2 to 40 stages and plots each point as it arrives.

2nd order: Type-1 vs 2 copies

3rd order: Type-1 vs 3 copies

paper's predicted slopes (10 and 20 dB per decade)

Live simulation (6 qubits, one random circuit, 0.36% two-qubit error). The paper's Fig. 11 uses 10 qubits averaged over 100 random circuits.

Same total noise, two ways

Hold the expected number of errors per run at 0.7. You can get there with a few stages of noisier gates or many stages of cleaner gates. Which gives the filter the bigger edge over copies alone? Predict, then run both.

In the paper's words, the benefit “is more significant when the circuit is rather noisy, or it is deep but is constituted by gates having relatively small error probabilities.”

What the paper found

The paper then tests the filters on a practical job. A base station with 10 antennas hears 10 phones transmitting at once; working out which bits each phone sent is a hard optimisation problem (multi-user detection, a “quadratic unconstrained binary optimization problem”). QAOA, the quantum approximate optimisation algorithm, attacks such problems with a quantum circuit whose tunable knobs are adjusted by a classical optimiser. The paper simulates it on 10 qubits with 0.7 expected errors per run, at depths from 10 to 150 stages.

Error of the computed result vs circuit depth (Fig. 13a)

Redrawn from Fig. 13 of Xiong, Ng & Hanzo; values read approximately from the published plot (10 qubits, 0.7 expected errors). Hover or tap the chart for values. Lower is better; 10 dB = 10× smaller error.

At 150 stages the 3rd-order filter's error is about 6.5 dB (≈4.5×) lower than 3rd-order distillation, and the 2nd-order filter's is about 10.8 dB (≈12×) lower than 2nd-order distillation.

For shallow circuits the filters gain little: at 10 stages all four mitigated curves lie within about 2 dB of each other, and the 3rd-order filter tracks 3rd-order distillation up to about 30 stages. While the noise is still spread out, the notch has little to grab.

Distillation alone flattens out with depth (2nd order stalls near −27.5 dB); the filters keep improving. This is the depth advantage predicted in chapter 6.

The price: more repetitions

Error mitigation trades a smaller bias for more statistical scatter, so each circuit must be repeated more often. The paper reports this as a sampling overhead factor.

At 0.7 expected errors, roughly constant with depth (Fig. 13b)

At 50 stages, as the noise grows (Fig. 14b, 2nd order)

The filters use the same gates as distillation, so they need no quantum hardware beyond what distillation already uses, but the overhead “increases dramatically when the number of expected errors is larger than 1”. Values redrawn approximately from Figs. 13b and 14b.

Back to the question

Can deeper quantum circuits keep their answer? Here is what you have seen.

Same quantum recipe, smarter weights. A permutation filter runs the same copy-and-shift circuits as virtual distillation. Only the classical weights change, plus more repetitions.

The advantage grows where circuits get deep. Deep noisy circuits squeeze the error states into a narrow band (Proposition 4), and a notch removes narrowband noise polynomially better than copies alone (Propositions 2–3).

The best weights are always findable. The design landscape is invex, so a downhill search reaches the global optimum (Proposition 1).

It is not free. The number of repetitions grows, and it explodes once a circuit averages more than about one error. The design metric bounds the error of every Pauli measurement at once; metrics tailored to specific measurements are the authors' suggested next step.

Source & credits

Paper: Yifeng Xiong, Soon Xin Ng, Lajos Hanzo. “Quantum Error Mitigation Relying on Permutation Filtering.” School of Electronics and Computer Science, University of Southampton. Manuscript PDF hosted by the University of Southampton (2022): southampton.ac.uk/~sxn/paper/2022_qfilter.pdf

Live simulation: the Spectrum Stage, chapters 1–6 and the opening scene run a 6-qubit re-implementation of the paper's circuit layout (Fig. 7: ZZ rotations on every qubit pair, then Rx and Ry on every qubit, random angles in [−π, π]) with depolarising noise, two-qubit gates ten times noisier than single-qubit gates. It is exact for that small system and is meant to illustrate the mechanism; the paper's own results use 10 qubits and average over 100 random circuits. Type-1, Type-2 and “optimal” filters follow the paper's definitions (eqs. 17, 20, 27–28, 31, 35 and Algorithm 1).

Redrawn figures: the chapter 7 charts are redrawn approximately from the paper's Figs. 13 and 14. Circuit sparks in chapter 1 are illustrative.

Prior work: virtual distillation is due to Koczor and to Huggins et al., as cited in the paper. The notch-filter, zeros and dB-per-decade language follows the paper's own signal-processing framing (FIR-like filters).

Topics in this iPaper

Physics
technologies have entered the era of noisy intermediate-scale quantum (NISQ) computation

Section I (Introduction), page 1

Computer science
Quantum error mitigation (QEM) is a class of promising techniques capable of reducing the computational error of variational quantum algorithms

Abstract, page 1

Engineering
These filters assume a similar form as the finite impulse response (FIR) filters widely used in classical signal processing tasks

Section I (Introduction), page 2

quantum error mitigation
Quantum error mitigation (QEM) is a class of promising techniques

Abstract, page 1

virtual distillation
namely the virtual distillation (VD) [34], [35], has been proposed, which relies on the permutation symmetry of quantum states

Section I (Introduction), page 2

variational quantum algorithms
reducing the computational error of variational quantum algorithms tailored for current noisy intermediate-scale quantum computers

Abstract, page 1

finite impulse response filter
finite impulse response (FIR) filters widely used in classical signal processing tasks

Section I (Introduction), page 2

quantum approximate optimization algorithm
we demonstrate the performance of permutation filters when applied to a practical variational quantum algorithm, namely the QAOA

Section V-C, page 12

multi user detection
we construct the phase Hamiltonian corresponding to the multi-user detection problem [51] for wireless communication systems

Section V-C, page 12

Quantum Error Mitigation Relying on Permutation Filtering — Interactive explanation | iPaper.ai