* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Download Quantum Error Correction (QEC) - ETH E
Theoretical and experimental justification for the Schrödinger equation wikipedia , lookup
Scalar field theory wikipedia , lookup
Basil Hiley wikipedia , lookup
Algorithmic cooling wikipedia , lookup
Delayed choice quantum eraser wikipedia , lookup
Quantum dot cellular automaton wikipedia , lookup
Particle in a box wikipedia , lookup
Bohr–Einstein debates wikipedia , lookup
Bell test experiments wikipedia , lookup
Path integral formulation wikipedia , lookup
Quantum field theory wikipedia , lookup
Copenhagen interpretation wikipedia , lookup
Quantum electrodynamics wikipedia , lookup
Hydrogen atom wikipedia , lookup
Probability amplitude wikipedia , lookup
Quantum decoherence wikipedia , lookup
Quantum dot wikipedia , lookup
Coherent states wikipedia , lookup
Density matrix wikipedia , lookup
Bell's theorem wikipedia , lookup
Measurement in quantum mechanics wikipedia , lookup
Quantum entanglement wikipedia , lookup
Quantum fiction wikipedia , lookup
Many-worlds interpretation wikipedia , lookup
Orchestrated objective reduction wikipedia , lookup
History of quantum field theory wikipedia , lookup
Symmetry in quantum mechanics wikipedia , lookup
EPR paradox wikipedia , lookup
Interpretations of quantum mechanics wikipedia , lookup
Quantum group wikipedia , lookup
Quantum machine learning wikipedia , lookup
Canonical quantization wikipedia , lookup
Quantum computing wikipedia , lookup
Quantum cognition wikipedia , lookup
Quantum key distribution wikipedia , lookup
Hidden variable theory wikipedia , lookup
Quantum Error Correction (QEC) Rainer Baumann, ETH Zurich 2003 [email protected], http://hypert.net/education Contents Contents ......................................................................................... 3 Preface ........................................................................................... 4 1. Preliminary Topics........................................................................ 5 1.1. Quantum computers and qubits ............................................... 5 1.2. Quantum gates...................................................................... 6 1.3. Measurement .......................................................................11 1.4. Shor’s factoring algorithm ......................................................12 1.5. Classical linear codes.............................................................12 2. Basics of quantum error correction................................................15 2.1. Quantum channel..................................................................15 2.2. Difficulties for quantum error correction...................................15 2.3. Quantum error correction codes (QECC) ..................................16 2.4. Errors..................................................................................28 2.5. Properties of quantum codes ..................................................30 3. Stabilizer formalism ....................................................................31 3.1. The basics............................................................................31 3.2. More formally .......................................................................33 3.3. Unitary gates and the stabilizer formalism................................34 3.4. Further examples..................................................................35 3.5. Calderbank-Shor-Steane (CSS) codes......................................37 3.6. Standard form for a stabilizer code..........................................40 3.7. Encoding, decoding, measuring and correcting .........................41 3.8. Quantum error-correction without measurement.......................43 4. Fault-tolerant quantum computation .............................................44 4.1. Basics of fault-tolerant quantum computation...........................44 4.2. Fault-tolerant procedure ........................................................45 4.3. Fault-tolerant gates...............................................................45 4.4. Fault-tolerant measurement ...................................................48 4.5. Fault-tolerant state preparation ..............................................49 5. Concatenated coding and threshold theorem ..................................50 5.1. Concatenated codes ..............................................................50 5.2. The threshold theorem ..........................................................52 6. Bounds ......................................................................................53 6.1. Quantum Hamming bound .....................................................53 6.2. Quantum Gilbert-Varshamov bound ........................................54 6.3. Quantum singleton / Knill-Laflamme bound ..............................54 7. Simulations and statistics.............................................................55 7.1. Trace distance and fidelity......................................................55 7.2. Simulations ..........................................................................55 7.3. Comparison of basic codes .....................................................57 8. Summary of most important topics ..............................................58 A. Appendix ...................................................................................59 A.1. Non-cloning theorem .............................................................59 B. Appendix - Quantum codes ..........................................................59 C. Figure Table ...............................................................................63 D. References .................................................................................64 Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 3/66 Preface Quantum error correction is a young discipline rooting in the mid nineties. Due to large research efforts, today’s knowledge over this topic is already very profound. But it is still a hot topic for scientists. This paper is not a general introduction in quantum computation. It focuses on the aspect of quantum error correction and requires basic understandings of quantum mechanics, classical computation and a bit group theory. Anyway in the first part a very short, general introduction to some preliminary topics is given. In this paper, I tried to use as much mathematics as necessary for a general understanding without giving a detailed mathematical derivation. Many proofs and mathematical concepts would rather need an own paper for their discussion and don’t fit in here. This paper originates from a term project at the Swiss Federal Institute of Technology Zurich ETH (www.ethz.ch), Department of Physics (www.phys.ethz.ch), Institute for Theoretical Physics, Prof. G. Blatter. I’d like to thank my sponsor Prof. G. Blatter for his support. I’m grateful that he has given me the opportunity to write this work. © Rainer Baumann, [email protected], 2003 Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 4/66 1. Preliminary Topics Computers became very important tools in today’s world. They can solve many problems much faster than any human being could do. But there are still a few classes of problems, which cannot be solved efficiently on classical computers as for example the simulation of quantum mechanics or factoring of large numbers. Moore’s law predicts that computers get continuously faster and smaller. Already today computer engineers face the physical limitations concerning the speed of light and the size of atoms. That’s why new technologies for future computers are wanted. During his studies of quantum mechanics, Feynman discovered that a quantum system of n spin-1/2 particles is represented in a 2ndimensional space due to entanglement and not in a 2n-dimensional space as in the classical n bit problem. This fact led him to conjecture that a computer based on quantum mechanics might be much more power full than a classical one. 1.1. Quantum computers and qubits The memory of a classical computer is an array of bits (0 or 1). For example [001101001111001]. More formally a vector over the finite field 2 := {0,1}. So n bits span a n-dimensional vector space over 2. While a quantum bit, also called qubit, lies in 2, with the complex number space (without normalization). So n qubits are in 2⊗n. The two basis of 2 are called 0 and 1 in analogy to the values of a classical bit. A single qubit is in the state Ψ = α 0 + β 1 with 2 2 normalization α + β =1. So a normalized qubit lives in . But for simplicity we still write out α and represented in the state vector form: β . A qubit also can be ⎛α ⎞ ⎜⎜ ⎟⎟ ⎝β ⎠ A memory of three qubits would look like: ⎛α 1 ⎞ ⎛α 2 ⎞ ⎛α 3 ⎞ ⎜⎜ ⎟⎟ ⊗ ⎜⎜ ⎟⎟ ⊗ ⎜⎜ ⎟⎟ ⎝ β1 ⎠ ⎝ β 2 ⎠ ⎝ β 3 ⎠ Multiple qubits can also be entangled so that they cannot be decomposed into two separate states. For example the EPR pair 1 ( 00 + 11 ) can not be written in terms of Ψ1 Ψ2 2 Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 5/66 = (α1 0 + β1 1 ) ⊗ (α 2 0 + β 2 1 ) = α1α 2 00 + α1β 2 01 + β1α 2 10 + β1β 2 11 because α 1α 2 and β1β 2 must not be zero while α 1 β 2 and β1α 2 have to be zero. In this paper we denote a classical bit with a double line and a qubit with a single line. Figure 1.1. Bit representation: classical bit (left), qubit (right) There is another specialty in quantum states we have to look at briefly. Consider the state e iΘ Ψ where Ψ is a normal qubit state and Θ a real number. We say that e iΘ Ψ ≡ Ψ are equal up to a global phase shift. We can do this because the measurements for them are absolutely the same. Assume a general measurement operator Mm with probability outcome m. The measurement equation would look like this: m = Ψ M Tt m M m Ψ = Ψ e − i Θ M mt M m e i Θ Ψ Note that especially i Ψ = e iπ / 2 Ψ ≡ Ψ . 1.2. Quantum gates To perform calculations on a quantum computer, some gates or operations are needed as in classical computers. Such gates are represented as unitary matrices which can be applied on the vector space, the qubits live in. For us the most important gates are the Pauli matrices X,Y,Z, the Hadamard gate H, the phase shift gate S, the π/8 gate T and finally the controlled-NOT CNOT. Later on in this paper we will permanently make use of this gates and there representation so look at them very carefully! ⎛ 1 0⎞ ⎛0 ⎟ ; X =⎜ I=⎜ ⎝ 0 1⎠ ⎝1 1⎞ ⎛ 0 −i ⎞ ⎛1 ⎟; Y =⎜ ⎟; Z = ⎜ 0⎠ ⎝i 0⎠ ⎝0 0 ⎤ ⎡1 ⎛ 1 0⎞ ⎟⎟ ; π / 8 = T = ⎢ S = ⎜⎜ iπ / 4 ⎥ ; ⎣0 e ⎦ ⎝0 i ⎠ 0⎞ 1 ⎛1 1 ⎞ ⎜⎜ ⎟⎟ ⎟; H = −1⎠ 2 ⎝1 − 1⎠ ⎛1 ⎜ ⎜0 CNOT = ⎜ 0 ⎜ ⎜0 ⎝ 0 1 0 0 0 0 0 1 0⎞ ⎟ 0⎟ 1⎟ ⎟ 0 ⎟⎠ Figure 1.2. Quantum gates Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 6/66 In a quantum circuit we represent a CNOT and a quantum gate M in the following way: Figure 1.3. Quantum gate representation for circuits: CNOT (left) and M gate (right) Note that all of these gates operate only on one qubit except the CNOT. It is a short notion of the controlled X gate. Similarly every arbitrary gate M can be executed conditionally (control qubits, black point) on several qubits (targets, M-Box) on parallel. Figure 1.4. Multiple controlled M gates (control qubit 1+2, target qubits 3+4) Lets have a look at the characteristics of some of these gates to for getting familiar with them. The identity I simply lets a qubit unchanged ⎛ 1 0 ⎞⎛ a ⎞ ⎛ a ⎞ ⎟⎟⎜⎜ ⎟⎟ = ⎜⎜ ⎟⎟ . I Ψ = ⎜⎜ ⎝ 0 1 ⎠⎝ b ⎠ ⎝ b ⎠ The Pauli X gate is also called the flip gate because it flips the basis ⎛ 0 1 ⎞⎛ a ⎞ ⎛ b ⎞ ⎟⎟⎜⎜ ⎟⎟ = ⎜⎜ ⎟⎟ . X Ψ = ⎜⎜ ⎝ 1 0 ⎠⎝ b ⎠ ⎝ a ⎠ The Pauli Z gate causes a phase flip ⎛ 1 0 ⎞⎛ a ⎞ ⎛ a ⎞ ⎟⎟⎜⎜ ⎟⎟ = ⎜⎜ ⎟⎟ . Z Ψ = ⎜⎜ ⎝ 0 − 1⎠⎝ b ⎠ ⎝ − b ⎠ The Hadamard gate brings a base state in superposition H Ψ = Rainer Baumann, ETH Zurich 2003 [email protected] 1 ⎛1 1 ⎞⎛ a ⎞ 1 ⎛a + b⎞ ⎜⎜ ⎟⎟⎜⎜ ⎟⎟ = ⎜⎜ ⎟⎟ . 2 ⎝1 − 1⎠⎝ b ⎠ 2 ⎝a − b⎠ Quantum Error Correction 7/66 It’s nice to see that H 2 = X and S 2 = Z . When you look at the equation below you’ll understand why the T gate is also called the π/8 gate. ⎡e − iπ / 8 π /8 = ⎢ ⎣ 0 0 ⎤ 0 ⎤ ⎡1 ≡ =T ⎥ ⎢ iπ / 4 ⎥ e iπ / 8 ⎦ ⎣0 e ⎦ Now we want to have a look at gates acting on two qubits. The most popular is the controlled-NOT which flips the target qubit if the control qubit is set. According to classical bits, we call a qubit set if it is in the base state 1 and not set if it is in the base state 0 . CNOT Ψ1 Ψ2 ⎛1 ⎜ ⎛ ⎛ a1 ⎞ ⎛ a 2 ⎞ ⎞ ⎜ 0 = CNOT ⎜⎜ ⎜⎜ ⎟⎟ ⊗ ⎜⎜ ⎟⎟ ⎟⎟ = ⎜ ⎝ ⎝ b1 ⎠ ⎝ b2 ⎠ ⎠ ⎜ 0 ⎜0 ⎝ 0 1 0 0 0 0 0 1 0 ⎞⎛ a1 a 2 ⎞ ⎛ a1 a 2 ⎞ ⎟ ⎜ ⎟ ⎟⎜ 0 ⎟⎜ a1b2 ⎟ ⎜ a 2 b2 ⎟ = 1 ⎟⎜ b1 a 2 ⎟ ⎜ b1b2 ⎟ ⎟ ⎜ ⎟ ⎟⎜ 0 ⎟⎠⎜⎝ b1b2 ⎟⎠ ⎜⎝ b1 a 2 ⎟⎠ Putting all together we are now able to construct a circuit which prepares entangled EPR pairs. Ψ1 EPRΨ12 Ψ2 Figure 1.5. Quantum circuit to create entangled EPR state CNOT • (H ⊗ I ) • Ψ1 Ψ2 ⎛1 ⎜ ⎜0 =⎜ 0 ⎜ ⎜0 ⎝ 0 1 0 0 0 0 0 1 0 ⎞⎛ 1 ⎟⎜ 0 ⎟⎜ 0 1 ⎟⎜ 1 ⎟⎜ 0 ⎟⎠⎜⎝ 0 0 1 0 ⎞⎛ a1 a 2 ⎞ ⎛ a1 a 2 + b1b2 ⎞ ⎜ ⎟ ⎟⎜ ⎟ 1 0 1 ⎟⎜ a1b2 ⎟ 1 ⎜ a1b2 + b1b2 ⎟ = 0 − 1 0 ⎟⎜ b1 a 2 ⎟ 2 ⎜⎜ b1 a 2 − b1b2 ⎟⎟ ⎟ ⎟⎜ ⎜a a − b a ⎟ 1 0 − 1⎟⎠⎜⎝ b1b2 ⎟⎠ ⎝ 1 2 1 2⎠ For a concrete EPR state this would look like: ⎛1⎞ ⎛1⎞ ⎜ ⎟ ⎜ ⎟ 1 ⎜ 0 ⎟ 00 + 11 ⎜ 0⎟ EPR12 0 0 = CNOT • (H ⊗ I ) • ⎜ ⎟ = ⎜0⎟ = 0 2 2 ⎜ ⎟ ⎜ ⎟ ⎜1⎟ ⎜ 0⎟ ⎝ ⎠ ⎝ ⎠ Nice to know is also that X2=I and XZ=Y up to a global phase shift. ⎛ 0 1 ⎞⎛ 1 0 ⎞ ⎛ 0 − 1⎞ ⎟⎟ = Y ⎟⎟ ≡ i⎜⎜ ⎟⎟⎜⎜ XZ = ⎜⎜ ⎝ 1 0 ⎠⎝ 0 − 1⎠ ⎝ 1 0 ⎠ Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 8/66 Often it is good to write out the basis to understand what happens. Below you see the basis of a 1, 2 and 3 qubit system. ⎛0 ⎞ base Ψ1 = ⎜⎜ ⎟⎟ ; base Ψ1 Ψ2 ⎝1 ⎠ ⎛ 00 ⎜ ⎜ 01 =⎜ 10 ⎜ ⎜ 11 ⎝ ⎞ ⎟ ⎟ ⎟ ; base Ψ1 Ψ2 ⎟ ⎟ ⎠ ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ Ψ3 = ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ 000 ⎞ ⎟ 001 ⎟ 010 ⎟ ⎟ 011 ⎟ ⎟ 100 ⎟ 101 ⎟ ⎟ 110 ⎟ 111 ⎟⎠ In multiple qubit systems, we often simply write the index of the qubits lowered right to the gate instead of always writing on which qubit we apply a certain gate. Assume we have a three qubit system. For applying X on the second qubit, we simply write X 2 as a short form for I ⊗ X ⊗ I . 1.2.1. Reversible quantum gates and irreversible classical gates Mathematically a quantum gate is described as a unitary matrix. Since every unitary matrix has an inverse, every calculation on a quantum computer must be reversible. Note that this is different to a classical computer where most gates are irreversible. For example a logical XOR (a XOR b = c) is not reversible, because it is impossible to determine the values of a and b from c. So the question comes up how to implement this irreversible gates in a reversible manner? This problem can be solved very easily by just keeping one of the original values. For example to calculate a XOR we can use the following circuit: A A B A⊕ B Figure 1.6. Reversible XOR circuit Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 9/66 1.2.2. Universal quantum gates In classical computers all logic can be build up from a small set of so called universal gates or even from one single (e.g. NAND). This is not surprising, as the truth table of a classical gate has finite combinations of outputs. This is very important for hardware construction. If we are able to implement such a set of universal gates we can compute what ever we want. But in quantum computation, infinitely many different gates exist. Implementing all of them is impossible. But fortunately, it turns out that also in quantum computation sets of universal quantum gates exist which can approximate every other quantum gate with an arbitrary small error. This first set consists of the CNOT, Hadamard and T gates. The second set consists of the CNOT, Hadamard, phase and Toffoli gates.(The Toffoli gate is a CNOT with two control qubits and one target qubit.) We will see in section four that all of this gates can be implemented fault-tolerantly. The Hadamard and T gate are used to approximate any single qubit unitary operation. The CNOT allows us to approximate multiple qubit unitary operations. A detailed proof of this would really go beyond the scope of this paper and can be found in the book of Nielsen and Chuang. The main idea is that we have to construct a rotation by an irrational multiple of 2π . Combining T and HTH let us construct a rotation on the Bloch sphere along the axis π π π⎞ r ⎛ π n = ⎜⎜ cos , sin , cos ⎟⎟ through the angle Θ = 2 cos : 8 8 8⎠ 8 ⎝ π T * HTH = e −i Z 8 *e −i π 8 X Rainer Baumann, ETH Zurich 2003 [email protected] = cos 2 π π ⎤ π ⎡ π I − i ⎢cos ( X + Z ) + sin Y ⎥ sin 8 8 8 ⎦ 8 ⎣ Quantum Error Correction 10/66 1.3. Measurement The value of a classical bit is always deterministically 0 or 1. When measuring a single qubit in an arbitrary state, the probability of the outcome 0 is α 2 and for 1 β 2 . Such a measurement is done by Hermitian projection on the basis states 0 , 1 . So a measurement is represented by Hermitian matrices. So we get a classical bit out of a measurement. But the axioms of quantum mechanics tells us that after the measurement an arbitrary qubit is collapsed in the measured bases state. So we destroy a qubit with a simple measurement. In a quantum circuit we use the following symbol: Figure 1.7. Symbol for measurement We often omit the two lines representing the classical bit at the right of a measurement because they normally do not interact again with the rest of a circuit. Concerning a general operator M, which is Hermitian and unitary with eigenvalues ±1, the following circuit can be used for measuring its eigenvalues without completely destroying the measured qubit. After measurement, the qubit will be in the corresponding eigenvector. This is a very important trick, but note, that we do not gain any information about α 2 or β 2 . 0 Ψ Φ1 Φ2 Φ3 Φ4 Figure 1.8. Measurement of general operator M ⎡1 0 ⎤ Lets verify this for the Pauli matrix Z = ⎢ ⎥ . It is obvious that Z ⎣0 − 1⎦ is a hermitian, unitary matrix with eigenvalues ±1. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 11/66 Φ1 = 0 Ψ = a 0 0 + b 0 1 Φ2 = Φ3 = Φ4 = 1 2 1 2 (0 (a 0 + 1 )Ψ = 1 2 (a 0 0 +a1 0 +b 0 1 +b1 1 ) 0 +a1 0 +b 0 1 −b1 1 ) 1 (a( 0 + 1 ) 0 + a( 0 − 1 ) 0 + b( 0 + 1 ) 1 − b( 0 − 1 ) 1 ) 2 1 ( 0 (a 0 + a 0 + b 1 − b 1 ) + 1 (a 0 − a 0 + b 1 + b 1 2 = (a 0 0 + b 1 1 ) = )) Measuring the first qubit, let us now determine the eigenvalue of Z leaving Ψ in the corresponding eigenstate. 1.4. Shor’s factoring algorithm For a long time it was not clear how to use the power of quantum computers. The major problem was the collapse of coherent states during measurements of a general qubit. It seemed impossible to get out a detailed result of a quantum computation. Peter Shor published in 1994 a surprising algorithm for the factorization of large numbers, which handled this problem in a very clever way. Most of modern public cryptography is based on the assumption that the factorization of large numbers is extremely difficult. But the new algorithm would allow solving this problem in polynomial time. This was a great improvement. For the interested reader, there are many good introduction to this algorithm so we won’t disuse it in here. 1.5. Classical linear codes Linear codes have been developed for making classical communication fault tolerant. With them it is possible to communicate over noisy and erroneous data channels. Encoding is used very often, because in reality there is no errorless communication. Famous examples for such communications are telecommunication (fix net or mobile), modem connections to the Internet, Ethernet networks. The major idea is to encode k data bits in n bits. The n-k bits are used for introducing additional information, the so called redundancy. This redundancy can be used to detect bit flips occurred during transmission. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 12/66 Assume we want to send the data bit x. We encode this with the generator matrix G by multiplication. This results in the code word c. ⎛1⎞ ⎛1⎞ ⎜ ⎟ ⎜ ⎟ x = (1) ; G = ⎜1⎟ ; x • G = c = ⎜1⎟ ⎜1⎟ ⎜1⎟ ⎝ ⎠ ⎝ ⎠ A code which encodes k data bits in n bits is called a [n,k] code. So the code we introduced above is a [3,1] code. It simply repeats the data bit three times. We call it the three-bit repetition code. This encoded bit c can now be transmitted over a communication channel. Assume that during delivery the second bit has been flipped by the error e. So we’ll receive r. ⎛0⎞ ⎛1⎞ ⎜ ⎟ ⎜ ⎟ e = ⎜1⎟ ; c + e = r = ⎜ 0⎟ ⎜0⎟ ⎜1⎟ ⎝ ⎠ ⎝ ⎠ For the correction of the received word we need two more things. The so called parity check matrix H and the syndrome decoder table. The parity check matrix is defined in the following way. When you multiply any valid codeword c with the transposed of the parity check matrix H you get zero. c•HT=0 There is a straight forward way getting the parity check matrix from the generator matrix, which can be found in every classical coding book. When you solve the same equation for a received word r you’ll get the syndrome s, which allows making drawbacks on the resulted error. s = (c+e)•HT = (r)•HT = c•HT+e•HT = 0+e•HT = e•HT Given the parity check matrix for our example we can calculate the syndrome. ⎡1 1 0⎤ ⎛1⎞ H =⎢ ; r • H T = s = ⎜⎜ ⎟⎟ ; ⎥ ⎣0 1 1 ⎦ ⎝1⎠ Rainer Baumann, ETH Zurich 2003 [email protected] Syndrome Error Pattern 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 1 1 0 1 0 Quantum Error Correction 13/66 With a look at the syndrome table we find the occurred error e. We now have to subtract this error from r getting c. Finally we have to decode c by the generator matrix getting back our original data bit. ⎛1⎞ ⎜ ⎟ r − e = c = ⎜1⎟ ; c • G −1 = (1) ⎜1⎟ ⎝ ⎠ For the interested reader the calculation of another example is given below, the [5,2] code. ⎛1 ⎜ ⎜0 ⎛1⎞ x = ⎜⎜ ⎟⎟ ; G = ⎜ 1 ⎜ ⎝1⎠ ⎜1 ⎜1 ⎝ ⎛1⎞ ⎜ ⎟ r • H = s = ⎜ 0⎟ ; ⎜ 0⎟ ⎝ ⎠ T ⎛1⎞ c • G −1 = ⎜⎜ ⎟⎟ ⎝1⎠ 0⎞ ⎛1⎞ ⎛1⎞ ⎟ ⎜ ⎟ ⎜ ⎟ 1⎟ ⎛1 1 1 0 0 ⎞ ⎜1⎟ ⎜1⎟ ⎜ ⎟ ⎟ ⎟ ⎟ ⎜ ⎜ 1 ; x • G = c = 0 ; r = 1 ; H = ⎜1 0 0 1 0 ⎟ ; ⎟ ⎜ ⎟ ⎜ ⎟ ⎜1 1 0 0 1 ⎟ 0⎟ ⎜1⎟ ⎜1⎟ ⎝ ⎠ ⎜ 0⎟ ⎜0⎟ 1 ⎟⎠ ⎝ ⎠ ⎝ ⎠ Syndrome Error Pattern 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 1 1 0 0 0 1 1 1 0 0 0 0 1 0 0 1 0 1 0 1 0 0 0 1 1 0 0 0 1 1 0 1 1 1 1 0 0 0 0 Rainer Baumann, ETH Zurich 2003 [email protected] ⎛0⎞ ⎛1⎞ ⎜ ⎟ ⎜ ⎟ ⎜0⎟ ⎜1⎟ ⎟ ⎜ e = 1 ; r − e = c = ⎜0⎟ ; ⎜ ⎟ ⎜ ⎟ ⎜0⎟ ⎜1⎟ ⎜0⎟ ⎜0⎟ ⎝ ⎠ ⎝ ⎠ Quantum Error Correction 14/66 2. Basics of quantum error correction 2.1. Quantum channel In the last paragraph we heard about classical communication channel. Lets have a look at the quantum analogue. A quantum channel is a connection over which qubits can be sent and coherence is preserved. In a real quantum channel always some error occurs. An input state can be changed or even worse can be entangled with the environment. For correcting such errors we need to introduce some additional information which let us figure out what happened, the so called redundancy. In a transmission, often redundancy is encoded for several qubits together. For this purpose we need quantum error correction codes (QECC). Also for stored qubits we need a certain redundancy because a quantum memory is much more vulnerable to errors than classical one. So it is self-evident to protect qubits by encoding them as in communication. 2.2. Difficulties for quantum error correction Now, one would think that we just have to take the classical linear codes and every thing gets fine. But there are three rather big difficulties to deal with: • • No cloning theorem: Most classical codes require the possibility to copy bits as the simple repetition code, discussed above, which just sends the same bit several times. Due to non-cloning we are not able to do such copies of qubits. (See Appendix A.1 for the No cloning theorem) Errors are continuous: Classical errors are discrete, only a bit flip can occur. But quantum errors are continuous. A qubit can be in any superposition of the two allowed bases states. Determining which error occurred in order to correct would appear to require infinite precision, and therefore infinite resources. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 15/66 • Measurement destroys quantum information: In classical error correction we simply observe the value of the output data bits to decide how to correct and decode it. But in quantum mechanics such an observation destroys the coherence of a state and lets it collapse in a basis state of the measurement operator. So we have to find other ways for error detection and correction. Because of these problems it was believed for a long time that quantum computation will never scale. Fortunately none of these problems is very serious as we will see in this chapter. 2.3. Quantum error correction codes (QECC) A quantum error correction code consists of four major steps. Assume you want to send a sequence of data qubits over a quantum channel. Then you split this sequence in fix sized sets of qubits. In the figure below the size is two. These sets are encoded independently resulting in a codeword. There are more qubits in a codeword than data bits in the original set. This codewords can then be transmitted over the quantum channel. We assume that potential errors can only occur during this transmission. When you receive the message you do some error detection and potentially also some error recovery. These two phases together are simply called error correction. The correct codeword can then be send through a decoder resulting in the original set of data bits. potential errors Ψ Ψ Figure 2.1. The major elements of quantum error correction codes The best thing for getting a first understanding of the major elements of a quantum error correction code is to look at some simple codes. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 16/66 2.3.1. Three-qubit flip code Assume we want to send a single qubit Ψ = a 0 +b1 through a quantum channel. During transmission the qubit can be flipped to X Ψ = b 0 + a 1 with probability p. Such a quantum channel is called a bit flip channel. Note that a qubit flip is the same as you apply the Pauli X gate to the qubit. Ψ = a 0 +b1 Ψ = a 0 +b1 X Ψ =b 0 +a1 Figure 2.2. Quantum bit flip channel We now can try to use the same idea as in the three bit repetition code from the last chapter. We just send the qubit three times over the quantum channel. ΨL denotes the original (logical) qubit to be encoded. The encoding for the two base (pure) states are the following: 0 L = 000 1L = 111 For an arbitrary qubit ΨL = a 0 + b 1 we get the encoding Ψ = a 000 + b 111 . But how to do this encoding without the possibility of qubit copying. The following circuit does this encoding. The two 0 states are so called ancillas prepared in standard state. Ancillas are additional qubits generally introducing the redundancy. Ψ 0 0 Figure 2.3. Three-qubit flip code - encoding circuit We write out again the basis of a three qubit system. The easiest way to understand the calculations is in term of bit flipping. Note that the first bit is the control bit. If it is set it simply interchanges the target states. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 17/66 base Ψ1 Ψ2 ⎛ ⎜ ⎜ ⎜ ⎜ ⎜ Ψ3 = ⎜ ⎜ ⎜ ⎜ ⎜ ⎜ ⎝ ⎛a⎞ ⎜ ⎟ 000 ⎞ ⎟ ⎜0⎟ 001 ⎟ ⎜0⎟ 010 ⎟⎟ ⎜ ⎟ a 1 1 ⎛ ⎞ ⎛ ⎞ ⎛ ⎞ ⎜0⎟ 011 ⎟ Ψ ⎜⎜ ⎟⎟ ⊗ ⎜⎜ ⎟⎟ ⊗ ⎜⎜ ⎟⎟ = ⎜ ⎟ 0 0 = Ψ = 123 ⎟; ⎝b ⎠ ⎝0⎠ ⎝0⎠ ⎜b ⎟ 100 ⎟ ⎜0⎟ 101 ⎟ ⎜ ⎟ ⎟ 110 ⎟ ⎜0⎟ ⎜0⎟ 111 ⎟⎠ ⎝ ⎠ CNOT1,3 • CNOT1, 2 • Ψ123 ⎛1 ⎜ ⎜0 ⎜0 ⎜ ⎜0 =⎜ ⎜0 ⎜0 ⎜ ⎜0 ⎜0 ⎝ ⎛1 ⎜ ⎜0 ⎜0 ⎜ ⎜0 = CNOT1,3 • ⎜ ⎜0 ⎜0 ⎜ ⎜0 ⎜0 ⎝ 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 ⎞⎛ a ⎞ ⎟⎜ ⎟ 0 ⎟⎜ 0 ⎟ 0 ⎟⎜ 0 ⎟ ⎟⎜ ⎟ 0 ⎟⎜ 0 ⎟ ⎜ ⎟ 0 ⎟⎟⎜ b ⎟ 1 ⎟⎜ 0 ⎟ ⎟⎜ ⎟ 0 ⎟⎜ 0 ⎟ 0 ⎟⎠⎜⎝ 0 ⎟⎠ 0 0 0 0 0 0 0 ⎞⎛ a ⎞ ⎛ a ⎞ ⎟⎜ ⎟ ⎜ ⎟ 1 0 0 0 0 0 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟ 0 1 0 0 0 0 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟ ⎟⎜ ⎟ ⎜ ⎟ 0 0 1 0 0 0 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟ ⎟⎜ ⎟ = ⎜ ⎟ 0 0 0 0 1 0 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟ 0 0 0 1 0 0 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟ ⎟⎜ ⎟ ⎜ ⎟ 0 0 0 0 0 0 1 ⎟⎜ b ⎟ ⎜ 0 ⎟ 0 0 0 0 0 1 0 ⎟⎠⎜⎝ 0 ⎟⎠ ⎜⎝ b ⎟⎠ Or just in non-vector form: Ψ123 = a 000 + b 100 CNOT12 (a 000 + b 100 ) = a 000 + b 110 CNOT23 (a 000 + b 100 ) = a 000 + b 111 After encoding, we now can pass each qubit independently over the described bit flip channel. With the used encoding, we are capable to correct a single or non qubit flip. This occurs with probability (1 − p )3 + 3 p(1 − p )2 = 1 − 3 p 2 + 2 p 3 . So the probability of an error remaining uncorrected or wrong corrected with this code is 3 p2 − 2 p3 . Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 18/66 Assume now, that during transmission a bit flip occurred on the first qubit resulting in Ψr = a 100 + b 011 . The error correction consists of the detection and recovery phase. • Detection: We perform a measurement with a projection operator P to determine the error syndrome. P0 ≡ 000 000 + 111 111 no error P1 ≡ 100 100 + 011 011 bit flip on qubit one P2 ≡ 010 010 + 101 101 bit flip on qubit two P3 ≡ 001 001 + 110 110 bit flip on qubit three Note that measurements in these basis do not change the state because they are orthogonal. For our received codeword Ψr we get the following syndrome measurements: Ψr P0 Ψr = 0 Ψr P1 Ψr = 1 Ψr P2 Ψr = 0 Ψr P3 Ψr = 0 Note that the syndrome only contains information about what error occurred and does not allow us to infer anything about a or b. • Recovery: The syndrome tells us if and how to correct the received state. In our example the syndrome tells us, that the first qubit was flipped. We simply flip it back by applying X1 to it. This all sounds very nice. But in the section about measurement, we learned that in reality we are not able to implement this measurement without destroying the measured qubit. So we somehow have to find other basis which provides us with the same information and but which can easily be implemented. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 19/66 Instead of measuring each single qubit with the four projectors P0, P1, P2, P3 we could perform two measurements on the observable Z1Z2 ( ≡ Z⊗Z⊗I ) and Z2Z3 ( ≡ I⊗Z⊗Z ). Each of them have eigenvalue ±1. The corresponding eigenvectors are the two valid codewords 000 and 111 . So we can use the measurement circuit introduced in the section about measurements. ⎛1 ⎜ ⎜0 ⎜0 ⎜ ⎜0 Z1 Z 2 = ⎜ ⎜0 ⎜0 ⎜ ⎜0 ⎜0 ⎝ 0 0 0 0 0 1 0 0 0 0 0 −1 0 0 0 0 0 −1 0 0 0 0 0 −1 0 0 0 0 0 −1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0⎞ ⎛1 0 0 ⎟ ⎜ 0⎟ ⎜0 −1 0 ⎟ ⎜0 0 −1 0 ⎟ ⎜ 0⎟ ⎜0 0 0 Z2Z3 = ⎜ ⎟ 0⎟ ⎜0 0 0 ⎜0 0 0 0⎟ ⎟ ⎜ 0⎟ ⎜0 0 0 ⎜0 0 0 1 ⎟⎠ ⎝ 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 −1 0 0 0 −1 0 0 0 0⎞ ⎟ 0⎟ 0⎟ ⎟ 0⎟ 0 ⎟⎟ 0⎟ ⎟ 0⎟ 1 ⎟⎠ We can understand the observable Z1Z2 as a comparison of the first two qubits. The eigenvalue +1 indicates they are the same and –1 that they are different. Like this we can construct the following syndrome (right) table and measurement basis (left). Z1 Z2 = ( 00 11 + 11 11 ) ⊗ I − ( 01 01 + 10 10 ) ⊗ I Z2 Z 3 = I ⊗ ( 00 11 + 11 11 ) − I ⊗ ( 01 01 + 10 10 ) Z1 Z2 Z2 Z 3 Error +1 +1 +1 -1 I X3 -1 +1 X1 -1 -1 X2 For our example we get: Ψr Z 1 Z 2 Ψr = −1 Ψr Z 2 Z 3 Ψr = +1 When we look up this error in the syndrome table we find: (-1,+1) -> X1 Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 20/66 As described in the last section, measurements usually are done with ancillas. For the observable Z1Z2, Z2Z3 the measurement and correction circuit is shown below. The three upper lines denote the encoded qubit block. In our figures, we will not mark them specially. 0 0 Figure 2.4. Three-qubit flip code - error detection and correction circuit with ZZ We could even simplify this gate. Instead of the Z1Z2, Z2Z3 measurements, we could perform two controlled-NOTs on the same target ancilla but with different control qubit. If the two control qubits are the same, the ancilla either stays in the 0 state or gets flipped twice resulting also in the 0 state. Like this we are able to compare two qubits as in the circuit above. 0 0 Figure 2.5. Three-qubit flip code - error correction circuit with CNOT The syndrome table stays the same: Rainer Baumann, ETH Zurich 2003 [email protected] M1 0 1 M2 0 0 Error I X1 1 1 X2 0 1 X3 Quantum Error Correction 21/66 For our example we get: CNOT14 • CNOT24 • Ψr 0 0 = −1 CNOT25 • CNOT35 • Ψr 0 0 = +1 When we look up this error in the syndrome table we find (-1,+1) > X1, what we expected. Now the decoding circuit is easy. We just reverse the encoding circuit: Ψ Figure 2.6. Three-qubit flip code - decoding circuit 2.3.2. Three-qubit phase flip code Let’s have a look at a different kind of error, which is not known from the classical theory, the phase flip error. Z Ψ = Z • (a 0 + b 1 ) = a 0 − b 1 A quantum channel on which a phase flip occurs with probability p is called a phase flip channel. Ψ = a 0 +b1 Ψ = a 0 +b1 X Ψ = a 0 −b1 Figure 2.7. Quantum phase flip channel There is a very easy way to protect against phase flips. Suppose we work in the qubit basis: + ≡ (0 + 1) (0 − 1 ) ; − ≡ 2 2 In this basis the phase flip operator Z acts as an ordinary bit flip operator and we can use the ordinary bit flip error correction code. The alternative syndrome measurement for this code can be described as following H⊗3Z1Z2H⊗3 = X1X2 and H⊗3Z2Z3H⊗3 = X2X3. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 22/66 The encoding circuit is described below. The three Hadamards at the right are responsible for the transformation of the basis. Ψ 0 0 Figure 2.8. Three-qubit phase flip code - encoding circuit The code qubits can now be passed independently over the quantum phase flip channel. For the error correction circuit we just have to convert our state back to the standard basis using the Hadamards again. There we can apply the same circuit as in the three-qubit flip code. Also the syndrome table stays the same. 0 0 Figure 2.9. Three-qubit phase flip code - error correction circuit with CNOT The decoding circuit also stays the same as in the three-qubit flip code because we have already switched back the bases by applying the Hadamards in the error correction circuit. Lets have a look at the calculation of a concrete example. We first encode our qubit: ΨL = 3 4 0 + 1 → ΨL 5 5 Rainer Baumann, ETH Zurich 2003 [email protected] ⎛ 3/ 5⎞ ⎟ ⎜ ⎜ 0 ⎟ ⎜ 0 ⎟ ⎟ ⎜ ⎜ 0 ⎟ 0 0 =⎜ ⎟ ⎜ 4 / 5⎟ ⎜ 0 ⎟ ⎟ ⎜ ⎜ 0 ⎟ ⎜ 0 ⎟ ⎠ ⎝ Quantum Error Correction 23/66 Ψc = H 1 • H 2 • H 3 • CNOT13 • CNOT12 • ΨL ⎛3/ 5⎞ ⎛ 7 / 5 ⎞ ⎟ ⎜ ⎟ ⎜ ⎜ 0 ⎟ ⎜ − 1/ 5⎟ ⎜ 0 ⎟ ⎜ − 1/ 5⎟ ⎟ ⎜ ⎟ ⎜ ⎜ 0 ⎟ ⎜ 7/5 ⎟ 0 0 = H1 • H 2 • H 3 • ⎜ ⎟ = ⎜ − 1/ 5⎟ 0 ⎟ ⎜ ⎟ ⎜ ⎜ 0 ⎟ ⎜ 7/5 ⎟ ⎟ ⎜ ⎟ ⎜ ⎜ 0 ⎟ ⎜ 7/5 ⎟ ⎜ 4 / 5⎟ ⎜ − 1/ 5⎟ ⎠ ⎝ ⎠ ⎝ Assume now, the second qubit is affected by a phase flip error getting: ⎛1 ⎜ ⎜0 ⎜0 ⎜ ⎜0 Ψr = Z 2 Ψc = ⎜ ⎜0 ⎜0 ⎜ ⎜0 ⎜0 ⎝ 0 0 0 1 0 0 0 −1 0 0 0 −1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 ⎞⎛ 7 / 5 ⎞ ⎛ 7 / 5 ⎞ ⎟⎜ ⎟ ⎜ ⎟ 0 0 0 ⎟⎜ − 1 / 5 ⎟ ⎜ − 1 / 5 ⎟ 0 0 0 ⎟⎜ − 1 / 5 ⎟ ⎜ 1 / 5 ⎟ ⎟⎜ ⎟ ⎜ ⎟ 0 0 0 ⎟⎜ 7 / 5 ⎟ ⎜ − 7 / 5 ⎟ = 0 0 0 ⎟⎟⎜⎜ − 1 / 5 ⎟⎟ ⎜⎜ − 1 / 5 ⎟⎟ 1 0 0 ⎟⎜ 7 / 5 ⎟ ⎜ 7 / 5 ⎟ ⎟⎜ ⎟ ⎜ ⎟ 0 − 1 0 ⎟⎜ 7 / 5 ⎟ ⎜ − 7 / 5 ⎟ 0 0 − 1⎟⎠⎜⎝ − 1 / 5 ⎟⎠ ⎜⎝ 1 / 5 ⎟⎠ Now we apply the Hadamards to convert our received word back in the normal basis and measure it as in the three-qubit flip code. ΨHr ⎛ 7/5 ⎞ ⎛ 0 ⎞ ⎟ ⎜ ⎟ ⎜ ⎜ −1/ 5 ⎟ ⎜ 0 ⎟ ⎜ 1/ 5 ⎟ ⎜ 3 / 5 ⎟ ⎟ ⎜ ⎟ ⎜ ⎜ − 7 / 5⎟ ⎜ 0 ⎟ = H 1 • H 2 • H 3 • Ψr = H 1 • H 2 • H 3 • ⎜ ⎟=⎜ 0 ⎟ − 1 / 5 ⎟ ⎜ ⎟ ⎜ ⎜ 7 / 5 ⎟ ⎜ 4 / 5⎟ ⎟ ⎜ ⎟ ⎜ ⎜ − 7 / 5⎟ ⎜ 0 ⎟ ⎜ 1/ 5 ⎟ ⎜ 0 ⎟ ⎠ ⎝ ⎠ ⎝ CNOT14 • CNOT24 • ΨHr 0 0 = −1 CNOT25 • CNOT35 • ΨHr 0 0 = −1 The syndrome table tells us that qubit two has been phase flipped. Now we have to phase flip back the qubit two. This would normally be done by Z2 but we already changed the basis and in this basis a Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 24/66 phase flip corresponds to an ordinary flip. So we simply apply X2 and we get the original code word. X 2 ΨHr ⎛0 ⎜ ⎜0 ⎜1 ⎜ ⎜0 =⎜ ⎜0 ⎜0 ⎜ ⎜0 ⎜0 ⎝ 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 ⎞⎛ 0 ⎞ ⎛ 3 / 5 ⎞ ⎟ ⎜ ⎟ ⎟⎜ 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟ 0 ⎟⎜ 3 / 5 ⎟ ⎜ 0 ⎟ ⎟ ⎜ ⎟ ⎟⎜ 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟ = 0 ⎟⎟⎜⎜ 0 ⎟⎟ ⎜⎜ 0 ⎟⎟ 1 ⎟⎜ 4 / 5 ⎟ ⎜ 0 ⎟ ⎟ ⎜ ⎟ ⎟⎜ 0 ⎟⎜ 0 ⎟ ⎜ 0 ⎟ 0 ⎟⎠⎜⎝ 0 ⎟⎠ ⎜⎝ 4 / 5 ⎟⎠ 2.3.3. Shor’s nine-qubit code We now know codes which protects against an ordinary qubit flip or a phase flip. Let us try to make a simple code out of them, which protects against both of these errors and even the combination of them. The main idea is to encode first the qubit using the phase flip algorithm and then to encode each of the three resulted qubits again with the common bit flip code. This is Shor’s nine-qubit code. The two base code words are the following: 0L = = 1 2 2 (( 000 + 111 )( 000 + 111 )( 000 + 111 )) 1 ( 000000000 + 000000111 + 000111000 + 2 2 111000000 + 000111111 + 111111000 + 111111111 ) 1L = = 1 2 2 (( 000 − 111 )( 000 − 111 )( 000 − 111 )) 1 ( 000000000 − 000000111 − 000111000 2 2 − 111000000 + 000111111 + 111111000 − 111111111 ) As already mentioned, this code combination of the errors X • Z = Y . Rainer Baumann, ETH Zurich 2003 [email protected] even protects Quantum Error Correction among the 25/66 The encoding circuit visualizes the used idea very well. At the left you see the three-qubit phase flip encoding circuit and at the right three times the three-qubit bit flip encoding circuits. Ψ 0 0 0 0 0 0 0 0 Figure 2.10. Nine-qubit code – encoding circuit The technique we used to build Shor’s nine-qubit code out of the two previous codes is called concatenation. In concatenation codes are cascaded to build better codes. We will have a deeper look at this technique in a later section. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 26/66 The error correction and decoding circuit for the nine-qubit code also concatenates the already known circuits from the three-qubit codes. From left to right the three-qubit phase flip error correction circuit, the three-qubit phase flip decoding, the three-qubit bit flip error correction circuit and finally the three-qubit bit flip decoding circuit. Ψ 0 0 0 0 0 0 0 0 Figure 2.11. Nine-qubit code – error correction and decoding circuit As for previous codes we can find an alternative syndrome measurement basis. The pairwise comparison for flip detection can be done in the following basis: Z1Z2; Z2Z3; Z4Z5; Z5Z6; Z7Z8; Z8Z9. For the phase flip we have to compare two tripples: X1X2X3X4X5X6; X4X5X6X7X8X9. These bases will be important in a further generalization, in the stabilizer mechanism. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 27/66 2.4. Errors Let’s summarize all the errors we already know: I – no error X - bit flip Z – phase flip Y – bit and phase flip But there are infinitely many other errors, which could occur. For example a qubit can be changed by an error E like: Ψ = 3 4 5 12 E ⎯→ 0 + 1 ⎯ 0 + b1 5 5 13 13 Surprisingly these continuum errors can be reduced to the discrete set of errors (I,X,Z,Y). Every general error E can be described as a superposition of this discrete set: E = e1 I + e 2 X + e3 Z + e4Y This is a characteristic of the Pauli matrices. Lets decompose a very nice error: ⎛1 0⎞ 1 1 ⎟⎟ = I + Z E = ⎜⎜ 2 ⎝0 0⎠ 2 This alone won’t help much. Now we measure the error syndrome, in the basis of the discrete error set (I,X,Z,Y). With the measurement the state collapses the superposition of errors into one of the four states. Like this we have reduced an arbitrary error to one of our four basic ones, from which we can easily correct the error. Lets look at a very simple example for getting the feeling what this means. We use the three-qubit flip code. The encoded qubit would look like: Ψ = 000 + 111 2 Assume a very nasty error E adulterates the encoded qubit getting: E Ψ = Ψ1 = 100 + 011 + 001 + 110 Rainer Baumann, ETH Zurich 2003 [email protected] 4 ; E= 1 1 X1 + X 3 2 2 Quantum Error Correction 28/66 Let’s calculate what happens step by step. 0 0 Ψ7 Ψ3 Ψ2 Ψ1 Ψ4 Ψ6 Ψ5 Figure 2.12. Three-qubit code – error correction circuit Ψ1 = Ψ2 = Ψ3 = Ψ4 = Ψ5 = = 100 00 + 011 00 + 001 00 + 110 00 4 100 10 + 011 00 + 001 00 + 110 10 4 100 10 + 011 10 + 001 00 + 110 00 4 100 10 + 011 11 + 001 00 + 110 01 4 100 10 + 011 10 + 001 01 + 110 01 4 ( 100 + 011 ) 10 + ( 001 + 110 ) 01 4 The two lower qubits are in the superposition: 10 + 01 2 Measuring these two qubits collapses the superposition in either 10 or 01 . Because of this the uncorrectable state Ψ5 also collapses in a correctable one. Assume we measure M1=0 and M2=1 Ψ5 collapses into the following state: Ψ6 = Rainer Baumann, ETH Zurich 2003 [email protected] 001 + 110 2 01 Quantum Error Correction 29/66 This state can then easily be corrected. A look at the syndrome table tells us that we just have to flip the third qubit with X3 back resulting in: Ψ7 = 000 + 111 2 2.5. Properties of quantum codes Codes are generally characterized by the triple [n,k,d], n>k n – length of resulting code word k – number of qubits to be encoded d – minimum distance An error on a system of qubits can be decomposed in errors on single qubits. In simple terms, the weight of an error is the number of such single errors it consists out. A code with minimal distance d is able to detect all errors of weight (d-1). After an error is detected, correction is not a difficult thing any more. The three-qubit flip and phase flip code are both [3,1,1] codes. Shor’s nine-qubit code is a [9,1,3] code. A quantum error-correcting code can be viewed as a mapping of k qubits (a 2k dimensional Hilbert space) into n qubits (a 2n dimensional Hilbert space). The additional (n-k) qubits provide the redundancy. In order for a code to correct two errors Ea and Eb, we must always be able to distinguish them acting on every combination of two different basis codewords. So for Ea Ψi and Eb Ψj to be distinguishable, they must be orthogonal. T Ψi E a Eb Ψj = δ abδ ij Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 30/66 3. Stabilizer formalism The stabilizer formalism is a very elegant and efficient way to describe most quantum error correction codes. It’s partially based on group theory. Best for familiarizing ourselves with this topic is an example. 3.1. The basics Actually we already met the basics of the stabilizer formalism in the last section. Remember the alternative measurement basis for error detection of the nine-qubit code: Z1Z2; Z2Z3; Z4Z5; Z5Z6; Z7Z8; Z8Z9; X1X2X3X4X5X6; X4X5X6X7X8X9. Lets write them in a table where every column represents a qubit and every row a basis called Mi. M1 1 Z 2 Z 3 I 4 I 5 I 6 I 7 I 8 I 9 I Z1 Z2 M2 I Z Z I I I I I I Z2 Z3 M3 I I I Z Z I I I I Z4 Z5 M4 I I I I Z Z I I I Z5 Z6 M5 I I I I I I Z Z I Z7 Z8 M6 I I I I I I I Z Z Z8 Z9 M7 X X X X X X I I I X1 X2 X3 X4 X5 X6 M8 I I I X X X X X X X 4 X 5 X 6 X 7 X 8 X 9 Figure 3.1. Extended stabilizer table for the nine-qubit code This is already the stabilizer table for the nine-qubit code. We now want to understand the central insight of the stabilizer formalism. It is easily illustrated by an example. Consider the EPR state: Ψ = 00 + 11 2 It is obvious that this state satisfies the identities X 1 X 2 Ψ = Ψ and Z1Z 2 Ψ = Ψ . We say that Ψ is stabilized by the operators Z 1 Z 2 and X 1 X 2 . Or more formally, an operator fixes a state if the state is an eigenvector with eigenvalue +1 of this operator. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 31/66 ⎛0 ⎜ ⎜0 X1X 2 Ψ = ⎜ 0 ⎜ ⎜1 ⎝ 0 0 1 ⎞ 1/ 2 ⎟ 0 1 0⎟ 0 1 0 0⎟ 0 ⎟ 0 0 0 ⎟⎠ 1 / 2 0 ⎛1 0 ⎜ ⎜0 −1 0 Z1Z 2 Ψ = ⎜ 0 0 −1 ⎜ ⎜0 0 0 ⎝ 0⎞ 1/ 2 ⎟ 0⎟ 0 0⎟ 0 ⎟ 1 ⎟⎠ 1 / 2 1/ 2 = 0 0 = Ψ 1/ 2 1/ 2 = 0 0 = Ψ 1/ 2 A little less obvious is that Ψ is the unique state which is stabilized by the two operators. This is an effect from linear algebra. Two different 4-dimensional matrices with eigenvalues ±1 have only one common eigenvector with eigenvalue +1. The basic idea of the stabilizer formalism is now that quantum states can be more easily described by working with the operators that stabilizes them than by working explicitly with the state itself. Coming back to the nine-qubit code, we find that also the two valid base codewords 0 L ; 1L of the code are eigenvectors of all eight operators M1 to M8 with eigenvalue +1. 0L = 1 1L = 1 ( 000000000 + 000000111 + 000111000 + 2 2 111000000 + 000111111 + 111111000 + 111111111 ) ( 000000000 − 000000111 − 000111000 2 2 − 111000000 + 000111111 + 111111000 − 111111111 ) All the operators that fix both base codewords 0 L ; 1L can be written as the product of the eight operators Mi. The set of operators that fix 0 L ; 1L form a group S, called ‘stabilizer’ of the code. The Mi‘s are the generators gi of this group. Depending if we focus on the generator or the operator aspect of a stabilizer we will denote it by Mi or gi interchangeable. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 32/66 As we heard in the previous section, the eigenvalue measurement of the operator M1, let us determine if a bit flip error has occurred on either qubit 1 or 2. We saw that this qubit flip errors can be represented by the operators X1 and X2. Note that both of these errors X1 and X2 anticommute with M1 while all other errors, which cannot be detected by M1, commute with it. {M 1 , X 1 } = 0 -> M 1 X 1 Ψ = − X 1 M 1 Ψ = − X 1 Ψ [M 1 , X 3 ] = 0 -> M 1 X 1 Ψ = + X 1 M 1 Ψ = + X 1 Ψ Or more general: {M , E } = 0 [M , E ] = 0 i j -> Mi E j Ψ = − E j Mi Ψ = − E j Ψ i j -> M i E j Ψ = + E j M i Ψ = + E j Ψ 3.2. More formally The Pauli group Gn on n qubits is defined to consist of all the Pauli matrices, together with the multiplicative factors ±1, ±i. We write out here just the simplest G1 Pauli group over one qubit: G1 ≡ { ±I, ±iI, ±X, ±iX, ±Y, ±iY, ±Z, ±iZ } This set forms a group under matrix multiplication. The stabilizer S is an abelian subgroup of Gn. S defines the set of states Vs to be the set of n qubit states which are fixed by every element of S. Vs is the vector space stabilized by S. Normally S is described by its generators personalized by the stabilizer table seen above. Note that not any subgroup Gn can be used as stabilizer. There are two important conditions: • The elements of S commute with each other • -I is not an element of S (Because (− I ) Ψ = Ψ has only the trivial solution Ψ = 0 ) It makes sense that the generators of S are independent so that S is as small as possible. The check matrix formalism could be used to achieve this. So a [n,k] stabilizer code is defined to be the vector space Vs stabilized by S=<g1, … , gn-k>. In order to perform error-detection operations for a stabilizer code, all we need to do is measuring the eigenvalue of each generator of the stabilizer. This measurement than uniquely identifies the syndrome from which can conclude on the error occurred. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 33/66 3.3. Unitary gates and the stabilizer formalism Let’s analyze what happens when a unitary gate U is applied to a vector space Vs stabilized by S. Let Ψ be any element of Vs. Then for any element g of the stabilizer group S, + U Ψ = Ug Ψ = UgU U Ψ and thus the state U Ψ is U gate CNOT + stabilized by UgU . Group theory reasons that for computing the changes of the stabilizer, we only need to compute how it affects the generators of the stabilizer. In the table at the right you see a list of such transformations. Any unitary operation taking an element from Gn to an elements of Gn under conjugation can be decomposed in H, S and CNOT gates. We say the set of U such that UGn U + = Gn is the normalizer of Gn denoted by N(Gn). With this formalism we can define the distance of a stabilizer code to be the minimum weight of an element of N(S)-S. H S X Y Z gIN gOUT X1 X2 X1 X2 X2 Z1 Z2 Z1 Z1 Z2 X Z X Z X Z X Z X Z Z X Y Z X -Z -X -Z -X Z Figure 3.2. Gate transformation table under unitary operations (right) Lets check this for two concrete examples: H T XH = 1 ⎛1 1 ⎞⎛ 0 1 ⎞⎛1 1 ⎞ 1 ⎛1 1 ⎞⎛1 − 1⎞ 1 ⎛ 2 0 ⎞ ⎟⎜ ⎟= ⎜ ⎟⎜ ⎟= ⎜ ⎟=Z ⎟⎜ ⎜ 2 ⎜⎝1 − 1⎟⎠⎜⎝ 1 0 ⎟⎠⎜⎝1 − 1⎟⎠ 2 ⎜⎝1 − 1⎟⎠⎜⎝1 1 ⎟⎠ 2 ⎜⎝ 0 − 2 ⎟⎠ H T ZH = 1 ⎛1 1 ⎞⎛ 1 0 ⎞⎛1 1 ⎞ 1 ⎛1 1 ⎞⎛ 1 1⎞ 1 ⎛ 0 2 ⎞ ⎟⎜ ⎟⎜ ⎟= ⎜ ⎟⎜ ⎟= ⎜ ⎟= X ⎜ 2 ⎜⎝1 − 1⎟⎠⎜⎝ 0 − 1⎟⎠⎜⎝1 − 1⎟⎠ 2 ⎜⎝1 − 1⎟⎠⎜⎝ − 1 1⎟⎠ 2 ⎜⎝ 2 0 ⎟⎠ Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 34/66 3.4. Further examples 3.4.1. The three-qubit flip code [3,1,1] As developed above, the three-qubit code consists of the generators at the right. X and Z are the X and Z operators transformed to the code space. They are usually also included in the stabilizer table because they also belong to N(S) among with g1 and g2. Error recovery for this code is done as already explained in a previous section. g1 Z Z I g2 I Z Z X Z X Z X Z X Z Figure 3.3. Stabilizer table for the three-qubit code (right) 3.4.2. The nine-qubit Code [9,1,3] Here again the complete stabilizer table for Shor’s nine-qubit code: g1 Z Z I I I I I I I g2 I Z Z I I I I I I g3 I I I Z Z I I I I g4 I I I I Z Z I I I g5 I I I I I I Z Z I g6 I I I I I I I Z Z g7 X X X X X X I I I I I I X X X X X X X X X X X X X X X X Z Z Z Z Z Z Z Z Z Z g8 Figure 3.4. Stabilizer table for the nine-qubit code 3.4.3. The five-qubit code [5,1,3] But what is the minimum size of a quantum code, which protects a single qubit among any single errors. As we will see in a later section the answer is the five-qubit code. You might think now, that this is the most important code, but due to its complexity it is not used very often. Let’s have a look at its the stabilizer table: g1 X g2 Z Z X I I X Z Z X g3 X I X Z Z Z X I X Z X X X X X X Z Z Z Z Z Z g4 Figure 3.5. Stabilizer table for the five-qubit code Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 35/66 From our knowledge about the generators we can build the unnormalized base codewords very easily. For 0 L we just make a summation over all elements of the stabilizer groups S multiplied with 00000 . For 1L we just transfer 0 L by X which flips every qubit. The base code words of the five-qubit looks than like: 0L = ∑ M 00000 M∈S = 00000 + M1 00000 + M2 00000 + M3 00000 + M4 00000 + M1 M2 00000 + M1 M3 00000 + M1 M4 00000 + M2 M3 00000 + M2 M4 00000 + M3 M 4 00000 + M1 M2 M3 00000 + M1 M2 M4 00000 + M1 M3 M4 00000 + M2 M3 M4 00000 + M1 M2 M3 M4 00000 = 00000 + 10010 + 01001 + 10100 + 01010 − 11011 − 00110 − 11000 − 11101 − 00011 − 11110 − 01111 − 10001 − 01100 − 10111 + 00101 1L = X 0 L = 11111 + 01101 + 10110 + 01011 + 10101 − 00100 − 11001 − 00111 − 00010 − 11100 − 00001 − 10000 − 01110 − 10011 − 01000 + 11010 The very complex encoding circuit of the five-qubit code is presented below. Understanding this circuit would requires dozens of pages of calculations. So just enjoy having a look at it: Ψ 0 0 0 0 Figure 3.6. Five-qubit code – encoding circuit Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 36/66 3.5. Calderbank-Shor-Steane (CSS) codes The Calderbank-Shor-Stean codes or simply CSS codes are a subclass of the stabilizer codes. They allow to construct quantum error correction codes from classical linear codes. Taking a classical parity check matrix P, we can construct a quantum code, correcting X errors, just by replacing every 1 by Z and putting I’s elsewhere. The same can be done with a second parity check matrix Q. To detect Z errors, we just have to place X’s instead of Z’s in the generators. We can combine these codes if the derived generators commute. This is true if the rows of P and Q are orthogonal. This means that the dual code of each code must be a subset of the other code. Such a combined code of P [n,k1,d1] and Q [n,k2,d2] is a CSS(P,Q) [n, |k1-k2|,d3] code with d3 = min{d1,d2}. 3.5.1. The Steane seven-qubit CSS code [7,1,3] The most popular example of a CSS code is the seven-qubit Steane code. It is created from the classical Hamming code [7,4,3] which is self dual. An explanation of classical Hamming codes and self duality is behind the scope of this paper but can be find in every good book about classical linear codes. For our example we take for P the parity check matrix H: ⎡0 0 0 1 1 ⎢ H = ⎢0 1 1 0 0 ⎢⎣ 1 0 1 0 1 1 1⎤ ⎥ 1 1⎥ 0 1⎦⎥ And for Q the transposed of its generator G: ⎡1 ⎢0 T G =⎢ ⎢0 ⎢0 ⎣ Rainer Baumann, ETH Zurich 2003 [email protected] 0 0 0 0 1 0 0 1 0 1 0 1 0 0 1 1 1 1⎤ 0 1⎥ ⎥ 1 0⎥ 1 1⎥⎦ Quantum Error Correction 37/66 After reducing all dependent generators and bringing them up in standard form we end up with the following stabilizer table and base codewords: ⎞ ⎟ ⎟ ⎟ ⎠ g1 I ⎛ 1111111 + 0101010 + 1001100 ⎞ 1 ⎜ ⎟ 1L = + 0011001 + 1110000 + 0100101 ⎟ ⎜ 8⎜ ⎟ ⎝ + 1000011 + 0010110 ⎠ g5 0L ⎛ 0000000 + 1010101 + 0110011 1 ⎜ = + 1100110 + 0001111 + 1011010 8 ⎜⎜ ⎝ + 0111100 + 1101001 I I X X X X g2 I X X I I X X g3 X I X I X I X g4 I I I Z Z Z Z I Z Z I I Z Z g6 Z I Z I Z I Z X X X X X X X X Z Z Z Z Z Z Z Z Figure 3.7. Stabilizer table for the seven-qubit code (right) The encoding circuits looks like this: Ψ 0 0 0 0 0 0 Figure 3.8. Stean seven-qubit code (a CSS code) – encoding circuit Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 38/66 Error correction for CSS codes is very easy because the generators gi does not mix up X’s and Z’s. So we can correct the flip and phase error separately with the same correction circuit in different basis. Figure 3.9. CSS code – error correction circuit 0 0 0 Figure 3.10. Stean seven-qubit code – error correction circuit Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 39/66 3.6. Standard form for a stabilizer code Probably you already noticed that the choice of generators is not at all unique. We can always replace a generator gi with gigj for some other generator gj. The goal of this paragraph is to develop a unique representation of the stabilizer. But first we have to learn how to write a stabilizer in a binary vector form. Till now, we wrote all the X’s and Z’s in the same matrix. Now we separate them in two separate ones, writing them next to each other delaminating them by a line in the middle. Then we replace all the I’s and empty places with 0’s and the X’s and Z’s with 1’s. For the five-qubit code this would look like this: ⎛1 ⎜0 ⎜ ⎜1 ⎜ ⎝0 0 1 0 1 0 0 1 0 1 0 0 1 00 10 00 01 1 0 0 0 1 1 0 0 0 1 1 0 0⎞ 0⎟⎟ 1⎟ ⎟ 1⎠ To bring such a binary vector in a standard form, we first have to bring it in the following shape with Gaussian elimination: ⎛ I A B C⎞ ⎜ ⎟ ⎝ 0 0 D E⎠ For our example this would look like: ⎛1 ⎜ ⎜0 ⎜0 ⎜ ⎜0 ⎝ 0 1 0 0 0 0 1 0 1 0 0 1 00 10 11 11 1 0 1 0 1 1 1 1 0 1 0 1 0⎞ ⎟ 0⎟ 0⎟ ⎟ 1 ⎟⎠ Then we perform another Gaussian elimination on E to get: ⎛ I A1 ⎜ ⎜⎜ 0 0 ⎝0 0 A2 B 0 D1 0 D2 C1 C2 ⎞ ⎟ I E2 ⎟ ⎟ 0 0⎠ Our example does not need any further elimination because D and E do not exist. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 40/66 The generators in the first row will not commute with them in the third unless D2=0, which really implies that S=0. So we can omit the last line finally getting the standard form. ⎛ I A1 ⎜ ⎝0 0 A2 B C1 C2 ⎞ ⎟ 0 D I E⎠ 3.7. Encoding, decoding, measuring and correcting One of the great advantages of the standard form of the stabilizer formalism is the ability for systematic construction for encoding and decoding. 3.7.1. Encoding and decoding For this systematic approach we need the so called Z and X operations. We have to pick k operators independently of the generators commuting with them and all other operators. But they can easily be determined from the standard form: ( X = (0E Z = 000 A2 0I T T ) I CT 00 ) ⊗n state, measure all We can now prepare the system in an 0 observables g1,…,gn-k,Z1,…,Zk and fix the system with the Pauli operators. Once this is prepared we can change it to any arbitrary encoded computational basis state. There is also a much more complex way how such an encoding can be done directly, which we will not discus. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 41/66 3.7.2. Measuring and correcting As in section 1.2 explained, there exists a clever gate, measuring single qubit operators M with eigenvalues ±1, using controlled-M operations, two Hadamard gates and an ancilla. Having this eigenvalues it is not a great thing anymore to make the corrections with the corresponding Pauli matrices. So to measure the seven-qubit Stean code you can use the following circuit: 0 0 0 0 0 0 Figure 3.11. Stean seven-qubit code – automatic constructed error detection circuit Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 42/66 3.8. Quantum error-correction without measurement Till now, for error-correction, we expected to measure an operator Mi and then executing conditionally the unitary operator Ui. But it is also possible, just to do this correction by unitary operations and ancillas without any measurement. This can be very useful in some systems when measurements are very undesirable. Prepare an ancilla system with basis state i corresponding to the possible error syndromes. The ancilla starts in a standard pure state 0 before error-correction. Define an unitary operator U on the principal system plus ancilla: U Ψ 0 ≡ ∑ (U i M i Ψ ) i i The effect of U is to effect the transformation R(σ ) = ∑ U i M iσM i+U i+ i on the system being corrected, exactly the same quantum operation as performed while common error correction. For the nine-qubit Shor code, error-correction without measurement is very intuitive. The decoding and correcting circuit would look like: Ψ Figure 3.12. Shor nine-qubit code – error correction circuit without measurement Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 43/66 4. Fault-tolerant quantum computation One of the most powerful applications of quantum error-correction is not the protection of stored or transmitted quantum information, but the protection of quantum information as it dynamically undergoes computation. This is very important because quantum gates are not at all as reliable as classical ones and the possible errors are much more complex. Assume we want to execute Shor’s factoring algorithm. Although it takes polynomial time in the size of the input, for reasonable numbers, it would still take millions of dependent calculations. Combined with the error rate of the gates, we would never get any useful result. Because of this it was believed for a long time that quantum computation is just a useless dream. But with Quantum error correction we are able to construct fault-tolerant quantum gates, due to which we can solve this problem. 4.1. Basics of fault-tolerant quantum computation Our goal is to construct a quantum computer, which still produces useful results despite of error influences. Unfortunately noise and errors occur in every unit of a quantum computer beginning at state preparations over gates and measurements up to simple transmissions. To fight this problem, we replace every qubit with the encoded block of it and the other units with their fault-tolerant analogs. 4.1.1. Error model Assume a single qubit has been flipped and we use this qubit as the control qubit for a controlled-NOT. Like this the error will propagate on the target qubit as well. Even worse, in concatenated states a phase error can propagate backwards on the other qubits in the same block. So we must correct such errors as fast as possible before they affect the whole system. By performing error-correction periodically after every step we prevent errors to propagate. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 44/66 4.2. Fault-tolerant procedure Let us define the fault-tolerance of a procedure to be the property that if only one component fails then the failure causes at most one error on each encoded qubit block. Furthermore, we require that if only one component fails then the measurement result reported must have a error probability O(p2), with p the maximum failure probability over all components. Like this we ensure that, in such an component, a single error is isolated and does not affect any other qubits. A component is an independent building unit after which error correction can be done like a quantum gate, a measurement or a state preparation. 4.3. Fault-tolerant gates Assume you want to execute an X gate on a qubit which is encoded in seven qubits. Then we denote this by a line over it like X . Note that such gates act on a particular code and usually can not be applied on other codes. Below we will focus on the popular seven-qubit Stean code. We need to construct a universal set of fault-tolerant quantum gates to be able to perform all desired operations. 4.3.1. Fault-tolerant Pauli gates In the stabilizer section, we have already described the implementation of the X and Z gate for the Steane code: X = X1 X 2 X 3 X 4 X5 X 6 X7 ; Z = Z1 Z2 Z3 Z4 Z5 Z6 Z7 . Out of them it is very easy to build a Y = X Z gate. We called this kind of implementation bitwise, because we just can apply the desired operation on every single qubit of a code block. It is obvious that a single error, occurring on one qubit just before the operation or in one of the single gates like X2, does not propagate any further, because there is no information exchange between the qubits. So every encoded gate implemented in bitwise fashion is automatically fault-tolerant. This property is called transversality. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 45/66 Figure 4.1. Fault tolerant gates: X (left), Z (middle), Y (right) 4.3.2. Fault-tolerant Hadamard An encoded Hadamard gate H should interchange X and Z under conjugation, just as the Hadamard gate interchanges Z and X. So the encoded Hadamard can be implemented as H = H1 H2 H3 H4 H5 H6 H7 . It is obvious that a single error, occurring on one qubit just before the operation or in one of the Hi’s, does not propagate any further, because there is no information exchange between the qubits. Figure 4.2. Fault tolerant Hadamard gates (right) 4.3.3. Fault-tolerant phase gate Implementing the phase gate S is a bit trickier. When we look at the table in section 3.3, we see that under conjugation S should take Z to Z and X to Y = iX Z . But a bitwise implementation of S would take Z to Z and X to − Y . The minus sign can be fixed with a Z operator in front. Like this we can implement S transversaly by applying ZS to every single qubit. Figure 4.3. Fault tolerant phase gates (right) Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction Z S Z S Z S Z S Z S Z S Z S 46/66 4.3.4. Fault-tolerant CNOT Let’s have a look at the CNOT gate next. The important question is, would a bitwise implementation violate the fault-tolerance. No. A CNOT involves two different blocks and one error in one block only results in one error in the same block. The error is propagated to one qubit in the other block but this does not violate our definition of fault-tolerance. Figure 4.4. Fault tolerant CNOT gates 4.3.5. Fault tolerant π/8 gate For the complete set of universal gates we lack of the implementation of a non transversal gate as the π/8 or T gate, which is much more complex. It consists of three major steps: a) Prepare an ancilla, in base state, apply a Hadamard and then a non fault-tolerant T gate on it resulting in the state: Θ = TH 0 = T 0 +1 2 = 0 + e iπ / 4 1 2 b) Apply a CNOT on the prepared state Θ as control qubit and on the state we want to transform Ψ as target qubit. The system would result in the following state: ⎛ 0 + e iπ / 4 1 ⎞ ⎟ ⊗ (a 0 + b 1 CNOT12 Θ Ψ = CNOT12 ⎜ ⎜ ⎟ 2 ⎝ ⎠ 1 0 (a 0 + b 1 ) + e iπ / 4 1 (a 1 + b 0 ) = CNOT12 2 1 = a 0 + be iπ / 4 1 0 + b 0 + ae iπ / 4 1 1 2 [ [( Rainer Baumann, ETH Zurich 2003 [email protected] ) ] ) ( ) ] Quantum Error Correction 47/66 c) Now we have to measure the original qubit Ψ . Resulting 0, we are done, with 1 we have to apply SX on the originally ancilla qubit to bring it in the state T Ψ . For the whole thing to be fault-tolerant, we have to show that the three steps are fault-tolerant as well. Above we showed that a faulttolerant CNOT exists and for the measurement, we will show it in the next paragraph. But, what about the preparation? HT is an eigenstate of Z and while measuring SX we collapse the state in the desired state. Like this we don’t have to care about fault tolerance here. THZHT + = TXT + = e − iπ / 4 SX So we end up with the following circuit. Remember, the double line denotes a classical bit. TΨ 0 Ψ Figure 4.5. Fault tolerant π/8 gate 4.4. Fault-tolerant measurement Remember from section 1.3, how a general hermitian, unitary operator M is measured. (All tensors in Gn are hermitian and unitary.) One first could think, that we just have to bring M in a transversal form M’ and then measure bitwise with the same control ancilla. But such a measurement is not fault tolerant, because an error in the ancilla block would cause several data bits to be corrupted. A nice way how to avoid this problem is illustrated above. We prepare for every data qubit an ancilla in base state. Then we transform them to the so called ‘cat’ state with a Hadamard applied on the first of them and a CNOT with the first qubit as the control qubit and the other as the target. We then have to verify this state by measuring them in pair like in the three-qubit flip code form section 2. If the cat is fine we continue, otherwise we just start again from the beginning. Then we perform the controlled M’ operations bitwise. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 48/66 Finally we combine the so gained results with a CNOT controlled from the first ancilla qubit on the other ancillas. Finally we have to apply a Hadamard on the first ancilla to get the eigenvalue of M. The last part is fault-tolerant anyway, because no error could affect the data qubits any more. But the final measurement and the verification measurement of the cat state can be faulty itself with a certain probability. To reduce this error probability we just have to perform the whole measurement procedure several times and take the majority vote. Like this a fault-tolerant measurement with arbitrary small error can be constructed. 0 0 0 0 0 0 Figure 4.6. Fault tolerant measurement circuit 4.5. Fault-tolerant state preparation Now fault tolerant state preparation is very easy. You just prepare the desired state and execute a verification as described in the section fault-tolerant measurement before. If the state is fine, continue, otherwise start again. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 49/66 5. Concatenated theorem coding and threshold Encoding data using quantum error-correcting codes and applying fault-tolerant operations may also introduce new errors. So if the arbitrary error rate p of a component is to high we could do things even worse. It could be shown that the probability for a faulttolerant circuit to introduce two or more errors into a single block is at most cp2 for some constant c≈104. So the encoded procedure will succeed with probability 1-cp2. Assume p is small enough, e.g. p<10-4, there is a real benefit using this technology. But we would still have a failure probability of cp2. For an arbitrary long calculation as Shor’s factoring algorithm with millions of calculation this is not useable. The success probability for a n step calculation is (1-cp2n)n. Assume a million calculations with a failure probability p<10-4 than the success probability is already inexistent with <101000. Even repeating the same calculation several times and take the majority result want help anymore. 5.1. Concatenated codes Knill and Laflamme solved this problem by introducing the concatenated codes we met already in Shor’s nine-qubit code. A concatenated code encodes a set of k qubits with a [n,k,d] code. It than takes every obtained qubit and encodes it again using a [n1,1,d1], these qubits could be encoded again with a [n2,1,d2] code and so on indefinitely. For k concatenation, this results in a [nn1n2..nk,k,dd1d2..dk] code. A so concatenated code has a failure 2k probability of (cp ) / c . This increase of reliability is remarkable. We now can construct quantum error-correction codes with arbitrary failure probability. Like this, it will be possible to execute arbitrary long calculations on a quantum computer. If such codes are transversal the effort for measurements and corrections are minimal, as we saw in the previous section. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 50/66 The circuit below visualizes the idea of concatenated codes with depth 3: Ψ1 Ψ2 Ψk Figure 5.1. [nn1n2,k,dd1d2] concatenated code Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 51/66 5.2. The threshold theorem Suppose we want to calculate an arbitrary long calculation on a quantum computer with a failure probability cp per operation. For example the factoring algorithm. The execution of the algorithm takes P(n) gates, where P(n) is a polynomial function of the problem size n, achieving a final accuracy of ε. For this we have to concatenate our code k times such that: (cp )2 c k ≤ ε p(n) This gives us the sufficient condition p<pth≡1/c that a k can be found. With respect to the growth of a circuit we get the following theorem. Threshold theorem for quantum computation: A quantum circuit containing p(n) gates may be simulated with a error probability of at most ε using ⎛ ⎞ ⎛ log p(n ) ⎞ O⎜⎜ poly⎜ ⎟ • p(n ) ⎟⎟ ⎝ ε ⎠ ⎝ ⎠ gates on hardware whose components fail with probability at most p, provided p is below a constant threshold, p<pth, and given reasonable assumptions about the noise in the underlying hardware. [Nielsen & Chaung] pth depends mainly on the assumptions made about the computational capability. A conservative estimate gives pth≈10-4. This result was very important because it dispelled the doubts that no quantum computer could ever do arbitrary long calculation due to error accumulation. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 52/66 6. Bounds Theoreticians always try to make general statements over general bounds especially for proofs. An important characteristic of classical codes for such bounds does not held for quantum codes. In a classical code, an error is always distinguishable from an other. Lets take the nine-qubit Shor code and consider the effects of a Z1 and a Z2 error. They are absolutely the same and just shift the phase of the first three qubits. This degeneration is bad for bound proofing but one of the reasons for the power of quantum codes. 6.1. Quantum Hamming bound An interesting question is, which is the best possible quantum code. The quantum Hamming bound gives a simple formula for this. Assume a code encoding k qubits into n qubits with the potential to ⎛ n⎞ correct t errors. Suppose j≤t errors occur. So there are ⎜ ⎟ possible ⎝ j⎠ sets of error locations. A single error could be a X, Y or Z error resulting in 3j possibilities. In order to encode k qubits in a nondegenerate way each of these errors must correspond to an orthogonal 2k-dimensional space. The code space is 2n-dimensional what leads to the quantum Hamming bound inequality: t ⎛ n⎞ ∑ ⎜⎝ j ⎟⎠ 3 2 j k ≤ 2n j =0 E.g. for [n,1] codes we get the following specialization: 2(1 + 3n) ≤ 2n ; n ≥ 5 As with classical code, we can nearly reach this bound with random codes. But they are very hard to implement. A better class of perfect quantum codes reaching this bound are the Hamming codes over GF(4). Although the quantum hamming bound is only for non-degenerative codes, it works very well for degenerative ones as well. No degenerative code is yet known, which brakes this bound. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 53/66 6.2. Quantum Gilbert-Varshamov bound For quantum non-degenerative distance codes, it is generally not possible to reach the quantum Hamming bound but another. Assume a [n,k,d] code with j error occurring. The GilbertVarshamov Bound says, that we can always find a distance d quantum code encoding k qubits in n qubits satisfying: d −1 ⎛ n⎞ ∑ ⎜⎝ j ⎟⎠ 3 2 j k ≥2 n j =0 6.3. Quantum singleton / Knill-Laflamme bound For degenerated [n,k,d] quantum codes which are able to correct errors on any t qubits must follow the following bound: n ≥ 4t + k Especially this limits the minimal size of a quantum code resolving any arbitrary single error to n ≥ 4 + 1 = 5 . We already saw a code which accomplishes this bound, the five-qubit code. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 54/66 7. Simulations and statistics 7.1. Trace distance and fidelity Distances describe how far two code words are away from each other. This means how many single errors are required at minimum to transfer a code word into another. So far we met the trace distance d between to quantum states: D (ρ , σ ) = 1 tr ρ − σ 2 The fidelity is an other distance metric which is not so obvious but it has some very nice characteristics in which we cannot go in here. It is defined as: F (ρ , σ ) ≡ tr ρ 1 / 2σρ 1 / 2 7.2. Simulations In this section we summarize the most important results from J. Niwa’s and K. Matsumoto’s paper ‘Simulating the Effects of Quantum Error Correction Schemes’. For more detailed information you’ll find a link to the online version in the references. Simulations and calculations of hardware error behavior correlated with quantum error correcting codes is very important to build a useable quantum computer. In the chart below QECC/X means that error-correction is done every X gates. The y-axis in the figure shows the fidelity and the xaxis the number of Hadamard transformations. It’s interesting that not always a higher frequency of error-correction is effectively better. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 55/66 Figure 7.1. Simulation results – error correction frequency Simulation shows that the seven-qubit code, with a decoherence probability p<10-4 and error-correction every 50~200 gates, is very effective. But for p<10-3 there is no error-correction rate which is nearly useable. We also see that for p<10-5 the differences between the different ratios are not very large. Below the effects of operational errors with a standard deviation of σ<10-3 and σ<10-2 is shown. It can be seen that for arbitrary long computation a standard deviation of σ<10-3 is clearly required. Figure 7.2. Simulation results – operational error frequency We learn that quantum computing hardware should have a decoherence ratio of p<10-4 and an operational error ratio of σ<10-3 for real world applications. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 56/66 7.3. Comparison of basic codes Comparison among the nine-qubit, seven-qubit and five-qubit codes. Depth of error-correcting circuits. [9,1,3] [7,1,3] [5,1,3] Encoder 5 4 10 (Decoder) Syn. Measurement 2 28 22 and recovery The number of (minimum) required qubits. [9,1,3] [7,1,3] [5,1,3] Qubits 9 4 6 Transversal operations implementation. [9,1,3] [7,1,3] [5,1,3] Hard Easy hard Simulations among these three codes have shown that the sevenqubit code is the most effective one. The bad results of the fivequbit code can mainly be explained by it’s complexity. Figure 7.3. Simulation results – code comparison Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 57/66 8. Summary of most important topics • • • • • Quantum error-correction code: An [n,k,d] quantum errorcorrection code uses n qubits to encode k qubits, with distance d. Quantum error-correction conditions: Let C be a quantum error-correcting code and P be the projector onto C. Then the + code can correct the error set {Ej} if and only if PEi E j P = αij P for some Hermitian matrix α of complex numbers. Stabilizer codes: Let S be the stabilizer for a stabilizer code C(S) and suppose {Ej} is a set of errors on the Pauli group + such that E j Ek ∉ N(S) − S for all j and k. Then {Ej} is a correctable set of errors for the code C(S). Fault-tolerant quantum computation: A universal set of logical operations on encode quantum states can be performed in such a way that the effective failure probability in the underlying gates. The threshold theorem: Provide the noise in individual quantum gates is below a certain constant threshold and obeys certain physically reasonable assumptions; it is possible to reliably perform an arbitrarily long quantum computation, with only a small overhead in the size of the circuit necessary to ensure reliability. Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 58/66 A. Appendix A.1. Non-cloning theorem Non-cloning theorem: It is not possible to copy an arbitrary quantum state. Proof: Assume we want to clone/copy the following state Ψ = a 0 + b 1 . The result should be Ψ = a 00 + b 11 . But a multiplication for two general state obeys the following role: Ψ Ψ = a 2 00 + ab 01 + ab 10 + b 2 11 So a or b must be zero. This would no longer be an arbitrary quantum state. B. Appendix - Quantum codes Today hundreds of quantum codes are known. In this section below, an overview over the stabilizers of the most important quantum codes is given. Also some codes with distance more than one are presented for the interested reader. B.1. Distance one quantum codes B.1.1. Three-qubit code [3,1,1] g1 Z I Z Z X Z X Z X Z X Z g2 Z I B.1.2. Fife-qubit code [5,1,3] Rainer Baumann, ETH Zurich 2003 [email protected] g1 X Z Z X I g2 I X Z Z X g3 X I X Z Z g4 Z X I X Z X X X X X X Z Z Z Z Z Z Quantum Error Correction 59/66 B.1.3. Seven-qubit code [7,1,3] g1 I I I X X X X g2 I X X I I X X g3 X I X I X I X I I I Z Z Z Z g5 I Z Z I I Z Z Z I Z I Z I Z g4 g6 X X X X I I I I Z Z Z Z I I I I B.1.4. Eight-qubit code [8,1,3] g1 X X X X X X X X g2 Z Z Z Z Z Z Z Z g3 I X I X Y Z Y Z g4 I X Z Y I X Z Y I Y X Z X Z I Y X1 X X I I I Z I Z X2 X I X Z I I Z I X3 g5 X I I Z X Z I I Z1 I Z I Z I Z I Z Z2 I I Z Z I I Z Z Z3 I I I I Z Z Z Z B.1.5. Nine-qubit code [9,1,3] g1 Z Z I I I I I I I g2 I Z Z I I I I I I g3 I I I Z Z I I I I g4 I I I I Z Z I I I g5 I I I I I I Z Z I g6 I I I I I I I Z Z g7 X X X X X X I I I g8 I I I X X X X X X X X X X X X X X X X Z Z Z Z Z Z Z Z Z Z Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 60/66 B.2. Distance two quantum codes B.2.1. [4,2,2] code g1 X Z Z X Y X X Y X1 X X X X X2 X I X Z X3 Y Z Y I I X Z Z g2 X4 B.2.2. [11,1,5] code g1 Z Z Z Z Z Z I I I I I g2 X X X X X X I I I I I g3 I I I Z X Y Y Y Y X Z g4 I I I X Y Z Z Z Z Y X g5 Z Y X I I I Z Y X I I g6 X Z Y I I I X Z Y I I g7 I I I Z Y X X Y Z I I g8 I I I X Z Y Z X Y I I g9 Z X Y I I I Z Z Z X Y g10 Y Z X I I I Y Y Y Z X X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z B.3. Distance three quantum codes B.3.1. [16,10,3] code g1 I X I X I X I X Z Y Z Y Z Y Z Y g2 I X I X Z Y Z Y X I X I Y Z Y Z g3 I X Z Y X I Y Z I X Z Y X I Y Z g4 I Y X Z I Y X Z I Y X Z I Y X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 61/66 B.4. Distance four quantum codes B.4.1. [16,6,4] code g1 I X I X I X I X Z Y Z Y Z Y Z Y g2 I X I X Z Y Z Y X U X U Y Z Y Z g3 I X Z Y X I Y Z Y X Z Y X I Y Z g4 I Y X Z I Y X Z I Y X Z I Y X Z n1 n2 I Z I Z I Z I Z X Y X Y X Y X Y I Z I Z X Y X Y Z I Z I Y X Y X I Z X Y Z I Y X I Z X Y Z I Y X I Y Z X I Y Z X I Y Z X I Y Z X X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z X Z g1 g3 n3 n4 B.4.2. [8,0,4] code I X I X Y Z Y Z g2 I X Z Y I X Z Y I Y X Z X Z I Y n1 n2 I Z I Z Y X Y X I Z X Y I Z X Y I Y Z X Z X I Y X Z X Z X Z X Z X Z X Z X Z X Z n3 X Z Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 62/66 C. Figure Table Figure 1.1. Figure 1.2. Figure 1.3. Figure Figure Figure Figure Figure 1.4. 1.5. 1.6. 1.7. 1.8. Figure Figure Figure Figure 2.1. 2.2. 2.3. 2.4. Figure Figure Figure Figure Figure Figure Figure Figure Figure Figure Figure 3.1. 3.2. 3.3. 3.4. 3.5. 3.6. 3.7. 3.8. 3.9. 3.10. 3.11. Figure Figure Figure Figure Figure Figure 4.1. 4.2. 4.3. 4.4. 4.5. 4.6. Bit representation: classical bit (left), qubit (right) ........................6 Quantum gates .........................................................................6 Quantum gate representation for circuits: ....................................7 CNOT (left) and M gate (right) ....................................................7 Multiple controlled M gates .........................................................7 Quantum circuit to create entangled EPR state..............................8 Reversible XOR circuit................................................................9 Symbol for measurement ......................................................... 11 Measurement of general operator M .......................................... 11 The major elements of quantum error correction codes................ 16 Quantum bit flip channel .......................................................... 17 Three-qubit flip code - encoding circuit ...................................... 17 Three-qubit flip code - error detection and correction circuit with ZZ ............................................................................................. 21 Figure 2.5. Three-qubit flip code - error correction circuit with CNOT ............. 21 Figure 2.6. Three-qubit flip code - decoding circuit ...................................... 22 Figure 2.7. Quantum phase flip channel ..................................................... 22 Figure 2.8. Three-qubit phase flip code - encoding circuit ............................. 23 Figure 2.9. Three-qubit phase flip code - error correction circuit with CNOT .... 23 Figure 2.10. Nine-qubit code – encoding circuit............................................. 26 Figure 2.11. Nine-qubit code – error correction and decoding circuit ................ 27 Figure 2.12. Three-qubit code – error correction circuit.................................. 29 Extended stabilizer table for the nine-qubit code ......................... 31 Gate transformation table under unitary operations (right) ........... 34 Stabilizer table for the three-qubit code (right) ........................... 35 Stabilizer table for the nine-qubit code....................................... 35 Stabilizer table for the five-qubit code........................................ 35 Five-qubit code – encoding circuit ............................................. 36 Stabilizer table for the seven-qubit code (right) .......................... 38 Stean seven-qubit code (a CSS code) – encoding circuit .............. 38 CSS code – error correction circuit ............................................ 39 Stean seven-qubit code – error correction circuit......................... 39 Stean seven-qubit code –......................................................... 42 automatic constructed error detection circuit .............................. 42 Figure 3.12. Shor nine-qubit code – error correction circuit without measurement ............................................................................................. 43 Fault Fault Fault Fault Fault Fault tolerant tolerant tolerant tolerant tolerant tolerant gates: X (left), Z (middle), Y (right)....................... 46 Hadamard gates (right)........................................ 46 phase gates (right) .............................................. 46 CNOT gates ........................................................ 47 π/8 gate ............................................................. 48 measurement circuit ............................................ 49 Figure 5.1. [nn1n2,k,dd1d2] concatenated code.......................................... 51 Figure 7.1. Figure 7.2. Figure 7.3. Simulation results – error correction frequency ........................... 56 Simulation results – operational error frequency ......................... 56 Simulation results – code comparison ........................................ 57 Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 63/66 D. References D.1. Books • • • • • Quantum Computation and Quantum Information, M.A. Nielson and I.L. Chuang; Cambridge University Press 2000 Online Book, Meglicki and Wang, http://beige.ucs.indiana.edu/B679 INTRODUCTION TO QUANTUM COMPUTATION AND INFORMATION, Lo, Popescu, Spiller, World Scientific Quantum Computation: A Grand Mathematical Challenge for the Twenty-First Century and the Millennium, Samuel J. Lomonaco, Jr., American Mathematical Society Quantum Computation and Information, Samuel J. Lomonaco, Jr, Howard E. Brandt, American Mathematical Society D.2. Lecture Notes • • • • • • Information and Communication, Prof. Ueli Maurer, CS Department ETH Zurich Lecture notes on Quantum Computation, John Perskill, http://www.theory.caltech.edu/people/preskill/ph229/ Doris Ahanorov, Hebrew University, Jerusalem, Israel, http://www.cs.huji.ac.il/~doria/qcomp.huji2001.html Quantum Computing, G. Eric Moorhouse, http://everest.uwyo.edu/~moorhous/quantum/ Introduction to Quantum Informationprocessing, Waterloo University, http://www.iqc.ca/~qipcourse/ Quantum Computing Circuits, John Hayes und Igor Markov, http://vlsicad.eecs.umich.edu/Quantum/EECS598/ D.3. Papers Most papers for this topic are available under http://arxiv.org/abs/quant-ph. • • • • Stabilizer Codes and Quantum Error Correction, Daniel Gottesman, 2001, http://arxiv.org/abs/quant-ph/9705052 Concatenated Quantum Codes, E. Knill, R. Laflamme, http://arxiv.org/abs/quant-ph/9608012 Fault-tolerant quantum computation by anyones, A. Yu. Kitaev, http://arxiv.org/abs/quant-ph/9707021 A theory of Fault-tolerant Quantum Computation, Daniel Gottesman, http://arxiv.org/abs/quant-ph/9702029 Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 64/66 • • • • • • • • • • • • • • • • Fault-tolerant Quantum Computation, P.W. Shor, http://arxiv.org/abs/quant-ph/9605011 Reliable Quantum Computers, John Preskill, http://arxiv.org/abs/quant-ph/9705031 Multiple Particle Interference and Quantum Error Correction, Andrew Steane, http://arxiv.org/abs/quant-ph/9601029 Fault-tolerant Error Correction with Efficient Quantum Codes, D.P. DiVincenzo, P.W. Shor, http://arxiv.org/abs/quant-ph/ 9605031 Quantum Error Correction Via Codes Over GF(4), Calderbank, Rains, Shor, Sloane, http://arxiv.org/abs/quant-ph/9608006 Good quantum error-correcting codes exist, Calderbank, Shor, http://arxiv.org/abs/quant-ph/9512032 Quantum Error Correction and Orthogonal Geometry, Calderbank, Rains, Shor, Sloane, http://arxiv.org/abs/quantph/9605005 A class of Quantum Error-Correcting Codes Saturating the Quantum Hamming Bound, Daniel Gottesman, http://arxiv.org/abs/quant-ph/9604038 Accuracy Threshold for Quantum Computation, Knill, Laflamnme, Zurek, http://arxiv.org/abs/quant-ph/9610011 Threshold Estimate for Fault Tolerant Quantum Computing, Zalka, http://arxiv.org/abs/quant-ph/9612028 Active stabilization, quantum computation and quantum state synthesis, A.m. Steane, http://arxiv.org/abs/quantph/9611027 A Theory of Quantum Error-Correcting Codes, Knill, Laflamme, http://arxiv.org/abs/quant-ph/9604034 Quantum Error-Correcting Codes Need Not Completely Reveal the Error Syndrome, P.W. Shor, http://arxiv.org/abs/quantph/9604006 Resilient Quantum Computation: Error Models and Thresholds, Knill, Laflamme, Zurekm, http://arxiv.org/abs/quantph/9702058 Simulating the Effects of Quantum Error Correction Schemes, J. Niwa, K. Matsumoto, http://arxiv.org/abs/quantph/0211071 Quantum Computing and Error Correction, A. M. Steane, http://arxiv.org/abs/quant-ph/0304016 D.4. Talks • Reliability Requirements For Quantum Computation, John Preskill, http://www.theory.caltech.edu/people/preskill/talks/13nov96. ps Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 65/66 D.5. More Material • • • Center for Quantum Computation, http://www.qubit.org/ Easy reading introduction to qc, Daniel Gottesman, http://www.cs.berkeley.edu/~gottesma/ Quantum Computing, Documenta Matematica, Peter W. Shorhttp://www.mathematik.unibielefeld.de/documenta/xvol-icm/00/Shor.MAN.html Rainer Baumann, ETH Zurich 2003 [email protected] Quantum Error Correction 66/66