Chapter 9 - Quantum Error Correcting Codes

Introduction

If one were to encode the information contained in some set of quantum states in such a way as to enable the information to be stored redundantly, then it would be possible to use the redundancy to detect and correct errors. Quantum error correcting codes aim to encode quantum information into states in just such a redundant fashion. It is worth noting that classical error correcting codes and coding theory has been around a long time. However, quantum error correction requires extra care when measuring to detect and correct errors. In this chapter, simple examples of quantum error correcting codes are given which correct errors in quantum computation. A later chapter will discuss more general concerns.

Bit-flip Errors: A Classical Code

A classical bit-flip error would turn a 0 into a 1 and a 1 into a 0. A classical error correcting code which protects against such bit-flip errors is the following code. Rather than use the state 0, the state is encoded redundantly; the state 000 is used. This is called an encoded zero state or a logical zero state. Likewise, 111 is used as an encoded 1, or logical 1. Now suppose one bit is flipped when the encoded state 111 is sent, and let this be the first bit. Then having sent 111 and finding 011, one would suppose that it was likely the case that the first bit was flipped. If one of the bits is flipped, the encoded state could be fixed by flipping the one that is different so that it agrees with the others. Let us assume that each error is independent and has probability $p\,\!$. The probability that the bit is not flipped is then $1-p\,\!$. Since the probability is $p\,\!$ that one bit flip occurs, then the probability that two are flipped is $3(1-p)p^{2}\,\!$ (assuming we don't know which one). The probability that three are flipped is $p^{3}\,\!$. So the code will help us if $p>3(1-p)p^{2}+p^{3}\,\!$ which happens when $p<1/2\,\!$.

This example will now be used to find a simple bit-flip code for a quantum system.

Bit-flip Errors: A Quantum Code

The quantum bit-flip code uses three quantum states to encode one as does the classical code. The state $\left\vert 0\right\rangle \otimes \left\vert 0\right\rangle \otimes \left\vert 0\right\rangle =\left\vert 000\right\rangle =\left\vert 0_{L}\right\rangle \,\!$ is the logical state representing the zero state of the encoded qubit. Similarly, $\left\vert 111\right\rangle =\left\vert 1_{L}\right\rangle \,\!$ is used for the logical one state. However, in quantum mechanics one cannot casually suggest measuring the three states to see if they agree. The reason is that a quantum state can be in a superposition of the zero state and the one state. A general state could be written as

	$\left|\psi _{L}\right\rangle =\alpha \left|0_{L}\right\rangle +\beta \left|1_{L}\right\rangle =\alpha \left|000\right\rangle +\beta \left|111\right\rangle .\,\!$	(9.1)

A measurement of the first qubit to see if it is in the state zero or not will immediately produce the state $\left|000\right\rangle \,\!$ with probability $|\alpha |^{2}\,\!$ destroying the superposition of the qubit state and producing a state which can be described as containing only classical information. (Essentially it is equivalent to the classical 000 binary state.)

There is a way to determine if the state has experienced a bit-flip error or not without ruining the superposition. This is done by measuring to see if the first two qubits are the same or not and then measuring to see if the last two qubits are the same or not. Let us examine this process in detail. First, measure the value of the operator $\sigma _{z}\otimes \sigma _{z}\otimes I\,\!$. Since the state $\left\vert 0\right\rangle \,\!$ is an eigenvalue of $\sigma _{z}\,\!$ with eigenvalue 1, and $\left\vert 1\right\rangle \,\!$ is an eigenvalue of $\sigma _{z}\,\!$ with eigenvalue -1.

$\,\!$ $\,\!$$\,\!$$\,\!$