{"id":"d9582c4f-caa4-48b0-ab1b-b979f0274a16","arxiv_id":"2504.21845","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"Quantum expander codes decoded by the simple peeling decoder show failure rates that decrease with code length, making them an attractive low-complexity erasure correction option.","lead":"This paper tests the peeling decoder on quantum expander codes for qubit erasures, and finds that its failure rate drops as the code gets longer. The result suggests a simple, linear-time decoder can be competitive with more complex erasure decoders for these codes.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Claimed length-scaled improvement of peeling failure rate ignores asymptotic no-threshold: constant-rate codes with d=Θ(√n) must fail for any fixed erasure rate as n grows; the paper's own Theorem 3 only guarantees O(√n) correctable erasures.","rationale":"The reader's weakest_assumption focuses on the missing proof of the small-set-flip erasure adaptation and the infinite loop in Algorithm 4. Those are valid technical concerns, but they concern the secondary decoding algorithm rather than the paper's principal empirical claim about the peeling decoder alone. The most load-bearing issue is that the central claim—failure rate decreases with code length—is presented without the asymptotic caveat that the trend must reverse for any constant-rate code with sublinear distance. This is not merely a disagreement with prior expectations; it follows from the paper's own Theorem 3 (correctable erasures O(√n)) and from a standard counting argument for logical operators. The simulation data in Table II at p=0.325 already exhibit the reversal, so the effect is not hypothetical. The paper should either add a clear finite-size disclaimer and a discussion of when the crossover occurs, or provide a theoretical argument for why peeling on the Tanner graph T(H_Z) corrects a positive fraction of erasures despite the logical-operator obstruction. Since the empirical results for the tested lengths remain useful, the conditional verdict is appropriate; my additional concern does not change the verdict category but adds a specific required revision.","tokens_in":17101,"tokens_out":12488,"duration_ms":141023,"concrete_test":"Compute (or lower-bound) the weight enumerator of the X-type logical operators for the (5,6)-biregular expander family used in Fig. 5, and evaluate the expected number of logical operators fully contained in an i.i.d. p-erasure pattern, E[#logical ops] = Σ_w A_w p^w, for p = 0.2, 0.25, 0.3 and growing n. Find the crossover size n* where this expectation exceeds 1. Then simulate the peeling decoder on codes with n just below and above n* (e.g., the next sizes in the family, m=12 vs m=20 or m=40, with 10^5 trials per point) and check whether the failure rate stops decreasing and begins to increase. If the failure rate continues to decrease past n*, the finite-size concern is weakened; if it flattens or rises, the claimed scaling is confirmed to be a finite-size artifact.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim is that for quantum expander codes, the peeling decoder's failure rate decreases with code length at low and moderate erasure rates, in contrast with [37]. The paper does not address that this trend cannot continue asymptotically. For these codes, the number of logical operators grows as 2^{Θ(n)} while each logical operator has weight Θ(√n). For any fixed erasure probability p>0, a random erasure set of size pn is therefore increasingly likely to contain the support of a nontrivial logical operator, making the erasure fundamentally uncorrectable by any decoder. Equivalently, Theorem 3 bounds the number of erasures correctable by the SSF decoder (and hence by Algorithm 4) by r min(γ_V|V|, γ_C|C|) = O(√n), a vanishing fraction of n. Thus the observed decrease in failure rate in Fig. 5 is a finite-size effect that must reverse for sufficiently large n, not a scaling law. The paper's own data at erasure rate 0.325 already show the reversal: the mean residual error after peeling increases with n (Table II: 66.78, 188.38, 272.09, 371.67). The comparison with [37] is therefore not evidence of a qualitative advantage; it only shows that for the simulated lengths (n ≤ 8784) the crossover has not yet occurred. Section V-C asserts but does not prove the erasure-domain analysis, and the stated bound provides no support for the 'decreases with length' claim beyond finite-size simulation.","agreement_with_reader":"disagree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The manuscript studies erasure decoding for quantum expander codes, i.e., hypergraph products of classical expander codes, with code parameters [[N,k,d]] where d = Θ(√N). The authors propose a multi-stage decoder that combines classical peeling (Algorithm 1), dangling-cluster classification and correction (Algorithms 2 and 4), and a small-set-flip (SSF) decoder adapted to erasures (Algorithm 3). The central empirical claim, stated in the abstract and Section VI, is that for the same erasure rate the peeling decoder's failure rate decreases significantly with code length at low and moderate erasure rates, in contrast with the flat failure rate reported for PEG-based HGP codes in [37]. The paper also provides tables of residual-error statistics after peeling, including maximum, mean, and variance of residual error weight, and statistics on isolated horizontal and vertical clusters. A theoretical analysis is presented in Section V, with correctness of SSF for erasures claimed via Theorem 3 and imported lemmas from [14].","tokens_in":17370,"tokens_out":6304,"duration_ms":68946,"significance":"If the finite-size observation is robust, the paper identifies a linear-complexity erasure-decoding option for a class of constant-rate quantum LDPC codes, which is practically relevant given recent interest in erasure-biased hardware. The empirical work uses 10^5 trials per parameter point and provides useful statistics on residual errors that could guide future decoder design. The strength of the paper is its simulation campaign; the weakness is that the theoretical analysis of Algorithm 4 is incomplete and the principal scaling claim is stated without the finite-size caveat that the code family's asymptotic parameters require. The claimed advantage over [37] would be more compelling if accompanied by error bars, released code, and a clear statement of the parameter regime in which the trend holds.","major_comments":[{"comment":"The central claim that the peeling failure rate 'decreases significantly with the length' cannot hold asymptotically for the code family considered. Constant-rate quantum expander codes have minimum distance Θ(√n), and there are 2^{Θ(n)} logical operators, each of weight Θ(√n). For any fixed erasure probability p>0, the expected number of logical operators fully contained in a random erasure set is 2^{Θ(n)} p^{Θ(√n)}, which grows exponentially with n, so no decoder can succeed with high probability as n grows. Theorem 3 itself only guarantees correction of |ε| ≤ r min(γV|V|, γC|C|) = O(√n) erasures. Thus the observed decrease in Fig. 5 is a finite-size effect that must reverse at sufficiently large n; Table II already shows the reversal beginning at erasure rate 0.325, where the mean residual error increases from 66.78 to 371.67 as the code length increases. Please state explicitly that the comparison with [37] is a finite-size comparison and avoid phrasing that implies an asymptotic scaling advantage.","section":"Section VI and Abstract"},{"comment":"The erasure-domain analysis of Algorithm 3 is asserted but not proven. Lemmas 1 and 2 are imported from [14], where they hold for arbitrary errors and for small sets defined without the erasure-support restriction. In Algorithm 3, the flip set F is restricted to F ⊆ Γ_X(g) ∩ ε, but no proof is given that the expander lemmas remain valid under this restriction or under the modified notion of critical generator introduced in Definition 3. Moreover Definition 3 contains a symbol error: 'Γ X (g) = Γ 1 ⊎ Γ 1 ⊎ Γ 2 ⊎ Γ 2' uses the same symbols for what must be two different parts, and the bulleted conditions are consequently unreadable as printed. Since the proof of Theorem 3 depends on Lemma 2, the claimed erasure-decoding guarantee of SSF is not established as it stands.","section":"Section V-C and Definition 3"},{"comment":"Algorithm 4 as printed does not guarantee termination. On line 8, if CLASSIFY returns Unclassified, the instruction 'continue' returns to line 5 without modifying Vκ, so if classification repeatedly fails for the same dangling cluster the while loop never exits. Remark 1 acknowledges this possibility and suggests a counter that is not included in the pseudocode. Consequently, the 'linear-time' and correctness claims for Algorithm 4 are not supported as stated. The algorithm must be modified to guarantee termination, and the modification must be reflected in the pseudocode and in the complexity analysis.","section":"Section IV, Algorithm 4, and Remark 1"},{"comment":"No theorem states that the peeling and cluster stages of Algorithm 4 reduce an arbitrary erasure pattern to a residual error satisfying the hypothesis |Eres| ≤ r min(γV|V|, γC|C|) of Theorem 3. Theorem 2 applies only inside a single classical cluster when |Vκ| ≤ γ|V|, and the cluster classification of Algorithm 2 as well as the delayed correction of free dangling clusters are not analyzed. The residual statistics in Tables I and II show that at erasure rates 0.3 and 0.325 the maximum residual weight can far exceed the O(√n) guarantee, so the stated theoretical guarantee often does not apply in the simulated regime. Please either provide a careful correctness proof for the full algorithm or state explicitly that the cluster-based stages are heuristic and that the proven guarantee applies only when the residual error after peeling is small.","section":"Section V"}],"minor_comments":[{"comment":"The figure lacks confidence intervals; with 10^5 trials per point, binomial error bars should be included to support comparisons at failure rates around 10^{-3} to 10^{-4}.","section":"Figure 5"},{"comment":"No simulation code or data files are provided, so the tables and figure cannot be independently reproduced.","section":"Reproducibility"},{"comment":"Reference [41] is incomplete: it lists the same author team as [37] but no title, journal, or arXiv identifier.","section":"References"},{"comment":"Definition 3 should be rewritten with distinct symbols for the two components and a precise statement of the critical-generator condition; as printed it cannot be checked by a reader.","section":"Definition 3"},{"comment":"The pseudocode calls PEEL(Vκ, σκ) after popping a pair (κ,c), but it does not specify how the syndrome is updated when the connecting check c is reinserted on line 23; this should be clarified.","section":"Algorithm 4, line 24"}],"recommendation":"major_revision","confidential_remarks":"The manuscript is likely salvageable as an empirical study of finite-size erasure decoding for quantum expander codes, provided the authors add the asymptotic caveat, fix the termination issue in Algorithm 4, and either prove or clearly label as heuristic the erasure-domain SSF analysis. The theoretical section as written does not yet support the stated decoding guarantees."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The paper's core empirical finding is credible: for the quantum expander codes they simulate (up to 8784 qubits), the peeling decoder's failure rate at low and moderate erasure rates drops as the code gets longer, and that does contrast with the flat behavior reported for PEG-based HGP codes. The residual-error statistics in Tables I-IV are also a genuinely useful resource for anyone designing a two-stage erasure decoder. That part deserves credit.\n\nThe soft spot is the interpretation. For these codes, the distance grows only as Θ(√n), and there are exponentially many logical operators. For any fixed erasure rate p > 0, a random erasure set of size pn will contain the support of a nontrivial logical operator with probability tending to 1, so the failure rate has to rise again for large enough n. The paper does not mention this, and its own data at erasure rate 0.325 already hint at the reversal: the mean residual error after peeling increases with n. The comparison with [37] is therefore not evidence of a qualitative asymptotic advantage; it is a finite-size comparison in a regime where the crossover has not yet happened. The authors should state this limitation clearly and soften the abstract's language.\n\nThe theoretical part is weaker than the empirical part. Remark 1 admits that Algorithm 4 as printed can loop forever, which undercuts the claim of a linear-time decoder until a termination guard is added. Definition 3 has a symbol-level typo, and the erasure-domain analysis of the small-set-flip decoder is asserted by analogy with [14] rather than proved; the imported lemmas were proven for errors, not erasures, and the adaptation is not straightforward. Theorem 3 only guarantees correction of O(√n) erasures, which does not support a length-scaling story for the peeling decoder itself.\n\nThese are fixable issues, and the empirical core is solid enough to justify referee time. The paper is aimed at researchers working on erasure decoding for photonic or neutral-atom platforms, where linear-time decoders matter. With a revision that adds the asymptotic caveat, fixes the loop, and either proves or precisely cites the erasure-domain SSF analysis, it would be a useful contribution.\n\nI would send it to peer review, but it needs meaningful revision before acceptance.","headline":"The finite-size simulation result is real and useful, but the paper's headline claim that peeling failure decreases with code length is not an asymptotic scaling law and needs an explicit caveat.","tokens_in":17960,"tokens_out":2905,"would_cite":true,"duration_ms":30716,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"For quantum expander codes, the peeling decoder's failure rate drops as code length grows, making linear-time erasure decoding practical where earlier hypergraph-product codes plateau.","keywords":["quantum expander codes","erasure decoding","peeling decoder","quantum LDPC codes","small-set-flip decoder","hypergraph product codes","stopping sets"],"falsifier":"Simulate the peeling decoder on a (5,6)-biregular quantum expander code with blocklength above 10,000 at erasure rate 0.25; the claimed scaling predicts a failure rate below the approximately $10^{-3}$ level of the [[6100,100]] code, so observing a flat or rising failure rate would falsify the central comparison. Alternatively, exhibit an erasure pattern of size at most $r\\min(\\gamma_V|V|,\\gamma_C|C|)$ on which the small-set-flip stage fails, which would disprove Theorem 3.","tokens_in":16879,"feed_emoji":"⚛️","tokens_out":5884,"duration_ms":58069,"temperature":0.7,"pith_summary":"Quantum expander codes—hypergraph products of classical expander codes—offer a simple route to erasure recovery: this paper claims that the classical peeling decoder alone, run on the Z-stabilizer Tanner graph, corrects erasures with a failure rate that decreases as the code grows, at least at low and moderate erasure rates. That contrasts with earlier simulation results for progressive-edge-growth-based hypergraph product codes, whose peeling failure rate stayed flat as blocklength increased. The paper backs the claim with simulations of four quantum expander codes (lengths 1525 to 8784) and supplements peeling with cluster-based correction and a small-set-flip stage to handle residual errors, arguing that the combined decoder runs in linear time. If the scaling holds, quantum expander codes become a practical option for platforms where qubit loss is the dominant noise, since longer codes improve erasure performance without a more complex decoder.","feed_headline":"Peeling decoder failure rates fall as quantum expander codes grow","feed_subtitle":"Simulations show a linear-time decoder improves with code length, unlike earlier hypergraph-product codes.","key_machinery":"The load-bearing object is the peeling decoder acting on the Tanner graph $T(H_Z)$ of the Z-type stabilizers, together with the expansion property of the underlying graph. A dangling check is a check incident to exactly one erased variable; peeling repeatedly resolves those variables. The expansion constants $\\gamma_V,\\delta_V,\\gamma_C,\\delta_C$ bound the size of correctable erasure sets: a classical expander-code erasure decoder corrects clusters of size at most $\\gamma_V |V|$ (horizontal) or $\\gamma_C |C|$ (vertical), and the small-set-flip stage uses small sets—subsets of an X-generator's support inside the erasure set—to reduce syndrome weight by at least $\\beta d_C |F|$. These ingredients convert the stopping-set problem, which is the usual barrier for quantum LDPC erasure decoding, into a residual-error problem of small weight.","core_discovery":"The paper's central claim is that the peeling decoder—a simple iterative routine that resolves any erased qubit attached to a check touched only once—does not stall as quickly on quantum expander codes as on other hypergraph-product constructions. For the [[1525,25]], [[3904,64]], [[6100,100]] and [[8784,144]] codes built from (5,6)-biregular expanders, simulations with $10^5$ trials per erasure rate show that, for erasure rates up to about 0.3, the failure rate falls markedly as blocklength grows; at an erasure rate of 0.25, the [[6100,100]] code under peeling performs comparably to the [[1600,64]] HGP code under the more complex vertical-horizontal decoder. The paper also proposes a complete linear-time erasure decoder that first peels, then corrects isolated and frozen clusters with a classical expander-code erasure decoder, defers free clusters, and finishes with a small-set-flip decoder on the small residual erasure set. It reports statistics showing that residual errors after peeling have small weight and are concentrated in a few clusters.","pith_inferences":["A testable consequence the authors do not draw: if expansion is the cause of the scaling, randomly generated biregular expander codes of the same length and rate should show the same peeling improvement, while non-expanding HGP codes should retain a flatter failure-rate curve; comparing the two at fixed length would isolate the mechanism.","The data suggest a practical pipeline for photonic or neutral-atom memories: convert loss to erasure, peel, then run an exact decoder on the small residual support; the reported residual weights mean the final step could be made near-exact at negligible cost.","The maximum residual weight at high erasure rates (0.325) grows sharply and non-monotonically with length (mean 371.67 for the [[8784,144]] code), so the linear-decoding promise should be expected to fail near the threshold; characterizing that threshold analytically would be a natural next step."],"forward_implications":["For low and moderate erasure rates, longer quantum expander codes give lower peeling failure rates, so hardware designers can use longer codes without paying a decoder-complexity penalty.","A linear-complexity decoder (peeling plus small-set-flip) can reach failure rates comparable to the vertical-horizontal decoder at a fraction of the decoding cost, in the simulated length regime.","After peeling, residual erasures are small in weight (for example, maximum 38 for the [[8784,144]] code at 0.3 erasure rate) and are contained in few clusters, so post-processing steps only need to handle small subsystems.","Cluster-based decoding adds only a small improvement over peeling for quantum expander codes, suggesting the peeling stage, not cluster handling, is the main performance driver.","The printed Algorithm 4 may loop forever when cluster classification repeatedly fails; the authors note that storing a previous-error check fixes termination, so the decoder as described needs that guard."],"supporting_citations":[{"why":"Defines classical expander codes and their linear-time decoding, providing the base code used in the hypergraph-product construction.","marker":"[12]"},{"why":"Introduces quantum expander codes and the small-set-flip decoder that the paper adapts to erasures.","marker":"[13]"},{"why":"Supplies the critical-generator lemmas (Lemmas 1 and 2) that the paper relies on for the small-set-flip analysis in the erasure setting.","marker":"[14]"},{"why":"Provides the classical linear-time erasure-decoding algorithm (Algorithm 1) used to correct isolated and frozen clusters.","marker":"[22]"},{"why":"Supplies the comparison baseline: peg-based HGP codes with a flat peeling failure rate and the vertical-horizontal decoder with higher complexity.","marker":"[37]"},{"why":"Provides the small-set-flip algorithm description (Algorithm 3) and its analysis, which the paper modifies for known error locations.","marker":"[40]"}],"fun_headline_variants":["Peeling decoder thrives on quantum expander codes","Quantum expander codes make peeling decoder effective","Linear-time erasure decoding improves with expander codes","Peeling plus small-set-flip: a fast erasure decoder for expanders","Quantum expander codes beat hypergraph-product for peeling"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that the small-set-flip lemmas proven for random errors in quantum expander codes remain valid when the error is known to be supported on the erasure set; the paper asserts this transfer rather than proving it, and the combined algorithm as printed can also fail to terminate without an added repeat-check.","fun_headline_variants_meta":{"raw":{"variants":["Peeling decoder thrives on quantum expander codes","Quantum expander codes make peeling decoder effective","Linear-time erasure decoding improves with expander codes","Peeling plus small-set-flip: a fast erasure decoder for expanders","Quantum expander codes beat hypergraph-product for peeling"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000842,"raw_usage":{"total_tokens":3659,"prompt_tokens":925,"completion_tokens":2734,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":541,"completion_tokens_details":{"reasoning_tokens":2655}},"tokens_in":541,"tokens_out":2734,"duration_ms":20270,"temperature":1.0,"reasoning_tokens":2655,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T04:51:40.096692+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Simulate the peeling decoder on a (5,6)-biregular quantum expander code with blocklength above 10,000 at erasure rate 0.25; the claimed scaling predicts a failure rate below the approximately $10^{-3}$ level of the [[6100,100]] code, so observing a flat or rising failure rate would falsify the central comparison. Alternatively, exhibit an erasure pattern of size at most $r\\min(\\gamma_V|V|,\\gamma_C|C|)$ on which the small-set-flip stage fails, which would disprove Theorem 3.","supporting_citations":[{"cited_title":"Expander codes,","cited_arxiv_id":null,"evidence_quote":"Defines classical expander codes and their linear-time decoding, providing the base code used in the hypergraph-product construction."},{"cited_title":"Quantum ex pander codes,","cited_arxiv_id":null,"evidence_quote":"Introduces quantum expander codes and the small-set-flip decoder that the paper adapts to erasures."},{"cited_title":"Efficient d ecoding of random errors for quantum expander codes,","cited_arxiv_id":null,"evidence_quote":"Supplies the critical-generator lemmas (Lemmas 1 and 2) that the paper relies on for the small-set-flip analysis in the erasure setting."},{"cited_title":"Linear-time decoding of regular expande r codes,","cited_arxiv_id":null,"evidence_quote":"Provides the classical linear-time erasure-decoding algorithm (Algorithm 1) used to correct isolated and frozen clusters."},{"cited_title":"Grospellier, Constant time decoding of quantum expander codes and applic ation to fault-tolerant quantum computation","cited_arxiv_id":null,"evidence_quote":"Provides the small-set-flip algorithm description (Algorithm 3) and its analysis, which the paper modifies for known error locations."}],"review_version":1}