1. Quantum Noise and Error Correction
Daniel Bulhosa
Massachusetts Institute of Technology, 77 Massachusetts Ave., Cambridge, MA 02139-4307
(Dated: May 9, 2014)
We present a formalism for describing quantum noise and quantifying its effects. We introduce
classical linear error correction, and present a procedure for using classical codes to create quantum
error correction codes. In particular we discussed the codes developed by Calderbank, Shor, and
Steane.
I. INTRODUCTION
Over the last two decades quantum computation has
become a research field of high interest. Following Shor’s
publication of a quantum algorithm capable of factoring
large prime numbers in polynomial time, it became un-
derstood that the quantum effects of superposition and
interference could be exploited to carry out certain calcu-
lations exponentially faster than conventional computers.
One of the challenges when dealing with any kind of
signal is the introduction of noise. In the last century
effective error correcting techniques have been developed
in order to alleviate this issue in classical systems. After
Shor’s publication, one of the biggest problems facing the
prospect of practical quantum computation was quantum
noise. Due to the seeming complexity of this kind of noise
it was initially thought that no protocols could be devel-
oped to remedy it. Further research showed that this
noise admitted a simple description, and thus error cor-
recting techniques could be developed to handle quantum
noise. In this paper we introduce the idea of quantum
noise, different measures of the fidelity of quantum infor-
mation after being corrupted, and introduce a formalism
for deriving quantum error correction codes from classi-
cal ones.
II. CLASSICAL LINEAR CODING AND ERROR
CORRECTION
Suppose we have a classical bit 0, and we wish to trans-
mit it over some signal line. Furthermore, suppose that
there is some probability p that an error will occur and
this bit will be flipped to 1. We would like to come up
with a scheme that reduces this error.
Consider the following proposition. Rather than send-
ing a single bit we send three bits, two of them contain-
ing redundant information. So, for example, rather than
sending 0 we would send 000. If the string contains no
errors the receiver leaves the string as is, and if one of
the bits differs from the others the receiver assumes the
value of the remaining two was the intended message and
corrects the error by flipping the erroneous bit. Assum-
ing that the errors on different bits occur independently
of each other and with sufficiently small probability this
scheme is sensible, since it is much more likely that no
error or a single error would occur in the bit string rather
than two or three.
Given that this is our protocol for transmitting infor-
mation, the receiver will only receive the wrong message
when two or three bits are flipped. This occurs with
probability:
3
2
p2
(1 − p) + p3
= 3p2
− 2p3
(1)
Since the probability of error without error correction
is p we see that this error correction code improves the
fidelity of our information transfer when p < 1/2.
This idea of redundancy of information can be general-
ized into what are called classical linear error correction
codes. In the theory of classical linear codes we represent
strings of k bits as k-dimensional vectors with entries in
the integers modulo 2. The value of each entry in one
of this vectors is equal to the value of the corresponding
bit. Thus for example, for five bits:
10010 → 1 0 0 1 0
T
(2)
In order to protect such strings of k bits from noise we
map, or encode, the k-dimensional basis that spans all
such strings to the k-dimensional basis of a subspace of
an n-dimensional bit string vector space. We call such a
subspace C an [n, k] code. Since k < n, C carries redun-
dant information about our original bit string. We call
the n×k matrix G that maps our original bit string x to
the encoded bit string Gx the generator matrix for the
code. Thus, for example, the generator matrix mapping
our single bit (k = 1) from the previous example to the
three bit encoding is:
G =


1
1
1

 (3)
It is easy to see that this matrix maps 0 and 1 to
[0, 0, 0]T
and [1, 1, 1]T
respectively. The generator char-
acterization of a code is very intuitive when dealing with
transforming the bit strings we wish to encode to their
encoded versions. However, for the purpose of carrying
out error correction it is easier to characterize a code by
its parity check matrix. If H is the parity check matrix
of some [n, k] code C, we define the code to be the set of
n-dimensional vectors x such that:

