Building the 9-Qubit Shor Code Encoder

Recommended resources

The freely available resources this lesson will direct you to.

Hello! Welcome to the sixth lesson in our module on Quantum Error Correction Fundamentals.

In our previous lesson, we implemented the 5-qubit "perfect" code. We saw how to construct syndrome measurement circuits and use the resulting syndrome—a unique fingerprint for each single-qubit error—to perform a correction. This provided a concrete application of the stabilizer formalism we had developed.

Today, we turn our attention to the first quantum error-correcting code ever discovered: the 9-qubit Shor code. Our goal is to construct the encoding circuit for the 9-qubit Shor code and demonstrate that it is a stabilizer code. This code introduces the powerful concept of concatenation and showcases a different approach to protecting a logical qubit.

1. Concatenated Codes: Building the Shor Code

The Shor code elegantly protects against both bit-flip ( $X$ ) and phase-flip ( $Z$ ) errors by composing, or concatenating, two simpler codes.

Inner Code: 3-Qubit Bit-Flip Code
This code protects against a single $X$ error. It encodes a single qubit state $∣ q ⟩$ into three qubits:
- $|0\rangle \to |000\rangle$
- $|1\rangle \to |111\rangle$
  The circuit for this is simply two CNOT gates, with the input qubit as the control and two ancillas as targets.
Outer Code: 3-Qubit Phase-Flip Code
This code protects against a single $Z$ error. It achieves this by performing the bit-flip encoding in the Hadamard basis ( $∣ + ⟩, ∣ - ⟩$ ). The encoding is:
- $|0\rangle \to |+_L\rangle = \frac{1}{\sqrt{2}}(|000\rangle + |111\rangle)$
- $|1\rangle \to |-_L\rangle = \frac{1}{\sqrt{2}}(|000\rangle - |111\rangle)$
  The circuit for this involves first creating a GHZ-like state.

The Shor code is constructed by first applying the phase-flip encoding and then applying the bit-flip encoding to each of the three resulting qubits.

2. The Encoding Circuit

Let's construct the circuit for encoding an initial state $∣ ψ ⟩ = α ∣0 ⟩ + β ∣1 ⟩$ on qubit $q_{0}$ into the 9-qubit Shor code state, using qubits $q_{1}, \dots, q_{8}$ as ancillas (initially in the $∣0 ⟩$ state). The process is as follows:

Outer Encoding (Phase-Flip Part): We first create the superposition characteristic of the phase-flip code. This involves entangling the input qubit $q_{0}$ with two other qubits, say $q_{3}$ and $q_{6}$ .
- Apply a Hadamard gate to $q_{0}$ .
- Apply CNOT gates from $q_{0}$ to $q_{3}$ and from $q_{0}$ to $q_{6}$ .
  After this stage, the state on qubits $(q_{0}, q_{3}, q_{6})$ is $α \frac{∣000 ⟩ + ∣111 ⟩}{2} + β \frac{∣000 ⟩ - ∣111 ⟩}{2}$ .
Inner Encoding (Bit-Flip Part): Now, we apply the bit-flip code to each of the three qubits from the previous step. We group the nine qubits into three blocks: $(q_{0}, q_{1}, q_{2})$ , $(q_{3}, q_{4}, q_{5})$ , and $(q_{6}, q_{7}, q_{8})$ .
- Block 1: Apply CNOTs from $q_{0}$ to $q_{1}$ and $q_{2}$ . This encodes the state of $q_{0}$ .
- Block 2: Apply CNOTs from $q_{3}$ to $q_{4}$ and $q_{5}$ . This encodes the state of $q_{3}$ .
- Block 3: Apply CNOTs from $q_{6}$ to $q_{7}$ and $q_{8}$ . This encodes the state of $q_{6}$ .

The following resource from IBM Quantum's learning platform illustrates this exact construction.

The 9-qubit Shor code

The article 'The 9-qubit Shor code' provides an excellent description of the code's construction as a concatenated code and presents the corresponding encoding circuit.

