Innovative Computer Architectures and Concepts

Fault Tolerant Quantum Computing

Author: Mentor: Supervisor:

Abdullah Mumtaz M.Sc. INFOTECH SS 02 Valentin Gherman Prof. H.-J. Wunderlich

Index
1. Introduction 2 1.1 Decoherence2 1.2 Gate Inaccuracies.2 1.3 Basic Problems In Quantum Information3 1.4 General 1 qubit error4 2. Laws Of Fault Tolerant Computation...5 3. Quantum Error Correcting Codes 8 3.1 Shors Code....8 3.2 Steans Code.11 3.2.1 Hamming (7,4,3) Code.11 3.2.2 Steans Code.13 3.3 Good Codes...15 3.4 Conclusion....15 4. Fault Tolerant Recovery.16 4.1 Back Action Problem16 4.2 Preparing The Ancilla....16 4.3 Verifying The Ancilla....17 4.4 Fault Syndrom..17 5. Fault Tolerant Quantum Gate....18 5.1 Gates Implementation With Steans 7-qubit Code.....18 6. Conclusion..20 7. References......21

Fault Tolerant Quantum Computing

1. Introduction:
Quantum computers appear to be capable, at least in principle, of solving certain problems far faster than any conceivable classical computer. In practice, though, quantum-computing technology is still in its infancy. While a practical and useful quantum computer may eventually be constructed, we cannot clearly say at present what the hardware of that machine will be like. But in any case some type of error correction will be needed for its correct operation. As compare to digital computers of today, quantum computers are more susceptible to making, and some method of controlling and correcting those errors will be needed to prevent a quantum computer from crashing. The two known enemies of quantum computing are 1 Decoherence 2 Gate Inaccuracies

1.1 Decoherence
If we keep on putting quantum gates together into circuits we will quickly run into some serious practical problems. The more interacting qubits are involved the harder it tends to be to engineer the interaction that would display the quantum interference. Apart from the technical difficulties of working at single-atom and single-photon scales, one of the most important problems is that of preventing the surrounding environment from being affected by the interactions that generate quantum superposition. The more components the more likely it is that quantum computation will spread outside the computational unit and will irreversibly dissipate useful information to the environment. This process is called Decoherence. Even though we try to isolate the quantum system from the environment much as we can, we cannot supply total isolation. Therefore, the interaction of the quantum system and the environment result in Decoherence of the quantum state, which is equivalent to a partial measurement of the state by the environment.

1.2 Gate Inaccuracies

Decoherence is not the only problem with quantum computing. Gates, whether they are classical or quantum, are not perfect. The gates are usually combined together. So small errors in gates can combine together during computation and eventually causing failure, and it is not clear how to correct these small errors. Modern digital solve this problem with the help from dissipation. Lets take an example, envisioning a classical gate that acts on a bit, encoded as a ball residing at the one of the two minima of a double-lobed potential. The gate may push the ball over the intervening barrier to the other side of the potential. Of course, the gate wont be implemented perfectly; it may push the ball a little to hard. Over time, these imperfections might accumulate, causing an error. To improve the performance, we cool the bit after each gate. This is a dissipative process that releases heat to the environment and compresses the phase space of the ball, bringing it close to the local minimum of the potential. So the small errors that may appear, wind up heating the environment rather than compromising the performance of the device.

Fault Tolerant Quantum Computing

But this procedure can not be applied in quantum computing case. Doing so will enhance the reliability of classical information, but will destroy encoded quantum information. More generally, accumulation of error will be a problem for the classical reversible computation as well. To prevent errors from building up, information about the errors should be discarded, and throwing away information is always a dissipative process. Sophisticated machinery has been developed to contend with errors in classical information, the theory of error correcting codes. In the 50s John Von Neumann showed that a classical computer with noisy components can work reliably, by employing redundancy. He pointed out that, If necessary, we can compute each logic gate many times, and accept the majority result. The simplest example of error correcting code is a repetition code: replacing the bit we want to protect by 3 copies of the bit, 0 (000) 1 (111) Now an error may occur that causes one of the three bits to flip; If its the first bit, say, (000) (100), (111) (011), Now in spite of the error, the bit can be encoded correctly, by majority voting. But trying to use the above method in quantum computing will reveal following problems:

