Lecture 23: Fault­Tolerant Quantum Computation

Scribed by: Jonathan Hodges

Department of Nuclear Engineering, MIT

December 4, 2003

1 Introduction
Before von Neumann proposed classical fault­tolerance in the 1940’s, it was assumed that a compu­
tational device comprised of more than 106 components could not perform a computation wihout
encountering a fatal hardware error. Von Neumann proved that one could indeed make the com­
putation work, as long as a certain degree of overhead was tolerable. Thus follows the classical
fault­tolerance theorem:

Theorem 1 (Classical Fault­Tolerance). A computation of length n using perfect computational

components can be executed reliably (i.e. with probability 1 − n1α for polynomial α ) using O(n log n)
steps, provided the components work with probability 1 ­ � of the time and that the faults encountered
are independent.

We can sketch von Neumann’s proof of Fault­Tolerance as follows: Given classical AND,NOT,
and OR gates let us encode a 0 into many 0’s for c log n times, where c is some constant.

0 → 0000000 (1)
Now take two identical copies of “0”, call them a and b, and put them through the AND gate.
Ideally one should get 1111111. Instead, suppose the strings received are 1110101 on a and 0111111
on b. If one performs a bit­wise AND on each successive bit of the bit strings a and b, the result is
0110101. Taking “triples” of bits of this resulting addition, one performs a majority vote. Thus, if
one bit has an error probablity of p , two bits in a triple being erroneous occurs with probabiltiy
3p2 . As long as p is small, one can perform operations with fault­tolerance. The same type of proof
can be shown for NOT and OR gates, thus giving universality.
In short, if one has compenents of a computer whose fidelity are high enough, and adding
additional compents is relatively easy, then the computation is indeed plausible. As it turns out
the critics were too critical. Your desktop computer does not even use a software error­correction
for doing computations, as the � for our silicon­based hardware has become increasingly small.

2 Using classical techniques for quantum computation

Classically, four methods exist for dealing with fault­tolerant computing, but only one of these
will prove feasible. Consistency checks, like the parity of a bit string, work classically, but in the
quantum world are simply not powerful enough. Checkpoints require stoping the computation at a

1
P. Shor – 18.435/2.111 Quantum Computation – Lecture 23 2

specific point, checking the result, then starting the computation again. The probablistic nature of
quantum mechanics and the no­cloning theorem make this technique useless for QC. Classically, one
might make many copies of the computation to perform a massive redundancy scheme; however,
this errs like consistency checks, as it is not “powerful enough” for quantum computations. Thus,
one is left with error correcting codes, which have previously been shown portable from the classical
to the quantum domain.

3 Quantum Fault Tolerance

In order to take an errorless quantum computation to a fault­tolerant computation, one first encodes
each qubit into a quantum error correcting code. Every gate in the circuit should then be replaced
by a fault tolerant version of it. Finally, insert an error correction step after every gate. Above we
argued that fault­tolerance in classical computations need only AND, NOT, OR gates. For universal
quantum computation only the CNOT and single­qubit gates are required, but formulating fault­
tolerant operations becomes easier with a finite gate set. CNOT, Hadamard, σx , σz , T, Toffoli, and
π
8 will be proven useful.

Theorem 2 (Kitaev­Solovay Theorem). Given a set of gates on SU(2) ( or SU(k) generally)

that generates a dense set in SU(2), then any gate U ∈ SU(2) can be approximated to � using
O(log c 1� ) gates where 1 ≤ c ≤ 2. See Appendix 3 of Nielsen and Chuang for more details.

3.1 Fault Tolerance of σx

In order to show that a σx gate can be done with fault tolerance, let us encode 1 qubit into k qubits
using a CSS Code (the Steane Code).
1 �
|0� −→ � |x� (2)
|C2 | x∈C2
1 �
|1� −→ � |x + v� (3)
|C2 | x∈C2

Since dim(C1 ) is k, dim(C2 ) is k­1, this code will encode a single qubit, and satisfies the inequality
0 ⊆ C2 ⊆ C1 . The codewords v are those not overlapping the two classical codes; v ∈ C1 − C2 .
Since the encoded |0� and |1� are orthogonal, a σx should just interchange the two encodings. These
two states are separated by v, which amounts to peforming a σx on each individual qubit. Now
suppose an error is made in performing σx on one of the qubits, where the errors on each qubit are
uncorrelated. Then this code will be able to correct for these errors, resulting in a quantum error
correcting code and operation that performs σx with fault­tolerance.

3.2 Fault Tolerance of σz

By using the Steane code above, the equivalent of σz on an unencoded qubit is to apply σz to those
individual qubits with a 1 in the codeword w where w ∈ C2⊥ − C1⊥ . This results in a state |a�
acquiring a phase of (−1)a.w . Under such a transformation the code words become
1 � 1 � 1 �
� |x� −→ � (−1)x.w |x� = � |x� (4)
|C2 | x∈C2 |C2 | x∈C2 |C2 | x∈C2
P. Shor – 18.435/2.111 Quantum Computation – Lecture 23 3

