⚛️ quantum physics

Error correction on an array of superconducting qubits with defective components

This paper demonstrates that excluding underperforming components from a 120-qubit superconducting array significantly reduces logical error rates in distance-5 surface codes, proving that defect exclusion is a more effective strategy for scaling solid-state quantum computing than ignoring defects or using defect-aware decoding.

Original authors: Julien M. Drouet, Xanda C. Kolesnikow, Campbell K. McLauchlan, Georgia M. Nixon, Seok-Hyung Lee, Dominic J. Williamson, Stephen D. Bartlett, Benjamin J. Brown, Robin Harper

Published 2026-07-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Julien M. Drouet, Xanda C. Kolesnikow, Campbell K. McLauchlan, Georgia M. Nixon, Seok-Hyung Lee, Dominic J. Williamson, Stephen D. Bartlett, Benjamin J. Brown, Robin Harper

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a massive, intricate castle out of 120 tiny, glowing LEGO bricks. These bricks are superconducting qubits, the building blocks of a quantum computer. In a perfect world, every single brick would be identical, strong, and work together flawlessly. But in the real world, manufacturing isn't perfect. Some bricks are slightly cracked, some glue sticks are weak, and a few bricks just refuse to snap in properly. These are the "defective components."

The big question the authors asked was: If you have a castle with a few bad bricks, how do you keep the whole structure from collapsing when you try to do a complex calculation?

The Two Main Strategies

The researchers tested two different ways to handle these bad bricks on their 120-brick "IBM Nighthawk" processor.

Strategy 1: The "Ignore and Hope" Approach (The Old Way)
This is like looking at your cracked LEGO brick and saying, "It's probably fine," and then trying to build your tower around it anyway. You tell the computer's brain (the decoder) that the brick is a bit wobbly, but you keep using it. The paper shows that this approach is weak. When they tried this, the castle fell apart (a logical error occurred) about 4.49% of the time in their memory test. It's like trying to walk across a tightrope with a loose shoe; you might make it, but you're likely to stumble.

Strategy 2: The "Quarantine and Rebuild" Approach (The New Way)
This is the paper's main finding. Instead of ignoring the bad bricks, they actively exclude them. If a brick is too cracked or the glue is too weak, they cut it out of the plan entirely. They then rearrange the remaining good bricks to form a new, slightly different shape that still holds the castle together. They call these new, larger structures "super-stabilizers." It's like taking a broken section of a bridge, removing the bad planks, and building a detour around them using only the strong planks you have left.

The Results: A Dramatic Rescue

When they switched to the "Quarantine and Rebuild" strategy, the results were dramatic.