1.3 Basic Problems In Quantum Information

1.3.1 Phase errors
With quantum information more things can go wrong. I addition to bit-flip errors |0> |1>, |1> |0>. There can also be phase errors |0> |0> |1> -|1> A phase error is serious, because it makes the state state flip to the orthogonal

. But the classical coding provided no protection against phase errors.

Fault Tolerant Quantum Computing

1.3.2 Small Errors

Quantum information is continuous, if a qubit is intended to be in the state a|0> + b|1>, An error might change a and b by an amount of order , and these errors can accumulate over time. The classical method is designed to correct large (bit flip) errors.

1.3.3 Measurement causes disturbance

In the majority-voting scheme, it seems that it is needed to measure the bits in the code to detect and correct the errors. But measuring qubits means disturbing the quantum information that they encode.

1.3.4 No Cloning
With classic coding, we protected information by making extra copies of it. But quantum information cannot be copied with the strict accuracy.

1.4 General 1 qubit error

The qubit in question might undergo a random unitary transformation, or it might decohere by becoming entangled with states of the environment. Suppose that, if no error occurs, the qubit ought be in the state a|0>+ b|1>. (Of course, this particular qubit might be entangled with others, so the coefficients a and b need not be complex numbers; they can be states that are orthogonal to both |0> and |1>, which we assume are unaffected by the error.) Now if the qubit is affected by an arbitrary error, the resulting state can be expanded in the form:

Where each |A>env denotes a state of the environment. The evolution of the qubit can be expressed as a linear combination of four possibilities: (1) no error occurs, (2) the bit flip |0> |1> occurs, (3) the relative phase of |0> and |1> flips, (4) both a bit flip and a phase flip occur. The following four matrices represent a basis for all unitary one-qubit errors:

(2)

These matrices correspond respectively to no error, bit-flip errors, phase-flip errors and phase and bit-flip errors, as can be seen by applying them to an arbitrary single-qubit state.

Fault Tolerant Quantum Computing

2. Laws of fault-tolerant computation

To perform fault-tolerant computation, we must (1) ensure that recovery from errors is performed reliably, (2) be able to implement gates that can process encoded information (3) control propagation of errors. Applying a gate to, say, a pair of qubits, and one of the qubits has an error, and then the error will tend to spread to the other qubit. We have to contain the infection. The procedures that must be followed to implement fault-tolerant computation can be codified in the laws of fault-tolerant computation." These laws can be extracted from Shor's pioneering paper (Shor96). The first law is Don't use the same bit twice. A bad network of XOR gates that breaks this commandment is shown in Fig. 2 (using the notation of Fig. 1). The ancilla bit is the target of several successive gates. If there is a single error in this ancilla bit, this network may propagate that error to the several other bits that are the sources of the XOR gates; hence the infection spreads virulently.

Fig. 1 Diagrammatic notation for the NOT gate, the XOR (controlled-NOT) gate, and the Toffoli(Controlled-controlled-NOT) gate.

Fig. 2 A bad circuit that uses the same ancilla bit several times, and a good circuit that uses each ancilla bit only once.

While even a classical XOR gate will propagate bit flip errors from the source to the target, for quantum gates phase errors are also a problem, and the phase errors propagate in the opposite direction, from the target to the source. So in quantum computation we need to be especially careful about propagation of errors. To follow this law, and redesigning the network is shown in fig 2, expanding the ancilla to several bits so that no single bit is acted on more than once. The second law concerns how recovery from errors must be affected. To recover, the procedure is: copy some information from the data to an ancilla and then measure the ancilla to find an error syndrome that will tell what recovery operation is required. The second law says that, Copy the errors, not the data. If some of the encoded information is copied to the ancilla, the resulting entanglement of the data register and ancilla will Fault Tolerant Quantum Computing 6

