Quantum Error Correction Codes Spring 2005 : EE229B Error Control Coding Milos Drezgic

Transcription

1 Quantum Error Correction Codes Spring 2005 : EE229B Error Control Coding Milos Drezgic Abstract This report contains the comprehensive explanation of some most important quantum error correction codes. After the brief corroboration of the quantum mechanical principles that govern any quantum mechanical process, we introduce stabilizer formalism and stabilizer codes for quantum error correction (QEC). As an interesting derivative from classical counterpart we also present Quantum Reed Muller codes and quantum BCH codes. 1 Introduction Quantum computers are currently jet only abstract devices with apparently great deal of potential. They are supposed to operate with qubits, the smallest peace of information whose mathematical interpretation has roots in an exact physical entity. For example: the orientation of electron or nuclear spin, a direction of photon polarization or the orientation of collective magnetization of ensemble of nuclei in some complex chemical solution. When we start thinking about the information as represented by some of these physical quantities susceptibility to errors dramatically changes in comparison to classical implementation of the bit of information. It is unlikely that quantum computers will ever reach the incredible reliability of classical computers, since digital computers guard against an error largely by being digital instead of analog. Theoretically repeated frequent measurement of the classical register can kick the bit back to the nearer of 0 or 1. This would prevent small errors from building up into larger errors, which are therefore very much reduced. However the same technique cannot be used in a quantum computer, since measuring the qubit would collapse the fine superposition between logical zero and logical one - the state space in which the qubit lives, to either of these states. Moreover the small interactions between the qubits and environment is a sort of continuous measurement of the system and as the quantum system grows in size, these interactions are harder and harder to ignore. The quantum system will decohere, lose its information, and begin to look like classical system. Interactions with the environment can reduce the effects of decoherence, but can not eliminate them entirely. Even if the basal error rate in a quantum computer can be reduced to some small value ɛ per unit time, after N time steps, the probability of surviving without an error is only (1 ɛ) N, which decreases exponentially with N. Even if an algorithm runs in polynomial time on an error-free computer, it will require exponentially many runs on a real computer unless something can be done to control the errors. Classical error-correction techniques cannot be directly carried over to quantum computers for two reasons. First of all, the classical techniques assume we can measure all of the bits in the computer. For a quantum computer, this would destroy any entanglement between qubits. More importantly, a classical computer only needs to preserve the bit values of 0 and 1. A quantum computer also needs to keep phase information in entangled 1 states. Thus, while quantum error-correcting codes are related to classical codes, they require a somewhat new approach. 1 Entangled state on set of n qubits is the one that can not be decomposed as a product of states of subsets of n qubits 1

2 2 Quantum Mechanical Preliminaries The state of a classical computer is a string of 0s and 1s, which is a vector over the finite field Z 2. The state of a quantum computer or any quantum system is instead a vector over the complex numbers C. More precisely, a quantum state lies in a Hilbert space, with the inner product as appropriate metrics. The state is usually written ψ, which is called a ket. A classical computer with n bits has 2 n possible states, but this is only an n-dimensional vector space over Z 2. A quantum computer with n qubits is a state in a 2 n -dimensional complex vector space. For a single qubit, the standard basis vectors are written as 0 and 1. An arbitrary single-qubit state is then ψ = α 0 + β 1. (1) α and β are complex numbers, or sometimes called complex amplitudes that satisfy normalization condition: α 2 + β 2 = 1. Thus state ψ is called a normalized state. With multiple qubits, we can have states that cannot be written as the product of single-qubit states. For instance, φ = 1 2 ( ) (2) cannot be decomposed in this way. Such a state is said to be entangled. Entangled states are what provide a quantum computer with its power. They will also play a major role in quantum error correction. The particular state (2) is called an Einstein-Podalsky-Rosen pair or EPR pair, and serves as a useful basic unit of entanglement in many applications. If we make a measurement on the qubit in equation (1), we get a classical number corresponding to one of the basis states. The measurement disturbs the original state, which collapses into the basis state corresponding to the measurement outcome. If we measure the state (1), the outcome will be 0 with probability α 2, and it will be 1 with probability β 2. The normalization ensures that the probability of getting some result is exactly 1, however we will sometimes drop the normalization factors when convenient assuming that these states stand for the corresponding normalized states. The overall phase of a state vector has no physical significance. The measurement we made implements one of two projection operators, the projections on the basis 0, 1. This is not the only measurement we can make on a single qubit. In fact, we can project on any basis for the Hilbert space of the qubit. If we have multiple qubits, we can measure a number of different qubits independently, or we can measure some joint property of the qubits, which corresponds to projecting on some entangled basis of the system. Note that the projection on the basis 0, 1 for either qubit destroys the entanglement of the state (2), leaving it in a tensor product state. A particularly fruitful way to understand a quantum system is to look at the behavior of various operators acting on the states of the system. For instance, a nice set of operators to consider for a single qubit is the set of Pauli spin matrices X = ( ) 0 1, Y = 1 0 ( ) ( ) 0 i 1 0, and Z =. (3) i The original measurement described above corresponds to measuring the eigenvalue of Z. The corresponding projection operators are 1 2 (I ± Z). If we have a spin-1/2 particle, this measurement is performed by measuring the spin of the particle along the z axis. We could also measure along the x or y axis, which corresponds to measuring the eigenvalue of X or Y. The projections are 1 2 (I ± X) and 1 2 (I ± Y ). We can also make measurements of more general operators, provided they have real eigenvalues. A matrix A has real eigenvalues iff it is Hermitian: A = A, where A is the Hermitian 2

