Why do bit-flips still matter?
If you know cat qubits, you’ll know they have a superpower: they’re extremely good at resisting bit-flip errors. In fact, cats currently hold the world record for bit-flip lifetimes, and they’re not done yet.
As the graph below shows, their upper limit of protection just keeps improving, and is now in hours’ territory.
Figure 1 – Measured idle bit-flip lifetimes on Alice & Bob’s single-cat-qubit chips continue to increase as the technology advances.
For reference, this is many millions of times longer than any other superconducting qubit technology.
So why isn’t this already enough?
Say we wanted to run very large algorithms and tackle some of the hardest problems out there (that is after all why we’re building quantum computers at all), we would need to reach ridiculously low error rates.
Take demanding chemistry applications like simulating the molecule FeMoco. Our recent resource estimate showed we would need a 1e-9 logical error rate, about 1 error in every billion operations. Such rates are miles beyond anything that today’s best quantum hardware can do, even with hours-long bit-flip times.
And while we plan to keep pushing cats’ protection higher and higher, what if hardware stopped improving, or we simply wanted to reach these algorithms sooner than hardware advances?
The answer we came up with is Elevator Codes, a new way to achieve extremely low logical error rates on our existing hardware.
In our new preprint, we found that we could reach error rates 10 000x lower using only 3x more qubits, compared to Alice & Bob’s standard error correction architecture, the repetition code.
Passive vs Active Error Correction
First, why do cats so rarely flip? Well, its their physics. If you picture a cat state as two blobs on a Wigner function, we simply pull those blobs farther apart in phase space. Intuitively, we separate the logical “0” and “1.” As we do that, bit-flips become exponentially unlikely. There is a trade-off, though, and that is that while bit-flips become very rare, the other main error type, phase-flips, gets worse, at a roughly linear rate.
Since phase-flips don’t benefit from this passive protection, we must handle them “actively” using quantum error correction. Quantum error correction works by redundancy: you encode the information across several physical qubits, allowing you to build a better logical qubit.
Luckily, because we’re correcting for one error, we can use the very efficient repetition code. This lets us dramatically reduce the number of qubits we need compared with other codes that must correct for both errors equally, like the surface code often used with common qubits such as transmons.
Figure 2: Simplified schematic comparing a conventional error-correction architecture using standard superconducting qubits (surface code, left) with one based on cat qubits (repetition code, right).
So, now we have a logical qubit, formed through “passive” bit-flips suppression and “active” phase-flips suppression.
But that may be not enough. We are talking about running long and deep algorithms, where even extremely rare errors become problematic. Even if a logical qubit fails only once every million operations, an algorithm with millions or billions of gates will almost certainly see a failure sneak in somewhere, and a single uncorrected error can spoil the entire computation. This is why quantum computing, or any computing for what matters, demands extraordinarily low logical error rates.
For phase-flips this is “easy”, we just increase the size of our repetition codes. As the repetition code becomes longer, phase-flip occurrences become rarer, so that at one point they will reach our current bit-flip limit. At that point we would be stuck. In fact our bit-flip lifetime is as good as our hardware is and to improve it, we would need to wait for new generations of chips to be engineered… To reach lower logical error rates on our future Alice & Bob quantum computers, on the same hardware, we must find a way to actively protects against bit-flips too, introducing logical protection.
How?
Concatenated Codes
The repetition code does a great job on phase-flips. Could we find a way to retain these advantages for bit-flips too?
The noise bias allows us to leverage codes that are asymmetric in what they correct, which reduces overhead. Standard approaches would use a thin rotated surface code or a thin XZZX code, essentially patches of surface code with one of their sides shrunk down so that they form a rectangle instead of a square. The rectangular shape lets the surface code correct for a large amount of one type of error (phase-flips), intuitively, the longer side of the rectangle, while correcting a small amount of the other kind of error (bit-flips) on the shorter side of the rectangle.
But these codes are not that favorable, since they inherit much of the surface code’s overhead and relatively lower thresholds, especially when compared to repetition codes.
This brings us to concatenated codes, in which one error-correcting code is embedded inside another, a bit like in a russian doll. This allows each error type to be handled, and optimized for, at a different level.
The “Elevator” Idea
This is exactly the idea behind Elevator Codes. Using this concept of concatenation, we don’t need to replace the repetition code, rather we can “boost” it. This has an enormous advantage, which is using the same hardware architecture already engineered for the standard Alice & Bob approach.
For the inner code, we keep our repetition code to correct for phase-flips. For the outer code, we have a high-rate code, protecting against bit-flips. Crucially, we execute the outer code using the logical operators of the inner code, thus concatenating the two codes together.
You can think of the code as comprising of multiple strips of repetition code all stacked on top of each other, like floors of a building. We then take another strip of repetition code and use it as a logical ancilla, sweeping up and down the floors like an elevator. The key here is that we can use a single logical ancilla and recycle it, rather than using multiple of them that would “ruin” the low overhead.
As it sweeps past the rows of logical qubits, it measures the parity checks of the outer code using transversal CNOT operations. Once it has completed one check, the ancilla is measured, reset, and and is each time sent off down the block again to execute the next one. This means we only need one ancilla strip to execute all the outer code checks, massively saving us on qubit overhead.
Figure 3: Layout of a concatenated repetition code. 
are repetition codes and 
is an 
qubit code. The six blocks of the repetition code are used as the five data qubits and one ancilla qubit of the outer code. Logical CNOT and SWAP gates are executed via transversal CNOT gates to implement syndrome extraction of using the logical ancilla qubit.
Results
With Elevator Codes, we show that we could reach dramatically lower error rates for only a small cost in qubits compared with our current error correction, and at a lower cost compared with other codes like the thin surface code. To put this into context, at certain error rates, Elevator Codes have an overhead about 3 times lower than the leading alternatives.
As the graph below shows, we could reach a 10,000× lower logical error rate, with only around 3× more qubits.
This is because the repetition code can only ever achieve an error rate of 3.7e-8 at an overhead of 17 qubits, while the concatenated codes, or Elevator Codes, can get an error rate of 3.4e-12 for an overhead of 52 qubits.
Figure 4: Qubit overhead as a function of the logical error rate with repetition codes, concatenated repetition codes (this work), thin surface codes, and thin XZZX codes.
So, What Does This Mean?
As we saw at the outset, bit-flip lifetimes have continued to improve, and we fully intend to keep pushing them further.
But Elevator Codes give us the option to push their error resilience further sooner, by adding logical bit-flip protection on top of our existing cat-qubit designs and opening a practical path to reaching ultra-low logical error rates at low overhead.
This means it becomes far more attainable to build logical qubits that can last during long and demanding computations, and this is what we will need to turn quantum computers into machines that can tackle truly meaningful problems.
And this is only the beginning. These results are limited by what we can simulate classically; with larger, higher-rate codes, the gains could be even bigger.
For the Experts: Why Concatenated Codes?
So why do concatenated codes work so well here? It all comes down to thresholds and encoding rates. The original motivation for this work was to avoid the relatively low phase-flip thresholds of the surface codes. When you make the jump from a repetition code to a thin surface code, suddenly your phase-flip threshold goes from around 4% to around 1%. While this is achievable, it means that adding bit-flip protection by moving to the thin surface code is going to cost you drastically in overhead as your phase-flip distance needs to increase significantly.
Now compare this to the Elevator Codes. Here, we don’t affect the phase-flip threshold of the repetition code in a substantial way, meaning we add bit-flip protection without needing to drastically increase the distance of our phase-flip repetition codes. Furthermore, we can allow the outer code to be of high rate through a subtlety that protects us against hook errors.
We are free to pursue high-rate outer codes, savings on overhead, and this only gets more efficient as the blocks get larger.
Want to dive even deeper? Read the paper on ArXiv.
Written by paper authors Peter Shanahan and Diego Ruiz.
