PaperlayerView exact revision on arXiv

Source-linked AI summary

Fault-tolerant execution of error-corrected quantum algorithms

Michael A. Perlin, Zichang He, Anthony Alexiades Armenakas, Pablo Andres-Martinez, Tianyi Hao, Dylan Herman, Yuwei Jin, Karl Mayer, Chris Self, David Amaro, Ciaran Ryan-Anderson, Ruslan Shaydulin

arXiv:2603.04584v1quant-ph

TL;DR

End-to-end fault-tolerant execution of complex logical algorithms remains an open challenge because many quantum-error-correction primitives must operate together. The paper combines Steane-code fault-tolerant gadgets to run QAOA and HHL on trapped-ion processors, finding near-break-even performance and improvements from active QEC and repeat-until-success procedures.

  • Problem

    Complex algorithmic circuits using only fault-tolerant components have not yet been demonstrated below break-even, where encoded execution outperforms direct physical execution.

  • Method

    The authors benchmark and combine Steane-code fault-tolerant gadgets to execute QAOA and HHL on Quantinuum H2 and Helios trapped-ion processors.

  • Results

    The experiments achieve near-break-even performance for complex Steane-encoded algorithmic circuits and demonstrate error suppression through active QEC and reduced discard rates through dynamic repeat-until-success subroutines.

  • Takeaways & Limitations

    Application-level benchmarks integrate the components required for fault-tolerant execution while exposing system-level challenges, including dynamic compilation bottlenecks in HHL.

Abstract

from arXiv · show

Scaling up quantum algorithms to tackle high-impact problems in science and industry requires quantum error correction and fault tolerance. While progress has been made in experimentally realizing error-corrected primitives, the end-to-end execution of logical quantum algorithms using only fault-tolerant (FT) components has remained out of reach. We demonstrate the FT and error-corrected execution of two quantum algorithms, the Quantum Approximate Optimization Algorithm (QAOA) and the Harrow-Hassidim-Lloyd (HHL) algorithm applied to the Poisson equation, on Quantinuum H2 and Helios trapped-ion quantum processors using the $[[7,1,3]]$ Steane code. For QAOA circuits on 5 and 6 logical qubits, we show performance improvements from increasing the number of QAOA layers and the number of $T$ gates used to approximate logical rotations, despite increased physical circuit complexity. We further show that QAOA circuits with up to 8 logical qubits and 9 logical $T$ gates perform similarly to unencoded 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. Finally, we show that adding active QEC cycles and increasing the repeat-until-success limit of state preparation subroutines can improve the performance of a quantum algorithm, thereby demonstrating critical capabilities of scalable FT quantum computation. Our results are enabled by an FT logical $T$ gate implementation with an infidelity of $\sim 2.6(4)\times10^{-3}$ and dynamic circuits with measurement-dependent feedback. Our work demonstrates near-break-even performance of complex, error-corrected algorithmic quantum circuits using only FT components.

I. INTRODUCTION

End-to-end fault-tolerant execution remains challenging because application circuits require many interacting primitives. This work benchmarks Steane-code gadgets and executes QAOA and HHL algorithms on trapped-ion processors, approaching algorithmic break-even.

  • Below-threshold memories and primitives have been demonstrated, but complex algorithmic circuits that outperform unencoded physical circuits remain an outstanding challenge.
  • The work executes error-corrected QAOA and HHL circuits using only fault-tolerant gadgets on Quantinuum H2 and Helios trapped-ion processors.
  • 2.6(4)×10^-3 approximate infidelity per logical T gate is achieved with a fault-tolerant implementation, improving on a prior non-fault-tolerant logical T gate.The reported Ramsey sequence used 16 T gates and achieved fidelity 0.960(6) on H2-1.
  • QAOA performance improves with increasing depth and T-gate count despite greater physical circuit complexity.
  • Repeat-until-success limits reduce post-selection discard rates to nearly zero, while active QEC improves logical circuit fidelity in HHL benchmarks.
  • The Steane code encodes one logical qubit into 7 physical qubits and has distance 3, supporting transversal Clifford operations and fault-tolerant computation.

C. Measurement and decoding