3 adjoint (or just adjoint), equal to the complex conjugate transpose. Note that all of the Pauli spin matrices are Hermitian. The Pauli matrices also satisfy an important algebraic property they anticommute with each other. That is, {σ i, σ j } = σ i σ j + σ j σ i = 0 (4) whenever σ i σ j and σ i, σ j {X, Y, Z}. Another possible relationship between two operators A and B is for them to commute. That is, [A, B] = AB BA = 0. (5) It is possible for two matrices to neither commute nor anticommute, and, in fact, this is the generic case. Two commuting matrices can be simultaneously diagonalized, and thus we can measure the eigenvalue of one of them without disturbing the eigenvectors of the other. Conversely, if two operators do not commute, measuring one will disturb the eigenvectors of the other, so we cannot simultaneously measure non-commuting operators. There is a natural complex inner product on quantum states. Given an orthonormal basis ψ i, the inner product between α = c i ψ i and β = d i ψ i is α β = c i d j ψ i ψ j = c i d i. (6) Each column ket ψ corresponds to a row bra ψ vector and the Hermitian adjoint is the adjoint with respect to this inner product, so U ψ corresponds to ψ U. The operator ψ φ acts on the Hilbert space as follows: ( ψ φ ) α = φ α ψ. (7) The inner product can reveal a great deal of information about the structure of a set of states. For instance, ψ φ = 1 if and only if ψ = φ. Eigenvectors of a Hermitian operator A with different eigenvalues are automatically orthogonal: ψ A φ = ψ (A φ ) = λ φ ψ φ = ( ψ A) φ = λ ψ ψ φ. (8) Since the eigenvalues of A are real, it follows that ψ φ = 0 whenever λ φ λ ψ. Conversely, if ψ φ = 0, there exists a Hermitian operator for which ψ and φ are eigenvectors with different eigenvalues. We often want to consider a subsystem A of a quantum system B. Since A may be entangled with the rest of the system, it is not meaningful to speak of the state of A. If we write the state of B as ψ i φ i, where ψ i is an orthonormal basis for B A, and φ i are possible states for A, then to an observer who only interacts with the subsystem A, the subsystem appears to be in just one of the states φ i with some probability. A is said to be in a mixed state as opposed to the pure state of a closed system in a definite state. We can extend the formalism to cover mixed states by introducing the density matrix ρ. For a pure system in the state ψ, the density matrix is ψ ψ. The density matrix for the subsystem for the entangled state above is φ i φ i. Density matrices are always positive and have Tr ρ = 1. To find the density matrix of a subsystem given the density matrix of the full system, simply trace over the degrees of freedom of the rest of the system. Given a closed quantum system, time evolution preserves the inner product, so the time evolution operator U must be unitary. That is, U U = UU = I. An open system can be described as a subsystem of a larger closed system, so the evolution of the open system descends from the global evolution of the full system. Time evolution of the subsystem is described by some superoperator acting on the density matrix of the subsystem. 3

4 ( ) 1 0 Identity I = I a = a 0 1 ( ) 0 1 Bit Flip X = X a = a ( ) 1 0 Phase Flip Z = Z a = ( 1) a a 0 1 ( ) 0 i Bit & Phase Y = = ixz Y a = i( 1) a a 1 i 0 Table 1: The Pauli matrices and the way they act on the states One fact about quantum states that has profound implications for quantum computation is that it is impossible to make a copy of an arbitrary unknown quantum state. This is known as the No Cloning Theorem, [6] and is a consequence of the linearity of quantum mechanics. The proof is straightforward: Suppose we wish to have an operation that maps an arbitrary state ψ ψ ψ.then arbitrary φ is mapped by φ φ φ as well. Because the transformation must be linear, it follows that However, ψ + φ ψ ψ + φ φ. (9) ψ ψ + φ φ ( ψ + φ ) ( ψ + φ ), (10) so we have failed to copy ψ + φ. In general, if we pick an orthonormal basis, we can copy the basis states, but we will not have correctly copied superpositions of those basis states. We will instead have either measured the original system and therefore destroyed the superposition, or we will have produced a state that is entangled between the original and the copy. This means that to perform quantum error correction, we cannot simply make backup copies of the quantum state to be preserved. 3 Quantum Error Correction Codes 3.1 Basic Example Unfortunately, the well-developed theory of classical error-correcting codes, cannot be applied directly to protect quantum mechanical information. Generally speaking a quantum error can be any 2 2 unitary matrix. It comes natural then to look at set of Pauli matrices as they span the space on 2 2 unitary matrices. This property makes them very important in the analysis of error correction process and thus each one of them has its own name and is defined as follows in table 1. They also have a nice property that they form a group called Pauli group since: X, Y, and Z anticommute, i.e. XZ = ZX, and similarly {X, Y } = 0 and {Y, Z} = 0. Thus, the n-qubit Pauli group P n consists of the 4 n tensor products of I, X, Y, and Z, and an overall phase of ±1 or ±i, for a total of 4 n+1 elements. It is important to note that the global phase for the arbitrary state psi is unimportant and can be discarded where as if we drop the phase of the operators in Pauli group we would lose its quite important property that it is not an Abelian group. Another nice algebraic property that is quite useful is that any pair of elements of P n either commute or anticommute. Also, the square of any element of P n is ±1. We shall only need to work with the elements with square +1, which are tensor products of I, X, Y, and Z with an overall sign ±1; the phase i is only necessary to make P n a group. We can now define the weight of an operator in P n to be the number of tensor factors which are not I. Thus, X Y I has weight 2. As explained earlier we can not use repetition code to protect arbitrary quantum state ψ due to No Cloning Theorem forbids 4