cause decoherence and hence errors. To avoid this, prepare a special state of the ancilla before copying any information, chosen so that by measuring the ancilla we acquire only information about the errors that have occurred, and learn nothing about the encoded data.

Figure 3: The second law. The ancilla must be prepared properly, so that the fault-tolerant syndrome measurement diagnoses the errors without spoiling the coherence of the data.

The third law say that whenever doing anything, check (if possible) to make sure it has been done right. Often a block has to be prepared that encodes a known quantum state, such as an encoded 0. The third law says, Verify when encoding a known quantum state. During the encoding procedure the power of the code to protect against errors is not yet in place, and a single error may propagate catastrophically. Therefore, measurement is necessary that checks that the encoding has been done correctly. Of course, the verification itself may be erroneous, so repeat the verification a few times and then sufficient satisfaction can be achieved.

Figure 4: The third law. The encoder constructs |0>code, and then a nondestructive measurement is performed (at least twice) to verify that the encoding was successful.

The fourth law says repeat operations. An important application of this law is to the measurement of the syndrome that precedes recovery.

Figure 5: The fourth law. Operations such as syndrome measurement must be repeated to ensure accuracy.

Fault Tolerant Quantum Computing

An error during syndrome measurement can both damage the data and result in an erroneous syndrome. Accepting the measured syndrome mistakenly and act accordingly we will cause further damage instead of correcting the error. Therefore, it is important to be highly confident that the syndrome measurement is correct before performing the recovery. To achieve sufficient confidence, repeat the syndrome measurement several times, in accord with the fourth law. The fifth law is perhaps the most important and also the hardest to obey: Use the right code. The code for computation should have special properties so that quantum gates can be applied to the encoded information, that operate efficiently and that adhere to the first four Laws. For example, a good code for computation might be such that XOR gate acting on encoded qubits is implemented as in Fig. 6. With a single XOR gate applied to each bit in both the source block and the target block. Then the gate acting on the encoded qubits obeys the first law and is fault-tolerant.

Figure 6: The fifth law. Transversal (bitwise) implementation of a fault-tolerant XOR gate.

Fault Tolerant Quantum Computing

3. Quantum error correcting codes

3.1 Shors Code
One of the first example of a quantum error-correcting code was constructed by Peter Shor. Shor has shown how to encode a one-qubit state |a> into a 9-qubit state |S > such that we can correct any one-qubit error. Lets look at that 3 bit code one more time, but this time with a quantum code. Lets consider only bit-flip for the moment. Assume that the only thing that can happen to our codeword is having NOT operated on one of its qubits. In classical computation, correcting such an error is by using repetition code as mentioned earlier. In quantum computation, we can use a similar concept. Suppose we encode a single qubit with 3 qubits: |0> |0-> |000> |1> |1-> |111> or in other words, encoding a superposition a|0> + b|1> a|0-> + b|1-> a|000> + b|111>
(4) (3)

The basic objective is to be able to correct a bit flip error without destroying this superposition. Performing measurement on each bit separately will mean lose of the quantum information encoded in the coefficients a and b. Collective measurements on two-qubits at once can solve this problem. For a 3-qubit state |xyz>, the two-qubits observable y z, or x z (where denotes addition modulo 2) can show the bit flip error. For both |xyz> = |000> and |111> these would be 0, but if any one bit flips, then at least one of these quantities will be 1. In fact, if there is a single bit flip, two bits (y z, x z), just designate in binary notation the position(1,2 or 3) of the bit that flipped. These two bits constitute a syndrome that diagnoses the error that occurred. For example, if the first bit flips, a|000> + b|111>

a|100> + b|011>,

Then the measurement of (y z, x z) yields the result (0,1), which instructs us to flip the first bit, this indeed repairs the error. Of course, instead of a (large) bit flip there could be a small error: |000> |000> + |100> |111> |111> + |011>.

Fault Tolerant Quantum Computing

