Content uploaded by Johannes Vrana

Author content

All content in this area was uploaded by Johannes Vrana

Content may be subject to copyright.

Tal k: Decoherence and Quantum Error Correction

Page 1

Seminar on Quantum Computing - WS 2002/2003

Decoherence and Quantum Error Correction

Talk

by Johannes Vrana

Tal k: Decoherence and Quantum Error Correction

Page 2

Content

I Introduction ..............................................................................................................................................3

II Decoherence and Errors.........................................................................................................................4

1. Decoherence.................................................................................................................................................................. 4

2. Errors.............................................................................................................................................................................6

3. Assumptions in the Following Chapters .......................................................................................................................6

III Classical 3 Bit Error Correction ..........................................................................................................7

IV Initial Considerations of Quantum Error Correction........................................................................8

1. No Cloning....................................................................................................................................................................8

2. Error Types: Bit-Flip and Phase Errors.........................................................................................................................9

3. Small Errors ..................................................................................................................................................................9

V 3 Qubit Error Correction for Bit-Flip Errors ....................................................................................10

Small Errors ....................................................................................................................................................................11

VI 3 Qubit Error Correction for Phase-Flip Errors..............................................................................14

VII The Shor Code....................................................................................................................................16

IX Restrictions and The Laws of Fault-Tolerant Computation ...........................................................18

Restrictions......................................................................................................................................................................18

1. Don’t use the same bit twice .......................................................................................................................................18

2. Copy the errors, not the data .......................................................................................................................................19

3. Verify when you encode a known quantum state .......................................................................................................19

4. Repeat operations........................................................................................................................................................19

5. Use the right code........................................................................................................................................................19

Bibliography ..............................................................................................................................................20

Table of Figures.........................................................................................................................................20

Tal k: Decoherence and Quantum Error Correction

Page 3

I Introduction

Up to this point we have looked at ideal quantum computers. We can store information in this system,

transform (apply quantum gates) the quantum system and finally measure the result.

The system is made of N entangled qubits. These qubits are correlated nonlocal among each other. One

qubit can be expressed in the form:

And N entangled qubits:

But this nonlocal correlation is very weak compared to the normal local correlation (em, gravitation, ...).

And that is the reason for my talk.

ψ|〉 a0|〉 b1|〉+= a2b2

+1=ab C∈,

ψ|〉 aii|〉

i0=

2N1–

∑

=aiC∈

Tal k: Decoherence and Quantum Error Correction

Page 4

II Decoherence and Errors

1. Decoherence

What is coherence? It is the ability of a quantum mechanical system to build interferences.

What is decoherence? It is the „destruction“ of the superposition, the transition from a quantum mechanical

system to a classical system. It is a result of the dynamics of an open quantum system.

Decoherence happens because of interaction with the environment. The probability for this process rises

with the size of the system.

So we have to isolate our quantum system. But this is normally impossible. And so we have interactions

leading to new nonlocal correlations.

The typical period of time in which the system is isolated is called the decoherence time.

The worst case is that our quantum information gets stored in a correlation between some qubits and the

environment. If this happens we will not be able to carry out measurements and/or transformations (which

are measurements, too) and so our information is lost and we have to start again.

Tal k: Decoherence and Quantum Error Correction

Page 5

Lets take a famous example: Schrödingers Cat

Schrödinger had difficulties to accept the existence of certain QM states for macroscopic objects like a cat.

A state like (if you want a macroscopic qubit ;-) ) is made out of a superposition of the two

macroscopically distinguishable states and .

This state is a possible QM state. So how is it possible that we only notice either living or dead cats. One

reason is decoherence. The decoherence time for such a big system is many magnitudes smaller than the

typical characteristic time scale of the system.

Back to QC: To perform complex calculations with our Quantum Computer we need to prepare big

quantum systems (about qubits) with a decoherence time large enough to save, transform and

measure. But the decoherence time gets very short for big quantum systems and we have to think of

another solution. Some sort of error correction would be best.

Finally we have to keep in mind that simple measurement destroys our prepared state.

cat|〉 1

2

-------living|〉dead|〉+()=

cat|〉

l|〉 d|〉

106

Tal k: Decoherence and Quantum Error Correction

Page 6

2. Errors

