🔢 mathematics

Entanglement-Assisted Quantum Locally Recoverable Codes: Bounds, Optimal Constructions, and Achievability

This paper investigates entanglement-assisted quantum locally recoverable codes (EA-qLRCs) constructed from classical locally recoverable codes via a CSS-like stabilizer framework, establishing comprehensive converse and achievability bounds, deriving necessary and sufficient conditions for Singleton-like optimality, and demonstrating that cyclic code families yield optimal constructions while Tamo--Barg codes are optimal only in degenerate regimes.

Original authors: Vijay Kumar, Ramakrishna Bandi

Published 2026-08-10

📖 7 min read🧠 Deep dive

CC0 1.0

Original authors: Vijay Kumar, Ramakrishna Bandi

Original paper dedicated to the public domain under CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.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 send a secret message across a galaxy using tiny, fragile particles of light called qudits. In the quantum world, these particles are incredibly sensitive; if even one gets lost or scrambled by noise, the whole message could vanish. To stop this, scientists use "quantum error-correcting codes," which are like magical safety nets that can rebuild lost information. But there's a catch: in a massive network of quantum computers, checking the entire message to find a single lost piece is too slow and expensive. This is where "Locally Recoverable Codes" come in. Think of them as a library where, if a book is missing from a shelf, you don't need to check the whole building to find a replacement; you only need to look at the three books right next to it.

Now, imagine adding a superpower to this library: "entanglement." This is a spooky connection where two particles, no matter how far apart, act as if they are holding hands. If one is lost, the other can instantly help reconstruct it. This paper explores what happens when you combine these two ideas: local recovery (checking only a few neighbors) and entanglement (using those magical hand-holding particles). The big question the authors asked was: "Can we build a quantum code that recovers lost data from just a few neighbors, even if the underlying math doesn't perfectly fit the old rules?" They discovered that yes, we can, and they figured out exactly how to build the best possible versions of these codes.

The Magic of Hand-Holding Neighbors

In the world of quantum storage, data is stored in "qudits" (quantum digits). Sometimes, a qudit gets erased, like a page torn out of a book. A standard quantum code might require you to check the entire book to fix that page. A Locally Recoverable Code (LRC) is smarter: it ensures that any single page can be fixed by looking at only a small group of other pages, say $r$ neighbors. This is crucial for large-scale quantum networks where speed matters.

However, building these codes has historically been very hard. The most common method, called the CSS construction, requires the two classical codes used to build the quantum code to be "dual-containing." Imagine trying to build a bridge where the left side must be a perfect mirror image of the right side. If your best designs for the left side don't match the right side, you can't build the bridge at all. This "dual-containment" rule blocked scientists from using many excellent, pre-existing code designs.

Enter Entanglement Assistance. This is the paper's main character. By sharing "entangled pairs" (EPR pairs) between the sender and receiver before the message is sent, the strict "mirror image" rule disappears. It's like having a magical translator that allows two different languages to work together perfectly, even if they aren't mirrors of each other. The authors show that you can now take almost any good classical code, pair it up, and use entanglement to build a quantum code that recovers data locally.

The Blueprint and the Boundaries

The authors didn't just say "it works"; they built a rigorous mathematical framework to prove it. They defined exactly what an Entanglement-Assisted Quantum Locally Recoverable Code (EA-qLRC) is and provided a "sufficient condition" (a recipe) to build them. The recipe is surprisingly simple: you need two classical codes where, for every position, you can find a small group of neighbors that can fix the error using the entangled help.

But how good can these codes get? The paper derives four major "converse bounds." Think of these as speed limits for the universe. They tell you the absolute best performance you can possibly achieve given your code's length, how much data it holds, how many errors it can fix, and how many entangled pairs you use.

Singleton-like Bound: The classic speed limit.
Griesmer-like Bound: A tighter limit for smaller, binary-like systems.
Plotkin-like Bound: The strictest limit when you need to fix a lot of errors.
Sphere-Packing-like Bound: A limit based on how much "space" the errors take up.

The authors compared these limits and found that for small systems or high error rates, the Griesmer and Plotkin bounds are much stricter than the old Singleton bound. They also found that in the "maximally entangled" regime (where you use as many entangled pairs as possible), all these bounds collapse into a single, clear picture of what is possible and what is impossible.

The Good, The Bad, and The "Vacuous"

The team then tried to build these codes using famous families of classical codes to see which ones hit the "speed limit" (the Singleton-like bound).