1 � 1 � 1 �
� |x + v� −→ � (−1)x.w (−1)v.w |x + v� = − � |x + v� (5)
|C2 | x∈C2 |C2 | x∈C2 |C2 | x∈C2
since at least 1 vector in C1 gives v.w = 1.

3.3 Fault Tolerance of Hadamard Gate

The fault tolerance of the Hadamard gate under this CSS encoding can be seen under the additional
constraint C1 = C2⊥ . If the function E(x) represents the act of encoding the bit, the action of a
Hadamard on an encoding qubit must follow the transformations:

1
E(|0�) −→ √ (E(|0�) + E(|1�)) (6)
2
1
E(|1�) −→ √ (E(|0�) − E(|1�)) (7)
2

A Hadamard transformation of each individual qubit, H ⊗k , applied to E(|0�) will give precisely the
correct encoded transformation.

1 � 1 �
H� |x� = k � (−1)x.y |x�
|C2 | x∈C2 2 2 |C2 | y,x∈C2
1 �
= � |y�
|C2⊥ | y∈C1
|0� + |1�
= E( √ )
2
The last line follows because E(|0�) is composed of all codeword in C2 and E(|1�) is everything in
C1 , but not in C2 by definition. A Hadamard transformation on E(|1�), simply adds in the phase
factor of (−1)y.v , which obviously follows from above. This phase factor will be unity if y ∈ C2 , but
­1 if y ∈ (C1 − C2 ), thus appropriately adding a phase to the states in the code that are E(|1�).

3.4 Fault Tolerance of CNOT Gate

The σx , σz , and H gates can all be performed on a single encoded qubit with fault­tolerance because
these gates are always applied to single qubits. Likewise, given two single­qubit encoded states, one
can perform CNOT operations between the k th qubit of one set, with the k th qubit of the other.
Thus there are at most two qubits interacting for a single gate, making errors independent among
the sets of qubits, and thus correctible with the CSS Code. This can be shown as follows:

⊗k 1 � � 1 � �
UCN OT |x + va � ⊗ |y + vb � = |x� ⊗ |x + y + va + vb �
|C2 | |C2 |
x∈C2 y∈C2 x∈C2 y∈C2
1 � �
= |x� ⊗ |y + va + vb �
|C2 |
x∈C2 y∈C2
P. Shor – 18.435/2.111 Quantum Computation – Lecture 23 4

If va = vb , then va + vb = 0 in binary addition and the vector is unchanged. Otherwise, the

resulting state will be a string of 1’s added to all states |y�, which is just the encoding E(|1�). If
an error occurs in any of the two­qubit CNOT operations, this will result in va or vb not being all
0’s or all 1’s, and the CSS code will correct the the appropriate state.

4 Error Correction With Fault­Tolerant Precision

Both classical and quantum error correction schemes require encoding information into a code,
computing the syndrome of the code after errors may have occurred, then applying a syndrome­
dependent correction step to the coding to recover the information. A simple means of checking the
syndrome would be to find the parity of a subset of qubits in a code. One could thus perform a series
of CNOT gates where a single target qubit will be flipped depending on the states of the controlled
qubits. Measurement of this ancilla qubit would unveil the syndrome, but not with fault­tolerant
precision.
This can easily be seen under a Hadamard transformation, H ⊗k+1 , which reverses the direction
of the CNOT gates and gives the dual CSS code in the H⊥ space. (H is the parity check matrix of
the code C1 .) Due to the reversed CNOT, if any of the gates have an error, the error will propagate
forward in time due to the back­action of the CNOT. The stringent requirement of each error not
affecting more than a single qubit (or pair in the FT CNOT construction) is not fulfilled.
Using the idea of single failure points between qubits, as seen in the FT CNOT construction,
we start our parity check register on k qubits in the state:
1 �
|ψ� = |s� (8)
2k−1
s∈Zk2

Measurement of |ψ� in the canonical basis will result in either an odd parity bit string, indicating
a syndrome of 1, or an even parity string for a 0 syndrome. The state |ψ� can be created by applying
the Hadamard transformation to the “cat” state.
1
H ⊗k |ψ� = √ (|0� + |1�) (9)
2
(The state |x� represents a k length string of x’s.)
Now suppose a maximally entangled state can be created and verified by performing a few
CNOT gates between the bits of the cat state and an ancilla. Fault tolerance is not an issue here;
one only wants to know if the state is maximally entangled. Measuring |0� on the ancilla for a
reasonable number of test qubits ensures that the state is in some superposition of the states |0�
and |1�. The Hadamard transform of this state:

α+β 1 � α−β 1 �
H ⊗k (α |0� + β |1�) = ( √ ) k−1 |s� + ( √ ) k−1 |s� (10)
2 2 s∈even 2 2 s∈odd

Thus if α = β, the state is all zeros and no backaction will occur. The all ones state simply
adds the ones vector to the qubits. Thus, fault­tolerant measurements can be obtained.