Magic state injection on IBM quantum processors above the distillation threshold

Why this matters for future computers

Today’s prototype quantum computers are powerful in principle but fragile in practice: tiny imperfections quickly scramble their calculations. This paper explores a concrete step toward taming that fragility on IBM’s quantum hardware. The authors show how to reliably create special “magic” quantum states—key ingredients for running the full range of quantum algorithms—using fewer hardware resources than before, and with quality high enough to be practically useful. Their results suggest that genuinely fault-tolerant quantum computing is inching closer from theory toward engineered reality.

Building a safer home for quantum information

To keep quantum information safe, researchers spread it across many physical qubits in a structured pattern known as a surface code. This code constantly checks for errors without directly peeking at the fragile information itself. The IBM devices used here arrange qubits in a “heavy-hexagon” layout, where each qubit touches at most three neighbors, unlike the four-way grid often assumed in textbooks. That hardware layout complicates how standard surface codes can be drawn and operated. The authors adopt a more economical variant called a rotated surface code and adapt it to fit naturally on IBM’s hexagonal connectivity, roughly halving the number of qubits needed compared with earlier approaches for large code sizes.

Making the code fit the hardware

In a textbook version of the surface code, certain multi-qubit checks, called stabilizers, act on four qubits at a time. On IBM’s heavy-hexagon chips, this is not directly possible because of limited connections. The authors solve this by “folding” each four-qubit check into a sequence of simpler two-qubit checks using extra bridge qubits as intermediaries. They then “unfold” the transformation to restore the original logical structure. At the outer edges of the code, where fewer neighbors are available, they carefully design smaller two-qubit and one-qubit checks that still slot into the same overall rhythm. Simulations under a realistic noise model show that this rotated layout not only preserves performance, but slightly improves the tolerated physical error rates compared to previous heavy-hexagon codes, with thresholds around three to four errors in a thousand operations.

Injecting a dash of quantum magic

Protecting information is only half the story. To run truly universal quantum algorithms, a computer must also perform certain special operations that cannot be built from the safest, easiest gates alone. A powerful workaround is to prepare “magic states,” special single-qubit states that, when fed through clever circuits, unlock those difficult operations. The authors implement a protocol called magic state injection on IBM’s ibm_fez processor using a distance-3 rotated surface code built from 25 physical qubits. They begin by preparing a chosen single-qubit state at the center of the code patch and simple states on the surrounding qubits. They then run a single round of error-checking circuitry tailored to the heavy-hexagon layout, and finally measure all qubits in carefully chosen bases to reconstruct what logical state was produced inside the code.

Sifting for the cleanest outcomes

Real devices are noisy, so the team uses a strategy known as post-selection: they keep only those experimental runs whose error-check signals look perfectly clean and discard the rest. Although this means they accept just over one-third of all shots, the survivors are high quality. From these selected events, they reconstruct the encoded logical state and compare it to the ideal target using standard measures of quantum similarity called fidelities. Across a wide range of target states on the Bloch sphere, the lowest observed fidelity is about 0.84, and the average is close to 0.88. Notably, two especially important magic states, often labeled H and T in the quantum computing literature, are produced with fidelities around 0.88 and 0.87—comfortably above the known thresholds where further “distillation” routines can boost them to even higher quality.

What this means for tomorrow’s quantum devices

In accessible terms, the authors show that IBM’s current quantum hardware can already host a compact error-correcting grid that not only protects information but also reliably manufactures the special ingredients needed for advanced quantum algorithms. Their rotated design is frugal with qubits, works within real-world wiring constraints, and achieves error rates below key theoretical limits. While many hurdles remain—especially improving measurements, scaling to larger code distances, and reducing subtle multi-qubit error pathways—this work demonstrates that high-value, error-corrected resources like magic states are no longer purely theoretical. They can be created, verified, and used as building blocks on today’s machines, bringing truly fault-tolerant quantum computing a step closer.

Citation: Kim, Y., Sevior, M. & Usman, M. Magic state injection on IBM quantum processors above the distillation threshold. Sci Rep 16, 11189 (2026). https://doi.org/10.1038/s41598-026-40381-1

Keywords: quantum error correction, surface code, magic state injection, IBM quantum processor, fault tolerant quantum computing