⚛️ quantum physics

Bounds for General $(r,δ)$ -Quantum Locally Recoverable Codes

This paper establishes new Singleton-like upper bounds for general $(r, \delta)$ -quantum locally recoverable codes without assuming purity, stabilizer structure, or disjoint recovery blocks, while providing explicit remainder corrections and identifying specific code families that attain these tightened limits.

Original authors: Shuowei Ma, Fei Shi

Published 2026-10-30

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Shuowei Ma, Fei Shi

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 vast, invisible architecture of the future, where data is stored not on single hard drives but across thousands of nodes in a distributed network, a single point of failure can be catastrophic. If one node goes dark, the information it held must be recoverable without needing to consult the entire network, a process that would be slow and expensive. This is the domain of locally recoverable codes, a mathematical framework designed to ensure that a lost piece of data can be rebuilt by looking at only a small, specific group of its neighbors. When this concept moves from classical bits to the fragile, entangled world of quantum information, the rules change. Quantum states are delicate; they cannot be copied, and any attempt to repair them must preserve their subtle correlations with the rest of the universe. The challenge for scientists has been to find the absolute limits of how much information can be stored in such a system while guaranteeing that any small error can be fixed locally, without knowing in advance whether the system is perfectly pure or if it carries hidden imperfections.

A team of researchers at Sun Yat-sen University has now mapped these limits with unprecedented clarity. They have established a new set of mathematical boundaries for a broad class of quantum codes known as locally recoverable codes, specifically those capable of correcting multiple errors at once. Unlike previous studies that relied on strict assumptions—such as the code being perfectly pure, having a specific algebraic structure, or using non-overlapping groups of nodes for repair—this work removes those constraints. The researchers proved that even when recovery blocks overlap and the code is not perfectly pure, there is a hard ceiling on how much information can be stored. They derived a formula that acts as a universal speed limit for these systems, showing exactly how the size of the network, the number of errors it can fix, and the size of the local repair groups interact to determine the maximum storage capacity.

The core of their discovery lies in a clever method of selection. Imagine trying to find the most efficient way to patch holes in a net where the patches can overlap. The researchers developed a step-by-step procedure to select groups of coordinates that can be repaired locally, ensuring that these groups do not interfere with one another in a way that breaks the global repair capability. By carefully counting how many coordinates can be covered by these local repairs and how many remain for global correction, they derived a precise upper bound on the amount of data the code can hold. This bound is tighter than previous estimates, especially when the system is designed to handle more than just a single error at a time. They found that by optimizing the arrangement of these repair groups, one can squeeze out a small but significant amount of extra capacity, a correction that previous methods had missed.

The study also explored what happens when the quantum code is "pure," meaning it has no hidden internal errors that could confuse the repair process. In this ideal scenario, the researchers showed that the limits become even stricter, extending a known formula to a much wider range of quantum systems than ever before. They demonstrated that for these pure codes, the local repair groups must behave in a very specific, almost rigid way to achieve the maximum possible storage. If the system tries to push beyond these limits, the mathematical structure forces the local groups to become isolated from one another, effectively breaking the network into disjoint islands. This structural insight reveals that nature imposes a kind of geometric discipline on quantum storage: to store the most data, the local repair zones must be arranged with a precise, non-overlapping geometry, or they must overlap in a very specific, unavoidable pattern.

To prove that these theoretical limits are not just abstract numbers but are actually reachable, the researchers examined three distinct families of existing codes. They showed that one family of pure codes, which uses overlapping repair groups, can achieve the new, tighter bound, demonstrating that the theoretical limit is a real, attainable target. Another family of impure codes, which does not require the system to be perfectly clean, was shown to hit the general bound, proving that the new formula works even in messy, realistic conditions. A third family, based on complex mathematical structures known as Hermitian codes, was found to simultaneously satisfy both the general and the pure-code limits, even when the system's ability to correct errors is greater than the minimum required. These examples serve as concrete proof that the boundaries drawn by the researchers are not merely theoretical walls but are the actual edges of what is possible.

The implications of this work are foundational for the design of future quantum storage systems. By removing the need for assumptions about purity or disjoint recovery blocks, the new bounds provide a more accurate blueprint for engineers building these systems. They now know exactly how much data they can hope to store given a specific repair strategy, and they understand the structural constraints that any optimal code must obey. The researchers also identified that when the local repair capability matches the error tolerance in a specific way, the code must decompose into a series of independent, optimal building blocks. This insight could guide the construction of more efficient quantum memories, ensuring that the systems of tomorrow are built on the most efficient mathematical foundations available. The work closes a gap in our understanding, moving from a collection of special-case rules to a unified theory of quantum local recovery that applies to the messy, overlapping, and imperfect reality of future quantum networks.

Technical Summary: Bounds for General (r, δ)-Quantum Locally Recoverable Codes

Problem Statement

The paper addresses the fundamental limits of quantum locally recoverable codes (qLRCs) capable of correcting multiple erasures. While existing literature has established bounds for qLRCs, these results often rely on restrictive assumptions:

Purity: Many bounds apply only to "pure" codes (where low-weight errors map the code space to an orthogonal subspace), excluding "impure" codes which may offer better parameters.
Stabilizer Structure: Several results are limited to stabilizer codes or specific algebraic constructions (e.g., CSS, Hermitian dual-containing).
Disjoint Recovery Blocks: Many bounds assume that recovery blocks (sets of coordinates used to repair a failure) are disjoint or form a partition.
Single-Erasure Focus: General bounds for multiple erasures often reduce to single-erasure analysis or require specific structural decompositions.

