⚛️ quantum physics

Quantum codes from classical annealing

This paper introduces an adaptive simulated annealing algorithm that successfully discovers state-of-the-art CSS and "self-dual with equivalent logicals" (SWEL) quantum error-correcting codes with high encoding rates and large distances, offering promising candidates for both fault-tolerant architectures and near-term hardware demonstrations.

Original authors: Michael A. Perlin, Matthew Steinberg, Ben Criger

Published 2026-07-23

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Michael A. Perlin, Matthew Steinberg, Ben Criger

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 library that can survive a hurricane. In the world of quantum computing, this "library" is a collection of fragile bits of information called qubits. Unlike the sturdy books on your shelf, qubits are like soap bubbles; the slightest touch from heat, noise, or a stray electromagnetic wave can pop them, destroying the data inside. To stop this, scientists use a trick called Quantum Error Correction. Instead of writing a story on one fragile bubble, they spread the story across many bubbles in a special pattern. If one bubble pops, the pattern allows you to reconstruct the story from the remaining ones.

However, there is a catch: the more bubbles you use to protect the story, the fewer stories you can tell at once. This is the trade-off between reliability (how well the code protects against errors) and efficiency (how much useful information you can store). Scientists have been hunting for "magic codes"—patterns that offer the best of both worlds: high protection without wasting too many bubbles. This paper dives into that hunt, using a clever computer search to find new, highly efficient patterns that could help build the quantum computers of the future.

The Great Code Hunt: Finding the Perfect Shield

Think of designing a quantum error-correcting code like trying to find the perfect lock for a treasure chest. You want a lock that is incredibly hard to pick (high distance, meaning it can withstand many errors) but also light enough to carry around (high encoding rate, meaning it doesn't waste too much space). For a long time, scientists have known that such locks should exist, based on mathematical theories, but actually finding the specific blueprints for them has been like looking for a needle in a haystack the size of a galaxy.

The authors of this paper, researchers from JPMorgan Chase and Quantinuum, decided to stop looking for the needle by hand and instead built a robotic search engine to do the work for them. They used a technique called simulated annealing. To understand this, imagine you are trying to find the lowest point in a vast, foggy mountain range. If you just walk downhill, you might get stuck in a small valley and think you've reached the bottom. But if you occasionally jump uphill (simulating heat), you can escape those small valleys and keep searching until you find the deepest, most perfect valley. In this case, the "valleys" are good quantum codes, and the "height" is how many errors the code can handle.

The team focused on two specific types of codes, which they call CSS codes and SWEL codes.

CSS codes are like a double-layered shield. They use one pattern to catch "X-type" errors (flips) and another to catch "Z-type" errors (phase shifts). They are popular because they are relatively easy to work with.
SWEL codes (Self-Dual with Equivalent Logicals) are a special, fancy version of CSS codes. They are "self-dual," meaning the X and Z layers are mirror images of each other. This symmetry is a superpower: it allows certain quantum operations (gates) to be performed simply by applying the same action to every physical qubit at once. This makes them much easier to use in real, fault-tolerant quantum computers.

The researchers set their search engine loose on codes with up to 50 physical qubits (the bubbles) and at least 4 logical qubits (the actual stories being told). They didn't just look for any code; they looked for ones that beat the theoretical "Gilbert-Varshamov bound." Think of this bound as a speed limit sign on the highway of quantum coding. It tells you the fastest speed (best distance) you should be able to go for a given number of qubits. The authors' search found codes that frequently met or even exceeded this speed limit, meaning they found shields that are better than the standard mathematical predictions suggested were possible for these sizes.

One of the smartest parts of their method was how they measured "goodness." Usually, you just count how many errors a code can fix. But the researchers realized that two codes might fix the same number of errors, yet one might be much more likely to fail in a real-world scenario because it has more "weak spots." To fix this, they created a custom "energy function" that acted like a super-sensitive detector. It didn't just count errors; it counted the number of ways a code could fail at its weakest point. This helped their search engine avoid getting stuck on "flat plateaus" where many codes looked the same, guiding it instead toward the truly superior designs.

After running their simulations, the team produced a list of the best codes they found, which are detailed in the paper's appendices. These aren't just theoretical musings; they are concrete blueprints. For example, they found a code using 20 physical qubits to store 6 logical qubits with a distance of 4, and another using 50 physical qubits to store 6 logical qubits with a distance of 8. Many of these codes have fewer "minimum-weight logical operators" (weak spots) than previous records, making them more robust.

The paper also highlights that these codes are particularly promising for "near-term" quantum hardware. While massive, perfect quantum computers are still years away, today's machines are small and noisy. These new codes offer a way to squeeze more useful work out of these small, imperfect machines. Furthermore, because the SWEL codes allow for special "transversal" gates (operations that don't need complex wiring), they could be the key to building fault-tolerant gate sets, which are essential for running complex algorithms without the computer crashing.