5 the tensor product state : ψ ψ ψ. To solve these problems, we will try a variant of the repetition code [9]. 0 0 = ( ) ( ) ( ) (11) 1 1 = ( ) ( ) ( ) (12) Note that this does not violate the No-Cloning theorem, since an arbitrary codeword will be a linear superposition of these two states α 0 + β 1 [α( ) + β( )] 3. (13) The superposition is linear in α and β. The complete set of codewords for this or any other quantum code form a linear subspace of the Hilbert space, the coding space. The inner layer of this code corrects bit flip errors: We take the majority within each set of three, so 010 ± ± 111. (14) The outer layer corrects phase flip errors: We take the majority of the three signs, so ( )( )( ) ( )( )( ). (15) Since these two error correction steps are independent, the code also works if there is both a bit flip error and a phase flip error. Note that in both cases, we must be careful to measure just what we want to know and no more, or we would collapse the superposition used in the code. The way we do this in general is, introducing some extra qubits ancilla qubits, that are initialized to 0 and record what type of error occurred. Then we measure the ancilla qubits without disturbing the state and invert the error sindrome we learned about from ancilla qubits: Z ( α 0 + β 1 ) 0 anc Z ( α 0 + β 1 ) Z anc ( α 0 + β 1 ) Z anc (16) I ( α 0 + β 1 ) 0 anc I ( α 0 + β 1 ) noerror anc ( α 0 + β 1 ) noerror anc (17) For instance when the actual error is: R θ/2 = cos θ 2 I i sin θ 2 ancilla gives us a superposition: Z, recording the error in the cos θ 2 I ( α 0 + β 1 ) noerror anc i sin θ 2 Z ( α 0 + β 1 ) Z anc, (18) and then by measuring the ancilla, with probability sin 2 θ/2 we get Z ( α 0 + β 1 ) Z anc, and with probability cos 2 θ/2 we end up with I ( α 0 + β 1 ) noerror anc. In each case, inverting the error indicated in the ancilla restores the original state. So far, we have only considered individual unitary errors that occur on the code. But we can easily add in all possible quantum errors. The most general quantum operation, including decoherence, interacts the quantum state with some extra qubits via a unitary operation, then discards some qubits. This process can turn pure quantum states into mixed quantum states, which are normally described using density matrices. Density matrix ρ is a completely positive stochastic matrix that tells us with what probability we are in any of possible pure states and thus Trρ = 1, since pure states probabilities are on the diagonal. We can write the most general operation as a transformation on density matrices ρ i E i ρe i, (19) where the E i s are normalized so E i E i = I. The density matrix ρ can be considered to represent an ensemble of pure quantum states ψ, each of which, in this case, should be in 5

6 the coding space of the code. Then this operation simply performs the following operation on each ψ : ψ E i ψ with probability E i ψ 2. If we can correct each of the individual errors E i, then we can correct this general error as well. For instance, for quantum operations that only affect a single qubit of the code, E i will necessarily be in the linear span of I, X, Y, and Z, so we can correct it. In general it is not unreasonable to expect that every qubit in our nine-qubit code will be undergoing some small error. For instance, qubit i experiences the error I + ɛe i, where E i is some single-qubit error. Then the overall error is ( ) i (I + ɛe i ) = I + ɛ E 1 I 8 + I E 2 I O(ɛ 2 ) (20) That is, to order ɛ, the actual error is the sum of single-qubit errors, which we know the nine-qubit code can correct. That means that after the error correction procedure, the state will be correct up to O(ɛ 2 ) when the two-qubit error terms begin to become important. While the code cannot completely correct this error, it still produces a significant improvement over not doing error correction when ɛ is small. 3.2 General properties of QECC Regardless of code we use there is a sufficient condition for abilily to distinguish error E from error F, when they act on 0 and 1. The perturbed states E 0 and F 1 should stay orthogonal: 0 E F 1 = 0. (21) Then a measurement will tell us exactly what the error is and we can correct it: 0 E F 0 = 1 E F 1 = 0 (22) for E F. To understand necessary condition for any code we can look at the nine-qubit code. We cannot distinguish between Z 1 and Z 2, but we can correct either one with a single operation, so still good. However, if we look at the operators F 1 = (Z 1 + Z 2 )/2 and F 2 = (Z 1 Z 2 )/2, we see that F 1 and F 2 span the same space as Z 1 and Z 2, so Shor s ninequbit code certainly corrects them. This is true since if we use the F s as the basis errors, equation (22) is satisfied. That means we can make a measurement and learn what the error is. But we also have to invert it, and this is a potential problem, since F 1 and F 2 are not unitary. However, F 1 acts the same way as Z 1 on the coding space, so Z 1 suffices to invert F 1 on the states of interest. F 2 acts the same way as the 0 operator on the coding space. We can t invert this, but we don t need to since F 2 annihilates codewords, it can never contribute a component to the actual state of the system. Thus the necessary condition to invert the errors is that error is such that it is either nonzero, as for F 1, in which case some unitary operator will act the same way as E on the coding space, or it will be zero, as for F 2, in which case E annihilates codewords and never arises. Mathematically the necessary condition is: 0 E E 0 = 1 E E 1. (23) These arguments show that if there is some basis for the space of errors for which equations (21), (22), and (23) hold, then the states 0 and 1 span a quantum error-correcting code. Massaging these three equations together and generalizing to multiple encoded qubits, we get the following theorem [2, 7]: Theorem 1 Suppose E is a linear space of errors acting on the Hilbert space H. Then a subspace C of H forms a quantum error-correcting code correcting the errors E iff ψ E E ψ = C(E) (24) for all E E. The function C(E) does not depend on the state ψ. 6

