Fault-tolerant execution of error-corrected quantum algorithms

This paper demonstrates the first end-to-end fault-tolerant execution of error-corrected quantum algorithms (QAOA and HHL) on Quantinuum trapped-ion processors using the $[[7,1,3]]$ Steane code, achieving near-break-even performance and showing that active error correction can improve algorithmic results despite increased physical circuit complexity.

The Gist

Imagine you are trying to build a skyscraper out of Jenga blocks. The problem is that the blocks are wobbly, the wind is blowing, and if you touch one wrong, the whole tower might collapse. This is the current state of quantum computers: they are incredibly powerful but also incredibly fragile. A single bit of noise (like a tiny vibration or heat) can ruin a calculation.

To solve this, scientists use Quantum Error Correction (QEC). Think of this as building a "logical" block out of seven "physical" Jenga blocks glued together. If one of the small blocks wobbles, the glue and the other six blocks hold the shape, and the "logical" block stays perfect.

This paper is a report card on a team that finally managed to build a small, working skyscraper using only these glued-together logical blocks, without ever touching the wobbly raw blocks directly. They did this on two of the world's most advanced quantum computers (Quantinuum's H2 and Helios).

Here is a breakdown of their journey using simple analogies:

1. The Goal: "Break-Even"

In the past, building a "logical" block (the safe, glued-together version) was so expensive and slow that it was actually worse than just using the raw, wobbly blocks. It was like hiring a team of 100 people to carry one brick; the team would trip and drop it more often than a single person would.

The goal of this research was to reach "Break-Even." This is the moment where the team of 100 people (the error-corrected logical qubit) actually does a better job than the single person (the physical qubit). The paper shows they have reached a point where they are almost at break-even, and for some tasks, they are already beating the raw hardware.

2. The Tools: The "Steane Code"

The team used a specific recipe called the Steane code. Imagine this as a specific blueprint for how to glue your 7 blocks together.

• The Magic Ingredient (T-gates): To do complex math, you need a special tool called a "T-gate." In the past, making this tool was like trying to bake a cake with a broken oven; it often came out burnt (low fidelity).
• The Upgrade: The authors invented a new, better way to bake this cake (a "fault-tolerant T-gate"). They improved the success rate from about 86% to 96%. This is a huge leap, like going from a shaky ladder to a solid staircase.

3. The Tests: Two Different Games

To prove their system works, they didn't just check if the blocks stayed still; they made the blocks play two different games.

Game A: The Optimization Puzzle (QAOA)

• The Analogy: Imagine you are trying to find the best route for a delivery truck visiting 12 cities. There are billions of routes, and you want the shortest one.
• The Result: They ran this puzzle with up to 12 logical qubits (which actually used 97 physical blocks!). Even though the "glued" version was more complex and had more chances to fail, it actually found better solutions than the raw version.
• The Surprise: They found that adding more layers to the puzzle (making it harder) actually helped the computer find the answer, even though it usually makes things noisier. This suggests that with enough error correction, quantum computers can handle complex problems that classical computers struggle with.

Game B: The Math Solver (HHL Algorithm)

• The Analogy: This is like solving a massive system of equations to predict weather or simulate a chemical reaction.
• The Result: They solved a simplified version of this (the Poisson equation). They found that by adding "checkpoints" (error correction cycles) in the middle of the calculation, they could fix mistakes as they happened, keeping the answer accurate.
• The Lesson: They discovered that sometimes, the software compiling the instructions was the bottleneck, not the hardware. It's like having a great car but a bad GPS; the car is fast, but the GPS sends you in circles. By fixing the "GPS" (the compiler), they improved the results.

4. The "Retry" Button (Repeat-Until-Success)

One of the coolest tricks they used is called Repeat-Until-Success (RUS).

