# Chapter 11 Decoherence and basic quantum error correction

About the one big problem that hinders us from physically implementing everything that we’ve learnt so far, namely

decoherence, as well as how we can start to deal with it via some elementaryerror correction.

In principle we know how to build a quantum computer: we can start with simple quantum logic gates and try to integrate them together into quantum networks.
However, if we keep on putting quantum gates together into networks we will quickly run into some serious practical problems.
The more interacting qubits involved, the harder it is to prevent them from getting entangled with the environment.
This unwelcome entanglement, also known as **decoherence**, destroys the interference, and thus the power, of quantum computing.

## 11.1 Decoherence simplified

Consider the following qubit-environment interaction:
^{128}
Let *measure* the qubit and, as the result, the two get entangled:
*This, however, should not be taken literally unless the states of the environment, |e_{\mathbf{1}}\rangle and |e_Z\rangle, are orthogonal.*

^{129}

This process is what we refer to as **decoherence**.

## 11.2 Decoherence and interference

Suppose the qubit undergoes the usual interference experiment, but, in between the two Hadamard gates, it is affected by **decoherence** (denoted by

Let us step through the circuit in Figure 11.1, keeping track of the state of the environment:

As we can see in Figure 11.2, the interference pattern is suppressed by a factor **visibility**.
As **perfect decoherence** case, the network outputs *it is useless as a computing device*.

It is clear that we want to avoid decoherence, or at least diminish its impact on our computing device.
For this we need **quantum error correction**: we encode the state of a single (logical) qubit across several (physical) qubits.

**!!!TODO!!! generalised decoherence as controlled- U gate, varying from \mathbf{1} to controlled-\texttt{NOT}**

## 11.3 Evolution of density operators under decoherence

In terms of density operators, the qubit alone evolves from the pure state **coherences**, vanish as

Notice that
*only* when

## 11.4 Quantum errors

The most general qubit-environment interaction

- nothing (
\mathbf{1} ), - phase-flip (
Z ), - bit-flip (
X ), or - both bit-flip and phase-flip (
Y ).

This is certainly the case when the states

What is important here is the discretisation of errors, and the fact that we can reduce quantum errors to *two types*: bit-flip errors

In general, given *this is not quite accurate if the corresponding states of the environment are not mutually orthogonal*, but it gives the right kind of intuition nonetheless.
Here the index

## 11.5 Same evolution, different errors

We can always pick up an orthonormal basis *not* unitary.
Now, the evolution of the density operator

## 11.6 Some errors can be corrected on some states

Alice prepares a quantum object in some state *some states*

Let

As an example, consider an object composed of three qubits and the subspace

## 11.7 Repetition codes

In order to give a sense of how quantum error correction actually works, let us begin with a *classical* example of a repetition code.
Suppose a transmission channel flips each bit in transit with probability *quantum* case, however, is more complicated, because we have both bit-flip *and* phase-flip errors.

## 11.8 Quantum error correction

In order to protect a qubit against bit-flips (incoherent

Suppose that at most one qubit is then flipped (say, the second one).
The encoded state then becomes

We measure the two auxiliary qubits, also known as **ancilla bits**, and the result of the measurement, known as the **error syndrome**, tells us how to reset the three qubits of the code.
The theory behind this network runs as follows.

If qubits one and two (counting from the top) are the same, then the first ancilla is in the

## 11.9 Turning bit-flips into phase-flips

The three-qubit code that we have just demonstrated is sufficient to protect a qubit against single bit-flips, but not phase-flips.
But this is good enough.
Recall that

## 11.10 Dealing with bit-flip and phase-flip errors

We can now put the bit-flip and phase-flip codes together: first we encode the qubit using the phase-flip code, and then we encode each of the three qubits of the code using the bit-flip code. This gives an error correction scheme that allows us to protect against both types of error, thus yielding a code that encodes a single logical qubit across nine physical qubits, protecting against a single quantum error on any of the nine qubits.

If we want to preserve a quantum state for a long time without doing any computations, or if we want to send it through a noisy communications channel, we can just encode the state using a quantum code and decode it when we are done. Computation on encoded states using noisy gates requires few more tricks.

**!!!TODO!!! (“to be completed”)**

## 11.11 Remarks and Exercises

**!!!TODO!!!**