Lecture 23: Fault-Tolerant Quantum Computation Scribed by: Jonathan Hodges Department of Nuclear Engineering, MIT December 4, 2003 1 Introduction Before von Neumann proposed classical fault-tolerance in the 1940’s, it was assumed that a compu-tational device comprised of more than 106 components could not perform a computation wihout encountering a fatal hardware error. Von Neumann proved that one could indeed make the com-putation work, as long as a certain degree of overhead was tolerable. Thus follows the classical fault-tolerance theorem: Theorem 1 (Classical Fault-Tolerance). A computation of length n using perfect computational components can be executed reliably (i.e. with probability 1− 1 α for polynomial α ) using O(n log n) nsteps, provided the components work with probability 1 - � of the time and that the faults encountered are independent. We can sketch von Neumann’s proof of Fault-Tolerance as follows: Given classical AND,NOT, and OR gates let us encode a 0 into many 0’s for c log n times, where c is some constant. 0 0000000 (1) → Now take two identical copies of “0”, call them a and b, and put them through the AND gate. Ideally one should get 1111111. Instead, suppose the strings received are 1110101 on a and 0111111 on b. If one performs a bit-wise AND on each successive bit of the bit strings a and b, the result is 0110101. Taking “triples” of bits of this resulting addition, one performs a majority vote. Thus, if one bit has an error probablity of p , two bits in a triple being erroneous occurs with probabiltiy 3p2. As long as p is small, one can perform operations with fault-tolerance. The same type of proof can be shown for NOT and OR gates, thus giving universality. In short, if one has compenents of a computer whose fidelity are high enough, and adding additional compents is relatively easy, then the com putation is indeed plausible. As it turns out the critics were too critical. Your desktop c omputer does not even use a software error-correction for doing computations, as the � for our silicon-based hardware has become increasingly small. 2 Using classical techniques for quantum computation Classically, four methods exist for dealing with fault-tolerant computing, but only one of these will prove feasible. Consistency checks, like the parity of a bit string, work classically, but in the quantum world are simply not powerful enough. Checkpoints require stoping the computation at a 1� � P. Shor – 18.435/2.111 Quantum Computation – Lecture 23 2 specific point, checking the result, then starting the computation again. The probablistic nature of quantum mechanics and the no-cloning theorem make this technique useless for QC. Classically, one might make many copies of the computation to perform a massive redundancy scheme; however, this errs like consistency checks, as it is not “powerful enough” for quantum computations. Thus, one is left with error correcting codes, which have previously been shown portable from the classical to the quantum domain. 3 Quantum Fault Tolerance In order to take an errorless quantum computation to a fault-tolerant computation, one first encodes each qubit into a quantum error correcting code. Every gate in the circuit should then be replaced by a fault tolerant version of it. Finally, insert an error correction step after every gate. Above we argued that fault-tolerance in classical computations need only AND, NOT, OR gates. For universal quantum computation only the CNOT and single-qubit gates are required, but formulating fault-tolerant operations becomes easier with a finite gate set. CNOT, Hadamard, σx, σz, T, Toffoli, and π 8 will be proven useful. Theorem 2 (Kitaev-Solovay Theorem). Given a set of gates on SU(2) ( or SU(k) generally) that generates a dense set in SU(2), then any gate U ∈ SU(2) can be approximated to � using O (logc 1 � ) gates where 1 ≤ c ≤ 2. See Appendix 3 of Nielsen and Chuang for more details. 3.1 Fault Tolerance of σx In order to show that a σx gate can be done with fault tolerance, let us encode 1 qubit into k qubits using a CSS Code (the Steane Code). 1 � (2)| 0� −→ | C2| x∈C2 | x� 1 � x + v� (3)| 1� −→ | C2| x∈C2 | Since dim(C1) is k, dim(C2) is k-1, this code will encode a single qubit, and satisfies the inequality 0 ⊆ C2 ⊆ C1. The codewords v are those not overlapping the two classical codes; v ∈ C1 − C2. Since the encoded 0� and 1� are orthogonal, a σx should just interchange the two encodings. These | |two states are separated by v, which amounts to peforming a σx on each individual qubit. Now suppose an error is made in performing σx on one of the qubits, where the errors on each qubit are uncorrelated. Then this code will be able to correct for these errors, resulting in a quantum error correcting code and operation that pe rforms σx with fault-tolerance. 3.2 Fault Tolerance of σz By using the Steane code above, the equivalent of σz on an unencoded qubit is to apply σz to those individual qubits with a 1 in the codeword w where w ∈ C2⊥− C1⊥. This results in a state | a�acquiring a phase of (− 1)a.w . Under such a transformation the code words become � � 1 �1 1(− 1)x.w� (4) | C2| x∈C2 | x� −→ � | C2| x∈C2 | x� = � | C2| x∈C2 | x�� � = � � � � P. Shor – 18.435/2.111 Quantum Computation – Lecture 23 3 � � 1 �1 1(−1)x.w (−1)v.w � x + v� = x + v� (5)||C2|x∈C2 |x + v� −→ � |C2|x∈C2 | −� |C2|x∈C2 since at least 1 vector in C1 gives v.w = 1. 3.3 Fault Tolerance of Hadamard Gate The fault tolerance of the Hadamard gate under this