Untangling the Mysteries of Knots with Quantum Computers
What Quantum Advantage actually looks like
By Konstantinos Meichanetzidis
One of the greatest privileges of working directly with the world’s most powerful quantum computer at Quantinuum is building meaningful experiments that convert theory into practice. The privilege becomes even more compelling when considering that our current quantum processor – our H2 system – will soon be enhanced by Helios, a quantum computer potentially a stunning trillion times more powerful, and due for launch in just a few months. The moment has now arrived when we can build a timeline for applications that quantum computing professionals have anticipated for decades and which are experimentally supported.
Quantinuum’s applied algorithms team has released an end-to-end implementation of a quantum algorithm to solve a central problem in knot theory. Along with an efficiently verifiable benchmark for quantum processors, it allows for concrete resource estimates for quantum advantage in the near-term. The research team, included Quantinuum researchers Enrico Rinaldi, Chris Self, Eli Chertkov, Matthew DeCross, David Hayes, Brian Neyenhuis, Marcello Benedetti, and Tuomas Laakkonen of the Massachusetts Institute of Technology. In this article, Konstantinos Meichanetzidis, a team leader from Quantinuum’s AI group who led the project, writes about the problem being addressed and how the team, adopting an aggressively practical mindset, quantified the resources required for quantum advantage:
Knot theory is a field of mathematics called ‘low-dimensional topology’, with a rich history, stemming from a wild idea proposed by Lord Kelvin, who conjectured that chemical elements are different knots formed by vortices in the aether. Of course, we know today that the aether theory was falsified by the Michelson-Morley experiment, but mathematicians have been classifying, tabulating, and studying knots ever since. Regarding applications, the pure mathematics of knots can find their way into cryptography, but knot theory is also intrinsically related to many aspects of the natural sciences. For example, it naturally shows up in certain spin models in statistical mechanics, when one studies thermodynamic quantities, and the magnetohydrodynamical properties of knotted magnetic fields on the surface of the sun are an important indicator of solar activity, to name a few examples. Remarkably, physical properties of knots are important in understanding the stability of macromolecular structures. This is highlighted by work of Cozzarelli and Sumners in the 1980’s, on the topology of DNA, particularly how it forms knots and supercoils. Their interdisciplinary research helped explain how enzymes untangle and manage DNA topology, crucial for replication and transcription, laying the foundation for using mathematical models to predict and manipulate DNA behavior, with broad implications in drug development and synthetic biology. Serendipitously, this work was carried out during the same decade as Richard Feynman, David Deutsch, and Yuri Manin formed the first ideas for a quantum computer.
Most importantly for our context, knot theory has fundamental connections to quantum computation, originally outlined by Witten’s work in topological quantum field theory, concerning spacetimes without any notion of distance but only shape. In fact, this connection formed the very motivation for attempting to build topological quantum computers, where anyons – exotic quasiparticles that live in two-dimensional materials – are braided to perform quantum gates. The relation between knot theory and quantum physics is the most beautiful and bizarre facts you have never heard of.
The fundamental problem in knot theory is distinguishing knots, or more generally, links. To this end, mathematicians have defined link invariants, which serve as ‘fingerprints’ of a link. As there are many equivalent representations of the same link, an invariant, by definition, is the same for all of them. If the invariant is different for two links then they are not equivalent. The specific invariant our team focused on is the Jones polynomial.
They all have the same Jones polynomial, as it is an invariant.
The mind-blowing fact here is that any quantum computation corresponds to evaluating the Jones polynomial of some link, as shown by the works of Freedman, Larsen, Kitaev, Wang, Shor, Arad, and Aharonov. It reveals that this abstract mathematical problem is truly quantum native. In particular, the problem our team tackled was estimating the value of the Jones polynomial at the 5th root of unity. This is a well-studied case due to its relation to the infamous Fibonacci anyons, whose braiding is capable of universal quantum computation.
Building and improving on the work of Shor, Aharonov, Landau, Jones, and Kauffman, our team developed an efficient quantum algorithm that works end-to end. That is, given a link, it outputs a highly optimized quantum circuit that is readily executable on our processors and estimates the desired quantity. Furthermore, our team designed problem-tailored error detection and error mitigation strategies to achieve a higher accuracy.
In addition to providing a full pipeline for solving this problem, a major aspect of this work was to use the fact that the Jones polynomial is an invariant to introduce a benchmark for noisy quantum computers. Most importantly, this benchmark is efficiently verifiable, a rare property since for most applications, exponentially costly classical computations are necessary for verification. Given a link whose Jones polynomial is known, the benchmark constructs a large set of topologically equivalent links of varying sizes. In turn, these result in a set of circuits of varying numbers of qubits and gates, all of which should return the same answer. Thus, one can characterize the effect of noise present in a given quantum computer by quantifying the deviation of its output from the known result.
The benchmark introduced in this work allows one to identify the link sizes for which there is exponential quantum advantage in terms of time to solution against the state-of-the-art classical methods. These resource estimates indicate our next processor, Helios, with 96 qubits and at least 99.95% two-qubit gate-fidelity, is extremely close to meeting these requirements. Furthermore, Quantinuum’s hardware roadmap includes even more powerful machines that will come online by the end of the decade. Notably, an advantage in energy consumption emerges for even smaller link sizes. Meanwhile, our teams aim to continue reducing errors through improvements in both hardware and software, thereby moving deeper into quantum advantage territory.
The importance of this work, indeed the uniqueness of this work in the quantum computing sector, is its practical end-to-end approach. The advantage-hunting strategies introduced are transferable to other “quantum-easy classically-hard” problems. Our team’s efforts motivate shifting the focus toward specific problem instances rather than broad problem classes, promoting an engineering-oriented approach to identifying quantum advantage. This involves first carefully considering how quantum advantage should be defined and quantified, thereby setting a high standard for quantum advantage in scientific and mathematical domains. And thus, making sure we instill confidence in our customers and partners.
Edited
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.
Visit Quantinuum at SC26 – Booth 4838
Quantinuum is heading to SC26 in Chicago, and we'd love to see you at Booth 4838 in the Quantum Junction. Stop by during exhibit hours to catch partner theater sessions throughout the day, see what's new with Helios and Nexus, and talk with our team about how quantum computing is expanding its footprint in the HPC datacenter, including hybrid quantum-classical applications.
In our booth:
Join our experts and partners at our kiosks and for short sessions in our theater running throughout the day. Topics include:
- Next Gen Enterprise Computing Partners – how leading enterprises are bringing quantum into their computing strategy
- Error Correction: The Path to Fault Tolerance – where quantum error correction stands today and what comes next
- Develop for the Fault Tolerant Era with Nexus – building, running, and managing quantum workflows on the Nexus platfor
- Helios: The Most Accurate Quantum Computer – a closer look at our latest system and what its performance makes possible
- Startup Partners: Accelerating Quantum Ecosystem Innovation – how startups are building on Quantinuum technology
- Real Commercial Impact – quantum applications in pharma, chemicals, materials, and finance
Coffee and cookies on us
Need a break from the show floor? Our barista will be serving up coffee, and we'll have fresh cookies every afternoon. Grab a cup, pull up a seat for a theater session, and chat with the team.
Catch Quantinuum in the SC26 program
Our experts are also speaking in the SC26 technical program. Add these sessions to your schedule (all times CST):
Speaking Sessions
November 15th
9:45 – 10:00am | Room: W178a
Quantum-HPC Workflows Across Multiple Quantum Computing Platforms: Two Case Studies – part of the 2nd International Workshop for Software Frameworks and Workload Management on Quantum-HPC Ecosystems
Presenting: Philipp Seitz
November 16th
3:30 – 4:00pm | Room: W179a
Software for Large Scale Application – part of the 2nd Annual Workshop on Large-Scale Quantum-Classical Computing (LSQCC)
Presenting: Juan Pederson
November 19th
3:30 – 4:00pm | Room: W181abc
Bringing Quantum Computing to the HPC Datacenter
Presenting: Kentaro Yamamoto
See you in Chicago
Whether you're exploring quantum for the first time or planning how to integrate it with your HPC environment, our team is ready to talk. Find us at Booth 4838 in the Quantum Junction, November 16–19.
Fault-tolerant quantum computing is entering a new phase. At Quantinuum, we have demonstrated almost every piece needed for large-scale fault tolerant hardware, from a universal fault tolerant gate set, to a proven fault tolerant architecture, to large-scale materials simulations with encoded qubits, at world-leading fidelity.
However, that’s only half the battle. Developers need practical tools that make this technology accessible without needing to become experts in quantum error correction.
A good quantum computing software stack should capture and reuse QEC1 expertise, turning the complexity of fault tolerance into capabilities that developers can build with.
"Our ambition is for Nexus to be the platform developers turn to for the fault-tolerant era." - Dr. Rajeeb Hazra, President & CEO, Quantinuum
Here at Quantinuum, we are working hard to make that a reality. Since its launch in 2024, Nexus has grown from managing cloud-based quantum workflows into an environment for end-to-end application development and deployment. Our new multi-year roadmap builds on that foundation, connecting software capabilities with each generation of Quantinuum hardware through Apollo, our universal, fault-tolerant quantum computer planned for 2029. Nexus will progressively handle more of the complexity of fault-tolerant development, helping developers build applications that grow in capability as the hardware advances.
With Nexus, you can explore quantum chemistry and materials using InQuanto, and you can make it fault tolerant using our pre-built fault tolerant primitives. You can use GPUs to decode errors in real time, while benefitting from hardware enabled error suppression like Leakage Repump or Dynamical Decoupling. You can also connect your HPC to our QPUs and use Nexus’ Hybrid workflow management system to enjoy the best of both worlds seamlessly.
Of course, all of the above needs a language framework that is fault tolerant in the first place. That’s why we are thrilled to introduce Guppy FT – Nexus’ fault tolerant quantum programming framework, and Guppy Algorithms, Nexus’ library of reusable algorithmic primitives.
Developing for the fault tolerant era: Guppy FT
“The field of QEC is quite abstract, and it is hard for non-experts to gauge what is feasible on current devices. Guppy FT promotes a game-changing paradigm: QEC is no longer just theory, it is also engineering, it is something you can use.” - the Guppy FT team
As we have been saying, the NISQ2 era is coming to an end. The next challenge is to turn fault tolerance from a hardware milestone into a capability developers can use.
We have built the physical QEC architecture: high-fidelity physical qubits, distance scaling and low logical error rates, all-to-all connectivity and reconfigurable qubits, all the primitives working harmoniously, real-time decoding, circuit optimization, and so on. The next step is ensuring our users can easily enjoy the above: with a fault tolerant programming language framework (Guppy FT) inside a fault tolerant user platform (Nexus).
Guppy FT brings three complementary capabilities together:
- A framework for QEC experts to define fault-tolerant architectures.
- Automatic compilation that takes programs written in standard Guppy and turns them into programs running on fault-tolerant architectures.
- Proprietary codes from our own QEC experts that get you the best performance out of our world-leading hardware.
The result is a programming experience in which developers can write quantum algorithms without having to understand the details of the underlying error-correction architecture, while QEC experts retain the ability to define and optimize the architectures that power those programs.
This separation between what the program does and how it is made fault tolerant is central to the approach.
With Guppy FT, QEC experts define the fault-tolerant architecture once, and application developers can program on it without needing to become QEC experts themselves. Developers can continue to write programs in standard, QEC-agnostic Guppy. The Guppy FT framework then automatically lowers those programs into an encoded, fault-tolerant form suitable for execution.
As fault-tolerant techniques improve, the same high-level programming model can therefore serve as a stable interface between applications and increasingly sophisticated QEC implementations. This approach also makes it possible to evolve the underlying architecture without requiring every application developer to rewrite their programs around its implementation details – a crucial benefit as we stay at the forefront of a quickly evolving field.
Available to users today, Guppy FT is an important step toward software designed for the fault-tolerant era. You can use already-perfected codes, like our high-rate quantum error detection code, through Nexus, with more codes coming online as they are developed.
Optimize your work with Guppy Algorithms & Realtime Analytics
We want you doing more than just writing fault tolerant programs – we want to help you write quickly and optimally.
With Guppy Algorithms, you can save needless repetition of work by constructing complex application-level software workflows in an application-agnostic way. Built on Guppy, Guppy Algorithms combines type-safe Guppy primitives with Python builders to help developers construct quantum algorithms out of already optimized building blocks. Guppy Algorithms is also QEC agnostic, enabling users to evolve their fault tolerance approach as the platform grows, without needing to re-write finished programs.
Current highlights include primitives that help you with:
- Trotterisation for Hamiltonian Simulation
- Quantum linear algebra
- Quantum arithmetic
Using Guppy Algorithms is simple. First, you build your abstract (application-specific) algorithm. Then, you simply compose it with Guppy Algorithms: import your desired implementations of circuit sub-components and bring your workflow to life.
"Guppy FT and Guppy Algorithms add a necessary abstraction on top of Guppy’s flexible programming model, so that application development and QEC research can advance in lockstep without either having to bake in assumptions about the other.” - Seyon Sivarajah, Chief Architect of Developer Tools
Soon, we plan to expand Guppy Algorithms to include end-to-end workflows of reusable components.
Of course, a set of optimized building blocks isn’t enough to ensure every program you write is optimal for execution. To that end, Nexus is introducing two tools to help users understand and optimize hardware execution:
- Real-time metrics that provide execution statistics, including gate counts and shot duration.
- ShotPlot, our tool for visualizing gate scheduling, helping users identify idle periods and improve circuit layout.
With these functionalities, you can try new approaches to minimizing gate counts or runtime with real-time feedback that helps you further optimize your result. Taken together, these new tools ensure that Nexus provides an optimal programming experience, from the circuit level to the user experience.
Using Guppy FT to reduce errors on quantum hardware: an end-to-end demonstration on Helios
To demonstrate Guppy FT, the team ran a Steane-encoded quantum algorithm, HHL, on Quantinuum’s Helios quantum computer.
The team compared three versions of the HHL program, with different settings for Guppy FT’s Steane code ([[7, 1, 3]]) encoding, each with 500 shots. The first used no explicit QEC cycles and performed on-demand, sequential state preparation. The second used Guppy FT’s state factories to parallelize state preparation, and the third also applied three QEC cycles to each of the five qubits.
Each shot is comprised of three stages: the HHL program, mid-circuit error detection, and the inverse of the HHL program. Mid-circuit error detection measures the ancilla qubits used by the HHL program, which it ought to disentangle from the data qubits. If an error is detected, the shot is discarded; otherwise, it moves on to the final stage and is marked as accepted. Fidelity is computed as the proportion of accepted shots that the inverse HHL program successfully returns to the initial state.
The results show that both QEC cycles and parallelized state preparation improve performance. QEC cycles actively correct errors while parallelization shortens execution time, reducing the chance of errors. Together, these results demonstrate how Guppy FT can implement fault-tolerant architectures for practical, end-to-end programs running on real quantum hardware.
Deploy Your Hybrid Quantum-Classical Application
The future of quantum computing is more than fault tolerant: it’s hybrid. Close co-ordination between classical and quantum computing resources will be essential for most killer use-cases, with a combination of AI, HPC, and QPU each working on the sub-components they are best suited for.
We’ve been perfecting hybridization for years now, including hybridizing our QPUs with the Fugaku supercomputer at RIKEN. Along the way, we have developed a robust event-based hybrid compute runtime, now available through Nexus. Our updated hybrid compute framework features:
- Multiple storage implementations
- Workflow attempts and restart improvements
- Runtime configuration files
- OTEL tracing and observability
- Workflow cancellation
- SQLite based state management
Quantinuum Nexus: A foundation for what comes next
Nexus brings together the capabilities and infrastructure needed to develop, analyze, run, and manage hybrid quantum-classical programs across the stack. By unifying quantum programming, validation, fault tolerance, compilation, and execution in one place, with interoperability across third-party environments, Nexus is making fault tolerance a practical reality.
Nexus users are already using our quantum processors to explore applications in finance, nuclear physics, particle physics, benchmarking, computational chemistry, and more. As our Nexus roadmap evolves, we plan on deploying ecosystem tools and libraries, as well as an applications marketplace where developers can monetize their work.
“Quantum computers are on the brink of achieving fault tolerance at scale. It's exciting: we are entering terra incognita for what we can compute. The new challenge is putting our high-level quantum algorithms into the right form to successfully run on error-corrected hardware. Developer platforms like Nexus help us bridge that gap between quantum algorithm design and deployment
-José Ignacio Latorre, Director, Centre for Quantum Technologies at the National University of Singapore at the National University of Singapore
By bringing everything together, Nexus is becoming a robust platform in which fault tolerance is a feature, rather than a barrier to entry.
Get ready for the fault tolerant future.
1 Quantum Error Correction
2 Noisy Intermediate Scale Quantum
By Chris Langer
Trustworthy answers are a prerequisite for useful quantum computing. First build machines that deliver answers reliably. Then focus on delivering them quickly.
A trustworthy answer also needs to arrive soon enough to be useful. But understanding how long that takes requires looking beyond the speed of any single operation.
Think about your commute: a car’s 0–60 time doesn’t tell you when you’ll arrive. Traffic, detours, and bottlenecks all affect the journey. Quantum computing works much the same way. No isolated metric, including gate speed, indicates how quickly the entire system can get the job done.
The goal of quantum computing is to solve valuable problems reliably and soon enough to matter.
At Quantinuum, we are pursuing that goal by scaling our systems and removing bottlenecks. Speed depends on how much work is required to make a computation reliable and how much of that work can happen simultaneously. We are improving how we build and operate logical qubits—an essential mechanism for complex computations—through more efficient error correction, faster qubit movement, and more parallel operations.
Understanding how these advances translate into faster answers starts with looking beyond the speed of a single gate.
The Gap Between Fast Gates and Useful Answers
Gate speed reveals how quickly a single step happens in a quantum calculation. It does not tell us how many steps are needed, how many can happen together, or how often a computation must be repeated.
An example illustrates the distinction.
Researchers from the University of Tokyo ran a small, three-qubit circuit on superconducting and trapped-ion systems.1 Armed with faster gates, the superconducting machine executed the circuit roughly 200 times faster. But it needed about 50 times more repetitions to reach comparable accuracy, reducing its practical speed advantage to approximately four times.
Faster gates led to faster answers in this example, but the headline execution speed overstated the advantage dramatically.
Even on a modestly larger circuit, the fourfold advantage could disappear entirely. A more complicated circuit means more room for errors and significantly more repetitions to overcome them. Now consider what is required of the systems, larger still, to solve real-world challenges. This calls for a move to logical qubits, which spread information across multiple physical qubits so that errors can be detected and corrected without loss.
At that scale, the question becomes how quickly the system can do useful work while keeping errors under control. The metric that tracks the rate of useful work is logical throughput, the amount of useful work a system completes per second.
What Drives Logical Throughput and Faster Answers
Logical throughput depends on logical clock rate (how quickly logical operations happen) and parallelism (how many can happen at once).
Consider two hypothetical machines: the first completes one logical operation at a time, each taking a microsecond. The second performs 1,000 independent logical operations simultaneously, each taking a millisecond. In one millisecond, each machine completes 1,000 operations. The second machine’s operations take 1,000 times longer, but parallelism offsets the difference.
Error correction takes time and physical qubits. Using both more efficiently can speed up logical operations and enable more work in parallel.
Three levers help improve that throughput:
Connectivity. Better connectivity enables error correction that is more efficient in time and space. Faster correction improves logical clock rate; fewer physical qubits per logical qubit leave room for more logical qubits. Connectivity also enables logical operations to work in parallel.
Fidelity. More reliable physical operations reduce the resources needed for error correction. This improves efficiency in space: fewer physical qubits can deliver the required logical reliability, leaving capacity for more logical qubits.
Scale. More physical qubits create room for more logical qubits. Efficient error correction, strong connectivity, and enough places to perform operations help turn that added capacity into more work happening at once. As systems scale to 1,000 logical qubits and beyond, putting more qubits to work simultaneously can help offset slower individual operations.
How Quantinuum Is Turning Scale into Speed
Faster gates, better connectivity, efficient error correction, and greater parallelism must work together. That is the thinking behind Quantinuum’s approach to scaling.
We are working to accelerate gate execution, qubit movement, and other factors while reducing unnecessary operations and improving error-correction efficiency. More efficient error correction lets us reach the required reliability with fewer resources. That means we can exploit parallelism and spend more of our extra qubits on speed.
Superconducting systems, by contrast, boast faster clock speeds, but limited connectivity forces more operations to run in sequence. That constrains the parallel capabilities of these systems, the other side of the throughput equation. Put simply, completing each step faster does not guarantee finishing the job sooner if more steps must wait their turn. Greater error-correction overhead also leaves fewer logical qubits available for computation from a given number of physical qubits. Even with more logical qubits, connectivity remains a separate constraint on how many operations can run in parallel. Together, these factors limit how effectively faster physical gates translate into faster computation.
Quantinuum’s architecture allows us to scale logical qubits and facilitate greater throughput. Maximizing the value of qubits remains an engineering challenge, which our roadmap to larger, faster machines addresses in three steps:
First, improve how qubits move. Sol, planned to launch in 2027, is our expected proving ground for a two-dimensional architecture that allows more efficient, parallel rearrangement of qubits as the system grows. Our prototypes have already demonstrated our two-dimensional geometry, operating concepts, and scalable controls work.2 We continue to improve the speed of qubit movement.
Second, create more places to work simultaneously. Adding operating zones enables more operations to run at once, increasing throughput by leveraging space.
Third, increase scale. Our planned progression from Sol to Apollo (targeted to launch in 2029) and then Lumos in the decade ahead is intended to increase physical qubit counts from approximately 200 to thousands and eventually millions.
On these larger systems, efficient error correction and connectivity-enabled parallelism will allow us to turn more qubits into dramatically higher computational throughput.
Measure the Time to a Useful Answer
As quantum computers grow, they must solve larger problems in a useful amount of time. Fast gates can’t guarantee that. Any speed advantage on a small, uncorrected circuit could vanish at the logical level. For superconducting systems, scaling this small-scale edge would mean overcoming architectural limits on connectivity and efficient error correction, which is no small feat.
For users and investors, the speed equation includes how much work the system requires, how efficiently it corrects errors, and how much computation it can perform at once. Additional qubits deliver their full value when these capabilities translate scale into increased logical throughput.
It doesn’t matter how fast you get to the wrong answer. What matters is getting the right answers efficiently. Returning to the commute analogy, we’re adding horsepower to our car and identifying the traffic detours on the road. The measure of progress will be how quickly we arrive at the destination.
References:
[1] E. Lötstedt and K. Yamanouchi, “Comparison of current quantum devices for quantum computing of Heisenberg spin chain dynamics,” Chemical Physics Letters, vol. 856, Art. no. 141817, Feb. 2024, doi: 10.1016/j.cplett.2023.141817.
[2] R. D. Delaney et al., “Scalable Multispecies Ion Transport in a Grid-Based Surface-Electrode Trap,” Physical Review X, vol. 14, no. 4, p. 041028, 2024, doi: 10.1103/PhysRevX.14.041028.
Forward-Looking Statements
This post contains forward-looking statements within the meaning of the Private Securities Litigation Reform Act of 1995. These include statements about Quantinuum's technology and product roadmap; the expected timing, capabilities, and performance of future systems, including Sol, Apollo, and Lumos; anticipated improvements in error correction, qubit transport, parallelism, and logical throughput; and the potential applications of quantum computing. Words such as "will," "intend," "plan," "expect," "target," "designed to," "may," "can," "could," and similar expressions identify forward-looking statements.
These statements are based on current expectations and assumptions and are subject to risks and uncertainties that could cause actual results to differ materially. These risks include technical challenges in scaling quantum hardware and error correction; delays in development, manufacturing, or supply of components; the pace of customer adoption; competition and advances in alternative technologies; our ability to fund research and development; and the other risks described under "Risk Factors" in the prospectus for our initial public offering and in our most recent Quarterly Report on Form 10-Q, each filed with the Securities and Exchange Commission. Forward-looking statements speak only as of the date of this post, and we undertake no obligation to update them, except as required by law.