2. Quantum Error Correction 2
Hx = 0 (4)
Here H is an n − k × n matrix. It can be shown [1]
that we can convert between generator matrices and par-
ity check matrices, and vice-versa. Thus the two char-
acterizations are equivalent. In the case of our previous
example the parity check matrix is:
H =
1 1 0
0 1 1
(5)
It can be shown that the unique vectors satisfying
Hx = 0 for this equation are [0, 0, 0]T
and [1, 1, 1]T
.
In order to develop the classical linear theory of er-
ror correction we must first introduce the concept of the
Hamming distance d(x, y) between two bit strings x and
y. This is defined to be the number of places where the
entries of the two bit strings differ. For a code C, de-
fine d(C) to be the smallest distance between any two
different codewords in the code:
d(C) = min
x,y∈C,x=y
d(x, y) (6)
Error detection is accomplished as follows [1]. Recall
that any n-dimensional bit string x contained in the code
C obeys Eq. 4. Suppose that as we transmit the bit string
x it incurs some errors, so that the bit string x is received
at the other end of the channel. Define e = x −x to be the
error vector of the transmission, which tells us the places
at which the original and final bit strings differ. If the
probability of error on each bit is assumed to be small and
independent, then with very high probability e will not lie
in C so if the receiver applies H on the received bit string
he will get a non-zero answer Hx = Hx + He = He.
A code with d(C) ≤ 2t + 1 can correct up to t errors
on a bit string. This condition guarantees that for any
errorneous bit string x with up to t errors there exists a
unique codeword x such that d(x , x) < t. The erroneous
bit string x is corrected by transforming it back to x.
The receiver can then map the codeword back to the
original k-dimensional bit string.
III. QUANTUM NOISE
When describing quantum noise we use the language of
density operators and quantum operations. For a review
of density matrices and their properties please refer to
[2].
Although most of the qubit systems we treat theoreti-
cally are in isolation, the systems we encounter in reality
are far from isolated. They are often coupled to an ex-
ternal system, which we call the environment, whose de-
tailed properties we are ignorant about. Such a system is
called an open system, and systems in isolation are called
closed.
If our qubits are in isolation we can evolve their state
by multiplying their initial state vector by a unitary op-
erator U. However if the qubits are in contact with some
environment we cannot in general evolve them separately
with a unitary operator. What we can do is make the
open qubit system closed by adjoining the environment
to our description. For example, if our qubits and the
environment are initially in the uncoupled states ρ and
ρe respectively, we can describe the full closed initial sys-
tem as ρ ⊗ ρe. We can then evolve this closed system
with some unitary operator U.
In quantum computation we can think of the sources
of noise as the environment of the qubits. We can then
characterize the effect of the environment on our qubit
over time by evolving the full qubit-environment state,
and then taking the partial trace over the environment
to get the ensemble describing only the qubits. The final
state resulting from the noise is thus:
E(ρ) = tre[U(ρ ⊗ ρe)U†
] (7)
The map E is a quantum operator. Mathematically,
a general quantum operation E is a completely positive,
convex linear map from density matrices to density ma-
trices such that 0 ≤ tr[E(ρ)] ≤ 1[i]
. This particular quan-
tum operation describes the effect of noise of a system of
qubits ρ.
Though this representation of the noise quantum op-
erator is physically intuitive, it is not the most useful for
computation. For that purpose we use the operator-sum
representation of this quantum operator. This can be de-
rived from Eq. 7 as follows. Let {|ek } be a basis for the
environment state space. Without loss of generality[ii]
assume that the environment starts in a pure state so
that ρe = |e0 e0|. Then Eq. 7 reduces to:
k
ek| U(ρ ⊗ |e0 e0|)U†
|ek =
k
EkρE†
k (8)
Here Ek = ek| U |ek is an operator on the state space
of ρ, which in general obeys:
k
EkE†
k ≤ 1 (9)
This is equivalent to the condition on the trace of E(ρ),
with equality occurring under the same circumstances.
Thus we can use 8 along with some set of {Ek} to describe
[i] The inequality is due to the fact that in general quantum oper-
ators can describe the process of measurement. When no mea-
surement is done we simply have the equality tr[E(ρ)] = 1.
[ii] See section 2.5 of [3].

