Introduction to Quantum Error Correction

1. Why Quantum Error Correction Is Hard¶

Before getting into actual quantum error correction, we explain what makes the quantum case harder than the classical one.

1.1 The Classical Repetition Code¶

On a classical computer, the simplest way to protect a bit $b$ from noise is the repetition code.

encode:   0 → 000     1 → 111
compute:  process while still encoded
recover:  read all 3 bits at the end, take a majority vote

Even if one bit flips along the way (000 → 010, say), the majority vote recovers the original value.

1.2 Encoding Works Fine on Quantum States Too¶

We carry the same idea over to quantum. Suppose we want to spread the logical state

across three qubits. Two CNOT gates produce the following state:

This is not three copies of the state ($(\alpha\lvert0\rangle+\beta\lvert1\rangle)^{\otimes 3}$); it is an entanglement spread across the three qubits. Encoding is built without trouble this way.

1.3 The Real Obstacle Is Correction¶

What breaks down is not encoding but correction.

The classical repetition code reads the three bits during correction and takes a majority vote. Classical bits are not destroyed by reading.

In the quantum case, “reading” is measurement, and measurement destroys superposition. If you measure $\alpha\lvert000\rangle+\beta\lvert111\rangle$ directly, it collapses to either $\lvert000\rangle$ or $\lvert111\rangle$, and $\alpha$ and $\beta$ are lost.

For the final readout at the end of a computation, “measure everything and take a majority vote” is fine, just as in the classical case. The problem is correcting during a computation — keeping the state intact for the rest of the computation while fixing only the error.

So quantum error correction does not measure the data itself. It measures only where and what kind of error occurred. This information about the location and type of the error is called the syndrome. “Syndrome” is originally a medical term for a set of symptoms; just as a doctor diagnoses a disease from its symptoms without observing it directly, error correction pins down the error from its “symptoms” alone, without measuring the error itself.

The syndrome is extracted through ancilla qubits, so the logical state ($\alpha,\beta$) is left untouched. This operation is syndrome measurement.

1.4 Another Difference: Phase Errors¶

There is one more difference between the classical and quantum cases.

Classical errors are only bit flips ($0 \leftrightarrow 1$). Qubits also have phase errors. The error that flips only the sign of $\lvert1\rangle$,

does not change any probability when measured in the computational basis, so a majority vote cannot detect it at all.

Quantum errors are also continuous — there are infinitely many intermediate errors, such as a qubit rotating slightly. Correcting each of these individually looks impossible, but in fact it is enough to consider only discrete errors.

The reasoning has two steps. First, any error on a single qubit can be written, as a matrix, as a linear combination of $I$ (do nothing), $X$, $Y$, $Z$. A small rotation, for instance, is a slight mixture of $I$ and $X$. Applying such an error to an encoded state turns it into a superposition of “no error”, “$X$ error”, “$Z$ error”, and so on.

Second, measuring the syndrome of this state collapses it onto one of the superposed cases. What is left after the measurement is a single discrete error, such as “an $X$ error on qubit $i$”. A continuous error is turned into a discrete Pauli error by syndrome measurement (we will see this collapse in action in the following sections).

So the only errors we need to correct are the full $X$, $Y$, $Z$. And since $Y=iXZ$, correcting $X$ and $Z$ automatically covers $Y$.

1.5 The Quantum Error Correction Flow¶

Quantum error correction proceeds as follows.

encode  →  error  →  syndrome measurement  →  correction

• Encode: spread one logical qubit across multiple physical qubits using entanglement.

• Syndrome measurement: extract only the location and type of the error into ancilla qubits, without measuring the logical state.

• Correction: apply a Pauli gate according to the syndrome to cancel the error.

From the next section on, we implement this flow with the simplest code — the 3-qubit bit-flip code.

