Implementing the 3-Qubit Bit-Flip Code

Hello! Welcome back to our exploration of quantum error correction.

In our last lesson, we derived the Knill-Laflamme theorem, which provides the abstract necessary and sufficient conditions for a quantum code to be correctable. We learned that error correction is possible if and only if the errors do not reveal any information about the logical state they corrupt.

Today, we will move from this abstract theory to concrete practice. Our goal is to implement the 3-qubit bit-flip code, the canonical first example of a quantum error-correcting code. We will walk through the three essential stages of any such code:

1. Encoding: Storing the information of one logical qubit across three physical qubits.
2. Syndrome Measurement: Detecting if and where a bit-flip error has occurred, without collapsing the precious quantum state.
3. Correction: Applying a targeted operation to reverse the error and restore the original logical state.

This lesson will bridge the gap between the formal conditions we've learned and a working quantum algorithm.

1. Encoding: Redundancy is Key

The core idea behind error correction is redundancy. We protect a fragile state by encoding it into a larger, more robust system. For the bit-flip code, we encode a single logical qubit into a three-qubit state. The logical basis states, which we denote with a bar, are mapped as follows:

• $|0_L⟩\mapsto |000⟩$
• $|1_L⟩\mapsto |111⟩$

A general logical state $|{\psi }_L⟩=\alpha |0_L⟩+\beta |1_L⟩$ is therefore encoded into the entangled state:

This is a Greenberger–Horne–Zeilinger (GHZ) state. It's crucial to note that this is an entangled state, not three copies of the original qubit. The no-cloning theorem forbids making multiple copies of an unknown quantum state.

How do we create this state? The circuit is remarkably simple. We start with our data qubit in the state $|\psi ⟩=\alpha |0⟩+\beta |1⟩$ and two ancillary qubits in the $|0⟩$ state. A sequence of two CNOT gates then generates the desired entangled state.

2. Syndrome Measurement: The Art of Diagnosis

Now, suppose our encoded state is subjected to noise. We'll consider a simple noise model where at most one of the three qubits undergoes a bit-flip, which corresponds to a Pauli $X$ gate. There are four possibilities:

1. No error: The state remains $\alpha |000⟩+\beta |111⟩$.
2. Error on qubit 0: $X_0|{\psi }_{\text{enc}}⟩=\alpha |100⟩+\beta |011⟩$.
3. Error on qubit 1: $X_1|{\psi }_{\text{enc}}⟩=\alpha |010⟩+\beta |101⟩$.
4. Error on qubit 2: $X_2|{\psi }_{\text{enc}}⟩=\alpha |001⟩+\beta |110⟩$.

The challenge is to determine which of these four situations has occurred without measuring the data qubits directly, as that would collapse the superposition and destroy the logical information encoded in $\alpha$ and $\beta$.

The solution is syndrome measurement. We perform a measurement that reveals information about the error (the "syndrome") but nothing about the underlying logical state. There are two powerful ways to think about this.

Perspective 1: Parity Checks (The Circuit View)

Intuitively, we can detect a bit-flip by checking if the qubits are still in agreement. In the error-free states $|000⟩$ and $|111⟩$, the parity (or XOR sum) of any two bits is 0. A single bit-flip will change the parity for any pair involving the flipped bit.

We can measure these parities without collapsing the state by using two ancillary qubits. For example, to check the parity of qubit 0 and qubit 1, we can CNOT them onto an ancilla. The ancilla's final state will tell us the parity. By measuring the parities of, say, (qubit 0, qubit 1) and (qubit 1, qubit 2), we can uniquely identify which qubit, if any, was flipped.

The key idea is that the measurement outcomes of the two ancilla qubits form a 2-bit syndrome that uniquely identifies the error, as summarized in the table from the notes.

Perspective 2: Stabilizer Measurements (The Operator View)

Given your physics background, you'll find this more formal perspective powerful. It forms the basis of the stabilizer formalism, a cornerstone of modern quantum error correction.

The code space $C=\text{span}\{|000⟩,|111⟩\}$ can be defined as the set of states that are "stabilized" by (i.e., are +1 eigenvectors of) a set of commuting Pauli operators. For the bit-flip code, these operators are:

• $S_1=Z_0{Z}_1=Z\otimes Z\otimes I$
• $S_2=Z_1{Z}_2=I\otimes Z\otimes Z$

