QEC11 Quantum Error Correction and Quantum Error-Correcting Codes - PowerPoint PPT Presentation

QEC11 Quantum Error Correction and Quantum Error-Correcting Codes Todd A. Brun Center for Quantum Information Science and Technology (CQIST)

Outline 1. What is Quantum Error Correction? 2. Classical Error-Correcting Codes 3. Does Encoding Copy Information? 4. Simplest Quantum Codes 5. Structure of a quantum code 6. The Stabilizer Formalism 7. Connection to Classical Linear Codes 8. Measuring Error Syndromes 9. Encoding and Decoding Circuits For Quantum Codes 10. Logical Operators 11. Degeneracy and Passive Error Correction 12. Operator (Subsystem) Quantum Error-Correcting Codes

What is Quantum Error Correction? Quantum error-correction (obviously enough) is the attempt to protect a quantum state from the effects of errors. So the real question is: what is a quantum error? Errors must arise in ways allowed by the laws of quantum mechanics. In the simplest description, two kinds of errors seem of natural concern: unitary errors (the Hamiltonian is not exactly what we thought it was), and decoherence (the system has an uncontrolled interaction with an external environment). In both these cases, we can abstract the occurrence of an error as our state being multiplied by an unknown and unwanted operator: � � E � (This could be, for example, an undesired unitary, or one term from a Kraus expansion.)

Classical Error-Correcting Codes The typical classical single-bit error is the bit-flip : 0 ↔ 1. If we assume a simple error model (the binary symmetric channel ) in which bit flips errors occur on each bit independently with probablility p per unit time, we expect a bit to be corrupted after O(1/p) steps. (In general, we assume p ≪ 1.) To get around this problem, we can use redundant coding to help detect and correct errors. The simplest version of this is just to keep multiple copies of each bit. If we keep two copies of each bit, 0 and 1 are encoded in the pairs 00 and 11, respectively. If an error occurs to one of the two bits, we will get the pair 01 or 10. Since these pairs should never occur, if we see them we know that an error has happened. (Error detection!) We can go further and actually correct errors by increasing redundancy and keeping 3 copies of each bit: 0 → 000, 1 → 111.

So what are the properties of a code that make error detection and correction possible? And what are the limitations? 1. Information is stored redundantly across multiple bits. 2. An error transforms an allowed code word into an illegal code word. (Necessary for detection.) 3. The allowed code words remain distinct even after errors occur. (Necessary for correction.) 4. No code can protect against every possible error. A code must be designed with a particular set of correctable errors in mind. This gives us guidelines in our quest for quantum error correction. However, quantum information has some additional restrictions and requirements that may complicate this picture.

Does encoding require information to be copied? What are some of the limitations that arise from quantum mechanics, that might prevent error correction? No-cloning: a general quantum state cannot be copied. • Superpositions: measuring a quantum system will generally • disturb the state. Continuous errors: the errors of a classical code are discrete. • The number of possible error operators E is continuously infinite. In analog computation, continuous errors make correction impossible. Complementarity: Different possible errors need not commute. • This seems like a formidable list of obstacles, and in the early days many people (including myself) doubted that quantum error correction was even possible. Fortunately, we were wrong.

Copying: In fact, a classical bit 0/1 and a code word 000/111 contain exactly the same information. Instead of storing information locally in a single bit, it is stored in correlations between bits. (Classical probability distributions also cannot be cloned, but that doesn’t prevent classical error correction!) Superpositions: Classically, there is no reason not to measure the exact state of a codeword to check for errors. But in principle this is not necessary. For instance, in the 3-bit repetition code, one need only measure the parities of neighboring bits. This reveals an error without revealing the actual stored value. � � 010 000 � , 111 � � 101 � p 0 = p 1 = 0 p 0 = p 1 = 1 p 0 = p 1 = 0 p 0 = p 1 = 1 A well-designed code can give information about errors without probing the encoded information!

