⚛️ quantum physics

Quantum codes in the Lee metric

This paper introduces a quantum coding framework based on the Lee metric to address discrete small-shift noise, developing stabilizer codes over $\mathbb{Z}_q$ that offer potential efficiency gains for qubits while revealing fundamental distance limitations for large- $q$ qudits and exploring the self-correcting properties of helical repetition codes.

Original authors: Jinkang Guo, Yiqiu Han, Aranya Chakraborty, Shubham P. Jain, Tianhao Liu, Victor V. Albert, Andrew Lucas

Published 2026-10-06

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Jinkang Guo, Yiqiu Han, Aranya Chakraborty, Shubham P. Jain, Tianhao Liu, Victor V. Albert, Andrew Lucas

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

In the race to build a working quantum computer, scientists face a fundamental problem: the fragile bits of information, called qubits, are constantly bombarded by noise. This noise causes errors, scrambling the delicate calculations before they can finish. To fight back, researchers use quantum error correction, a method where information is spread out across many physical particles so that if one gets corrupted, the others can reveal the mistake and fix it. For years, the standard approach has treated every possible error as equally likely, counting them simply by how many particles are involved. This is like assuming a typo in a book is just as likely to be a single missing letter as it is to be a whole paragraph of gibberish. However, in many real-world systems, such as the spinning nuclei of atoms used to store data, small mistakes are far more common than large, chaotic ones. The physics of these systems naturally favors tiny, gentle shifts over massive jumps.

A team of physicists has now developed a new framework that takes this reality into account. Instead of counting errors by the number of particles they touch, they measure them by the size of the shift they cause. This approach, known as the Lee metric, treats a small nudge as a minor error and a large leap as a major one. By designing codes that specifically protect against these small, frequent nudges, the researchers found they could build systems that are much more efficient. They discovered that for certain types of quantum hardware, these new codes can detect and fix errors using fewer physical particles than the old methods require. In some cases, they found codes that could correct two types of errors with just six particles, whereas the traditional method would have needed eleven. This efficiency is a significant step forward, suggesting that we can build more powerful quantum memories without needing an impossibly large number of components.

The researchers did not stop at finding better codes; they also explored how these codes behave when the particles are subjected to the complex operations needed for calculation. They mapped out how errors spread when quantum gates, the tools that manipulate information, are applied. They found that while some operations can amplify small errors, others leave them unchanged, providing a clear guide for which tools are safe to use. A particularly clever part of their work involved translating these new codes into the language of standard two-level qubits. They showed that codes built on four-level particles could be converted into robust codes for two-level systems, effectively unlocking new ways to store information that were previously hidden. This translation revealed that some of these new codes possess special gates that can be applied directly across the whole system, a feature that is rare and highly prized in quantum computing.

Despite these successes, the paper also draws a firm line in the sand regarding what is possible. The team proved that even with these advanced codes, there is a hard limit to how well they can protect information in a specific, desirable way. They demonstrated that for these codes, the error-correcting distance cannot grow faster than linearly with the size of the system, regardless of how large the internal states of the particles are. This finding reveals an unexpected obstruction to using the large internal Hilbert space of a large-q qudit to make high-Lee-distance codes. It rules out the hope that simply making the particles larger or more complex will automatically create a perfect, self-healing quantum memory that works at room temperature. The laws of physics, as revealed by their analysis, prevent the error-correcting power from growing fast enough to overcome thermal noise in the way some had hoped.

However, the story does not end in defeat. The researchers identified a specific class of codes, built from repeating patterns that spiral through the system, that can store information for incredibly long times under certain conditions. These codes act like a one-way street for errors; while it is easy to make a small mistake, it is exponentially difficult to accidentally drift all the way to a different, incorrect state. In simulations, these codes showed the ability to hold onto information for times that grow exponentially as the system gets larger, provided the particles have enough internal states. This suggests that while a perfect, universal self-correcting memory might be out of reach, there are still promising pathways to building quantum memories that can survive for long periods in the real world, offering a realistic hope for the future of quantum technology. The researchers found that these spiral codes can protect one type of error (Z-errors) automatically at high temperatures, but whether they can protect the other type of error (X-errors) in the same way remains an open question.