Steane-code measurement decodes noisy physical readouts into logical outcomes, while repeat-until-success preparation and error-correction gadgets support fault-tolerant state and gate operations. Specialized preparation circuits reduce resource requirements for non-Clifford states.

  • Measurement and decoding: A logical Z-basis measurement decodes a 7-bit physical readout using its syndrome, then obtains the logical result from the corrected bitstring parity.
  • State preparation: Fault-tolerant |H⟩ preparation measures H and performs quantum error detection, restarting when the measurement indicates a preparation error.
  • Non-Clifford gates: The prepared |H⟩ state is converted to |T⟩ and consumed by a teleportation gadget to implement a logical T gate.
  • Quantum error correction: Steane QEC copies physical errors to an ancilla block without changing the logical state, then measures the ancilla to diagnose errors for correction or software tracking.
  • Quantum error correction: Steane-swap QEC instead corrects errors passively by decoding them through a logical measurement on the source block.
  • State preparation: The specialized |H⟩ circuit uses two stabilizer measurements and a shorter preparation circuit, compared with six stabilizer measurements in the straightforward protocol.

III. APPLICATION BENCHMARKS

The application benchmarks apply QAOA to optimization problems and use QAOA outputs to identify optimal bitstrings. The section also introduces HHL as a quantum linear-systems algorithm with QPE ancillas and post-selection.

  • QAOA: QAOA prepares a parameterized state from a cost Hamiltonian and mixing Hamiltonian, then estimates success by repeatedly measuring candidate bitstrings.The success probability is the probability of measuring the optimization problem’s optimal solution.
  • HHL: HHL prepares a quantum state approximating a normalized solution to a linear system, using eigenvalue processing, uncomputation, and post-selection.The algorithm’s circuit includes QPE-related ancillas and an explicit measurement of the eigenvalue register.
  • Optimization benchmarks: The benchmarks cover LABS and binary unconstrained mean-variance portfolio optimization, with cost Hamiltonians obtained by promoting classical variables to quantum operators.LABS uses Pauli-Z operators, while portfolio optimization uses single-qubit projectors corresponding to asset-selection variables.
  • Optimization benchmarks: Portfolio instances are generated from historical equity price data through choices of expected returns and covariance matrices.The risk factor q balances risk and return in the objective function.

B. HHL

HHL addresses the quantum linear-systems problem by preparing a quantum state close to the normalized solution of Ax = b. Its original circuit combines state preparation, eigenvalue estimation, controlled inversion, eigenvalue uncomputation, and post-selection.

  • Problem formulation: HHL prepares a normalized quantum state |y⟩ that is ϵ-close to the solution state |x⋆⟩ of Ax = b.The formulation assumes appropriate access to b and A, with M ≤ N and ∥A∥ ≤ 1.
  • Complexity: HHL can have runtime Θ(κ log(1/ϵ)) in query complexity, with sparse-matrix implementations scaling as O(κ log(1/ϵ) polylog(M, N)).Here κ is related to the smallest nonzero singular value of A.
  • Scope: The quantum linear-systems output remains a quantum state, and extracting the full classical vector can remove the solver’s quantum speedup.The state is instead intended for measuring selected observables or serving as input to other quantum subroutines.
  • Algorithm: The original HHL circuit is organized around state preparation, eigenvalue estimation, eigenvalue inversion, eigenvalue uncomputation, and post-selection.The eigenvalue register is uncomputed before the final measurement and post-selection step.
  • Algorithm: Post-selection measures the final qubit register and retains executions with measurement outcome 0.The resulting state is the prepared solution state of the quantum linear-systems problem.

3 ) Eigenvalue inversion

The HHL benchmark uses a small Poisson-equation instance and compiles its logical circuit into fault-tolerant components. QAOA compilation similarly approximates continuous rotations with Clifford+T sequences and applies iterative circuit simplification.

  • Eigenvalue inversion: The HHL circuit contains an explicit eigenvalue-register measurement and post-selection on outcome 0.In the absence of errors, the QPE ancillas end in |0⟩ states that can support logical error detection.
  • Eigenvalue inversion: The benchmark solves the Poisson equation on a one-dimensional periodic lattice with L = 4 points using a structured toy problem.The circuit uses b = (1, −1, i, −i) and is constructed for near-term implementation.
  • Compilation: QAOA rotations are compiled into Clifford+T by mapping multi-qubit Z rotations to RZ gates and approximating them with synthesized T sequences.This compilation is needed because continuously parameterized rotations are not transversal under the relevant code constraints.
  • Compilation: In the HHL circuit, controlled-S gates use three T gates exactly, while controlled-RY(2π/3) is approximated with two T gates at channel fidelity ∼0.966.The controlled-RY approximation is the non-exact component described for this circuit.
  • Compilation: Logical benchmarking circuits are repeatedly optimized by gate merging, Pauli-frame-based simplification, and simplification around known initial states and measurements.The compilation cycle stops at a fixed point or after ten cycles.