Another way to look at our problem is to consider that errors caused by the interaction between the

quantum computer and the environment (decoherence) occure.

Let us assume that storage produces no errors but that each of our unitary transformations (each

quantum gate) involves a small error. So it will become:

And the result will differ slightly from the result we have assumed. After about gates we will get a

serious error.

Classical circuits have very similar problems but because the information is stored digitally the (small)

errors disappear after each gate. It will be projected back on the 0,1-Basis. (That is a very big advantage of

digital computers in contrast to analog computers)

But in our quantum computer we need the superposition of 0 and 1.

3. Assumptions in the Following Chapters

In the following chapters we will first discuss the error correction of information stored in the QC and

neglect errors in the gates.

U0

UU

01Oε()+()=

1

ε

---

Tal k: Decoherence and Quantum Error Correction

Page 7

III Classical 3 Bit Error Correction

The most simple way of error correction is to take 3 bits instead of 1. So we are able to make a majority

voting. If one of three bits gets skipped we can skip it back. But if two or three bits are erroneous our result

will be wrong.

Lets assume the probability of one error is . Than the probability of achieving a correct 3 bit result will be

higher than achieving a correct 1 bit result if

To improve this we can make more copies unless the multi bit result gets worse than that one with less bits.

This type of error correction code is called repetition code, since we encode the message several times.

The main assumption of this code is that every single bit error has the same probability. But there can be

some reasons for errors which involve several bits at the same time. Nevertheless the repetition code brings

some improvements.

ε

ε1

2

---

<

Tal k: Decoherence and Quantum Error Correction

Page 8

IV Initial Considerations of Quantum Error Correction

1. No Cloning

Here we have to make two copies of our first bit. So how to do that in a quantum computer?

Fig 1a: This is impossible: (Non-Cloning-Theorem)

Fig 1b: But this is possible: (we are not cloning but it is all we need)

So it is possible to build a states like => if we measure at one bit we get either

or . This means we can’t measure 1 qubit without destroying the information in the other two.

ψ|〉 a0|〉 b1|〉+= ψ|〉 a00|〉b11|〉+=

ψ′|〉 0|〉=

ψ|〉 a000|〉b111|〉+=

000|〉 111|〉

U

ψ|〉 a0|〉 b1|〉+= ψ|〉 a0|〉 b1|〉+=

ψ|〉 a0|〉 b1|〉+=ψ′|〉

Tal k: Decoherence and Quantum Error Correction

Page 9

2. Error Types: Bit-Flip and Phase Errors

Like in classical computers we have bit-flip errors:

But here we have phase errors, too:

Phase errors are serious because flips to the orthogonal . The classical error

coding provides no correction for this. So we have to think about a solution.

3. Small Errors

In a classical computer we don’t have to think about small errors, because they are not large enough to flip

the bit. Here we have continuous information and the small errors can accumulate over time and produce a

big one.

0|〉 1|〉→

1|〉 0|〉→

0|〉 0|〉→

1|〉 1|〉–→

1

2

-------0|〉 1|〉+() 1

2

-------0|〉 1|〉–()

Tal k: Decoherence and Quantum Error Correction

Page 10

V 3 Qubit Error Correction for Bit-Flip Errors

Now we have a 3 qubit state (qubits , and ). But we want to measure where the error has happened

and we want to correct this error. Of course we can’t perform a simple single qubit measurement (that

would destroy the information). So we have to measure two qubits at once - lets say and . This is

applying one qnot-gate and measuring the qubit. After this measurement we know

what we must do to correct the error.

We need to measure ( , ) and ( , ). From this result we know exactly where the error has happend.

Let us assume we start with . Now we can get to one of this four states. (The state

without an error or three states with a single-qubit-error)

With it gets

and we can measure qubit .

q1q2q3

q1q2

q2

|〉 q1q2

⊕|〉→q2

q1q2q1q3

ψ|〉 a000|〉b111|〉+=

a000|〉b111|〉a100|〉b011|〉a010|〉b101|〉a001|〉b110|〉+,+,+,+

q2

|〉 q1q2

⊕|〉→

a000|〉b101|〉a110|〉b011|〉a010|〉b111|〉a001|〉b100|〉+,+,+,+

q2

