⚛️ quantum physics

Decoder- and Noise-Aware Optimization Framework for Clifford-Deformed Quantum Error-Correcting Codes

This paper introduces Evolution-Based Best-arm Identification (EBBI), a shot-efficient search algorithm that enables the scalable optimization of Clifford deformations for quantum error-correcting codes under circuit-level noise, successfully discovering and generalizing a new high-performance "B-XZZX" code pattern that outperforms existing methods.

Original authors: Julius Rye Bønnelykke, Benjamin Joecker, Peter Krogstrup, Vincent Philippe Michal, Mark Kamper Svendsen

Published 2026-10-12

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Julius Rye Bønnelykke, Benjamin Joecker, Peter Krogstrup, Vincent Philippe Michal, Mark Kamper Svendsen

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

Building a computer that can solve problems beyond the reach of today's machines requires a fundamental shift in how we handle information. In the quantum world, the basic units of data are incredibly fragile, prone to losing their state from the slightest whisper of heat or electromagnetic interference. To keep these systems running, scientists use a method called quantum error correction, which acts like a safety net, constantly checking for mistakes and fixing them before they ruin the calculation. However, this safety net is expensive; it requires many physical components to protect just one piece of information. The challenge for researchers is to make this protection as efficient as possible, squeezing the most reliability out of the fewest resources. A promising strategy involves tweaking the rules of the safety net itself. Instead of using a standard, uniform set of rules for every part of the system, scientists can slightly alter the connections between components to better match the specific types of errors their hardware tends to make. This approach, known as Clifford deformation, offers a way to boost performance without adding any new hardware, but finding the perfect pattern of tweaks for a large system is a task so vast that checking every possibility is impossible.

A team of researchers at the Niels Bohr Institute in Copenhagen has developed a new method to navigate this immense search space, successfully identifying superior error-correction patterns that were previously missed. They created an intelligent search algorithm called Evolution-Based Best-arm Identification, which treats the complex quantum system as a black box. Rather than trying to understand every internal detail of the noise and the decoding software, the algorithm tests different patterns, learns from the results, and gradually evolves toward the best solution. It works by simulating the quantum computer thousands of times, observing how often errors slip through, and using those observations to guide the next set of tests. The key insight driving this method is that patterns which are very similar to each other tend to produce similar results. This allows the algorithm to use information gathered from one test to make educated guesses about nearby patterns, effectively pruning away the vast majority of useless options and focusing its energy on the most promising candidates.

The researchers tested this approach on a widely used design called the surface code, which arranges qubits in a two-dimensional grid. They simulated the system under realistic conditions where the hardware is more likely to make one type of error than another, a common trait in many modern quantum devices. In these simulations, the algorithm was pitted against a random search, which simply picks patterns to test without any strategy. The results were striking. For a small version of the code, the new method found the optimal pattern using roughly one thousand times fewer simulation runs than the random approach. As the size of the code grew, the advantage became even more pronounced. While the random search failed to find the best pattern even after billions of attempts, the new algorithm consistently converged on a solution that significantly reduced the rate of logical errors. This efficiency is crucial because simulating these quantum systems is computationally expensive, and the ability to find good solutions with fewer trials makes the optimization of large-scale quantum computers feasible.

Perhaps the most significant discovery was a new pattern of error correction that the algorithm uncovered, which the researchers named the B-XZZX code. This pattern is a variation of a previously known design, but with a specific modification to the edges of the grid. While the new pattern differs from the old one on only a tiny fraction of the total components, its performance improves as the system gets larger. At a code distance of three, it offered a five percent improvement over the previous best, but at a distance of eleven, that advantage grew to about twelve percent. This finding is counterintuitive, as one might expect the benefits of a small change to fade as the system scales up. Instead, the researchers found that the specific way the edges were tuned helped the system handle the unique noise characteristics of their simulated hardware more effectively. They also discovered that the best pattern depends heavily on the specific type of noise and the software used to decode the errors, proving that a one-size-fits-all solution does not exist and that optimization must be tailored to the specific hardware environment.

The work demonstrates that it is possible to systematically improve quantum error correction without building new hardware, simply by finding the right configuration for the existing one. The researchers showed that their method can scale from small test cases to larger, more complex systems, identifying patterns that human intuition or random chance would likely miss. They also highlighted that the success of these patterns is tied to the specific decoder software used to fix errors, suggesting that future quantum computers will need to be co-designed with their error-correction strategies in mind. By providing a practical tool to tailor these codes to the unique noise signatures of real devices, this research offers a clear path toward making fault-tolerant quantum computing a reality, turning the theoretical promise of error correction into a practical engineering solution.

Technical Summary: Decoder- and Noise-Aware Optimization Framework for Clifford-Deformed Quantum Error-Correcting Codes