7 Proof: suppose {E a } is a basis for E and { ψ i } is a basis for C. By setting E and ψ equal to the basis elements and to the sum and difference of two basis elements (with or without a phase factor i), we can see that (24) is equivalent to ψ i E ae b ψ j = C ab δ ij, (25) where C ab is a Hermitian matrix independent of i and j. Suppose equation (25) holds. We can diagonalize C ab. This involves choosing a new basis {F a } for E, and the result is equations (21), (22), and (23). The arguments before the theorem show that we can measure the error, determine it uniquely (in the new basis), and invert it (on the coding space). Thus, we have a quantum error-correcting code. Now suppose we have a quantum error-correcting code, and let ψ and φ be two distinct codewords. Then we must have ψ E E ψ = φ E E φ (26) for all E. That is, (24) must hold. If not, E changes the relative size of ψ and φ. Both ψ + φ and ψ + c φ are valid codewords, and where N is a normalization factor and E( ψ + φ ) = N( ψ + c φ ), (27) c = ψ E E ψ / φ E E φ. (28) The error E will actually change the encoded state, which is a failure of the code, unless c = 1. Q.E.M It is important to note that in phrasing of equation (24) we require E to be a linear space of errors, which means that it must be closed under sums of errors which may act on different qubits. In contrast, for a code that corrects t errors, in (25), it is safe to consider only E a and E b acting on just t qubits. We can restrict even further, and only use Pauli operators as E a and E b, since they will span the space of t-qubit errors. This leads us to a third variation of the condition: ψ E ψ = C (E), (29) where E is now any operator acting on 2t qubits since, it replaces E ae b in (25). This can be easily interpreted as saying that no measurement on 2t qubits can learn information about the codeword. Alternatively, it says we can detect up to 2t errors on the code without necessarily being able to say what those errors are. That is, we can distinguish those errors from the identity. If the matrix C ab in (25) has maximum rank, the code is called nondegenerate. If not, as for the nine-qubit code, the code is degenerate. In a degenerate code, different errors look the same when acting on the coding subspace. 3.3 Stabilizer Codes Now let us revisit nine-qubit code to examine what we need to do in order to correct errors. First, we must determine if the first three qubits are all the same, and if not, which is different. We can do this by measuring the parity of the first two qubits and the parity of the second and third qubit. That is, we measure Z Z I and I Z Z. The first tells us if an X error has occurred on qubits one or two, and the second tells us if an X error has occurred on qubits two or three. It is important to note that the error detected in both cases anticommutes with the error measured. Combining the two pieces of information tells us precisely where the error is. 7