In short, this paper doesn't claim to have solved the entire mystery of quantum error correction. Instead, it provides a powerful new map and a set of high-quality tools. By using an adaptive search algorithm, the authors have discovered a collection of "seed codes" that are ready to be used in future quantum architectures. They show that even with the limitations of current hardware, we can find highly efficient, robust ways to protect quantum information, bringing us one step closer to the day when quantum computers can tackle problems that are impossible for today's supercomputers.

Technical Summary: Quantum Codes from Classical Annealing

Problem Statement

Quantum error correction (QEC) is essential for large-scale fault-tolerant (FT) quantum computation. However, known code families often impose prohibitive resource overheads. Topological codes (e.g., surface codes) are constrained by the Bravyi-Poulin-Terhal bound, limiting their encoding rates. Quantum low-density parity-check (qLDPC) codes offer favorable asymptotic parameters but require long-range interactions and complex decoding, making them difficult to implement on current near-term hardware. While code concatenation offers a path to constant spacetime overheads, it relies on high-quality "seed" codes with high encoding rates and large distances.

Brute-force searches for such codes are generally intractable because the space of stabilizer codes grows exponentially with block length $n$ , and computing code distance is an NP-hard problem. Consequently, there is a need for efficient numerical methods to discover moderately-sized ( $n \le 50$ ) quantum stabilizer codes that achieve high encoding rates ( $k/n$ ) and distances ( $d$ ) meeting or exceeding theoretical bounds, specifically for architectures that can support long-range interactions (e.g., trapped ions or neutral atoms).

Methodology

The authors introduce an adaptive simulated annealing algorithm to search for optimal quantum codes within two specific classes:

CSS Codes: Calderbank-Shor-Steane codes, which allow for relatively simple FT state preparation and decoding.
SWEL Codes: A subclass of CSS codes termed "Self-Dual with Equivalent Logicals." These codes satisfy specific symmetry conditions ( $H_X = H_Z$ and logical operators $L_X = L_Z$ ) that guarantee transversal implementations of logical Hadamard ( $H^{\otimes k}$ ) and Phase ( $S^{\otimes k}$ ) gates, facilitating the construction of FT gate sets.

Search Space and Moves

Initialization: Instead of starting from trivial codes, the algorithm "warm starts" by applying a random CSS-preserving or SWEL-preserving gate to a trivial code.
- For CSS codes, the search space is sampled via the general linear group $GL(n, \mathbb{F}_2)$ .
- For SWEL codes, the search space is sampled via the orthogonal group $O(n, \mathbb{F}_2)$ .
Proposal Distribution (Moves):
- CSS: Moves are generated by applying random CNOT gates between pairs of qubits. Theorem 1 establishes that CNOT gates can transform any CSS code into any other CSS code with the same rank parameters.
- SWEL: Moves are generated by applying "elementary SWEL-preserving gates," which act on four qubits. Theorem 5 proves that these gates, combined with permutations, can traverse the entire space of SWEL codes.

Energy Function