Before getting into the implementation, we load Qamomile and the Qiskit integration and define two helper functions. _first_bit_distribution and _sample_first_bit are just utilities that compile and run a kernel and return the 0/1 counts of the first bit. They are not central to QEC, so feel free to skip them.

2. The 3-Qubit Bit-Flip Code¶

The first code we build is the bit-flip code. It is the simplest quantum error correction code, correcting just a single bit-flip ($X$) error. We implement the whole flow from 1.5 — encode → error → syndrome measurement → correction — with this code.

2.1 The Target Error: Bit Flip¶

An $X$ error flips a qubit, $\lvert0\rangle\leftrightarrow\lvert1\rangle$. It is the error corresponding to a classical bit flip. The bit-flip code aims to correct this single $X$ error.

2.2 The Code Space¶

We encode the logical state $\alpha\lvert0\rangle+\beta\lvert1\rangle$ into the 3-qubit state

The logical $\lvert0\rangle$ corresponds to $\lvert000\rangle$ and the logical $\lvert1\rangle$ to $\lvert111\rangle$. The space spanned by these two is called the code space, and the only valid codewords are $\lvert000\rangle$ and $\lvert111\rangle$.

2.3 The Encoding Circuit¶

Encoding is just one CNOT each from the data qubit $q_0$ to $q_1$ and $q_2$.

If $q_0$ is $\lvert1\rangle$, the two CNOTs flip $q_1$ and $q_2$ as well, giving $\lvert111\rangle$. If $q_0$ is $\lvert0\rangle$, nothing happens and it stays $\lvert000\rangle$. If $q_0$ is a superposition $\alpha\lvert0\rangle+\beta\lvert1\rangle$, the result is $\alpha\lvert000\rangle+\beta\lvert111\rangle$.

2.4 Syndrome Measurement: $Z$ Parity¶

To find the location of the error, we measure two parities (whether two qubits hold the same value).

• $S_0 = Z_0Z_1$ — whether $q_0$ and $q_1$ are equal

• $S_1 = Z_0Z_2$ — whether $q_0$ and $q_2$ are equal

In the code space ($\lvert000\rangle$ and $\lvert111\rangle$) all three qubits hold the same value, so both parities report “equal”. When a single $X$ error occurs, the parity pattern changes according to its location.

The three $X$ errors each show a distinct syndrome, so the syndrome uniquely determines the error location.

To measure $Z_iZ_j$, prepare an ancilla qubit, apply CX(data[i], anc) and CX(data[j], anc), then measure anc. Only the ancilla is measured; the data qubits are left untouched.

Let us follow a concrete example. Suppose an $X$ error hits the second qubit $q_1$ of the encoded state $a\lvert000\rangle+b\lvert111\rangle$. Since $X$ flips $q_1$, the state becomes

We add two ancilla qubits initialized to $\lvert00\rangle$ and perform syndrome measurement. CX adds the control qubit’s value into the ancilla by XOR, so

• $S_0=Z_0Z_1$: ancilla 1 receives $q_0\oplus q_1$. For $\lvert010\rangle$ it is $0\oplus1=1$; for $\lvert101\rangle$ it is $1\oplus0=1$.

• $S_1=Z_0Z_2$: ancilla 2 receives $q_0\oplus q_2$. For $\lvert010\rangle$ it is $0\oplus0=0$; for $\lvert101\rangle$ it is $1\oplus1=0$.

Both terms give the same ancilla values $(1,0)$, and the state evolves as follows.

The key point is that the two terms of the superposition give the same ancilla values. Because of this, measuring the ancilla does not destroy the superposition of $a$ and $b$. All the measurement yields is the syndrome $(s_0,s_1)=(1,0)$, which the table identifies as an $X$ error on $q_1$.

2.5 Correction¶

Once the syndrome is known, correction is just applying the same $X$ as the detected error, at the same location, once more. Since $X$ returns to the identity when applied twice ($X^2=I$), the error’s $X$ and the correction’s $X$ cancel out.