3. Quantum Error Correction 3
the effect of any kind of noise on quantum bits. The Ek’s
are called the operation elements for the noise operation
E.
For concreteness we present an example of noise. An-
other term for an environment that introduces noise into
a qubit system is a noise channel. Consider a single
qubit. Since the state of a quantum bit can be deter-
mined by two numbers on the unit sphere we can think
of it as having a particular direction, that is, a particular
polarization. We say the qubit is depolarized when it has
equal probability to point in any direction. We also call
this state the maximally mixed state. The noise channel
with probability p of depolarizing some quantum state
and probability (1 − p) of leaving it alone is called the
depolarizing channel. Its noise operation can be written
as:
E(ρ) =
pI
2
+ (1 − p)ρ (10)
In the formalism of density matrices this equation is
the statement that the resulting state E(ρ) is equal to
the maximally mixed state I/2 with probability p, and
equal to the input state ρ with probability 1 − p. This
operation can be re-expressed as:
E(ρ) = (1 − p)ρ +
p
3
(σxρσx + σyρσy + σzρσz) (11)
Here the σi’s are the Pauli spin matrices. Thus in the
operator sum representation the E has operation elements
{I, σx, σy, σz}.
IV. FIDELITY
When considering classical information we used the
Hamming distance to quantify the differences between
two different bit strings. We would like to like to have an
analogous construction for quantum information. Unfor-
tunately because of the probabilistic nature of quantum
mechanics the concept of the Hamming distance does not
extend naturally into the field of quantum information.
In probability theory there exist different measures to
quantify the difference between two probability distribu-
tions. One of these is called the fidelity. Suppose p and
q are probability distributions for discrete random vari-
ables. The fidelity of p and q is defined as:
F(p, q) =
x
√
pxqx (12)
Here we sum over all values of the random variables.
Note that when the two probability distributions p and
q are equal then the fidelity equals 1, and zero when the
distributions are non-zero exclusively on different values
of x. Geometrically, we can think of
√
p and
√
q as unit
vectors, and we can interpret F(p, q) to be their inner
product. Thus the arccosine of the fidelity measures the
angular separation of these two vectors along the unit
sphere.
The definition of fidelity commonly used in quantum
information theory is motivated by Eq. (12). Given two
density matrices ρ and σ describing a quantum system
we define their fidelity to be [3]:
F(ρ, σ) = tr ρ1/2σρ1/2 (13)
Here ρ1/2
is the matrix square root of ρ. That is, ρ1/2
is
a matrix such that ρ1/2
ρ1/2
= ρ. Though it is not appar-
ent from the above definition, the fidelity is symmetric
in its entries and its values range between 0 and 1. A
value of 1 is obtained when ρ = σ. The quantum fidelity
also has a geometric interpretation as the inner product
of state vectors on the unit sphere. This interpretation,
however, requires some rigorous motivation[iii]
.
We can use the fidelity to measure to what extent a
noise channel corrupts quantum information. For exam-
ple, let ρ = |ψ ψ| and consider the effect of the depo-
larization operator on this state. Note that (|ψ ψ|)2
=
|ψ ψ| so ρ1/2
= |ψ ψ|. Let:
σ =(1 − p) |ψ ψ| +
p
3
σx |ψ ψ| σx (14)
+
p
3
σy |ψ ψ| σy +
p
3
σz |ψ ψ| σz
Then:
F(|ψ , E(|ψ )) = F(|ψ ψ| , E(|ψ ψ|)) (15)
= (1 − p) +
p
3 i
| ψ| σi |ψ |2
= 1 −
2
3
p
So as the probability of the noise occurring increases,
the agreement between the initial and final states de-
creases.
V. QUANTUM ERROR CORRECTION
A. The Shor 9-Qubit Code
Now that we have a formalism for describing noise and
a means of quantifying the magnitude of the effect of
noise on a state we can consider protocols for correcting
quantum errors and their effectiveness.
[iii] See section 9.2.2 of [3], in particular the proof of Uhlmann’s
theorem.

