Quantum Error Correction

Indian Institute of Technology, Kanpur

CS682A

Quantum Computation

Author: Roll Numbers: Pranav Bisht 17111268 Samik Some 17111271

November 15, 2017 Contents

1 Introduction ...... 1 2 Bit ﬂip code ...... 2 2.1 Encoding: ...... 2 2.2 Error Detection: ...... 3 2.3 Error Recovery: ...... 4 3 Phase Flip Code ...... 4 4 Alternate Look At Syndrome Measurements ...... 5 5 The Shor Code [Sho95] ...... 6 5.1 Bit Flip Errors ...... 7 5.2 Phase Flip Errors ...... 7 5.3 Combined Bit and Phase Flip Errors ...... 8 6 Classical Linear Codes ...... 9 6.1 Generator Matrix ...... 9 6.2 Parity Check Matrix ...... 9 6.3 Error Correction ...... 10 7 CSS codes ...... 11 7.1 Error Detection and Correction ...... 12 8 The Steane Code [Ste96] ...... 14 9 Conclusion ...... 15

1 Abstract This document serves as a project report on Quantum Error Correcting codes (QEC) done as part of the course Quantum Computation. Efficient and reliable communication has posed a challenge to mankind since ages, eventually leading to birth of Information Technology. This field received a great boost after the advent of Internet with high demand for time and space efficient error correcting codes. Now, at the dawn of Quantum computation, which with every day is coming closer to being a feasible reality, researchers have explored error correcting schemes for reliable transfer of qubits. We primarily focus on Quantum codes and study the classical codes briefly to the extent required for the presentation here. We start with simple repetition code and its quantum equivalent, the bit flip and phase flip codes. We show how Shor code combines both of these. We also look at a broader class of QECs called CSS codes and study Steane code in its light. Pranav Bisht Quantum Error Correction Samik Some

1 Introduction

In the classical world, error correcting codes have been extensively studied and developed to ensure reliable communication across a noisy channel. Variety of error correcting schemes exist catering to different requirements like Parity codes, Hamming Codes, Reed Solomon codes et cetera. The primary requirements these codes try to achieve are that of time efficiency with respect to encoding and decoding a message, while also trying to save on the number of extra bits used in the transfer of message. However, in this report our primary focus is to explore Error Correcting algorithms in the Quantum world, highlighting the potential challenges they face and how they are cleverly handled. Quantum error correcting codes derive main idea from their classical counterparts. We will briefly discuss simple repetition code and classical linear codes [6], in order to understand QECs. We will be discussing qubit flip codes [2], phase flip codes [3], Shor’s code [5], Steane’s code [8] and the general framework of Calderbank-Shor-Steane (CSS) codes [7] in detail in this report. Every error correction scheme has 3 parts - Message Encoding, Error Detection, Error Correc- tion. In all these codes, we will try to describe all the 3 parts in one flow. On the way we will state and assume certain mathematical properties but we will prove them at the end of each section as lemmas, for ease of reading. The setting is as follows: Alice wants to send Bob a message. We can assume the message to be composed of bits (qubits in case of QEC). In real world the communication channel (air, wire) is noisy. Physical factors tend to corrupt the bits. Bob receives a corrupted or original message, but he does not know. How can Bob recover the original message? It is definitely not possible if the message was n bits and Alice sends exactly n bits. However, if Alice sends extra bits, Bob may be able to recover the message. How? Consider Alice wants to send a single bit 0 to Bob. Suppose we are assured that only a single bit error can occur during transmission. If Alice sends 000 as message. Then Bob can receive one of the following:

000 // no error 100 // error on 1st bit 010 // error on 2nd bit 001 // error on 3rd bit

On receiving the message, Bob simply takes the majority (max of 0,1) in order to get the original message (in this case 0). Similarly, if Alice wished to send 1 she would instead send 111, and Bob could decode the message appropriately. This simple idea is exploited in Repetition codes. The key idea in any kind of error correction scheme is to append “suﬃcient” number of redundant bits to the message. Researchers are always trying to optimize the extra bits needed. In fact, there is a dedicated ﬁeld known as Coding Theory which studies these codes in detail providing theoretical bounds alongside.

1 Pranav Bisht Quantum Error Correction Samik Some