• The Analogy: Imagine you are trying to pour water into a cup without spilling. If you spill, you don't give up; you just clean the table and try again.
• The Innovation: In the past, if a step failed, the whole computer had to stop and restart the whole program. The authors built a system where, if a small part fails, the computer just retries that specific part instantly.
• The Result: This reduced the number of times they had to throw away the whole experiment from a high rate to almost zero. It's the difference between a chef throwing away an entire meal because they dropped a salt shaker, versus just picking up the shaker and continuing to cook.

5. The Big Picture: Why This Matters

This paper is a milestone because it proves that fault-tolerant quantum computing is real.

• Before: We could only show off tiny, isolated tricks with error correction.
• Now: They ran full, complex algorithms from start to finish using only error-corrected parts.
• The Future: They are currently at "near-break-even." This means we are on the very edge of the "Early Fault-Tolerant Era." With a few more improvements (better software, better cooling, better glue), these logical computers will start solving problems that are impossible for today's supercomputers.

In summary: The authors took a fragile, wobbly quantum computer and wrapped it in a safety net of error correction. They proved that this safety net doesn't just protect the computer; it actually makes it smarter and more capable, paving the way for the next generation of quantum supercomputers.

Technical Summary

Here is a detailed technical summary of the paper "Fault-tolerant execution of error-corrected quantum algorithms."

1. Problem Statement

Scaling quantum computers to solve high-impact scientific and industrial problems requires Quantum Error Correction (QEC) and Fault Tolerance (FT). While recent experiments have demonstrated "break-even" performance for simple primitives (where logical error rates are lower than physical error rates) and small error-corrected circuits, the end-to-end execution of complex logical algorithms using only fault-tolerant components has remained out of reach.

Key challenges include:

• Integrating the full stack of QEC components (state preparation, gates, measurement, decoding) into a single pipeline.
• Managing the massive overhead of physical qubits and gates required for logical operations.
• Achieving "algorithmic break-even," where a logically encoded, fault-tolerant algorithm outperforms the same algorithm run directly on physical (unencoded) qubits.
• Handling dynamic control flow (e.g., repeat-until-success protocols) required for FT without introducing prohibitive discard rates.

2. Methodology

The authors executed and benchmarked two distinct quantum algorithms on Quantinuum's trapped-ion quantum processors (H2-1, H2-2, and Helios) using the Steane [[7,1,3]] code.

Hardware & Architecture

• Platform: Trapped-ion quantum computers (QCCD architecture) supporting qubit movement and real-time classical feedback.
• Error Correction Code: Steane code, encoding 1 logical qubit into 7 physical qubits with distance 3.
• Fault-Tolerant Gadgets:
  • Logical T Gates: Implemented via "T-swap" and "T-bare" gadgets consuming magic states.
  • State Preparation: Improved repeat-until-success (RUS) protocols for preparing $|H\rangle$ and $|T\rangle$ states.
  • QEC Cycles: Comparison of "Flag-Fault-Tolerant" (flag-FT), "Steane-bare," and "Steane-swap" strategies. The Steane-swap strategy (teleporting data to a fresh block) was found to be superior.
  • Dynamic Circuits: Utilization of real-time feedback for conditional branching and RUS subroutines.

Algorithms Benchmarked

1. Quantum Approximate Optimization Algorithm (QAOA):
   • Applied to Low-Autocorrelation Binary Sequences (LABS) (N=5 to N=9) and Portfolio Optimization (N=12).
   • Circuits were compiled from parameterized rotations to a Clifford+T gate set using the trasyn compiler.
2. Harrow-Hassidim-Lloyd (HHL) Algorithm:
   • Applied to a toy Poisson equation on a 1D lattice.
   • Used for demonstrating state preparation, eigenvalue estimation, and post-selection.

Compilation & Execution Strategy

• Logical Compilation: Rotations were decomposed into Clifford+T sequences.
• Physical Mapping: Logical circuits were expanded into physical circuits using Steane gadgets.
• Dynamic Control: The Helios processor allowed for real-time dynamic allocation of qubits and non-linear control flow (loops/branches), whereas H2-2 required serialized instructions.
• Repeat-Until-Success (RUS): The limit ($r$) on the number of attempts for state preparation subroutines was varied to test scalability and discard rates.

