Back to News
quantum-computing

Cultivating record-fidelity magic states with lattice surgery on publicly accessible IBM quantum computers - Q-CTRL

Google News – Quantum Computing
Loading...
5 min read
0 likes
⚡ Quantum Brief
In our most recent work using publicly accessible IBM Quantum Nighthawk processor, our performance-management infrastructure software, and newly demonstrated protocols, we go even further, delivering 10x lower state error, and setting a total of three performance records along the way. Google recently hit a major milestone with a beautiful demonstration of magic-state cultivation using its Willow processor, until now the only quantum processing unit (QPU) on which magic-state cultivation had been demonstrated. And we show a clear path to efficient magic-state factories for large-scale fault-tolerant quantum computing.
AI Audio Summary
0:00 / 0:00
Click to play
8377ec08-9e06-4a8f-b6b0-006509aa5665.jpeg
Quantum News · Media Library

Table of contentsQuantum error correction promises to make large-scale quantum computation possible. It also introduces a formidable cost.One of the most painful tasks in building and running a large-scale fault-tolerant quantum computer comes from the need to generate special “magic states” enabling universal algorithms to be run. Google recently hit a major milestone with a beautiful demonstration of magic-state cultivation using its Willow processor, until now the only quantum processing unit (QPU) on which magic-state cultivation had been demonstrated. In our most recent work using publicly accessible IBM Quantum Nighthawk processor, our performance-management infrastructure software, and newly demonstrated protocols, we go even further, delivering 10x lower state error, and setting a total of three performance records along the way. And we show a clear path to efficient magic-state factories for large-scale fault-tolerant quantum computing.Today’s quantum processors support a rich set of native operations, delivering huge flexibility and efficiency in algorithmic execution while hardware exists at modest scales. So-called fault-tolerant architectures typically support only a much more restricted set in order to ensure errors don’t grow in an uncontrolled fashion as systems grow in size. Translating algorithms into that narrow class of operations can increase circuit depths by orders of magnitude, turning a compact computation into an enormous circuit constituting a huge number of “building-block” operations and supporting subtasks. A major source of that overhead is the need for magic state factories.In universal fault-tolerant quantum computation, we have to implement an unusual (non-Clifford) operation called the T gate, which often cannot be executed directly on logical qubits protected by quantum error correction (QEC). As a result, we require that the gates be “injected” using specialized auxiliary resource states, also known as magic states. Generating magic states with fault-tolerant-grade fidelity is notoriously demanding. In early resource estimates, magic state factories took up more than 90% of a machine’s physical qubits. Better protocols have recently cut that share sharply, but factories remain a substantial part of the cost of fault-tolerant algorithms. Lowering magic-state-factory overhead is among the most critical milestones on the road to practical large-scale quantum computing. In our latest manuscript, Q-CTRL researchers report the first experimental demonstration of magic state cultivation with lattice-surgery escape. The demonstration connects cultivation, a method for preparing high-quality magic states, with the lattice-surgery operations needed to provide the state with greater QEC protection.The work sets three new experimental records. It achieves the lowest reported error rate for magic state cultivation, the lowest per-round logical error rate after escape in magic-state cultivation, and the highest-fidelity magic state demonstrated in a surface code.First introduced in 2024, magic state cultivation provides a low-overhead alternative to traditional magic state “distillation” by avoiding the need for large physical qubit arrays. The protocol proceeds in two stages:Where that refined state ends up depends on the escape strategy used:Executed on an IBM Quantum Nighthawk processor, our lattice-surgery protocol delivered state-of-the-art performance across all four evaluation phases. Achieving this level of performance stems from coupling an efficient protocol and next-generation hardware with a tightly optimized execution pipeline. Our approach involved custom compilation, strategic layout selection to map operations onto the best-performing qubits, interleaved dynamical decoupling to actively suppress environmental noise, and deployment of an upgraded decoding procedure to resolve errors more accurately. Together, these layers ensured that the routines ran cleanly enough to preserve logical advantages.Our cultivation and grafting circuits are very similar to those of the first cultivation experiment, executed on Google’s Willow processor, so the two experiments can be compared side by side. The performance gains shown below span most of the metrics by which a fault-tolerant implementation is measured.These are very significant increases in performance over the prior records using a publicly accessible quantum computer. There’s no special “behind-the-wall” access used to implement these experiments.An effective magic-state factory must satisfy two demands at once: prepare high-fidelity resource states, and preserve them in memory using a decoder fast enough to track real-time errors for later consumption.Our results demonstrate that lattice-surgery escape meets both criteria using the native operations and efficient decoders a surface-code architecture already relies on, demanding no exotic circuitry, prohibitively expensive decoding algorithms, or downstream code conversions. The head-to-head comparison with grafting highlights an essential principle for fault-tolerant architecture design: a code transformation must be evaluated across its entire path, not just where it lands. Errors compound during intermediate steps, ultimately compromising the quality of the generated state. Although grafting eventually reaches a “decoder-friendly” code, the detour it takes sacrifices fidelity and demands slow decoding along the way. Lattice surgery takes the direct path, avoiding both overheads.Building on this demonstration benchmarking a distance-5 implementation, the roadmap forward is clear:At Q-CTRL, we work to make quantum technology useful by improving what quantum hardware can deliver. These results bring that approach to one of fault-tolerant quantum computing’s most demanding building blocks and advance the effort to reduce the resources practical quantum computation will require.To explore the complete experimental protocols and benchmarks, read our technical manuscript arXiv:2611.22035. Interested in applying these methods to your own error-correction pipeline? Contact us.

Read Original

Tags

quantum-computing
ibm

Source Information

Source: Google News – Quantum Computing

Discussion

0 professional contributions

Sign in to join this professional discussion.

Be the first to add a constructive contribution.