Text from the interactive explanation
Duality of Quantum and Classical Error Correction Codes: Design Principles and Examples
Zunaira Babar, Daryus Chandra, Hung Viet Nguyen, Panagiotis Botsinis, Dimitrios Alanis, Soon Xin Ng, Lajos Hanzo
Original paperQuantum and classical error correction, side by side
Engineers spent seventy years perfecting codes that protect ordinary bits. Can that playbook protect qubits, which can't be copied, can't be looked at, and break in ways bits can't?
Picture a quantum internet: quantum computers linked across continents, secret keys that no eavesdropper can copy, clocks synchronised more precisely than ever. That is the possibility this paper starts from, along with what stands in its way: qubits are fragile, and every channel and every piece of quantum hardware is imperfect.
Zunaira Babar, Lajos Hanzo and colleagues at the University of Southampton answer with a step-by-step tutorial on the duality between classical and quantum codes. The live picture is where it leads.
Watching. The first error strikes in a moment. You can also tap any qubit to strike it yourself.
The classical playbook: copy and vote
A bit is a 0 or a 1: a voltage, a pit on a disc, a pulse of light. Noise sometimes flips it. The oldest fix is to send every bit three times, 0 → 000 and 1 → 111, and let the receiver take a majority vote.
One flipped copy is out-voted. It takes two flips in the same triple to fool the vote, which is far rarer: without the code a fraction p of bits arrive wrong; with it only 3p² − 2p³ do. At p = 10 % that is 2.8 %.
The price is three times as many bits sent: a code rate of 1/3. The paper calls this rate-1/3 repetition code the simplest single-error-correcting code, and uses it as the seed from which every quantum code on this page grows.
Drag p towards 50 % and the vote stops helping: when a flip is as likely as not, copies carry no information.
Find the error without reading the message
Majority voting has to read every bit. There is a subtler way to decode, and it turns out to be the key to everything that follows. Instead of reading the bits, ask two yes/no questions: does bit 1 agree with bit 2? and does bit 1 agree with bit 3? Engineers write such questions as a parity-check matrix; the pattern of answers is the syndrome.
Tap a bit to let noise flip it.
Three walls between bits and qubits
A qubit is the quantum version of a bit. It can be 0, 1, or a blend of both at once, a superposition written α|0⟩ + β|1⟩, where α² and β² are the odds of finding 0 or 1 if you look. The blend is the precious part: it is what quantum computers compute with. And it puts three walls in front of copy-and-vote.
1You can't copy a qubit
The natural copier is a CNOT gate: it flips a blank qubit only if the original is 1. For a plain 0 or 1 that is a perfect copy. Slide to a blend:
This is the no-cloning theorem. The paper's way around it: copy the labels, not the blend . α|0⟩ + β|1⟩ becomes α|000⟩ + β|111⟩, three qubits entangled into one shared state.
2You can't look
Reading a qubit forces it to choose 0 or 1, with odds α² and β². Here the blend is 0.8|0⟩ + 0.6|1⟩.
A fresh qubit in the blend 0.8|0⟩ + 0.6|1⟩. Reading it will force a choice.
So a quantum decoder may never read the message qubits. The paper's way around it: measure only comparisons , exactly like the lamps in chapter 1.
3A new kind of error
Noise can flip 0 ↔ 1 (a bit flip, X), flip the sign between the two parts of the blend (a phase flip, Z), or both (Y).
The paper's way around it: look through Hadamard glasses . In the +/− view a phase flip is just a bit flip, so the same repetition trick catches it.
The repetition code, reborn as a quantum code
Put the three fixes together. Two helper qubits are entangled with the message, α|0⟩ + β|1⟩ → α|000⟩ + β|111⟩. To decode, extra helper qubits ask only “does qubit 1 agree with qubit 2?” and “does qubit 1 agree with qubit 3?”, the same parity checks as before, answered without ever reading the message.
In the flip guard, strike qubit 2 with a bit flip, press Check, then Repair. Back to 100 %.
Now strike with a phase flip and Check. The lamps stay dark, yet the match drops: this guard is blind to phase.
Switch to the phase guard. Phase flips are now caught (and bit flips slip through).
Try a partial flip, a small continuous error. Check it a few times: the measurement snaps it to “nothing” or “one whole flip”, and either way the repair is perfect.
Peek at all three qubits, and watch the message vanish.
Nine qubits, both guards: be the decoder
In 1995 Peter Shor published the first quantum error-correcting code; until then, the paper notes, quantum error correction was widely believed impossible. Each row below is a flip guard. The two cyan bands compare the rows' phases. These eight checks are the code's stabilizers: measurements that return +1 on every valid codeword and −1 when an error disturbs them.
The eight checks (stabilizers)
Each check is a string of Pauli letters, one per qubit (I = ignore this qubit). The flip checks are built from Z letters and the phase checks from X letters: a check notices exactly the errors that clash with it, and X and Z clash. Lit rows are the ones the hidden error disturbs.
Rule of thumb: inside a row, the lit flip checks point to one qubit (like Table IV). Between rows, the lit phase bands point to one block. Any Z on that block repairs a phase flip, because Z on two qubits of the same block is itself one of the checks and does nothing to a valid codeword. That freedom is called degeneracy, and it has no classical counterpart.
The dictionary: every qubit error is two bits
Here is the duality at the heart of the paper. Any error on one qubit is a combination of a flip part and a phase part. Write each part as one bit and a quantum code becomes a classical code of twice the length, so classical tools and decoders can be reused almost unchanged.
Left bit = phase (Z) part, right bit = flip (X) part, as in the paper's Eq. 75. Multiplying two errors is just adding their bits. The paper also gives a four-symbol version, I → 0, X → 1, Z → ω, Y → ω̄, which lets four-letter classical codes be imported.
A set of checks is then a binary parity-check matrix H = (Hz | Hx). One rule has no classical counterpart: two checks can be measured together only if they commute , which happens when they clash (different non-identity letters on the same qubit) at an even number of positions. In bits, the “symplectic product” of their rows must be zero. Explore it below: click any tile to change it.
Do the checks commute?
If checks clash, the paper's fix is entanglement assistance: give the receiver one half of a pre-shared entangled pair (an ebit) and extend the clashing checks onto it. In the paper's example (Eq. 111–112) one ebit suffices. The paper notes that example is an arbitrary illustration, not a good code.
Shorter codes, higher rates
Each dot is a physical qubit; amber dots count the message qubits protected. Through the dictionary, a quantum code of rate R corresponds to an equivalent classical binary code of rate (1 + R)/2.
All four correct any single-qubit error. The five-qubit code is the shortest that can; it treats flips and phases jointly instead of with separate guards. The quantum BCH code is one of the paper's two worked design examples, alongside quantum convolutional codes.
How far can quantum codes go?
For classical channels, Shannon's limit says how much information can be sent reliably through a given amount of noise. Its quantum twin, the hashing bound, does the same for qubits hit by random X, Y and Z errors, and pre-shared entanglement raises it.
Curves computed from the paper's Eq. 27–28, as in its Fig. 12. They are limits for infinitely long codes, not the performance of any particular code.
Published codes approach the bound, but only with blocks of 2,000 to 821,760 qubits. Reproduced from Fig. 16 of Babar et al. (2019), CC BY 3.0; cropped.
The paper flags the catch: such long codewords are “particularly detrimental in the quantum domain”, because qubits may lose their state faster than a long block can be corrected. Until hardware improves, short codes like the ones on this page matter most.
Seven decades, then a sprint
The paper's history table lines up classical and quantum milestones. For almost fifty years the quantum column is empty. Then, once Shor showed it could be done, quantum versions of the classical families arrived one after another, often within a few years.
Redrawn after Table I of the paper; years approximate.
Back to the quantum internet
The opening question was whether the classical playbook could protect qubits. The paper's answer: not directly, but almost entirely, once three design principles are in place.
The no-cloning wall is passed by copying |0⟩ and |1⟩, not the blend (chapter 2–3).
Syndrome decoding finds the error without reading the message (chapters 1, 3, 4).
Phase flips become bit flips in the +/− view, so the same codes catch them (chapter 2–3).
On top of these principles sits the dictionary of chapter 5: checks are a parity-check matrix, each qubit error is two bits, and the only new rule is that checks must commute. With it, the paper concludes, virtually all major families of classical codes now have a quantum counterpart; it singles out parallel-concatenated codes and joint coding-and-modulation schemes as the exceptions. Its worked examples carry two classical families across: BCH codes and convolutional codes.
What remains open, in the authors' words, is a balancing act among coding rate, qubit error rate, entanglement consumption, delay and complexity, and above all codes short enough to finish before the qubits decohere. Every one of those future codes will run on the idea you watched at the top of this page: find the error without looking at the message .
↑ Back to the live lattice
Source and credits
Zunaira Babar, Daryus Chandra, Hung Viet Nguyen, Panagiotis Botsinis, Dimitrios Alanis, Soon Xin Ng and Lajos Hanzo. “Duality of Quantum and Classical Error Correction Codes: Design Principles and Examples.” IEEE Communications Surveys & Tutorials, vol. 21, no. 1, pp. 970–1010, 2019. DOI: 10.1109/COMST.2018.2861361. Full text: author-hosted PDF.
The article is licensed under Creative Commons Attribution 3.0. Fig. 16 is reproduced from the article (cropped). Table I is redrawn as an interactive timeline. Codes, check strings, lookup tables and bounds follow the article's equations.
The paper is a survey and tutorial: its constructions are derived analytically, and its benchmark figure compiles previously published codes. The interactive simulations on this page are illustrative implementations of the paper's constructions, assuming perfect gates, perfect check measurements and independent random single-qubit errors. They are not results reported in the paper.
Topics in this iPaper
Physics
Quantum technology derives its strengths from harnessing the peculiar laws of quantum physics, namely the super-position and entanglement.
Section I, page 971
Engineering
Index Terms—Channel coding, quantum error correction, BCH codes, convolutional codes.
Abstract, page 970
Computer science
The quantum-to-classical mapping allows us to use the state-of-the-art classical syndrome decoding techniques in the quantum realm
Section I-A (Outline), page 974
quantum error correction
Quantum error correction codes (QECCs) can be constructed from the known classical coding paradigm
Abstract, page 970
channel coding
Index Terms—Channel coding, quantum error correction, BCH codes, convolutional codes.
Abstract, page 970
stabilizer codes
the stabilizer formalism provides a general theoretical framework for designing the quantum versions of the known classical codes.
Section V, page 989
bose chaudhuri hocquenghem codes
Quantum BCH codes [94]–[99] can be derived from the classical dual-containing binary BCH codes
Section VIII-A, page 1000
convolutional codes
Let us now design a CSS-type rate-1/3 QCC [168], [169] from a classical self-dual rate-2/3 binary convolution code
Section VIII-B, page 1004