Technical Summary: Quantum Codes in the Lee Metric

Problem Statement
Current theoretical frameworks for quantum error correction predominantly assume qubits (two-level systems) and utilize the Hamming metric, which counts the number of physical subsystems an error acts upon. However, many physical platforms, such as nuclear spins or superconducting circuits, naturally possess $q$ -level systems (qudits) where $q > 2$ . In these systems, errors are often modeled as small shifts in phase space (analogous to displacement noise in continuous-variable systems) rather than arbitrary Pauli flips. Consequently, a shift of magnitude $k$ (e.g., $X^k$ ) is physically distinct from a shift of magnitude 1, and the probability of occurrence typically decays with the magnitude of the shift. The standard Hamming metric fails to capture this structure, treating $X^1$ and $X^k$ as errors of equal weight if they act on the same number of qudits. This paper addresses the gap in the literature by developing a systematic formalism for quantum stabilizer codes over $\mathbb{Z}_q$ that utilizes the Lee metric, which weights errors by the magnitude of their $X$ and $Z$ shifts rather than just their support size.

Methodology
The authors develop a comprehensive theoretical framework for quantum codes in the Lee metric, extending classical Lee-metric coding theory to the quantum domain. The methodology proceeds through several key stages:

Metric Definition: The paper defines two metrics for Pauli strings $X^x Z^z$ on $n$ qudits:
- Separate Lee Metric: Records the pair $(|x|_L, |z|_L)$ , suitable for CSS codes.
- Joint Lee Metric: Records the sum $|x|_L + |z|_L$ . For qubits, this assigns weight 2 to $Y$ errors and weight 1 to $X$ and $Z$ , reflecting the assumption that $Y$ errors arise from independent $X$ and $Z$ processes.
  The Lee weight $|x|_L$ is defined as $\sum \min(x_i, q-x_i)$ .
Stabilizer Formalism: The authors generalize the symplectic stabilizer formalism to $\mathbb{Z}_q$ using the Lee metric. They derive sphere-packing bounds and identify perfect codes that saturate these bounds. Unlike the Hamming metric, where perfect quantum codes are rare and limited to distance 3, the Lee metric admits perfect codes with higher distances and varying parameters (e.g., a single-qudit perfect code on $\mathbb{Z}_{10}$ ).
CSS Codes and Torsion: A significant portion of the work focuses on CSS codes over composite $q$ . The authors utilize the Smith Normal Form (SNF) of parity-check matrices to analyze the codespace structure. They explicitly characterize "torsion factors," where logical qudits have dimensions that divide $q$ but are less than $q$ . This allows for the construction of codes with logical operators of specific dimensions and the derivation of explicit conjugate pairs of logical operators.
Fault Tolerance and Gate Spread: The paper introduces the concept of Lee error spread ( $w_B$ ) for Clifford gates, quantifying how much a gate can increase the Lee weight of an error. This is analogous to the amplification of displacement errors in GKP codes. The authors prove that the fault distance of a logical gate is bounded by the code distance divided by the gate's spread. They identify gates of spread 1 (permutations and Fourier gates) which preserve Lee weight exactly.
Qubitization via Gray Maps: To bridge the gap between qudit and qubit architectures, the authors employ the Gray map to convert $\mathbb{Z}_4$ stabilizer codes into qubit codes. They demonstrate that this map is an isometry from the Lee metric on $\mathbb{Z}_4^n$ to the Hamming metric on $\mathbb{Z}_2^{2n}$ . Crucially, they show that while $\mathbb{Z}_4$ Pauli operators map to qubit Clifford gates, $\mathbb{Z}_4$ Clifford gates map to the third level of the qubit Clifford hierarchy (including non-Clifford gates like $T$ and $CS$ ).
Lee-LDPC Codes and Bounds: The authors define Lee-LDPC codes, where check matrices have bounded Lee weight. Using tools from the geometry of numbers (transference theorems), they prove that for any nontrivial quantum Lee-LDPC code, the Lee distance cannot exceed $O(n)$ , uniformly in $q$ . This establishes an obstruction to using large $q$ to achieve high-distance codes within the LDPC framework.
Self-Correction and Memory: The paper investigates helical repetition codes and their hypergraph products. They show that under local Metropolis dynamics, certain classical helical codes exhibit exponentially long memory times at fixed temperatures for sufficiently large $q$ , attributed to both energetic barriers and entropic effects. When extended to quantum CSS codes via hypergraph products, these codes inherit self-correction for $Z$ errors, though the status of $X$ error self-correction remains an open question.