4. Quantum Error Correction 4
Early in the study of quantum noise it was thought
that creating a quantum error correction scheme would
be impossible. This is because of the large set of values a
quantum bit can take on. As opposed to a classical digital
bit, which can take on only two values, a quantum bit has
an infinite set of states, which can be parametrized by the
coordinates of the unit sphere. There can be no physical
error correction scheme that could correct for an infinite
set of possible errors in finite time.
However, it was eventually realized that although
qubits can take on an infinity of states, the errors that
a particular qubit can undergo admit a discrete, finite
description after error detection has occurred. We illus-
trate how this is accomplished by considering the Shor
9-qubit code [4], which is capable of correcting an ar-
bitary error on a single qubit. Consider a generic pure
state α |0 + β |1 , and the encoding:
|0 → |0L = a+ ⊗3
(16)
|1 → |1L = a− ⊗3
Here |ψ
⊗n
denotes the tensor product of |ψ with itself
n times, and:
a±
=
(|000 ± |111 )
√
2
(17)
b±
=
(|100 ± |011 )
√
2
The space spanned by the orthonormal vectors |0L
and |1L is our quantum code C. Note that just like
the classical codes, this quantum error correction code
relies on the use of redundant qubits. Suppose a single
error occurs on the first qubit. Any operation on a single
quantum bit can be written as a linear combination of
Pauli matrices with some complex coefficients:
E1
= e0I1
+ e1σ1
x + e2σ1
y + e3σ1
z (18)
The upper index 1 denotes that these operators are
acting on the first qubit. The error E1 maps the state
α |0L + β |1L to:
E1
(α |0L + β |1L ) (19)
= α e0 a+
+ e1 a−
+ ie2 b−
+ e3 b+
a+ ⊗2
+ β e0 a−
+ e1 a+
+ ie2 b+
+ e3 b−
a− ⊗2
For brevity we have suppresed the tensor product sym-
bols that should be written between the superposition in
parathensis and the tensored states to the right of them.
Note that:
σ1
xσ2
xσ3
x a±
= ±1 a±
, σ1
xσ2
xσ3
x b±
= ±1 b±
(20)
σ1
zσ2
z a±
= +1 a±
, σ1
zσ2
z b±
= −1 b±
As examination of the equations above shows, mea-
surement of the operator σ1
zσ2
z tells us whether the first
and second qubits match. If we measure +1, then the
superposition collapses to a state in which the first two
qubits match, and thus in effect no bit flip error occurred:
E1
(α |0L + β |1L ) (21)
→ α e0 a+
+ e1 a−
a+ ⊗2
+ β e0 a−
+ e1 a+
a− ⊗2
On the other hand, if we measure −1 then the super-
position collapses to a state in which the first two qubits
differ, and thus in effect a bit flip did occur:
E1
(α |0L + β |1L ) (22)
→ α ie2 b−
+ e3 b+
a+ ⊗2
+ β ie2 b+
+ e3 b−
a− ⊗2
In this sense we can think of the act of measurement
determining which error occurs, and given the knowledge
of what error this is we can correct it. In the first case
no action is necessary, and in the second case application
of σ1
x to the state will correct the bit flip error.
Suppose we have detected any bit flip errors and cor-
rected them, so the problem reduces to consideration of
state in Eq. (21). Inspection of Eq. (20) reveals that
measurement of the operator σ1
xσ2
xσ3
xσ4
xσ5
xσ6
x compares
the first two kets in the tensor product of state (21)[iv]
.
If measurement of this operator yields +1 the first two
kets are the same. On the other hand, if the measurement
yields −1 the two kets are opposite. Thus, for example,
|a+
|a+
|a+
has eigenvalue +1 with respect to this op-
erator, and |a−
|a+
|a+
has eigenvalue −1.
For example, assume we measure σ1
xσ2
xσ3
xσ4
xσ5
xσ6
x for
(21) and the measurement yields −1. Then the superpo-
sition collapses to:
→ αe1 a−
a+ ⊗2
+ βe1 a+
a− ⊗2
(23)
If we eliminate the e1 factor by renormalizing and ap-
ply σ1
z to flip the sign of the first state in the tensor
product we arrive at the state:
→ α a+ ⊗3
+ β a− ⊗3
= α |0L + β |1L (24)
Thus after detecting and correcting as necessary we
have returned to the original state. The procedure we
[iv] In fact this operator compares the relative sign between the
terms implicit in this two states. Thus, the state b+ a+ a−
has eigenvalue +1 with respect to this operator, and the state
a+ b− a− has eigenvalue −1.

