Implementing Shor Code Syndrome Measurement

Hello! Welcome to your seventh lesson in the module on Quantum Error Correction Fundamentals.

In our last lesson, we constructed the encoding circuit for the 9-qubit Shor code. We established that it is a [[9,1,3]] stabilizer code defined by a set of eight commuting stabilizer generators: six $ZZ$ -type generators to detect bit-flips within blocks, and two $X^{\otimes 6}$ -type generators to detect phase-flips across blocks.

Today, we will build directly on that foundation. Our learning outcome is to implement the syndrome measurement circuits for the 9-qubit Shor code to extract bit-flip and phase-flip error syndromes. We will design the specific quantum circuits that measure the eigenvalues of each of the eight stabilizer generators, and then see how the combined 8-bit result—the syndrome—uniquely identifies single-qubit errors.

1. The Principle of Stabilizer Measurement

Before diving into the specifics of the Shor code, let's briefly revisit the general method for measuring the eigenvalue of a Pauli operator, $P$ . The standard circuit uses an auxiliary qubit, or ancilla, prepared in the $∣ + ⟩$ state. A controlled- $P$ operation is applied, where the ancilla is the control and the data qubits are the target. Finally, the ancilla is measured in the Hadamard basis.

generic_stabilizer_measurement

Figure from "Quantum error correction : an introductory guide" by C. G. Brell. This diagram shows the general circuit for measuring a stabilizer operator P_i using an ancilla qubit A_i. The ancilla is prepared in |+\rangle, a controlled-P_i gate is applied, and the ancilla is then measured in the X-basis (equivalent to H then Z-basis measurement).

The measurement outcome of the ancilla directly corresponds to the eigenvalue of $P$ for the data state. If the ancilla is measured as $∣0 ⟩$ , the eigenvalue is +1 (no error detected by this stabilizer). If it's measured as $∣1 ⟩$ , the eigenvalue is -1 (an error has anti-commuted with this stabilizer). Our task is to construct the controlled-P gates for all eight of the Shor code's generators.

2. Measuring Bit-Flip Syndromes (Z-type Stabilizers)

The first six generators of the Shor code detect bit-flip errors. They are of the form $g = Z_{i} Z_{j}$ . Let's take the first generator, $g_{0} = Z_{0} Z_{1}$ , as our example. We need a circuit to measure its eigenvalue.

A key insight is that the eigenvalue of $Z_{i} Z_{j}$ for a computational basis state $∣ q_{i} q_{j} ⟩$ is +1 if the parity of the bits is even ( $q_{i} \oplus q_{j} = 0$ ) and -1 if the parity is odd ( $q_{i} \oplus q_{j} = 1$ ). Therefore, measuring $Z_{i} Z_{j}$ is equivalent to measuring the bitwise parity of qubits $i$ and $j$ .

The circuit to measure the parity of two qubits, $q_{i}$ and $q_{j}$ , and write the result to an ancilla qubit $a$ is:

Initialize the ancilla: H(a)
Compute parity: CNOT(qi, a) followed by CNOT(qj, a)
Return to computational basis: H(a)
Measure the ancilla: Measure(a)

Quantum Circuit for the 9-Qubit Shor Code — A portion of a syndrome measurement circuit for the Shor code. The structure shown on the right with two CNOTs targeting an ancilla from data qubits is precisely the building block for measuring a Z-type stabilizer.

To measure the six bit-flip syndromes, we would use six separate ancilla qubits and repeat this pattern for each of the $Z_{i} Z_{j}$ pairs:

Syndrome bit $s_{0}$ (for $Z_{0} Z_{1}$ ): CNOT(q0, a0), CNOT(q1, a0)
Syndrome bit $s_{1}$ (for $Z_{1} Z_{2}$ ): CNOT(q1, a1), CNOT(q2, a1)
...and so on for $(q_{3}, q_{4})$ , $(q_{4}, q_{5})$ , $(q_{6}, q_{7})$ , and $(q_{7}, q_{8})$ .

Each of these six sub-circuits will produce one bit of the final syndrome. A '1' indicates that a bit-flip may have occurred that distinguishes the two qubits involved (e.g., a flip on $q_{0}$ but not $q_{1}$ ).

