Quantinuum researchers are unlocking a more efficient and powerful path towards fault tolerance
We've discovered a technique based on “genon braiding” for the construction of logical gates which could be applied to “high rate” error correcting codes
“Computers are useless without error correction”
- Anonymous
If you stumble while walking, you can regain your balance, recover, and keep walking. The ability to function when mistakes happen is essential for daily life, and it permeates everything we do. For example, a windshield can protect a driver even when it’s cracked, and most cars can still drive on a highway if one of the tires is punctured. In fact, most commercially operated planes can still fly with only one engine. All of these things are examples of what engineers call “fault-tolerance”, which just describes a system’s ability to tolerate faults while still functioning.
When building a computer, this is obviously essential. It is a truism that errors will occur (however rarely) in all computers, and a computer that can’t operate effectively and correctly in the presence of faults (or errors) is not very useful. In fact, it will often be wrong - because errors won’t be corrected.
In a new paper from Quantinuum’s world class quantum error correction team, we have made a hugely significant step towards one of the key issues faced in quantum error correction – that of executing fault-tolerant gates with efficient codes.
This work explores the use of “genon braiding” – a cutting-edge concept in the study of topological phases of matter, motivated by the mathematics of category theory, and both related to and inspired by our prior groundbreaking work on non-Abelian anyons.
The native fault tolerant properties of braided toric codes have been theoretically known for some time, and in this newly published work, our team shares how they have discovered a technique based on “genon braiding” for the construction of logical gates which could be applied to “high rate” error correcting codes – meaning codes that require fewer physical qubits per logical qubit, which can have a huge impact on scaling.
Stepping along the path to fault-tolerance
In classical computing, building in fault-tolerance is relatively easy. For starters, the hardware itself is incredibly robust and native error rates are very low. Critically, one can simply copy each bit, so errors are easy to detect and correct.
Quantum computing is, of course, much trickier with challenges that typically don’t exist in classical computing. First off, the hardware itself is incredibly delicate. Getting a quantum computer to work requires us to control the precise quantum states of single atoms. On top of that, there’s a law of physics called the no cloning theorem, which says that you can’t copy qubits. There are also other issues that arise from the properties that make quantum computing so powerful, such as measurement collapse, that must be considered.
Some very distinguished scientists and researchers have thought about quantum error correcting including Steane, Shor, Calderbank, and Kitaev [9601029.pdf (arxiv.org), 9512032.pdf (arxiv.org), arXiv:quant-ph/9707021v1 9 Jul 1997]. They realized that you can entangle groups of physical qubits, store the relevant quantum information in the entangled state (called a “logical qubit”), and, with a lot of very clever tricks, perform computations with error correction.
There are many different ways to entangle groups of physical qubits, but only some of them allow for useful error detection and correction. This special set of entangling protocols is called a “code” (note that this word is used in a different sense than most readers might think of when they hear “code” - this isn’t “Hello World”).
A huge amount of effort today goes into “code discovery” in companies, universities, and research labs, and a great deal of that research is quite bleeding-edge. However, discovering codes is only one piece of the puzzle: once a code is discovered, one must still figure out how to compute with it. With any specific way of entangling physical qubits into a logical qubit you need to figure out how to perform gates, how to infer faults, how to correct them, and so on. It’s not easy!
Quantinuum has one of the world’s leading teams working on error correction and has broken new ground many times in recent years, often with industrial or scientific research partners. Among many firsts, we were the first to demonstrate real-time error correction (meaning a fully-fault tolerant QEC protocol). This included many milestones: repeated real-time error correction, the ability to perform quantum "loops" (repeat-until-success protocols), and real-time decoding to determine the corrections during the computation. We were also the first to perform a logical two-qubit gate on a commercial system. In one of our most recent demonstrations, in partnership with Microsoft, we supported the use of error correcting techniques to achieve the first demonstration of highly reliable logical qubits, confirming our place at the forefront of this research – and indeed confirming that Quantinuum’s H2-1 quantum computer was the first – and at present only – device in the world capable of what Microsoft characterizes as Level 2 Resilient quantum computing.
Introducing new, exotic error correction codes
While codes like the Steane code are well-studied and effective, our team is motivated to investigate new codes with attractive qualities. For example, some codes are “high-rate”, meaning that you get more logical qubits per physical qubit (among other things), which can have a big impact on outlooks for scaling – you might ultimately need 10x fewer physical qubits to perform advanced algorithms like Shor’s.
Implementing high-rate codes is seductive, but as we mentioned earlier we don’t always know how to compute with them. A particular difficulty with high-rate codes is that you end up sharing physical qubits between logical qubits, so addressing individual logical qubits becomes tricky. There are other difficulties that come from sharing physical qubits between logical qubits, such as performing gates between different logical qubits (scientists call this an “inter-block” gate).
One well-studied method for computing with QEC codes is known as “braiding”. The reason it is called braiding is because you move particles, or “braid” them, around each other, which manipulates logical quantum information. In our new paper, we crack open computing with exotic codes by implementing “genon” braiding. With this, we realize a paradigm for constructing logical gates which we believe could be applied to high-rate codes (i.e. inter-block gates).
What exactly “genons” are, and how they are braided, is beautiful and complex mathematics - but the implementation is surprisingly simple. Inter-block logical gates can be realized through simple relabeling and physical operations. “Relabeling”, i.e. renaming qubit 1 to qubit 2, is very easy in Quantinuum’s QCCD architecture, meaning that this approach to gates will be less noisy, faster, and have less overhead. This is all due to our architectures’ native ability to move qubits around in space, which most other architectures can’t do.
Using this framework, our team delivered a number of proof-of-principle experiments on the H1-1 system, demonstrating all single qubit Clifford operations using genon braiding. They then performed two kinds of two-qubit logical gates equivalent to CNOTs, proving that genon braiding works in practice and is comparable to other well-researched codes such as the Steane code.
What does this all mean? This work is a great example of co-design – tailoring codes for our specific and unique hardware capabilities. This is part of a larger effort to find fault-tolerant architectures tailored to Quantinuum's hardware. Quantinuum scientist and pioneer of this work, Simon Burton, put it quite succinctly: “Braiding genons is very powerful. Applying these techniques might prove very useful for realizing high-rate codes, translating to a huge impact on how our computers will scale.”
About Quantinuum
Quantinuum, the world’s largest integrated quantum company, pioneers powerful quantum computers and advanced software solutions. Quantinuum’s technology drives breakthroughs in materials discovery, cybersecurity, and next-gen quantum AI. With over 500 employees, including 370+ scientists and engineers, Quantinuum leads the quantum computing revolution across continents.
- A new experiment tests what makes a quantum computer genuinely quantum by using a simple game that demonstrates a provable advantage from quantum superposition, without relying on entanglement or assumptions about classical computational difficulty.
- The test was demonstrated on Quantinuum’s System Model H2, where researchers ran thousands of circuits and observed results close to theoretical quantum predictions. The approach also offers an efficiently verifiable way to test for non-classical behavior.
- The work provides a new way to think about quantum-computing verification: rather than focusing only on metrics like qubit count, we can ask whether a machine demonstrates capabilities that fundamentally distinguish quantum systems from classical ones. This validates that the computer is working as intended.
Building a quantum computer is one thing. Showing that it is genuinely using quantum mechanics is another.
A new experiment, just published in Nature Communications, takes a fresh approach to that question. Instead of relying on entanglement or the complex calculations often used to benchmark quantum computers, researchers designed a simple game (initially published in Physical Review Letters) that tests something more fundamental: quantum superposition.
Using superposition, the team constructed a game where quantum mechanics provides a provable advantage over classical approaches. Once the game was set, the team ran it on real hardware. The results showed a clear performance gap between the best possible classical system and our System Model H2 – a gap that only grew as the test became more difficult.
A game that classical computers can’t win
The game is played by a single player with access to a computer. The player receives a quantum state representing a set of numbers—for example, {0, 1, 5, 7}. Their goal is to return a number that belongs to the complement of that set: {2, 3, 4, 6}.
That sounds simple. But as the size of the sets grows, something remarkable happens.
A classical strategy needs to test many numbers to succeed. A quantum strategy, however, succeeds in one step. The authors show that the quantum strategy has a score that grows exponentially faster.
Importantly, this isn't based on an assumption that this problem is difficult for classical computers. The separation is mathematically proven. In other words, the researchers can show that the quantum advantage exists without relying on unproven assumptions from complexity theory.
Using our System Model H2, the experimenters were able to confirm the theoretically derived separation between the quantum and the classical strategy (up to the largest sizes they could fit on the quantum processor) with high confidence – showing that the violation remained close to exponential.
Testing quantum mechanics without entanglement
Many famous experiments testing quantum behavior rely on entanglement and non-locality, where multiple parties share parts of a quantum system.
This experiment is different.
There is only one player, who has access to the entire quantum system. The advantage comes from superposition—the ability of a quantum system to exist in a combination of states until it is measured.
That distinction matters because it provides another way to ask whether a quantum computer is actually behaving quantum mechanically.
The researchers turned their game into an experimental test and ran thousands of different circuits on Quantinuum's System Model H2. The scores they observed were close to the theoretical predictions for a quantum strategy.
Why verification matters
One of the challenges with existing quantum-computing demonstrations is figuring out whether the machine really produced the result it was supposed to produce.
For example, random circuit sampling can be extremely difficult to verify classically as systems become larger. That creates a tension: you want to demonstrate that a quantum computer is doing something a classical computer cannot easily reproduce, but you also need a practical way to check the result.
The complement-sampling game offers a different approach. The violation of classical performance can be efficiently verified with a classical computer.
That makes the test potentially more scalable: you don't need to reproduce the entire quantum computation on a classical computer just to determine whether the machine demonstrated non-classical behavior.
So, what makes a quantum computer “quantum”?
The deeper message of the experiment is that demonstrating a quantum computer isn't simply about having qubits.
A convincing demonstration should show that the machine is exploiting properties that genuinely distinguish quantum computation from classical computation. Here, the researchers focus on one of those defining properties—superposition—and construct a game where quantum mechanics provides a provable advantage.
This first experimental demonstration of complement sampling doesn't close every possible loophole, which is common for this sort of experiment – closing the major experimental loopholes in Bell-inequality tests took decades—a body of work that ultimately contributed to the 2022 Nobel Prize in Physics. The researchers explicitly note that the implementation relies on assumptions about how the input state is prepared, so the experimental results should be interpreted with some caution.
Still, the work provides a new way to probe the boundary between classical and quantum computation.
And that may be the most interesting part: rather than asking only “How many qubits does the machine have?”, we can ask a more meaningful question—
“What can this machine do that only a quantum system can?”
That is ultimately what it takes for a quantum computer to actually be quantum.
- Helix is Quantinuum’s QEC architecture designed for scalability, leveraging reconfigurable connectivity to reduce the physical-qubit and time overhead required for fault-tolerant computation.
- The architecture has been experimentally validated on Helios, demonstrating logical memory, logical computation, and logical entanglement across different QEC codes—all outperforming corresponding physical-level results without post-selection.
- Helix provides a foundation for Apollo, combining efficient logical gates, multiple QEC encodings, and a path to universal fault-tolerant computation. The results on commercial hardware validate Quantinuum’s roadmap toward scalable, fault-tolerant quantum computing.
The NISQ1 era is coming to an end. At Quantinuum, we’ve already demonstrated numerous QEC codes, all the primitives needed for logical computation, steadily declining logical error rates, and full computations at the logical level.
But there’s still a way to go. One of the defining challenges over the coming years will be putting it all together into a usable – and scalable – fault tolerant architecture. Today, we are excited to announce that we have experimentally validated one of our own leading candidates for such an architecture, the Helix code.
With this demonstration, we have put all the pieces together: logical memory, logical computation, a heterogenous code architecture that optimizes for magic vs gates, all with super efficient operations and record-breaking2 fidelity.
The Challenge of Fault Tolerance
The delicate nature of qubits gives them their strength – they can be entangled, placed into superpositions, and even teleported. However, this comes at a cost: on the hardware level, quantum bits (qubits) will always be noisier than classical bits.
Enter quantum error correction (QEC). QEC moves us past prohibitive physical noise to fidelities that really matter; where industrial workflows and scientific discovery live. Our field has been hard at work to realize - and optimize - QEC, and we are finally starting to reap the fruits of that labor.
However, for the most part, this work has taken shape only a few pieces at a time: a demonstration of fault tolerant gates here or memory there, sometimes even a full fault-tolerant algorithm, but rarely do we see demonstrations at the architectural scale needed to build our next generation of machines.
The difficulty is that encoding and performing fault-tolerant computation costs considerable space (qubit number) and time (circuit complexity), which QEC researchers summarize with a “spacetime volume”.
Introducing Helix: A QEC Architecture for Apollo
The Helix code was custom-designed to usher in the next generation of fault tolerance.
Using our reconfigurable qubits, we designed Helix to minimize its spacetime volume by employing more exotic entanglement schemes compared to traditional codes (imagine cat’s cradle compared to a simple, 2D net). This entanglement complexity is impossible with processors that don’t have reconfigurable connectivity.
Ultimately, this translates to a code that requires fewer physical qubits per logical qubit, while also giving you fast and simple computing.
To build the Helix code, we use the [[4,2,2]] code as the physical building block for each qubit in the [[10,2,3]] code. In other words, rather than constructing the torus directly from physical qubits, we construct it from logical qubits encoded in [[4,2,2]] code blocks. In the image on the left, the black dots represent these logical qubits, and the dashed lines represent the connections between them. Importantly, the dashed lines connect logical qubits within the same [[4,2,2]] code block.
This concatenation would be extremely difficult to implement without the reconfigurable connectivity enabled by our mobile qubits.
In general, gates between logical qubits can be quite difficult because logical qubits are composed of physical qubits that are entangled together in some specific way. Sometimes, a single physical qubit may even be shared between multiple logical qubits, as is the case with codes that offer lots of logical qubits per physical qubit. Performing gates across these complex structures can be tricky, and can take a lot of individual operations on physical qubit pairs to accomplish.
There are two major exceptions. The first, called a transversal gate, is where the logical operation maps directly onto the physical one: you just perform a regular 2-qubit gate between each physical qubit in each logical qubit.
The second is simpler still: gates can be accomplished by simple software-level qubit relabeling (eg simply renaming qubit A to qubit B), combined with easy, single qubit gates. This type of automorphism, or permutation-based gate, is particularly elegant.
The Helix code makes heavy use of transversal and automorphism gates, making it considerably faster and easier to compute with than a lot of other options. Ultimately, this translates to a significant reduction in both space (qubit) and time (circuit complexity) overheads: less space is needed for block encoding and ancilla; and time is drastically reduced when simple software relabeling or transversal gates are performed in the place of expensive protocols like lattice surgery.
Demonstrating the Building Blocks of a Fault-Tolerant System
Experiment 1: Logical Memory
The team started by showing that the Helix code can successfully preserve encoded quantum information for extended periods of time.
To show this, the team started with their logical qubits in a given state. Then, they performed 20 rounds of syndrome extraction, paying special attention to leakage (a dominant source of error on Helios). To remove leakage, the team leveraged Helios’ new leakage repump capacity, as well as circuit-level leakage reduction units.
Result: per qubit, per round, they achieved an error rate of 4.6 x 10-5, with no post selection.
This amounts to a block logical error per round of 9.3 x 10-5, with no post selection. With a small amount of post selection (0.5%), the block logical error per round was reduced to 1.9 x 10-5.
Why This Matters
Quantum memory is one of the most fundamental building blocks of a fault-tolerant quantum computer. A useful quantum processor must be able to preserve quantum information long enough to perform the computation, error correction, and communication required by larger algorithms.
These results prove that encoded quantum information can be preserved with a lower error rate than the underlying physical operations – all without needing post selection.
Experiment 2: Logical Computation
A central feature of the Helix logical architecture is that encoding multiple logical qubits does not require correspondingly expensive logical computation. By construction, this code has a variety of logical gates all implementable with only physical single-qubit gates and qubit relabeling. These ‘SWAP-transversal’, or ‘automorphism’, gates provide the ability to do some logical circuits essentially for free, as permutations are realized by simple ion-transport and software level relabeling.
The team experimentally tested the code’s computational abilities by benchmarking the complete logical Clifford group (i.e., all gates except for T gates) while interleaving up to 27 rounds of active adaptive syndrome extraction.
Result: 2.8 x 10-4 logical error rate per Clifford gate, a significant improvement (4.28x) over Helios’ physical 2-qubit Clifford error rate, again achieved without post selection.
This impressive result is partially enabled by the team’s clever adaptive syndrome extraction (ASE) technique. Their ASE technique reduces the number of physical gates required per logical gate by about 33%. This pruning also shortens the physical run time, reducing the ‘wall clock duration’ by about 23%. Both gates and idling contribute significantly to errors, so these reductions translate to a lower logical error rate.
Why This Matters
This experiment proves the Helix code’s ability to compute, all while showing significant improvement over the physical level with no post selection. In addition, this marks the first demonstration of randomized benchmarking on a code encoding more than one logical qubit, an important milestone for our community.
Experiment 3: Universality via Logical Entanglement Across Different Codes
Clifford gates alone are insufficient for universal fault-tolerant computation; our QEC architecture must also provide access to non-Clifford resource states (often called “magic”). While the Helix code has many desirable features in terms of Clifford gates, it’s sub-optimal for preparing magic states. Rather than forcing the Helix code to work in this regime, we developed our architecture to employ two codes; one for Clifford gates and memory, and one for magic state preparation. Using different codes each optimized for their own tasks, called a heterogenous architecture, makes the entire assembly considerably more efficient and cost effective.
The trick that makes it all possible is something called chain-mapping, that allows the QPU to smoothly switch between underlying encoding schemes. To test this, the team used a rotated surface code for magic state generation, which would then be injected into the computational (Helix) code to generate non-Clifford gates (enabling fault tolerant universal computation).
Rather than performing magic state injection directly, the team wanted to benchmark the interface (the chain-map). To do this, they used their chain-mapped gates to prepare a three logical qubit GHZ state that spans the two different codes. The resulting GHZ state contained 1 logical qubit from the surface code and two from the Helix code, making for a truly heterogeneous structure.
Result: The logical GHZ state had a fidelity lower bound of 99.925%, and an upper bound of 99.975%. The lower bound exceeded the physical baseline, making all three experiments better than their physical counterparts.
Why This Matters
This experiment demonstrates one of our key architectural advantages: using our reconfigurable connectivity to employ multiple QEC encodings in a single fault tolerant architecture, improving our efficiency and reducing qubit costs.
Accelerating the Path to Apollo
The quantum computing industry has proposed many approaches to error correction. This paper marks one of the first experimentally validated plans for a QEC architecture. With the low logical error rates (all improving on the physical baseline), the practical logical operations (which drastically reduce qubit costs and compute time), and real commercial hardware performance, this result helps to prove that we will deliver on our roadmap.
A crucial element of this demonstration is that these results were obtained on our commercial hardware. This is not a result from a testbed, or a result from hardware that has limited functionality. This is a result from the same computer as our customers use for their own research.
Furthermore, simulations indicate that the improvements in physical fidelity we expect from moving from Helios to Apollo will bring logical error rates in line with our roadmap targets. Because logical error rates depend strongly on physical error rates, Apollo’s expected improvements at the physical level should translate directly into lower logical error rates. Importantly, we expect to achieve these gains without increasing the code distance or using additional physical qubits per logical qubit.
Building a fault-tolerant quantum computer requires solving multiple engineering challenges. In this result we have proven our path to a scalable QEC architecture, showing not just one-off results on test stand hardware, but a harmonious whole consisting of:
✓ A candidate architectural code
✓ Logical memory
✓ Logical computation
✓ A path to magic
✓ Multiple encodings in one architecture
✓ Commercial hardware compatibility
By validating our fault-tolerant architecture on real commercial hardware, Quantinuum has taken a significant step toward Apollo - and toward quantum computers capable of solving meaningful problems at scale.
1 Noisy Intermediate-Scale Quantum
2 Based on a study of existing literature
Progressing your organization along the five levels of quantum maturity
Quantum computing has moved from a bet on the future to a race already underway. Early adopters are locking in strategic partnerships, building proprietary IP, and positioning themselves years ahead of competitors who are still watching from the sidelines. For executives, the question isn't whether to engage with quantum computing. It's how far along that journey your organization actually is, and what it takes to move forward.
That's a harder question to answer than it sounds. Quantum maturity isn't a single milestone you either hit or miss. It's a progression, built across talent, technology access, workflow integration, partnerships, and value realization, and most organizations aren't entirely sure where they currently stand and what to do next.
Our new paper, A Roadmap for Quantum Maturity, is built to answer exactly that.
A Framework for Where You Stand, and Where to Go Next
Drawing on extensive client experience, the paper lays out five distinct levels of quantum maturity, from early awareness through full transformation, along with the leadership actions that move an organization from one level to the next.
- Awareness — early conversations, but no clear ownership or use cases yet
- Exploration — exploring partnerships and prioritizing use cases with limited budget
- Experimentation — quantum roadmap established and guiding dedicated teams, funding, and partners to execute pilot use case projects
- Integration — quantum computing applications are being embedded into business unit workflows, and the quantum roadmap is integrated with broader digital technology strategy, including AI, HPC, and data
- Transformation — quantum capabilities are embedded in core products and decision-making, with differentiated, proprietary advantage
Most industry leaders today sit at the exploration or experimentation stages, with clear ambitions to reach transformation within the next several years. The paper breaks down what separates organizations that progress from those that stall out at proof-of-concept.
The Advantage Is Built, Not Bought
One of the paper's central takeaways is one many executives underestimate: investing in quantum technology alone isn't enough. Organizations that advance fastest pair that investment with a deliberate strategy, building quantum literacy across leadership and technical teams, honestly assessing capability gaps, focusing on a small number of high-impact use cases tied to real business metrics, and defining a clear roadmap that connects research to business advantage.
How Quantinuum Can Help
Achieving quantum maturity is a journey, not a single step, and most organizations don't need to make that journey alone. Quantinuum's consulting services are built to support every stage of it, from advisory and use-case identification, to capability building, technology access, and the co-development of scalable quantum solutions.
Whether your organization is just starting to build awareness or already scaling toward transformation, our team can help you identify exactly where you stand today, and what it takes to move to the next level.