1. Quantum Error Correction and Fault Tolerance Daniel Gottesman Perimeter Institute

2. The Classical and Quantum Worlds

3. Quantum Error Correction

4. Quantum Errors For quantum error correction, we consider errors to be caused by a quantum channel (superoperator):  A k  A k † Examples of single-qubit errors: Bit Flip X: X  0  =  1 , X  1  =  0  Phase Flip Z: Z  0  =  0 , Z  1  = -  1  Complete dephasing:   (  + Z  Z † )/2 (decoherence) Rotation: R   0  =  0 , R   1  = e i2   1  Frequently, we assume errors are rare, and assume at most t errors, and try to correct just that case. For fault-tolerance, we must also consider errors in the gates. Alice Environment  Bob

5. QECC Conditions Theorem: A QECC can correct a set E of errors iff  i  E a † E b  j  = C ab  ij where {  i  } form a basis for the codewords, and E a, E b  E. Note: The matrix C ab does not depend on i and j. As an example, consider C ab =  ab. Then we can make a measurement to determine the error. If C ab has rank < maximum, the code is degenerate. Otherwise, it is nondegenerate. 00 11 codespace space with an error E a 00 11

6. Linearity of QECCs Define the Pauli group P n on n qubits to be generated by X, Y, and Z on individual qubits. Then P n consists of all tensor products of up to n operators I, X, Y, or Z with overall phase ±1, ±i. The weight of M  P n is the number of qubits on which M acts as a non-identity operator. The weight t Pauli operators span the space of t-qubit errors. Therefore, A QECC which corrects all weight t Paulis automatically corrects all t-qubit errors. Theorem: If a quantum error-correcting code (QECC) corrects errors A and B, it also corrects  A +  B. A general single-qubit error    A k  A k † acts like a mixture of   A k , and A k is a 2x2 matrix.

7. Stabilizer Codes A stabilizer code is a code defined in terms of a stabilizer, a group of Pauli operators that have eigenvalue +1 for every codeword. A stabilizer S must be an Abelian subgroup of the Pauli group, and cannot contain -1, but is otherwise arbitrary. Theorem: A stabilizer code with r generators on n qubits encodes k = n - r logical qubits. Let N(S) = {Paulis P s.t. PM = MP  M  S}, and let d be the minimum weight of an element of N(S) \ S. Then the code has distance d; it corrects  (d-1)/2  general errors. We say the code is a [[n, k, d]] QECC.

8. Design Goals for QECCs When we design new QECCs, there are many possible goals: High rate (high value of both k/n and d/n). Efficient decoding (for a general QECC, determining the exact error can take exponentially long in n). Efficient encoding (all stabilizer codes can be encoded using O(n 2 ) operations, but O(n) is better). Specific error models (we can sometimes be more efficient if don’t insist on correcting all t-qubit errors). Many symmetries (useful for fault-tolerance and sometimes other constructions). Other application-specific properties

9. 5-Qubit Code We can generate good codes by picking an appropriate stabilizer. For instance: X  Z  Z  X  I I  X  Z  Z  X X  I  X  Z  Z Z  X  I  X  Z n = 5 physical qubits - 4 generators of S k = 1 encoded qubit Distance d of this code is 3: Code space is {  s.t. M  =   M  S}. [[5,1,3]] code: Each single-qubit error anticommutes with a different set of generators, which determine its error syndrome. E.g.: X  I  I  I  I has syndrome 0001 I  I  Y  I  I has syndrome 1110

10. CSS Codes We can then define a quantum error-correcting code by choosing two classical linear codes C 1 and C 2, and replacing the parity check matrix of C 1 with Z’s and the parity check matrix of C 2 with X’s. X  X  X  X  I  I  I X  X  I  I  X  X  I X  I  X  I  X  I  X Z  Z  Z  Z  I  I  I Z  Z  I  I  Z  Z  I Z  I  Z  I  Z  I  Z E.g.: C 1 : [7,4,3] Hamming C 2 : [7,4,3] Hamming [[7,1,3]] QECC  0000000  +  1111000  +  1100110  +  1010101  +  0011110  +  0101101  +  0110011  +  1001011  0 0  1 1   1111111  +  0000111  +  0011001  +  0101010  +  1100001  +  1010010  +  1001100  +  0110100 

11. Fault Tolerance

12. Error Propagation When we perform multiple-qubit gates during a quantum computation, any existing errors in the computer can propagate to other qubits, even if the gate itself is perfect. CNOT propagates bit flips forward: 00 11 00 00 00 11 11 Phase errors propagate backwards:  0  +  1   0  -  1  Of course gates can be wrong too. We assume a faulty gate can cause errors in all qubits involved in the gate. We must design protocols so that one faulty gate causes at most one error per block of the code.

13. Transversal Operations Error propagation is only a serious problem if it propagates errors within a block of the QECC. Then one wrong gate could cause the whole block to fail. The solution: Perform gates transversally - i.e. only between corresponding qubits in separate blocks. 7-qubit code For the 7-qubit code, we can perform CNOT, Hadamard, and R  /4 (diag(1,i)) transversally. These gates generate a group of unitaries called the Clifford group.