IV. RESULTS

The component benchmarks evaluate state preparation, logical T gates, and QEC cycles using the Steane code before application-level benchmarking. Specialized state-preparation circuits reduce discard rates, while QEC cycles improve long Ramsey sequences but can reduce fidelity for shorter sequences.

  • |H⟩-state preparation: After post-selection, all |H⟩-state preparation methods have logical fidelities statistically indistinguishable from 1, while specialized circuits have roughly half the discard rate.The specialized circuits also reduce two-qubit gate depth from 25 to 9.
  • |H⟩-state preparation: The specialized |H⟩-state circuits reduce runtime and may reduce idling errors because their two-qubit gate depth is 9 versus 25 for the encoding circuit.The paper notes that computation is typically bottlenecked by the runtime of such subroutines.
  • T gates: The H2-1 Ramsey results are post-selected on successful logical |H⟩-state preparation because H2-1 has limited support for conditional ion transport.Application-level benchmarking on Helios allows conditional reset and restart of failed preparation protocols.
  • T gates: 2.6(4)×10^-3 per T gate is the reported infidelity for the fault-tolerant T-swap implementation, compared with 14 × 10^-3 for a prior non-fault-tolerant implementation.The T-swap Ramsey fidelity was 0.960(6) for a sequence of 16 T gates.
  • T gates: The measured Ramsey-fidelity decay is non-exponential, indicating that the independent-and-identically-distributed logical-error assumption does not describe the experimental data well.Correlated physical errors across T-gate gadgets may affect whether a logical error occurs.
  • T gates: Adding a QEC cycle between every pair of T gates restores exponential Ramsey-fidelity decay but decreases fidelity when the sequence contains ≲64 T gates.The added cycles increase opportunities for gate, measurement, and idling errors.

3. Quantum error correction

The paper benchmarks fault-tolerant QEC strategies and applies Steane-code gadgets to increasingly large QAOA circuits. Steane-swap performs best among tested QEC protocols, while encoded QAOA remains better than random guessing at the largest tested scale.

  • QEC benchmarking: Steane-swap outperforms Steane-bare and flag-FT in the tested QEC benchmark.The authors note that compiler limitations disadvantage flag-FT and that future compiler improvements may improve its fidelity.
  • QEC benchmarking: 1.79(3) × 10^-3 is the fitted entanglement infidelity for Steane-swap, compared with 3.53(12) × 10^-3 for flag-FT.The Steane-bare protocol exhibits non-exponential decay, preventing a principled entanglement-infidelity inference.
  • Application benchmarks: Increasing the logical T-gate budget improves QAOA success at depth p = 2 for both N = 5 and N = 6 LABS instances despite greater physical circuit complexity.For r = 1, two-qubit gate counts increase from 399 to 551 for N = 5 and from 420 to 686 for N = 6.
  • Application benchmarks: Increasing QAOA depth also improves success for N = 5 and N = 6 at fixed logical T-gate budget, with the N = 6 depth-2 circuit being Clifford.The N = 6 depth-2 circuit is slightly smaller physically than the depth-1 circuit.
  • Application benchmarks: For LABS instances up to N = 8, encoded circuits achieve success probabilities significantly above random guessing and comparable to unencoded execution.The experiments use parameter settings producing compiled circuits with fewer than 30 T gates.
  • Application benchmarks: The N = 12 portfolio circuit uses 97 physical qubits and 2132 physical two-qubit gates at p = 2, yet still outperforms random guessing.The p = 2 circuit performs worse than p = 1 because of its larger physical gate count.

2. HHL