3. Measuring Phase-Flip Syndromes (X-type Stabilizers)

The remaining two generators detect phase-flip errors across the blocks. They are multi-qubit Pauli-X operators:

$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}$

Measuring these follows a more direct implementation of the controlled-Pauli gate. A controlled- $X_{i}$ gate is simply a CNOT gate where the ancilla is the control and the data qubit $q_{i}$ is the target. To measure an operator like $g_{6}$ , we just chain these CNOTs together.

The circuit to measure $g_{6} = X^{\otimes 6}$ on qubits 0 through 5 using ancilla $a_{6}$ is:

Initialize the ancilla: H(a6)
Apply controlled-X operations: CNOT(a6, q0), CNOT(a6, q1), CNOT(a6, q2), CNOT(a6, q3), CNOT(a6, q4), CNOT(a6, q5)
Return to computational basis: H(a6)
Measure the ancilla: Measure(a6)

If the ancilla state $∣1 ⟩_{A}$ is applied to the data, it leaves the state $(X_{0} \dots X_{5}) ∣ ψ ⟩_{L}$ . After the final Hadamard, the ancilla's state will depend on whether $∣ ψ ⟩_{L}$ was an eigenstate of $g_{6}$ . A measurement of '1' on the ancilla means a phase-flip error (or any error that anti-commutes with $g_{6}$ ) has likely occurred.

An identical circuit structure is used to measure $g_{7}$ with an eighth ancilla, $a_{7}$ , targeting qubits 3 through 8.

The following resource provides a detailed guide to quantum error correction. While it discusses syndrome measurement in a general stabilizer context, its explanation is directly applicable here.

Quantum error correction : an introductory guide

The paper "Quantum error correction : an introductory guide" by C. Brell provides a solid introduction to stabilizer measurement. The principles it outlines for a general [[n, k, d]] code form the basis for our specific Shor code implementation.

Please review Section 4, "Stabilizer codes", focusing on Figure 4 and the accompanying text (Equation 29). This section formalizes the syndrome extraction process we've just discussed, showing how each ancilla measurement reveals the eigenvalue of its corresponding stabilizer generator. You don't need to read the full section, but focusing on the circuit diagram and its description will reinforce the general principle.

4. Interpreting the Syndrome

Once we run these eight measurement circuits, we obtain an 8-bit string, $s = s_{0} s_{1} s_{2} s_{3} s_{4} s_{5} s_{6} s_{7}$ . This is the error syndrome. The value of this syndrome tells us which error occurred. How? An error $E$ flips the syndrome bit $s_{i}$ if and only if it anti-commutes with the corresponding stabilizer generator $g_{i}$ .

Let's consider two examples:

Case 1: Bit-flip error $E = X_{4}$
- Z-stabilizers: $X_{4}$ anti-commutes with any $Z$ operator on qubit 4. This includes $g_{2} = Z_{3} Z_{4}$ and $g_{3} = Z_{4} Z_{5}$ . So, we expect $s_{2} = 1$ and $s_{3} = 1$ . All other $Z_{i} Z_{j}$ generators act on other qubits, so they commute with $X_{4}$ .
- X-stabilizers: $X_{4}$ commutes with all Pauli-X operators. Thus, it commutes with $g_{6}$ and $g_{7}$ . We expect $s_{6} = 0$ and $s_{7} = 0$ .
- Full Syndrome: 00110000. This syndrome points to a bit-flip in block 2 ( $s_{2}, s_{3}$ are non-zero) and specifically to qubit 4, which is the only one involved in both $g_{2}$ and $g_{3}$ .
Case 2: Phase-flip error $E = Z_{4}$
- Z-stabilizers: $Z_{4}$ commutes with all $Z_{i} Z_{j}$ generators. All six bit-flip syndrome bits will be 0.
- X-stabilizers: $Z_{4}$ anti-commutes with $X_{4}$ . Both $g_{6}$ and $g_{7}$ contain an $X_{4}$ term. Therefore, $Z_{4}$ anti-commutes with both. We expect $s_{6} = 1$ and $s_{7} = 1$ .
- Full Syndrome: 00000011. This syndrome indicates no bit-flip error but a phase-flip error in a qubit common to the support of $g_{6}$ and $g_{7}$ , i.e., in block 2 (qubits 3,4,5).