Key Contributions and Results

Formalism: Established a rigorous stabilizer formalism for $\mathbb{Z}_q$ codes using both joint and separate Lee metrics, including sphere-packing bounds and the classification of perfect codes.
Qubit Advantage: Demonstrated that for qubits, optimizing for the joint Lee metric (counting $Y$ errors twice) yields codes with higher distances than those optimized for the Hamming metric. For example, a $[[9, 1, 5]]$ Lee-distance code corrects any two $X/Z$ errors or one $Y$ error, whereas the shortest Hamming-distance code correcting two arbitrary errors requires 11 qubits.
Perfect Codes: Identified new families of perfect quantum Lee codes, including single-qudit codes on $\mathbb{Z}_{10}$ and families on $\mathbb{Z}_{3^m}$ , which do not exist in the Hamming metric for the same parameters.
Eastin-Knill Violation: Showed that the Eastin-Knill theorem (which forbids transversal non-Clifford gates for codes detecting all single-qudit errors in the Hamming metric) does not apply to Lee-metric codes. The authors present a perfect two-qudit code on $\mathbb{Z}_{10}$ that corrects all Lee-weight-1 errors yet admits a continuous family of transversal logical gates.
Qubitization: Provided a method to "qubitize" $\mathbb{Z}_4$ codes using Gray maps, converting them into non-additive qubit codes with transversal gates at the third level of the Clifford hierarchy.
Distance Bounds: Proved that for Lee-LDPC codes, the Lee distance is bounded by $O(n)$ regardless of $q$ . This contrasts with general codes where distance can grow with $q$ at fixed $n$ , highlighting a fundamental limitation of sparse-check constructions in the Lee metric.
High-Temperature Memory: Demonstrated that classical helical repetition codes can act as high-temperature memories with exponentially long memory times due to symmetry breaking in the limit of large $q$ . Their quantum hypergraph products provide local 2D codes with self-correction for $Z$ errors.

Significance
The paper argues that the Lee metric provides a more realistic and potentially more powerful framework for quantum error correction in systems dominated by small-shift noise, such as spin qubits. By moving beyond the Hamming metric, the authors reveal:

Efficiency: Codes can be more efficient (fewer physical resources for the same error correction capability) when tailored to the specific noise profile (low-weight shifts).
New Possibilities: The Lee metric enables the existence of perfect codes and transversal gate sets that are forbidden in the Hamming metric, challenging standard no-go theorems like Eastin-Knill when the error model is restricted to small shifts.
Scalability Limits: While large $q$ offers advantages, the paper identifies a hard $O(n)$ bound on the distance of Lee-LDPC codes, suggesting that achieving high-distance, self-correcting quantum memories in the LDPC regime requires more than just increasing the local dimension $q$ .

The work serves as a foundational step toward the "co-design" of quantum codes and experimental error models, offering a pathway to leverage the high-dimensional Hilbert spaces of physical qudits for more robust quantum computation.

More like this