To approach the problem of qubit errors from the quantum angle, we will want to deal with *logical* qubits instead. Even though Alice is looking forward to sending a message to Bob (for example, $|0\rangle$ or $|1\rangle$), she knows about errors and is worried that noise in their communication channel might cause her qubit to end up with a bit-flip error (remember that we can use the Pauli-$X$ operator to effectively flip a qubit between the states $|0\rangle$ and $|1\rangle$). Let's help Alice design her messaging system, so Bob can receive her qubit safe and sound. At her lab, Alice can prepare a total of three qubits to send to Bob — the first one is her message and the other two can be used as auxiliary qubits. Of course, this should work for any one-qubit message Alice sends, with both the auxiliary qubits initialized to the state $|0\rangle$. What is the easiest way for that to happen? Using the magic of CNOT gates, we can entangle Alice's message with the two auxiliary qubits pretty easily:

Solution.

If Alice's message was $|0\rangle$, the CNOT gates would encode it into the logical qubit $|0_{\mathcal{l}}\rangle = |000\rangle$; if it was $|1\rangle$, the CNOT gates would encode it into the logical qubit $|1_{\mathcal{l}}\rangle = |111\rangle$. Now you can easily check that the state $|ψ\rangle = a|0\rangle + b|1\rangle$ would be encoded into the logical state $|ψ_{\mathcal{l}}\rangle = a|0_{\mathcal{l}}\rangle + b|1_{\mathcal{l}}\rangle = a|000\rangle + b|111\rangle$.

--- Once the message has been encoded into a logical qubit, it begins its trip to Bob. For each qubit there is some small probability $p$ that it will experience a bit-flip error, and once he receives the message, Bob starts with checking its error syndrome — the pattern of errors in a piece of information. Either none of the qubits got flipped, only the first one did, only the second one, or only the third one. Note that, because the error we're working with is small, it's quite unlikely that two or even all three qubits got flipped on the way to Bob, so we can ignore that case (for now). Bob can again use CNOT gates to address the bit-flip errors:

However, this is a very simple approach to the bit-flip error that gives us the original message without telling us where (if at all) an error happened. We could also think about this problem a bit differently if we thought about it in terms of syndrome measurement — in other words, in terms of diagnosing the error. If Bob doesn't apply the last three gates in the circuit above, the projectors Bob would need to use for each of these four cases to identify which qubit experienced a bit-flip error would look like this: $$ P_0 = |000\rangle \langle 000| + |111\rangle \langle 111|, $$ if no qubits flipped, $$ P_1 = |100\rangle \langle 100| + |011\rangle \langle 011|, $$ if the first (message qubit) flipped, $$ P_2 = |010\rangle \langle 010| + |101\rangle \langle 101|, $$ if the second qubit flipped, or $$ P_3 = |001\rangle \langle 001| + |110\rangle \langle 110| $$ if the third qubit flipped. And here's the coolest thing: because these projectors are orthogonal, Bob could use their linear combination to figure out what message Alice sent him even if he had no idea which qubit got flipped. --- ***Exercise E.2.2*** Check what happens when you apply Bob's projectors to a message in which one of the qubits has gone through a bit-flip error. Let's consider the case where Alice's message is $|ψ \rangle = a|0\rangle + b|1\rangle$ and the third qubit receives a bit-flip error. (a) Which projective measurement helps Bob identify the qubit where the error occurred? Can you write down the a general correction projector that helps Bob get to the bottom of the problem and decode the original message? (b) What is the probability of the error not being detected by the syndrome measurement you found in part (a), and how does it compare to the classical repetition code? *Solution.*

(a)

If Alice wanted to send the message $|ψ \rangle = a|0\rangle + b|1\rangle$, she would first encode it into the state $|ψ_\mathcal{l} \rangle = a|000\rangle + b|111\rangle$. Let's say the third qubit picked up a bit-flip error on its way to Bob. Then the state Bob receives would be $|ψ_\mathcal{e} \rangle = a|001\rangle + b|110\rangle$. The projector $P_3$ measurement would be the only one to lead to a non-zero result, as $\langle ψ_\mathcal{e}| P_3 |ψ_\mathcal{e} \rangle =1$, so Bob would know that the third qubit got flipped. However, in order to get to the bottom of the problem and find the original message, it's best for Bob's measurement to correct the flipped qubit (if any got flipped) right away. If you remember that the bit-flip error acts as the Pauli-$X$ operator, you know that Bob has to act on the qubit that got flipped with the Pauli-$X$ operator to correct it. He can use this operator on the message he received: $$ \mathcal{E}_{\textrm{corr.}} = P_0 |ψ_\mathcal{e}\rangle P_0 + \sum_{i = 1}^3 X_i P_i |ψ_\mathcal{e}\rangle P_i X_i, $$ where $X_i$ is the Pauli-$X$ operator applied to the $i$-th qubit.

(b)

We know that each of the qubits experiences a bit-flip error in this noisy channel with a small probability $p$. This correcting procedure assumes that either no qubits get flipped, or a maximum of one qubits does. This means that if two or three qubits get flipped, Bob would receive the incorrect result! The likelihood of the message being detectable is $$ (1-p)^3 + 3p(1-p)^2 = (1-p)^2(1+2p) = 1+2p^3-3p^2. $$ This means the probability of the error not being detected is $3p^2-2p^3$, which is the same result we get for the classical three-bit repetition code. The three-qubit bit-flip code is comparable to the classical three-bit repetition code!

--- Now that we have all the details figured out, let's put it all together. This is what happens to Alice's message on its way to Bob if each qubit risks a bit-flip error:

Alice encodes her message qubit into a logical qubit using two auxiliary qubits
The encoded state passes through a noisy channel and one of the qubits may pick up a bit-flip error
Bob performs the procedure to correct the flipped qubit (if there is one)

Congratulations! You have now learned to perform the *three-qubit bit-flip code*, one of the fundamental codes of quantum error correction, and you're all done with this chapter! …wouldn't that be great? But quantum physics always has another wrench to throw into our well-laid plans. Unlike classical bits, which can only suffer errors that flip them from $1$ to $0$ or the other way around, qubits live in the Bloch sphere, which gives us an additional problem — their phase!

Codercise E.2.1 - A message via logical qubits

Codercise E.2.2 - Unfazed by the phases

Codercise E.2.3 - How bad can errors be?

Codercise E.2.4 - Lightning strikes twice

The no cloning theorem and its consequences

Detecting bit flip errors

Phase flip errors