To avoid "barren plateaux" where the code distance remains constant despite local changes, the authors define an energy function $E(C)$ that serves as a surrogate for the logical error rate in a code-capacity noise model.
$E(C) = \frac{\log m}{\log(1/p)} - d$
where $d$ is the code distance, $m$ is the number of minimum-weight nontrivial logical operators, and $p$ is the physical error rate (set to $10^{-3}$ ). This function penalizes codes with higher distances (lower energy) and, crucially, breaks ties between codes of equal distance by favoring those with fewer minimum-weight logical operators ( $m$ ).

Adaptive Annealing

The algorithm employs an adaptive temperature schedule to prevent the system from freezing on plateaus or degenerate local minima. The temperature is adjusted at each epoch based on the observed energy differences of proposed moves, targeting a specific uphill acceptance rate. A memory factor is used to dampen temperature fluctuations.

Post-Processing

After finding a code via annealing, a greedy algorithm is applied to reduce the weights of the stabilizer generators. This step minimizes the complexity of syndrome measurements without altering the code's distance or logical operators.

Key Contributions

Algorithmic Framework: The development of an adaptive simulated annealing algorithm specifically tailored for the search of CSS and SWEL quantum codes, utilizing group-theoretic properties to ensure the search space is fully covered.
SWEL Characterization: A rigorous theoretical framework (Theorems 3 and 4) defining SWEL codes and proving that the set of SWEL-preserving gates (isomorphic to $O(n, \mathbb{F}_2)$ ) is sufficient to generate all SWEL codes from a trivial seed.
Energy Surrogate: The formulation of an energy function that combines code distance with the count of minimum-weight logical operators, effectively resolving the discrete plateaux that hinder naive distance optimization.
Discovery of State-of-the-Art Codes: The identification of numerous new codes for block lengths up to $n=50$ that outperform previously known codes indexed on qecdb.org.

Results

The authors present a comprehensive table of discovered codes (Appendix F) with parameters $[n, k, d]$ where $n \le 50$ and $k \ge 4$ .

Performance: Many of the discovered CSS and SWEL codes achieve distances that meet or exceed the quantum Gilbert-Varshamov (QGV) bound ( $d_{QGV}$ ) and the CSS-specific Gilbert-Varshamov bound ( $d_{CSS}$ ).
Comparison: The results are compared against the best known codes on qecdb.org. In many cases, the new codes offer higher distances for the same $n$ and $k$ , or higher $k$ for the same $n$ and $d$ .
Logical Error Rates: Using Monte Carlo simulations with importance sampling, the authors estimate logical error rates for these codes. The results validate that the energy function successfully identifies codes with lower logical error rates, particularly for distances $d > 4$ .
SWEL Specifics: The discovered SWEL codes possess the necessary structure for transversal logical Clifford gates. For example, the $[20, 6, 4]$ SWEL code was found to have at least 2,304 SWAP-transversal logical Clifford gates.

Significance and Claims

The paper claims that these numerically optimized codes serve as favorable seed codes for fault-tolerant architectures based on code concatenation. By providing high-rate, high-distance codes for moderate block sizes, they can be used to construct larger-scale logical qubits with reduced overhead.

Furthermore, the authors highlight the potential of these codes for near-term hardware demonstrations. Specifically, they note that trapped-ion and neutral-atom platforms, which support long-range interactions, are well-suited to implement these codes. The SWEL codes are particularly significant because their transversal gate sets allow for the construction of fault-tolerant logical gate sets without the need for complex magic state distillation for Clifford operations.

The authors remain modest regarding the immediate scalability of the search algorithm, noting that the exponential runtime of distance calculation limits the search to $n \le 50$ . They suggest that future work could involve parallelizing the energy function evaluation, improving annealing schedules, or incorporating machine learning techniques to scale the search to larger block lengths. They also propose that code concatenation using these seeds (e.g., combining $[8, 6, 2]$ Iceberg codes with $[38, 12, 6]$ codes) could yield practical architectures for commercial-scale quantum computing.