Continuing the previous example: the syndrome $(1,0)$ indicates an $X$ error on $q_1$, so applying $X$ to $q_1$ gives

restoring the encoded state exactly. The “Correction” column of the table above gives the correction for each syndrome.

2.6 Implementation and Run: Logical $\lvert1\rangle$¶

We collect everything into a single @qkernel. error_pos specifies where to inject the error, and the kernel performs encoding, error injection, syndrome measurement, and correction.

error_pos is a compile-time parameter. The values 0, 1, 2 inject an $X$ error at that location. The value 3 matches no branch, so it means “no error”.

First we prepare the logical $\lvert1\rangle$ (an ry gate with theta $=\pi$). If correction works, data[0] should always be 1.

2.7 Superposition Input¶

The code also preserves amplitudes. The state prepared with theta $=\pi/3$ has probability

This probability should be preserved regardless of the injected error.

2.8 Limitation: Powerless Against Phase Errors¶

The bit-flip code can correct only $X$ errors. It is powerless against the phase error $Z$.

The reason lies in how the $Z$ parity is measured. A $Z$ error only changes the sign of $\lvert000\rangle$ or $\lvert111\rangle$; it does not change the bit values. The $Z_iZ_j$ parity only looks at whether bits are equal, so even when a $Z$ error occurs the syndrome stays $(0,0)$ — the error cannot be detected.

Correcting $Z$ errors requires a different code. In the next section we build the phase-flip code, which uses Hadamard gates to move the bit-flip code into “the world of phases”.

3. The 3-Qubit Phase-Flip Code¶

The bit-flip code could correct only $X$ errors. Next we build a code that corrects the phase error $Z$. Rather than designing one from scratch, we reuse the bit-flip code “in a different basis”.

3.1 The Target Error: Phase Flip¶

A $Z$ error flips only the sign of $\lvert1\rangle$ ($\lvert0\rangle\to\lvert0\rangle$, $\lvert1\rangle\to-\lvert1\rangle$). As seen in 1.4, it is an error invisible when measured in the computational basis. The phase-flip code aims to correct this single $Z$ error.

3.2 The Key Identity: $H$ Swaps $X$ and $Z$¶

The Hadamard gate $H$ satisfies the following relations.

That is, conjugating by $H$ swaps $X$ errors and $Z$ errors. The bit-flip code could correct $X$ errors. If we change the basis of each qubit with $H$, that code becomes a code that corrects $Z$ errors. This is the phase-flip code.

3.3 The Code Space¶

Since $H\lvert0\rangle=\lvert+\rangle$ and $H\lvert1\rangle=\lvert-\rangle$, transforming the bit-flip codewords $\lvert000\rangle$ and $\lvert111\rangle$ with $H$ on all three qubits gives the logical states of the phase-flip code.

• $\lvert0_L\rangle = \lvert+++\rangle$

• $\lvert1_L\rangle = \lvert---\rangle$

Just as an $X$ error swaps $\lvert0\rangle\leftrightarrow\lvert1\rangle$ in the bit-flip code, a $Z$ error swaps $\lvert+\rangle\leftrightarrow\lvert-\rangle$ in the phase-flip code ($Z\lvert+\rangle=\lvert-\rangle$).

3.4 The Encoding Circuit¶

Encoding is just the bit-flip encoding followed by an $H$ on all three qubits.

3.5 Syndrome Measurement: $X$ Parity¶

For the bit-flip code we measured the $Z$ parity $Z_iZ_j$. For the phase-flip code, with $X$ and $Z$ swapped, we measure the $X$ parity $X_iX_j$.

To measure $X_iX_j$, prepare an ancilla in $\lvert+\rangle$ (apply $H$), use it as the control for CNOTs into the two data qubits, then apply $H$ again before measuring. The syndrome-to-error correspondence has the same shape as for the bit-flip code; only the correction changes from $X$ to $Z$.

3.6 Implementation and Run¶

