# Lecture 16: Quantum Error Correction 1 Introduction ```Lecture 16: Quantum Error Correction
Scribed by: Dah-Yoh Lim
October 30, 2003
1
Introduction
Today we are going to look at how one can do error correction in the quantum world. In the
PreShannon days, simple repetition codes were used: to transmit bit 0, it is ﬁrst encoded into a
string of zeros, say 0000. Similarly, 1 gets encoded into 1111. One can prove that if you want to
reduce the error rate to 1/n, and the channel ﬂips bits with probability 1/�, then you need roughly
log n
log(1/�) repetitions.
2
Quantum Analog to Repetition Code
The analog to the repetition code is to say encode |0� as |000� and |1� as |111�. Note that this is
not the same as copying/cloning the bit, since in the quantum world we know that cloning is not
possible.
So for instance, under this encoding E the EPR state
√12 (|0� + |1�) would be encoded as
√1 (|000�
2
2.1
+ |111�).
Bit Errors
Suppose there is a bit error σX at the third qubit.
(3)
(3)
(3)
(3)
σX E(|0�) = σX (|000�) = |001�.
Similarly,
σX E(|1�) = σX (|111�) = |110�.
To correct bit errors, simply project onto the subspaces {|000�, |111�}, {|001�, |110�}, {|010�, |100�},
{|100�, |011�}.
2.2
Phase Errors
Suppose there is a phase error σZ .
1
1
(j)
(j) 1
σZ E( √ (|0� + |1�)) = σZ √ (|000� + |111�) = E( √ (|0� − |1�)),
2
2
2
for j = 1, 2, 3. Therefore, if we use this code, single bit errors can be corrected but phase errors will
be come 3 times more likely!
1
P. Shor – 18.435/2.111 Quantum Computation – Lecture 16
Recall that
1
H≡√
2
�
1
1
1 −1
�
2
.
This takes bit errors to phase errors. If we apply H to the 3-qubit protection code, we get:
1
1
√ (|0� + |1�) → √ (|000� + ... + |111�),
2
2 2
and
1
1
√ (|0� − |1�) → √ (|000� − |001� + ... − |111�),
2
2 2
with a negative sign iﬀ the string contains an odd number of 1s.
Now consider the following 3-qubit phase error correcting code:
1
|0� → (|000� + |011� + |101� + |110�),
2
and
1
|1� → (|011� + |100� + |010� + |001�
).
2
Now if there is a phase error on the ﬁrst qubit:
(1)
(1)
σZ
(|000� + |011� + |101� + |110�)
2
1
= (|000� + |011� − |101� − |110�).
2
σZ E(|0�) =
(i)
(i)
Next, note that σZ E(|0�) and σZ E(|1�) are orthogonal, for i = 1, 2, 3. Therefore, to correct
(i)
(i)
phase errors we can project onto the four subspaces {σZ E(|0�), σZ E(|1�)} and {E(|0�), E(|1�)}.
Now we have a code that corrects phase error but not bit errors.
2.3
Bit and Phase Errors
If we concatenate the codes that corrected bit and phase errors respectively, then we can get a code
that corrects both errors. Consider:
1
E(|0�) = (|000000000� + |000111111� + |111000111� + |111111000�)
2
1
E(|1�) = (|111111111� + |111000000� + |000111000� + |000000111�).
2
It is easy to see that this corrects bit errors. Note that the error correcting procedure does not
collapse
the superposition, so it can be applied to superpositions as well. There is a continuum of
�
�
α β
that one can apply to the 1st qubit.
γ δ
�
�
�
� −iθ
1 0
0
e
≡ Rθ .
In general, phase errors can be expressed as
= eiθ
0 e2iθ
0
eiθ
P. Shor – 18.435/2.111 Quantum Computation – Lecture 16
3
1
Rθ ( (|000� + |011� + |101� + |110�))
2
1
= (e−iθ |000� + e−iθ |011� + eiθ |101� + eiθ |110�)
2
1 −eiθ + e−iθ
1 eiθ + e−iθ
(|000� + |011� + |101� + |110�) +
(|000� + |011� − |101� − |110�)
=
2
2
2
2
(1)
= cos θE(|0�) − i sin θσZ E(|0�),
i.e. phase error on the 1st qubit.
With our 9-qubit code, let’s say we apply
�
α β
γ
δ
�
=
�
α β
γ
δ
�
to some qubit. Since
α+δ
α−δ
β+γ
β−γ
I+
σZ +
σY ,
σX + i
2
2
2
2
we can separate its operation on ηE |0� + &micro;E |1� as follows:
�
�
α β
(ηE |0� + &micro;E |
1�)
γ δ
α−δ
α+δ
(ηE|0� + &micro;E |1�) +
σZ (ηE |0� + &micro;E |1�)
=
2
2
β+γ
β−γ
+
σX (ηE |0� + &micro;E |1�) + i
σY (ηE |0� + &micro;E |1�).
2
2
However, we know that projection onto |φ� is equivalent to applying the projection matrix |φ��φ|;
therefore, we see that the code corrects phase errors too.
3
7 bit Hamming Code
The Hamming code encodes 4 bits into 7 bits. The 24 codewords are:
S0
S1
0000000 1111111
1110100 1011000
0111010 0101100
0011101 0010110
1001110 0001011
0100111 1000101
1010011 1100010
1101001 0110001
Recall that a linear code is a code where the sum of two codewords (mod 2) is another codeword.
The
Hamming code is a⎤ linear code, i.e. one can chose 4 basis elements generated by GC =
⎡
1 1 1 1 1 1 1
⎢ 1 1 1 0 1 0
0 ⎥
⎢
⎥
⎣ 0 1 1 1 0 1 0
⎦, where the rowspace of this matrix gives all the codewords. The parity
0 0 1 1 1 0 1
P. Shor – 18.435/2.111 Quantum Computation – Lecture 16
4
⎡
⎤
1 1 1 0 1 0 0
check matrix is HC = ⎣ 0 1 1 1 0 1 0 ⎦, which is exactly the generator matrix for the dual
0 0 1 1 1 0 1
code (the set of vectors orthogonal to every vector in the code C).
3.1
Quantum Hamming Code
The quantum analog of the Hamming Code is as follows:
|0� →
1
Σ |v � ;
|1� →
23/2 v∈HC
1
Σ |v + e�,
23/2 v∈HC
where e is the string of all 1s.
Note that this corrects σX on any qubit (because of the properties of the Hamming code). Also,
if we apply the Hadamard transformation to the quantum Hamming code, we can correct phase
errors as well:
H ⊗7 E|0� =
1
Σ H ⊗7 |v �
23/2 v∈HC
1
1
27 −1
Σ Σ (−1)x&middot;v |x�
23/2 27/2 x=0 v∈HC
1
= 7/2 23 Σ |x�
x∈GC
2
1
= √ (E |0� + E |1�).
2
1
⊗7
H E|1� = 3/2 Σ H ⊗7 |v + e�
2 v∈HC
1 1 27 −1
= 3/2 7/2 Σ Σ (−1)x&middot;(v+e) |x�
2 2 x=0 v∈HC
1
= 7/2 23 Σ (−1)x&middot;e |x�
x∈GC
2
1
= √ (E |0� − E |1�)
2
= EH |1�.
=
So, the σX and σZ errors are “independent”, and therefore this code can correct σX error in
any qubit and σZ error in any other qubit.
```