But even in this case the above procedure would work fine. In measuring (y z, x z), we would project out an eigenstate of this observable. Most of the time (probability 1-||2) (0,0) will be the result, and project the damaged state back to the original state, and so correct the error. Occasionally (probability ||2) we obtain the result (0,1) and project the state on to a|000> + b|111>

a|100> + b|011>

But then from syndrome occurrence and location of the error will be known. Similarly, if there is an amplitude of order for each of the three qubits to flip, then with a probability of order ||2 the syndrome measurement will project the state to one in which one of the three bits is flipped, and the syndrome will tell us which one. 3 of the 4 obstacles given earlier are so far solved. It is shown that it is possible to make a measurement that diagnoses the error without damaging the information (solving the problem 3), and that a quantum measurement can project a state with a small error to either a state with no error or a state with a large discrete error that we know how to correct (answering 2). As for cloning (problem 4), it didnt come up, because the state a|0-> + b|1-> is not obtained by cloning- it is not the same as a ( |0> + b|1>)3; that is it differs from the three copies of the unencoded state. If any one of the three qubits undergoes a phase error then our encoded state a|0-> + b|1-> is transformed to a|0-> - b|1->, and the encoded quantum information is damage. In fact, phase error has become three times more likely than without using the code. First of all, to correct the phase flip, we have to realize that a phase flip is just a bit flip in the Hadamard basis. This can be seen by presenting the bit-flip matrix in the Hadamard basis:
(6)

Then phase errors in the |0>, |1> basis become bit flip errors in the rotated basis.
(7)

Therefore by encoding message in Hadamard basis and then applying bit-flip correcting transformation will solve Phase error. Having protected against bit-flip errors by encoding bits redundantly, protect against phase-flip errors by encoding phase redundantly. Following Shor, encode a single qubit using nine qubits, according to |0> |0-> 1/23/2 (|000> + |111>) (|000> + |111>) (|000> + |111>), |1> |1-> 1/23/2 (|000> - |111>) (|000> - |111>) (|000> - |111>). (8)

Fault Tolerant Quantum Computing

10

Both |0-> and |1-> consist of three clusters of three qubits each, with each cluster prepared in the same quantum state. Each of the cluster has triple bit redundancy, it is possible to correct a single bit flip in any cluster by the method discussed above. Now suppose that a phase flip occurs in one of the clusters. The error changes the relative sign of |000> and |111> in that cluster so that |000> + |111> |000> - |111>, |000> - |111> |000> + |111>. This means that the relative phase of the damaged cluster differs from the phases of the other two clusters. Thus, as in the case of bit-flip correction, identify the damaged cluster not by measuring the relative phase in each cluster (which would disturb the encoded information) but by comparing the phase of the pairs of clusters. In this case we need to measure a six-qubit observable to do the comparison, e.g ., the observable that flips qubits 1 through 6. Since flipping twice is the identity, this observable squares to 1, and has eigenvalues +1, -1. A pair of clusters with the same sign is an eigenstate with eigenvalue +1, and a pair of cluster with opposite sign is an eigenstate with eigenvalue 1. By measuring the six-qubit observable for a second pair of clusters, we can determine which cluster has a different sign than the others. Then we apply unitary phase transformation to one of the qubits in that cluster to reverse the sign and correct the error.

Fault Tolerant Quantum Computing

11

3.2 Steane's code