We collect everything into a single @qkernel. This time we prepare the logical $\lvert0_L\rangle=\lvert+++\rangle$.

After correction, data[0] is back in $\lvert+\rangle$. Since $\lvert+\rangle$ measured directly gives 0 and 1 half the time, we apply one final $H$ to data[0] to turn it into $\lvert0\rangle$ before measuring. If correction works, data[0] should always be 0.

3.7 Limitation: Only One Error Type¶

The phase-flip code can correct $Z$ errors, but now it cannot correct $X$ errors. Since it is a basis transformation of the bit-flip code, the errors it can correct were simply swapped.

The bit-flip code handles only $X$, the phase-flip code only $Z$ — each corrects just one error type. But real noise causes both $X$ and $Z$, and also $Y$, where both occur at once. In the next section we combine the two codes into Shor’s 9-qubit code, which corrects any single-qubit error.

4. Shor’s 9-Qubit Code¶

Combining the bit-flip code and the phase-flip code should let us correct both $X$ and $Z$. Shor’s 9-qubit code is what realizes this.

4.1 The Idea: Nest Two Codes¶

Shor’s code encodes in two stages.

1. Encode one qubit into three with the phase-flip code.

2. Encode each of those three qubits into three more with the bit-flip code.

This spreads 1 → 3 → 9 qubits. This construction of “putting one more code inside a code” is called a concatenated code. The outer phase-flip layer handles $Z$ errors, and the inner bit-flip layer handles $X$ errors.

4.2 Viewing 9 Qubits as 3 Blocks¶

We view the 9 qubits as three blocks.

(q0, q1, q2)   (q3, q4, q5)   (q6, q7, q8)

Each block is the inner bit-flip code. The representatives of the three blocks, $q_0, q_3, q_6$, form the outer phase-flip code.

4.3 The Encoding Circuit¶

Encoding is just applying the outer phase-flip encoding to $q_0, q_3, q_6$, then bit-flip encoding each block.

4.4 Syndrome Measurement¶

Shor’s syndrome has 8 bits, split into two kinds.

• Intra-block $Z$ parities (anc[0]–anc[5], two per block): these are exactly the bit-flip code’s syndrome measurement, locating an $X$ error within each block.

• Inter-block $X$ parities (anc[6], anc[7]): the two parities $X_0X_1X_2X_3X_4X_5$ and $X_3X_4X_5X_6X_7X_8$. These correspond to the phase-flip code’s syndrome measurement, identifying the block containing a $Z$ error.

4.5 Why $Y$ Errors Are Corrected¶

Shor’s code corrects not only $X$ and $Z$ but also $Y$ errors. Since $Y=iXZ$, a $Y$ error contains both an $X$ component and a $Z$ component.

The intra-block $Z$ parities detect the $X$ component and the inter-block $X$ parities detect the $Z$ component, independently. With both the $X$ correction and the $Z$ correction applied, the $Y$ error is cancelled.

4.6 Implementation and Run¶

We collect everything into a single @qkernel. error_type is 1=X, 2=Y, 3=Z, and error_pos is the index of the qubit to inject the error into.

Even after correction, the logical state is still encoded across nine qubits. For this demonstration we apply the inverse encoding circuit at the end so that the logical bit can be read directly from q[0]. This inverse encoding is a step for checking the result; the correction itself is already complete with syndrome measurement and feedback.

We try one representative error per block ($X$ on block 0, $Y$ on block 1, $Z$ on block 2). If the logical $\lvert1\rangle$ is preserved, q[0] should always be 1.

4.7 Why It Corrects “Any Single Error”¶

Shor’s code corrects all three of $X$, $Y$, $Z$. This directly means it “corrects any single-qubit error”.

As seen in 1.4, any error can be written, as a matrix, as a linear combination of $I, X, Y, Z$, and syndrome measurement collapses that superposition into a single discrete Pauli error. What remains after the collapse is just one of $X$, $Y$, $Z$ (or no error), all of which Shor’s code can correct. This is why it handles any single-qubit error, including continuous ones.

