“Talking quantum circuits”
Interpretable and scalable quantum natural language processing
The central question that pre-occupies our team has been:
“How can quantum structures and quantum computers contribute to the effectiveness of AI?”
In previous work we have made notable advances in answering this question, and this article is based on our most recent work in the new papers [arXiv:2406.17583, arXiv:2408.06061], and most notably the experiment in [arXiv:2409.08777].
This article is one of a series that we will be publishing alongside further advances – advances that are accelerated by access to the most powerful quantum computers available.
Large language Models (LLMs) such as ChatGPT are having an impact on society across many walks of life. However, as users have become more familiar with this new technology, they have also become increasingly aware of deep-seated and systemic problems that come with AI systems built around LLM’s.
The primary problem with LLMs is that nobody knows how they work - as inscrutable “black boxes” they aren’t “interpretable”, meaning we can’t reliably or efficiently control or predict their behavior. This is unacceptable in many situations. In addition, Modern LLMs are incredibly expensive to build and run, costing serious – and potentially unsustainable –amounts of power to train and use. This is why more and more organizations, governments, and regulators are insisting on solutions.
But how can we find these solutions, when we don’t fully understand what we are dealing with now?1
At Quantinuum, we have been working on natural language processing (NLP) using quantum computers for some time now. We are excited to have recently carried out experiments [arXiv: 2409.08777] which demonstrate not only how it is possible to train a model for a quantum computer in a scalable manner, but also how to do this in a way that is interpretable for us. Moreover, we have promising theoretical indications of the usefulness of quantum computers for interpretable NLP [arXiv:2408.06061].
In order to better understand why this could be the case, one needs to understand the ways in which meanings compose together throughout a story or narrative. Our work towards capturing them in a new model of language, which we call DisCoCirc, is reported on extensively in this previous blog post from 2023.
In new work referred to in this article, we embrace “compositional interpretability” as proposed in [arXiv:2406.17583] as a solution to the problems that plague current AI. In brief, compositional interpretability boils down to being able to assign a human friendly meaning, such as natural language, to the components of a model, and then being able to understand how they fit together2.
A problem currently inherent to quantum machine learning is that of being able to train at scale. We avoid this by making use of “compositional generalization”. This means we train small, on classical computers, and then at test time evaluate much larger examples on a quantum computer. There now exist quantum computers which are impossible to simulate classically. To train models for such computers, it seems that compositional generalization currently provides the only credible path.
1. Text as circuits
DisCoCirc is a circuit-based model for natural language that turns arbitrary text into “text circuits” [arXiv:1904.03478, arXiv:2301.10595, arXiv:2311.17892]. When we say that arbitrary text becomes ‘text-circuits’ we are converting the lines of text, which live in one dimension, into text-circuits which live in two-dimensions. These dimensions are the entities of the text versus the events in time.
To see how that works, consider the following story. In the beginning there is Alex and Beau. Alex meets Beau. Later, Chris shows up, and Beau marries Chris. Alex then kicks Beau.
The content of this story can be represented as the following circuit:
2. From text circuits to quantum circuits
Such a text circuit represents how the ‘actors’ in it interact with each other, and how their states evolve by doing so. Initially, we know nothing about Alex and Beau. Once Alex meets Beau, we know something about Alex and Beau’s interaction, then Beau marries Chris, and then Alex kicks Beau, so we know quite a bit more about all three, and in particular, how they relate to each other.
Let’s now take those circuits to be quantum circuits.
In the last section we will elaborate more why this could be a very good choice. For now it’s ok to understand that we simply follow the current paradigm of using vectors for meanings, in exactly the same way that this works in LLMs. Moreover, if we then also want to faithfully represent the compositional structure in language3, we can rely on theorem 5.49 from our book Picturing Quantum Processes, which informally can be stated as follows:
If the manner in which meanings of words (represented by vectors) compose obeys linguistic structure, then those vectors compose in exactly the same way as quantum systems compose.4
In short, a quantum implementation enables us to embrace compositional interpretability, as defined in our recent paper [arXiv:2406.17583].
3. Text circuits on our quantum computer
So, what have we done? And what does it mean?
We implemented a “question-answering” experiment on our Quantinuum quantum computers, for text circuits as described above. We know from our new paper [arXiv:2408.06061] that this is very hard to do on a classical computer due to the fact that as the size of the texts get bigger they very quickly become unrealistic to even try to do this on a classical computer, however powerful it might be. This is worth emphasizing. The experiment we have completed would scale exponentially using classical computers – to the point where the approach becomes intractable.
The experiment consisted of teaching (or training) the quantum computer to answer a question about a story, where both the story and question are presented as text-circuits. To test our model, we created longer stories in the same style as those used in training and questioned these. In our experiment, our stories were about people moving around, and we questioned the quantum computer about who was moving in the same direction at the end of the stories. A harder alternative one could imagine, would be having a murder mystery story and then asking the computer who was the murderer.
And remember - the training in our experiment constitutes the assigning of quantum states and gates to words that occur in the text.
4. Compositional generalization
The major reason for our excitement is that the training of our circuits enjoys compositional generalization. That is, we can do the training on small-scale ordinary computers, and do the testing, or asking the important questions, on quantum computers that can operate in ways not possible classically. Figure 4 shows how, despite only being trained on stories with up to 8 actors, the test accuracy remains high, even for much longer stories involving up to 30 actors.
Training large circuits directly in quantum machine learning, leads to difficulties which in many cases undo the potential advantage. Critically - compositional generalization allows us to bypass these issues.
5. Real-world comparison: ChatGPT
We can compare the results of our experiment on a quantum computer, to the success of a classical LLM ChatGPT (GPT-4) when asked the same questions.
What we are considering here is a story about a collection of characters that walk in a number of different directions, and sometimes follow each other. These are just some initial test examples, but it does show that this kind of reasoning is not particularly easy for LLMs.
The input to ChatGPT was:
What we got from ChatGPT:
Can you see where ChatGPT went wrong?
ChatGPT’s score (in terms of accuracy) oscillated around 50% (equivalent to random guessing). Our text circuits consistently outperformed ChatGPT on these tasks. Future work in this area would involve looking at prompt engineering – for example how the phrasing of the instructions can affect the output, and therefore the overall score.
Of course, we note that ChatGPT and other LLM’s will issue new versions that may or may not be marginally better with ‘question-answering’ tasks, and we also note that our own work may become far more effective as quantum computers rapidly become more powerful.
6. What’s next?
We have now turned our attention to work that will show that using vectors to represent meaning and requiring compositional interpretability for natural language takes us mathematically natively into the quantum formalism. This does not mean that there doesn't exist an efficient classical method for solving specific tasks, and it may be hard to prove traditional hardness results whenever there is some machine learning involved. This could be something we might have to come to terms with, just as in classical machine learning.
At Quantinuum we possess the most powerful quantum computers currently available. Our recently published roadmap is going to deliver more computationally powerful quantum computers in the short and medium term, as we extend our lead and push towards universal, fault tolerant quantum computers by the end of the decade. We expect to show even better (and larger scale) results when implementing our work on those machines. In short, we foresee a period of rapid innovation as powerful quantum computers that cannot be classically simulated become more readily available. This will likely be disruptive, as more and more use cases, including ones that we might not be currently thinking about, come into play.
Interestingly and intriguingly, we are also pioneering the use of powerful quantum computers in a hybrid system that has been described as a ‘quantum supercomputer’ where quantum computers, HPC and AI work together in an integrated fashion and look forward to using these systems to advance our work in language processing that can help solve the problem with LLM’s that we highlighted at the start of this article.
1 And where do we go next, when we don’t even understand what we are dealing with now? On previous occasions in the history of science and technology, when efficient models without a clear interpretation have been developed, such as the Babylonian lunar theory or Ptolemy’s model of epicycles, these initially highly successful technologies vanished, making way for something else.
2 Note that our conception of compositionality is more general than the usual one adopted in linguistics, which is due to Frege. A discussion can be found in [arXiv: 2110.05327].
3 For example, using pregroups here as linguistic structure, which are the cups and caps of PQP.
4 That is, using the tensor product of the corresponding vector spaces.
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.