The following lecture notes include a table summarizing the syndromes for all single-qubit Pauli errors.

Quantum Error Correction

These lecture notes on Quantum Error Correction by R. Renes provide a concise but comprehensive overview of the Shor code's stabilizer structure.

Please read Section 1.6.5, "Shor code stabilizer structure". Focus on the table at the end of the section. It explicitly lists the syndromes for all single-qubit X, Y, and Z errors. Compare the syndromes we derived for X4 and Z4 with the entries in the table to verify our reasoning.

Test your understanding!

What syndrome would you expect for a $Y_{8}$ error? Recall that $Y = i XZ$ .

Show answer

An error $E = Y_{8} = i X_{8} Z_{8}$ will anti-commute with a stabilizer $g_{i}$ if an odd number of its Pauli components anti-commute.

Z-stabilizers:
- The $X_{8}$ part anti-commutes with $g_{4} = Z_{6} Z_{7}$ (no) and $g_{5} = Z_{7} Z_{8}$ (yes).
- The $Z_{8}$ part commutes with all Z-stabilizers.
- So, only $g_{5}$ anti-commutes. Syndrome bits $s_{0} .. s_{5}$ should be 000001.
X-stabilizers:
- The $Z_{8}$ part anti-commutes with $g_{6}$ (no) and $g_{7}$ (yes).
- The $X_{8}$ part commutes with all X-stabilizers.
- So, only $g_{7}$ anti-commutes. Syndrome bits $s_{6}, s_{7}$ should be 01.

The full syndrome for $Y_{8}$ is 00000101. You can verify this in the table from the resource LINK.

Your Task: Implementation

Now it's time to put this into practice. Your task is to implement and simulate the syndrome extraction process. Given your background in implementing simulations, this should be a familiar process of building a model (the circuit) and testing it against theoretical predictions (the syndromes).

Please use a quantum circuit simulator like Qiskit or Cirq to perform the following steps:

Build the Encoder: Start by creating the 9-qubit Shor code encoding circuit from the previous lesson. Encode the state $∣0 ⟩$ into the logical state $∣ 0_{L} ⟩$ .
Introduce an Error: Manually insert a single-qubit Pauli error on one of the nine data qubits. For example, apply an X gate to q_5.
Build the Syndrome Measurement Circuit: Create a circuit that measures all eight stabilizer generators. This will require 9 data qubits and 8 ancilla qubits.
- For each of the six Z-stabilizers, implement the parity measurement circuit using two CNOTs targeting an ancilla.
- For each of the two X-stabilizers, implement the circuit using a chain of CNOTs controlled by an ancilla.
Simulate and Verify:
- Combine the circuits: Encoder $\to$ Error $\to$ Syndrome Measurement.
- Run the simulation and measure the eight ancilla qubits.
- The 8-bit outcome is your measured syndrome. Compare it to the expected syndrome for the error you introduced (e.g., for $X_{5}$ , you'd expect the syndrome 00011000).
- Repeat for a phase-flip error, like Z on q_1, and verify you get the expected syndrome 00000010.

This exercise directly addresses the learning outcome by having you construct and use the syndrome measurement circuits to identify specific, known errors.

Conclusion

In this lesson, we have designed the complete syndrome measurement apparatus for the 9-qubit Shor code.

Key Takeaways:

Syndrome measurement relies on using ancilla qubits to non-destructively measure the eigenvalues of the stabilizer generators.
Z-type stabilizers ( $Z_{i} Z_{j}$ ) are measured using a circuit that computes the parity of the two corresponding data qubits.
X-type stabilizers ( $X^{\otimes k}$ ) are measured using a chain of CNOT gates controlled by an ancilla.
The resulting 8-bit syndrome is a unique fingerprint that, for single-qubit errors, allows us to diagnose both the type and location of the error.

Preview of the next lesson:
We have now seen how to encode a state and how to detect an error. The final step in the error correction process is to use the syndrome to apply a corrective operation. In the next lesson, we will complete the cycle by implementing the decoding logic and correction operations for the 9-qubit Shor code to recover the original logical state.