Tal k: Decoherence and Quantum Error Correction

Page 11

After that we perform and get:

Written in another way it is:

Now you see - is correct except of case 2. So what do we have to do to get where we started?

We have to invert some qubits, in case 3 and in case 4 , and we have to apply and

. Finally the error is corrected.

Small Errors

By now we have not thought about small errors. So what to do if we get a state like

with a small .

q3

|〉 q1q3

⊕|〉→

a000|〉b100|〉a111|〉b011|〉a010|〉b110|〉a001|〉b101|〉+,+,+,+

a(0|〉 b1|〉)00|〉a(1|〉 b0|〉)11|〉a(0|〉 b1|〉)10|〉a(0|〉 b1|〉)01|〉+,+,+,+

q1

q2q3q2

|〉 q1q2

⊕|〉→

q3

|〉 q1q3

⊕|〉→

a1-ε()000|〉ε100|〉+()b1-ε()111|〉ε011|〉+()+

ε

Tal k: Decoherence and Quantum Error Correction

Page 12

It is simple. We apply . With this we get:

After the measuerment of qubit it gets a bit more difficult - in most cases we get 0 (with a probability of

). This measurement leads the state to the one without the small error:

But in some cases we measure 1 (with a probability of ) and we get for sure:

To correct this states we have simply to look up what we have to do (see above).

This shows that small (single-qubit) errors automatically distinguish or get maximal. So it is very simple to

correct them.

q2

|〉 q1q2

⊕|〉→

a1-ε()000|〉ε110|〉+()b1-ε()101|〉ε011|〉+()+

q2

1-ε()

a000|〉b101|〉+

ε

a110|〉b011|〉+

Tal k: Decoherence and Quantum Error Correction

Page 13

Fig 2: Illustration of the quantum 3 bit error correction for bit-flip errors

0|〉

0|〉

a0|〉 b1|〉+

a000|〉b111|〉+

Error

M

without

Error

Preparation of the 3 Qubit-State Error Correction

M

m=

(0,0)

(1,0)

(0,1)

(1,1)

Tal k: Decoherence and Quantum Error Correction

Page 14

VI 3 Qubit Error Correction for Phase-Flip Errors

Up to now we have only corrected bit-flip errors. In a classical computer we could stop here but here we

have to think about phase flip errors.

How can they be corrected? Simple - we have to add a Hadamard Transformation on every qubit after we

have prepared the 3 qubit-state.

After that our prepared state looks like:

Now lets assume we get a phase-flip at qubit - that means we get:

Before we start we rotate all three qubits by Hadamard Transformations:

ψ|〉 a0|〉 1|〉+()0|〉 1|〉+()0|〉 1|〉+()()b0|〉 1|〉–()0|〉 1|〉–()0|〉 1|〉–()()+

22

--------------------------------------------------------------------------------------------------------------------------------------------------------------------=

q1

ψ|〉 a0|〉 1|〉–()0|〉 1|〉+()0|〉 1|〉+()()b0|〉 1|〉+()0|〉 1|〉–()0|〉 1|〉–()()+

22

--------------------------------------------------------------------------------------------------------------------------------------------------------------------=

ψ|〉 a100|〉b011|〉+=

Tal k: Decoherence and Quantum Error Correction

Page 15

Now we see that we have the same situation as above. So lets take the same algorithm. To come back to the

point we started we need three more Hadamard Transformations.

So this is nearly as simple as the correction of bit-flip.

Fig 3: Illustration of the quantum 3 bit error correction for phase-flip errors

0|〉

0|〉

a0|〉 b1|〉+

Error without

Error

Preparation of the 3 Qubit-State Error Correction

H

H

H

H

H

H

H

H

H

M

M

m=

(0,0)

(1,0)

(0,1)

(1,1)

Tal k: Decoherence and Quantum Error Correction

Page 16

VII The Shor Code

By now we know how to correct bit-flip and phase-flip errors seperate. Shor’s error correction code is a

simple combination of both. Now we prepare the state:

Fig 4: Preparation of the Shor nine qubit code

ψ|〉 a000|〉111|〉+()000|〉111|〉+()000|〉111|〉+()()b000|〉111|〉–()000|〉111|〉–()000|〉111|〉–()()+

22

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------=