You can easily verify that $S_1|{\psi }_{\text{enc}}⟩=+1\cdot |{\psi }_{\text{enc}}⟩$ and $S_2|{\psi }_{\text{enc}}⟩=+1\cdot |{\psi }_{\text{enc}}⟩$ for any $\alpha ,\beta$.

When an error occurs, it may commute or anti-commute with these stabilizers.

• If an error $E$ commutes with a stabilizer $S$, then $S(E|\psi ⟩)=E(S|\psi ⟩)=E|\psi ⟩$. The eigenvalue remains +1.
• If an error $E$ anti-commutes with a stabilizer $S$, then $S(E|\psi ⟩)=-E(S|\psi ⟩)=-E|\psi ⟩$. The eigenvalue flips to -1.

By measuring the eigenvalues of $S_1$ and $S_2$, we obtain a syndrome that identifies the error. For example, an error $X_1=I\otimes X\otimes I$ anti-commutes with both $S_1$ and $S_2$. A measurement of these stabilizers would yield the syndrome $(-1,-1)$, pinpointing the error on the first qubit (using 0-based indexing).

The parity-check circuit we saw earlier is, in fact, the physical implementation for measuring these stabilizer operators. Each pair of CNOTs onto an ancilla followed by a measurement of that ancilla constitutes a measurement of one stabilizer generator.

3. Correction: Reversing the Damage

Once we have the syndrome, correction is straightforward. The syndrome tells us exactly which qubit was flipped. Since the bit-flip error is a Pauli $X$ gate, and $X^2=I$, we can correct the error by simply applying another $X$ gate to the identified qubit.

• Syndrome says "error on qubit 0" $⟹$ apply $X_0$.
• Syndrome says "error on qubit 1" $⟹$ apply $X_1$.
• Syndrome says "error on qubit 2" $⟹$ apply $X_2$.
• Syndrome says "no error" $⟹$ do nothing.

This correction step is a conditional operation. Modern quantum processors and simulators can implement this using "mid-circuit measurements," where the outcome of measuring the ancilla qubits classically controls whether a subsequent gate is applied.

4. Implementation with PennyLane

Now let's translate this entire process into code. The PennyLane tutorial provides a complete, runnable implementation of the 3-qubit bit-flip code, using mid-circuit measurement and conditional operations for the correction step.

Your task is to implement this code. The tutorial will serve as an excellent guide.

Your Implementation Task

Using the tutorial as a guide, construct a single PennyLane QNode that performs the full error correction sequence:

1. Encode an arbitrary state $\alpha |0⟩+\beta |1⟩$ into three qubits.
2. Manually inject a single bit-flip error $X$ on one of the three data qubits to simulate noise.
3. Perform the syndrome measurement using two ancilla qubits.
4. Use mid-circuit measurements and qml.cond to apply the appropriate correction $X$ gate.
5. Return the final density matrix of the three data qubits.
6. Finally, calculate the fidelity between the final, corrected state and the initial, error-free encoded state. You should find the fidelity to be 1.0, demonstrating perfect correction.

This exercise will solidify your understanding by having you build the complete circuit from the components we've discussed.

Conclusion

In this lesson, we have constructed our first quantum error-correcting code. We have seen how to use redundancy to protect a quantum state and how the principles of syndrome measurement allow us to detect and correct errors without destroying the logical information.

Key Takeaways:

• The 3-qubit bit-flip code encodes one logical qubit into the three-qubit GHZ state $\alpha |000⟩+\beta |111⟩$.
• Syndrome measurement is the key to non-destructive error detection. It can be viewed operationally as measuring parities with ancillas, or more formally as measuring the eigenvalues of stabilizer operators ($Z_0{Z}_1,Z_1{Z}_2$).
• The measured syndrome uniquely identifies a single bit-flip error.
• Correction is achieved by applying a conditional Pauli $X$ gate on the qubit identified by the syndrome.

Preview of the next lesson:
The bit-flip code is a great start, but it's incomplete. It protects against $X$ errors but is completely vulnerable to phase-flip errors ($Z$ errors). In the next lesson, we will analyze the 3-qubit phase-flip code. We will discover that it is intimately related to the bit-flip code through a simple change of basis, moving us one step closer to building a code that can handle all types of single-qubit errors.