Download Quantum Error Correction (QEC) - ETH E

Quantum Error Correction
(QEC)
Rainer Baumann, ETH Zurich 2003
[email protected], http://hypert.net/education
Contents
Contents ......................................................................................... 3
Preface ........................................................................................... 4
1. Preliminary Topics........................................................................ 5
1.1. Quantum computers and qubits ............................................... 5
1.2. Quantum gates...................................................................... 6
1.3. Measurement .......................................................................11
1.4. Shor’s factoring algorithm ......................................................12
1.5. Classical linear codes.............................................................12
2. Basics of quantum error correction................................................15
2.1. Quantum channel..................................................................15
2.2. Difficulties for quantum error correction...................................15
2.3. Quantum error correction codes (QECC) ..................................16
2.4. Errors..................................................................................28
2.5. Properties of quantum codes ..................................................30
3. Stabilizer formalism ....................................................................31
3.1. The basics............................................................................31
3.2. More formally .......................................................................33
3.3. Unitary gates and the stabilizer formalism................................34
3.4. Further examples..................................................................35
3.5. Calderbank-Shor-Steane (CSS) codes......................................37
3.6. Standard form for a stabilizer code..........................................40
3.7. Encoding, decoding, measuring and correcting .........................41
3.8. Quantum error-correction without measurement.......................43
4. Fault-tolerant quantum computation .............................................44
4.1. Basics of fault-tolerant quantum computation...........................44
4.2. Fault-tolerant procedure ........................................................45
4.3. Fault-tolerant gates...............................................................45
4.4. Fault-tolerant measurement ...................................................48
4.5. Fault-tolerant state preparation ..............................................49
5. Concatenated coding and threshold theorem ..................................50
5.1. Concatenated codes ..............................................................50
5.2. The threshold theorem ..........................................................52
6. Bounds ......................................................................................53
6.1. Quantum Hamming bound .....................................................53
6.2. Quantum Gilbert-Varshamov bound ........................................54
6.3. Quantum singleton / Knill-Laflamme bound ..............................54
7. Simulations and statistics.............................................................55
7.1. Trace distance and fidelity......................................................55
7.2. Simulations ..........................................................................55
7.3. Comparison of basic codes .....................................................57
8. Summary of most important topics ..............................................58
A. Appendix ...................................................................................59
A.1. Non-cloning theorem .............................................................59
B. Appendix - Quantum codes ..........................................................59
C. Figure Table ...............................................................................63
D. References .................................................................................64
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
3/66
Preface
Quantum error correction is a young discipline rooting in the mid
nineties. Due to large research efforts, today’s knowledge over this
topic is already very profound. But it is still a hot topic for scientists.
This paper is not a general introduction in quantum computation. It
focuses on the aspect of quantum error correction and requires
basic understandings of quantum mechanics, classical computation
and a bit group theory. Anyway in the first part a very short,
general introduction to some preliminary topics is given.
In this paper, I tried to use as much mathematics as necessary for
a general understanding without giving a detailed mathematical
derivation. Many proofs and mathematical concepts would rather
need an own paper for their discussion and don’t fit in here.
This paper originates from a term project at the Swiss Federal
Institute of Technology Zurich ETH (www.ethz.ch), Department of
Physics (www.phys.ethz.ch), Institute for Theoretical Physics, Prof.
G. Blatter.
I’d like to thank my sponsor Prof. G. Blatter for his support. I’m
grateful that he has given me the opportunity to write this work.
© Rainer Baumann, [email protected], 2003
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
4/66
1. Preliminary Topics
Computers became very important tools in today’s world. They can
solve many problems much faster than any human being could do.
But there are still a few classes of problems, which cannot be solved
efficiently on classical computers as for example the simulation of
quantum mechanics or factoring of large numbers.
Moore’s law predicts that computers get continuously faster and
smaller. Already today computer engineers face the physical
limitations concerning the speed of light and the size of atoms.
That’s why new technologies for future computers are wanted.
During his studies of quantum mechanics, Feynman discovered that
a quantum system of n spin-1/2 particles is represented in a 2ndimensional space due to entanglement and not in a 2n-dimensional
space as in the classical n bit problem. This fact led him to
conjecture that a computer based on quantum mechanics might be
much more power full than a classical one.
1.1. Quantum computers and qubits
The memory of a classical computer is an array of bits (0 or 1). For
example [001101001111001]. More formally a vector over the finite
field 2 := {0,1}. So n bits span a n-dimensional vector space over 2.
While a quantum bit, also called qubit, lies in 2, with the complex
number space (without normalization). So n qubits are in 2⊗n.
The two basis of 2 are called 0 and 1 in analogy to the values of
a classical bit. A single qubit is in the state Ψ = α 0 + β 1 with
2
2
normalization α + β =1. So a normalized qubit lives in . But for
simplicity we still write out α and
represented in the state vector form:
β . A qubit also can be
⎛α ⎞
⎜⎜ ⎟⎟
⎝β ⎠
A memory of three qubits would look like:
⎛α 1 ⎞ ⎛α 2 ⎞ ⎛α 3 ⎞
⎜⎜ ⎟⎟ ⊗ ⎜⎜ ⎟⎟ ⊗ ⎜⎜ ⎟⎟
⎝ β1 ⎠ ⎝ β 2 ⎠ ⎝ β 3 ⎠
Multiple qubits can also be entangled so that they cannot be
decomposed into two separate states. For example the EPR pair
1
( 00 + 11 ) can not be written in terms of Ψ1 Ψ2
2
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
5/66
= (α1 0 + β1 1 ) ⊗ (α 2 0 + β 2 1 ) = α1α 2 00 + α1β 2 01 + β1α 2 10 + β1β 2 11
because α 1α 2 and β1β 2 must not be zero while α 1 β 2 and β1α 2 have to
be zero.
In this paper we denote a classical bit with a double line and a qubit
with a single line.
Figure 1.1. Bit representation: classical bit (left), qubit (right)
There is another specialty in quantum states we have to look at
briefly. Consider the state e iΘ Ψ where Ψ is a normal qubit state
and Θ a real number. We say that e iΘ Ψ ≡ Ψ
are equal up to a
global phase shift. We can do this because the measurements for
them are absolutely the same. Assume a general measurement
operator Mm with probability outcome m. The measurement
equation would look like this:
m = Ψ M
Tt
m
M
m
Ψ = Ψ e − i Θ M mt M m e i Θ Ψ
Note that especially i Ψ = e iπ / 2 Ψ ≡ Ψ .
1.2. Quantum gates
To perform calculations on a quantum computer, some gates or
operations are needed as in classical computers. Such gates are
represented as unitary matrices which can be applied on the vector
space, the qubits live in. For us the most important gates are the
Pauli matrices X,Y,Z, the Hadamard gate H, the phase shift gate S,
the π/8 gate T and finally the controlled-NOT CNOT. Later on in this
paper we will permanently make use of this gates and there
representation so look at them very carefully!
⎛ 1 0⎞
⎛0
⎟ ; X =⎜
I=⎜
⎝ 0 1⎠
⎝1
1⎞
⎛ 0 −i ⎞
⎛1
⎟; Y =⎜
⎟; Z = ⎜
0⎠
⎝i 0⎠
⎝0
0 ⎤
⎡1
⎛ 1 0⎞
⎟⎟ ; π / 8 = T = ⎢
S = ⎜⎜
iπ / 4 ⎥ ;
⎣0 e ⎦
⎝0 i ⎠
0⎞
1 ⎛1 1 ⎞
⎜⎜
⎟⎟
⎟; H =
−1⎠
2 ⎝1 − 1⎠
⎛1
⎜
⎜0
CNOT = ⎜
0
⎜
⎜0
⎝
0
1
0
0
0
0
0
1
0⎞
⎟
0⎟
1⎟
⎟
0 ⎟⎠
Figure 1.2. Quantum gates
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
6/66
In a quantum circuit we represent a CNOT and a quantum gate M in
the following way:
Figure 1.3. Quantum gate representation for circuits:
CNOT (left) and M gate (right)
Note that all of these gates operate only on one qubit except the
CNOT. It is a short notion of the controlled X gate. Similarly every
arbitrary gate M can be executed conditionally (control qubits, black
point) on several qubits (targets, M-Box) on parallel.
Figure 1.4. Multiple controlled M gates
(control qubit 1+2, target qubits 3+4)
Lets have a look at the characteristics of some of these gates to for
getting familiar with them. The identity I simply lets a qubit
unchanged
⎛ 1 0 ⎞⎛ a ⎞ ⎛ a ⎞
⎟⎟⎜⎜ ⎟⎟ = ⎜⎜ ⎟⎟ .
I Ψ = ⎜⎜
⎝ 0 1 ⎠⎝ b ⎠ ⎝ b ⎠
The Pauli X gate is also called the flip gate because it flips the basis
⎛ 0 1 ⎞⎛ a ⎞ ⎛ b ⎞
⎟⎟⎜⎜ ⎟⎟ = ⎜⎜ ⎟⎟ .
X Ψ = ⎜⎜
⎝ 1 0 ⎠⎝ b ⎠ ⎝ a ⎠
The Pauli Z gate causes a phase flip
⎛ 1 0 ⎞⎛ a ⎞ ⎛ a ⎞
⎟⎟⎜⎜ ⎟⎟ = ⎜⎜ ⎟⎟ .
Z Ψ = ⎜⎜
⎝ 0 − 1⎠⎝ b ⎠ ⎝ − b ⎠
The Hadamard gate brings a base state in superposition
H Ψ =
Rainer Baumann, ETH Zurich 2003
[email protected]
1 ⎛1 1 ⎞⎛ a ⎞
1 ⎛a + b⎞
⎜⎜
⎟⎟⎜⎜ ⎟⎟ =
⎜⎜
⎟⎟ .
2 ⎝1 − 1⎠⎝ b ⎠
2 ⎝a − b⎠
Quantum Error Correction
7/66
It’s nice to see that H 2 = X and S 2 = Z .
When you look at the equation below you’ll understand why the T
gate is also called the π/8 gate.
⎡e − iπ / 8
π /8 = ⎢
⎣ 0
0 ⎤
0 ⎤ ⎡1
≡
=T
⎥
⎢
iπ / 4 ⎥
e iπ / 8 ⎦ ⎣0 e ⎦
Now we want to have a look at gates acting on two qubits. The
most popular is the controlled-NOT which flips the target qubit if the
control qubit is set. According to classical bits, we call a qubit set if
it is in the base state 1 and not set if it is in the base state 0 .
CNOT Ψ1 Ψ2
⎛1
⎜
⎛ ⎛ a1 ⎞ ⎛ a 2 ⎞ ⎞ ⎜ 0
= CNOT ⎜⎜ ⎜⎜ ⎟⎟ ⊗ ⎜⎜ ⎟⎟ ⎟⎟ = ⎜
⎝ ⎝ b1 ⎠ ⎝ b2 ⎠ ⎠ ⎜ 0
⎜0
⎝
0
1
0
0
0
0
0
1
0 ⎞⎛ a1 a 2 ⎞ ⎛ a1 a 2 ⎞
⎟ ⎜
⎟
⎟⎜
0 ⎟⎜ a1b2 ⎟ ⎜ a 2 b2 ⎟
=
1 ⎟⎜ b1 a 2 ⎟ ⎜ b1b2 ⎟
⎟ ⎜
⎟
⎟⎜
0 ⎟⎠⎜⎝ b1b2 ⎟⎠ ⎜⎝ b1 a 2 ⎟⎠
Putting all together we are now able to construct a circuit which
prepares entangled EPR pairs.
Ψ1
EPRΨ12
Ψ2
Figure 1.5. Quantum circuit to create entangled EPR state
CNOT • (H ⊗ I ) • Ψ1 Ψ2
⎛1
⎜
⎜0
=⎜
0
⎜
⎜0
⎝
0
1
0
0
0
0
0
1
0 ⎞⎛ 1
⎟⎜
0 ⎟⎜ 0
1 ⎟⎜ 1
⎟⎜
0 ⎟⎠⎜⎝ 0
0 1
0 ⎞⎛ a1 a 2 ⎞
⎛ a1 a 2 + b1b2 ⎞
⎜
⎟
⎟⎜
⎟
1 0 1 ⎟⎜ a1b2 ⎟
1 ⎜ a1b2 + b1b2 ⎟
=
0 − 1 0 ⎟⎜ b1 a 2 ⎟
2 ⎜⎜ b1 a 2 − b1b2 ⎟⎟
⎟
⎟⎜
⎜a a − b a ⎟
1 0 − 1⎟⎠⎜⎝ b1b2 ⎟⎠
⎝ 1 2 1 2⎠
For a concrete EPR state this would look like:
⎛1⎞
⎛1⎞
⎜ ⎟
⎜ ⎟
1 ⎜ 0 ⎟ 00 + 11
⎜ 0⎟
EPR12 0 0 = CNOT • (H ⊗ I ) • ⎜ ⎟ =
⎜0⎟ =
0
2
2
⎜ ⎟
⎜ ⎟
⎜1⎟
⎜ 0⎟
⎝ ⎠
⎝ ⎠
Nice to know is also that X2=I and XZ=Y up to a global phase shift.
⎛ 0 1 ⎞⎛ 1 0 ⎞ ⎛ 0 − 1⎞
⎟⎟ = Y
⎟⎟ ≡ i⎜⎜
⎟⎟⎜⎜
XZ = ⎜⎜
⎝ 1 0 ⎠⎝ 0 − 1⎠ ⎝ 1 0 ⎠
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
8/66
Often it is good to write out the basis to understand what happens.
Below you see the basis of a 1, 2 and 3 qubit system.
⎛0 ⎞
base Ψ1 = ⎜⎜ ⎟⎟ ; base Ψ1 Ψ2
⎝1 ⎠
⎛ 00
⎜
⎜ 01
=⎜
10
⎜
⎜ 11
⎝
⎞
⎟
⎟
⎟ ; base Ψ1 Ψ2
⎟
⎟
⎠
⎛
⎜
⎜
⎜
⎜
⎜
Ψ3 = ⎜
⎜
⎜
⎜
⎜
⎜
⎝
000 ⎞
⎟
001 ⎟
010 ⎟
⎟
011 ⎟
⎟
100 ⎟
101 ⎟
⎟
110 ⎟
111 ⎟⎠
In multiple qubit systems, we often simply write the index of the
qubits lowered right to the gate instead of always writing on which
qubit we apply a certain gate. Assume we have a three qubit
system. For applying X on the second qubit, we simply write X 2 as
a short form for I ⊗ X ⊗ I .
1.2.1. Reversible quantum gates and
irreversible classical gates
Mathematically a quantum gate is described as a unitary matrix.
Since every unitary matrix has an inverse, every calculation on a
quantum computer must be reversible. Note that this is different to
a classical computer where most gates are irreversible. For example
a logical XOR (a XOR b = c) is not reversible, because it is
impossible to determine the values of a and b from c. So the
question comes up how to implement this irreversible gates in a
reversible manner? This problem can be solved very easily by just
keeping one of the original values. For example to calculate a XOR
we can use the following circuit:
A
A
B
A⊕ B
Figure 1.6. Reversible XOR circuit
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
9/66
1.2.2. Universal quantum gates
In classical computers all logic can be build up from a small set of
so called universal gates or even from one single (e.g. NAND). This
is not surprising, as the truth table of a classical gate has finite
combinations of outputs. This is very important for hardware
construction. If we are able to implement such a set of universal
gates we can compute what ever we want.
But in quantum computation, infinitely many different gates exist.
Implementing all of them is impossible. But fortunately, it turns out
that also in quantum computation sets of universal quantum gates
exist which can approximate every other quantum gate with an
arbitrary small error. This first set consists of the CNOT, Hadamard
and T gates. The second set consists of the CNOT, Hadamard, phase
and Toffoli gates.(The Toffoli gate is a CNOT with two control qubits
and one target qubit.) We will see in section four that all of this
gates can be implemented fault-tolerantly.
The Hadamard and T gate are used to approximate any single qubit
unitary operation. The CNOT allows us to approximate multiple
qubit unitary operations. A detailed proof of this would really go
beyond the scope of this paper and can be found in the book of
Nielsen and Chuang. The main idea is that we have to construct a
rotation by an irrational multiple of 2π . Combining T and HTH let us
construct a rotation on the Bloch sphere along the axis
π
π
π⎞
r ⎛
π
n = ⎜⎜ cos , sin , cos ⎟⎟ through the angle Θ = 2 cos :
8
8
8⎠
8
⎝
π
T * HTH = e
−i Z
8
*e
−i
π
8
X
Rainer Baumann, ETH Zurich 2003
[email protected]
= cos 2
π
π ⎤ π
⎡ π
I − i ⎢cos ( X + Z ) + sin Y ⎥ sin
8
8
8 ⎦
8
⎣
Quantum Error Correction
10/66
1.3. Measurement
The value of a classical bit is always deterministically 0 or 1. When
measuring a single qubit in an arbitrary state, the probability of the
outcome 0 is α 2 and for 1 β 2 . Such a measurement is done by
Hermitian projection on the basis states 0 , 1 . So a measurement
is represented by Hermitian matrices. So we get a classical bit out
of a measurement. But the axioms of quantum mechanics tells us
that after the measurement an arbitrary qubit is collapsed in the
measured bases state. So we destroy a qubit with a simple
measurement. In a quantum circuit we use the following symbol:
Figure 1.7. Symbol for measurement
We often omit the two lines representing the classical bit at the
right of a measurement because they normally do not interact again
with the rest of a circuit.
Concerning a general operator M, which is Hermitian and unitary
with eigenvalues ±1, the following circuit can be used for measuring
its eigenvalues without completely destroying the measured qubit.
After measurement, the qubit will be in the corresponding
eigenvector. This is a very important trick, but note, that we do not
gain any information about α 2 or β 2 .
0
Ψ
Φ1
Φ2
Φ3
Φ4
Figure 1.8. Measurement of general operator M
⎡1 0 ⎤
Lets verify this for the Pauli matrix Z = ⎢
⎥ . It is obvious that Z
⎣0 − 1⎦
is a hermitian, unitary matrix with eigenvalues ±1.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
11/66
Φ1 = 0 Ψ = a 0 0 + b 0 1
Φ2 =
Φ3 =
Φ4 =
1
2
1
2
(0
(a 0
+ 1 )Ψ =
1
2
(a 0
0 +a1 0 +b 0 1 +b1 1 )
0 +a1 0 +b 0 1 −b1 1
)
1
(a( 0 + 1 ) 0 + a( 0 − 1 ) 0 + b( 0 + 1 ) 1 − b( 0 − 1 ) 1 )
2
1
( 0 (a 0 + a 0 + b 1 − b 1 ) + 1 (a 0 − a 0 + b 1 + b 1
2
= (a 0 0 + b 1 1 )
=
))
Measuring the first qubit, let us now determine the eigenvalue of Z
leaving Ψ in the corresponding eigenstate.
1.4. Shor’s factoring algorithm
For a long time it was not clear how to use the power of quantum
computers. The major problem was the collapse of coherent states
during measurements of a general qubit. It seemed impossible to
get out a detailed result of a quantum computation.
Peter Shor published in 1994 a surprising algorithm for the
factorization of large numbers, which handled this problem in a very
clever way. Most of modern public cryptography is based on the
assumption that the factorization of large numbers is extremely
difficult. But the new algorithm would allow solving this problem in
polynomial time. This was a great improvement. For the interested
reader, there are many good introduction to this algorithm so we
won’t disuse it in here.
1.5. Classical linear codes
Linear codes have been developed for making classical
communication fault tolerant. With them it is possible to
communicate over noisy and erroneous data channels. Encoding is
used very often, because in reality there is no errorless
communication. Famous examples for such communications are
telecommunication (fix net or mobile), modem connections to the
Internet, Ethernet networks.
The major idea is to encode k data bits in n bits. The n-k bits are
used for introducing additional information, the so called
redundancy. This redundancy can be used to detect bit flips
occurred during transmission.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
12/66
Assume we want to send the data bit x. We encode this with the
generator matrix G by multiplication. This results in the code word
c.
⎛1⎞
⎛1⎞
⎜ ⎟
⎜ ⎟
x = (1) ; G = ⎜1⎟ ; x • G = c = ⎜1⎟
⎜1⎟
⎜1⎟
⎝ ⎠
⎝ ⎠
A code which encodes k data bits in n bits is called a [n,k] code. So
the code we introduced above is a [3,1] code. It simply repeats the
data bit three times. We call it the three-bit repetition code.
This encoded bit c can now be transmitted over a communication
channel. Assume that during delivery the second bit has been
flipped by the error e. So we’ll receive r.
⎛0⎞
⎛1⎞
⎜ ⎟
⎜ ⎟
e = ⎜1⎟ ; c + e = r = ⎜ 0⎟
⎜0⎟
⎜1⎟
⎝ ⎠
⎝ ⎠
For the correction of the received word we need two more things.
The so called parity check matrix H and the syndrome decoder
table. The parity check matrix is defined in the following way. When
you multiply any valid codeword c with the transposed of the parity
check matrix H you get zero.
c•HT=0
There is a straight forward way getting the parity check matrix from
the generator matrix, which can be found in every classical coding
book.
When you solve the same equation for a received word r you’ll get
the syndrome s, which allows making drawbacks on the resulted
error.
s = (c+e)•HT = (r)•HT = c•HT+e•HT = 0+e•HT = e•HT
Given the parity check matrix for our example we can calculate the
syndrome.
⎡1 1 0⎤
⎛1⎞
H =⎢
; r • H T = s = ⎜⎜ ⎟⎟ ;
⎥
⎣0 1 1 ⎦
⎝1⎠
Rainer Baumann, ETH Zurich 2003
[email protected]
Syndrome
Error Pattern
0
0
0
0
0
0
1
0
0
1
1
0
1
0
0
1
1
0
1
0
Quantum Error Correction
13/66
With a look at the syndrome table we find the occurred error e. We
now have to subtract this error from r getting c. Finally we have to
decode c by the generator matrix getting back our original data bit.
⎛1⎞
⎜ ⎟
r − e = c = ⎜1⎟ ; c • G −1 = (1)
⎜1⎟
⎝ ⎠
For the interested reader the calculation of another example is
given below, the [5,2] code.
⎛1
⎜
⎜0
⎛1⎞
x = ⎜⎜ ⎟⎟ ; G = ⎜ 1
⎜
⎝1⎠
⎜1
⎜1
⎝
⎛1⎞
⎜ ⎟
r • H = s = ⎜ 0⎟ ;
⎜ 0⎟
⎝ ⎠
T
⎛1⎞
c • G −1 = ⎜⎜ ⎟⎟
⎝1⎠
0⎞
⎛1⎞
⎛1⎞
⎟
⎜ ⎟
⎜ ⎟
1⎟
⎛1 1 1 0 0 ⎞
⎜1⎟
⎜1⎟
⎜
⎟
⎟
⎟
⎟
⎜
⎜
1 ; x • G = c = 0 ; r = 1 ; H = ⎜1 0 0 1 0 ⎟ ;
⎟
⎜ ⎟
⎜ ⎟
⎜1 1 0 0 1 ⎟
0⎟
⎜1⎟
⎜1⎟
⎝
⎠
⎜ 0⎟
⎜0⎟
1 ⎟⎠
⎝ ⎠
⎝ ⎠
Syndrome
Error Pattern
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
1
0
1
0
0
0
0
1
0
0
1
1
0
0
0
1
1
1
0
0
0
0
1
0
0
1
0
1
0
1
0
0
0
1
1
0
0
0
1
1
0
1
1
1
1
0
0
0
0
Rainer Baumann, ETH Zurich 2003
[email protected]
⎛0⎞
⎛1⎞
⎜ ⎟
⎜ ⎟
⎜0⎟
⎜1⎟
⎟
⎜
e = 1 ; r − e = c = ⎜0⎟ ;
⎜ ⎟
⎜ ⎟
⎜0⎟
⎜1⎟
⎜0⎟
⎜0⎟
⎝ ⎠
⎝ ⎠
Quantum Error Correction
14/66
2. Basics of quantum error correction
2.1. Quantum channel
In the last paragraph we heard about classical communication
channel. Lets have a look at the quantum analogue.
A quantum channel is a connection over which qubits can be sent
and coherence is preserved. In a real quantum channel always
some error occurs. An input state can be changed or even worse
can be entangled with the environment. For correcting such errors
we need to introduce some additional information which let us
figure out what happened, the so called redundancy. In a
transmission, often redundancy is encoded for several qubits
together. For this purpose we need quantum error correction codes
(QECC).
Also for stored qubits we need a certain redundancy because a
quantum memory is much more vulnerable to errors than classical
one. So it is self-evident to protect qubits by encoding them as in
communication.
2.2. Difficulties for quantum error correction
Now, one would think that we just have to take the classical linear
codes and every thing gets fine. But there are three rather big
difficulties to deal with:
•
•
No cloning theorem: Most classical codes require the
possibility to copy bits as the simple repetition code,
discussed above, which just sends the same bit several times.
Due to non-cloning we are not able to do such copies of
qubits. (See Appendix A.1 for the No cloning theorem)
Errors are continuous: Classical errors are discrete, only a bit
flip can occur. But quantum errors are continuous. A qubit can
be in any superposition of the two allowed bases states.
Determining which error occurred in order to correct would
appear to require infinite precision, and therefore infinite
resources.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
15/66
•
Measurement destroys quantum information: In classical error
correction we simply observe the value of the output data bits
to decide how to correct and decode it. But in quantum
mechanics such an observation destroys the coherence of a
state and lets it collapse in a basis state of the measurement
operator. So we have to find other ways for error detection
and correction.
Because of these problems it was believed for a long time that
quantum computation will never scale. Fortunately none of these
problems is very serious as we will see in this chapter.
2.3. Quantum error correction codes (QECC)
A quantum error correction code consists of four major steps.
Assume you want to send a sequence of data qubits over a
quantum channel. Then you split this sequence in fix sized sets of
qubits. In the figure below the size is two. These sets are encoded
independently resulting in a codeword. There are more qubits in a
codeword than data bits in the original set. This codewords can then
be transmitted over the quantum channel. We assume that
potential errors can only occur during this transmission. When you
receive the message you do some error detection and potentially
also some error recovery. These two phases together are simply
called error correction. The correct codeword can then be send
through a decoder resulting in the original set of data bits.
potential errors
Ψ
Ψ
Figure 2.1. The major elements of quantum error correction codes
The best thing for getting a first understanding of the major
elements of a quantum error correction code is to look at some
simple codes.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
16/66
2.3.1. Three-qubit flip code
Assume we want to send a single qubit
Ψ = a 0 +b1
through a
quantum channel. During transmission the qubit can be flipped to
X Ψ = b 0 + a 1 with probability p. Such a quantum channel is called
a bit flip channel. Note that a qubit flip is the same as you apply the
Pauli X gate to the qubit.
Ψ = a 0 +b1
Ψ = a 0 +b1
X Ψ =b 0 +a1
Figure 2.2. Quantum bit flip channel
We now can try to use the same idea as in the three bit repetition
code from the last chapter. We just send the qubit three times over
the quantum channel. ΨL denotes the original (logical) qubit to be
encoded. The encoding for the two base (pure) states are the
following:
0 L = 000
1L = 111
For
an
arbitrary
qubit
ΨL = a 0 + b 1
we
get
the
encoding
Ψ = a 000 + b 111 .
But how to do this encoding without the possibility of qubit copying.
The following circuit does this encoding. The two 0 states are so
called ancillas prepared in standard state. Ancillas are additional
qubits generally introducing the redundancy.
Ψ
0
0
Figure 2.3. Three-qubit flip code - encoding circuit
We write out again the basis of a three qubit system. The easiest
way to understand the calculations is in term of bit flipping. Note
that the first bit is the control bit. If it is set it simply interchanges
the target states.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
17/66
base Ψ1 Ψ2
⎛
⎜
⎜
⎜
⎜
⎜
Ψ3 = ⎜
⎜
⎜
⎜
⎜
⎜
⎝
⎛a⎞
⎜ ⎟
000 ⎞
⎟
⎜0⎟
001 ⎟
⎜0⎟
010 ⎟⎟
⎜ ⎟
a
1
1
⎛ ⎞ ⎛ ⎞ ⎛ ⎞ ⎜0⎟
011 ⎟ Ψ
⎜⎜ ⎟⎟ ⊗ ⎜⎜ ⎟⎟ ⊗ ⎜⎜ ⎟⎟ = ⎜ ⎟
0
0
=
Ψ
=
123
⎟;
⎝b ⎠ ⎝0⎠ ⎝0⎠ ⎜b ⎟
100 ⎟
⎜0⎟
101 ⎟
⎜ ⎟
⎟
110 ⎟
⎜0⎟
⎜0⎟
111 ⎟⎠
⎝ ⎠
CNOT1,3 • CNOT1, 2 • Ψ123
⎛1
⎜
⎜0
⎜0
⎜
⎜0
=⎜
⎜0
⎜0
⎜
⎜0
⎜0
⎝
⎛1
⎜
⎜0
⎜0
⎜
⎜0
= CNOT1,3 • ⎜
⎜0
⎜0
⎜
⎜0
⎜0
⎝
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
1
0
0
0
0 ⎞⎛ a ⎞
⎟⎜ ⎟
0 ⎟⎜ 0 ⎟
0 ⎟⎜ 0 ⎟
⎟⎜ ⎟
0 ⎟⎜ 0 ⎟
⎜ ⎟
0 ⎟⎟⎜ b ⎟
1 ⎟⎜ 0 ⎟
⎟⎜ ⎟
0 ⎟⎜ 0 ⎟
0 ⎟⎠⎜⎝ 0 ⎟⎠
0 0 0 0 0 0 0 ⎞⎛ a ⎞ ⎛ a ⎞
⎟⎜ ⎟ ⎜ ⎟
1 0 0 0 0 0 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟
0 1 0 0 0 0 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟
⎟⎜ ⎟ ⎜ ⎟
0 0 1 0 0 0 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟
⎟⎜ ⎟ = ⎜ ⎟
0 0 0 0 1 0 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟
0 0 0 1 0 0 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟
⎟⎜ ⎟ ⎜ ⎟
0 0 0 0 0 0 1 ⎟⎜ b ⎟ ⎜ 0 ⎟
0 0 0 0 0 1 0 ⎟⎠⎜⎝ 0 ⎟⎠ ⎜⎝ b ⎟⎠
Or just in non-vector form:
Ψ123 = a 000 + b 100
CNOT12 (a 000 + b 100 ) = a 000 + b 110
CNOT23 (a 000 + b 100 ) = a 000 + b 111
After encoding, we now can pass each qubit independently over the
described bit flip channel. With the used encoding, we are capable
to correct a single or non qubit flip. This occurs with probability
(1 − p )3 + 3 p(1 − p )2 = 1 − 3 p 2 + 2 p 3 . So the probability of an error
remaining uncorrected or wrong corrected with this code is
3 p2 − 2 p3 .
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
18/66
Assume now, that during transmission a bit flip occurred on the first
qubit resulting in Ψr = a 100 + b 011 . The error correction consists of
the detection and recovery phase.
•
Detection: We perform a measurement with a projection
operator P to determine the error syndrome.
P0 ≡ 000 000 + 111 111 no error
P1 ≡ 100 100 + 011 011 bit flip on qubit one
P2 ≡ 010 010 + 101 101 bit flip on qubit two
P3 ≡ 001 001 + 110 110 bit flip on qubit three
Note that measurements in these basis do not change the
state because they are orthogonal.
For our received codeword Ψr
we get the following
syndrome measurements:
Ψr P0 Ψr = 0
Ψr P1 Ψr = 1
Ψr P2 Ψr = 0
Ψr P3 Ψr = 0
Note that the syndrome only contains information about what
error occurred and does not allow us to infer anything about a
or b.
•
Recovery: The syndrome tells us if and how to correct the
received state. In our example the syndrome tells us, that the
first qubit was flipped. We simply flip it back by applying X1
to it.
This all sounds very nice. But in the section about measurement, we
learned that in reality we are not able to implement this
measurement without destroying the measured qubit. So we
somehow have to find other basis which provides us with the same
information and but which can easily be implemented.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
19/66
Instead of measuring each single qubit with the four projectors P0,
P1, P2, P3 we could perform two measurements on the observable
Z1Z2 ( ≡ Z⊗Z⊗I ) and Z2Z3 ( ≡ I⊗Z⊗Z ). Each of them have
eigenvalue ±1. The corresponding eigenvectors are the two valid
codewords 000 and 111 . So we can use the measurement circuit
introduced in the section about measurements.
⎛1
⎜
⎜0
⎜0
⎜
⎜0
Z1 Z 2 = ⎜
⎜0
⎜0
⎜
⎜0
⎜0
⎝
0 0 0 0 0
1 0 0 0 0
0 −1 0 0 0
0 0 −1 0 0
0 0 0 −1 0
0 0 0 0 −1
0 0 0 0 0
0 0 0 0 0
0
0
0
0
0
0
1
0
0⎞
⎛1 0 0
⎟
⎜
0⎟
⎜0 −1 0
⎟
⎜0 0 −1
0
⎟
⎜
0⎟
⎜0 0 0
Z2Z3 = ⎜
⎟
0⎟
⎜0 0 0
⎜0 0 0
0⎟
⎟
⎜
0⎟
⎜0 0 0
⎜0 0 0
1 ⎟⎠
⎝
0
0
0
1
0
0
0
0
0 0 0
0 0 0
0 0 0
0 0 0
1 0 0
0 −1 0
0 0 −1
0 0 0
0⎞
⎟
0⎟
0⎟
⎟
0⎟
0 ⎟⎟
0⎟
⎟
0⎟
1 ⎟⎠
We can understand the observable Z1Z2 as a comparison of the first
two qubits. The eigenvalue +1 indicates they are the same and –1
that they are different.
Like this we can construct the following syndrome (right) table and
measurement basis (left).
Z1 Z2 = ( 00 11 + 11 11 ) ⊗ I − ( 01 01 + 10 10 ) ⊗ I
Z2 Z 3 = I ⊗ ( 00 11 + 11 11 ) − I ⊗ ( 01 01 + 10 10 )
Z1 Z2
Z2 Z 3
Error
+1
+1
+1
-1
I
X3
-1
+1
X1
-1
-1
X2
For our example we get:
Ψr Z 1 Z 2 Ψr = −1
Ψr Z 2 Z 3 Ψr = +1
When we look up this error in the syndrome table we find:
(-1,+1) -> X1
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
20/66
As described in the last section, measurements usually are done
with ancillas. For the observable Z1Z2, Z2Z3 the measurement and
correction circuit is shown below. The three upper lines denote the
encoded qubit block. In our figures, we will not mark them specially.
0
0
Figure 2.4. Three-qubit flip code - error detection and correction circuit with ZZ
We could even simplify this gate. Instead of the Z1Z2, Z2Z3
measurements, we could perform two controlled-NOTs on the same
target ancilla but with different control qubit. If the two control
qubits are the same, the ancilla either stays in the 0 state or gets
flipped twice resulting also in the 0 state. Like this we are able to
compare two qubits as in the circuit above.
0
0
Figure 2.5. Three-qubit flip code - error correction circuit with CNOT
The syndrome table stays the same:
Rainer Baumann, ETH Zurich 2003
[email protected]
M1
0
1
M2
0
0
Error
I
X1
1
1
X2
0
1
X3
Quantum Error Correction
21/66
For our example we get:
CNOT14 • CNOT24 • Ψr 0 0 = −1
CNOT25 • CNOT35 • Ψr 0 0 = +1
When we look up this error in the syndrome table we find (-1,+1) > X1, what we expected.
Now the decoding circuit is easy. We just reverse the encoding
circuit:
Ψ
Figure 2.6. Three-qubit flip code - decoding circuit
2.3.2. Three-qubit phase flip code
Let’s have a look at a different kind of error, which is not known
from the classical theory, the phase flip error.
Z Ψ = Z • (a 0 + b 1 ) = a 0 − b 1
A quantum channel on which a phase flip occurs with probability p is
called a phase flip channel.
Ψ = a 0 +b1
Ψ = a 0 +b1
X Ψ = a 0 −b1
Figure 2.7. Quantum phase flip channel
There is a very easy way to protect against phase flips. Suppose we
work in the qubit basis:
+ ≡
(0
+ 1)
(0 − 1 )
; − ≡
2
2
In this basis the phase flip operator Z acts as an ordinary bit flip
operator and we can use the ordinary bit flip error correction code.
The alternative syndrome measurement for this code can be
described as following H⊗3Z1Z2H⊗3 = X1X2 and H⊗3Z2Z3H⊗3 = X2X3.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
22/66
The encoding circuit is described below. The three Hadamards at the
right are responsible for the transformation of the basis.
Ψ
0
0
Figure 2.8. Three-qubit phase flip code - encoding circuit
The code qubits can now be passed independently over the
quantum phase flip channel.
For the error correction circuit we just have to convert our state
back to the standard basis using the Hadamards again. There we
can apply the same circuit as in the three-qubit flip code. Also the
syndrome table stays the same.
0
0
Figure 2.9. Three-qubit phase flip code - error correction circuit with CNOT
The decoding circuit also stays the same as in the three-qubit flip
code because we have already switched back the bases by applying
the Hadamards in the error correction circuit.
Lets have a look at the calculation of a concrete example. We first
encode our qubit:
ΨL =
3
4
0 + 1 → ΨL
5
5
Rainer Baumann, ETH Zurich 2003
[email protected]
⎛ 3/ 5⎞
⎟
⎜
⎜ 0 ⎟
⎜ 0 ⎟
⎟
⎜
⎜ 0 ⎟
0 0 =⎜
⎟
⎜ 4 / 5⎟
⎜ 0 ⎟
⎟
⎜
⎜ 0 ⎟
⎜ 0 ⎟
⎠
⎝
Quantum Error Correction
23/66
Ψc = H 1 • H 2 • H 3 • CNOT13 • CNOT12 • ΨL
⎛3/ 5⎞ ⎛ 7 / 5 ⎞
⎟ ⎜
⎟
⎜
⎜ 0 ⎟ ⎜ − 1/ 5⎟
⎜ 0 ⎟ ⎜ − 1/ 5⎟
⎟ ⎜
⎟
⎜
⎜ 0 ⎟ ⎜ 7/5 ⎟
0 0 = H1 • H 2 • H 3 • ⎜
⎟ = ⎜ − 1/ 5⎟
0
⎟ ⎜
⎟
⎜
⎜ 0 ⎟ ⎜ 7/5 ⎟
⎟ ⎜
⎟
⎜
⎜ 0 ⎟ ⎜ 7/5 ⎟
⎜ 4 / 5⎟ ⎜ − 1/ 5⎟
⎠ ⎝
⎠
⎝
Assume now, the second qubit is affected by a phase flip error
getting:
⎛1
⎜
⎜0
⎜0
⎜
⎜0
Ψr = Z 2 Ψc = ⎜
⎜0
⎜0
⎜
⎜0
⎜0
⎝
0 0 0
1 0 0
0 −1 0
0 0 −1
0 0 0
0 0 0
0 0 0
0 0 0
0
0
0
0
1
0
0
0
0 0 0 ⎞⎛ 7 / 5 ⎞ ⎛ 7 / 5 ⎞
⎟⎜
⎟ ⎜
⎟
0 0 0 ⎟⎜ − 1 / 5 ⎟ ⎜ − 1 / 5 ⎟
0 0 0 ⎟⎜ − 1 / 5 ⎟ ⎜ 1 / 5 ⎟
⎟⎜
⎟ ⎜
⎟
0 0 0 ⎟⎜ 7 / 5 ⎟ ⎜ − 7 / 5 ⎟
=
0 0 0 ⎟⎟⎜⎜ − 1 / 5 ⎟⎟ ⎜⎜ − 1 / 5 ⎟⎟
1 0 0 ⎟⎜ 7 / 5 ⎟ ⎜ 7 / 5 ⎟
⎟⎜
⎟ ⎜
⎟
0 − 1 0 ⎟⎜ 7 / 5 ⎟ ⎜ − 7 / 5 ⎟
0 0 − 1⎟⎠⎜⎝ − 1 / 5 ⎟⎠ ⎜⎝ 1 / 5 ⎟⎠
Now we apply the Hadamards to convert our received word back in
the normal basis and measure it as in the three-qubit flip code.
ΨHr
⎛ 7/5 ⎞ ⎛ 0 ⎞
⎟ ⎜
⎟
⎜
⎜ −1/ 5 ⎟ ⎜ 0 ⎟
⎜ 1/ 5 ⎟ ⎜ 3 / 5 ⎟
⎟ ⎜
⎟
⎜
⎜ − 7 / 5⎟ ⎜ 0 ⎟
= H 1 • H 2 • H 3 • Ψr = H 1 • H 2 • H 3 • ⎜
⎟=⎜ 0 ⎟
−
1
/
5
⎟ ⎜
⎟
⎜
⎜ 7 / 5 ⎟ ⎜ 4 / 5⎟
⎟ ⎜
⎟
⎜
⎜ − 7 / 5⎟ ⎜ 0 ⎟
⎜ 1/ 5 ⎟ ⎜ 0 ⎟
⎠ ⎝
⎠
⎝
CNOT14 • CNOT24 • ΨHr 0 0 = −1
CNOT25 • CNOT35 • ΨHr 0 0 = −1
The syndrome table tells us that qubit two has been phase flipped.
Now we have to phase flip back the qubit two. This would normally
be done by Z2 but we already changed the basis and in this basis a
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
24/66
phase flip corresponds to an ordinary flip. So we simply apply X2
and we get the original code word.
X 2 ΨHr
⎛0
⎜
⎜0
⎜1
⎜
⎜0
=⎜
⎜0
⎜0
⎜
⎜0
⎜0
⎝
0
0
0
1
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
1
0
0
0
0 ⎞⎛ 0 ⎞ ⎛ 3 / 5 ⎞
⎟ ⎜
⎟
⎟⎜
0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟
0 ⎟⎜ 3 / 5 ⎟ ⎜ 0 ⎟
⎟ ⎜
⎟
⎟⎜
0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟
=
0 ⎟⎟⎜⎜ 0 ⎟⎟ ⎜⎜ 0 ⎟⎟
1 ⎟⎜ 4 / 5 ⎟ ⎜ 0 ⎟
⎟ ⎜
⎟
⎟⎜
0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟
0 ⎟⎠⎜⎝ 0 ⎟⎠ ⎜⎝ 4 / 5 ⎟⎠
2.3.3. Shor’s nine-qubit code
We now know codes which protects against an ordinary qubit flip or
a phase flip. Let us try to make a simple code out of them, which
protects against both of these errors and even the combination of
them. The main idea is to encode first the qubit using the phase flip
algorithm and then to encode each of the three resulted qubits
again with the common bit flip code. This is Shor’s nine-qubit code.
The two base code words are the following:
0L =
=
1
2 2
(( 000
+ 111 )( 000 + 111 )( 000 + 111 ))
1
( 000000000 + 000000111 + 000111000 +
2 2
111000000 + 000111111 + 111111000 + 111111111 )
1L =
=
1
2 2
(( 000
− 111 )( 000 − 111 )( 000 − 111 ))
1
( 000000000 − 000000111 − 000111000
2 2
− 111000000 + 000111111 + 111111000 − 111111111 )
As already mentioned, this code
combination of the errors X • Z = Y .
Rainer Baumann, ETH Zurich 2003
[email protected]
even
protects
Quantum Error Correction
among
the
25/66
The encoding circuit visualizes the used idea very well. At the left
you see the three-qubit phase flip encoding circuit and at the right
three times the three-qubit bit flip encoding circuits.
Ψ
0
0
0
0
0
0
0
0
Figure 2.10. Nine-qubit code – encoding circuit
The technique we used to build Shor’s nine-qubit code out of the
two previous codes is called concatenation. In concatenation codes
are cascaded to build better codes. We will have a deeper look at
this technique in a later section.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
26/66
The error correction and decoding circuit for the nine-qubit code
also concatenates the already known circuits from the three-qubit
codes. From left to right the three-qubit phase flip error correction
circuit, the three-qubit phase flip decoding, the three-qubit bit flip
error correction circuit and finally the three-qubit bit flip decoding
circuit.
Ψ
0
0
0
0
0
0
0
0
Figure 2.11. Nine-qubit code – error correction and decoding circuit
As for previous codes we can find an alternative syndrome
measurement basis. The pairwise comparison for flip detection can
be done in the following basis: Z1Z2; Z2Z3; Z4Z5; Z5Z6; Z7Z8; Z8Z9.
For the phase flip we have to compare two tripples: X1X2X3X4X5X6;
X4X5X6X7X8X9. These bases will be important in a further
generalization, in the stabilizer mechanism.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
27/66
2.4. Errors
Let’s summarize all the errors we already know:
I – no error
X - bit flip
Z – phase flip
Y – bit and phase flip
But there are infinitely many other errors, which could occur. For
example a qubit can be changed by an error E like:
Ψ =
3
4
5
12
E
⎯→
0 + 1 ⎯
0 + b1
5
5
13
13
Surprisingly these continuum errors can be reduced to the discrete
set of errors (I,X,Z,Y). Every general error E can be described as a
superposition of this discrete set:
E = e1 I + e 2 X + e3 Z + e4Y
This is a characteristic of the Pauli matrices. Lets decompose a very
nice error:
⎛1 0⎞ 1
1
⎟⎟ = I + Z
E = ⎜⎜
2
⎝0 0⎠ 2
This alone won’t help much. Now we measure the error syndrome,
in the basis of the discrete error set (I,X,Z,Y). With the
measurement the state collapses the superposition of errors into
one of the four states. Like this we have reduced an arbitrary error
to one of our four basic ones, from which we can easily correct the
error.
Lets look at a very simple example for getting the feeling what this
means. We use the three-qubit flip code. The encoded qubit would
look like:
Ψ =
000 + 111
2
Assume a very nasty error E adulterates the encoded qubit getting:
E Ψ = Ψ1 =
100 + 011 + 001 + 110
Rainer Baumann, ETH Zurich 2003
[email protected]
4
; E=
1
1
X1 + X 3
2
2
Quantum Error Correction
28/66
Let’s calculate what happens step by step.
0
0
Ψ7
Ψ3
Ψ2
Ψ1
Ψ4
Ψ6
Ψ5
Figure 2.12. Three-qubit code – error correction circuit
Ψ1 =
Ψ2 =
Ψ3 =
Ψ4 =
Ψ5 =
=
100 00 + 011 00 + 001 00 + 110 00
4
100 10 + 011 00 + 001 00 + 110 10
4
100 10 + 011 10 + 001 00 + 110 00
4
100 10 + 011 11 + 001 00 + 110 01
4
100 10 + 011 10 + 001 01 + 110 01
4
( 100 + 011 ) 10 + ( 001 + 110 ) 01
4
The two lower qubits are in the superposition:
10 + 01
2
Measuring these two qubits collapses the superposition in either 10
or 01 . Because of this the uncorrectable state Ψ5 also collapses in
a correctable one. Assume we measure M1=0 and M2=1
Ψ5
collapses into the following state:
Ψ6 =
Rainer Baumann, ETH Zurich 2003
[email protected]
001 + 110
2
01
Quantum Error Correction
29/66
This state can then easily be corrected. A look at the syndrome
table tells us that we just have to flip the third qubit with X3 back
resulting in:
Ψ7 =
000 + 111
2
2.5. Properties of quantum codes
Codes are generally characterized by the triple [n,k,d], n>k
n – length of resulting code word
k – number of qubits to be encoded
d – minimum distance
An error on a system of qubits can be decomposed in errors on
single qubits. In simple terms, the weight of an error is the number
of such single errors it consists out. A code with minimal distance d
is able to detect all errors of weight (d-1). After an error is
detected, correction is not a difficult thing any more.
The three-qubit flip and phase flip code are both [3,1,1] codes.
Shor’s nine-qubit code is a [9,1,3] code.
A quantum error-correcting code can be viewed as a mapping of k
qubits (a 2k dimensional Hilbert space) into n qubits (a 2n
dimensional Hilbert space). The additional (n-k) qubits provide the
redundancy.
In order for a code to correct two errors Ea and Eb, we must always
be able to distinguish them acting on every combination of two
different basis codewords. So for Ea Ψi
and Eb Ψj
to be
distinguishable, they must be orthogonal.
T
Ψi E a Eb Ψj = δ abδ ij
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
30/66
3. Stabilizer formalism
The stabilizer formalism is a very elegant and efficient way to
describe most quantum error correction codes. It’s partially based
on group theory. Best for familiarizing ourselves with this topic is an
example.
3.1. The basics
Actually we already met the basics of the stabilizer formalism in the
last section. Remember the alternative measurement basis for error
detection of the nine-qubit code: Z1Z2; Z2Z3; Z4Z5; Z5Z6; Z7Z8;
Z8Z9; X1X2X3X4X5X6; X4X5X6X7X8X9. Lets write them in a table
where every column represents a qubit and every row a basis called
Mi.
M1
1
Z
2
Z
3
I
4
I
5
I
6
I
7
I
8
I
9
I
Z1 Z2
M2
I
Z
Z
I
I
I
I
I
I
Z2 Z3
M3
I
I
I
Z
Z
I
I
I
I
Z4 Z5
M4
I
I
I
I
Z
Z
I
I
I
Z5 Z6
M5
I
I
I
I
I
I
Z
Z
I
Z7 Z8
M6
I
I
I
I
I
I
I
Z
Z
Z8 Z9
M7
X
X
X
X
X
X
I
I
I
X1 X2 X3 X4 X5 X6
M8 I I I X X X X X X X 4 X 5 X 6 X 7 X 8 X 9
Figure 3.1. Extended stabilizer table for the nine-qubit code
This is already the stabilizer table for the nine-qubit code. We now
want to understand the central insight of the stabilizer formalism. It
is easily illustrated by an example. Consider the EPR state:
Ψ =
00 + 11
2
It is obvious that this state satisfies the identities X 1 X 2 Ψ = Ψ and
Z1Z 2 Ψ = Ψ . We say that Ψ is stabilized by the operators Z 1 Z 2 and
X 1 X 2 . Or more formally, an operator fixes a state if the state is an
eigenvector with eigenvalue +1 of this operator.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
31/66
⎛0
⎜
⎜0
X1X 2 Ψ = ⎜
0
⎜
⎜1
⎝
0 0 1 ⎞ 1/ 2
⎟
0 1 0⎟ 0
1 0 0⎟ 0
⎟
0 0 0 ⎟⎠ 1 / 2
0
⎛1 0
⎜
⎜0 −1 0
Z1Z 2 Ψ = ⎜
0 0 −1
⎜
⎜0 0
0
⎝
0⎞ 1/ 2
⎟
0⎟ 0
0⎟ 0
⎟
1 ⎟⎠ 1 / 2
1/ 2
=
0
0
= Ψ
1/ 2
1/ 2
=
0
0
= Ψ
1/ 2
A little less obvious is that Ψ is the unique state which is stabilized
by the two operators. This is an effect from linear algebra. Two
different 4-dimensional matrices with eigenvalues ±1 have only one
common eigenvector with eigenvalue +1. The basic idea of the
stabilizer formalism is now that quantum states can be more easily
described by working with the operators that stabilizes them than
by working explicitly with the state itself.
Coming back to the nine-qubit code, we find that also the two valid
base codewords 0 L ; 1L of the code are eigenvectors of all eight
operators M1 to M8 with eigenvalue +1.
0L =
1
1L =
1
( 000000000 + 000000111 + 000111000 +
2 2
111000000 + 000111111 + 111111000 + 111111111 )
( 000000000 − 000000111 − 000111000
2 2
− 111000000 + 000111111 + 111111000 − 111111111 )
All the operators that fix both base codewords
0 L ; 1L
can be
written as the product of the eight operators Mi. The set of
operators that fix 0 L ; 1L form a group S, called ‘stabilizer’ of the
code. The Mi‘s are the generators gi of this group. Depending if we
focus on the generator or the operator aspect of a stabilizer we will
denote it by Mi or gi interchangeable.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
32/66
As we heard in the previous section, the eigenvalue measurement
of the operator M1, let us determine if a bit flip error has occurred
on either qubit 1 or 2. We saw that this qubit flip errors can be
represented by the operators X1 and X2. Note that both of these
errors X1 and X2 anticommute with M1 while all other errors, which
cannot be detected by M1, commute with it.
{M 1 , X 1 } = 0 -> M 1 X 1 Ψ = − X 1 M 1 Ψ = − X 1 Ψ
[M 1 , X 3 ] = 0
-> M 1 X 1 Ψ = + X 1 M 1 Ψ = + X 1 Ψ
Or more general:
{M , E } = 0
[M , E ] = 0
i
j
-> Mi E j Ψ = − E j Mi Ψ = − E j Ψ
i
j
-> M i E j Ψ = + E j M i Ψ = + E j Ψ
3.2. More formally
The Pauli group Gn on n qubits is defined to consist of all the Pauli
matrices, together with the multiplicative factors ±1, ±i. We write
out here just the simplest G1 Pauli group over one qubit:
G1 ≡ { ±I, ±iI, ±X, ±iX, ±Y, ±iY, ±Z, ±iZ }
This set forms a group under matrix multiplication. The stabilizer S
is an abelian subgroup of Gn. S defines the set of states Vs to be the
set of n qubit states which are fixed by every element of S. Vs is the
vector space stabilized by S.
Normally S is described by its generators personalized by the
stabilizer table seen above. Note that not any subgroup Gn can be
used as stabilizer. There are two important conditions:
• The elements of S commute with each other
• -I is not an element of S
(Because (− I ) Ψ = Ψ has only the trivial solution Ψ = 0 )
It makes sense that the generators of S are independent so that S
is as small as possible. The check matrix formalism could be used to
achieve this. So a [n,k] stabilizer code is defined to be the vector
space Vs stabilized by S=<g1, … , gn-k>.
In order to perform error-detection operations for a stabilizer code,
all we need to do is measuring the eigenvalue of each generator of
the stabilizer. This measurement than uniquely identifies the
syndrome from which can conclude on the error occurred.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
33/66
3.3. Unitary gates and the stabilizer formalism
Let’s analyze what happens when a unitary gate
U is applied to a vector space Vs stabilized by S.
Let Ψ be any element of Vs. Then for any
element
g
of
the
stabilizer
group
S,
+
U Ψ = Ug Ψ = UgU U Ψ and thus the state U Ψ is
U
gate
CNOT
+
stabilized by UgU . Group theory reasons that for
computing the changes of the stabilizer, we only
need to compute how it affects the generators of
the stabilizer. In the table at the right you see a
list of such transformations.
Any unitary operation taking an element from Gn
to an elements of Gn under conjugation can be
decomposed in H, S and CNOT gates.
We say the set of U such that UGn U + = Gn is the
normalizer of Gn denoted by N(Gn). With this
formalism we can define the distance of a
stabilizer code to be the minimum weight of an
element of N(S)-S.
H
S
X
Y
Z
gIN
gOUT
X1
X2
X1 X2
X2
Z1
Z2
Z1
Z1 Z2
X
Z
X
Z
X
Z
X
Z
X
Z
Z
X
Y
Z
X
-Z
-X
-Z
-X
Z
Figure 3.2. Gate transformation table under unitary operations (right)
Lets check this for two concrete examples:
H T XH =
1 ⎛1 1 ⎞⎛ 0 1 ⎞⎛1 1 ⎞ 1 ⎛1 1 ⎞⎛1 − 1⎞ 1 ⎛ 2 0 ⎞
⎟⎜
⎟= ⎜
⎟⎜
⎟= ⎜
⎟=Z
⎟⎜
⎜
2 ⎜⎝1 − 1⎟⎠⎜⎝ 1 0 ⎟⎠⎜⎝1 − 1⎟⎠ 2 ⎜⎝1 − 1⎟⎠⎜⎝1 1 ⎟⎠ 2 ⎜⎝ 0 − 2 ⎟⎠
H T ZH =
1 ⎛1 1 ⎞⎛ 1 0 ⎞⎛1 1 ⎞ 1 ⎛1 1 ⎞⎛ 1 1⎞ 1 ⎛ 0 2 ⎞
⎟⎜
⎟⎜
⎟= ⎜
⎟⎜
⎟= ⎜
⎟= X
⎜
2 ⎜⎝1 − 1⎟⎠⎜⎝ 0 − 1⎟⎠⎜⎝1 − 1⎟⎠ 2 ⎜⎝1 − 1⎟⎠⎜⎝ − 1 1⎟⎠ 2 ⎜⎝ 2 0 ⎟⎠
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
34/66
3.4. Further examples
3.4.1. The three-qubit flip code [3,1,1]
As developed above, the three-qubit code consists of
the generators at the right. X and Z are the X and Z
operators transformed to the code space. They are
usually also included in the stabilizer table because
they also belong to N(S) among with g1 and g2. Error
recovery for this code is done as already explained in a
previous section.
g1
Z
Z
I
g2
I
Z
Z
X
Z
X
Z
X
Z
X
Z
Figure 3.3. Stabilizer table for the three-qubit code (right)
3.4.2. The nine-qubit Code [9,1,3]
Here again the complete stabilizer table for Shor’s nine-qubit code:
g1
Z
Z
I
I
I
I
I
I
I
g2
I
Z
Z
I
I
I
I
I
I
g3
I
I
I
Z
Z
I
I
I
I
g4
I
I
I
I
Z
Z
I
I
I
g5
I
I
I
I
I
I
Z
Z
I
g6
I
I
I
I
I
I
I
Z
Z
g7
X
X
X
X
X
X
I
I
I
I
I
I
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
Z
Z
Z
Z
Z
Z
Z
Z
Z
Z
g8
Figure 3.4. Stabilizer table for the nine-qubit code
3.4.3. The five-qubit code [5,1,3]
But what is the minimum size of a quantum code, which protects a
single qubit among any single errors. As we will see in a later
section the answer is the five-qubit code. You might think now, that
this is the most important code, but due to its complexity it is not
used very often. Let’s have a look at its the stabilizer table:
g1
X
g2
Z
Z
X
I
I
X
Z
Z
X
g3
X
I
X
Z
Z
Z
X
I
X
Z
X
X
X
X
X
X
Z
Z
Z
Z
Z
Z
g4
Figure 3.5. Stabilizer table for the five-qubit code
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
35/66
From our knowledge about the generators we can build the
unnormalized base codewords very easily. For 0 L we just make a
summation over all elements of the stabilizer groups S multiplied
with 00000 . For 1L we just transfer 0 L by X which flips every
qubit. The base code words of the five-qubit looks than like:
0L =
∑ M 00000
M∈S
= 00000 + M1 00000 + M2 00000 + M3 00000 + M4 00000
+ M1 M2 00000 + M1 M3 00000 + M1 M4 00000 + M2 M3 00000
+ M2 M4 00000 + M3 M 4 00000 + M1 M2 M3 00000
+ M1 M2 M4 00000 + M1 M3 M4 00000 + M2 M3 M4 00000
+ M1 M2 M3 M4 00000
= 00000 + 10010 + 01001 + 10100 + 01010 − 11011 − 00110 − 11000
− 11101 − 00011 − 11110 − 01111 − 10001 − 01100 − 10111 + 00101
1L = X 0 L
= 11111 + 01101 + 10110 + 01011 + 10101 − 00100 − 11001 − 00111
− 00010 − 11100 − 00001 − 10000 − 01110 − 10011 − 01000 + 11010
The very complex encoding circuit of the five-qubit code is
presented below. Understanding this circuit would requires dozens
of pages of calculations. So just enjoy having a look at it:
Ψ
0
0
0
0
Figure 3.6. Five-qubit code – encoding circuit
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
36/66
3.5. Calderbank-Shor-Steane (CSS) codes
The Calderbank-Shor-Stean codes or simply CSS codes are a
subclass of the stabilizer codes. They allow to construct quantum
error correction codes from classical linear codes. Taking a classical
parity check matrix P, we can construct a quantum code, correcting
X errors, just by replacing every 1 by Z and putting I’s elsewhere.
The same can be done with a second parity check matrix Q. To
detect Z errors, we just have to place X’s instead of Z’s in the
generators.
We can combine these codes if the derived generators commute.
This is true if the rows of P and Q are orthogonal. This means that
the dual code of each code must be a subset of the other code.
Such a combined code of P [n,k1,d1] and Q [n,k2,d2] is a CSS(P,Q)
[n, |k1-k2|,d3] code with d3 = min{d1,d2}.
3.5.1. The Steane seven-qubit CSS code [7,1,3]
The most popular example of a CSS code is the seven-qubit Steane
code. It is created from the classical Hamming code [7,4,3] which is
self dual. An explanation of classical Hamming codes and self
duality is behind the scope of this paper but can be find in every
good book about classical linear codes. For our example we take for
P the parity check matrix H:
⎡0 0 0 1 1
⎢
H = ⎢0 1 1 0 0
⎢⎣ 1 0 1 0 1
1 1⎤
⎥
1 1⎥
0 1⎦⎥
And for Q the transposed of its generator G:
⎡1
⎢0
T
G =⎢
⎢0
⎢0
⎣
Rainer Baumann, ETH Zurich 2003
[email protected]
0 0
0 0
1 0
0 1
0 1
0 1
0 0
1 1
1 1⎤
0 1⎥
⎥
1 0⎥
1 1⎥⎦
Quantum Error Correction
37/66
After reducing all dependent generators and bringing them up in
standard form we end up with the following stabilizer table and base
codewords:
⎞
⎟
⎟
⎟
⎠
g1
I
⎛ 1111111 + 0101010 + 1001100 ⎞
1 ⎜
⎟
1L =
+ 0011001 + 1110000 + 0100101 ⎟
⎜
8⎜
⎟
⎝ + 1000011 + 0010110
⎠
g5
0L
⎛ 0000000 + 1010101 + 0110011
1 ⎜
=
+ 1100110 + 0001111 + 1011010
8 ⎜⎜
⎝ + 0111100 + 1101001
I
I
X
X
X
X
g2
I
X
X
I
I
X
X
g3
X
I
X
I
X
I
X
g4
I
I
I
Z
Z
Z
Z
I
Z
Z
I
I
Z
Z
g6
Z
I
Z
I
Z
I
Z
X
X
X
X
X
X
X
X
Z
Z
Z
Z
Z
Z
Z
Z
Figure 3.7. Stabilizer table for the seven-qubit code (right)
The encoding circuits looks like this:
Ψ
0
0
0
0
0
0
Figure 3.8. Stean seven-qubit code (a CSS code) – encoding circuit
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
38/66
Error correction for CSS codes is very easy because the generators
gi does not mix up X’s and Z’s. So we can correct the flip and phase
error separately with the same correction circuit in different basis.
Figure 3.9. CSS code – error correction circuit
0
0
0
Figure 3.10. Stean seven-qubit code – error correction circuit
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
39/66
3.6. Standard form for a stabilizer code
Probably you already noticed that the choice of generators is not at
all unique. We can always replace a generator gi with gigj for some
other generator gj. The goal of this paragraph is to develop a unique
representation of the stabilizer.
But first we have to learn how to write a stabilizer in a binary vector
form. Till now, we wrote all the X’s and Z’s in the same matrix. Now
we separate them in two separate ones, writing them next to each
other delaminating them by a line in the middle. Then we replace all
the I’s and empty places with 0’s and the X’s and Z’s with 1’s. For
the five-qubit code this would look like this:
⎛1
⎜0
⎜
⎜1
⎜
⎝0
0
1
0
1
0
0
1
0
1
0
0
1
00
10
00
01
1
0
0
0
1
1
0
0
0
1
1
0
0⎞
0⎟⎟
1⎟
⎟
1⎠
To bring such a binary vector in a standard form, we first have to
bring it in the following shape with Gaussian elimination:
⎛ I A B C⎞
⎜
⎟
⎝ 0 0 D E⎠
For our example this would look like:
⎛1
⎜
⎜0
⎜0
⎜
⎜0
⎝
0
1
0
0
0
0
1
0
1
0
0
1
00
10
11
11
1
0
1
0
1
1
1
1
0
1
0
1
0⎞
⎟
0⎟
0⎟
⎟
1 ⎟⎠
Then we perform another Gaussian elimination on E to get:
⎛ I A1
⎜
⎜⎜ 0 0
⎝0 0
A2 B
0 D1
0 D2
C1 C2 ⎞
⎟
I E2 ⎟
⎟
0 0⎠
Our example does not need any further elimination because D and E
do not exist.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
40/66
The generators in the first row will not commute with them in the
third unless D2=0, which really implies that S=0. So we can omit
the last line finally getting the standard form.
⎛ I A1
⎜
⎝0 0
A2 B C1 C2 ⎞
⎟
0 D I
E⎠
3.7. Encoding, decoding, measuring and
correcting
One of the great advantages of the standard form of the stabilizer
formalism is the ability for systematic construction for encoding and
decoding.
3.7.1. Encoding and decoding
For this systematic approach we need the so called Z and X
operations. We have to pick k operators independently of the
generators commuting with them and all other operators. But they
can easily be determined from the standard form:
(
X = (0E
Z = 000 A2 0I
T
T
)
I CT 00
)
⊗n
state, measure all
We can now prepare the system in an 0
observables g1,…,gn-k,Z1,…,Zk and fix the system with the Pauli
operators. Once this is prepared we can change it to any arbitrary
encoded computational basis state. There is also a much more
complex way how such an encoding can be done directly, which we
will not discus.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
41/66
3.7.2. Measuring and correcting
As in section 1.2 explained, there exists a clever gate, measuring
single qubit operators M with eigenvalues ±1, using controlled-M
operations, two Hadamard gates and an ancilla. Having this
eigenvalues it is not a great thing anymore to make the corrections
with the corresponding Pauli matrices.
So to measure the seven-qubit Stean code you can use the
following circuit:
0
0
0
0
0
0
Figure 3.11. Stean seven-qubit code –
automatic constructed error detection circuit
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
42/66
3.8. Quantum error-correction without
measurement
Till now, for error-correction, we expected to measure an operator
Mi and then executing conditionally the unitary operator Ui. But it is
also possible, just to do this correction by unitary operations and
ancillas without any measurement. This can be very useful in some
systems when measurements are very undesirable. Prepare an
ancilla system with basis state i corresponding to the possible
error syndromes. The ancilla starts in a standard pure state
0
before error-correction. Define an unitary operator U on the
principal system plus ancilla:
U Ψ 0 ≡ ∑ (U i M i Ψ ) i
i
The effect of U is to effect the transformation
R(σ ) = ∑ U i M iσM i+U i+
i
on the system being corrected, exactly the same quantum operation
as performed while common error correction.
For the nine-qubit Shor code, error-correction without measurement
is very intuitive. The decoding and correcting circuit would look like:
Ψ
Figure 3.12. Shor nine-qubit code – error correction circuit without measurement
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
43/66
4. Fault-tolerant quantum computation
One of the most powerful applications of quantum error-correction
is not the protection of stored or transmitted quantum information,
but the protection of quantum information as it dynamically
undergoes computation. This is very important because quantum
gates are not at all as reliable as classical ones and the possible
errors are much more complex. Assume we want to execute Shor’s
factoring algorithm. Although it takes polynomial time in the size of
the input, for reasonable numbers, it would still take millions of
dependent calculations. Combined with the error rate of the gates,
we would never get any useful result. Because of this it was
believed for a long time that quantum computation is just a useless
dream. But with Quantum error correction we are able to construct
fault-tolerant quantum gates, due to which we can solve this
problem.
4.1. Basics of fault-tolerant quantum computation
Our goal is to construct a quantum computer, which still produces
useful results despite of error influences. Unfortunately noise and
errors occur in every unit of a quantum computer beginning at state
preparations over gates and measurements up to simple
transmissions. To fight this problem, we replace every qubit with
the encoded block of it and the other units with their fault-tolerant
analogs.
4.1.1. Error model
Assume a single qubit has been flipped and we use this qubit as the
control qubit for a controlled-NOT. Like this the error will propagate
on the target qubit as well. Even worse, in concatenated states a
phase error can propagate backwards on the other qubits in the
same block.
So we must correct such errors as fast as possible before they affect
the whole system. By performing error-correction periodically after
every step we prevent errors to propagate.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
44/66
4.2. Fault-tolerant procedure
Let us define the fault-tolerance of a procedure to be the property
that if only one component fails then the failure causes at most one
error on each encoded qubit block. Furthermore, we require that if
only one component fails then the measurement result reported
must have a error probability O(p2), with p the maximum failure
probability over all components. Like this we ensure that, in such an
component, a single error is isolated and does not affect any other
qubits.
A component is an independent building unit after which error
correction can be done like a quantum gate, a measurement or a
state preparation.
4.3. Fault-tolerant gates
Assume you want to execute an X gate on a qubit which is encoded
in seven qubits. Then we denote this by a line over it like X . Note
that such gates act on a particular code and usually can not be
applied on other codes.
Below we will focus on the popular seven-qubit Stean code. We
need to construct a universal set of fault-tolerant quantum gates to
be able to perform all desired operations.
4.3.1. Fault-tolerant Pauli gates
In the stabilizer section, we have already described the
implementation of the X and Z gate for the Steane code:
X = X1 X 2 X 3 X 4 X5 X 6 X7 ; Z = Z1 Z2 Z3 Z4 Z5 Z6 Z7 . Out of them it is very easy to
build a Y = X Z gate. We called this kind of implementation bitwise,
because we just can apply the desired operation on every single
qubit of a code block.
It is obvious that a single error, occurring on one qubit just before
the operation or in one of the single gates like X2, does not
propagate any further, because there is no information exchange
between the qubits.
So every encoded gate implemented in bitwise fashion is
automatically fault-tolerant. This property is called transversality.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
45/66
Figure 4.1. Fault tolerant gates: X (left), Z (middle), Y (right)
4.3.2. Fault-tolerant Hadamard
An encoded Hadamard gate H should interchange X and
Z under conjugation, just as the Hadamard gate
interchanges Z and X. So the encoded Hadamard can be
implemented as H = H1 H2 H3 H4 H5 H6 H7 . It is obvious that a
single error, occurring on one qubit just before the
operation or in one of the Hi’s, does not propagate any
further, because there is no information exchange between
the qubits.
Figure 4.2. Fault tolerant Hadamard gates (right)
4.3.3. Fault-tolerant phase gate
Implementing the phase gate S is a bit trickier. When
we look at the table in section 3.3, we see that under
conjugation S should take Z to Z and X to Y = iX Z .
But a bitwise implementation of S would take Z to Z
and X to − Y . The minus sign can be fixed with a Z
operator in front. Like this we can implement S
transversaly by applying ZS to every single qubit.
Figure 4.3. Fault tolerant phase gates (right)
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
Z
S
Z
S
Z
S
Z
S
Z
S
Z
S
Z
S
46/66
4.3.4. Fault-tolerant CNOT
Let’s have a look at the CNOT gate next. The important question is,
would a bitwise implementation violate the fault-tolerance. No. A
CNOT involves two different blocks and one error in one block only
results in one error in the same block. The error is propagated to
one qubit in the other block but this does not violate our definition
of fault-tolerance.
Figure 4.4. Fault tolerant CNOT gates
4.3.5. Fault tolerant π/8 gate
For the complete set of universal gates we lack of the
implementation of a non transversal gate as the π/8 or T gate,
which is much more complex. It consists of three major steps:
a) Prepare an ancilla, in base state, apply a Hadamard and then
a non fault-tolerant T gate on it resulting in the state:
Θ = TH 0 = T
0 +1
2
=
0 + e iπ / 4 1
2
b) Apply a CNOT on the prepared state Θ as control qubit and
on the state we want to transform Ψ as target qubit. The
system would result in the following state:
⎛ 0 + e iπ / 4 1 ⎞
⎟ ⊗ (a 0 + b 1
CNOT12 Θ Ψ = CNOT12 ⎜
⎜
⎟
2
⎝
⎠
1
0 (a 0 + b 1 ) + e iπ / 4 1 (a 1 + b 0 )
= CNOT12
2
1
=
a 0 + be iπ / 4 1 0 + b 0 + ae iπ / 4 1 1
2
[
[(
Rainer Baumann, ETH Zurich 2003
[email protected]
)
]
)
(
) ]
Quantum Error Correction
47/66
c) Now we have to measure the original qubit Ψ . Resulting 0,
we are done, with 1 we have to apply SX on the originally
ancilla qubit to bring it in the state T Ψ .
For the whole thing to be fault-tolerant, we have to show that the
three steps are fault-tolerant as well. Above we showed that a faulttolerant CNOT exists and for the measurement, we will show it in
the next paragraph. But, what about the preparation? HT is an
eigenstate of Z and while measuring SX we collapse the state in the
desired state. Like this we don’t have to care about fault tolerance
here.
THZHT + = TXT + = e − iπ / 4 SX
So we end up with the following circuit. Remember, the double line
denotes a classical bit.
TΨ
0
Ψ
Figure 4.5. Fault tolerant π/8 gate
4.4. Fault-tolerant measurement
Remember from section 1.3, how a general hermitian, unitary
operator M is measured. (All tensors in Gn are hermitian and
unitary.) One first could think, that we just have to bring M in a
transversal form M’ and then measure bitwise with the same control
ancilla. But such a measurement is not fault tolerant, because an
error in the ancilla block would cause several data bits to be
corrupted.
A nice way how to avoid this problem is illustrated above.
We prepare for every data qubit an ancilla in base state. Then we
transform them to the so called ‘cat’ state with a Hadamard applied
on the first of them and a CNOT with the first qubit as the control
qubit and the other as the target.
We then have to verify this state by measuring them in pair like in
the three-qubit flip code form section 2. If the cat is fine we
continue, otherwise we just start again from the beginning.
Then we perform the controlled M’ operations bitwise.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
48/66
Finally we combine the so gained results with a CNOT controlled
from the first ancilla qubit on the other ancillas. Finally we have to
apply a Hadamard on the first ancilla to get the eigenvalue of M.
The last part is fault-tolerant anyway, because no error could affect
the data qubits any more. But the final measurement and the
verification measurement of the cat state can be faulty itself with a
certain probability. To reduce this error probability we just have to
perform the whole measurement procedure several times and take
the majority vote. Like this a fault-tolerant measurement with
arbitrary small error can be constructed.
0
0
0
0
0
0
Figure 4.6. Fault tolerant measurement circuit
4.5. Fault-tolerant state preparation
Now fault tolerant state preparation is very easy. You just prepare
the desired state and execute a verification as described in the
section fault-tolerant measurement before. If the state is fine,
continue, otherwise start again.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
49/66
5. Concatenated
theorem
coding
and
threshold
Encoding data using quantum error-correcting codes and applying
fault-tolerant operations may also introduce new errors. So if the
arbitrary error rate p of a component is to high we could do things
even worse. It could be shown that the probability for a faulttolerant circuit to introduce two or more errors into a single block is
at most cp2 for some constant c≈104. So the encoded procedure will
succeed with probability 1-cp2. Assume p is small enough, e.g.
p<10-4, there is a real benefit using this technology. But we would
still have a failure probability of cp2. For an arbitrary long
calculation as Shor’s factoring algorithm with millions of calculation
this is not useable. The success probability for a n step calculation is
(1-cp2n)n. Assume a million calculations with a failure probability
p<10-4 than the success probability is already inexistent with <101000. Even repeating the same calculation several times and take
the majority result want help anymore.
5.1. Concatenated codes
Knill and Laflamme solved this problem by introducing the
concatenated codes we met already in Shor’s nine-qubit code. A
concatenated code encodes a set of k qubits with a [n,k,d] code. It
than takes every obtained qubit and encodes it again using a
[n1,1,d1], these qubits could be encoded again with a [n2,1,d2] code
and so on indefinitely. For k concatenation, this results in a
[nn1n2..nk,k,dd1d2..dk] code. A so concatenated code has a failure
2k
probability of (cp ) / c . This increase of reliability is remarkable. We
now can construct quantum error-correction codes with arbitrary
failure probability. Like this, it will be possible to execute arbitrary
long calculations on a quantum computer. If such codes are
transversal the effort for measurements and corrections are
minimal, as we saw in the previous section.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
50/66
The circuit below visualizes the idea of concatenated codes with
depth 3:
Ψ1
Ψ2
Ψk
Figure 5.1. [nn1n2,k,dd1d2] concatenated code
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
51/66
5.2. The threshold theorem
Suppose we want to calculate an arbitrary long calculation on a
quantum computer with a failure probability cp per operation. For
example the factoring algorithm. The execution of the algorithm
takes P(n) gates, where P(n) is a polynomial function of the problem
size n, achieving a final accuracy of ε. For this we have to
concatenate our code k times such that:
(cp )2
c
k
≤
ε
p(n)
This gives us the sufficient condition p<pth≡1/c that a k can be
found. With respect to the growth of a circuit we get the following
theorem.
Threshold theorem for quantum computation: A quantum
circuit containing p(n) gates may be simulated with a error
probability of at most ε using
⎛
⎞
⎛ log p(n ) ⎞
O⎜⎜ poly⎜
⎟ • p(n ) ⎟⎟
⎝ ε
⎠
⎝
⎠
gates on hardware whose components fail with probability at most
p, provided p is below a constant threshold, p<pth, and given
reasonable assumptions about the noise in the underlying hardware.
[Nielsen & Chaung]
pth depends mainly on the assumptions made about the
computational capability. A conservative estimate gives pth≈10-4.
This result was very important because it dispelled the doubts that
no quantum computer could ever do arbitrary long calculation due
to error accumulation.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
52/66
6. Bounds
Theoreticians always try to make general statements over general
bounds especially for proofs. An important characteristic of classical
codes for such bounds does not held for quantum codes. In a
classical code, an error is always distinguishable from an other. Lets
take the nine-qubit Shor code and consider the effects of a Z1 and a
Z2 error. They are absolutely the same and just shift the phase of
the first three qubits. This degeneration is bad for bound proofing
but one of the reasons for the power of quantum codes.
6.1. Quantum Hamming bound
An interesting question is, which is the best possible quantum code.
The quantum Hamming bound gives a simple formula for this.
Assume a code encoding k qubits into n qubits with the potential to
⎛ n⎞
correct t errors. Suppose j≤t errors occur. So there are ⎜ ⎟ possible
⎝ j⎠
sets of error locations. A single error could be a X, Y or Z error
resulting in 3j possibilities. In order to encode k qubits in a nondegenerate way each of these errors must correspond to an
orthogonal 2k-dimensional space. The code space is 2n-dimensional
what leads to the quantum Hamming bound inequality:
t
⎛ n⎞
∑ ⎜⎝ j ⎟⎠ 3 2
j
k
≤ 2n
j =0
E.g. for [n,1] codes we get the following specialization:
2(1 + 3n) ≤ 2n ; n ≥ 5
As with classical code, we can nearly reach this bound with
random codes. But they are very hard to implement. A better
class of perfect quantum codes reaching this bound are the
Hamming codes over GF(4).
Although the quantum hamming bound is only for non-degenerative
codes, it works very well for degenerative ones as well. No
degenerative code is yet known, which brakes this bound.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
53/66
6.2. Quantum Gilbert-Varshamov bound
For quantum non-degenerative distance codes, it is generally not
possible to reach the quantum Hamming bound but another.
Assume a [n,k,d] code with j error occurring. The GilbertVarshamov Bound says, that we can always find a distance d
quantum code encoding k qubits in n qubits satisfying:
d −1
⎛ n⎞
∑ ⎜⎝ j ⎟⎠ 3 2
j
k
≥2 n
j =0
6.3. Quantum singleton / Knill-Laflamme bound
For degenerated [n,k,d] quantum codes which are able to correct
errors on any t qubits must follow the following bound:
n ≥ 4t + k
Especially this limits the minimal size of a quantum code resolving
any arbitrary single error to n ≥ 4 + 1 = 5 . We already saw a code
which accomplishes this bound, the five-qubit code.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
54/66
7. Simulations and statistics
7.1. Trace distance and fidelity
Distances describe how far two code words are away from each
other. This means how many single errors are required at minimum
to transfer a code word into another. So far we met the trace
distance d between to quantum states:
D (ρ , σ ) =
1
tr ρ − σ
2
The fidelity is an other distance metric which is not so obvious but it
has some very nice characteristics in which we cannot go in here. It
is defined as:
F (ρ , σ ) ≡ tr ρ 1 / 2σρ 1 / 2
7.2. Simulations
In this section we summarize the most important results from J.
Niwa’s and K. Matsumoto’s paper ‘Simulating the Effects of
Quantum Error Correction Schemes’. For more detailed information
you’ll find a link to the online version in the references.
Simulations and calculations of hardware error behavior correlated
with quantum error correcting codes is very important to build a
useable quantum computer.
In the chart below QECC/X means that error-correction is done
every X gates. The y-axis in the figure shows the fidelity and the xaxis the number of Hadamard transformations. It’s interesting that
not always a higher frequency of error-correction is effectively
better.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
55/66
Figure 7.1. Simulation results – error correction frequency
Simulation shows that the seven-qubit code, with a decoherence
probability p<10-4 and error-correction every 50~200 gates, is very
effective. But for p<10-3 there is no error-correction rate which is
nearly useable. We also see that for p<10-5 the differences between
the different ratios are not very large.
Below the effects of operational errors with a standard deviation of
σ<10-3 and σ<10-2 is shown. It can be seen that for arbitrary long
computation a standard deviation of σ<10-3 is clearly required.
Figure 7.2. Simulation results – operational error frequency
We learn that quantum computing hardware should have a
decoherence ratio of p<10-4 and an operational error ratio of
σ<10-3 for real world applications.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
56/66
7.3. Comparison of basic codes
Comparison among the nine-qubit, seven-qubit and five-qubit
codes.
Depth of error-correcting circuits.
[9,1,3] [7,1,3] [5,1,3]
Encoder
5
4
10
(Decoder)
Syn. Measurement
2
28
22
and recovery
The number of (minimum) required qubits.
[9,1,3] [7,1,3] [5,1,3]
Qubits
9
4
6
Transversal operations implementation.
[9,1,3] [7,1,3] [5,1,3]
Hard
Easy
hard
Simulations among these three codes have shown that the sevenqubit code is the most effective one. The bad results of the fivequbit code can mainly be explained by it’s complexity.
Figure 7.3. Simulation results – code comparison
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
57/66
8. Summary of most important topics
•
•
•
•
•
Quantum error-correction code: An [n,k,d] quantum errorcorrection code uses n qubits to encode k qubits, with
distance d.
Quantum error-correction conditions: Let C be a quantum
error-correcting code and P be the projector onto C. Then the
+
code can correct the error set {Ej} if and only if PEi E j P = αij P
for some Hermitian matrix α of complex numbers.
Stabilizer codes: Let S be the stabilizer for a stabilizer code
C(S) and suppose {Ej} is a set of errors on the Pauli group
+
such that E j Ek ∉ N(S) − S for all j and k. Then {Ej} is a
correctable set of errors for the code C(S).
Fault-tolerant quantum computation: A universal set of
logical operations on encode quantum states can be
performed in such a way that the effective failure probability
in the underlying gates.
The threshold theorem: Provide the noise in individual
quantum gates is below a certain constant threshold and
obeys certain physically reasonable assumptions; it is possible
to reliably perform an arbitrarily long quantum computation,
with only a small overhead in the size of the circuit necessary
to ensure reliability.
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
58/66
A. Appendix
A.1. Non-cloning theorem
Non-cloning theorem: It is not possible to copy an arbitrary
quantum state.
Proof: Assume we want to clone/copy the following state
Ψ = a 0 + b 1 . The result should be
Ψ = a 00 + b 11 . But a
multiplication for two general state obeys the following role:
Ψ Ψ = a 2 00 + ab 01 + ab 10 + b 2 11 So a or b must be zero. This
would no longer be an arbitrary quantum state.
B. Appendix - Quantum codes
Today hundreds of quantum codes are known. In this section
below, an overview over the stabilizers of the most important
quantum codes is given. Also some codes with distance more than
one are presented for the interested reader.
B.1. Distance one quantum codes
B.1.1. Three-qubit code [3,1,1]
g1
Z
I
Z
Z
X
Z
X
Z
X
Z
X
Z
g2
Z
I
B.1.2. Fife-qubit code [5,1,3]
Rainer Baumann, ETH Zurich 2003
[email protected]
g1
X
Z
Z
X
I
g2
I
X
Z
Z
X
g3
X
I
X
Z
Z
g4
Z
X
I
X
Z
X
X
X
X
X
X
Z
Z
Z
Z
Z
Z
Quantum Error Correction
59/66
B.1.3. Seven-qubit code [7,1,3]
g1
I
I
I
X
X
X
X
g2
I
X
X
I
I
X
X
g3
X
I
X
I
X
I
X
I
I
I
Z
Z
Z
Z
g5
I
Z
Z
I
I
Z
Z
Z
I
Z
I
Z
I
Z
g4
g6
X
X
X
X
I
I
I
I
Z
Z
Z
Z
I
I
I
I
B.1.4. Eight-qubit code [8,1,3]
g1
X
X
X
X
X
X
X
X
g2
Z
Z
Z
Z
Z
Z
Z
Z
g3
I
X
I
X
Y
Z
Y
Z
g4
I
X
Z
Y
I
X
Z
Y
I
Y
X
Z
X
Z
I
Y
X1
X
X
I
I
I
Z
I
Z
X2
X
I
X
Z
I
I
Z
I
X3
g5
X
I
I
Z
X
Z
I
I
Z1
I
Z
I
Z
I
Z
I
Z
Z2
I
I
Z
Z
I
I
Z
Z
Z3
I
I
I
I
Z
Z
Z
Z
B.1.5. Nine-qubit code [9,1,3]
g1
Z
Z
I
I
I
I
I
I
I
g2
I
Z
Z
I
I
I
I
I
I
g3
I
I
I
Z
Z
I
I
I
I
g4
I
I
I
I
Z
Z
I
I
I
g5
I
I
I
I
I
I
Z
Z
I
g6
I
I
I
I
I
I
I
Z
Z
g7
X
X
X
X
X
X
I
I
I
g8
I
I
I
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
X
Z
Z
Z
Z
Z
Z
Z
Z
Z
Z
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
60/66
B.2. Distance two quantum codes
B.2.1. [4,2,2] code
g1
X
Z
Z
X
Y
X
X
Y
X1
X
X
X
X
X2
X
I
X
Z
X3
Y
Z
Y
I
I
X
Z
Z
g2
X4
B.2.2. [11,1,5] code
g1
Z
Z
Z
Z
Z
Z
I
I
I
I
I
g2
X
X
X
X
X
X
I
I
I
I
I
g3
I
I
I
Z
X
Y
Y
Y
Y
X
Z
g4
I
I
I
X
Y
Z
Z
Z
Z
Y
X
g5
Z
Y
X
I
I
I
Z
Y
X
I
I
g6
X
Z
Y
I
I
I
X
Z
Y
I
I
g7
I
I
I
Z
Y
X
X
Y
Z
I
I
g8
I
I
I
X
Z
Y
Z
X
Y
I
I
g9
Z
X
Y
I
I
I
Z
Z
Z
X
Y
g10
Y
Z
X
I
I
I
Y
Y
Y
Z
X
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
B.3. Distance three quantum codes
B.3.1. [16,10,3] code
g1
I
X
I
X
I
X
I
X
Z
Y
Z
Y
Z
Y
Z
Y
g2
I
X
I
X
Z
Y
Z
Y
X
I
X
I
Y
Z
Y
Z
g3
I
X
Z
Y
X
I
Y
Z
I
X
Z
Y
X
I
Y
Z
g4
I
Y
X
Z
I
Y
X
Z
I
Y
X
Z
I
Y
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
61/66
B.4. Distance four quantum codes
B.4.1. [16,6,4] code
g1
I
X
I
X
I
X
I
X
Z
Y
Z
Y
Z
Y
Z
Y
g2
I
X
I
X
Z
Y
Z
Y
X
U
X
U
Y
Z
Y
Z
g3
I
X
Z
Y
X
I
Y
Z
Y
X
Z
Y
X
I
Y
Z
g4
I
Y
X
Z
I
Y
X
Z
I
Y
X
Z
I
Y
X
Z
n1
n2
I
Z
I
Z
I
Z
I
Z
X
Y
X
Y
X
Y
X
Y
I
Z
I
Z
X
Y
X
Y
Z
I
Z
I
Y
X
Y
X
I
Z
X
Y
Z
I
Y
X
I
Z
X
Y
Z
I
Y
X
I
Y
Z
X
I
Y
Z
X
I
Y
Z
X
I
Y
Z
X
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
g1
g3
n3
n4
B.4.2. [8,0,4] code
I
X
I
X
Y
Z
Y
Z
g2
I
X
Z
Y
I
X
Z
Y
I
Y
X
Z
X
Z
I
Y
n1
n2
I
Z
I
Z
Y
X
Y
X
I
Z
X
Y
I
Z
X
Y
I
Y
Z
X
Z
X
I
Y
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
X
Z
n3
X
Z
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
62/66
C. Figure Table
Figure 1.1.
Figure 1.2.
Figure 1.3.
Figure
Figure
Figure
Figure
Figure
1.4.
1.5.
1.6.
1.7.
1.8.
Figure
Figure
Figure
Figure
2.1.
2.2.
2.3.
2.4.
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
Figure
3.1.
3.2.
3.3.
3.4.
3.5.
3.6.
3.7.
3.8.
3.9.
3.10.
3.11.
Figure
Figure
Figure
Figure
Figure
Figure
4.1.
4.2.
4.3.
4.4.
4.5.
4.6.
Bit representation: classical bit (left), qubit (right) ........................6
Quantum gates .........................................................................6
Quantum gate representation for circuits: ....................................7
CNOT (left) and M gate (right) ....................................................7
Multiple controlled M gates .........................................................7
Quantum circuit to create entangled EPR state..............................8
Reversible XOR circuit................................................................9
Symbol for measurement ......................................................... 11
Measurement of general operator M .......................................... 11
The major elements of quantum error correction codes................ 16
Quantum bit flip channel .......................................................... 17
Three-qubit flip code - encoding circuit ...................................... 17
Three-qubit flip code - error detection and correction circuit with ZZ
............................................................................................. 21
Figure 2.5. Three-qubit flip code - error correction circuit with CNOT ............. 21
Figure 2.6. Three-qubit flip code - decoding circuit ...................................... 22
Figure 2.7. Quantum phase flip channel ..................................................... 22
Figure 2.8. Three-qubit phase flip code - encoding circuit ............................. 23
Figure 2.9. Three-qubit phase flip code - error correction circuit with CNOT .... 23
Figure 2.10. Nine-qubit code – encoding circuit............................................. 26
Figure 2.11. Nine-qubit code – error correction and decoding circuit ................ 27
Figure 2.12. Three-qubit code – error correction circuit.................................. 29
Extended stabilizer table for the nine-qubit code ......................... 31
Gate transformation table under unitary operations (right) ........... 34
Stabilizer table for the three-qubit code (right) ........................... 35
Stabilizer table for the nine-qubit code....................................... 35
Stabilizer table for the five-qubit code........................................ 35
Five-qubit code – encoding circuit ............................................. 36
Stabilizer table for the seven-qubit code (right) .......................... 38
Stean seven-qubit code (a CSS code) – encoding circuit .............. 38
CSS code – error correction circuit ............................................ 39
Stean seven-qubit code – error correction circuit......................... 39
Stean seven-qubit code –......................................................... 42
automatic constructed error detection circuit .............................. 42
Figure 3.12. Shor nine-qubit code – error correction circuit without measurement
............................................................................................. 43
Fault
Fault
Fault
Fault
Fault
Fault
tolerant
tolerant
tolerant
tolerant
tolerant
tolerant
gates: X (left), Z (middle), Y (right)....................... 46
Hadamard gates (right)........................................ 46
phase gates (right) .............................................. 46
CNOT gates ........................................................ 47
π/8 gate ............................................................. 48
measurement circuit ............................................ 49
Figure 5.1.
[nn1n2,k,dd1d2] concatenated code.......................................... 51
Figure 7.1.
Figure 7.2.
Figure 7.3.
Simulation results – error correction frequency ........................... 56
Simulation results – operational error frequency ......................... 56
Simulation results – code comparison ........................................ 57
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
63/66
D. References
D.1. Books
•
•
•
•
•
Quantum Computation and Quantum Information, M.A.
Nielson and I.L. Chuang; Cambridge University Press 2000
Online Book, Meglicki and Wang,
http://beige.ucs.indiana.edu/B679
INTRODUCTION TO QUANTUM COMPUTATION AND
INFORMATION, Lo, Popescu, Spiller, World Scientific
Quantum Computation: A Grand Mathematical Challenge for
the Twenty-First Century and the Millennium, Samuel J.
Lomonaco, Jr., American Mathematical Society
Quantum Computation and Information, Samuel J. Lomonaco,
Jr, Howard E. Brandt, American Mathematical Society
D.2. Lecture Notes
•
•
•
•
•
•
Information and Communication, Prof. Ueli Maurer, CS
Department ETH Zurich
Lecture notes on Quantum Computation, John Perskill,
http://www.theory.caltech.edu/people/preskill/ph229/
Doris Ahanorov, Hebrew University, Jerusalem, Israel,
http://www.cs.huji.ac.il/~doria/qcomp.huji2001.html
Quantum Computing, G. Eric Moorhouse,
http://everest.uwyo.edu/~moorhous/quantum/
Introduction to Quantum Informationprocessing, Waterloo
University, http://www.iqc.ca/~qipcourse/
Quantum Computing Circuits, John Hayes und Igor Markov,
http://vlsicad.eecs.umich.edu/Quantum/EECS598/
D.3. Papers
Most papers for this topic are available under
http://arxiv.org/abs/quant-ph.
•
•
•
•
Stabilizer Codes and Quantum Error Correction, Daniel
Gottesman, 2001, http://arxiv.org/abs/quant-ph/9705052
Concatenated Quantum Codes, E. Knill, R. Laflamme,
http://arxiv.org/abs/quant-ph/9608012
Fault-tolerant quantum computation by anyones, A. Yu.
Kitaev, http://arxiv.org/abs/quant-ph/9707021
A theory of Fault-tolerant Quantum Computation, Daniel
Gottesman, http://arxiv.org/abs/quant-ph/9702029
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
64/66
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Fault-tolerant Quantum Computation, P.W. Shor,
http://arxiv.org/abs/quant-ph/9605011
Reliable Quantum Computers, John Preskill,
http://arxiv.org/abs/quant-ph/9705031
Multiple Particle Interference and Quantum Error Correction,
Andrew Steane, http://arxiv.org/abs/quant-ph/9601029
Fault-tolerant Error Correction with Efficient Quantum Codes,
D.P. DiVincenzo, P.W. Shor, http://arxiv.org/abs/quant-ph/
9605031
Quantum Error Correction Via Codes Over GF(4), Calderbank,
Rains, Shor, Sloane, http://arxiv.org/abs/quant-ph/9608006
Good quantum error-correcting codes exist, Calderbank, Shor,
http://arxiv.org/abs/quant-ph/9512032
Quantum Error Correction and Orthogonal Geometry,
Calderbank, Rains, Shor, Sloane, http://arxiv.org/abs/quantph/9605005
A class of Quantum Error-Correcting Codes Saturating the
Quantum Hamming Bound, Daniel Gottesman,
http://arxiv.org/abs/quant-ph/9604038
Accuracy Threshold for Quantum Computation, Knill,
Laflamnme, Zurek, http://arxiv.org/abs/quant-ph/9610011
Threshold Estimate for Fault Tolerant Quantum Computing,
Zalka, http://arxiv.org/abs/quant-ph/9612028
Active stabilization, quantum computation and quantum state
synthesis, A.m. Steane, http://arxiv.org/abs/quantph/9611027
A Theory of Quantum Error-Correcting Codes, Knill, Laflamme,
http://arxiv.org/abs/quant-ph/9604034
Quantum Error-Correcting Codes Need Not Completely Reveal
the Error Syndrome, P.W. Shor, http://arxiv.org/abs/quantph/9604006
Resilient Quantum Computation: Error Models and Thresholds,
Knill, Laflamme, Zurekm, http://arxiv.org/abs/quantph/9702058
Simulating the Effects of Quantum Error Correction Schemes,
J. Niwa, K. Matsumoto,
http://arxiv.org/abs/quantph/0211071
Quantum Computing and Error Correction, A. M. Steane,
http://arxiv.org/abs/quant-ph/0304016
D.4. Talks
•
Reliability Requirements For Quantum Computation, John
Preskill,
http://www.theory.caltech.edu/people/preskill/talks/13nov96.
ps
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
65/66
D.5. More Material
•
•
•
Center for Quantum Computation, http://www.qubit.org/
Easy reading introduction to qc, Daniel Gottesman,
http://www.cs.berkeley.edu/~gottesma/
Quantum Computing, Documenta Matematica, Peter W.
Shorhttp://www.mathematik.unibielefeld.de/documenta/xvol-icm/00/Shor.MAN.html
Rainer Baumann, ETH Zurich 2003
[email protected]
Quantum Error Correction
66/66