Quantum error correction has a promise baked into its name: take many flawed qubits, wire them into a code, and get one qubit that behaves better than any of the parts. For years that was a story told on whiteboards. The physical qubits you added to protect information tended to bring their own noise, and the machinery of measuring and correcting errors introduced fresh mistakes faster than it swept old ones away. The result was a protected qubit that was worse than an unprotected one. Adding redundancy made things go downhill.
The moment that flips is called break-even. It is the point where a logical qubit, encoded across a block of physical qubits, survives longer or computes more reliably than the single best physical qubit on the same chip. Break-even is not the finish line for fault tolerance, but it is the first hard evidence that the entire premise works. Below it, error correction is a physics demonstration. Above it, it becomes a tool.
Why the crossover is so hard
Encoding a logical qubit means spreading its information across many physical qubits so that no single fault destroys it. To catch errors, the machine repeatedly measures groups of qubits, producing what are called syndromes: hints about where something went wrong without revealing the encoded data itself. Those measurements need ancilla qubits, entangling gates, and readout, and every one of those operations can fail.
So the code is racing against itself. It fixes errors, but the act of fixing errors creates new ones. Whether you come out ahead depends on a brutal accounting. If the physical error rate per operation sits below the code's threshold, then making the code larger drives the logical error rate down. If it sits above, making the code larger makes everything worse. Break-even is the experimental proof that a real machine is on the good side of that ledger and can actually convert its overhead into a net gain.
Two ways to measure it
There is more than one honest way to ask whether you have crossed the line, and the distinction matters when reading claims.
- Memory break-even: Store a logical qubit, do nothing but keep correcting it, and see whether it holds its state longer than an idle physical qubit. This tests the code's ability to preserve information over time.
- Break-even under scaling: Compare a small code to a larger version of the same code. If the bigger one has a lower logical error rate, the machine is below threshold and improvements compound as you add qubits. This is the more demanding and more meaningful test, because it shows the path forward rather than a single lucky data point.
A convincing result also has to correct both bit-flip and phase-flip errors at once. Protecting against only one kind is easier and less interesting, since a full logical qubit needs both. The gold standard is a two-dimensional code, like the surface code, that guards against everything and still comes out ahead.
What it does and does not prove
Crossing break-even is a psychological and technical milestone, but it is worth being clear about its limits. A logical qubit that merely outlives its parts by a modest margin is not yet useful for a real algorithm, which may demand error rates a billion times lower than today's hardware delivers. What break-even proves is direction. It says the curve bends the right way, and that pouring in more qubits buys real protection rather than diminishing returns.
The economics behind it are steep. Reaching deep into the fault-tolerant regime can require hundreds or thousands of physical qubits per logical qubit, depending on the hardware quality and the code. Every incremental drop in the logical error rate costs more physical qubits, more cabling, more control electronics, and more cooling. That is why the physical error rate matters so much. A machine that squeaks past threshold pays an enormous overhead tax, while one that sits comfortably below it gets the same protection with far fewer resources.
The line everyone is chasing
Whether the qubits are superconducting circuits, trapped ions, or neutral atoms, the roadmap for each approach eventually runs through the same checkpoint. Vendors report physical gate fidelities and coherence times partly because those numbers predict how far past break-even a machine can push. The next question the field is already asking is not whether a single logical qubit can beat its parts, but whether many logical qubits can do so simultaneously while entangling with one another. That is the step from a protected memory to a protected computer, and the break-even line is the door it has to walk through first.
