Quantinuum Sets New Record with Highest Ever Quantum Volume
Simpler, faster and fewer errors: How arbitrary angle gates help increase H1’s quantum volume
New arbitrary angle gate capabilities enable increase in Quantum Volume (QV) to 8192 as Quantinuum continues to achieve its previously stated objective of increasing its QV by 10x every year; TKET downloads surpass 500,000
Quantinuum President and COO Tony Uttley announced three major accomplishments during his keynote address at the IEEE Quantum Week event in Colorado last week.
The three milestones, representing actionable acceleration for the quantum computing eco-system, are: (i) new arbitrary angle gate capabilities on the H-series hardware, (ii) another QV record for the System Model H1 hardware, and (iii) over 500,000 downloads of Quantinuum’s open-sourced TKET, a world-leading quantum software development kit (SDK).
The announcements were made during Uttley’s keynote address titled, “A Measured Approach to Quantum Computing.”
These advancements are the latest examples of the company’s continued demonstration of its leadership in the quantum computing community.
“Quantinuum is accelerating quantum computing’s impact to the world,” Uttley said. “We are making significant progress with both our hardware and software, in addition to building a community of developers who are using our TKET SDK.”
This latest quantum volume measurement of 8192 is particularly noteworthy and is the second time this year Quantinuum has published a new QV record on their trapped-ion quantum computing platform, the System Model H1, Powered by Honeywell.
A key to achieving this latest record is the new capability of directly implementing arbitrary angle two-qubit gates. For many quantum circuits, this new way of doing a two-qubit gate allows for more efficient circuit construction and leads to higher fidelity results.
Dr. Brian Neyenhuis, Director of Commercial Operations at Quantinuum, said, “This new capability allows for several user advantages. In many cases, this includes shorter interactions with the qubits, which lowers the error rate. This allows our customers to run long computations with less noise.”
These arbitrary angle gates build on the overall design strength of the trapped-ion architecture of the H1, Neyenhuis said.
“With the quantum-charged coupled device (QCCD) architecture, interactions between qubits are very simple and can be limited to a small number of qubits which means we can precisely control the interaction and don’t have to worry about additional crosstalk,” he said.
This new gate design represents a third method for Quantinuum to improve the efficiency of the H1 generation, said Dr. Jenni Strabley, Senior Director of Offering Management at Quantinuum.
“Quantinuum’s goal is to accelerate quantum computing. We know we have to make the hardware better and we have to make the algorithms smarter, and we’re doing that,” she said. “Now we can also implement the algorithms more efficiently on our H1 with this new gate design.”
A powerful new capability: More information on arbitrary angle gates
Currently, researchers can do single qubit gates – rotations on a single qubit – or a fully entangling two-qubit gate. It’s possible to build any quantum operation out of just those building blocks.
With arbitrary angle gates, instead of just having a two-qubit gate that's fully entangling, scientists can use a two-qubit gate that is partially entangling.
“There are many algorithms where you want to evolve the quantum state of the system one tiny step at a time. Previously, if you wanted a tiny bit of entanglement for some small time step, you had to entangle it all the way, rotate it a little bit, and then unentangle it almost all the way back,” Neyenhuis said. “Now we can just add this tiny little bit of entanglement natively and then go to the next step of the algorithm.”
There are other algorithms where this arbitrary angle two-qubit gate is the natural building block, according to Neyenhuis. One example is the quantum Fourier transform. Using arbitrary angle two-qubit gates cuts the number of two-qubit gates (and the overall error) in half, drastically improving the fidelity of the circuit. Researchers can use this new gate design to run harder problems that resulted in catastrophic errors in previous experiments.
“By going to an arbitrary angle gate, in addition to cutting the number of two-qubit gates in half, the error we get per gate is lower because it scales with the amplitude of that gate,” Neyenhuis said.
This is a powerful new capability, particularly for noisy intermediate-scale quantum algorithms. Another demonstration from the Quantinuum team was to use arbitrary angle two-qubit gates to study non-equilibrium phase transitions, the technical details of which are available on the arXiv here.
“For the algorithms that we are going to want to run in this NISQ regime that we're in right now, this is a more efficient way to run your algorithm,” Neyenhuis said. “There are lots of different circuits you would want to run where this arbitrary angle gate gives you a fairly significant increase in the fidelity of your overall circuit. This capability also allows for a speed up in the circuit execution by removing unneeded gates, which ultimately reduces the time of executing a job on our machines.”
Researchers working with machine learning algorithms, variational algorithms, and time evolution algorithms would see the most benefit from these new gates. This advancement is particularly relevant for simulating the dynamics of other quantum systems.
“This just gave us a big win in fidelity because we can run the sort of interaction you're after natively, rather than constructing it out of some other Lego blocks,” Neyenhuis said.
A new milestone in quantum volume
Quantum volume tests require running arbitrary circuits. At each slice of the quantum volume circuit, the qubits are randomly paired up and a complex two-qubit operation is performed. This SU(4) gate can be constructed more efficiently using the arbitrary angle two-qubit gate, lowering the error at each step of the algorithm.
The H1-1’s quantum volume of 8192 is due in part to the implementation of arbitrary angle gates and the continued reduction in error rates. Quantinuum’s last quantum volume increase was in April when the System Model H1-2 doubled its performance to become the first commercial quantum computer to pass Quantum Volume 4096.
This new increase is the seventh time in two years that Quantinuum’s H-Series hardware has set an industry record for measured quantum volume as it continues to achieve its goal of 10X annual improvement.
Quantum volume, a benchmark introduced by IBM in 2019, is a way to measure the performance of a quantum computer using randomized circuits, and is a frequently used metric across the industry.
Building a quantum ecosystem among developers
Quantinuum has also achieved another milestone: over 500,000 downloads of TKET.
TKET is an advanced software development kit for writing and running programs on gate-based quantum computers. TKET enables developers to optimize their quantum algorithms, reducing the computational resources required, which is important in the NISQ era.
TKET is open source and accessible through the PyTKET Python package. The SDK also integrates with major quantum software platforms including Qiskit, Cirq and Q#. TKET has been available as an open source language for almost a year.
This universal availability and TKET’s portability across many quantum processors are critical for building a community of developers who can write quantum algorithms. The number of downloads includes many companies and academic institutions which account for multiple users.
Quantinuum CEO Ilyas Khan said, “Whilst we do not have the exact number of users of TKET, it is clear that we are growing towards a million people around the world who have taken advantage of a critical tool that integrates across multiple platforms and makes those platforms perform better. We continue to be thrilled by the way that TKET helps democratize as well as accelerate innovation in quantum computing.”
Arbitrary angle two-qubit gates and other recent Quantinuum advances are all built into TKET.
“TKET is an evolving platform and continues to take advantage of these new hardware capabilities,” said Dr. Ross Duncan, Quantinuum’s Head of Quantum Software. “We’re excited to put these new capabilities into the hands of the rapidly increasing number of TKET users around the world.”
Additional Data for Quantum Volume 8192
The average single-qubit gate fidelity for this milestone was 99.9959(5)%, the average two-qubit gate fidelity was 99.71(3)% with fully connected qubits, and state preparation and measurement fidelity was 99.72(1)%. The Quantinuum team ran 220 circuits with 90 shots each, using standard QV optimization techniques to yield an average of 175.2 arbitrary angle two-qubit gates per circuit.
The System Model H1-1 successfully passed the quantum volume 8192 benchmark, outputting heavy outcomes 69.33% of the time, with a 95% confidence interval lower bound of 68.38% which is above the 2/3 threshold.
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.