A quantum computer needs more than a way to keep information from fading. It must also carry out operations on that protected information—and connect it to other protected systems—without letting errors creep back in. Those jobs are often treated as separate engineering problems. A new trapped-ion experiment puts them under one roof, testing a compact code designed for computation as well as memory.
The design, called C4-Helix, encodes two logical qubits in 20 physical qubits. A logical qubit is information stored across a group of hardware qubits so that the group can reveal and correct certain mistakes without directly reading the information itself. The code has a distance of six: in principle, it can correct errors affecting up to two physical qubits in its encoded block.
That compactness matters because error correction has a cost. Each protected qubit requires extra hardware, repeated checks, and time. A code that stores information efficiently but makes every useful operation cumbersome can still be a poor foundation for a computer. C4-Helix was built with this tension in mind: it combines layers of error-correcting codes while allowing many logical operations to be carried out with relatively little extra machinery.
Researchers tested the architecture on Helios, a trapped-ion processor with 98 qubits. In one set of experiments, they repeatedly checked the code for signs of errors, running 20 rounds of these checks. The processor’s measurements did not reveal each encoded quantum state directly. Instead, the team gathered error signals, called syndromes, and used them to infer what had gone wrong while preserving the encoded information.
The memory test showed an important step in the code’s operation. At distance six, the measured error rate was 4.6+6.2−2.6 × 10−5 per logical qubit per correction cycle. A smaller, distance-three version of the code had an error rate of 2.1+1.0−0.7 × 10−4. Moving to the larger code reduced the measured error rate by a factor of 4.52 at the processor’s operating conditions. These uncertainty ranges are broad, but the comparison is evidence that adding protection helped rather than simply adding overhead.
Then came the harder question: could the protected qubits do something? To test that, the researchers applied sequences of logical operations drawn from the full set of two-qubit Clifford gates, while continuing active error correction. They compared each sequence with the operation that should undo it. This kind of randomized benchmarking checks whether a system can reliably carry out many different operations, not just preserve a state chosen for a memory test.
The encoded operations had an error rate of 2.8+1.0−1.6 × 10−4 per logical gate, compared with about 1.2 × 10−3 for the corresponding unencoded physical operations. That is a 4.3-fold improvement. The advantage appeared without postselection—without discarding selected runs after seeing their results. In other words, the experiment tested useful encoded operations under error correction, rather than improving the numbers by keeping only the most favorable outcomes.
A quantum computer’s components may also use different codes for different tasks. One code might be efficient for general computation; another might be better at preparing special resource states needed for operations beyond the Clifford gates. The team therefore tested a connection between C4-Helix and a different code, a distance-five rotated surface code.
They used a logical operation called a chain-map CNOT to entangle the two logical qubits in C4-Helix with a third logical qubit in the surface code. The result was a three-qubit GHZ state, a distinctive form of entanglement in which the qubits’ measurement results are linked. The team reported a lower bound on its fidelity of 99.925+0.068−0.245%. For an unencoded physical version of the same test, the lower bound was 99.537+0.099−0.118%. The encoded result was better, though its fidelity bound reflects the full sequence—including state preparation, operations, the connection between codes, and readout—not the chain-map operation alone.
This cross-code link points toward a possible division of labor: a computer could use one code for its main operations and another to prepare special states, then transfer those states through a protected interface. The experiment did not demonstrate that full process or perform magic-state injection. Instead, the GHZ test checked a key entangling operation that such a route would need.
There is another important distinction between what the team measured and what it predicts. The experiments reached logical error rates around 10−4 per correction cycle and logical gate. Circuit-level simulations suggest that, if physical gate errors improve to the 10−4 range, the same code could reach logical error rates of 10−6 to 10−8. Those lower rates are projections, not experimental results from this processor.
The achievement, then, is not a finished fault-tolerant computer. It is a tested design that brings together three difficult ingredients: protected memory, a broad set of protected operations, and a demonstrated connection to another code family. By making the code’s computational role part of the design from the start, the researchers offer a different way to tackle a central challenge: building quantum hardware that can do more than hold information—it must be able to work with it, reliably.