The Tamo–Barg Codes: They tried using a popular family called Tamo–Barg codes. They found that these codes could be turned into EA-qLRCs, but they hit a wall. The only time they reached the optimal speed limit was when the code was so small that the "locality" rule didn't actually matter anymore. It's like building a race car that hits the speed limit, but only when you are driving in a parking lot where the speed limit is zero. The authors proved that for any real scenario where locality is a constraint, Tamo–Barg codes fail to be optimal.

The Cyclic Codes: On the other hand, they found that Cyclic Codes (codes with a repeating pattern) could be constructed to be perfectly optimal. Specifically, they focused on a special type called LCD codes (Linear Complementary Dual codes), which have a unique property that makes them "pure" and efficient. By using these cyclic LCD codes, they created explicit families of EA-qLRCs that hit the theoretical speed limit with equality. These are the "gold standard" codes the paper presents.

The "What If" Scenarios: Existence Proofs

Finally, the authors asked: "If we can't find a specific code for every situation, do they exist at all?" They used a method called Gilbert–Varshamov bounds to prove that good codes do exist for almost all scenarios, provided the field size (the number of symbols the code uses) is greater than 3. They showed that for field sizes $q > 3$ , you can always find a code that meets a certain rate of performance. They even provided a "sharper" bound using a technique called "concatenated codes," which offers even better performance than the basic method.

The Bottom Line

This paper solves a major puzzle in quantum storage. It proves that by using pre-shared entanglement, we can break the old "mirror image" rule that limited quantum code design. The authors showed that:

Yes, we can build quantum codes that recover data from just a few neighbors using entanglement.
No, the famous Tamo–Barg codes aren't the magic bullet for this; they only work in trivial cases.
Yes, we can build optimal codes using specific cyclic LCD codes, and we have a mathematical proof that even better codes exist for larger systems.

The result is a unified map of the "forbidden" and "achievable" zones for these codes, giving engineers and scientists a clear target for building the next generation of quantum storage systems. While the gap between what is theoretically possible and what we can explicitly build remains (a common theme in coding theory), this paper has pushed the boundary significantly, showing exactly where the finish line is and how to get there.

Technical Summary: Entanglement-Assisted Quantum Locally Recoverable Codes

Problem Statement

Classical Locally Recoverable Codes (LRCs) address single-node failures in distributed storage by enabling the recovery of an erased symbol from a small subset of other symbols, rather than requiring the entire codeword. This concept was extended to the quantum domain as Quantum Locally Recoverable Codes (qLRCs). However, existing qLRC constructions, primarily based on the Calderbank–Shor–Steane (CSS) or Hermitian stabilizer frameworks, require the underlying classical codes to satisfy a dual-containment (or self-orthogonality) condition. This restriction is severe because the best-known optimal classical LRC constructions (such as Tamo–Barg codes) are almost never dual-containing, rendering them inaccessible to standard CSS-based quantum constructions.

While Entanglement-Assisted Quantum Error-Correcting Codes (EAQECCs) were developed to remove the dual-containment requirement by utilizing pre-shared entanglement, it remained an open question whether this mechanism could be extended to support local recovery. Specifically, Luo et al. posed the question: "Do entanglement-assisted quantum codes admit the property of being locally recoverable?"

Methodology

This paper develops a systematic theory of Entanglement-Assisted Quantum Locally Recoverable Codes (EA-qLRCs) built via a CSS-like stabilizer construction from pairs of classical linear codes without requiring dual-containment. The methodology proceeds through the following steps:

Stabilizer Foundations: The authors define EA-qLRCs through local recovery channels. They derive a sufficient stabilizer criterion (Theorem 2) showing that local recoverability depends on the existence of two local dual codewords (one from each constituent classical code) whose combined support covers a coordinate with weight at most $r+1$ . This condition is purely local and support-based, distinct from the global dual-containment condition required for commutativity in non-entanglement-assisted codes.
Construction Framework: Using the entanglement-assisted CSS construction (Theorem 1), the paper constructs EA-qLRCs from pairs of classical linear codes $(C_1, C_2)$ . The number of required pre-shared entangled pairs ( $c$ ) is determined by the rank of the product of their parity-check matrices, or equivalently, the dimension of the hull $C_1 \cap C_2^\perp$ .
Converse Bounds: The authors derive four explicit converse bounds (Singleton-like, Griesmer-like, Plotkin-like, and Sphere-packing-like) and a non-explicit Cadambe–Mazumdar-like bound for CSS-like EA-qLRCs. These are derived by relating the quantum parameters to known bounds for classical LRCs.
Optimality Characterization: Necessary and sufficient conditions are derived for a "pure" (non-degenerate) CSS-like EA-qLRC to attain the Singleton-like bound with equality. This involves analyzing the hull dimension $s = \dim(C \cap C^\perp)$ when $C_1 = C_2 = C$ .
Explicit Constructions: The paper investigates specific families of classical codes (Tamo–Barg codes and cyclic codes) to instantiate these constructions. It also establishes asymptotic achievability bounds using classical Gilbert–Varshamov results adapted via monomial-equivalence arguments to ensure the Linear Complementary Dual (LCD) property.