14. Ancilla States However, the Clifford group is not universal (it can be efficiently simulated classically). In order to get a universal set of gates, and to perform fault-tolerant error correction, we must create special ancilla states. These ancillas are frequently (but not always) specific states encoded using the same QECC. Use a non-FT method to create the ancilla. Verify the ancilla carefully. This may be a very resource-intensive activity; we often imagine a separate part of the computer, an ancilla factory, is dedicated just to making ancillas. Interact the ancilla with the data block, often using some form of teleportation. Generally, we follow a procedure along these lines:

15. Error correction is performed more frequently at lower levels of concatenation. Threshold for fault-tolerance proven using concatenated error- correcting codes. Effective error rate One qubit is encoded as n, which are encoded as n 2, … (for a code correcting 1 error) p  Cp 2 Concatenated Codes If using a fault-tolerant protocol improves the error rate, apply it again and again to get the error rate as low as you like.

16. Threshold for Fault-Tolerance Theorem: There exists a threshold p t such that, if the error rate per gate and time step is p < p t, arbitrarily long quantum computations are possible. Proof sketch: Each level of concatenation changes the effective error rate p  p t (p/p t ) 2. The effective error rate p k after k levels of concatenation is then and for a computation of length T, we need only log (log T) levels of concatention, requiring polylog (T) extra qubits, for sufficient accuracy. The physical assumptions for the theorem are discussed in the next few slides. We allow a small imperfection in every part of the quantum computer, including state preparation, gates, qubit storage, and measurement of qubits.

17. Requirements for Fault-Tolerance 1.Low gate error rates. 2.Ability to perform operations in parallel. 3.A way of remaining in, or returning to, the computational Hilbert space. 4.A source of fresh initialized qubits during the computation. 5.Benign error scaling: error rates that do not increase as the computer gets larger, and no large-scale correlated errors. Without some form of the following requirements, fault tolerance is impossible:

18. Additional Desiderata 1.Ability to perform gates between distant qubits. 2.Fast and reliable measurement and classical computation. 3.Little or no error correlation (unless the registers are linked by a gate). 4.Very low error rates. 5.High parallelism. 6.An ample supply of extra qubits. 7.Even lower error rates. The following properties are desireable but not essential: It is difficult, perhaps impossible, to find a physical system which satisfies all desiderata. Therefore, we need to study tradeoffs: which sets of properties will allow us to perform fault-tolerant protocols?

19. Threshold Values AssumptionsProofSimulation Long-range gates, many extra qubits 10 -3 5 x 10 -2 Two dimensions, nearest neighbor gates 10 -5 6 x 10 -3 One dimension, two lines of qubits, nearest neighbor gates 10 -6 All numbers assume probabilistic errors, good classical processing and measurement, and full parallelism. Proofs assume adversarial errors with exponential bound (errors in r specific locations have probability < p r ) Simulations assume uncorrelated depolarizing channel.

20. Coherent errors: Not serious; could add amplitudes instead of probabilities, but this worst case will not happen in practice (unproven). Restricted types of errors: Generally not helpful; tough to design appropriate codes. (But other control techniques might help here.) There are some exceptions: Depolarizing channel (threshold improves somewhat) Erasure errors (errors occur in known locations) Pure dephasing (but must match gates to model) Non-Markovian errors: Allowed; when the environment is weakly coupled to the system, at least for bounded system-bath Hamiltonians. Other Error Models

21. Summary Quantum error-correcting codes exist which can correct very general types of errors on quantum systems. A systematic theory of stabilizer codes allows us to build many interesting quantum codes. To design fault-tolerant protocols, we must isolate errors to prevent them from spreading too far. The threshold theorem states that we can perform arbitrarily long quantum computations provided the physical error rate is sufficiently low. Study of the threshold value is underway, under various assumptions about the properties of the quantum computer.

22. Further Information Short intro. to QECCs: quant-ph/0004072 Short intro. to fault-tolerance: quant-ph/0701112 Chapter 10 of Nielsen and Chuang Chapter 7 of John Preskill’s lecture notes: http://www.theory.caltech.edu/~preskill/ph229 http://www.theory.caltech.edu/~preskill/ph229 Threshold proof & fault-tolerance: quant-ph/0504218 My Ph.D. thesis: quant-ph/9705052 Complete course on QECCs: http://perimeterinstitute.ca/personal/dgottesman/QECC2007 http://perimeterinstitute.ca/personal/dgottesman/QECC2007

23. We cannot clone, perforce; instead, we split Coherence to protect it from that wrong That would destroy our valued quantum bit And make our computation take too long. Correct a flip and phase - that will suffice. If in our code another error's bred, We simply measure it, then God plays dice, Collapsing it to X or Y or Zed. We start with noisy seven, nine, or five And end with perfect one. To better spot Those flaws we must avoid, we first must strive To find which ones commute and which do not. With group and eigenstate, we've learned to fix Your quantum errors with our quantum tricks. Quantum Error Correction Sonnet