5. Quantum Error Correction 5
followed is not particular to our assumption that an error
occurred on the first qubit, it can be carried out for other
qubits by carrying out an analogous set of measurements.
Also, we chose to consider a pure state for the sake of
simplicity, but the same analysis can be carried out for
ensembles described by density matrices. The only key
assumption we made was that an error occurred on a
single qubit. Hence the Shor code is capable of remedying
any single qubit error.
Note that the error operator E1
has four complex de-
grees of freedom so the image of α |0L + β |1L under
it is an infinite set. However, the process of measuring
the operators σ1
zσ2
z and σ1
xσ2
xσ3
xσ4
xσ5
xσ6
x eliminates these
degrees of freedom, reducing the set of all possible errors
to a single element. It is this fact which makes quantum
error correction possible.
B. Calderbank-Shor-Steane Codes
As can be seen from consideration of the effect of σz,
qubits can suffer from bit flip errors just like classical bits.
However, qubits can also suffer from phase flip errors.
This kind of error is described by the action of σz, and
is unique to quantum information channels[v]
. Given the
added complexity of quantum errors it is perhaps a sur-
prising result that classical error correction codes can be
used to create quantum error correction codes. The class
of quantum error correction codes created in this man-
ner are named Calderbank-Shor-Steane Codes (or CSS
codes) after their inventors. In order to understand how
these codes are constructed we must first introduce some
mathematical definitions.
1. Mathematical Background
The following are some definitions and theorems from
group theory:
Definition 1: We define a group to be a set G along with
an operation · which combines two elements of the group
to produce a third. A group must obey the following
axioms:
• Closure: If a and b are elements of G, then a·b must
be an element of G.
• Associativity: For every a, b, and c in G, (a · b) · c =
a · (b · c).
[v] Note that the action of σy on qubits can be described as a joint
bit flip and phase flip, since σy = iσzσx. Thus all quantum
errors can be described as a combination of these two types of
errors.
• Identity Element: There exists an element 1 in G
such that for each a in G we have that 1·a = a·1 =
a.
• Inverse Element: For each element a in G there
exists an element a−1
in G such that a · a−1
=
a−1
· a = 1
Definition 2: Suppose G is a group with operation ·.
We say a subset H ⊂ G is a subgroup of G if H along with
the operation · obeys the axioms above.
It can be seen from the definitions above that vector
spaces are a particular kind of group, with the commuta-
tive operation +. Thus the above definitions and any the-
orems about groups are applicable to the Hilbert spaces
we work with in quantum mechanics. We will be taking
+ as our group operation in the remainder of this paper,
denoting its inverse by − as is conventional. We will also
need the following definitions:
Definition 3: Suppose G is a group, H is a subgroup of
G, and a is an element of G. We define the coset of H in
G with respect to a to be the set:
a + H = {a + h | h is an element of H}
Definition 4: Suppose C is a subspace of some larger
vector space V. We define C⊥
to be the orthogonal space
to C, that is, the subspace of all vectors orthogonal to
the subspace C:
C⊥
= {v in V | v · x = 0 for every x in C}
When V is some Hilbert space and C is a code in V then
we call C⊥
the code dual to C. If C has generator matrix
G and parity check matrix H, then C⊥
has generator
matrix HT
and parity check matrix GT
. Furthermore, if
the dimension of V is n and the dimension of C is k then
the dimension of C⊥
is n − k.
We state the following theorem without proof. The
proof of this theorem can be found in [5].
Theorem 1 (Lagrange’s Theorem): Let G be a group
and let H be a subgroup of G. Let |G| and |H| denote
the number of elements in G and H respectively. If |G|
is finite and [G : H] denotes the number of unique left
cosets of H in G then the following equality holds:
|G| = [G : H]|H|
It can be shown that the number of left cosets is equal to
the number of right cosets, so the above equation holds
for right cosets as well. We call [G : H] the index of H in
G. We will also use the following theorems:
Theorem 2: Suppose G is a group and H is a subgroup
of G. Suppose a and b are elements of G. Then b − a is
an element of H if and only if a + H = b + H.