8 Z Z I I I I I I I I Z Z I I I I I I I I I Z Z I I I I I I I I Z Z I I I I I I I I I Z Z I I I I I I I I Z Z X X X X X X I I I I I I X X X X X X Table 2: Summarization of the operators measured for the stabilizer of the nine-qubit code. Each column represents a different qubit. We do the same thing for the other two sets of three. That gives us four more operators to measure. Note that measuring Z Z gives us just the information we want and no more. This is crucial so that we do not collapse the superpositions used in the code. We saw we can do this by bringing in an ancilla qubit. We start it in the state and perform controlled-z operations to the first and second qubits of the code; i.e. if the first qubit is in 1 we perform Z operation on the second and if the first qubit is in 0 we do nothing to the second qubit: ( ) c abc abc ) c abc ( 0 abc + ( 1) a b 1 abc (30) abc abc At this point, measuring the ancilla in the basis 0 ± 1 will tell us the eigenvalue of Z Z I, but nothing else about the data. Second, we must check if the three signs are the same or different. We do this by measuring and X X X X X X I I I (31) I I I X X X X X X. (32) This gives us a total of eight operators to measure. These two measurements detect Z errors on the first six and last six qubits, correspondingly. Again note that the error detected anticommutes with the operator measured. This is no coincidence. In each case, we are measuring an operator M which should have eigenvalue +1 for any codeword: M ψ = ψ. If an error E which anticommutes with M has occurred, then the true state is E ψ, and M (E ψ ) = EM ψ = E ψ. (33) That is, the new state has eigenvalue 1 instead of +1. We use this fact to correct errors: each single-qubit error E anticommutes with a particular set of operators {M}; which set, exactly, tells us what E is. In the case of the nine-qubit code, we cannot tell exactly what E is, for instance, we cannot distinguish Z 1 and Z 2 since: Z 1 Z 2 ψ = ψ Z 1 ψ = Z 2 ψ. Because of this fact the nine-qubit code is an example of degenerate code. As stated earlier these 8 operators generate an Abelian group called the stabilizer of the nine-qubit code. The stabilizer contains all operators M in the Pauli group for which M ψ = ψ for all ψ in the code. Conversely, given an Abelian subgroup S of the Pauli group P n, we can define a quantum code T (S) as the set of states ψ for which M ψ = ψ for all M S. S must be Abelian and cannot contain 1, or the code is trivial: if M, N S, MN ψ = M ψ = NM ψ = N ψ = ψ thus: [M, N] ψ = MN ψ NM ψ = 0. (34) 8

9 Stabilizers GF(4) I 0 Z 1 X ω Y ω 2 tensor products vectors multiplication addition [M, N] = 0 T r (M N) = 0 N(S) dual Table 3: Connections between stabilizer codes and codes over GF(4). Since elements of the Pauli group either commute or anticommute, [M, N] = 0. Clearly, if M = 1 S, there is no nontrivial ψ for which M ψ = ψ. If these conditions are satisfied, there will be a nontrivial subspace consisting of states fixed by all elements of the stabilizer. We can tell how many errors the code corrects by looking at operators that commute with the stabilizer. We can correct errors E and F if either E F S, so E and F act the same on codewords, or if M S s.t. {M, E F } = 0, in which case measuring the operator M distinguishes between E and F. If the first condition is ever true, the stabilizer code is degenerate; otherwise it is nondegenerate. We can systematize this by looking at the normalizer N(S) of S in the Pauli group which is in this case equal to the centralizer, composed of Pauli operators which commute with S. The distance d of the code is the minimum weight of any operator in N(S) \ S [3, 14]. Theorem 2 Let S be an Abelian subgroup of order 2 a of the n-qubit Pauli group, and suppose 1 S. Let d be the minimum weight of an operator in N(S) \ S. Then the space of states T (S) stabilized by all elements of S is an [[n, n a, d]] quantum code. To correct errors of weight (d 1)/2 or below, we simply measure the generators of S. This will give us a list of eigenvalues, the error syndrome, which tells us whether the error E commutes or anticommutes with each of the generators. The error syndromes of E and F are equal iff the error syndrome of E F is trivial. For a nondegenerate code, the error syndrome uniquely determines the error E (up to a trivial overall phase) the generator that anticommutes with E F distinguishes E from F. For a degenerate code, the error syndrome is not unique, but error syndromes are only repeated when E F S, implying E and F act the same way on the codewords. If the stabilizer has a generators, then the code encodes n a qubits. Each generator divides the allowed Hilbert space into +1 and 1 eigenspaces of equal sizes. To prove the statement, note that we can find an element G of the Pauli group that has any given error syndrome (though G may have weight greater than (d 1)/2, or even greater than d). Each G maps T (S) into an orthogonal but isomorphic subspace, and there are 2 a possible error syndromes, so T (S) has dimension at most 2 n /2 a. In addition, the Pauli group spans U(2 n ), so its orbit acting on any single state contains a basis for H. Every Pauli operator has some error syndrome, so T (S) has dimension exactly 2 n a. Finally, it is possible to make a connection between stabilizer codes and codes over GF(4) a vector space over Z 2, by identifying the four operators I, X, Y, and Z with the four elements of GF(4), as in table 3 [4]. Since GF(4), is the finite field with four elements, with characteristic 2, containing the elements {0, 1, ω, ω 2 } we can define two operations. The first one is conjugation, which switches the two roots of the characteristic polynomial x 2 + x + 1: 9

10 Z Z Z Z I I I Z Z I I Z Z I Z I Z I Z I Z X X X X I I I X X I I X X I X I X I X I X Table 4: Stabilizer for the seven-qubit code. 1 = 1, ω = ω 2, 0 = 0 and ω 2 = ω, and the trace, which is multiplication with conjugate: T r 0 = T r 1 = 0 and T r ω = T r ω 2 = 1 Now the commutativity constraint in the Pauli group becomes a symplectic inner product between vectors in GF(4). The fact that the stabilizer is Abelian can be phrased as the fact that the code must be contained in its dual with respect to this inner product, and to determine the number of errors corrected by the code we must examine vectors which are in the dual that corresponds to N(S) but not in the code, corresponding to S. Making this correspondence many results from classical coding theory become available. Many classical codes over GF(4) are known, and many of them are self-dual with respect to the symplectic inner product, hence they define quantum codes. For instance, the five-qubit code that is introduced in the next section is one such code a it is just an instance of a Hamming code over GF(4)! In classical coding theory we consider linear codes, i.e, the codes that are closed under addition and scalar multiplication, whereas in the quantum case we wish to consider the slightly more general class of additive GF(4) codes that are close only addition of elements. 3.4 Calderbank-Shor-Steane codes The stabilizer formalism makes it easy to describe new codes, and the idea used in construction of CSS codes is behind all codes in the rest of this report. In quantum codes, the stabilizer is closely analogous to the classical parity check matrix, and we will see how. One well-known code is the seven-bit Hamming code correcting one error, with parity check matrix (35) If we replace each 1 in this matrix by the operator Z, and 0 by I, we are really changing nothing, just specifying three operators that implement the parity check measurements. The statement that the classical Hamming code corrects one error is the statement that each bit flip error of weight one or two anticommutes with one of these three operators. Now suppose we replace each 1 by X instead of Z. We again get three operators, and they will anticommute with any weight one or two Z error. Thus, if we make a stabilizer out of the three Z operators and the three X operators, as in table 4, we get a code that can correct any single qubit error [10]. X errors are picked up by the first three generators, Z errors by the last three, and Y errors are distinguished by showing up in both halves. Of course, there is one thing to check: the stabilizer must be Abelian; but that is easily verified. The stabilizer has 6 generators on 7 qubits, so it encodes 1 qubit and it is designated as [[7, 1, 3]] code. For construction of the quantum [[7, 1, 3]] code there was no particular reason to use the same classical code for both the X and Z generators. More generally we could can use any two classical codes C 1 and C 2 [5, 19]. The only requirement is that the X and Z generators commute. This corresponds to the statement that C2 C 1, i.e. all orthogonal codewords of C 2 will be a subset of C 1. If C 1 is an (n, k 1, d 1 ) code, and C 2 is an (n, k 2, d 2 ) code, then the 10

11 X Z Z X I I X Z Z X X I X Z Z Z X I X Z Table 5: The stabilizer for the five-qubit code. Codewords are given in appendix. corresponding quantum code is an [[n, k 1 + k 2 n, min(d 1, d 2 )]] code. Interestingly the true distance of the code could be larger than expected because of the possibility of degeneracy, which would not be an issue for the classical codes. This construction is known as the CSS construction after its inventors Calderbank, Shor, and Steane. The codewords of a CSS code have a particularly nice form. They all must satisfy the same parity checks as the classical code C 1, so all codewords will be superpositions of words of C 1. The parity check matrix of C 2 is the generator matrix of C2, so the X generators of the stabilizer add a word of C2 to the state. Thus, the codewords of a CSS code are of the form u + w, (36) w C 2 where u C 1 (C 2 C 1, so u + w C 1 ). If we perform a Hadamard transform , on each qubit of the code, we switch the Z basis with the X basis, and C 1 with C 2, so the codewords are now w C 1 u + w (u C 2 ). (37) Thus, to correct errors for a CSS code, we can measure the parities of C 1 in the Z basis, and the parities of C 2 in the X basis. The smallest possible code to construct is [[5, 1, 3]] [2, 8]. Its stabilizer is given in table 5. all stabilizer elements commute and actually have distance 3. Since multiplication by M S merely rearranges elements of the group S, the sum ( M S M) φ is in the code for any state φ. We only need to find two states φ for which (3.4) is nonzero. Note that as well as telling us about the error-correcting properties of the code, the stabilizer provides a more compact notation for the coding subspace than listing the basis codewords and provides even compact notion for description of the entanglement, but that is beyond our scope here. A representation of stabilizers that is often useful is as a pair of binary matrices, frequently written adjacent with a line between them [3]. The first matrix has a 1 everywhere the stabilizer has an X or a Y, and a 0 elsewhere; the second matrix has a 1 where the stabilizer has a Y or a Z. Multiplying together Pauli operators corresponds to adding the two rows for both matrices. Two operators M and N commute iff their binary vector representations (a 1 b 1 ), (a 2 b 2 ) are orthogonal under a symplectic inner product: a 1 b 2 +b 1 a 2 = 0. For instance, the stabilizer for the five-qubit code becomes the matrix Quantum Reed-Muller Codes (38) The subject of quantum error correction may be considered to have two distinct parts. The first part is how to apply error correction in a physical situation, and the second it to find good quantum error correction codes, and that is what this section is dealing with. 11

12 The previous section explained the first known general code construction CSS code that used a pair of classical codes C 1 = [n, k 1, d], C 2 = [n, k 2, d] with C2 C 1 to produce a quantum [[n, k 1 +k 2 n, d]] code [3, 19]. More efficient codes are found by Gottesman [14] who discovered an infinite set of optimal single-error correcting quantum codes, with parameters [[2 r, 2 r r 2, 3]]. This section presents a set of quantum codes of which Gottesman s is a subset. They are obtained by combining classical Reed-Muller codes, and have parameters [[ [[n, k, d]] = 2 r, 2 r t 1 C(r, t) 2 C(r, i), 2 t + 2 t 1]], (39) where C(r, t) = r!/t!(r t)!. To show how the codes are derived, we will use the results and notation of Calderbank et al [16], who showed how to reduce the quantum coding problem to one of orthogonal geometry, to formalize the constructions explained in the previous two sections. A quantum code for n qubits is specified by its generator matrix which has the general form G = (G x G z ) (40) where G x and G z generate n-bit binary vector spaces. The rows of G x and G z have length n, and the number of rows is n + k. The minimum distance of the code is the minimum weight of a non-zero generated code word, where the weight is the number of non-zero bit locations. A bit location is non-zero if it is non-zero in either the left hand, X part, or the right hand, Z part. In other words, if a code word is written (u x u z ), where u x and u z are n-bit strings, then the weight is the Hamming weight of the bitwise or of u x with u z. To qualify as an error correcting code, the quantum code must satisfy a property which is best specified in terms its stabiliser The stabiliser is related to the generator by: i=0 S = (S x S z ). (41) S x G T z + S z G T x = 0, (42) where the arithmatic is over a binary field, i.e. is bitwise and and + is bitwise xor. From this relation, it is clear that the stabiliser and generator are the quantities corresponding to the parity check and generator matrices for a classical code. Relation (42) states that S may be obtained from G by swapping the X and Z parts, and extracting the dual of the resulting (n + k) 2n binary matrix. The further property which a quantum code must satisfy is [16] S x S T z + S z S T x = 0. (43) The encoding method of [5, 19] using pairs of classical codes leads to a generator and stabilisor of the form ( ) ( ) G1 0 S2 0 G =, S = (44) 0 G 2 0 S 1 where G 1 and G 2 generate the classical codes C 1 and C 2. We see that the selfduality relation (43) is the generalization of the dual condition C2 C 1 which such codes must satisfy. Now we will see that extension of this procedure will allow us to construct a quantum Reed-Muller codes that have the parameters given by (39). The construction is obtained codes by adding further rows D to G 1 such that G 1 and D together generate a classical code of smaller minimum distance than G 1 alone, due to few more generator vectors introduced by D [18]. G = G G 2 D x 12 D z (45)

13 We can now use the generator (45), to chose G 1 and G 2 to be Reed-Muller code: G 1 = G 2 = [ 2 r, k RM (t, r), 2 t+1], k RM (t, r) = 2 r t C(r, i). (46) i=0 Finally we take D x such that G 1 and D x together generate the Reed-Muller code of distance 2 t. This classical code has size k RM (t 1, r) so the total number of rows in the quantum generator equation (45) is: n + k = k RM (t, r) + k RM (t 1, r) (47) which gives the size k of the quantum code in equation (39). If D z were zero, then the generated quantum code would have minimum distance 2 t. We now construct D z so as to increase this minimum distance to 2 t + 2 t 1. Let Dx i refer to the i th row of D x, and let the rows be numbered 1 to m where m = k RM (t 1, r) k RM (t, r). Form D z such that: Dz i = Dx i+1 for 1 i < m Dz m ( ) = L t D 1 (48) x where the action of L t is left shift by t places, e.g. L 2 ( ) = ). This completes the construction of the generator G, which completely specifies the quantum RM code. The proof that these codes have minimum distance 2 t + 2 t 1 for all r is by induction on t, using the fact that this was proved for t = 1 previously. The induction on t, i.e. the fact that 2 t + 2 t 1 is the correct formula for d should be obvious from the construction of the codes. To prove that the codes satisfy the self dual condition (43), notice that the stabiliser S of a code [[n, k, d]] constructed as above is equal to the generator of a [[n, k, d ]] code constructed by the same method where: d is 2d for odd r and 4d for even r. In other words, the stabiliser matrix is also built out of classical Reed-Muller matrices by the same recipe. Because the classical Reed-Muller codes contain their duals, it is easy to show that whenever the number of rows in the stabiliser is less than n (i.e. k > 0), S x Sz T = 0 and therefore equation (43) is satisfied. When the stabiliser or generator matrix has n rows, on the other hand, one finds D x Dz T 0 which, combined with the fact that the rest of S x Sz T is zero, means that S x Sz T cannot be symmetric and therefore (43) is not satisfied. In summary, the method works for k > 0, and the generators for k < 0 are stabilisers of k > 0 codes. We conclude this section with the few comments on usefulness of QRM codes. For applications in a quantum computer where efficient correction is necessary easy encoding and decoding of QRM codes is very appealing. The codes are also optimal,i.e. they have maximal k for given n and d for t = 1 [14], and close to optimal for small t and r However they are far from optimal for large t and r. Moreover the code size falls to zero at t = r/2 with even r, giving parameters [[2 r, 0, 2 r/2 + 2 r/2 1 ]], i.e. d n 1/2 for n 1, which means that in the limit of large r the small size codes are no better than those obtained by the simpler method of equation (44) applied to the self-dual Reed-Muller codes, leading to parameters [[2 r 1, 0, 2 r/2 ]]. 3.6 Quantum BCH codes This section describes three constructions for BCH codes that are important for quantum erasure channel. For QBCH codes there are efficient algorithms to correct erasures and errors. Using the algorithm of Berlekamp and Massey for decoding binary BCH codes with designed distance d BCH, ν erasures and t errors can be corrected provided that ν + 2t < d BCH [12]. A quantum BCH code is a quantum error-correcting code that is derived from a classical, weakly self-dual BCH code using any of the following three constructions: 13