Problem Statement
Practical fault-tolerant quantum computing necessitates qubit-efficient Quantum Error Correction (QEC). Clifford Deformations (CDs) offer a strategy to modify the stabilizers of a QEC code to lower the logical error rate ( $P_L$ ) without increasing hardware overhead. However, the search space for optimal CDs grows exponentially with the number of qubits ( $6^n$ or $3^n$ depending on noise symmetries), rendering exhaustive search infeasible for codes beyond small distances. Furthermore, previous optimization approaches have been limited: some rely on analytical constructions for specific code families, others use local rules or random-family analysis that are decoder-independent, and exhaustive searches have historically been restricted to code-capacity noise models or phenomenological noise with objectives that ignore the specific decoder. Consequently, there has been no scalable method to systematically assess the gains of CDs under realistic circuit-level noise with practical decoders.

Methodology: Evolution-Based Best-Arm Identification (EBBI)
To address these limitations, the authors introduce Evolution-Based Best-Arm Identification (EBBI), a scalable optimization framework designed to identify high-performing CDs under general circuit-level noise models and decoders. EBBI treats the circuit, noise model, and decoder as a "black box," requiring no prior knowledge of their internal mechanics.

The algorithm operates through three iterative steps:

Initialization: A set of $K$ random CD candidates is selected from the search space. Each candidate undergoes a "warm-up" phase where simulations run until a fixed number of logical faults ( $W$ ) are observed. The logical error rate ( $P_L$ ) for each candidate is modeled as a Beta distribution based on the observed faults and successful decodings.
Sampling: To reduce uncertainty, the algorithm selects the candidate with the largest standard deviation in its $P_L$ posterior distribution. It samples this candidate further until the standard deviation is reduced by a factor of 1.5.
Prune and Re-populate: Candidates are evaluated against a pruning criterion. If the lower bound of a candidate's $P_L$ (at a confidence level $\gamma$ ) exceeds the upper bound of another candidate's $P_L$ , the former is deemed suboptimal and pruned. The pruned slot is filled by a new candidate generated via mutation of the current best CD. The mutation strategy leverages the observation that neighboring CDs (differing by a single qubit's deformation) exhibit strong correlations in $P_L$ . The new candidate is created by either copying the deformation from the current best CD or picking a random deformation with a mutation probability $M$ .

To mitigate the high shot cost required for reliable $P_L$ estimation in large codes, the authors employ a search strategy where the physical error rate is artificially increased ( $p \to p_{search} \ge p$ ) during the optimization phase. This brings the system closer to the code threshold, where $P_L$ is less sensitive to code distance, allowing for efficient identification of promising regions before evaluating at the target error rate.

Key Contributions and Results
The framework was benchmarked on the rotated surface code under two strongly Z-biased circuit-level noise models (HBD and HBD-SI1000) using the PyMatching decoder.

Efficiency: EBBI demonstrates a significant speedup over random search. For the distance-3 surface code, EBBI finds the optimal CD using approximately $1100\times$ fewer shots than random search under specific conditions. For distance-5, while random search fails to converge within the simulation budget, the median EBBI run converges to the believed optimal CDs.
Discovery of B-XZZX: Under the HBD-SI1000 noise model, EBBI discovers a new optimal CD termed B-XZZX (Bordered XZZX). This code differs from the standard XZZX code only on a fraction $O(d^{-1})$ of qubits, specifically modifying the boundary qubits (using Hadamard deformations on left/right edges and corners).
Scalability: The authors generalize the B-XZZX pattern to larger code distances ( $d=3$ to $d=11$ ). While the relative advantage of B-XZZX over XZZX is modest at $d=3$ ( $\approx 5\%$ ), it grows to $\approx 12\%$ at $d=11$ . This demonstrates that the specific boundary effects identified at low distances can be systematically scaled to larger codes, outperforming previously identified constructions.
Decoder Awareness: The study highlights that the optimal CD is strongly dependent on the decoder. For instance, the performance ranking of CDs changes significantly between the PyMatching and BP-OSD decoders, a nuance that decoder-independent surrogates would miss.

Significance and Claims
The paper claims that this work represents a "first step towards scalable CD optimization for general QEC codes." By establishing a method that is both scalable and decoder-aware, the authors provide a practical tool for tailoring quantum error-correcting codes to specific hardware noise characteristics. The discovery of the B-XZZX code illustrates that even minor, localized modifications to code boundaries can yield substantial performance gains at large distances, a finding that was previously inaccessible due to the intractability of the search space. The authors conclude that EBBI enables the systematic assessment of CD gains under circuit-level noise, moving beyond the limitations of code-capacity assumptions and decoder-independent heuristics.

Technical Summary: Decoder- and Noise-Aware Optimization Framework for Clifford-Deformed Quantum Error-Correcting Codes

More like this