Researchers have achieved fault-tolerant execution of quantum algorithms using 97 physical qubits, a significant step toward scalable quantum computation. The team from JPMorganChase and Quantinuum demonstrated the Quantum Approximate Optimization Algorithm and the Harrow-Hassidim-Lloyd algorithm on Quantinuum’s H2 and Helios processors, using the ⟦ 7, 1, 3 ⟧ Steane code for error correction. This work marks the first end-to-end execution of logical quantum algorithms using only fault-tolerant components, with the results showing better-than-random performance even with complex circuits containing 2132 two-qubit gates.

Steane Code Implementation for Fault-Tolerant Algorithms

A logical T gate, important for universal quantum computation using the Steane code, achieved 0.960(6) fidelity, a significant improvement over prior non-fault-tolerant implementations which demonstrated an infidelity of 14× $10^{- 3}$ . This new gate, tested on Quantinuum’s H2-1 processor, corresponds to an approximate infidelity of 2.6(4)× $10^{- 3}$ per T gate, marking a substantial reduction in error rates for this fundamental operation. The team benchmarked this and other circuit gadgets both in emulators and directly on the quantum hardware to optimize performance before scaling to more complex algorithms.

This represents a step toward practical quantum computation, as the HHL algorithm is applicable to solving linear systems of equations, a common task in scientific computing. The choice of the Steane code is notable, as it provides a specific approach to encoding and protecting quantum information from errors.

Beyond the HHL algorithm, the work also explored the Quantum Approximate Optimization Algorithm (QAOA) and the LABS problem, alongside binary portfolio optimization, to assess the broader applicability of the fault-tolerant system. All logical operators, once compiled, were stripped of overline notation to focus solely on logical degrees of freedom during the benchmarking process. The team’s component benchmarks informed their application-level testing of these small-scale quantum algorithms, demonstrating a methodical approach to building and verifying a fully fault-tolerant quantum system.

Quantinuum H2 and Helios Processors Enable Error Correction

Using 97 physical qubits, logical quantum algorithm execution has been achieved by Quantinuum’s H2 and Helios processors, a feat previously hindered by limited qubit counts and fidelity challenges. The work extends beyond simply demonstrating error-corrected primitives; it shows end-to-end execution with exclusively fault-tolerant components.

This is a key distinction, as it signifies a move toward genuinely robust quantum computation, capable of mitigating errors throughout the entire algorithmic process. The team benchmarked circuits on both emulators and the quantum hardware itself, assessing performance improvements as the number of layers and T gates increased within the QAOA circuits, despite the growing complexity of the physical circuits.

QAOA circuits with up to 8 logical qubits and 9 logical T gates perform similarly to unencoded circuits. Even with the largest QAOA circuits tested, involving 2132 two-qubit gates, the system still yielded better-than-random performance.

QAOA Performance Gains with Logical Qubit Scaling

Increasing the computational depth of quantum approximate optimization algorithms (QAOA) does not necessarily diminish performance even with the added complexity of error correction, the team demonstrated with circuits using up to 12 logical qubits. Performance improvements were observed by increasing both the number of QAOA layers and the logical T gates used to approximate rotations, despite a corresponding increase in the size of the underlying physical circuits.

For the largest QAOA circuits we run, with 12 logical (97 physical) qubits and 2132 physical two-qubit gates, we still observe better-than-random performance.

6(4) x 10^-3 Infidelity Achieved with FT Logical T-Gates

A logical T gate with an infidelity of 2.6(4)× $10^{- 3}$ . This gate, realized using the Steane code on Quantinuum’s H2 and Helios processors, is a key component in enabling universal quantum computation with error correction. This level of performance is important for scaling quantum algorithms beyond small experimental setups. Researchers found that simply counting logical T and CNOT gates to estimate circuit fidelity can be misleading, as factors like dynamic program compilation and the fault-tolerant composition of gadgets significantly influence overall performance.