14 Construction of Binary Codes Let C = [n, k, d] be a weakly self-dual linear binary code, i.e., C is contained in its dual C = [n, n k, d ]. Furthermore, let {w j : 0 j 2 n 2k } be a set of coset representatives of C /C. Then the 2 n 2k mutually orthogonal states ψ j = 1 C c C c + w j span a quantum error-correcting code C = [[n, n 2k]] of length n and dimension 2 n 2k. Based on classical decoding algorithms for the code C, up to (d 1)/2 errors can be corrected. Moreover, the code can correct errors up to weight (d 1)/2 where d = min{wgt c : c C \ C} d. (49) The outline of the decoding process is as follows: any superposition of code states ψ j is a superposition of quantum states corresponding to codewords of the dual code C. A correctable bit-flip error takes the superposition of codewords into a superposition of the corresponding coset. This coset can be identified by computing an error syndrome using auxiliary qubits. Measuring this syndrome reveals information about the error, but not about the original superposition. After correction of the bit-flip errors, a Hadamard transform turns the remaining phase-flip errors into sign-flip errors. The Hadamard transform changes the code state into: H n 1 ψ j = ( 1) c wj c. (50) C c C Here c w j is the standard inner product x y = i x iy i. Again, any superposition of states (50) is a superposition of quantum states corresponding to codewords of the dual code C. Hence the errors can be corrected in the same manner. The last step is another Hadamard transform returning to the original basis. Construction of Quaternary Codes For a linear space C F n 4 = GF (4) = {0, 1, w, w = w2 = w + 1}, by C we denote the linear space that is orthogonal with respect to the inner product x y := j x jy j. Let C = [n, k, d] be a self-orthogonal linear quaternary code, i. e., C is contained in C = [n, n k, d ]. Then a quantum error-correcting code C = [[n, n 2k]] of length n and dimension 2 n 2k exists. Based on classical decoding algorithms for the code C, up to (d 1)/2 errors can be corrected. Moreover, the code can correct errors up to weight (d 1)/2 where d = min{wgt c : c C \ C} d. (51) Note that C and C are related by conjugation and thus d = d. Construction of Codes Over Any Finite Field of Characteristics Two Let C = [n, k, d] be a weakly self-dual code over F 2 l, i.e. C is contained in its dual C = [n, n k, d ] with respect to the inner product. Furthermore, let B be a self-dual basis of F 2 l over F 2. Expanding each element of F 2 l with respect to the basis B yields a weakly self-dual linear binary code C 2 = [ln, lk, d 2 d]. Its dual C2 = [ln, l(n k), d 2 d ] is obtained in the same manner. Usually, BCH codes are specified by the zero sets, i.e. the exponents of the roots α z of their generator polynomial g(x) X n 1 where α is a primitive n-th root of unity. For a BCH code over the field F q, the zero set is a union of cyclotomic cosets modulo n closed under multiplication by q, i. e., Z C = z C z where C z = {q i z mod n : i 0}. The zero sets of a code and its dual are related as follows. 14

