Surface code scaling on heavy-hex superconducting quantum processors

In the quest to build a quantum computer, scientists face a fundamental problem: the delicate quantum states that hold information are incredibly fragile. The slightest disturbance from the environment can corrupt the data, causing the machine to fail. To solve this, researchers developed a method called quantum error correction. Instead of relying on a single, perfect physical component, they spread a single piece of information across many physical components. If one part glitches, the system can detect the error and fix it without losing the information, much like how a single torn page in a book does not destroy the story if the text is printed on multiple pages. The most promising way to do this is using a "surface code," a grid-like arrangement where information is protected by checking the relationships between neighboring parts. However, for this protection to work, the machine must be able to correct errors faster than they appear. This requires the system to operate below a specific "threshold" of noise. If the machine is too noisy, the error correction itself introduces more mistakes than it fixes.

The challenge becomes even harder when the physical hardware does not naturally match the grid pattern required by the surface code. Most quantum processors today are built with a specific layout of connections that differs from the ideal square grid needed for these codes. To make them work together, scientists must find clever ways to map the code onto the hardware, often requiring extra steps to move information between distant parts of the chip. These extra steps create pauses where the quantum bits sit idle, waiting for instructions. During these pauses, the bits are vulnerable to noise, which can accumulate and ruin the protection the code is supposed to provide. A team of researchers set out to test whether they could make this difficult setup work on a real quantum processor, specifically one with a unique "heavy-hex" layout used by IBM. They wanted to see if they could scale up the size of their error-correcting code and actually see the error rate drop, proving that the system was entering the safe zone where quantum computers could eventually become powerful enough to solve real-world problems.

The researchers turned to a 156-qubit processor known as "Heron," which features a heavy-hex lattice structure. This layout is designed to reduce interference between qubits, but it makes the surface code harder to implement because the qubits are not all directly connected to their neighbors. To bridge this gap, the team designed a new method to embed the code onto the chip. They used a technique that folds and unfolds the circuit, using special "bridge" qubits to temporarily connect distant parts of the code so they can talk to each other. This approach minimized the time the qubits spent waiting, keeping the circuit as short as possible. However, they knew that even with a short circuit, the idle moments would still allow noise to build up. To combat this, they integrated a powerful noise-suppression strategy called dynamical decoupling. This involves applying a rapid series of control pulses to the qubits while they wait, effectively canceling out the unwanted interactions with the environment before they can cause damage.

The team tested their system by running the error correction code in two different sizes. They started with a smaller code and then expanded it in one direction to create a larger, anisotropic code. In a perfect world, making the code larger would always make it better at protecting information. But in the real world, a larger code requires a more complex circuit, which introduces more opportunities for errors. The researchers found that when they increased the size of the code, the protection improved for one type of error but not the other. Specifically, when they made the code longer in one direction, it became much better at protecting against phase-flip errors, but the protection against bit-flip errors did not improve as much. This happened because the extra complexity of the larger circuit introduced new vulnerabilities that the code could not yet handle.

A critical discovery in this work was the role of the noise-suppression pulses. The researchers found that without these pulses, the larger code appeared to be performing better than the smaller one, suggesting a successful scaling. However, this was a misleading result. When they applied the noise-suppression pulses, they realized that the smaller code benefited from them much more than the larger one did. The pulses were so effective at cleaning up the noise in the smaller, simpler circuit that it looked like the larger code was failing by comparison. This revealed a trap: if you do not carefully optimize the noise suppression for every size of code you test, you might falsely claim that scaling up is working when it is not. The team showed that only by comparing the best possible version of each code size could they get an honest picture of the performance.

To measure the results accurately, the team moved away from standard ways of calculating error rates that rely on simple assumptions about how errors behave. Instead, they developed a new metric based on "entanglement fidelity," which measures how well the system preserves the quantum information across all possible states, not just the ones that are easiest to measure. Using this rigorous method, they found that on their current hardware, the system had not yet reached the point where scaling up the code size guarantees better protection for all types of information. While the larger codes showed improvement in specific directions, the overall system was still too noisy to achieve the universal protection needed for a fully fault-tolerant machine.

The study concludes that the path to a working quantum computer is clear but requires precise engineering. The researchers demonstrated that by combining a smart way to map the code onto the hardware with aggressive noise suppression, they could see the beginnings of error suppression. They showed that with a modest reduction in the current noise levels—roughly a thirty percent improvement—and access to a slightly larger chip to host an even bigger code, the system would cross the threshold into the safe zone. This work does not claim to have solved the problem of quantum error correction, but it provides a concrete roadmap. It proves that the right combination of hardware-aware design and noise control can push these systems closer to the point where they can reliably perform the complex calculations that will define the future of quantum computing.