Another important example of a quantum error-correcting code is the 7-qubit code devised by Andrew Steane (1996ab). This code enables us to store one qubit of quantum information (an arbitrary state in a two-dimensional Hilbert space) using altogether 7qubits (by embedding the two dimensional Hilbert space in a space of dimension 27). Steane's code is actually closely related to a familiar classical error-correcting code, the [7,4,3] Hamming code (MacWilliams & Sloane 1977). To understand why Steane's code works, it is important to first understand the classical Hamming code. 3.2.1 Hamming (7,4) Code The key to the Hamming Code is the use of extra parity bits to allow the identification of a single error. Create the code word as follows: 1. Mark all bit positions that are powers of two as parity bits. (Positions 1, 2, 4, 8, 16, 32, 64, etc.) 2. All other bit positions are for the data to be encoded. (Positions 3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 17, etc.) 3. Each parity bit calculates the parity for some of the bits in the code word. The position of the parity bit determines the sequence of bits that it alternately checks and skips. Position 1: check 1 bit, skip 1 bit, check 1 bit, skip 1 bit, etc. (3,5,7,9,11,13,15...) Position 2: check 2 bits, skip 2 bits, check 2 bits, skip 2 bits, etc. (3,6,7,10,11,14,15...) Position 4: check 4 bits, skip 4 bits, check 4 bits, skip 4 bits, etc. (5,6,7,12,13,14,15,20,21,22,23...) Position 8: check 8 bits, skip 8 bits, check 8 bits, skip 8 bits, etc. (7-15,24-31,4047...) Position 16: check 16 bits, skip 16 bits, check 16 bits, skip 16 bits, etc. (17-31,4863,80-95...) Position 32: check 32 bits, skip 32 bits, check 32 bits, skip 32 bits, etc. (33-63,96127,160-191,...) etc. 4. Set a parity bit to 1 if the total number of ones in the positions it checks is odd. Set a parity bit to 0 if the total number of ones in the positions it checks is even. A linear code is a code in which all of the words form a subspace of some vector space. Now, all the words in Hamming's (7,4) code can be viewed as the kernel of a linear transformation represented by a 7 by 3 matrix:
|1 0 1 0 1 0 1| |0 1 1 0 0 1 1| |0 0 0 1 1 1 1|

The three rows have 1s in positions i where a certain digit of the binary representation of i has a 1 (the columns form binary representations of i). They are therefore a subspace of Fault Tolerant Quantum Computing 12

a seven-dimensional vector space [GF(2)]. Since the transformation is linear, any linear combination of words in the kernel is also in the kernel (that is, it is mapped to the checking number 000). A code can be checked for errors in a similar way. The checking number is an r digit number whose ith digit is the sum modulo 2 of the digits whose binary representations have a 1 in their ith digit. Notably the checking number points to the digit with an error (the most significant digit of the checking number is on the right). If it is zero there are no errors. Lets see an example With this hamming code, the number 5 (in binary, 101) would be represented as **0*101. Treating this as a 7-vector: [0 0 0 0 1 0 1] where the check digits * are now treated as zeros, we can multiply by |1 0 1 0 1 0 1| |0 1 1 0 0 1 1| |0 0 0 1 1 1 1| using matrix multiplication (modulo 2) and obtain the 3-vector: [0 1 0] The digits in this vector are then substited for the check digits in the original 7-vector giving [0 1 0 0 1 0 1] Now, try introducing an error into say, the third digit. Now the word is [0 1 1 0 1 0 1] Multiply again by the matrix, and the result is [1 1 0] As these digits read from right to left are the binary representation of decimal 3, this indicates that there is an error in the third digit of the word.

Fault Tolerant Quantum Computing

13

3.2.2 Steane's code Steanes code generalizes this sort of classical error-correcting code to a quantum error-correcting code. The code is designed to enable us to recover from an arbitrary error occurring in any of the 7 qubits in the block. Consider a qubit in an arbitrary state: a|0> + b|1> Where |a|2 + |b|2 = 1. How are the general 1-qubit errors (presented earlier) correctable? Steane proposed creating a new basis using 7 qubits: |0-> = 1/81/2 (|0000000> + |0110011> + |0111100> + |0001111> + |1101001> + |1011010> + |1010101> + |1100110>) |1-> = 1/81/2 (|0011001> + |0101010> + |0100101> + |0010110> + |1110000> + |1000011> + |1001100> + |1111111>) (9)

These are simply super positions of words in the Hamming code with the same parity. Note that these states use all of the words in the Hamming code. For the first type of error, a bit-flip on one of the bits, controlled-not gates can be applied to add bits modulo 2 in an analogous manner to the error-checking procedure for the digital Hamming code.

Figure 7: Computation of the bit-flip syndrome for Steane's 7-qubit code. Repeating the Computation in the rotated basis diagnoses the phase-flip errors. Three ancilla bits are initially set to state |0>.