The authors aim to establish Singleton-like upper bounds for general $(r, \delta)$ -qLRCs that:

Do not assume purity or a stabilizer structure.
Allow for arbitrarily overlapping recovery blocks.
Explicitly handle multiple erasures ( $\delta \ge 2$ ) within local blocks.

Methodology

The authors employ a combination of information-theoretic arguments, entropy properties, and combinatorial selection lemmas.

1. Selection Lemma for Multiple Erasures

A core technical contribution is a selection lemma (Lemma 14) that constructs correctable erasure sets from overlapping recovery blocks.

Mechanism: Given a budget of coordinates $N$ , the lemma selects a set of erasures $S$ that can be recovered sequentially using local recovery channels.
Two-Stage Process:
- Stage 1: Selects $t = \delta - 1$ coordinates from blocks that have at least $t$ uncovered coordinates.
- Stage 2: If blocks have fewer than $t$ uncovered coordinates, it selects all available coordinates in those blocks.
Result: This ensures that the selected erasures $S$ can be recovered locally before the remaining erasures are handled by the global distance, even in the presence of overlaps.

2. Entropy and Decoupling Arguments

The bounds are derived using the quantum Singleton bound framework, adapted for local recovery:

General Case (Impure/Arbitrary Overlaps): The authors construct two disjoint correctable erasure sets ( $A_1$ and $A_2$ ) using the selection lemma. By applying the data processing inequality and the decoupling property of correctable sets (Lemma 8), they derive a dimension bound $k \le n - |A_1| - |A_2|$ .
Pure Case: For pure codes, the authors utilize the property that reduced states on small sets are maximally mixed (Lemma 20). This allows for local decoupling from the reference system (Lemma 21), leading to a stronger bound where the entropy of the local support code is maximized.

3. Integer Optimization

The initial bounds involve floor functions. The authors perform integer optimization (Corollary 16, Proposition 17) to tighten these bounds. They derive an explicit remainder correction term ( $\varepsilon$ ) that can reduce the upper bound on the dimension $k$ by up to $\delta - 2$ .

4. Structural Analysis at Minimal Locality

For the specific case where the locality parameter equals the erasure tolerance ( $r = \delta$ ), the authors analyze $F_q$ -linear stabilizer codes. They prove a decomposition theorem (Theorem 28) showing that such codes, after removing fixed pure-state coordinate factors, decompose into disjoint inner MDS codes and an outer stabilizer code.

Key Contributions and Results

1. General Singleton-like Bound (Theorem 15)

The paper establishes a bound for general quantum subspaces with arbitrary overlaps:
$k \le n - 2d + 2 - (\delta - 1) \left\lfloor \frac{n - d + 1}{r + \delta - 1} \right\rfloor - \text{correction terms}$

Significance: This bound applies to impure codes and overlapping blocks.
Reduction: When $\delta = 2$ , it reduces to the general single-erasure bound by Golowich and Guruswami.
Optimization: The integer optimization yields a tighter bound (Corollary 16) with an explicit correction term $\varepsilon \in [0, \delta-2]$ .

2. Pure-Code Bound (Theorem 22)

For pure codes, the authors derive a stronger bound:
$k \le n - 2 \max_{0 \le e \le d-1} \left\{ e + (\delta - 1) \left\lfloor \frac{n - e}{r + \delta - 1} \right\rfloor \right\}$

Significance: This extends the parameter bounds of Galindo et al. (originally for dual-containing classical constructions) to arbitrary pure quantum subspaces.
Improvement: It removes the disjoint-block assumption from previous pure-code bounds (e.g., Stylianou–Boche) and provides a tighter expression when the remainder of the division exceeds the locality parameter.

3. Structural Constraints and Decomposition

Equality Conditions: The paper characterizes the conditions under which the bounds are met, showing that equality forces local MDS structures and specific isolation properties of recovery blocks (Theorem 25, 26).
Minimal Locality ( $r=\delta$ ): For linear stabilizer codes with $r=\delta$ , the authors prove that the code decomposes into disjoint MDS inner codes and an outer code (Theorem 28). This implies that the distance $d$ must be divisible by $\delta$ and provides a sharper dimension bound than the general case.

4. Attaining Families

The paper analyzes three families of codes that attain these bounds, demonstrating the tightness of the results:

Glued GRS Family (Pure, Overlapping): A pure CSS family with unavoidable overlaps. It exhibits a strict improvement over the general bound for certain parameters and simultaneously attains both general and pure bounds for others.
Impure Concatenated Codes: Impure CSS codes constructed via standard concatenation that attain the general bound, proving the bound is sharp even without purity.
Existing Hermitian Family (Pure, Overlapping, $d > \delta$ ): An existing construction that attains all derived bounds, including cases where the global distance exceeds the local distance.

Significance and Claims

The paper claims to fill a critical gap in the theory of quantum LRCs by providing bounds that are:

General: Applicable to non-stabilizer, impure codes with arbitrary overlaps, moving beyond the restrictive assumptions of prior work.
Tight: The bounds are shown to be attainable by explicit constructions, and the integer optimization provides the first explicit remainder correction for general $(r, \delta)$ -qLRCs.
Unifying: The pure-code bound unifies and extends several existing results (Galindo et al., Stylianou–Boche) to arbitrary pure subspaces without requiring disjoint partitions or specific algebraic constructions.

The authors modestly note that while they have established these bounds and identified attaining families, future work is required to determine the full range of attainable parameters and to extend structural conclusions (like the decomposition theorem) beyond $F_q$ -linear stabilizer codes. The paper does not propose new experimental implementations or specific applications beyond the theoretical framework of distributed quantum storage.