15 Theorem 3 Let Z C denote the zero set of a BCH code C over the field F q, i.e., the generator polynomial of C is given by g(x) = z Z C (X α z ). Then the generator polynomial of the dual code C is given by h(x) = z {0,...,n 1}\Z C (X α z ), i.e., the zero set of the dual code is given by Z C = { z mod n : z {0,..., n 1} \ Z C }. For codes over F 4, the generator polynomial of the orthogonal code C is given by h(x) = z {0,...,n 1}\Z C (X α 2z ), i. e., the zero set of the orthogonal code is given by Z C = { 2z mod n : z {0,..., n 1} \ Z C }. As as a corollary BCH code is weakly self-dual if and only if Z C Z C or, equivalently, z : (z Z C ( z mod n) / Z C ). A BCH code over F 4 is self-orthogonal if and only if Z C Z C or, equivalently, z : ( z Z C ( 2 1 z mod n) / Z C ). Moreover a lower bound for the minimum distance of a BCH code and in turn for the corresponding QBCH code can be derived from its zero set. Theorem 4 (BCH bound) If the zero set Z C C contains d BCH 1 consecutive numbers, i. e., of the dual of a weakly self-dual BCH code z 0 +d BCH 2 then the minimum distance d of C is at least d BCH. z=z 0 C z Z C, (52) On the other hand, if a BCH code is specified by the left hand side of equation (52), d BCH is called the designed distance. Yet actual minimum distance of a BCH code may be larger than d BCH. 4 Concluding Remarks This report hopefully explained reasonably well the concept involved in quantum errorcorrection process, with explanation on stabilizer codes, CSS, Reed-Muller and BCH codes. However its brevity expunged the concepts of quantum convolutional codes, cyclic QECC, approximate QECC and toric codes. Moreover, the big picture is also missing, and that is the mere consequence of the fact that the attempt to have a computation process in a noisy environment incorporates much more theoretical machinery then just providing a robust way of transferring the information between Alice and Bob. Hence without the notion of fault tolerant computation with the noisy gates, information theory approach to QEC, quantum channels, state and entanglement fidelity, one can not clearly think about the concept of quantum error correction. As we have seen QEC is the field that vastly imports from the field of classical error correction, yet surprisingly perhaps has a back action providing for some results about locally decodable codes that haven t been know before. References [1] D. Aharonov and M. Ben-Or, Fault-tolerant quantum computation with constant error, Proc. 29th Ann. ACM Symp. on Theory of Computation (ACM, New York, 1998), pp , quant-ph/ ; D. Aharonov and M. Ben-Or, Fault-tolerant quantum computation with constant error rate, quant-ph/ [2] C. Bennett, D. DiVincenzo, J. Smolin, and W. Wootters, Mixed state entanglement and quantum error correction, Phys. Rev. A 54 (1996), ; quant-ph/ [3] A. R. Calderbank, E. M. Rains, P. W. Shor, and N. J. A. Sloane, Quantum error correction and orthogonal geometry, Phys. Rev. Lett. 78 (1997), ; quant-ph/

