Notes 8.370/18.

435 Fall 2022

Lecture 28 Prof. Peter Shor
We continue our discussion of the nine-qubit code.
Recall that last time, we started our discussion with the three-qubit bit flip correct-
ing code. This was based on the classical repetition code, that just repeats every bit
three times. This code takes

| 0i → | 000i ,
| 1i → | 111i .

This is not a cloning transformation, because α | 0i + β | 1i → α | 000i + β | 111i. This

code corrected one bit-flip error, but made phase-flip errors more likely. We then used
the fact that Hσx H = σz to get a three-qubit phase-flip correcting code. This code is

| 0i → | + + +i ,
| 1i → | − − −i .

or in the {| 0i , | 1i} basis,

1
| 0i → √ (| 0i + | 1i)⊗3 ,
8
1
| 1i → √ (| 0i − | 1i)⊗3 .
8
A bit-flip error (σx ) on any qubit results in a phase flip error on the encoded state:
It will change one of the (| 0i − | 1i) terms to (| 1i − | 0i), which changes a | 1iL to a
− | 1iL , and leaves an encoded | 0i the same.
On the other hand, this will correct any phase-flip (σz ) error on a single qubit. Why
is this true? It’s because the eight states
(1) (2) (3)
| 0iL , σz | 0iL , σz | 0iL , σz | 0iL
(1) (2) (3)
| 1iL , σz | 1iL , σz | 1iL , σz | 1iL
(j)
are all orthogonal, where σz denotes a σz error on qubit j.
To correct the state, we project it onto one of the four subspaces:

| 0L ih0L | + | 1L ih1L |

and
σz(j) | 0L ih0L | + | 1L ih1L | σzj ,

for j = 1, 2, 3.
We combined these two codes by concatenating them. This means first encoding
by using the phase-flip code (it would work just as well if we used the bit-flip code

1
first, but this is the standard way to do it) and then encoding each of the qubits in the
resulting three-qubit code by the bit-flip code:

⊗3 1
⊗3
| 0i → | +i → √ | 000i + | 111i ,
8
⊗3 1
⊗3
| 1i → | −i → √ | 000i − | 111i .
8
This results in a nine-qubit code. It corrects both bit and phase errors. This nine-qubit
code can correct one Pauli error on any qubit. One σx error is corrected by the bit-flip
correcting code. One σz error passes through the bit-flip correcting code to apply a σz
error to one of the groups of three qubits, which then gets corrected by the phase-error
correcting code. And a σy error can be thought of as both a σx and a σz error on the
same qubit, since σy = iσx σz , so the bit-flip correcting code corrects the σx error and
the phase-flip correcting code corrects the σz error..
But what about arbitrary errors? You can have arbitrary unitary errors, or you
can have a measurement on qubits, or you can have a more general type of quantum
transformation that we haven’t covered in this class (but which you will see if you take
8.371/18.436). It turns out that this code will correct them, as well. This is because of
the following theorem:

Theorem 1 Any quantum error-correcting code, which corrects t or fewer Pauli errors
(σx , σy , and σz errors) on a subset of t or fewer qubits will also correct an arbitrary
quantum operation which is applied to at most t qubits.
That the 9-qubit code will correct any arbitrary single-qubit error follows from the
above theorem with t = 1.
How do we prove this theorem? We will first show why it works by looking at an
example on the three-qubit phase-flip error–correcting code, and then prove it.
Let’s consider a qubit α | 0i+β | 1i encoded in the three -qubit phase-flip correcting
code:
α | 0i + β | 1i → α | 0iL + β | 1iL
 −iθ 
e 0
What happens when we apply the phase error to the second qubit of
0 eiθ
it? We have
 −iθ   
e 0 cos θ − i sin θ 0
= = cos θI − i sin θσz
0 eiθ 0 cos θ + i sin θ

So we get the state

cos θ α | 0L i + β | 1L i − i sin θ σz(2) α | 0L i + β | 1L i

When we measure which qubit is in error, we get that there is no error with probability
cos2 θ and that there is a σz in qubit 2 with probability sin2 θ. And in fact, we collapse
the state, so after the measurement, this will indeed be the case. When we correct the
σz error on qubit 2, this restores the original state.

2
 Why did this happen? The reason is that the error matrix has a decomposition in I
and σz :  −iθ 
e 0
= (cos θ)I − i(sin θ)σz .
0 eiθ
When you apply it, you get a superposition of applying the identity matrix with am-
plitude cos θ and the σz matrix with amplitude −i sin θ. Now, when you perform the
error correction protocol, you measure the error, and find out that there was no error
(2)
with probability cos2 θ and a σz error with probability sin2 θ. However, after the
quantum state has collapsed, this is indeed the situation.
So how do we prove Theorem 1? We prove that if an error-correcting code can
correct errors described by matrices M1 , M2 , M3 , . . ., Mk , then it can correct errors
described by any linear combination of these. Then we show that any error on t qubits
is a linear combination of Pauli errors on t qubits.
The first step is just an application of the linearity of quantum mechanics. Consider
an error correcting circuit. Then we can apply the principle of delayed measurement to
postpone any measurements until the end. Here, instead of measuring the error classi-
cally and applying Pauli matrices (say) to correct it, you measure the error coherently
and then use controlled Pauli gates to correct the error. This gives us a unitary which
takes
Mi | ψi 0l −→ | ψi | Di i
whereP| Di i is essentially a description of the error. Then, for an error F , if we have
F = i Mi , we can correct it. This is because the error correction circuit takes
X X
F | ψi 0k = αi Mi | ψi 0k −→ | ψi αi | Di i .
i i

This calculation also shows how error correction gets around the Heisenberg Uncer-
tainty Principle, which says that if you measure a quantum state, you disturb it. What
error correction does is measure the error without measuring the encoded quantum
state. This lets you correct the error without measuring the quantum state.
Finally, let me address the question of what happens if you have a small error on ev-
ery qubit. For example, suppose you have n qubits, and each qubit has an independent
error where the error on the ith qubit is

Fi = (1 − i )I + δx,i σx(i) + δy,i σy(i) + δz,i σz(i) .

N
What you do is expand the tensor product i Fi . If the δ’s are small enough, then
most of the amplitude of this product will be in terms which have relatively few Pauli
errors, so if you can correct (say) any tensor product of fewer than n/100 Pauli errors,
then if the δ’s are small enough, nearly all the time, when you measure the error there
will be Pauli errors on fewer than n/100 qubits, and the probability that you make an
error that is too large to be corrected will be exponentially small.