# Topological error correction

How can we use topology to protect quantum computers from errors?

Errors in quantum computers are unavoidable. Controlling qubits stored in individual electrons or photons is simply much more challenging than controlling macroscopic flows of charge in traditional computers.

The world record for the lifetime of a qubit is 39 minutes at room temperature, after which all quantum information is lost. With better technology, we might be able to push to slightly longer lifetimes. But for quantum computations much longer lifetimes are needed. To do this we will need to use quantum error correcting codes to make a logical qubit. The approach allows use to extend the lifetime as long as we need, provided we use enough physical qubits (maybe hundreds or thousands will be needed).

It is actually quite remarkable that quantum error correction is possible at all. With binary data it is possible to we make many copies and store each copy in a different location. Making enough copies it is highly unlikely that all copies will become damaged at the same time! However, quantum mechanics is governed by the no-cloning principle, which says that a quantum state cannot be copied. It is easy to see that no-cloning follows from the more widely known Heisenberg uncertainty principle. The uncertainty principle tells us that we can’t learn everything about a quantum particle. For instance, we can’t learn both its position and its momentum. Although, we can choose one of these things to measure and reveal itself. If we were able to clone quantum states, then from one clone we could learn the position and form the other clone we could learn the momentum. So cloning is impossible (assuming Heisenberg was right!).

Making many copies of something is a sort of encoding process where 0 is encoded as 000..000 and 1 is encoded as 111…111. Because of no-cloning we won’t be able to perform a quantum copying process enacting
$\vert \psi \rangle \rightarrow \vert \psi \rangle \vert \psi \rangle \cdots \vert \psi \rangle \vert \psi \rangle$
for all $\vert \psi \rangle$ (in Dirac notation). But other encoding are possible that can protect our quantum information. We often write
$\vert 1 \rangle \rightarrow \vert 1_L \rangle$
$\vert 0 \rangle \rightarrow \vert 0_L \rangle$
where $\vert 0_L \rangle$ and $\vert 1_L \rangle$ are simply labels to reprents the logical 0 and logical 1 quantum states. Other quantum states are encoded (respecting the linearity of quantum physics) via
$\alpha \vert 0 \rangle + \beta \vert 0 \rangle \rightarrow \alpha \vert 0_L \rangle + \beta \vert 1_L \rangle$
The encoding is then useful if there exist measurements that enable to detect the presence of errors without learning any logical information (e.g. we the measurement results are not influneced by whether we were orginally in the state $\vert 0_L \rangle$ or $\vert 1_L \rangle$). For more details, good introductions to quantum error correction include: an early review by Gottesman (arXiv:0904.2557), Chapter 10 of Nielsen and Chuang and a more modern review by Barbara Terhal.

An important class of error correcting codes are the so-called topological (or homological) codes. These codes are built using an array or lattice of qubits arranged on a surface (or higher dimensional structure). On local patches of the lattice different logical states look indistinguishable. On every such local patch, there are measurable quantities that can detect the presence of errors. Physicists often think of these codes as being the lowest error states of some local Hamiltonian, with individual errors creating localised excitations. The quantum information is instead stored on large scale features of the lattice, such as non-contractible loops on a donut. Below I illustrate this for the toric code, which is the best code to learn about if your new to the subject src=”https://earltcampbell.files.wordpress.com/2017/05/homology-01.jpg&#8221; alt=”homology-01″ width=”1833″ height=”592″ class=”alignnone size-full wp-image-843″ />

If you want to learn more about the connection between homology/topology and error correction, I recommend: Dan Browne’s lecture notes, a tutorial talk that Dan gave at QEC in Zurich and appendix A of arXiv:1311.4895.

## Hyperbolic surface codes

Hyperbolic geometries have a curvature that means distances are distorted whenever we try to project it into a familiar Euclidean plane (e.g. see left). We can use these geometries to constuct bizarre variants of the toric code, with the advantage that hyperbolic codes can more efficiently pack in quantum information. So we get the same number of logical qubits using fewer physical qubits. Though this is only true assuming the hyperbolic toric code is just as good at correcting errors as the familiar Euclidean toric code. In a recent project with collaborators in Germany and Canada, we found hyperbolic codes that do indeed have a similar error correcting properties to the toric code (e.g. similar thresholds). We also asked how one might perform computation in the world of hyperbolic space. The conventional toric code has dominated the field for over the decade, but this work finally shows we can do better. Read more here arXiv:1703.00590

## Cellular automata decoders

We never directly see errors but rather evidence of them (e.g. the endpoints of error strings). An important problem is the design of fast software that can take this evidence and make a good educated guess at what error patern generated it. This is called the decoding problem and there are lots of ideas on how to tackle it, including the infamous minimum-weight perfect-matching decoder. In collaboration that started in my Berlin days, we looked at a different approach based on cellular automata. You can see our cellular automata decoder at work in the video below.

[Credit: simulation and video by Michael Herold]

The relevant papers are
nature partner journal: Quantum Information. 1 15010 (2015)
arXiv:1511.0557 (accepted in NJP)

## Qudit topological codes

Qudits are d-level quantum systems with d>2. Just like qubits (the d=2 case) they can form the basis of quantum computation. With collaborators, we have looked at implementing qudit topological codes.

We took a qudit analog of the toric code and developed decoding software to study how well it tolerates noise. Qubit are a very special case, so not all the qubit decoding methods (e.g. MWPM) carry over to qudits. We used two different renormalisation approaches to decoding and found qudit codes to be very promising (much higher thresholds). Read more here New J. Phys. 16 063038 (2014)

In another project on qudit topological codes, we investigated their computational features. Different codes allow different quantum logic gates to be implemented fault-tolerantly (e.g. transversally). From this perspective, the colour codes are especially interesting and allow a very rich group of quantum logic gates. Previously, they were only understood in the qubit setting and we proved some interesting fault-tolerance properties of their qudit cousins. Read more here Phys. Rev. A 92, 022312 (2015)

These qudit projects complement other projects on qudit magic state distillation. Together these qudit research projects show us how to build a fault-tolerant quantum computing using qudits, and they also show that it could be a lot more efficien than the conventional qubit approaches.