Quantum error correction: what it is, how it works and why it is decisive

Quantum error correction is the true frontier of quantum computing, because more than the number of qubits, it is the ability to protect them from errors that will decide when a quantum computer moves from experiments to real applications. It is also the most technically demanding topic in the sector, and this guide tries to make it accessible without trivialising it, addressing why qubits make mistakes, why they cannot be corrected with classical methods, what the ingenious idea of redundancy without copying is, what surface codes and the fault-tolerance threshold are, as well as the real state of the art and how all this can be studied in quantum emulation, where every error and every correction becomes observable. It is worth clarifying right away that the disturbance we are talking about, decoherence, gate imperfection, is a physical phenomenon, tied to real hardware interacting with its environment, whereas in an emulation environment such as the one we will use later there is no spontaneous disturbance, because there is no physical machine to generate it. The approach remains educational, without giving up rigour, because this is the topic on which a good part of the industrial future of the sector is at stake.

What is quantum error correction?

Quantum error correction is the set of techniques that make it possible to run reliable computations on unreliable hardware, protecting quantum information from decoherence and from gate imperfections. The underlying idea is redundancy, because instead of entrusting a piece of information to a single fragile qubit, it is distributed across many qubits, so that an error on some of them can be detected and corrected without destroying the computation. It is the quantum analogue of the error-correcting codes that protect classical data in every hard disk and transmission, even though physical constraints make it enormously more subtle, as we shall see. Without it, quantum computing remains confined to short, noisy circuits, those of the NISQ era in which we find ourselves, while the transition to the fault-tolerant era, in which correction works continuously and reliably, is exactly what this technique makes possible.

Why do qubits make errors?

Qubits make mistakes for two physical causes which, with current technology, are difficult to avoid entirely, and which by definition concern real hardware, not a simulated environment. The first is decoherence, since every uncontrolled exchange with the environment, a thermal photon, a vibration, a stray field, acts as a partial measurement and degrades the state, with coherence times ranging from microseconds to minutes depending on the platform. The second is gate imperfection, because every operation has a fidelity below one hundred per cent and errors accumulate along the circuit. Unlike the classical case, quantum errors are continuous and of two types, bit and phase, and can occur in superposition. On a deep circuit, without correction, the probability of a correct result collapses exponentially with the number of operations, and this is why the circuits that can be run reliably today remain short. Beyond a certain depth the noise dominates the signal, and at that point, without correction, there is no remedy.

Why can’t classical methods be used?

Because two pillars of classical correction are forbidden in the quantum domain. The first is copying, because the no-cloning theorem prevents duplicating an unknown quantum state, so the trivial redundancy of saving three copies and taking a majority vote is impracticable. The second is measurement, since reading a qubit to check whether it has made an error destroys its superposition, erasing precisely the information one wants to protect. Quantum correction must therefore do the apparently impossible, that is, detect and correct errors without ever copying or directly reading the state of the data. That this is possible, as demonstrated by Peter Shor in 1995, remains one of the most surprising results of the entire discipline.

How do you correct without copying or measuring the data?

By combining two ideas. The first consists in distributing the logical information over the collective entanglement of many qubits, so that no single qubit contains the data, which lives instead in the correlations. The second provides that, instead of measuring the data qubits, dedicated ancilla qubits are measured, revealing the syndrome, that is, which error has occurred and where, without revealing anything about the protected logical value. The syndrome indicates, for example, that there was a bit-flip on the third qubit, without saying whether the logical data is 0 or 1. A classical decoding algorithm interprets the syndrome and prescribes the correction, in a mechanism that is counterintuitive but rigorous, since one always looks at the error and never at the data. This cycle, made up of syndrome measurement and conditional correction, repeats continuously throughout the computation, many times for each logical operation, so that correction accompanies every instant of execution instead of being limited to a final check.

What is the difference between physical and logical qubits?