The HHL benchmark tests logical state preparation on Helios while varying RUS limits and active QEC cycles. Two QEC cycles can improve fidelity, but additional cycles or higher RUS limits can introduce trade-offs, and substantial logical errors remain.

  • HHL results: r = 2 drives state-preparation discard rates nearly to zero but reduces HHL logical circuit fidelity.This trade-off differs from QAOA, where higher RUS limits had little performance effect.
  • Discussion: The HHL results place the Steane code near, but not yet below, algorithmic break-even for these circuits.The authors suggest dynamical decoupling, extended rectangles, or correlated decoding as routes toward suppressing the remaining logical errors.
  • Error diagnosis: Application-level benchmarking exposes behaviors that isolated component tests may miss, including the HHL fidelity penalty at higher RUS limits.The authors use effective RUS limits to separate hardware effects from software-level effects.
  • Error diagnosis: More than 0.3 of shots yield nonzero logical outcomes on QPE qubits even when state preparation succeeds frequently.The authors associate these outcomes with a large logical error rate not explained by the physical gate count alone.
  • Discussion: The processors operate near break-even for encoded algorithmic circuits involving dozens of physical qubits and hundreds of gates.The authors report that modest improvements to gadgets, compilation, decoding, or code choice may suffice to reach algorithmic break-even.

Appendix A: Improved magic-state preparation

This appendix describes the circuits and protocols used to implement fault-tolerant primitives and compile the logical HHL benchmark. It covers optimized magic-state preparation, flagged QEC, and the assembled HHL circuit.

  • Improved magic-state preparation: The improved |H⟩ preparation circuit reduces the two-qubit-gate count from 48 to 30.The construction modifies magic-state preparation and syndrome extraction while retaining fault-tolerant checks.
  • Improved magic-state preparation: Back-propagating an X representative until its support has weight 2 enables the logical rotation RX(θ) in magic-state preparation.The resulting subcircuit is additionally flagged to detect many errors at their origin.
  • Improved magic-state preparation: The final syndrome gadgets are selected by propagating possible Pauli faults through the non-Clifford circuit and minimizing the required stabilizer set.Redundant flag-at-origin gadgets are then removed where final syndrome measurements detect the same errors.
  • Flagged QEC: Flagged QEC measures XZZ and ZXX stabilizers, decodes syndromes, applies active correction, and corrects hook errors with logical operators.The protocol conditionally performs stabilizer measurements and uses syndrome information to determine logical X or Z corrections.
  • Logical HHL circuit: The logical HHL circuit combines quantum phase estimation and eigenvalue inversion for a least-squares Poisson-equation problem.The compiled circuit is arranged so its logical inputs and outputs match the reference HHL circuit.

1. Quantum phase estimation

The phase-estimation construction exploits the spectrum and Fourier structure of the normalized Poisson operator. These properties reduce the required precision and simplify controlled operations used in HHL.

  • Quantum phase estimation: Two bits of precision exactly resolve the eigenvalues {0, 1/2, 1/4} of the normalized operator A.The phase-estimation unitary is U = e^i2πA.
  • Quantum phase estimation: The quantum Fourier transform diagonalizes A, allowing the phase-estimation unitary to be represented through a diagonal operator.This structure is used to simplify the controlled powers of U.
  • Quantum phase estimation: U^2 simplifies to I ⊗ Z after the controlled operations are expressed with CNOT and controlled-Z structure.The simplification follows from the diagonal form of the transformed operator.
  • Quantum phase estimation: Controlled-S gates can be implemented with 3 T gates.This provides the Clifford+T realization used in the compiled phase-estimation circuit.
  • Eigenvalue inversion: The HHL eigenvalue-inversion circuit maps encoded eigenvalues λ_j to controlled ancilla rotations scaled by a constant C.The construction chooses C = 1/4 and implements the resulting transformations coherently.
  • Eigenvalue inversion: A controlled-RY(2π/3) gate is approximated by Clifford+T synthesis with channel fidelity approximately 0.966.The approximation uses the Solovay-Kitaev algorithm.

Appendix D: The Ramsey protocol with a dephasing noise model