The formal treatment is organized in the second part, Stabilizer Formalism and the Steane Code.

5. The Common Pattern¶

We have built three codes — bit-flip, phase-flip, and Shor. In fact all of them follow the same four-step template.

1. Encode into a code space: spread one logical qubit across multiple physical qubits using entanglement.

2. Parity measurement: instead of measuring the data directly, extract a parity of several qubits ($Z_iZ_j$ or $X_iX_j$) into ancilla qubits.

3. Syndrome: read the location and type of the error from the parity measurements.

4. Feedback correction: apply a Pauli gate according to the syndrome to cancel the error.

This skeleton does not change as the code changes. What differs is only “which parity to measure”.

5.1 Naming the Parity Operators: Stabilizers¶

The parity operators we have been measuring — $Z_0Z_1$, $X_0X_1$, and so on — have a name: stabilizers.

A stabilizer is a Pauli operator that leaves every state of the code space unchanged. Applied to a valid codeword, the state is unchanged (eigenvalue +1). When an error occurs, the measured value of a stabilizer that anticommutes with that error flips to -1, and that becomes a bit of the syndrome.

The $Z_0Z_1$ of the bit-flip code, the $X_0X_1$ of the phase-flip code, and the eight parities of Shor’s code are all stabilizers. The three codes were different manifestations of one idea: “measure stabilizers to obtain a syndrome.” This view is called the stabilizer formalism, and the second part treats it in earnest.

5.2 Summary of the Three Codes¶

We summarize the three codes together with their stabilizers.

$[[n,k,d]]$ is a notation for a code: $n$ is the number of physical qubits, $k$ is the number of logical qubits protected, and $d$ is the code distance. The distance $d$ is an indicator with the meaning “$d\ge3$ is required to correct any single-qubit error”. The 3-qubit codes have $d=1$ — they can correct only one specific type of error ($X$ or $Z$). Shor’s code has $d=3$ and corrects any single error. The precise definition of distance is covered in the second part.

6. Try It Yourself¶

To test your understanding, modify the code a little and run it.

• Change the error location: set error_pos of each *_syndrome_run to various values and confirm that correction works.

• Make it fail on purpose: below, we experience the limitation of the bit-flip code.

Make It Fail on Purpose¶

The bit-flip code can correct only up to a single $X$ error. What happens when $X$ errors occur at two locations?

The following kernel injects $X$ errors at two locations, data[0] and data[1], into the logical $\lvert1\rangle$ ($\lvert111\rangle$), and performs syndrome measurement and correction as usual.

data[0] becomes 0, not 1. Far from fixing the state, the correction turned the logical $\lvert1\rangle$ into the logical $\lvert0\rangle$.

With $X$ at two locations, $\lvert001\rangle$ looks “different in only one place” from $\lvert111\rangle$, so the correction applies an $X$ to the remaining location as well, ending at $\lvert000\rangle$. This is the limitation “up to a single error” — the actual meaning of the bit-flip code having $d=1$ in the table of 5.2.

7. Summary¶

In this article we implemented three quantum error correction codes.

• The 3-qubit bit-flip code — corrects a single $X$ error with $Z$ parity checks.

• The 3-qubit phase-flip code — corrects a single $Z$ error with $X$ parity checks.

• Shor’s 9-qubit code — concatenates the two and corrects any single-qubit error ($X,\ Y,\ Z$).

The common skeleton was “encode into a code space → parity (stabilizer) measurement → syndrome → feedback correction”.

Next¶

The second part, Stabilizer Formalism and the Steane Code, treats the stabilizers — only named here — formally. Its main subjects are the CSS construction, which systematically builds quantum codes from classical codes, and the Steane code, which achieves $d=3$ with seven qubits, fewer than Shor’s nine.