Let us now think about QECs. Alice wants to send Bob qubits. Noise in the channel corrupts qubits. How does Bob recover the original qubits? A careful thinker will be stumped by these challenges first: • No cloning: The moment we hear repeated copies, it should raise an alarm in the quantum world, because of the no cloning theorem. The laws of quantum mechanics don’t allow copying of qubits. So we cannot simply send 3 copies of qubits to send a single qubit reliably. • Continuous errors: In the classical world, the only kind of error is bit flip. But here a continuum of different errors may occur, due to infinite superposition states possible. Deciphering the order of errors seems to require infinite precision. • Measurement destroys the state: In classical error correction, Bob observes the message received and adopts decoding procedure accordingly. But in the case of qubits observing or measuring perturbs the quantum state. Despite these potential challenges, we will see how researchers deftly overcome these in the error correcting codes to follow. Also, in this writing, we assume that no errors are introduced while encoding or decoding which in the real world does happen. Nonetheless, the theory of fault tolerant quantum computation ensures that they are not a significant setback.

2 Bit ﬂip code

As of now, assume that there are only two types of qubit errors: bit flip and phase flip, described by unitary matrices X and Z respectively. Throughout this report, we will concern ourselves with reliable transmission of just a single qubit from Alice to Bob. In this section, we will show how to correct single qubit bit flip error and in the next section we will show the same for qubit phase flip error. Later we will discuss why we can correct any kind of quantum error if we are able to correct both bit flip and phase flip errors. Single bit flip error is described by:

|0i → |1i |1i → |0i

This is the same as action of Pauli matrix X.

2.1 Encoding:

Suppose Alice wants to send qubit Ψ = a |0i + b |1i. Similar to the repetition code, we will append two qubits |00i to Ψ, giving us Ψ1. Note that we bypassed the ﬁrst challenge as we did not copy the state Ψ. We merely appended two ancilla bits which is always possible.

2 Pranav Bisht Quantum Error Correction Samik Some

Figure 1: Bit Flip Code Encoding [Wik17]

Ψ0 ≡ (a |0i + b |1i) |0i |0i ≡ a |000i + b |100i

Ψ1 ≡ a |000i + b |111i

2.2 Error Detection:

Assuming that only a single qubit ﬂip can occur during transmission, Bob will receive one of these 4 possible states:

Φ0 ≡ a |000i + b |111i // No error st Φ1 ≡ a |100i + b |011i // 1 qubit flip nd Φ2 ≡ a |010i + b |101i // 2 qubit flip rd Φ3 ≡ a |001i + b |110i // 3 qubit flip

Let us deﬁne the following 4 Projection operators:

P0 ≡ |000i h000| + |111i h111| // No error st P1 ≡ |100i h100| + |011i h011| // 1 qubit flip nd P2 ≡ |010i h010| + |101i h101| // 2 qubit flip rd P3 ≡ |001i h001| + |110i h110| // 3 qubit flip