16 [4] A. R. Calderbank, E. M. Rains, P. W. Shor, and N. J. A. Sloane, Quantum error correction via codes over GF(4), IEEE Trans. Inform. Theory 44 (1998), ; quantph/ [5] A. R. Calderbank and P. W. Shor, Good quantum error-correcting codes exist, Phys. Rev. A 54 (1996), ; quant-ph/ [6] W. K. Wootters and W. H. Zurek, A single quantum cannot be cloned, Nature 299, 802 (1982). [7] E. Knill and R. Laflamme, A theory of quantum error-correcting codes, Phys. Rev. A 55 (1997), ; quant-ph/ [8] R. Laflamme, C. Miquel, J. P. Paz, and W. Zurek, Perfect quantum error correction code, Phys. Rev. Lett. 77 (1996), ; quant-ph/ [9] P. W. Shor, Scheme for reducing decoherence in quantum memory, Phys. Rev. A 52 (1995), [10] A. M. Steane, Error correcting codes in quantum theory, Phys. Rev. Lett. 77 (1996), [11] A. M. Steane, Multiple particle interference and quantum error correction, Proc. Roy. Soc. London A 452 (1996), ; quant-ph/ [12] Grassl, M., Beth, T., and Pellizzari, T. Codes for the Quantum Erasure Channel. Physical Review A, 56(1):33 38, July [13] Grassl, M., Beth, T. Quantum BCH codes quant-ph/ [14] D. Gottesman, A class of quantum error-correcting codes saturating the quantum Hamming bound (quant-ph/ ) [15] D. Gottesman, Stabilizer Codes and Quantum Error Correction. PhD. Thesis, Caltech 1997, quant-ph/ [16] A. R. Calderbank, E. M. Rains, N. J. A. Sloane and P. W. Shor, Quantum error correction and orthogonal geometry (quant-ph/ ). [17] A. M. Steane, Error correcting codes in quantum theory, Phys. Rev. Lett. 77, 793 (1996). [18] A. M. Steane, Simple quantum error correcting codes, Phys. Rev. A, (quant-ph/ ). [19] Steane, A. Quantum Reed-Muller Codes quant-ph/ Appendix This example shows logical zero and one for five qubit code [[5,1,3]]. The code is cyclic and has distance three. 0 = (53) , 16

17 and 1 = (54)