The Simplest Quantum Codes For a first attempt, can we design a quantum code that emulates our simplest classical code, and corrects a single bit flip? In the quantum context, a bit-flip is the same as an X gate. |0 ⟩ → X |0 ⟩ = |1 ⟩ , |1 ⟩ → X |1 ⟩ = |0 ⟩ , | ψ ⟩ = α |0 ⟩ + β |1 ⟩ → X | ψ ⟩ = α |1 ⟩ + β |0 ⟩ . We protect from such errors by unitarily embedding this single q- bit state in the state of three q-bits: ( α |0 ⟩ + β |1 ⟩ )|0 ⟩ |0 ⟩ → α |000 ⟩ + β |111 ⟩ . Note that we have not copied | ψ ⟩ , so this doesn’t violate the no- cloning theorem.

A simple circuit that does this encoding is: α | 0 � + β | 1 � • •    ���� ����    | 0 � α | 000 � + β | 111 �   ���� ����    | 0 � Suppose a single bit-flip error occurs on (say) bit 1. The state becomes α |100 ⟩ + β |011 ⟩ . Similarly, errors on bits 2 and 3 result in states α |010 ⟩ + β |101 ⟩ and α |001 ⟩ + β |110 ⟩ . We could determine which error (if any) occurred if we knew the parities of bits 1 and 2 and bits 2 and 3. To really be quantum error correction, though, we need to be able to determine the error and correct it without measuring the individual qubits themselves (and thereby destroy the state).

We can determine the error by the following circuit: •     | Ψ L � • •    • ���� ���� ���� ���� �� � � ˆ | 0 � Z ���� ���� ���� ���� �� � � | 0 � ˆ Z Based on the results of these two measurements (the error syndrome ), we can undo the error with a unitary X operator on one of the three qubits. So we have two of the key requirements for a quantum code: 1. Measure error syndromes, not individual qubits. 2. Apply unitaries to correct the errors.

Discretization of Errors The fact that we can replicate the performance of a classical code while protecting quantum information is a good start. But this code is more powerful than it might immediately appear. Consider, instead of a bit flip operator X , a general X-rotation : ( ) = exp � i � X / 2 ( ) = cos � / 2 ( ) I � i sin � / 2 ( ) X . R X � If we apply this operator to (say) the first qubit of our code word we get the following state: ( ) � i sin � / 2 ( ) . ( ) � 000 + � 111 ( ) � 100 + � 011 cos � / 2 Note that this is a superposition of the code word with no error and the code word with a single bit-flip. When we measure the syndrome, we will project into one or the other state, and then apply the corresponding correction. In fact, this code can correct any error that is a linear combination error operators: aI + bX 1 + cX 2 + dX 3 .

Phase Errors In QM there are many other kinds of errors besides bit flips. We can construct a code to correct phase errors |0 ⟩ → Z |0 ⟩ = |0 ⟩ , |1 ⟩ → Z |1 ⟩ = -|1 ⟩ , | ψ ⟩ = α |0 ⟩ + β |1 ⟩ → Z | ψ ⟩ = α |0 ⟩ - β |1 ⟩ . exactly along the same lines as the bit-flip code: ( α |0 ⟩ + β |1 ⟩ )|00 ⟩ → α |+ + + ⟩ + β |- - - ⟩ . The encoding circuit and syndrome measurement circuit can be constructed exactly the same way as for the bit flip code, just by applying Hadamard gates to switch between the X and Z bases.

The Shor Code Consider the following encoding of a single qubit in nine qubits: � 3 + � � 8 � � � 3 . ( ) 0 ( ) ( ) � 0 + � 1 000 + 111 000 � 111 8 8 These 9-qubit code words have the structure of a phase-flip code, but with each qubit in state (|0 ⟩ ± |1 ⟩ ) encoded in a bit-flip code as (|000 ⟩ ± |111 ⟩ ). This type of code—one code nested inside another—is called a concatenated code . This is a very important concept in making quantum computers robust against noise. Here it is used to protect against more than one kind of error. We see that this code can detect a bit flip and a phase flip. But it can do more than that! Recall that iY = ZX. A Y error is the same as an X error followed by a Z error. So this code can correct Y errors as well. Since any 1-bit operator can be written O = aI + bX + cY + dZ , this code can correct any error on a single bit . The Shor code protects against general one-qubit errors.