Fault Tolerant Quantum Computing

14

Each ancilla bit is the target of four successive controlled-not gates. For the first ancilla bit, they are applied to the 1st, 3rd, 5th, and 7th qubits; for the second ancilla bit, they are applied to the 2nd, 3rd, 6th, and 7th qubits, and for the third, the 4th, 5th, 6th, 7th. This in effect implements the matrix multiplication of the digital Hamming code above. The three-ancilla bits are now measured. Either the result of this measurement is 000 or another three-bit binary number. If the result is the former, then there could have been no error. If the result is the latter, there is an error and the location of the error is know. To solve the phase error problem, its is clear from (6) and (7) that this can be solved by changing the basis for each qubit by applying the Hadamard rotation It will therefore be sufficient if the given code is able to diagnose bit flip errors in this rotated basis. But applying the Hadamard rotation R to each of the 7 qubits, Steane's logical 0 and logical 1 become in the rotated basis

(10)

The key point is that |0->code and |1->code, like |0>code and |1>code, are super positions of Hamming code words. Hence, in the rotated basis, as in the original basis, Hamming parity check is used to diagnose bit flips, which are phase flips in the original basis. Assuming that only one qubit is in error, performing the parity check in both bases completely diagnoses the error, and enables us to correct it.

Fault Tolerant Quantum Computing

15

3.3 Good Codes

In the above-mentioned codes, the basic assumption was: the error will affect only one of the qubits in the block. Clearly, this assumption as stated is not realistic. Better codes can be constructed that can protect the information from up to t errors within a single block. Some of them are presented in the (Steane, 1996), (Calderbank, Shor, 1996), (Calderbank, Rains, Shor, Sloane, 1996).

3.4 Conclusion
The key conceptual insight that makes quantum error correction possible is that we can fight entanglement with entanglement. Entanglement can be our enemy, since entanglement of our device with the environment can conceal quantum information from us, and so cause errors. But entanglement can also be our friend. We can encode the information that we want to protect in entanglement, that is, in correlations involving a large number of qubits. This information, then, cannot be accessed if we measure just a few qubits. By the same token, the information cannot be damaged if the environment interacts with just a few qubits.
1.

Although the quantum computer is in a sense an analog device, we can digitalize the errors that it makes. We deal with small errors by making appropriate measurements that project the state of our quantum computer onto either a state where no error has occurred, or a state with a large error, which can then be corrected with familiar methods. And we have seen that it is possible to measure the errors without measuring the data. We can acquire information about the precise nature of the error without acquiring any information about the quantum information encoded in our device (which would result in decoherence and failure of our computation).
2.

Fault Tolerant Quantum Computing

16

4. Fault Tolerant Recovery