0|〉

0|〉

H

0|〉

0|〉

H

0|〉

0|〉

H

0|〉

0|〉

a0|〉 b1|〉+

Qubitblock 1

Qubitblock 2

Qubitblock 3

Qubitline 1

Tal k: Decoherence and Quantum Error Correction

Page 17

How to correct errors in these nine qubits?

1. Bit-flip errors in one of the three qubitblocks is simply corrected as described before. So we can correct

one singlequbit bit-flip error in any qubitblock.

2. Phase-flip errors can be corrected almost like bit-flip errors, but we have to take a qubitline instead of a

qubitblock and to apply a Hadamard Transformation on each qubit. So you have to take qubit 1, 4 and 7 (or

2, 5, 8 or 3, 6, 9) and put it into the error correction procedure for phase-flip errors.

Fig 5: Error correction with Shor’s code

without

Error Qubitblock out

Qubitblock in

H

H

H

Qubitline in

H

H

H

Qubitline out

M

M

m=

(0,0)

(1,0)

(0,1)

(1,1)

Tal k: Decoherence and Quantum Error Correction

Page 18

IX Restrictions and The Laws of Fault-Tolerant Computation

Restrictions

We have seen a code to protect stored quantum information from (small) errors. But to correct single qubit

errors we need 9qubits. There are codes with less qubits (like Steane’s 7 qubit code) and codes for multiple

qubit errors (errors are sometimes not independent - so the probability for multiple qubit errors is of the

same magnitude as a single qubit error), but that would lead us too far.

Something we haven’t thought of is that transformations can have errors, too. Even those we used to

correct. But we can extend the codes to this.

There are some other very important rules for fault-tolerant computation we haven’t thought of yet.

These 5 were published 1996 by Shor.

1. Don’t use the same bit twice

Fig 6 (Taken from [5]): A bad circuit uses the same ancilla bit several times, and a good one only once

Tal k: Decoherence and Quantum Error Correction

Page 19

2. Copy the errors, not the data

As we have seen we copy data to the ancilla to correct the error. If the prepared state of the ancilla isn’t

prepared properly the entanglement of data and ancilla will cause decoherence.

3. Verify when you encode a known quantum state

During the encoding of the fault tolerant state we are quite vulnerable to errors because the code to protect

is not in place. So we have to be sure that this state is the right one. Otherwise a small error would

propagate catastrophically.

4. Repeat operations

We have to be really sure about the error before we correct it. If there is an error in the syndrome

measurement and we don’t check the measurement new errors will be caused instead of being corrected.

5. Use the right code

We want to efficiently apply quantum gates to the encoded information. And we want these gates to fulfill

the first 4 rules. So we have to use the right code for this.

All this rules can be implemented but they lead to a growing number of qubits and gates needed to operate

a single qubit.

Tal k: Decoherence and Quantum Error Correction

Page 20

Bibliography

[1] J. Preskill, Quantum Computation, http://theory.caltech.edu/~preskill/ph229/ (2000)

[2] W.T. Strunz, G. Alber, F.Haake, Dekohärenz in offenen Quantensystemen, Physik Journal 1 Nr. 11, 47-52 (2002)

[3] E. Joos, Dekohärenz und der Übergang von der Quantenphysik zur klassischen Physik, Verschränkte Welt, 169-195 (2002)

[4] M.A. Nielsen, I.L. Chuang, Qunatum Computation and Qunatum Information, 426-499 (2000)

[5] J. Preskill, Reliable Quantum Computers, CALT-68-2112 (1997)

Table of Figures

Fig 1a: This is impossible: (Non-Cloning-Theorem) ............................................................................................................................................8

Fig 1b: But this is possible: (we are not cloning but it is all we need)..................................................................................................................8

Fig 2: Illustration of the quantum 3 bit error correction for bit-flip errors .........................................................................................................13

Fig 3: Illustration of the quantum 3 bit error correction for phase-flip errors..................................................................................................... 15

Fig 4: Preparation of the Shor nine qubit code.................................................................................................................................................... 16

Fig 5: Error correction with Shor’s code.............................................................................................................................................................17

Fig 6 (Taken from [5]): A bad circuit uses the same ancilla bit several times, and a good one only once......................................................... 18