Skip main navigation

New offer! Get 30% off your first 2 months of Unlimited Monthly. Start your subscription for just £35.99 £24.99. New subscribers only T&Cs apply

Find out more

Error Propagation and Threshold

Dr. Simon Devitt rejoins us to describe how errors propagate in a system and what a quantum error correction threshold is.
Tell me about actually executing gates on top of error correction, how hard is that? What we’ve got to be very careful is to how we do it because when you’re executing gates on an error corrected system, whether it’s for the error correction or the logic operations themselves, we are starting to replace one gate with many gates. One qubit with many qubits in order to do the encoding and then do the operations. Obviously, the question is, well, are we actually making things worse?
Every qubit has got an error, every gate has got an error, so if we replace every fundamental operation with a hundred operations, this can be a problem, so what we have to do is design these systems using a principle called Fault Tolerance. This is not a principle that’s unique to quantum computing. It exists in classical computing and has been talked about for many, many years. The principle is very, very simple. When you design a quantum circuit, sometimes there’s multiple ways in which you can design it. You can have quantum circuits that do the same thing, but look structurally different. The gates you apply, which qubits you apply them to, and when.
What you have to do when you’re designing something fault-tolerantly is you have to design these circuits in such a way that errors don’t spread too much. Errors can spread through quantum gates. If I get an error on this qubit here, and I have this gate operation, it can spread through that gate to a second qubit. If you design circuits badly, these errors can cascade out of control. A single error can turn into hundreds of errors, if your circuit is designed badly.
What we do when we do fault tolerance circuit design is that we are basically checking, okay, how the errors spread when I do this, are they spreading too badly; if they are, we have to redesign it, until generally we try and stop the circuits from creating any more than two errors, if one actual error occurs. This is the principle that we call Fault Tolerant Circuit Design. Okay.
What ends up happening after that is you start asking the question with quantum computing and quantum error correction of when do things start getting better. If my error rate is too high, I have added a lot more machinery to do my error correction. Even if errors don’t spread, they just might occur too frequently and the error correction will collapse. In the process of doing the error correction, we are actually introducing errors into the system? Yeah, exactly.
If our error rates are too high, we introduce too many errors and the whole thing collapses and we can’t do any computation with it, but if the error rate is small enough, the code is actually correcting more errors than it’s introducing by us doing all this extra stuff. Now, that point, that crossover point, where our error rate becomes small enough that the error correction starts working is what we call the Fault Tolerant Threshold. If our error rates are below threshold, we are correcting more errors than we are creating and everything works fine. If we are above threshold, we are creating errors too fast, the error correction code can’t keep up and everything is going to collapse almost instantaneously.
The fault tolerant threshold is actually one of the major calculations we do when we analyze error correction codes. This threshold that you’re talking about, that’s the probability that an error happens in a physical gate when you’re doing something on these physical qubits? Yeah, and you can say, well, it’s either a gate operation or maybe it’s just a little bit of memory time. We are going to hold this qubit for a microsecond or a millisecond, what is the probability that I experience a bit-flip or a phase-flip at that little time-window that we set aside that the qubit is just sitting there doing nothing or perhaps doing a gate operation.
You can characterize that number and say what is that probability and then you analyze the code and say, “Well, how small does that need to be in order for the code to correct more errors than it’s causing and for error correction to work for a large-scale machine?”

Dr. Simon Devitt of Turing, Inc. rejoins us to describe how errors propagate inside a quantum system, and how that leads us to determine a threshold for a quantum error correction code. When the probability of error on a single gate is above that threshold, error correction makes things worse instead of better. When the probability of error is below the threshold, the overall quality of our system begins to improve.



This article is from the free online

Understanding Quantum Computers

Created by
FutureLearn - Learning For Life

Reach your personal and professional goals

Unlock access to hundreds of expert online courses and degrees from top universities and educators to gain accredited qualifications and professional CV-building certificates.

Join over 18 million learners to launch, switch or build upon your career, all at your own pace, across a wide range of topic areas.

Start Learning now