Recovery is itself a quantum computation that will be prone to error. If the probability of error for each bit in our code block is , then it is reasonable to suppose that each quantum gate that we employ in the recovery procedure has a probability of order of introducing an error (or that storage errors" occur with probability of order during recovery). If our recovery procedure is carelessly designed, then the probability that the procedure fails (e.g., because two errors occur in the same block) may be of order . In this case, no benefit from using a Quantum error correcting code, in fact, the probability of error per data qubit is even higher than without any coding. To make the procedure fault tolerant, find all the possible ways that recovery might fail with a probability of order , and then ensure that they are all eliminated.

4.1 The Back Action Problem

One serious concern is propagation of error. Suppose an error occurs in one qubit. This qubit interacts with another qubit when we apply on them. The error is likely to spread to the second qubit. We need to be careful to contain the infection, or at least we must strive to prevent two errors from appearing in a single block. In performing error recovery, we repeatedly use the two-qubit XOR gate. To solve the above-mentioned problem, we should follow the first Law of fault tolerance. Don't use the same bit twice (page 5). But this procedure is still not adequate as it stands, because we have copied too much information. The circuit entangles the ancilla with the error that has occurred in the data, which is good, but it also entangles the ancilla with the encoded data itself, which is bad. The code words will lose all protection against phase errors.

4.2 Preparing The Ancilla

Solving the first law of fault tolerance has introduced the second law and Now we have to find a way to obey it. We prepare a Shor state of the ancilla before proceeding with the syndrome computation (Shor 1996). This is a state of four ancilla bits that is an equally weighted superposition of all even weight strings: (11) There are altogether 6 syndrome bits (3 to diagnose bit-flip errors and 3 to diagnose phase-flip Errors), so the syndrome measurement uses 24 ancilla bits prepared in 6 Shor states, and 24 XOR gates.

Fault Tolerant Quantum Computing

17

(One way to obtain the phase-flip syndrome would be to first apply 7 parallel R gates to the data block to rotate the basis, then to apply the XOR gates as in Fig. 7 (but with the ancilla expanded into a Shor state), and finally to apply 7 R gates to rotate the data back.

Figure 8: A useful identity. The source and the target of an XOR gate are Interchanged if we perform a change of basis with Hadamard rotations. However, using the identity represented in Fig. 8, this procedure can be improved. By reversing the direction of the XOR gates (that is, by using the ancilla as the source and the data as the target). We can avoid applying the R gates to the data, and hence can reduce the likelihood of damaging the data with faulty gates (Zalka 1996; Steane 1997).)

4.3 Verifying the Ancilla

Due to error propagation, a single error that occurs during the preparation of the Shor state can result in two phase errors in the state, and these can both propagate to the data if the faulty ancilla is used for syndrome measurement. Therefore the Shor state must be tested for multiple phase errors before it is used (an instance of the third law), as in Fig below.

Figure 9: Construction and verification of the Shor state. If the measurement outcome is 1, then the state is discarded and a new Shor state is prepared.

If it fails the test, it should be discarded, and a new Shor state should be constructed.

4.4 Faulty Syndrome

Finally, a single error during syndrome measurement can result in a faulty syndrome. Thus, the syndrome measurement should be repeated to verify accuracy (the fourth law). When the same result is obtained twice in a row, the result can be safely accepted and recovery can proceed. If we take all the precautions described above, then recovery will fail only if two independent errors occur, so the probability of an error occurring in the encoded block will be of order 2. The error-correction procedure is fault-tolerant.

Fault Tolerant Quantum Computing

18

5. Fault-Tolerant Quantum Gates

Now we know how to protect the quantum information by using error-correcting codes. But the problem in storing the information is just the half of the total problem. The other half is processing of that information. One option is: decode the encoded quantum information, perform a gate, and then reencode, but this procedure will temporarily expose the quantum information to harm. Instead, if we want our quantum computer to operate reliably, we must be able to apply quantum gates directly to the encoded data, and these gates must respect the laws of fault tolerance if catastrophic propagation of error is to be avoided.

5.1 Gates Implementation With Steans 7-Qubit Code

With Steane's 7-qubit code, there are a number of gates that can be easily implemented. Three single-qubit gates can be applied bitwise; that is applying these gates to each of the 7 qubits in the block implements the same gate acting on the encoded qubit. It is shown in Eq. (10) that the Hadamard rotation R acts this way. The same is true for the NOT gate (since each odd parity Hamming codeword is the complement of an even parity Hamming codeword), and the phase gate (12) The XOR gate can also be implemented bitwise; that is, by XOR'ing each bit of the source block into the corresponding bit of the target block, as in Fig. 11. This works because the even codewords form a subcode, while the odd code words are its nontrivial coset.

Figure 11: The transversal XOR gate, shown schematically. By XOR'ing each bit of the source block into the corresponding bit of the target block, we implement an XOR acting on the encoded qubits. The gate implementation is fault tolerant because each qubit in both code blocks is acted on by a single gate. Thus there are simple fault-tolerant procedures for implementing the gates NOT, R, and XOR.

Fault Tolerant Quantum Computing

19

6. Plumbing Quantum Leaks

We have ignored the possibility of leakage. In our model of a quantum computer, each of our qubits lives in a two-dimensional Hilbert space. We assumed that, when an error occurs, this qubit either becomes entangled with the environment, or rotates in the two-dimensional space in an unpredictable way. But there is another possible type of error, in which the qubit leaks out of the two-dimensional space into a larger space (Plenio & Knight 1996). For example, in an ion trap computer we might store quantum information in a two-dimensional space spanned by the ground state of the ion and a particular long-lived metastable state (Cirac & Zoller 1995). But during the operation of the device, the ion might make an unexpected transition to another state. If that state decays quickly to the ground state, then the error can be detected and corrected using the now standard methods of fault tolerant quantum error correction. But if the ion remains hung up in the wrong state for a long time, those methods will fail. One strategy for dealing with the leakage problem would be to identify the levels that are the most likely candidates for leakage, and to repeatedly pump these levels back to the ground state, but this strategy might be unwieldy if there are many candidate levels. A more elegant solution is to detect the leakage, but without trying to diagnose exactly what happened to the leaked qubit. For example, in an ion trap, we might design a controlledNOT gate that acts trivially if the control bit does not reside in the two-dimensional space where the qubit belongs. Then we can carry out the gate sequence shown in Fig. 16.

Figure 16: A quantum leak detection circuit. The outcome of the measurement is 0 if leakage has occurred, 1 otherwise.

Nothing happens if the data qubit has leaked, but in the event that no leakage has occurred, the ancilla bit will flip. We then measure the ancilla bit. The measurement result 1 projects the qubit to the right Hilbert space, but the result 0 projects the qubit to a leaked state. If leakage has occurred, the qubit is damaged and must be discarded. We replace it with a Fresh qubit in a standard state, say the state |0>. (If concatenated coding is used, leakage detection need be implemented only at the lowest coding level.) Now we can perform conventional syndrome measurement, which will project the qubit onto a state such that the error can be reversed by a simple unitary transformation. In fact, since we know before the syndrome measurement that the damaged qubit is in a particular position within the code block, we can apply a streamlined version of error correction designed to diagnose and reverse the error at that known position (Grassl et al. 1996).

Fault Tolerant Quantum Computing

20

7. Conclusion
Now after looking at the fault tolerant methods, we know that in principle it is possible to make quantum computer that can save and operate the quantum information in stable way. But in the future, it may be possible that fault tolerance is implemented in hardware. All the work done so far in the fault tolerance is theoretical and we are far from these devices that can accurately exploit the quantum computing. But the way the theoretical quantum computation has developed at a spectacular pace over the last couple of years, we should be confident that these devices would not remain imaginations. And if this happens, then relatively small quantum system will have far greater potential than we now think. So discovery of fault-tolerant methods has great effect, both for the future of experimental physics and for the future of technology.

Fault Tolerant Quantum Computing

21

8. References
1. Shor, P: 1996 Fault-tolerant quantum computation. Page 3-5 http://www.research.att.com/~shor/papers/fault-tol.pdf 2. John Preskill: 1997 Reliable Quantum Computers Page 15-21 http://www.cs.mcgill.ca/~crepeau/QCOMP/preskill.ps.gz 3. Calderbank, A. R. & Shor, P. W: 1996 Good quantum error-correcting codes http://xxx.lanl.gov/abs/quant-ph/9512032 4. Preskill, J: 1997 Introduction and Overview of Quantum Computing Page 23-25 http://www.theory.caltech.edu/people/preskill/ph229/notes/chap1.ps 5. Preskill, J: 1997 Quantum Error Correction http://www.theory.caltech.edu/people/preskill/ph229/notes/chap7.ps 6. D. Gottesman: 1996 A class of quantum error-correcting codes saturating the quantum Hamming bound Page 10-12 http://xxx.lanl.gov/abs/quant-ph/9604038 7. J. Preskill: 1997 Reliable quantum computers Pages 2-13,19-20 http://xxx.lanl.gov/abs/quant-ph/9705031 8. P. Shor: 1996 Fault-tolerant quantum computation Page 4-7 http://xxx.lanl.gov/abs/quant-ph/9605011

Fault Tolerant Quantum Computing

22