The Memory Test: In a test where the computer had to hold onto a piece of information (a "memory experiment"), the error rate dropped from 4.49% down to 1.62%. That is a 2.8 times improvement!
The Logic Gate Test: They also tested "measurement-based logic gates," which are like performing a magic trick with the bricks. Without removing the bad parts, the trick failed every time the number of steps increased (the failure rate didn't go down). But when they excluded the bad components, the failure rate dropped by 6.3% per round. The trick started working again!

What About the "Smart Decoder"?

The paper explicitly argues against the idea that just telling the computer's brain "Hey, this brick is bad" is enough. They tested a "noise-informed decoder" that knows exactly which bricks are wobbly but still tries to use them.

The Verdict: This only gave a tiny, modest improvement (dropping the error from 4.49% to 4.22%).
The Lesson: Knowing a brick is bad isn't enough; you have to physically stop using it. The paper suggests that for large-scale quantum computers, you can't just "software fix" a broken part; you have to "hardware quarantine" it.

The "Leakage" Mystery

There was one more twist. The authors noticed that even with the best strategies, their computer was still making more mistakes than their computer simulations predicted. They suspected "leakage"—a fancy way of saying the glowing bricks were sometimes jumping out of their designated "room" (the computational subspace) and getting lost in a hallway where they couldn't be controlled.

To test this, they used a "post-selection" trick. Imagine taking a photo of your castle after every step. If the photo shows a brick has jumped out of the room, they throw that photo away and pretend it never happened.

The Result: When they threw away the "leaky" photos, the error rate for their distance-5 code (the big castle) dropped to 0.98%.
The Comparison: This was actually better than the best possible "distance-3" code (a smaller, simpler castle) they could build, which had an error rate of 1.26%.
The Catch: The paper is careful to say this "post-selection" is just a way to prove the point. It's not a scalable solution for a real computer because you can't just throw away your work every time a brick jumps. Real quantum computers will need a way to physically reset the bricks back into the room, which this specific machine (IBM Miami) cannot do yet.

The Bottom Line

The authors are confident that as we build bigger and bigger quantum computers, we will inevitably have defective parts. Their experiments prove that actively excluding these bad parts and rebuilding the code around them is essential. It's not just a nice idea; it's the only way to get the error rates low enough to do useful work.

They showed that by removing the bad components, they could make a large, complex code (distance-5) perform better than a smaller, simpler one (distance-3) in specific situations. However, they also note that this is a "proof-of-principle." While the results are measured and real, the full potential of this method depends on future hardware that can handle "leakage" more actively, rather than just throwing away the bad data.

In short: If you have a broken brick, don't try to glue it back in. Take it out, rearrange the rest, and your castle will stand much taller.

Technical Summary: Error Correction on an Array of Superconducting Qubits with Defective Components

Problem Statement
Solid-state quantum computing architectures require the fabrication of large arrays of coupled qubits. As these arrays scale, fabrication imperfections inevitably lead to variability in component performance, resulting in a subset of underperforming or defective qubits and couplers. These defects pose a critical challenge to Quantum Error Correction (QEC): highly noisy components can drastically increase logical error probabilities in memory units and render parity checks for syndrome extraction unreliable, potentially introducing logical errors during gate operations. While noise-informed decoders can accommodate minor variations, theoretical literature suggests that when components are excessively noisy, active strategies that modify syndrome extraction circuits to exclude these defects are necessary. However, the practical efficacy of such strategies on large-scale, real-world hardware with non-uniform defect distributions had not been comprehensively demonstrated.

Methodology
The authors implemented and compared various strategies for operating distance-5 surface codes on the 120-qubit IBM Nighthawk quantum processor (ibm_miami). The study utilized a square-lattice array where data qubits and measure qubits are partitioned to perform stabilizer measurements.

Defect Identification: The team characterized the device to identify underperforming components. Criteria included:
- Couplers with error rates > 5% or lacking calibration data.
- Measure qubits with measurement error rates > 7%.
- Data qubits with both $T_1$ and $T_2$ times below 80 $\mu$ s.
Strategies Compared:
- Defect-Ignorant (Passive): The standard code and syndrome extraction circuit were used without modification. Decoding was performed using either a uniform prior (uninformed) or a noise-informed BeliefMatching decoder utilizing full calibration data.
- Defect-Aware (Active Exclusion): The code and syndrome extraction circuits were locally modified to avoid defective components.
  - Coupler/Measure Qubit Defects: Handled via "ancilla repurposing" (Ref. [19]), where neighboring measure qubits perform additional parity checks to reconstruct original stabilizers, preserving spatial code distance.
  - Data Qubit Defects: Handled via "super-stabilizer" construction (Ref. [13, 14]), where neighboring stabilizers are merged around the excluded data qubit. This reduces code distance in at least one Pauli basis.
- Leakage Post-Selection: Samples were post-selected based on IQ data to exclude events where the qubit likely leaked out of the computational subspace.
Experiments:
- Memory Experiments: Repeated stabilizer readout rounds (up to 32) to measure logical error rates per round in both Pauli-X and Pauli-Z bases.
- Stability Experiments: Designed to test measurement-based logical gates by verifying that a product of stabilizer checks yields a known value (+1). The failure rate was analyzed as a function of measurement rounds to determine if error suppression occurred.

Key Results

Memory Performance: Active defect exclusion yielded a dramatic reduction in logical error rates compared to defect-ignorant approaches.
- In the Pauli-Z basis, excluding underperforming couplers reduced the logical error per round from 4.49% (uninformed decoder) to 2.71%.
- Further excluding an underperforming data qubit reduced the error rate to 1.62%.
- In contrast, using a noise-informed decoder without excluding defects only reduced the error rate to 4.22%, demonstrating that passive decoding offers only modest gains compared to active exclusion.
- The improvement was less pronounced in the Pauli-X basis, attributed to the specific geometry of the defects and the formation of a weight-10 super-stabilizer required to handle the exclusion.
Stability Experiments: Defect exclusion was critical for measurement-based logic.
- With active exclusion, the failure rate decayed with increasing measurement rounds, showing a suppression factor $\Gamma = 0.94$ .
- Without exclusion, the failure rate did not decay ( $\Gamma \geq 1$ ), indicating that the error correction strategy was introducing errors faster than it could correct them.
Leakage Mitigation: Combining defect exclusion with leakage post-selection (cutoff at 3% probability) further reduced logical errors.
- In the Pauli-Z basis, the distance-5 code with full defect exclusion and post-selection achieved a logical error per round of 0.98%, outperforming the best distance-3 code (1.26%) found within the same footprint.
Simulation vs. Reality: Simulations using Stim and circuit-level noise models captured the qualitative trends but consistently predicted lower error rates than observed, suggesting unmodeled error sources like leakage.

Significance and Claims
The paper provides a proof-of-principle demonstration that active defect exclusion methods are essential for the scale-up of solid-state quantum computing. The authors claim that:

Necessity of Active Strategies: As devices scale, the presence of defective components is inevitable. Relying solely on noise-informed decoding is insufficient; active modification of the code to quarantine defective components is required to achieve significant logical error suppression.
Resurrection of Gate Performance: Defect exclusion is particularly vital for measurement-based logical operations, which are highly sensitive to component reliability. Excluding defects "resurrects" the ability to suppress failure rates in stability experiments, a capability lost when defects are ignored.
Synergy with Leakage Mitigation: Combining active defect exclusion with leakage post-selection allows a distance-5 code to outperform a distance-3 code, highlighting the potential for scalable fault tolerance when hardware noise characteristics are co-designed with error correction protocols.

The authors conclude that while their current post-selection approach is not scalable (as it discards data), the results underscore the importance of developing scalable leakage-resilient circuits alongside active defect exclusion strategies for future large-scale quantum processors.