Deﬁne measurement M = 0P0 + 1P1 + 2P2 + 3P3. Lemma 2.1 proves that {P0,P1,P2,P3} indeed form a valid measurement. Observe that MΦi = i ∀i = 0 ... 3, since ( 1 if i = j Pi |Φji = 0 otherwise

This detects which qubit was ﬂipped during the transmission. Note that we chose our pro- jections for measurement cleverly so that the state before and after the measurement is same |PiΦii Φi = 2 . In this way the third challenge is taken care of by measuring in superposition. kPiΦik

3 Pranav Bisht Quantum Error Correction Samik Some

Figure 2: Bit Flip Code Encoding and Decoding [Wik17]

2.3 Error Recovery:

Once the error syndrome is detected, error recovery is very simple: • No error (0)⇒ Do nothing. • 1st qubit flip (1)⇒ Flip 1st qubit again. • 2nd qubit flip (2)⇒ Flip 2nd qubit again. • 3rd qubit flip (3)⇒ Flip 3rd qubit again. The overall encoding, decoding quantum circuit is shown in Figure 2 Lemma 2.1. The four projectors P0,P1,P2,P3 defined in section 2.2 form a valid measurement

Proof. It is easy to verify that 3 X Pi = I8×8 i=0

Pi · Pj = 0 , ∀i 6= j Hence, they form a valid projective measurement.

3 Phase Flip Code

Now, we will see how to handle only a single qubit phase flip which might creep in during transmission. Phase flip error is equivalent to action of Pauli matrix Z. a |0i + b |1i → a |0i − b |1i Here Hadamard gate comes to our rescue again. The neat idea is that phase flip error in the |+i , |−i basis is same as bit flip error: |+i → |−i |−i → |+i This simple idea gives the whole algorithm for phase flip errors:

4 Pranav Bisht Quantum Error Correction Samik Some

Figure 3: Phase Flip Code Encoding [Wik17]

Figure 4: Phase Flip Encoding and Decoding [Wik17]

• Append ancilla bits: a |0i + b |1i → a |000i + b |111i • Apply Hadamard: a |000i + b |111i → a |+ + +i + b |− − −i • Apply bit ﬂip algorithm to detect and correct a bit ﬂip error in the |+i , |−i basis. • Apply Hadamard again to recover original message in |0i , |1i basis.

4 Alternate Look At Syndrome Measurements

Till now we looked at detecting errors via syndrome measurements. There is an alternative way of doing the same thing. Instead of the projector measurements we look at a set of observables. As an example, for the 3 qubit bit-ﬂip code we can look at observables Z1Z2 ≡ Z ⊗ Z ⊗ I and Z2Z3 ≡ I ⊗ Z ⊗ Z. These observables can be described as follows: Z1Z2 = |00i h00| + |11i h11| ⊗ I − |01i h01| + |10i h10| ⊗ I Z2Z3 = I ⊗ |00i h00| + |11i h11| − I ⊗ |01i h01| + |10i h10|

The descriptions above can be viewed as measurements which give 1 when the corresponding qubits are same and -1 when they are diﬀerent. In essence, we are simply comparing the values of the qubits at required positions. Using these values we can easily determine where the error has occured as shown in Table 1: We should note that these observables neither tell us anything about the amplitudes of the quantum state being measured nor do they change the said state.

5 Pranav Bisht Quantum Error Correction Samik Some

Z1Z2 Z2Z3 Corrupted Bit 1 1 None 1 -1 3rd -1 1 1st -1 -1 2nd

Table 1: Using Observables to ﬁnd Error

We can use similar observables for measuring phase ﬂip errors as well. For phase ﬂip errors, the observables will be X1X2 and X2X3, which can be expressed as: X1X2 = |++i h++| + |−−i h−−| ⊗ I − |+−i h+−| + |−+i h−+| ⊗ I X2X3 = I ⊗ |++i h++| + |−−i h−−| − I ⊗ |+−i h+−| + |−+i h−+|

5 The Shor Code [Sho95]

We have already seen two quantum codes, the bit-flip code and the phase-flip code which protect qubits against bit flip and phase flip errors individually. However, we would like to have a quantum code which protects not just from specific errors but from a general quantum error on a qubit. The Shor code is such a code which uses 9 qubits to encode 1 qubit and protects (detects and corrects) from any quantum error on a single qubit. Essentially, the Shor code is a combination of bit flip and phase flip codes. We first encode a qubit using the encoding procedure of the phase flip code: |0i → |+ + +i , |1i → |− − −i. This is followed by encoding each of these 3 qubits according to the bit flip encoding procedure: √ |+i → (|000i + |111i)/ 2 √ |−i → (|000i − |111i)/ 2

Thus the ﬁnal codewords are: (|000i + |111i)(|000i + |111i)(|000i + |111i) |0i → |0Li ≡ √ 2 2 (|000i − |111i)(|000i − |111i)(|000i − |111i) |1i → |1Li ≡ √ 2 2

Figure 5 shows the quatum circuit which can be used for encoding using Shor code. The first part shows the encoding similar to phase flip code and the second part encodes the qubits similar to the bit flip code. To show that the Shor code can correct any quantum error on a single qubit, we first show that it detects and corrects the following errors.

6 Pranav Bisht Quantum Error Correction Samik Some

Figure 5: Shor Code Encoding [Wik17]

• Bit flip error on a single qubit. • Phase flip error on a single qubit. • Combined bit and phase flip error on a single qubit.

5.1 Bit Flip Errors

Without any loss of generality we may assume that the bit-flip error occurs on the first qubit. To detect the bit-flip error, we apply operator Z1Z2. Since the qubits are diferent we get measurement output −1. Next we apply Z2Z3, and obtain 1 as measurement value since the qubits are same. From these we determine that the first qubit has flipped and correct it accordingly. We may apply similar observables for detecting bit flip in any of the 9 qubits.

5.2 Phase Flip Errors

Let us again assume that the phase flip occurs on the first qubit. We would like to detect and correct this error. We note that a phase flip on any of the first three qubits has the same effect on the codeword; all of them cause a relative phase change in the first triplet of qubits. We can detect this phase flip by applying observables X1X2X3X4X5X6 and X4X5X6X7X8X9. In our case, the first observable will measure −1 as the sign of the first two triplets are different and the second one will measure 1 as the signs of the last two triplets are same. From this, we determine that the first triplet has undergone a phase flip (indeed it can be any of the first 3 qubits that underwent a phase flip), and correct it accordingly.

7 Pranav Bisht Quantum Error Correction Samik Some

Figure 6: Shor Code Encoding and Decoding [Wik17]

5.3 Combined Bit and Phase Flip Errors

In the case of a combined error on the first qubit, Z1X1 ≡ −Y1 is applied on the qubit. From the above discussion it is clear that in this case, the bit flip correction procedure will detect and correct the bit flip on the first qubit and the phase flip correction procedure will detect and correct phase flip on the first triplet of qubits. Thus, the Shor code also corrects a combination of bit and phase flip error as long as they are on a single qubit. We will now show how the Shor code manages to correct any general quantum error simply by correcting bit and phase flips. The basic idea lies in the fact that the any general quantum error will always be a unitary transformation of the codeword. As such we can express the error E as:

E = e1I + e2X + e3Y + e4Z

This is because {I,X,Y,Z} forms a basis for all 2 × 2 unitary matrices. We also note that while doing error detection and correction our error syndromes are simply the above case: I - no error; X - bit flip; Z - phase flip; Y - bit and phase flip. Now even though a general error is a superposition of these four errors, when we measure the error syndrome we effectively force the error to collapse into one of these errors and that is the one we measure and subsequently correct. This is the reason any general error on a qubit can be corrected simply by correcting bit and phase flip errors. Figure 6 shows the full quantum circuit for encoding and decoding using Shor code.

8 Pranav Bisht Quantum Error Correction Samik Some

6 Classical Linear Codes

In the next section we will discuss CSS codes, which derive their mathematical basis from the classical linear codes. Therefore we will brush up with the material relevant to us. Linear codes C[n, k] form a general class of error correcting codes which encode a k bit message in a n bit codeword. Obviously n > k for error correction to be possible. There are two dual views of linear codes - generator matrix and parity check matrix.

6.1 Generator Matrix

Generator matrix G is a binary matrix (0/1 entries) such that it’s column space spans the whole space of possible codewords. More formally, k n Gnxk :(Z2) → (Z2) C[n, k] = colsp(G) For example for the simple repetition code discussed earlier: 1 G = 1 1 G(0) = (0, 0, 0) and G(1) = (1, 1, 1) are two possible codewords as expected. This also brings out an advantage linear codes have over other error correcting codes: Compact representation. A general code would require n · 2k bits to describe the encoding (2k possible codewords each requiring n bits), whereas here we require only nk bits of the generator matrix, which gives an exponential saving. Also note that G must have k linearly independent columns since we want linear transformation G to be one-one for decoding to be possible: all possible 2k message should map to diﬀerent codewords.

6.2 Parity Check Matrix

An alternate dual view for a C[n, k] linear code is that in terms of parity check matrix H. H deﬁnes the linear code as the span of it’s kernel. Formally:

H(n−k)×n · x = 0 C[n, k] = Ker(H) Since, we want Ker(H) to span whole space of possible codewords, it’s dimension must be k. By Rank Nullity Theorem: Rank + Nullity = n Rank + k = n Rank = n − k

9 Pranav Bisht Quantum Error Correction Samik Some

Thus, H must have n − k linearly independent rows. For example, for the simple repetition code, 1 1 0 H = 0 1 1 And as exected, Ker(H) = {(0, 0, 0), (1, 1, 1)}. We will now show that Generator matrix and Parity check matrix are equivalent in the sense that given G, we can ﬁnd H and vice versa. The purpose of parity check matrix is that error correction is easier to see in terms of H. In short, encoding is easier to see in light of G and decoding in light of H. We quickly describe steps to go from H to G and vice versa: Parity to Generator

• Pick k linearly independent vectors y1, . . . , yk ∈ ker(H)

• Set y1, . . . , yk as k columns of G. Generator to Parity ⊥ • Pick n − k linearly independent vectors y1, . . . , yn−k ∈ colsp(G) > > • Set y1 , . . . , yn−k as n − k rows of H. Example:

1 G = 1 1 1 1 0 H = 0 1 1 Ker(H) = {(0, 0, 0), (1, 1, 1)} Colsp(G) = {(1, 1, 0), (0, 1, 1), (1, 0, 1)}

6.3 Error Correction

Suppose Alice wants to send a k bit message x to Bob. She encodes the message x as n bit codeword y = Gx. Assuming that only a single bit error can occur in the channel, we can 0 write the corrupted codeword y = y + e, where en×1 is an elementary vector. Now, we make use of parity check matrix H. We know that:

H(y0) = H(y + e) = Hy + He = He

Hy = 0 since y is a valid codeword and thus belongs in Ker(H). We call Hy0, the error 0 syndrome. Bob compares the measured value Hy with He1, . . . Hen where ei is the elementary vector with 1 in its ith place and rest all 0s. The measured value must be equal to one of th these Hei thus revealing the error ei to Bob. Bob will simply ﬂip the i bit of the corrupted codeword to get a valid codeword. He will then ﬁnd which unique message corresponds to this

10 Pranav Bisht Quantum Error Correction Samik Some

Figure 7: The Big Picture valid codeword. Note that both Bob and Alice must share the same G, H matrices they are using to correctly encode and decode.

7 CSS codes

In this section we ﬁnally discuss the Calderbank-Shor Steane codes which are quantum ana- logues of classical linear codes. It is a general framework which covers a class of QECs, for example Shor’s code, Steane’s code. Stabilizer codes, discussed in class are further generaliza- tion of CSS codes.

Consider C1[n, k1],C2[n, k2] two classical linear codes such that:

• C2 ⊂ C1(k1 > k2). ⊥ • C1 and C2 both correct t errors. ⊥ Note that by Lemma 7.1 C2 is also a valid linear code. Using these two linear codes, we will construct a quantum code CSS(C1,C2) which will correct upto t errors. Let x ∈ C1 be a codeword. We deﬁne a quantum state |x + C2i as follows: 1 X |x + C2i = p |x + yi |C2| y∈C2

0 Let x be another codeword in C1. Note that C1 is a group under vector addition and C2 is 0 a subgroup of C1. Consider the left cosets of C1 with respect to C2. If x, x belong to same 0 coset in C1/C2, then x − x ∈ C2. Then, by lemma 7.2 we get that: 0 |x + C2i = x + C2 0 0 On the other hand, if x, x belong to diﬀerent cosets, then x − x ∈/ C2. By lemma 7.2 again, we get that: 0 |x + C2i is orthonormal to x + C2

11 Pranav Bisht Quantum Error Correction Samik Some

Finally, we deﬁne CSS(C1,C2) = span{|x + C2i | ∀x ∈ C1}. Since the number of cosets is k −k |C1|/|C2| = 2 1 2 , it is an [n, k1 − k2] code.

7.1 Error Detection and Correction

In this section we’ll see how CSS(C1,C2) can be used to detect and correct upto t bit ﬂip and phase ﬂip errors.

Let |x + C2i be the codeword sent. We shall represent the errors using two binary vectors each of size n, e1 and e2, which denote bit flip and phase flip errors respectively. A 1 indicates an error on a particular qubit whereas a 0 signifies no error. Using these vectors the corrupted codeword may be expressed as follows: 1 X (x+y).e2 p (−1) |x + y + e1i |C2| y∈C2

⊥ We shall make use of the properties of the linear codes C1 and C2 to detect and correct e1 and e2. We start by detecting e1. Let H1 be the parity check matrix for C1. We can construct a quantum gate which takes as input the corrupted codeword and some ancilla qubits and gives us the result of applying H1 on the codeword in the ancilla bits. Speciﬁcally, we have:

|x + y + e1i |0i → |x + y + e1i |H1(x + y + e1)i In the above equation we have left out the normalization constant and phase for the sake of clarity. We note, that |H1(x + y + e1)i = |H1e1i. This is so because, x ∈ C1 and y ∈ C2; as C2 ⊂ C1, y ∈ C1; Since C1 in a linear code, we have x + y ∈ C1; As H1 is the parity check matrix for C1, we have H1(x + y) = 0. Therefore, our ancilla bits have the state |H1e1i. We can now measure this ancilla and ﬁnd exactly which error has occured using similar methods to those in linear codes. Once we know the error, we can simply apply quantum NOT gates (Pauli X) to the aﬀected qubits and reverse e1. Hence, after correction we are left with the following state. 1 X (x+y).e2 p (−1) |x + yi |C2| y∈C2

The above operations have succeeded in detecting and correcting e1, but we still have e2 left. To detect e2 we ﬁrst apply a Hadamard operation on each qubit. The resulting state is: 1 X X (−1)(x+y).(e2+z) |zi p n |C2|2 z y∈C2

n 0 where z ranges from 0 to 2 . Let z = z + e2, we can rewrite our state as:

1 X X (x+y).z0 0 (−1) z + e2 (1) p n |C2|2 0 z y∈C2 We can show that:

12 Pranav Bisht Quantum Error Correction Samik Some

• If z0 ∈ C⊥, P (−1)y.z0 = |C | 2 y∈C2 2 • If z0 ∈/ C⊥, P (−1)y.z0 = 0 2 y∈C2 Using the above facts, we can simplify equation 1 to:

1 X x.z0 0 (−1) z + e2 p n 2 /|C2| 0 ⊥ z ∈C2

The above state looks just like a state with bitﬂip error e2, and indeed we will correct it in ⊥ such a manner. We will now use H2, the parity check matrix of C2 and apply it to the state to measure the error syndrome e2 like we did with e1. So, we have:

0 0 0 z + e2 |0i → z + e2 H2(z + e2)

0 0 0 ⊥ We again note that |H2(z + e2)i = |H2e2i, since |H2z = 0i as z ∈ C2 . Now we can measure the ancilla and detect and correct error e2. After error correction the state is:

1 X 0 (−1)x.z z0 p n 2 /|C2| 0 ⊥ z ∈C2 To get back the original state we apply Hadamard transform again, as Hadamard is it’s own inverse. After applying Hadamard we get the state:

1 X p |x + yi = |x + C2i |C2| y∈C2

This is the exact state we started with. Threfore we have detected and corrected both e1 and e2. Lemma 7.1. If C is a linear code then C⊥ is also a linear code.

Proof. C⊥ also known as dual code is deﬁned as:

C⊥ = {x | x.y = 0 , ∀y ∈ C}

Suppose u, v ∈ C⊥, then u + v also belongs to C⊥ because u.y = 0 and v.y = 0 ∀y ∈ C ⇒ (u + v).y = 0 ∀y ∈ C. If C is an [n, k] code then C⊥ is an [n, n − k] code. In fact, it is easy to see that generator matrix for C is parity check matrix for C⊥ and vice versa.

Lemma 7.2. Let C1[n, k1],C2[n, k2] be two linear codes such that C2 ⊂ C1. Also suppose 0 x, x be two codewords in C1 then: 0 0 • x − x ∈ C2 ⇒ |x + C2i = |x + C2i 0 0 • x − x ∈/ C2 ⇒ |x + C2i is orthonormal to |x + C2i

13 Pranav Bisht Quantum Error Correction Samik Some

0 0 Proof. For the ﬁrst part, observe that |x + C2i can be written as |x + y + C2i for some 0 0 0 0 y ∈ C2 since x − x ∈ C2. And |x + y + C2i is exactly |x + C2i since group y + C2 = 0 {y + y | ∀y ∈ C2} = C2. 0 0 0 0 For the second part, x − x ∈/ C2 ⇒ x + y 6= x + y , ∀y, y ∈ C2. Since |x + C2i and 0 |x + C2i is the sum of all quantum states in the standard basis, and the two sets are disjoint, they will have 1’s at diﬀerent positions and hence the two states will be orthonormal.

8 The Steane Code [Ste96]

We now provide an example of a CSS code and show how to construct it from two linear codes. Let C be the standard [7, 4, 3] Hamming code. C is a linear code with the following generator and parity check matrices:

1 0 0 0 0 1 0 0     0 0 1 0 0 0 0 1 1 1 1   G[C] = 0 0 0 1 H[C] = 0 1 1 0 0 1 1   0 1 1 1 1 0 1 0 1 0 1   1 0 1 1 1 1 0 1

⊥ We deﬁne C1 ≡ C and C2 ≡ C . We note that C1 is a [7, 4] code and by lemma 7.1 C2 is a [7, 3] code. To ascertain that C1 and C2 can be used for a valid CSS code we need to show two things:

• C2 ⊂ C1 ⊥ • Both C1 and C2 correct upto t errors ⊥ To show the ﬁrst part, we note that since C2 is simply C we can state that the parity check matrix of C2 is simply the transpose of the generator matrix of C. Hence:

1 0 0 0 0 1 1 T 0 1 0 0 1 0 1 H[C2] = (G[C]) =   0 0 1 0 1 1 0 0 0 0 1 1 1 1

Also we have H[C1] = H[C] Looking at the parity check matrices of C1 and C2, we can easily see that the rowspace of H[C1] is strictly contained in the rowspace of H[C2]. Since the codewords reside in the nullspace of the parity matrices, we conclude that C2 ⊂ C1. ⊥ ⊥ ⊥ To show that both codes correct upto t errors we notice that C2 = (C ) = C = C1. Thus both codes are same and equal to C; as such both can correct upto 1 error on any bit (t = 1, since C is a distance 3 code).

14 Pranav Bisht Quantum Error Correction Samik Some

This shows that CSS(C1,C2) is indeed a valid [7, 1] quantum code and can correct errors upto 1 qubit. To find the codewords for CSS(C1,C2) we simply need to find the coset states |x + C2i , x ∈ C1. The first codeword is simply |0 + C2i: 1 h |0Li = √ |0000000i + |1010101i + |0110011i + |1100110i + |0001111i 8 i + |1011010i + |0111100i + |1101001i

0 0 For the second codeword we need to ﬁnd x ∈ C1 such that x ∈/ 0 + C2. (1, 1, 1, 1, 1, 1, 1) is such an x0. Hence we have: 1 h |1Li = √ |1111111i + |0101010i + |1001100i + |0011001i + |1110000i 8 i + |0100101i + |1000011i + |0010110i

The Steane code uses 7 qubits to encode 1 qubit and protects against 1 qubit error. This is better than Shor’s code which used 9 qubits to encode 1 qubit and oﬀered the same protection.

9 Conclusion

This project helped us in exploring a completely unfamiliar topic. We ended up learning a great deal about QECs, the potential pitfalls and how to utilize the resources of quantum computation to overcome them. Along the way (without realizing at that time), we happened to learn quite a bit about Coding Theory during our study of classical linear codes [6]. The use of group theory in CSS and stabilizer codes was a pleasant surprise. More importantly, we developed an insight into techniques relevant to quantum algorithms besides those covered in class. Our understanding for this topic was greatly simpliﬁed, thanks to the lucid explanations in the textbook [NC02]. We also thank Prof. Rajat Mittal for his lively course lectures and notes [Mit17]. We also studied a bit of Stabilizer codes but not to the extent of presenting here.

15 Bibliography

[Mit17] Rajat Mittal. Lecture notes: Quantum computation. Dept of Computer Science and Engineering, 2017.

[NC02] Michael A Nielsen and Isaac Chuang. Quantum computation and quantum information, 2002.

[Sho95] Peter W Shor. Scheme for reducing decoherence in quantum computer memory. Physical review A, 52(4):R2493, 1995.

[Ste96] Andrew M Steane. Error correcting codes in quantum theory. Physical Review Letters, 77(5):793, 1996.

[Wik17] Wikipedia. Quantum error correction — wikipedia, the free encyclopedia, 2017. [On- line; accessed 15-November-2017].