Please read the first two subsections, 'Code description' and 'Correcting bit-flip and phase-flip errors'. Focus on the structure of the encoding circuit diagram. Note how it's composed of an initial 'outer code' part followed by three parallel 'inner code' blocks. This directly visualizes the concatenation process we've just discussed.

The resulting logical basis states, $∣ 0_{L} ⟩$ and $∣ 1_{L} ⟩$ , are:
$∣ 0_{L} ⟩ = (\frac{∣000 ⟩ + ∣111 ⟩}{2}) \otimes (\frac{∣000 ⟩ + ∣111 ⟩}{2}) \otimes (\frac{∣000 ⟩ + ∣111 ⟩}{2})$
$∣ 1_{L} ⟩ = (\frac{∣000 ⟩ - ∣111 ⟩}{2}) \otimes (\frac{∣000 ⟩ - ∣111 ⟩}{2}) \otimes (\frac{∣000 ⟩ - ∣111 ⟩}{2})$
These expressions can look intimidating, but they follow directly from the circuit: the outer encoding creates the three identical superpositions, and the inner encoding replaces each $∣0 ⟩$ with $∣000 ⟩$ and each $∣1 ⟩$ with $∣111 ⟩$ .

3. The Shor Code as a Stabilizer Code

Now we need to demonstrate that this code fits into the stabilizer formalism we've been using. A stabilizer code is the simultaneous $+ 1$ eigenspace of a set of commuting Pauli operators, known as the stabilizer generators. For the 9-qubit Shor code, we need $n - k = 9 - 1 = 8$ independent generators.

Where do these generators come from? They arise directly from the stabilizers of the constituent codes.

Stabilizers for Bit-Flip Errors

The inner code (bit-flip code) for each of the three blocks is stabilized by operators that check if adjacent qubits are the same. These are:

Block 1 (qubits 0,1,2): $Z_{0} Z_{1}$ , $Z_{1} Z_{2}$
Block 2 (qubits 3,4,5): $Z_{3} Z_{4}$ , $Z_{4} Z_{5}$
Block 3 (qubits 6,7,8): $Z_{6} Z_{7}$ , $Z_{7} Z_{8}$

This gives us our first six stabilizer generators. For example, consider $Z_{0} Z_{1}$ . In the state $∣ 0_{L} ⟩$ , it acts on terms like $∣000 ⟩_{012}$ and $∣111 ⟩_{012}$ . In both cases, the eigenvalues of $Z_{0}$ and $Z_{1}$ are the same ( $+ 1, + 1$ or $- 1, - 1$ ), so their product is $+ 1$ . The state is thus stabilized.

Stabilizers for Phase-Flip Errors

The outer code protects against phase-flips by encoding the logical information in the relative phase of a GHZ-like state. The stabilizers for this code must check the parity of the blocks. These operators act across the three blocks:

$X_{0} X_{1} X_{2} X_{3} X_{4} X_{5}$
$X_{3} X_{4} X_{5} X_{6} X_{7} X_{8}$

This provides the final two stabilizer generators. Let's check one, for instance $g_{6} = X_{0} X_{1} X_{2} X_{3} X_{4} X_{5}$ . This operator acts as $X^{\otimes 3}$ on the first block and $X^{\otimes 3}$ on the second block. We know that $X^{\otimes 3} (∣000 ⟩ \pm ∣111 ⟩) = ∣111 ⟩ \pm ∣000 ⟩$ .
When we apply $g_{6}$ to $∣ 0_{L} ⟩$ , it transforms:

(\frac{∣111 ⟩ + ∣000 ⟩}{2}) \otimes (\frac{∣111 ⟩ + ∣000 ⟩}{2}) \otimes (\frac{∣000 ⟩ + ∣111 ⟩}{2})

This is exactly the original state $∣ 0_{L} ⟩$ . The same holds for $∣ 1_{L} ⟩$ .

The following lecture notes formally list these generators and define the Shor code in terms of them.

Recap of Shor code - Lecture #25

