We deploy a universal fault-tolerant quantum computing (FTQC) architecture based on error-detecting $[\![8,3,2]\!]$ and $[\![4,2,2]\!]$ codes on Quantinuum's Helios-1 trapped-ion quantum computer. We compile and execute ripple-carry adder (RCA) circuits for classical inputs up to five bits on this architecture. Uncomputing a workspace qubit provides an additional ``algorithmic check'' to detect errors. While available at both the physical and logical levels, this check synergizes with our architecture by increasing the effective fault distance of many circuit locations from two to four. Combining this algorithmic check with the error-detecting codes, we observed only a single logical failure in one-bit addition after burst-error filtering, yielding an estimated logical failure rate of $(6.0 \pm 5.9) \times 10^{-5}$. This is well below the $(3.5 \pm 1.3) \times 10^{-3}$ failure probability observed for one-bit addition on the same hardware in unencoded form. Two- and three-bit adders also showed performance improvements, while the longer four- and five-bit adders executed just above threshold.
AI Summary
This paper tests whether encoded ripple-carry addition can outperform unencoded execution on Quantinuum’s 98-qubit Helios-1 trapped-ion processor, and whether an algorithmic consistency check improves error detection. Cuccaro adders for one- to five-bit classical inputs are compiled into an existing architecture using $[\![8,3,2]\!]$ and $[\![4,2,2]\!]$ error-detecting codes, transversal gates, and teleportation-based code switching. Clifford proxy simulations guide implementation choices.
The additional check measures whether the initial carry workspace returns to $|0\rangle$. Error-propagation analysis shows that it detects otherwise harmful logical-$Z$ faults between Hadamards implementing Toffoli gates, increasing the effective fault distance from two to four at many, but not all, circuit locations. Experiments compare encoded and physical failure probabilities, with and without this check and with and without filtering jobs exhibiting atypically rapid syndrome rejection. With the check, encoded failure rates are below physical rates through three-bit addition; without it, only one-bit addition improves. After burst filtering, one-bit addition has one observed logical failure, giving $(6.0\pm5.9)\times10^{-5}$ versus $(3.5\pm1.3)\times10^{-3}$ physically.
These are conditional failure rates after post-selection: encoded acceptance falls from slightly above $60\%$ at one bit to approximately $1\%$ at five bits. Four- and five-bit encoded adders perform slightly worse than physical counterparts. Limitations include sparse failure statistics, burst filtering identified after collection, omitted syndrome extraction during idling, and serialized hardware operations. Only classical inputs are tested, with just-in-time preparation and early readout; coherent inputs or embedding within larger algorithms would require different scheduling. The five-bit behavior remains unexplained.
No sign of AI-generated textIncremental
Error found: The logical |000⟩ preparation caption incorrectly bounds propagated single-X errors by weight three modulo the X stabilizer: an error on wire four can propagate to X₄X₅X₆X₇, which has minimum weight four modulo that stabilizer but remains detectable by S₁.
Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.
We deploy a universal fault-tolerant quantum computing (FTQC) architecture based on error-detecting [[8,3,2]] and [[4,2,2]] codes on Quantinuum's Helios-1 trapped-ion quantum computer. We compile and execute ripple-carry adder (RCA) circuits for classical inputs up to five bits on this architecture. Uncomputing a workspace qubit provides an additional ``algorithmic check'' to detect errors. While available at both the physical and logical levels, this check synergizes with our architecture by increasing the effective fault distance of many circuit locations from two to four. Combining this algorithmic check with the error-detecting codes, we observed only a single logical failure in one-bit addition after burst-error filtering, yielding an estimated logical failure rate of (6.0±5.9)×10−5. This is well below the (3.5±1.3)×10−3 failure probability observed for one-bit addition on the same hardware in unencoded form. Two- and three-bit adders also showed performance improvements, while the longer four- and five-bit adders executed just above threshold.
This paper tests whether encoded ripple-carry addition can outperform unencoded execution on Quantinuum’s 98-qubit Helios-1 trapped-ion processor, and whether an algorithmic consistency check improves error detection. Cuccaro adders for one- to five-bit classical inputs are compiled into an existing architecture using [[8,3,2]] and [[4,2,2]] error-detecting codes, transversal gates, and teleportation-based code switching. Clifford proxy simulations guide implementation choices.
The additional check measures whether the initial carry workspace returns to ∣0⟩. Error-propagation analysis shows that it detects otherwise harmful logical-Z faults between Hadamards implementing Toffoli gates, increasing the effective fault distance from two to four at many, but not all, circuit locations. Experiments compare encoded and physical failure probabilities, with and without this check and with and without filtering jobs exhibiting atypically rapid syndrome rejection. With the check, encoded failure rates are below physical rates through three-bit addition; without it, only one-bit addition improves. After burst filtering, one-bit addition has one observed logical failure, giving (6.0±5.9)×10−5 versus (3.5±1.3)×10−3 physically.
These are conditional failure rates after post-selection: encoded acceptance falls from slightly above 60% at one bit to approximately 1% at five bits. Four- and five-bit encoded adders perform slightly worse than physical counterparts. Limitations include sparse failure statistics, burst filtering identified after collection, omitted syndrome extraction during idling, and serialized hardware operations. Only classical inputs are tested, with just-in-time preparation and early readout; coherent inputs or embedding within larger algorithms would require different scheduling. The five-bit behavior remains unexplained.
Quantum error correction (QEC) is beginning to enable logical operations that outperform their unencoded physical counterparts, but useful fault-tolerant computation will require more than low-error quantum memory. An effective architecture must orchestrate efficient logical encoding, low-overhead logical operations, and access to the non-Clifford resources required for universal computation. Here, we introduce and experimentally validate such an architecture based on the [[20,2,6]]C4-Helix code, designed for the early fault-tolerant regime. Using Quantinuum Helios, a 98-qubit trapped-ion quantum processor, we experimentally demonstrate the principal components of this architecture: we perform repeated quantum error correction with an error of 4.6−2.6+6.2×10−5 per logical qubit per QEC cycle. We benchmark the complete Clifford group on the two logical qubits of a single codeblock under active error correction, obtaining an error of 2.8−1.6+1.0×10−4 per two-qubit logical Clifford. We further demonstrate a fault-tolerant chain-map interface between C4-Helix and a distance-5 surface code, preparing a heterogeneous three-logical-qubit GHZ state with a fidelity lower bound of 99.925−0.245+0.068%. In each case, the encoded implementation outperforms its corresponding unencoded physical baseline without relying on postselection. Circuit-level simulations indicate that improvements in physical fidelity bring the same architecture into the 10−6-10−8 logical-error regime targeted for early fault-tolerant computation. Together, these results establish C4-Helix as a hardware-validated fault-tolerant architecture rather than a bare quantum memory.
Quantum error correction enables scalable fault-tolerant quantum computation by suppressing logical errors exponentially with code distance once physical error rates fall below a critical threshold. Here we demonstrate below-threshold operation of triangular color codes with distances d=3,5, and 7 on Quantinuum's Helios trapped-ion quantum processor. Leveraging both circuit- and hardware- level leakage reduction schemes, we achieve logical error rates as low as 5−2+4×10−6, and demonstrate error suppression by over an order of magnitude, Λ=12−2+3, with each successive increase in code distance. Moreover, we demonstrate below threshold scaling of error rates for Clifford two-qubit randomized benchmarking circuits when encoded in d=3,5 color codes, achieving logical error rate of 7−3+3×10−5 per logical two-qubit Clifford at distance 5 with a suppression factor of Λ=9−3+8. We compare logical performance for existing near-optimal algorithmic decoders, and both convolutional neural network and transformer-based neural network decoders capable of real-time decoding an order of magnitude faster than the syndrome extraction rate. These results approach the logical error rates required for megaquop-scale quantum computation and indicate that scaled trapped-ion processors could reach application-relevant performance with substantially smaller code blocks than indicated by previous results in other qubit modalities.
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 ∼2.6(4)×10−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.
We propose a fault-tolerant quantum computer architecture for trapped-ion devices, which we call the walking cat architecture. Our blueprint includes a compiler, a detailed description of all the quantum error-correction protocols, a micro-architecture, a sufficiently fast decoder, and thorough simulations. The backbone of the architecture is a cat factory, producing cat states distributed throughout the machine, which are consumed to perform logical operations. The walking cat architecture is based entirely on a modern quantum error-correction approach called low-density parity-check (LDPC) codes.
We identify promising instances of the walking cat architecture, such as (1) a simple architecture based on a single LDPC code, (2) a fast architecture based on fast logical gates relying on a [[70, 6, 9]] code, equipped with Clifford-frame tracking for any 6-qubit Clifford gate, and (3) a dense architecture based on a [[102, 22, 9]]] code encoding 22 logical qubits per memory block. Our dense architecture provides a design with 110 logical qubits executing about one million T gates per day using only 2,514 physical qubits. We estimate that the quantum Hamiltonian simulation of a Heisenberg model on 100 sites can be executed within one month with 10,000 physical qubits, including all shots required to achieve chemical accuracy, suggesting that such a device could enter the regime of classically intractable physics simulations.
Our design relies on hardware components that have been experimentally demonstrated on small devices. We emphasize simplicity over hypothetical performance to facilitate the practical realization of this machine. Based on this approach, we believe that a fault-tolerant quantum computer with hundreds of logical qubits capable of running millions of logical gates can be built in the near term, providing a platform to explore a broad range of applications.
Fault-tolerant operations based on stabilizer codes are the state of the art in suppressing error rates in quantum computations. Most such codes do not permit a straightforward implementation of non-Clifford logical operations, which are necessary to define a universal gate set. As a result, implementations of these operations must use either error-correcting codes with more complicated error correction procedures or gate teleportation and magic states, which are prepared at the logical level, increasing overhead to a degree that precludes near-term implementation. Here, we implement a small quantum algorithm, one-qubit addition, fault-tolerantly on a trapped-ion quantum computer, using the [[8, 3, 2]] color code. By removing unnecessary error correction circuits and using low-overhead techniques for fault-tolerant preparation and measurement, we reduce the number of error-prone two-qubit gates and measurements to 36. We observe arithmetic errors with a rate of ∼1.1 × 10−3for the fault-tolerant circuit and ∼9.5 × 10−3for the unencoded circuit.
A fully fault-tolerant implementation of the quantum error-detecting Iceberg [[2m,2m−2,2]] code applied to a Toffoli circuit achieved beyond-break-even error detection on a leading trapped-ion quantum computer, where the effect of encoding a circuit with a quantum error-detection code enables increased fidelity compared to an unencoded circuit. This code was also applied to Bell state preparation circuits, where a lean non-fault-tolerant implementation of the Iceberg code enables a fidelity gain as well. This highlights the important point that, at least for small-scale circuits with a substantial portion of error-free runs, it can be effective simply to use error detection to filter out the runs with errors. Furthermore, experiments performed in this work highlight the necessity for judicious compilation of circuits not only for a given hardware but also within a quantum error detection code.