This is the distinction that makes it possible to read every announcement in the sector correctly. The physical qubit is the real device, the superconducting circuit or the trapped ion, with all its fragility, while the logical qubit is a protected unit of information, built by making many physical qubits cooperate through an error-correcting code, and it is the reliable object on which the algorithm actually runs. The ratio between the two is the key figure, because with current codes and error rates hundreds to thousands of physical qubits are needed for each quality logical qubit, as already anticipated on the page about the qubit. This is why counting the physical qubits of a processor, without asking how many logical qubits can be obtained from them, remains an almost meaningless exercise. The right question to put to a vendor is not so much how many qubits it has, but how many reliable logical qubits it can sustain and with what logical error rate, because it is that number, more than the raw count, that tells how close we really are to real applications.

What are surface codes?

The surface code is today the leading candidate for solid-state hardware, for a fairly simple practical reason, because it requires only interactions between neighbouring qubits on a two-dimensional grid, compatible with the real chips that manufacturers already know how to build. The logical information is encoded in global topological properties of the lattice, protected from local errors, while the stabilisers, that is, parity operators measured on the ancillas, provide the syndrome without disturbing the logical state. It is an approach that lends itself well to growing over time, as the hardware improves, and it is precisely this scalability that makes it the preferred choice of a good part of the sector’s major research laboratories.

What is the fault-tolerance threshold?

The threshold theorem is probably the most important result in the whole field, because it establishes that there is a critical error rate per operation. If the hardware stays below that threshold, adding redundancy reduces the logical error by more than the redundancy itself introduces, and arbitrarily long computation becomes possible, whereas if it stays above it, correcting makes things worse. For surface codes the threshold lies at around one per cent error per gate, a value that the best hardware has recently begun to surpass in the laboratory. Staying stably below the threshold on many qubits, and not just on a few under ideal conditions, is the engineering challenge that separates the current era from large-scale quantum computing.

Where does research stand today?

Research is today in a phase of real, though still early, transition. In recent years the first laboratory evidence has been demonstrated that increasing the code size reduces the logical error, the expected signal of the below-threshold regime, and logical qubits have been realised with performance superior to the physical qubits that compose them. These are historic results, even if obtained on very few logical qubits and under controlled conditions. The leap towards the hundreds or thousands of logical qubits needed for applications, such as factoring with Shor’s algorithm, still requires years and progress on several fronts. The most serious estimates place useful fault-tolerant computing in the next decade, while honestly admitting wide margins of uncertainty, because anyone who gives precise dates, in either direction, ends up confusing the trajectory, which is clear, with the timing, which depends instead on engineering advances that have not yet happened.

Why is error correction so expensive?

Because the overhead multiplies at every level. Each logical qubit costs many physical qubits, each logical operation requires many cycles of syndrome measurement and correction, and some gates, such as the T gate needed for universality, require additional costly procedures such as magic state distillation. The result is that the millions of physical qubits estimated for applications such as RSA derive almost entirely from this overhead, rather than from the intrinsic size of the problem. Reducing it, thanks to better codes, higher-fidelity hardware and more efficient decoders, is the goal on which much of current research concentrates, because it is the lever that really brings applications closer, far more than simply increasing the qubit count.

How is error correction studied in emulation?

Emulation makes it possible to study it in the clearest possible way, because it makes visible what remains hidden on hardware, with a fundamental difference to bear in mind, namely that in a simulated environment there is no real decoherence, since there is no physical machine to generate it. In an environment such as the EQM platform used by HumanQ the disturbance does not occur spontaneously, but is recreated deliberately, because an error can be injected on a qubit on purpose, the syndrome can be watched lighting up on the ancillas, the decoder can be followed as it identifies and corrects, and it can be verified that the logical data has survived intact, so that the logical chain becomes a reproducible, controllable experiment instead of remaining an uncontrolled physical phenomenon. Different codes can be compared, the distance varied, noise models calibrated and the effective threshold estimated. For training the teams that will design the fault-tolerant era, and for assessing which code best suits a given hardware, it is the tool of choice, because it makes it possible to see correction at work instead of having only to imagine it.