Key Contributions and Results

1. Theoretical Foundations and Bounds

Decoupling Locality and Dual-Containment: The paper establishes that locality and dual-containment are orthogonal requirements. Entanglement assistance acts as a resource that decouples them, allowing the use of non-dual-containing classical LRCs.
Four Explicit Converse Bounds:
- Singleton-like: $2\delta \le n - \kappa + c - 2\lceil \kappa/r \rceil + 4$ .
- Griesmer-like, Plotkin-like, and Sphere-packing-like: These bounds are shown to be strictly tighter than the Singleton-like bound in specific regimes (e.g., small alphabet sizes, high distance, or asymptotic limits).
- Comparative Analysis: The paper provides a detailed comparison of these bounds in both finite-length and asymptotic regimes. It demonstrates that the Griesmer-like and Plotkin-like bounds are generally tighter for small fields, while the Sphere-packing-like bound becomes competitive in specific asymptotic regimes with large locality.

2. Optimality Conditions

Pure CSS-like EA-qLRCs: The paper proves that a pure EA-qLRC attains the Singleton-like bound if and only if the constituent classical codes are identical ( $C_1=C_2=C$ ), are optimal classical LRCs, and satisfy a specific condition on their hull dimension $s$ : $s \le (k-1) \mod r$ .
Maximally Entangled Case: For the case where the code is maximally entangled ( $c = n-k$ ), the condition simplifies to requiring $C$ to be an LCD code (where $s=0$ ).

3. Explicit Constructions and Limitations

Tamo–Barg Codes: The paper constructs EA-qLRCs from Tamo–Barg codes but identifies a structural obstruction: these constructions only attain the Singleton-like bound in the degenerate regime where $k \le r$ . In this regime, the locality constraint is vacuous (every symbol is recoverable from any information set), meaning the construction does not yield optimal codes with meaningful locality.
Cyclic Codes: The paper presents constructions using cyclic codes. It shows that general cyclic pairs do not necessarily attain the Singleton bound. However, by restricting to cyclic LCD codes of length dividing $q \pm 1$ , the authors construct explicit families of optimal, maximally entangled, pure CSS-like EA-qLRCs that meet the Singleton-like bound with equality in non-trivial regimes.

4. Achievability Bounds

The paper establishes two Gilbert–Varshamov-like achievability bounds for CSS-like EA-qLRCs:
1. A basic bound via parity-check augmentation.
2. A sharper bound via concatenated-code construction.
Unconditional Validity: Using a monomial-equivalence argument (Carlet et al.), the authors prove that for field sizes $q > 3$ , these bounds are achievable unconditionally because any classical LRC can be transformed into an LCD LRC without losing locality or distance. The cases $q=2, 3$ remain open.

5. Unified Parameter Landscape

The paper unifies all converse and achievability bounds under the maximally entangled regime ( $\gamma = 1 - R$ ). This allows for a single visual comparison of the achievable and forbidden rate–distance–locality regions, highlighting the gap between current constructions and theoretical limits, analogous to the classical Singleton vs. Gilbert–Varshamov gap.

Significance and Claims

The paper claims to provide the first systematic theory of EA-qLRCs, answering the open question of whether entanglement assistance can enable local recovery. Its significance lies in:

Removing Barriers: It removes the dual-containment barrier that previously excluded optimal classical LRC families (like Tamo–Barg) from quantum construction, provided entanglement is available.
Optimality Characterization: It provides precise algebraic conditions (involving hull dimensions and LCD properties) for when these codes are optimal.
Explicit Optimal Constructions: It delivers the first explicit constructions of optimal EA-qLRCs that are not degenerate (i.e., where locality is a non-trivial constraint), specifically using cyclic LCD codes.
Comprehensive Bounds: It offers a complete set of converse bounds and achievability results, characterizing the fundamental trade-offs between rate, distance, locality, and entanglement consumption.

The authors note that while they have constructed optimal codes for the Singleton-like bound, constructing codes that meet the tighter Griesmer, Plotkin, or Sphere-packing bounds remains an open problem. Additionally, extending the achievability results to $q=2, 3$ and exploring impure (degenerate) EA-qLRCs are identified as future directions.