{"id":"07ff7de5-a6fe-41a8-b6d5-814d83c4435c","arxiv_id":"2507.18175","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"Optimal (r,δ)-locally repairable codes decompose into MDS local codes, forcing d≥δ, and this structure yields new optimal quantum (r,δ)-LRCs.","lead":"The paper proves a general decomposition theorem for optimal (r,δ)-locally repairable codes, showing their local protection codes must be MDS codes and that the code distance is always at least δ. It uses this structure to characterize and construct three infinite families of optimal quantum (r,δ)-LRCs from classical optimal codes.","discovery_kind":"first_principles","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Lemma 3.3's Algorithm 1 permits zero-rank additions: P2 does not require c_i_j to lie outside span(S_{j-1}), so a P4 step can add a full local protection set without increasing rank, violating condition (2) of Lemma 3.1; the decomposition theorem and d≥δ are not yet proved.","rationale":"The reader's weakest assumption is exactly the behavior of Algorithm 1 in Lemma 3.3, and my analysis agrees. The algorithm's termination is not the issue: because the whole column set has rank k and each iteration adds at least one new indexed pair, the loop must stop. The issue is the rank-growth condition. A P4 step can add a full local protection set S_j whose columns lie in the current span; this is not excluded by the phrase \"C \\setminus S_{j-1}\". Such a step produces a block with zero rank increase, so the resulting S cannot be written as C1 \\cup ... \\cup C_{i0} \\cup terminal with the required 1 \\leq rank-increase inequalities unless the zero-rank block is moved elsewhere. Moving it into the terminal set breaks the claim that the terminal set is contained in a single local protection code, and moving it into U breaks the accounting |U| = d. This is load-bearing because Lemma 3.1's equality |S| = k-1+(\\lceil k/r \\rceil -1)(\\delta-1) — the backbone of Theorem 3.4 and Theorem 4.1(1) — depends on every C_i satisfying 1 \\leq r_i = s_i - (\\delta-1). I find no counterexample to the theorem itself; the gap appears repairable by adding an explicit selection rule (choose columns outside the current span). Therefore the central claim is plausible but not rigorously established as written. The verdict CONDITIONAL is appropriate; I would not move to ACCEPT or REJECT without the authors addressing this step. Typos and the Remark 3.10/Example 3.6 mismatch are real but secondary.","tokens_in":30025,"tokens_out":28963,"duration_ms":294991,"concrete_test":"Re-derive Lemma 3.3 with Algorithm 1 modified so that Step P2 always selects (i_j,c_{i_j}) with c_{i_j} not in span(S_{j-1}); prove that (a) such a choice exists whenever rank(S_{j-1}) < k, (b) every P4 addition then has rank increase at least 1, and (c) the Step P5 terminal-set construction still yields a terminal subset of size at most r-1 contained in one local protection code. If any of (a)-(c) fails, the decomposition theorem is unsupported; if all hold, the gap is a missing detail in the published proof.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim is Theorem 3.4, proved via Lemma 3.3 and Algorithm 1. The algorithm's Step P2 says \"Pick (i_j,c_{i_j}) \\in C \\setminus S_{j-1}\", where the complement is taken in the indexed set, not in the linear span. Thus it may pick a column already in span(S_{j-1}). Step P3 then chooses an arbitrary local protection code C|S_j for that coordinate. If that local code is entirely contained in span(S_{j-1}) — possible, for example, with a length-2, distance-2 local code consisting of the new column and a proportional old column — then rank(S_{j-1} \\cup S_j) = rank(S_{j-1}) < k, so Step P4 adds S_j with rank increase 0. The resulting decomposition S = C1 \\cup ... \\cup C_{i0} \\cup terminal then includes such a zero-rank block among the C_i, violating condition (2) of Lemma 3.1 (\"1 \\leq rank(...) - rank(...)\"). If zero-rank blocks are instead discarded, the terminal set need no longer be contained in a single local protection code, and the bound s_{i0+1} \\leq r-1 in Lemma 3.3 is not established. The proof asserts termination and the rank-size accounting without proving a selection rule that avoids zero-rank additions. A likely fix is simple: while rank(S_{j-1}) < k, a column outside span(S_{j-1}) exists, and choosing it forces any local protection code containing it to increase rank. But this rule is absent from Algorithm 1 and Lemma 3.3. Consequently Theorem 3.4, Theorem 3.7, and Theorem 4.1(1) rest on an unproven algorithmic premise. Secondary issues include Remark 3.10 conflicting with Example 3.6, the typo \"n=k(\\delta-1)\" in the proof of Theorem 4.1, and the sign error in Corollary 3.11; these are fixable but add to the need for revision.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper studies optimal (r,δ)-locally repairable codes and their quantum counterparts. Its main structural claim (Theorem 3.4) is that every optimal (r,δ)-LRC, viewed as an indexed set of generator-matrix columns, admits one of two decompositions into MDS local protection codes, a terminal set, and a residual set whose size equals the minimum distance. From this decomposition the paper derives rigidity results (every local protection code is MDS, Theorem 3.7; d ≥ δ, Theorem 4.1(1)), a parity-check criterion for optimal quantum (r,δ)-LRCs induced by classical optimal codes admitting a minimal decomposition (Theorem 4.6), and three infinite families of optimal quantum (r,δ)-LRCs with explicit parameters (Theorems 5.1, 5.4, 5.6).","tokens_in":30383,"tokens_out":30287,"duration_ms":265720,"significance":"If the decomposition theorem is established, it is a substantial structural contribution: it extends earlier partition-type results of Song et al. and Prakash et al. to the general case, including r | (k−1), and it gives a clean route to quantum (r,δ)-LRC constructions while removing auxiliary conditions present in Galindo et al. The paper is largely self-contained and the three construction families are concrete, with worked examples in Section 5. The main weakness is that the proof of the central decomposition rests on an incompletely specified selection algorithm, and several secondary structural claims are asserted rather than proved. With a repair of Lemma 3.3, the central results are plausible and potentially publishable.","major_comments":[{"comment":"Step P2 of Algorithm 1 chooses (i_j,c_{i_j}) from C \\ S_{j-1}, i.e., an unselected indexed element, not a vector outside span(S_{j-1}). Step P4 then adds a full local protection code S_j whenever rank(S_{j-1} ∪ S_j) < k, even if the rank increase is zero, which can happen when the newly picked column lies in the current span and the chosen local code for it is contained in that span. The proof asserts termination and that each added block satisfies condition (2) of Lemma 3.1 (rank increment at least 1), but this is not guaranteed by the stated algorithm; a run could add zero-rank blocks, invalidating the accounting |S| = k−1+(⌈k/r⌉−1)(δ−1) and leaving the terminal-size bound s_{i0+1} ≤ r−1 unproved. This is load-bearing: Lemma 3.3 is used to prove Theorem 3.4, Theorem 3.7, and Theorem 4.1(1). The likely fix is local: while rank < k, always pick a column outside the current span (such a column exists because the generator matrix has rank k), and then prove that every added block increases the rank by at least one and that the terminal set satisfies the stated bound.","section":"§3.1, Lemma 3.3 (Algorithm 1)"},{"comment":"The proof's statement that 'we can require that C1 in Case (I) is exactly S1 due to the proof of Theorem 3.4' is not an argument. Theorem 3.4, as stated, produces one decomposition; to show that an arbitrary local protection code C|S1 is MDS, one must rerun the corrected selection procedure with S1 as the first chosen local protection code and verify that the rank-growth and terminal-set conditions still hold. As written, Theorem 3.7 is an unproved invariance claim rather than a consequence of Theorem 3.4.","section":"§3.2, Theorem 3.7"},{"comment":"The observation that any two distinct local protection codes satisfy S1 = S2 or S1 ∩ S2 = ∅ is false. The second code in Example 3.6 is verified there to be an optimal (2,2)-LRC, and its two displayed local protection codes C|{1,2,3} and C|{2,4,5} are distinct yet intersect in coordinate 2. This remark should be corrected or removed; it is not needed for the decomposition theorem, and as stated it gives a false consistency claim with [28, Theorem 9].","section":"§3.2, Remark 3.10"},{"comment":"After defining C_t = C|T for a local protection code T containing the terminal set, the proof asserts 'By Case (I) of Theorem 3.4, we have s_i ≥ δ' for all i ∈ [t]. For i ≤ t−1 this follows from condition (2), but for i = t it does not: s_t is the number of new coordinates contributed by T outside the earlier blocks, and Theorem 3.4's Case (I) only says that the terminal set is contained in some local protection code T. The argument needs the additional condition rank(C_1 ∪ ... ∪ C_{t−1} ∪ T) = k, which appears in the construction inside Lemma 3.3 but is omitted from the statement of Theorem 3.4, together with a proof that this condition and the Singleton bound on T imply s_t ≥ δ. Without this, Theorem 4.1(1), and hence d ≥ δ, is not fully established.","section":"§4.1, Theorem 4.1(1) proof"},{"comment":"The proof of Theorem 4.3 is incomplete in its rank computation. The sentence 'the number of repeated indices between cH_i and H_{i+1} is less than n_i−(δ−1)' uses an undefined quantity and is the only justification given for the claim that the matrix in Eq. (4.5) has rank t(δ−1). The subsequent extension by appending B_1,...,B_t also needs a proof that such matrices exist and that together with the top blocks they have rank t(δ−1)+l. Because Theorem 4.6, Corollary 4.7, and the constructions in Section 5 depend on this parity-check characterization, the proof should be completed.","section":"§4.2, Theorem 4.3"}],"minor_comments":[{"comment":"The displayed identity ends with '−δ−1'; it should presumably be '−(δ−1)' to match Lemma 3.1. The proof sketch is also too terse to verify the claimed conclusion.","section":"§3.2, Corollary 3.11"},{"comment":"The reference 'Corollary 3.7' should be 'Theorem 3.7'.","section":"§4.2, Theorem 4.3 proof"},{"comment":"The sentence 'the code C in Theorem 5.4 has a parity-check matrix' should refer to Theorem 5.6.","section":"§5.3, Example 5.8"},{"comment":"The expression 'dim(C) = n+k/2' should be 'dim(C) = (n+k)/2' to be consistent with the Hermitian construction parameters.","section":"§2.3, Definition 2.8"},{"comment":"Using the same symbol C for both the linear code and the indexed set of its generator-matrix columns can be confusing in statements such as Theorem 4.3 and Corollary 4.4; a distinct symbol for the indexed set would improve readability.","section":"General notation"}],"recommendation":"major_revision","confidential_remarks":"The paper has a promising core: the decomposition theorem is plausible and the quantum constructions are concrete. However, the proof of Lemma 3.3 must be repaired before the central claims can be accepted; the fix is likely local but needs to be written out. I also recommend that the authors re-examine Remark 3.10 and the rank arguments in Theorems 4.1 and 4.3. Given the number of proof gaps, major revision is appropriate."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Zhou and Cao have a real structural result here. Theorem 3.4 unifies the known decomposition theorems for optimal (r,δ)-LRCs to cover all parameter regimes, including the previously open r|(k−1) case. The d≥δ consequence (Theorem 4.1(1)) is new to me, and the characterization of optimal quantum (r,δ)-LRCs via minimal decompositions (Theorems 4.3 and 4.6) plus three explicit infinite families is a solid package. The constructions are concrete, with explicit parity-check matrices and verifiable parameters; the Hermitian self-orthogonality checks via root-of-unity sums are correct as far as I checked.\n\nThe soft spots are real but fixable. The largest is Lemma 3.3's Algorithm 1. The stress-test note is correct: P2 picks a column not in the current set, not outside its span, so a zero-rank addition is possible. Termination and the bound s_t ≤ r−1 are asserted, not proved. The fix is easy—pick a column outside span(S_{j−1}) while the rank is below k—but as written the decomposition theorem rests on an unproven algorithmic premise. Relatedly, Theorem 3.7's proof justifies 'we can require C1 = S1' by an appeal to the proof of Theorem 3.4; that is not rigorous, since an arbitrary local protection code need not satisfy the rank-size equation the first block must satisfy. Remark 3.10 directly contradicts Example 3.6, where two local protection codes intersect at coordinate 2 without being equal. There are also typos in Corollary 3.11 (sign error: should be −(δ−1)) and in the r=1 case of Theorem 4.1's proof ('n=k(δ−1)' should be an inequality).\n\nNone of this kills the central claim—the decomposition theorem is very likely true with a repaired algorithm. But the paper as submitted is not rigorous enough for the theorems as stated. The intended audience is coding theorists working on LRCs and quantum LRCs; they will find both a new structural tool and ready-to-use families. My recommendation: send it to a serious referee, but ask for a major revision that rewrites the proof of Lemma 3.3, fixes Theorem 3.7's argument, and clears up the contradiction and typos. The three construction families are a useful contribution on their own.","headline":"Unified decomposition theorem is a genuine advance, but the proof has fixable gaps—worth a serious referee.","tokens_in":31041,"tokens_out":4963,"would_cite":true,"duration_ms":47059,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["94B05","11T71","81P70"],"pacs":[],"model":"deepseek-v4-flash","headline":"Every optimal locally repairable code decomposes into MDS repair blocks, a structure that automatically yields optimal quantum locally repairable codes.","keywords":["locally repairable codes","$(r,\\delta)$-locality","optimal codes","decomposition theorem","MDS local protection codes","quantum locally repairable codes","CSS construction","Hermitian construction"],"falsifier":"Exhibit a single optimal $(r,\\delta)$-LRC with parameters $[n,k,d]_q$ whose set of generator columns cannot be partitioned as in Case (I) or Case (II) of Theorem 3.4—for instance, an optimal code with a local protection code of length $n_i\\le r+\\delta-1$ whose punctured distance is $\\delta+1$ rather than $\\delta$—or an optimal $(r,\\delta)$-LRC with $d<\\delta$. A brute-force search over small $q$, $r$, $\\delta$, $n$, $k$ (e.g. all optimal $(2,2)$-LRCs over $\\mathbb{F}_q$ for $q\\le 9$) checking whether every repair set's punctured code is MDS would settle the decomposition theorem in those cases.","tokens_in":29766,"feed_emoji":"🧩","tokens_out":8977,"duration_ms":79705,"temperature":0.7,"pith_summary":"Locally repairable codes (LRCs) let a distributed storage system recover a lost symbol by reading only a small local group of other symbols, and optimal LRCs hit the Singleton-like bound on the tradeoff between redundancy and repair locality. This paper proves a unified decomposition theorem: every optimal $(r,\\delta)$-LRC is a disjoint union of MDS local protection codes of distance $\\delta$ plus a leftover set whose size is exactly the code's minimum distance $d$. Because the decomposition holds in full generality, the paper can show that every local protection code is MDS and that $d\\geq \\delta$ always holds. That removes a technical condition that previously stood between classical optimal $(r,\\delta)$-LRCs and optimal quantum $(r,\\delta)$-LRCs, so CSS and Hermitian constructions now convert classical optimal codes directly into optimal quantum ones. The paper also characterizes which optimally decomposed classical codes induce optimal quantum codes and gives three infinite families of such quantum codes.","feed_headline":"Every optimal repair code splits into MDS local blocks","feed_subtitle":"The decomposition makes optimal quantum LRCs automatic from classical ones, no extra conditions needed.","key_machinery":"The load-bearing mechanism is the subset-selection algorithm (Algorithm 1) operating on the canonical indexed set $\\mathcal{C}=\\{(i,c_i)\\}$. Starting from an empty set, it repeatedly picks a coordinate, chooses a local protection code for that coordinate, and adds the local block (or a sub-block chosen so that the rank increments by exactly one per added vector) until the accumulated rank reaches $k-1$. The key identity is the rank-size inequality for each block: each added local protection set contributes rank at most $|\\text{added set}|-(\\delta-1)$ but at least $1$, while the terminal leftover set has size at most $r-1$; together with the Singleton-type bound this forces the total size $|S|=k-1+(\\lceil k/r\\rceil-1)(\\delta-1)$ and equality throughout, which is what makes each block MDS. In the quantum half of the paper, the analogous load-bearing object is the block parity-check matrix (4.4), whose off-diagonal blocks determine whether the constituent codes generated by (4.7) are Hermitian or Euclidean self-orthogonal, and hence whether the classical code is dual-containing and induces an optimal quantum LRC.","core_discovery":"The central discovery is a structural dichotomy for any optimal $(r,\\delta)$-LRC with parameters $[n,k,d]_q$. Viewing the code as the indexed set $\\mathcal{C}=\\{(i,c_i)\\}$ of generator-matrix columns, Theorem 3.4 asserts that $\\mathcal{C}$ is either $\\mathcal{C}=\\mathcal{C}_1\\cup\\cdots\\cup\\mathcal{C}_{t-1}\\cup\\{(j_1,c_{j_1}),\\ldots,(j_{s_t},c_{j_{s_t}})\\}\\cup U$ with $t=\\lceil k/r\\rceil$, or $\\mathcal{C}=\\mathcal{C}_1\\cup\\cdots\\cup\\mathcal{C}_t\\cup U$ with $t=\\lceil k/r\\rceil-1$, where each $\\mathcal{C}|_{\\mathcal{C}_i}$ is a local protection code that is an MDS code with parameters $[n_i\\le r+\\delta-1,\\, n_i-\\delta+1,\\, \\delta]_q$, the terminal vectors lie inside some local protection code and number at most $r-1$, and the residual set $U$ is disjoint with $|U|=d(\\mathcal{C})$. Along the chain the rank-size equations $\\operatorname{rank}(\\cup_{j=1}^{i}\\mathcal{C}_j)-\\operatorname{rank}(\\cup_{j=1}^{i-1}\\mathcal{C}_j)=|\\cup_{j=1}^{i}\\mathcal{C}_j|-|\\cup_{j=1}^{i-1}\\mathcal{C}_j|-(\\delta-1)$ hold. From this the paper derives that every local protection code of an optimal $(r,\\delta)$-LRC is MDS of distance $\\delta$ (Theorem 3.7), and that $n-k\\ge \\lceil k/r\\rceil(\\delta-1)$, equivalently $d\\ge\\delta$ (Theorem 4.1(1)). It then proves that an optimal classical $(r,\\delta)$-LRC with a minimal decomposition induces an optimal quantum $(r,\\delta)$-LRC exactly when its parity-check matrix has the block form (4.4) and all codes generated by the matrices in (4.7) are Hermitian or Euclidean self-orthogonal (Theorem 4.6).","pith_inferences":["An implication the authors leave implicit: the decomposition theorem suggests that repair groups of an optimal $(r,\\delta)$-LRC form near-disjoint MDS islands, so a storage system could schedule repairs within each island independently without global coordination; this is directly testable on existing optimal constructions.","The $d\\ge\\delta$ bound, combined with the quantum Singleton-type bound, implies these constructions can never produce quantum LRCs with $d<\\delta$; if applications need shorter distances, one would have to step outside the optimal classical class or weaken locality.","A testable extension is to apply the parity-check criterion of Theorem 4.6 to known families of optimal LRCs (pyramid codes, Tamo-Barg codes, propagated constructions) and enumerate which of them become optimal quantum LRCs, which would produce many new explicit parameter sets beyond the three families given.","The minimal-decomposition concept could be made algorithmic: finding the minimal decomposition of a given optimal code is a combinatorial optimization problem of choosing local blocks maximizing rank gain per coordinate, and automating it would let one certify optimal quantum LRCs by computer search."],"forward_implications":["Every local protection code of an optimal $(r,\\delta)$-LRC is an MDS code with parameters $[n_i\\le r+\\delta-1,\\, n_i-\\delta+1,\\, \\delta]_q$, so local repair sets are as efficient as possible.","Every optimal $(r,\\delta)$-LRC satisfies $n-k\\ge \\lceil k/r\\rceil(\\delta-1)$, i.e. $d\\ge\\delta$, guaranteeing that the code can always correct at least $\\delta-1$ erasures.","Any Hermitian dual-containing (resp. Euclidean dual-containing) optimal $(r,\\delta)$-LRC induces, through the Hermitian (resp. CSS) construction, an optimal quantum $(r,\\delta)$-LRC with no separate inequality check needed.","An optimal classical $(r,\\delta)$-LRC with a minimal decomposition induces an optimal quantum LRC if and only if the associated block codes are all Hermitian or all Euclidean self-orthogonal, giving a complete and checkable criterion.","Three infinite families of optimal quantum $(r,\\delta)$-LRCs exist with flexible parameters, including one family whose length grows super-linearly in the field size."],"supporting_citations":[{"why":"Introduces the locality model and supplies the rank-based distance characterization used in Lemma 2.4.","marker":"[9]"},{"why":"Establishes the Singleton-type bound for $(r,\\delta)$-LRCs and defines optimality; the decomposition theorem targets exactly the codes attaining this bound.","marker":"[23]"},{"why":"Gives an earlier structural decomposition of optimal LRCs under special conditions that Theorem 3.4 unifies and extends.","marker":"[28]"},{"why":"Supplies Lemma 2.5's parity-check characterization of $(r,\\delta)$-locality, used in the local protection arguments and in proving the block-matrix criteria.","marker":"[19]"},{"why":"Introduces quantum $(r,\\delta)$-LRCs and Definition 2.8; this paper removes its restrictive conditions and builds on its CSS/Hermitian equivalence principle.","marker":"[7]"},{"why":"Provides the Hermitian construction that converts Hermitian dual-containing classical codes into quantum codes.","marker":"[1]"},{"why":"Provides the CSS construction used to turn Euclidean dual-containing codes into quantum codes.","marker":"[3]"},{"why":"Provides the CSS construction alongside [3], used throughout the quantum conversion.","marker":"[31]"},{"why":"Gives the first infinite family of optimal LRCs whose construction style motivates the parity-check matrices in Section 5.","marker":"[30]"}],"fun_headline_variants":["Optimal repair codes decompose into MDS blocks","Quantum LRCs from classical optimal codes","MDS decomposition yields optimal quantum LRCs","Classical optimal LRCs give quantum ones","Optimal quantum repair codes via decomposition"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that the algorithm that builds the decomposition never gets stuck—at each step one can pick a repair group that adds new information, and when it stops at most $r-1$ columns remain outside the chosen repair groups—because if a choice forces a larger leftover set, the exact count $|S|=k-1+(\\lceil k/r\\rceil-1)(\\delta-1)$ that drives the theorem fails.","fun_headline_variants_meta":{"raw":{"variants":["Optimal repair codes decompose into MDS blocks","Quantum LRCs from classical optimal codes","MDS decomposition yields optimal quantum LRCs","Classical optimal LRCs give quantum ones","Optimal quantum repair codes via decomposition"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000199,"raw_usage":{"total_tokens":1479,"prompt_tokens":1162,"completion_tokens":317,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":778,"completion_tokens_details":{"reasoning_tokens":249}},"tokens_in":778,"tokens_out":317,"duration_ms":4329,"temperature":1.0,"reasoning_tokens":249,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-06T14:42:20.750652+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Exhibit a single optimal $(r,\\delta)$-LRC with parameters $[n,k,d]_q$ whose set of generator columns cannot be partitioned as in Case (I) or Case (II) of Theorem 3.4—for instance, an optimal code with a local protection code of length $n_i\\le r+\\delta-1$ whose punctured distance is $\\delta+1$ rather than $\\delta$—or an optimal $(r,\\delta)$-LRC with $d<\\delta$. A brute-force search over small $q$, $r$, $\\delta$, $n$, $k$ (e.g. all optimal $(2,2)$-LRCs over $\\mathbb{F}_q$ for $q\\le 9$) checking whether every repair set's punctured code is MDS would settle the decomposition theorem in those cases.","supporting_citations":[{"cited_title":"On the locality of codeword symbols","cited_arxiv_id":null,"evidence_quote":"Introduces the locality model and supplies the rank-based distance characterization used in Lemma 2.4."},{"cited_title":"Optimal linear codes with a local-error-correction property","cited_arxiv_id":null,"evidence_quote":"Establishes the Singleton-type bound for $(r,\\delta)$-LRCs and defines optimality; the decomposition theorem targets exactly the codes attaining this bound."},{"cited_title":"Optimal locally repairable linear codes","cited_arxiv_id":null,"evidence_quote":"Gives an earlier structural decomposition of optimal LRCs under special conditions that Theorem 3.4 unifies and extends."},{"cited_title":"Three new constructions of optimal locally repairable codes from matrix- product codes","cited_arxiv_id":null,"evidence_quote":"Supplies Lemma 2.5's parity-check characterization of $(r,\\delta)$-locality, used in the local protection arguments and in proving the block-matrix criteria."},{"cited_title":"Nonbinary quantum stabilizer codes","cited_arxiv_id":null,"evidence_quote":"Provides the Hermitian construction that converts Hermitian dual-containing classical codes into quantum codes."},{"cited_title":"Good quantum error-correcting codes exist","cited_arxiv_id":null,"evidence_quote":"Provides the CSS construction used to turn Euclidean dual-containing codes into quantum codes."},{"cited_title":"Simple quantum error-correcting codes","cited_arxiv_id":null,"evidence_quote":"Provides the CSS construction alongside [3], used throughout the quantum conversion."},{"cited_title":"A family of optimal locally recoverable codes.IEEE Transactions on Information Theory, 2014, 60(8): 4661-4676","cited_arxiv_id":null,"evidence_quote":"Gives the first infinite family of optimal LRCs whose construction style motivates the parity-check matrices in Section 5."}],"review_version":1}