{"id":"ff6d2941-fcef-449c-9e84-7fbe21f46e73","arxiv_id":"2608.10922","paper_version":1,"verdict":"REJECT","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"high","formal_verification":"none","parameter_count":0,"one_line_summary":"New Singleton-like and linear-programming dimension bounds are proven for disjoint quantum locally recoverable codes under a blockwise purity condition.","lead":"This paper derives new upper bounds on the size of a class of quantum error-correcting codes with local recovery, using weight enumerators organized by recovery blocks. The advertised strengthening of known bounds depends on a 'pure' condition that is stronger than the usual purity assumption in quantum coding.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Definition 4's blockwise purity is much stronger than standard purity and is not shown to be satisfied by any known pure qLRC; if no known family satisfies it, Theorem 4's bound does not strengthen the known bounds for the intended class.","rationale":"The reader's weakest assumption identifies the same conceptual gap: Definition 4 is a nonstandard purity condition and is not shown to cover known pure qLRCs. I focused on why this is load-bearing for the central claim: Theorem 4's proof relies on discarding all nonzero A^SL_k for k in T_{d,δ}, and T_{d,δ} includes profiles with large total weight but small per-block weight, so the condition is strictly stronger than standard purity. The conditional inequality itself appears to follow from the stated assumptions once the omitted MacWilliams identity is supplied; the problem is that the assumptions define a possibly empty class, so the claimed strengthening over the known disjoint (r,δ)-qLRC bound is unsubstantiated for the standard pure class. This is fixable by either exhibiting a nontrivial family satisfying Definition 4 or explicitly reframing the contribution as a bound for a newly introduced class, hence a conditional verdict rather than an outright rejection. I am not questioning the authors' integrity; the concern is about the scope and support of the advertised claim.","tokens_in":10727,"tokens_out":21892,"duration_ms":214108,"concrete_test":"Take a known pure stabilizer disjoint (r,δ)-qLRC from [4] with disjoint blocks of size N, and compute its stabilizer group. Check whether there exists a nonidentity element g with wt(g ∩ J_l) ≤ δ−1 for every recovery block J_l. If such g exists, its block profile k lies in T_{d,δ} \\ {0} and |Tr(gP)|^2 = K^2 contributes to A^SL_k, so the code fails Definition 4. Performing this check on the smallest cited CSS-based examples settles whether known pure qLRCs belong to the theorem's domain.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The load-bearing step is Definition 4, used in Theorem 4 to discard every nonzero k ≤ j in the expansion of A^U_j. The set T_{d,δ} contains every profile with i_l ≤ δ−1 for all l, regardless of total weight, because the sum over i_l ≥ δ is empty. Thus purity forces A^SL_i = 0 for profiles whose total weight can exceed d−1, a condition strictly stronger than the usual pure-code condition A_i = 0 for total weight < d. The proof of Theorem 4 needs exactly this stronger condition: k ≤ j is shown to lie in T_{d,δ}, and all nonzero A^SL_k are discarded; if a code is pure only in the standard sense, those terms may be positive and the inequality K ≤ q^{n−2m} need not follow. The paper neither cites a construction satisfying Definition 4 nor proves that the known pure stabilizer qLRC families from [4] and [6] satisfy it. Consequently, the advertised strengthening of the known disjoint (r,δ)-qLRC bound (7) is not established for the class of codes previously called pure; it applies only to a possibly empty newly defined subclass.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper develops a blockwise weight-enumerator framework for disjoint (r,δ)-quantum locally recoverable codes (qLRCs) without assuming a stabilizer structure. It introduces local Knill--Laflamme conditions, blockwise Shor--Laflamme and unitary weight enumerators, and uses them to prove a Singleton-like dimension bound (Theorem 4) and a linear-programming bound (Theorem 6) under a 'purity' condition (Definition 4). The authors claim that the Singleton-like bound strengthens the known bound (7) for disjoint (r,δ)-qLRCs and that the LP bound is tighter than previously relaxed bounds. The main issue is that Definition 4 is not the standard purity condition used in the cited literature, and the paper does not show that any known pure qLRC family satisfies it; consequently, the advertised strengthening is not established for the intended class of codes.","tokens_in":11009,"tokens_out":11495,"duration_ms":110450,"significance":"If the blockwise enumerator identities were fully proved and the purity condition were satisfied by natural code families, the framework would offer a genuinely non-stabilizer route to qLRC bounds and the LP adaptation in Theorem 6 would be a useful contribution. However, as it stands, the central results apply to a newly defined 'pure' subclass whose nonemptiness is not demonstrated, and several load-bearing proofs are omitted. The paper does not provide machine-checked proofs, reproducible code, or explicit examples, so the practical significance of the bounds is currently unclear.","major_comments":[{"comment":"The purity condition A_i^SL=0 for all i in T_{d,δ}\\{0} is substantially stronger than the standard purity condition A_i=0 for total weight i<d. Because T_{d,δ} contains every profile with all block weights at most δ−1 (the sum over blocks with weight at least δ is empty), Definition 4 forces A_i^SL=0 also for profiles whose total weight is at least d. The proof of Theorem 4 relies on exactly this stronger condition when it discards all nonzero k≤j. The paper neither proves that the known pure stabilizer qLRC families from [4] or [6] satisfy Definition 4 nor supplies any construction of a code that does. Therefore the claimed strengthening of bound (7) for the class of codes previously called pure is not established; Theorem 4 applies only to a possibly empty newly defined subclass.","section":"Section V, Definition 4 and Theorem 4"},{"comment":"The blockwise MacWilliams identity is load-bearing for Corollary 1, Theorem 4, and Theorem 5, but its proof is omitted with only the sentence that it follows by adapting arguments in [18]. Similarly, Theorem 5's proof is a one-sentence appeal to the LP method of [16], and Theorem 6 is presented as a proof sketch with the nonnegativity of the Krawtchouk coefficients f_i≥0 stated as 'standard' without details. These gaps prevent the reader from verifying two of the paper's main results, and they should be filled with complete proofs or precise reductions to stated references.","section":"Section IV-A, Theorem 2(3), and Section VI, Theorems 5 and 6"},{"comment":"The assertions that Theorem 4 'agrees with' the pure stabilizer bound (8) for δ=2 and that it recovers the stabilizer (r,2)-qLRC bound are not justified, because the purity notion used in (8) is weaker than Definition 4. Even for δ=2, a standard pure stabilizer code can have A_i^SL>0 for a profile with one error in each of several blocks and total weight at least d, while Definition 4 forces such a profile to have zero enumerator. The comparison must be either proved for the standard pure class or explicitly restricted to the new blockwise-pure class.","section":"Section V, comparison with known bounds"}],"minor_comments":[{"comment":"Reference [16] spells the second author 'Litsyu'; the standard spelling is 'Litsyn'.","section":"References"},{"comment":"The remark assumes equal block sizes |J_ℓ|=N and N|n, but Definition 2 only guarantees |R_i|≤N; the reduction to identical block sizes should be stated as a separate assumption, with a discussion of how the bounds change for unequal blocks.","section":"Section II, Remark after Definition 2"},{"comment":"The notation E^(ℓ)_V is used in the proof without definition; define E_V = ⊗_{ℓ∈V} E^(ℓ) before the displayed equation.","section":"Theorem 2(2)"},{"comment":"The term 'pure' conflicts with the established meaning of a pure quantum code; the authors should use 'blockwise pure' or another unambiguous term throughout, or explicitly justify why the established term should be extended.","section":"Definition 4"}],"recommendation":"reject","confidential_remarks":"The central advertised claim rests on a nonstandard purity definition that is not shown to be satisfied by any known pure qLRC and is in fact stronger than standard purity in a way that can fail for ordinary pure stabilizer codes. This is a scope error rather than a local presentation issue. I would be willing to reconsider a revision that either proves known optimal pure qLRC families satisfy the new definition or recasts the paper as a study of an explicitly named new class with nontrivial examples and revised comparison statements. The omitted proofs of the MacWilliams identity and the LP bound are additional concerns."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The blockwise Shor–Laflamme and unitary enumerators are a real addition to the qLRC toolkit. Extending split enumerators from two blocks to s blocks is natural but nontrivial, and the local KL condition in Theorem 1 is cleanly formulated. Theorem 3's equality characterization (K B_i^U = A_i^U iff every erasure with block profile bounded by i is correctable) is correct and useful. The paper is also honest about what it does not prove, which is refreshing.\n\nThe soft spots are where the advertised results live. Definition 4's purity condition, A_i^SL = 0 for all i in T_{d,δ} \\ {0}, is strictly stronger than the standard purity condition A_i = 0 for total weight < d. As the stress-test note observes, T_{d,δ} contains profiles whose total weight exceeds d−1, for example (2,1) with d=3 and δ=2. So Theorem 4 discards terms that standard purity would not discard. The paper does not show that any known pure stabilizer qLRC family from [4] or [6] satisfies this stronger condition, and without such a construction the strengthening over bound (7) is not established for the class the literature already calls pure. This is a load-bearing gap, not a cosmetic one.\n\nThe MacWilliams identity for the blockwise enumerators is stated and its proof omitted; for a paper whose main tool is weight enumerators, that proof should be either included or clearly referenced. Theorem 5's LP bound is justified in one sentence, and Theorem 6's proof sketch claims standard Krawtchouk identities imply f_i ≥ 0, but that nonnegativity is exactly the delicate part of the Agarwal–Barg–Hu–Mazumdar–Tamo construction and is not demonstrated. The comparison with the pure stabilizer bound (8) is also handwavy.\n\nWho gets value: researchers working on weight-enumerator bounds for locally recoverable quantum codes will want to know about these blockwise enumerators, and the local KL condition may be reusable. But the paper, as it stands, is not a reliable source for the stronger bounds because the central purity assumption is unpopulated and several proof steps are sketches. It deserves a serious referee, but the referee should insist on either connecting Definition 4 to known pure qLRC constructions or explicitly restricting the theorems to a new subclass with examples, and on filling the omitted proofs.\n\nI would not cite the main bounds yet, but I would keep the enumerator framework in mind.","headline":"Genuinely new blockwise enumerator formalism, but the headline Singleton bound rests on a purity definition that is much stronger than the standard one and is not shown to be satisfied by any known pure qLRC family.","tokens_in":11477,"tokens_out":1995,"would_cite":false,"duration_ms":20351,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["81P70","94B65"],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper proves a Singleton-like dimension bound for pure disjoint $(r,\\delta)$-quantum locally recoverable codes using blockwise weight enumerators, without a stabilizer structure.","keywords":["quantum locally recoverable codes","disjoint recovery sets","weight enumerators","Singleton-like bound","linear programming bound","local Knill–Laflamme conditions","non-stabilizer quantum codes","purity condition"],"falsifier":"Search for a pure disjoint $(r,\\delta)$-qLRC with parameters violating the bound (5), or compute the blockwise SL enumerators of a known pure stabilizer qLRC: finding any nonzero $A^{SL}_i$ with $i \\in T_{d,\\delta}\\setminus\\{0\\}$ would demonstrate that the purity premise is not inherited from standard purity, so the theorem's strengthened bound would not cover that code.","tokens_in":10563,"feed_emoji":"⚛️","tokens_out":6768,"duration_ms":54738,"temperature":0.7,"pith_summary":"This paper tries to establish a Singleton-like dimension bound for pure disjoint $(r,\\delta)$-quantum locally recoverable codes (qLRCs) without invoking a stabilizer structure. The claimed bound is $$K \\le $q^{{\\,n-2(d-1)-2\\left\\lfloor \\tfrac{n-(d-1)}}${N}\\right\\rfloor(\\delta-1)},$$ where $N=r+\\delta-1$ is the recovery-block size; it strengthens the previously known bound for disjoint $(r,\\delta)$-qLRCs when the code satisfies a blockwise purity condition. To get there, the paper formulates local Knill–Laflamme conditions for within-block erasure recovery and introduces blockwise Shor–Laflamme and unitary weight enumerators that record how error weight is split across recovery blocks. A sympathetic reader would care because the argument is enumerator-based rather than stabilizer-based, so it applies to a wider class of quantum codes, and the same machinery yields a linear-programming upper bound.","feed_headline":"Stricter purity tightens Singleton bound for disjoint quantum LRCs","feed_subtitle":"Blockwise weight enumerators track errors across recovery sets and yield a sharper dimension ceiling.","key_machinery":"The load-bearing tools are the blockwise Shor–Laflamme enumerators $A^{SL}_i(M_1,M_2)$ and $B^{SL}_i(M_1,M_2)$ and the blockwise unitary enumerators $A^U_i$, $B^U_i$, which sum operator products over tensor-product basis operators with block weight profile $i$. The local Knill–Laflamme condition (Theorem 1) reduces within-block correctability to the local code support $Q_\\ell$, so that the set of correctable block profiles is exactly $T_{d,\\delta} = \\{i : \\sum_{\\ell: i_\\ell \\ge \\delta} i_\\ell \\le d-1\\}$. MacWilliams-type identities and the duality $B^U_i = A^U_{N-i}$ convert correctability into an equation for the unitary enumerators; purity then annihilates all intermediate terms in the Krawtchouk expansion, leaving only the $A^{SL}_0 = K^2$ contribution and yielding the dimension bound. The same enumerators feed a linear-programming bound (Theorems 5 and 6) using nonnegative Krawtchouk expansions of auxiliary polynomials.","core_discovery":"The central claim is that purity, defined blockwise as $A^{SL}_i = 0$ for every nonzero correctable block profile $i \\in T_{d,\\delta}$, lets the blockwise weight enumerators collapse exactly on the set $T_{d,\\delta}$ of locally-then-globally correctable erasure patterns. Using the identity $A^U_j = K A^U_{N-j}$ for a carefully chosen pattern $j$ with total weight $m=(d-1)+\\lfloor (n-(d-1))/N\\rfloor(\\delta-1)$, the paper forces $K \\le q^{n-2m}$, which is the bound above. A key comparison: for $\\delta=2$ this recovers the pure stabilizer $(r,2)$-qLRC bound without stabilizer assumptions, and for all $\\delta$ it sits below the general disjoint bound while matching the dual-containing classical $(r,\\delta)$-LRC dimension bound in quantum form. The paper's own framing is that these are the first bounds for disjoint $(r,\\delta)$-qLRCs derived from the new blockwise enumerator framework rather than from an underlying classical code.","pith_inferences":["If Definition 4's purity condition is genuinely satisfied by code families beyond stabilizer codes, the enumerator identity provides a direct route to optimality proofs; but the paper does not exhibit such families, so the practical coverage of the bound remains open.","The same blockwise enumerators could be adapted to overlapping recovery sets by replacing the partition with a cover, where the correctable set $T_{d,\\delta}$ would become a union over recovery sets rather than a simple sum over blocks.","One testable extension is to compute the blockwise SL spectra of small pure stabilizer qLRCs: any nonzero $A^{SL}_i$ for $i \\in T_{d,\\delta}\\setminus\\{0\\}$ would show the paper's purity is genuinely stronger than standard purity, and the bound would not apply to those codes.","The LP method may generalize to impure codes by subtracting shadow-type terms, mirroring how shadow enumerators tighten classical quantum LP bounds."],"forward_implications":["Any pure disjoint $(r,\\delta)$-qLRC with $n$ qudits and distance $d$ has dimension at most $q^{n-2(d-1)-2\\lfloor(n-(d-1))/N\\rfloor(\\delta-1)}$.","For $\\delta=2$, the new bound reproduces the pure stabilizer $(r,2)$-qLRC bound while dropping the stabilizer assumption, so any such non-stabilizer code inherits the same ceiling.","The linear-programming bound of Theorem 6 is at least as tight as the pure Singleton bound and strictly stronger than the relaxed versions of previously known bounds in both regimes $\\partial \\ge \\delta$ and $\\partial < \\delta$.","The construction of the LP polynomial shows that the admissible block profiles form a natural domain for Krawtchouk-based LP arguments, analogous to classical LRC bounds."],"supporting_citations":[{"why":"Defines $(r,2)$-qLRCs and provides the earlier Singleton-like bound that the new result sharpens in the pure disjoint case.","marker":"[1]"},{"why":"Introduces $(r,\\delta)$-qLRCs in the stabilizer setting and supplies the correspondence with dual-containing classical LRCs, including the bound (8) being compared.","marker":"[4]"},{"why":"Introduces the Shor–Laflamme weight enumerators and MacWilliams identities that the blockwise versions adapt.","marker":"[12]"},{"why":"Introduces unitary weight enumerators and the correctability characterization used in Theorem 3.","marker":"[13]"},{"why":"Provides the linear-programming method for quantum codes that Theorem 5 adapts to the blockwise enumerators.","marker":"[16]"},{"why":"Supplies split weight enumerators for entanglement-assisted codes; the blockwise MacWilliams identity in Theorem 2 is adapted from this work.","marker":"[18]"},{"why":"Provides the good-polynomial construction used for the LP polynomial in Theorem 6.","marker":"[20]"}],"fun_headline_variants":["Blockwise enumerators tighten Singleton bound for pure disjoint qLRCs","Purity sharpens Singleton bound for disjoint quantum LRCs","Non-stabilizer bounds from blockwise weight enumerators","Sharper dimension ceilings for pure disjoint qLRCs","Quantum LRC bounds improved via blockwise purity"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The paper assumes that no nonzero correctable error pattern contributes to the blockwise Shor–Laflamme enumerator; that is a much stronger purity condition than the usual one, and no existing family of pure codes is shown to meet it.","fun_headline_variants_meta":{"raw":{"variants":["Blockwise enumerators tighten Singleton bound for pure disjoint qLRCs","Purity sharpens Singleton bound for disjoint quantum LRCs","Non-stabilizer bounds from blockwise weight enumerators","Sharper dimension ceilings for pure disjoint qLRCs","Quantum LRC bounds improved via blockwise purity"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.00043,"raw_usage":{"total_tokens":2189,"prompt_tokens":929,"completion_tokens":1260,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":545,"completion_tokens_details":{"reasoning_tokens":1177}},"tokens_in":545,"tokens_out":1260,"duration_ms":9283,"temperature":1.0,"reasoning_tokens":1177,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-12T14:16:06.898854+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Search for a pure disjoint $(r,\\delta)$-qLRC with parameters violating the bound (5), or compute the blockwise SL enumerators of a known pure stabilizer qLRC: finding any nonzero $A^{SL}_i$ with $i \\in T_{d,\\delta}\\setminus\\{0\\}$ would demonstrate that the purity premise is not inherited from standard purity, so the theorem's strengthened bound would not cover that code.","supporting_citations":[{"cited_title":"Quantum analog of the MacWilliams identities for classical coding theory,","cited_arxiv_id":null,"evidence_quote":"Introduces the Shor–Laflamme weight enumerators and MacWilliams identities that the blockwise versions adapt."},{"cited_title":"Upper bounds on the size of quantum codes,","cited_arxiv_id":null,"evidence_quote":"Provides the linear-programming method for quantum codes that Theorem 5 adapts to the blockwise enumerators."},{"cited_title":"Combinatorial alphabet-dependent bounds for locally recoverable codes,","cited_arxiv_id":null,"evidence_quote":"Provides the good-polynomial construction used for the LP polynomial in Theorem 6."}],"review_version":1}