Application benchmarks revealed the importance of these circuit-level considerations, highlighting that a precise noise model is needed to optimize Clifford+ $R_{Z}$ circuits into Clifford+T circuits. “Our results are enabled by an FT logical T gate implementation with an infidelity of ~ 2.6(4)× $10^{- 3}$ and dynamic circuits with measurement-dependent feedback,” the authors report. This suggests a viable pathway toward building larger, more robust quantum computers capable of tackling complex problems, and validates the approach of using only fault-tolerant components for end-to-end algorithm execution.

Steane Code QEC Cycle Benchmarking and Optimization

QAOA, a method for tackling optimization problems, relies on a cost Hamiltonian and mixing Hamiltonian, with performance influenced by parameters like QAOA depth, the number of layers in the circuit, and the vectors used to prepare the initial state. The HHL algorithm, applied to solving the Poisson equation, provided a second algorithmic test case, with a compiled logical circuit executed on the Helios processor. Detailed analysis focused on QAOA circuits ranging from five to twelve logical qubits, with corresponding physical qubit counts scaling up to 97, and physical two-qubit gate counts reaching 2132.

Harrow-Hassidim-Lloyd Algorithm Applied to Poisson Equation

The application of the Harrow-Hassidim-Lloyd (HHL) algorithm to the Poisson equation served as a second algorithmic test case, demonstrating the feasibility of solving linear systems on the Quantinuum H2 and Helios trapped-ion quantum processors. This implementation allowed for a small-scale demonstration of the algorithm’s potential in tackling problems relevant to fields like computational physics and engineering. A key element of this work involved an explicit measurement and post-selection on an “eigenvalue” qubit within the HHL circuit, a technique designed to aid in logical error detection.

The team’s approach used this characteristic to assess the effectiveness of the fault-tolerant framework, confirming the potential for robust error mitigation during the solution process. The successful execution of HHL, alongside QAOA, highlights the versatility of the Steane code and the potential for scaling these algorithms to tackle increasingly complex problems.

Repeat-Until-Success Improves State Preparation Fidelity

This enhancement was observed while preparing logical states encoded using the Steane code, a specific approach to stabilizing quantum information against errors. The team’s circuits, tested on Quantinuum hardware, used an improved method for fault-tolerant preparation of the |H⟩ state, an essential step in several algorithms. This suggests that optimizing the error correction code itself and the timing and placement of QEC cycles within a larger circuit, is critical for scaling quantum computation.

Near-Break-Even Performance of Error-Corrected Circuits Demonstrated

The work, conducted on Quantinuum’s H2 and Helios trapped-ion processors, achieved this improvement by strategically adding error correction and optimizing the repeat-until-success limit for state preparation, a technique that minimizes discarded results. These advancements facilitated near-break-even performance for complex algorithmic circuits built solely from fault-tolerant components, an essential distinction from prior demonstrations that often mixed conventional and error-corrected elements.

Quantum Approximate Optimization Algorithm (QAOA) circuits showed improved performance with increased depth and the inclusion of more T gates, despite the added complexity of the physical circuits. Encoded circuits using few T gates consistently matched the performance of their unencoded counterparts, suggesting that hardware and optimized fault-tolerant gadgets are driving these gains.

Increasing the allowed attempts within repeat-until-success subroutines had minimal impact on QAOA performance on H2-2 and no impact on Helios, while effectively reducing the rate of discarded results to near zero, a critical capability for scaling up quantum computations. The researchers report, highlighting the interplay between software and hardware improvements. These findings suggest that future upgrades to both hardware and software, including dynamical decoupling and circuit-level decoding, could push error-corrected algorithms beyond break-even performance, where logically encoded circuits consistently outperform unencoded ones.

👉 More information
🗞 Fault-tolerant execution of error-corrected quantum algorithms
✍️ Michael A. Perlin et al.
🧠 DOI: http://link.aps.org/doi/10.1103/gnq3-c2df

More like this