6. Quantum Error Correction 6
Proof: Suppose that a+H = b+H, then each element
of a + H is equal to some element of b + H. This implies
that for some h and h in H we must have that a + h =
b + h and thus b − a = h − h. Since H is a subgroup
h − h is an element of H, so b − a is an element of H.
Conversely suppose that b − a = h for some element
h of H. Then b = a + h so by associativity:
b + H = {b + h | h is an element of H}
= {a + h + h | h is an element of H}
= {a · h | h is an element of H}
= a + H
Theorem 3 Suppose G is a group and H is a subgroup
of G. Suppose a and b are elements of G. Then a and
b belong to different cosets, that is a + H = b + H, if
and only if the cosets a + H and b + H do not share any
elements in common.
Proof: For ease we prove the contrapositive statements,
which are logically equivalent. Suppose a + H and b + H
share an element in common, then by definition 3 there
must exist elements h and h of H such that a+h = b+h.
By Theorem 2 it then follows that a + H = b + H.
Conversely, suppose that a + H = b + H, then clearly
they share every element in common.
2. The CSS Procedure
We can now construct the CSS codes. The following
discussion is based on the derivation from [3]. Suppose C1
is a [n, k1] classical code, that is, C1 is a k1-dimensional
subspace of n-dimensional Hilbert space. Suppose C2 is
a [n, k2] classical code such that C2 ⊂ C1. Furthermore,
suppose C1 and C⊥
2 correct up to t errors. Define for each
element x of C1:
|x + C2 ≡
1
|C2| y∈C2
|x + y (25)
The set of vectors |x + C2 define the CSS code of C1
over C2, CSS(C1, C2). Note that the elements of the sum
(24) are exactly the elements of the coset x + C2.
Now, notice that if x is an element of C1 such that
x − x is an element of C2, then it follows from Theorem
2 that x + C2 = x + C2 and thus the states |x + C2 and
|x + C2 are equal. Furthermore, note that if x and x
belong to different cosets then it follows from Theorem 3
that x+C2 = x +C2. This implies that if x and x are in
different cosets then |x + C2 and |x + C2 are orthogonal
to each other. By Lagrange’s Theorem there are,
|C1|
|C2|
=
2k1
2k2
= 2k1−k2
(26)
cosets of C2 with respect to C1 and thus Eq. (25) de-
fines 2k1−k2
orthonormal vectors. These vectors define a
2k1−k2
-dimensional space so the CSS code CSS(C1, C2) is
a [n, k1 − k2] quantum code.
We now demonstrate how the error correction proce-
dure works. Suppose that our original state is |x + C2
and this state undergoes an error. We can describe the
bit flip error and the phase flip error respectively by the
n-dimensional bit vectors e1 and e2
[vii]
. For example, if
the nth bit of the code underwent a bit flip the nth entry
of e1 would be a 1. We can write erroneous state as:
1
|C2| y∈C2
(−1)(x+y)·e2
|x + y + e1 (27)
Here · denotes the usual vector dot product, modulo 2.
We can attach a “blank” extra qubit to this state, called
an ancilla,
1
|C2| y∈C2
(−1)(x+y)·e2
|x + y + e1 |0 (28)
and then apply a quantum operation to this joint state
such that:
|x + y + e1 |0 → |x + y + e1 |H1(x + y + e1) (29)
= |x + y + e1 |H1e1
Here H1 is the parity check matrix for the code C1,
and thus since x + y is an element of C1 it follows that
H1(x+y) = 0. After applying this operation on the state
from Eq. (28) we end up with the state:
1
|C2| y∈C2
(−1)(x+y)·e2
|x + y + e1 |H1e1 (30)
Thus when we measure the ancilla qubit we will retrieve
the vector He1. Since the classical code C1 can correct
up to t errors then as long as less than t bit flip errors oc-
curred the vector H1e1 will determine exactly on which
qubits the errors occured. We can apply σx to the er-
roneous qubits to eliminate all the bit flip errors. This
yields the state:
[vii] Recall that the phase flip noise operation on a single qubit is
described by the action of σz. The dot product (x + y) · e2
counts the number of times that a |1 in the qubit string |x + y
gets acted on by a σz noise operator, that is the number of single
qubit phase flips that occur due to the noise.