3. Key Contributions

A. Component-Level Improvements

• Logical T Gate Fidelity: Demonstrated a logical T gate with an infidelity of $\sim 2.6(4) \times 10^{-3}$ (fidelity $\approx 0.9974$), a significant improvement over prior non-fault-tolerant logical T gates ($14 \times 10^{-3}$).
• Optimized State Preparation: Introduced specialized circuits for $|H\rangle$ state preparation that reduced the discard rate by roughly half compared to previous encoding methods while maintaining high fidelity.
• QEC Strategy Selection: Identified Steane-swap (teleportation-based) as the most effective QEC strategy for active error correction on this hardware, outperforming flag-FT and Steane-bare methods.

B. Algorithm-Level Execution

• End-to-End FT Execution: Successfully ran QAOA and HHL algorithms using only fault-tolerant components (logical qubits, logical gates, and active QEC cycles).
• Scalability: Executed QAOA circuits with up to 12 logical qubits (97 physical qubits) and HHL circuits with 5 logical qubits.
• Dynamic RUS: Demonstrated that increasing the RUS limit ($r$) drastically reduces the program discard rate (to nearly zero) without significantly degrading algorithm performance, a critical capability for scalable FT.

4. Key Results

QAOA Performance

• Performance vs. Depth: For LABS instances (N=5, 6), increasing the QAOA depth ($p$) and the number of T gates improved success probability, even though physical circuit complexity increased.
• Break-Even Proximity: Encoded circuits with up to 8 logical qubits performed comparably to unencoded (physical) circuits.
• Large Scale: For the largest QAOA run (12 logical qubits, 2132 physical two-qubit gates), the algorithm achieved better-than-random performance, demonstrating that FT execution is viable for complex circuits.
• RUS Impact: Increasing the RUS limit from 1 to 2 reduced the hardware discard rate to nearly zero on Helios, proving the viability of dynamic protocols.

HHL Performance

• Error Suppression: Adding active QEC cycles improved the logical state fidelity (up to 0.97), but adding too many cycles introduced more errors than they corrected, indicating the system is near the "break-even" point but not yet below it for this specific algorithm.
• Software Artifacts: Analysis revealed that fidelity penalties associated with higher RUS limits were software compilation artifacts (how dynamic programs were written/compiled) rather than hardware limitations. This highlights the necessity of application-level benchmarking to uncover system-level behaviors.

Fidelity Metrics

• Logical T Gate: Infidelity $\approx 2.6 \times 10^{-3}$.
• QEC Cycle: Steane-swap showed an entanglement infidelity of $\approx 1.79 \times 10^{-3}$.
• Algorithm Fidelity: The HHL circuit achieved a target state fidelity of $0.97 \pm 0.02$ with 2 QEC cycles.

5. Significance and Implications

• Near-Break-Even Achievement: The work demonstrates that current trapped-ion hardware, combined with optimized FT gadgets, can execute complex, error-corrected algorithms with performance near the break-even point (where logical circuits match physical ones).
• Validation of FT Stack: It proves that the entire QEC stack (state prep, gates, measurement, decoding, and dynamic feedback) can work together in an end-to-end pipeline.
• Shift in Bottlenecks: The results suggest that while component error rates are improving, the bottlenecks for FT algorithms are shifting toward software compilation, dynamic program management, and correlated decoding strategies rather than just raw gate fidelity.
• Path to Scalability: The successful use of RUS protocols to eliminate discard rates provides a clear path for scaling FT quantum computers, as it allows for the rejection of faulty subroutines without aborting the entire computation.
• Future Directions: The authors note that further improvements in compiler optimizations (e.g., dynamical decoupling), extended rectangles (to enforce independent error assumptions), and correlated decoding are necessary to push performance definitively below the break-even point.

In summary, this paper marks a pivotal transition from demonstrating isolated fault-tolerant primitives to executing full, complex quantum algorithms with error correction, establishing a new benchmark for the "early-fault-tolerant" era of quantum computing.