These lecture notes from UC Berkeley's course on ECC concisely define the Shor code via its logical states and explicitly list its eight stabilizer generators.

Please read Section 2, 'Recap of Shor code', and the first part of Section 3, 'Stabilizer Codes'. Pay close attention to the list of 8 stabilizer generators (labeled P1...P8) in Section 2.1. Note that the notes use a slightly different, but equivalent, set of generators (e.g., Z1Z2 and Z2Z3 instead of Z1Z2 and Z1Z3). Section 3 reinforces the definition of a stabilizer code, confirming that the Shor code is a primary example.

The eight generators you saw are:

Bit-flip checks (6 generators):
- $g_{0} = Z_{0} Z_{1}$
- $g_{1} = Z_{1} Z_{2}$
- $g_{2} = Z_{3} Z_{4}$
- $g_{3} = Z_{4} Z_{5}$
- $g_{4} = Z_{6} Z_{7}$
- $g_{5} = Z_{7} Z_{8}$
Phase-flip checks (2 generators):
- $g_{6} = X_{0} X_{1} X_{2} X_{3} X_{4} X_{5}$
- $g_{7} = X_{3} X_{4} X_{5} X_{6} X_{7} X_{8}$

All these operators are products of Pauli matrices, they all commute with each other (you can verify this), and they form an independent set of generators for an Abelian group. The Shor code is defined as the 2-dimensional subspace of the full $2^{9}$ -dimensional Hilbert space that is simultaneously stabilized by all eight of these operators. This confirms that the Shor code is indeed a [[9, 1, 3]] stabilizer code.

Test your understanding!

Let's say an error $E = X_{7}$ occurs. Which of the eight stabilizer generators will anti-commute with this error, thus flipping their measured eigenvalue from +1 to -1?

Show answer

We need to find the generators $g_{i}$ that have a non-identity Pauli operator on qubit 7 that is not $X$ .

$g_{0}, g_{1}, g_{2}, g_{3}$ : Act on qubits 0-5. They commute with $X_{7}$ .
$g_{4} = Z_{6} Z_{7}$ : Has $Z_{7}$ at qubit 7. Since ${X_{7}, Z_{7}} = 0$ , this generator anti-commutes. Eigenvalue flips.
$g_{5} = Z_{7} Z_{8}$ : Has $Z_{7}$ at qubit 7. Since ${X_{7}, Z_{7}} = 0$ , this generator anti-commutes. Eigenvalue flips.
$g_{6} = X_{0} X_{1} X_{2} X_{3} X_{4} X_{5}$ : Acts on qubits 0-5. It commutes with $X_{7}$ .
$g_{7} = X_{3} X_{4} X_{5} X_{6} X_{7} X_{8}$ : Has $X_{7}$ at qubit 7. Since $[X_{7}, X_{7}] = 0$ , this generator commutes.

So, only generators $g_{4}$ and $g_{5}$ will anti-commute with an $X_{7}$ error. The resulting syndrome will signal a bit-flip error in the third block, localized to qubit 7.

Conclusion

In this lesson, we dissected the 9-qubit Shor code, the pioneering work in quantum error correction. We saw how it is not a monolithic construction, but rather a clever composition of two simpler codes.

Key Takeaways:

The Shor code is a concatenated code, combining a 3-qubit phase-flip (outer) code and three 3-qubit bit-flip (inner) codes.
The encoding circuit reflects this structure: an initial stage entangles three qubits for phase protection, followed by three parallel blocks of bit-flip encoding.
The Shor code is a stabilizer code. Its eight generators are inherited from its constituent parts: six $ZZ$ -type generators check for bit-flips within blocks, and two $X^{\otimes 6}$ -type generators check for phase-flips across blocks.
The code is defined as the common $+ 1$ eigenspace of these eight commuting generators.

Preview of the next lesson:
Now that we have constructed the Shor code and understand its stabilizer group, the next logical step is to see it in action. In our next lesson, we will implement the syndrome measurement circuits for the Shor code to extract the bit-flip and phase-flip error syndromes, building on the techniques we used for the 5-qubit code.