The appendix models repeated noisy T gates in a Ramsey protocol as dephasing noise. It derives how the resulting fidelity depends on the number of T gates and the single-gate error parameter.

  • Dephasing model: The DepModel predicts exponential decay of Ramsey fidelity with the number n of applied T gates.The model uses a single error parameter p for repeated T-gate applications.
  • Dephasing model: After Pauli twirling, the noisy T gate is represented as an ideal T channel mixed with a dephasing channel D_z.The parameter p is interpreted as the probability of a dephasing event that removes relative-phase information.
  • Fidelity analysis: For an equal superposition input, the appendix states a closed-form fidelity for the n-fold noisy T operation relative to the noiseless target.The derivation uses that dephasing commutes with T and is a projection.
  • Fidelity analysis: The n-fold noisy operation expands into an ideal contribution weighted by (1 − p)^n and a dephased contribution with the complementary weight.This decomposition makes the dependence on the number of repeated T gates explicit.
  • Fidelity analysis: A single noisy T gate on |+⟩ has infidelity ε = p/2.Substituting p = 2ε recovers the corresponding expression cited from prior work.

Appendix E: Entanglement fidelity of a single-qubit channel

This appendix defines entanglement fidelity for a single-qubit channel and relates it to gate fidelity. It also develops a Pauli-basis representation using eigenstate projectors and considers depolarizing channels.

  • Definition: The channel fidelity is defined from a maximally entangled state by applying the channel to one subsystem and taking the resulting overlap.The displayed expression writes this overlap equivalently as a trace involving the channel acting on one half of the state.
  • Definition: Entanglement fidelity evaluates how a single-qubit channel affects entanglement between target qubits and the rest of a computation.For a d-dimensional system, it relates to gate fidelity through F_G = (dF_G + 1)/(d + 1) as stated in the supplied text.
  • Pauli-basis representation: The single-qubit expression can be expanded in the Pauli basis using projectors onto the eigenstates of X, Y, and Z.The projectors are ΠP,b = (I + (−1)^bP)/2, with P = ΠP,0 − ΠP,1.
  • Pauli-basis representation: Trace preservation ensures that the projector terms retain their traces during the channel expansion.The supplied derivation uses Tr[C(ΠP,b)] = Tr(ΠP,b) = 1 for the relevant projectors.
  • Depolarizing channel: A depolarizing mixture is analyzed as Qp = (1 − p)I + pD, where D maps every input state to the maximally mixed state.The appendix uses the identities I∘D = D∘I = D² = D in the corresponding proof.

Appendix F: Additional benchmarking data

This appendix explains the quantities recorded in the application-benchmark tables, including logical-qubit counts, T-gate counts, QAOA depth, and LABS merit factors. It also gives the asymptotic conjecture used as a reference for LABS performance.

  • Benchmark data: The benchmark tables report the logical-qubit count N, decomposed-circuit T-gate count n_T, and, for QAOA, the circuit depth p.They also include noise-free observables before and after decomposition for reference.
  • LABS metrics: The LABS merit factor is reported for bitstrings s ∈ {+1, −1}^N and used to characterize QAOA results.The supplied text introduces the merit factor as a quantity associated with LABS bitstrings and QAOA states.
  • LABS metrics: The asymptotic reference is F_opt^LABS ≈ 12.32 as N → ∞, which the appendix identifies as a conjectured limit.The text presents this value as a conjecture rather than an established result.

Appendix G: Logical errors and correlated decoding

This appendix shows that fault-tolerant gadgets alone do not guarantee suppression of logical errors beyond O(p). It explains how correlated errors can propagate through encoded circuits and identifies the application tables documenting the benchmark settings.

  • Logical-error limitation: O(p) logical error rates can persist in a toy Steane-code circuit even when physical operations are replaced by fault-tolerant gadgets.The example is explicitly presented as a case where encoding and fault-tolerant gadgets do not improve the physical-error scaling.
  • Correlated errors: Weight-2 mixed X- and Z-type errors from state preparation can change type under S-type gates and propagate through logical CNOT gates.The supplied example gives X_0Z_1 as a representative correlated error and describes its transformation under an SX gate.
  • Correlated errors: A propagated physical error can be decoded as a logical error, showing that naive decoding may fail to correct correlated measurement effects.The text states that the lower-qubit measurement errors are decoded into a logical error with at least the propagated physical-error probability.
  • Logical-error limitation: Suppressing logical errors beyond O(p) requires more than merely substituting physical gates with fault-tolerant gadgets.The appendix uses this example to motivate additional treatment of correlated errors in the logical circuit.
  • Benchmark scope: Tables I–V document QAOA and HHL benchmark configurations, including QEC-cycle settings and effective repeat-until-success limits.Tables I–IV cover QAOA instances, while Table V reports decomposed HHL data and post-selection conditions.
Loading 2603.04584v1…