7. Quantum Error Correction 7
1
|C2| y∈C2
(−1)(x+y)·e2
|x + y (31)
Note that we have discarded the ancilla after measur-
ing it. It remains to correct the phase flip error e2. In or-
der to accomplish this we introduce the operator known
as the Hadamard gate. This operator acts on a single
qubit, and is defined by the following equations:
F |0 = |+ , F |1 = |− , F2
= 1 (32)
Applying F to every qubit in state (30) and redefining
dummy variables we get the state:
1
2n|C2| z∈C1 y∈C2
(−1)(x+y)·z
|z + e2 (33)
Now, consider the dot product y · z. Since y is an
element of C2 then if z is in C⊥
2 we have that y · z = 0 so:
y∈C2
(−1)y·z
=
y∈C2
1 = |C2|, if z ∈ C⊥
2 (34)
On the other hand if z is an element of C2 then for each
y such that y · z = 0 there exists a y such that y · z = 1
so when we sum over all y we find that:
y∈C2
(−1)y·z
= 0, if z /∈ C⊥
2 (35)
The vector space C1 is the direct sum of C2 and C⊥
2 so
combining Eqs. (34) and (35) with Eq. (33) we can write
the latter as,
1
2n/|C2| z∈C⊥
2
(−1)x·z
|z + e2 (36)
and thus we have returned to the case of the bit flip error
we encountered in Eq. (27). Using the same procedure
we used in that case, with the parity check matrix H2 for
the classical code C⊥
2 instead of H1 we can eliminate this
bit flip to arrive at the state:
1
2n/|C2| z∈C⊥
2
(−1)x·z
|z (37)
Inverting the effect of the Hadamard operations by ap-
plying them once more we finally arrive at the state:
1
|C2| y∈C2
|x + y (38)
Thus we have returned to the original encoded state.
We can see that the CSS procedure works in two steps:
First it corrects qubit bit flip errors by exploiting the bit
flip correction properties of the classical code C1. It then
uses the Hadamard operation to traslate the remaining
phase flip errors into bit flip errors, and uses the bit flip
correction properties of the classical code C⊥
2 to correct
these errors. Since both C1 and C⊥
2 can correct up to t
errors, CSS(C1, C2) can correct t qubit errors.
VI. DISCUSSION
We have introduced the formalism for describing quan-
tum noise and its effects, and we have showed that clas-
sical linear error correcting codes can be used to create
quantum error correction codes. The CSS codes can be
used to prove interesting bounds of the number of en-
coding qubits necessary in order to tolerate a particu-
lar number of errors. Furthermore, since we know good
classical error correction codes exist, the CSS procedure
shows that good quantum error correction codes also ex-
ist.
The 9-qubit code and the CSS codes we have intro-
duced are a subset of a class of codes called stabilizer
codes. These codes are derived from a very powerful for-
malism called the stabilizer formalism, which can be used
to show that some quantum information operations can
be simulated efficiently (i.e. in polynomial time) on a
classical computer. We encourage the curious reader to
refer to section 10.5 of [3] to learn more about this formal-
ism. For those interested in even further reading about
quantum error correction, [3] provides a thourough list
of important literature on the subject in section 10.6.
In our discussion of error correction we did not consider
the possibility that the application of the very operations
we used to detect and correct noise might itself induce
some noise. This is in fact something that we gener-
ally expect to occur in physical systems. Although this
does pose an extra complication, it can be shown that if
the noise induced by these operations is below a certain
threshold then quantum computation to a desireable de-
gree of precision is achievable. We state this result by
saying that quantum computation can be made fault tol-
erant. For some discussion on this subject please refer to
[3].

8. Quantum Error Correction 8
[1] S. Lin and W. Ryan, Channel Codes: Classical and Mod-
ern. Cambridge University Press, New York (2009).
[2] A. W. Harrow, 8.06 Spring 2014 Lecture Notes: 1.
Entanglement, density matrices and decoherence.
https://stellar.mit.edu/S/course/8/sp14/8.06/materials.html
(2014).
[3] I. Chuang and M. Nielsen, Quantum Computation and
Quantum Information Cambridge University Press, New
York (2010).
[4] P. W. Shor, Phys. Rev. A 52, 2493 (1995).
[5] M. Artin, Algebra. Pearson, Boston (2011).