Pith. sign in

REVIEW 4 major objections 5 minor 41 references

On the Efficacy of the Peeling Decoder for the Quantum Expander Code

T0 review · 4 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read 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.

desk verdict 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. read the letter →

arxiv 2504.21845 v2 pith:K25R6PNL submitted 2025-04-30 quant-ph cs.ITmath.IT

Jefrin Sharmitha Prabhu , Abhinav Vaishya , Shobhit Bhatnagar , Aryaman Manish Kolhe , V. Lalitha , P. Vijay Kumar This is my paper · ORCID
classification quant-phcs.ITmath.IT
keywords quantumexpandercodeserasuredecodingpeelingdecoderLDPCsmall-set-fliphypergraphproductstoppingsets
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

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.

What carries the argument

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.

What would settle it

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.

Watch

Extended reading notes

Core claim

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.

Load-bearing premise

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.

Editorial extensions

If this is right

  • 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.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • 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.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

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].

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 (4)
  1. [Section VI and Abstract] 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.
  2. [Section V-C and Definition 3] 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.
  3. [Section IV, Algorithm 4, and Remark 1] 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.
  4. [Section V] 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.
minor comments (5)
  1. [Figure 5] 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}.
  2. [Reproducibility] No simulation code or data files are provided, so the tables and figure cannot be independently reproduced.
  3. [References] Reference [41] is incomplete: it lists the same author team as [37] but no title, journal, or arXiv identifier.
  4. [Definition 3] 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.
  5. [Algorithm 4, line 24] 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.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the paper's central claims are empirical simulations plus imported external theorems; no fitted parameter is relabeled as a prediction.

full rationale

The central claim is that the peeling decoder's failure rate for quantum expander codes decreases with code length at low and moderate erasure rates. This is presented as a simulation result in Section VI and Fig. 5, with 10^5 trials per erasure rate for four code lengths. No parameter is fitted to a subset of the data and then used to predict a closely related quantity; the reported failure rates are direct Monte Carlo estimates. The theoretical analysis in Section V imports Lemmas 1 and 2 from Ref. [14] and the classical expander-code erasure decoding result of Ref. [22]; these are external results, not self-citations, and they are not invoked to define the simulated outcome. The assertion that the SSF decoder analysis for erasures 'follows a similar analysis as done for errors in [14]' is an unproved transfer of an external argument, which is a correctness/completeness concern rather than circularity. There is no definition of a quantity in terms of the quantity being predicted, no fitted input called a prediction, and no self-citation chain that forces the conclusion. The asymptotic limitation that Theorem 3 only certifies O(sqrt(n)) correctable erasures while the simulation shows finite-size improvement may undermine the strength of the scaling claim, but that is an external correctness risk, not a circularity. Accordingly, the derivation chain is self-contained for the empirical claim, and no circular step is present.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The paper introduces no new free parameters or invented entities. Its theoretical claims rest on imported expander graph properties and prior decoder analyses; the weakest imported assumption is that the error-domain small-set-flip analysis extends to erasures without re-derivation.

assumptions (4)
  • domain assumption Expander graphs with (gamma_V, delta_V, gamma_C, delta_C)-left-right expansion exist and can be sampled efficiently (Theorem 1 from [14]).
    The simulated codes are built from (5,6)-biregular expander graphs, and the theoretical bounds in Theorem 3 assume such expansion with delta_V, delta_C < 1/8.
  • standard math The classical peeling decoder for expander codes corrects up to gamma|V| erasures in linear time (Viderman [22]).
    Used in Theorem 2 and in the cluster correction step of Algorithm 4, where isolated or frozen dangling clusters are decoded as classical expander codes.
  • domain assumption The small-set-flip analysis for errors in quantum expander codes (Lemmas 1 and 2 from [14]) applies to erasures with known locations.
    Theorem 3 for erasures is asserted to follow from [14] without a full derivation; the critical generator properties are assumed to hold when the error is restricted to the erasure set.
  • standard math The hypergraph product of a classical expander code with itself yields a valid CSS quantum expander code with the stated parameters.
    Standard background from [11] and [13], used to set up the code model in Section III-A.

how reviews work

0 comments
Cite this review

Pith. "Pith review of On the Efficacy of the Peeling Decoder for the Quantum Expander Code." pith.science (2026). https://pith.science/paper/K25R6PNL

@misc{pith2026250421845,
  author       = {Pith},
  title        = {Pith review of: On the Efficacy of the Peeling Decoder for the Quantum Expander Code},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/K25R6PNL}},
  note         = {Machine review of arXiv:2504.21845}
}
read the original abstract

The problem of recovering from qubit erasures has recently gained attention as erasures occur in many physical systems such as photonic systems, trapped ions, superconducting qubits and circuit quantum electrodynamics. While several linear-time decoders for error correction are known, their error-correcting capability is limited to half the minimum distance of the code, whereas erasure correction allows one to go beyond this limit. As in the classical case, stopping sets pose a major challenge in designing efficient erasure decoders for quantum LDPC codes. In this paper, we show through simulation, that an attractive alternative here, is the use of quantum expander codes in conjunction with the peeling decoder that has linear complexity. We also discuss additional techniques including small-set-flip decoding, that can be applied following the peeling operation, to improve decoding performance and their associated complexity.

Figures

Figures reproduced from arXiv: 2504.21845 by the authors.

Figure 1
Figure 1. The Tanner graph for the HGP code constructed from cla [PITH_FULL_IMAGE:figures/full_fig_p006_1.png] view at source ↗
Figure 2
Figure 2. Stabilizer stopping set for the HGP code constructed [PITH_FULL_IMAGE:figures/full_fig_p008_2.png] view at source ↗
Figure 3
Figure 3. Horizontal and vertical stopping sets for the HGP cod [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Illustration of different types of clusters. [PITH_FULL_IMAGE:figures/full_fig_p011_4.png]
Figure 5
Figure 5. Figure 5: Performance of the [[1525, 25]], [[3904, 64]], [[6100, 100]], and [[8784, 144]] quantum expander codes under the peeling decoder. As [PITH_FULL_IMAGE:figures/full_fig_p018_5.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

41 extracted references · 33 canonical work pages

  1. [37]

    F ast erasure decoder for hypergraph product codes,

    N. Connolly, V . Londe, A. Leverrier, and N. Delfosse, “F ast erasure decoder for hypergraph product codes,” Quantum, vol. 8, p. 1450, 2024

    2024

  2. [14]

    Efficient d ecoding of random errors for quantum expander codes,

    O. Fawzi, A. Grospellier, and A. Leverrier, “Efficient d ecoding of random errors for quantum expander codes,” in Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing , pp. 521–534, 2018

    work page 2018

  3. [1]

    Gottesman, Stabilizer codes and quantum error correction

    D. Gottesman, Stabilizer codes and quantum error correction . California Institute of Technology, 1997

    1997

  4. [2]

    Fault-tolerant quantum computation wit h constant overhead,

    D. Gottesman, “Fault-tolerant quantum computation wit h constant overhead,” arXiv preprint arXiv:1310.2984 , 2013

    arXiv 2013

  5. [3]

    Fiber bundle c odes: breaking the n 1/2 polylog (n) barrier for quantum ldpc codes,

    M. B. Hastings, J. Haah, and R. O’Donnell, “Fiber bundle c odes: breaking the n 1/2 polylog (n) barrier for quantum ldpc codes,” in Proceedings of the 53rd Annual ACM SIGACT Symposium on Theor y of Computing , pp. 1276–1288, 2021

    work page 2021

  6. [4]

    Balanced product q uantum codes,

    N. P . Breuckmann and J. N. Eberhardt, “Balanced product q uantum codes,” IEEE Transactions on Information Theory , vol. 67, no. 10, pp. 6653–6674, 2021

    work page 2021

  7. [5]

    Quantum ldpc codes with al most linear minimum distance,

    P . Panteleev and G. Kalachev, “Quantum ldpc codes with al most linear minimum distance,” IEEE Transactions on Information Theory , vol. 68, no. 1, pp. 213–229, 2021

    work page 2021

  8. [6]

    Asymptotically good quan tum and locally testable classical ldpc codes,

    P . Panteleev and G. Kalachev, “Asymptotically good quan tum and locally testable classical ldpc codes,” in Proceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing , pp. 375–388, 2022

    work page 2022

Show all 41 references
  1. [7]

    Quantum tanner codes,

    A. Leverrier and G. Z´ emor, “Quantum tanner codes,” in 2022 IEEE 63rd Annual Symposium on F oundations of Computer S cience (FOCS), pp. 872–883, IEEE, 2022

    2022

  2. [8]

    Decoding quantum tanner cod es,

    A. Leverrier and G. Z´ emor, “Decoding quantum tanner cod es,” IEEE Transactions on Information Theory , vol. 69, no. 8, pp. 5100–5115, 2023

    2023

  3. [9]

    Good qua ntum ldpc codes with linear time decoders,

    I. Dinur, M.-H. Hsieh, T.-C. Lin, and T. Vidick, “Good qua ntum ldpc codes with linear time decoders,” in Proceedings of the 55th annual ACM symposium on theory of computing , pp. 905–918, 2023

    2023

  4. [10]

    An efficient decoder f or a linear distance quantum ldpc code,

    S. Gu, C. A. Pattison, and E. Tang, “An efficient decoder f or a linear distance quantum ldpc code,” in Proceedings of the 55th Annual ACM Symposium on Theory of Computing , pp. 919–932, 2023

    2023

  5. [11]

    Quantum ldpc codes with positive rate and minimum distance proportional to the square root of the blocklength,

    J.-P . Tillich and G. Z´ emor, “Quantum ldpc codes with positive rate and minimum distance proportional to the square root of the blocklength,” IEEE Transactions on Information Theory , vol. 60, no. 2, pp. 1193–1202, 2013

    2013

  6. [12]

    Expander codes,

    M. Sipser and D. A. Spielman, “Expander codes,” IEEE transactions on Information Theory , vol. 42, no. 6, pp. 1710–1722, 1996

    1996

  7. [13]

    Quantum ex pander codes,

    A. Leverrier, J.-P . Tillich, and G. Z´ emor, “Quantum ex pander codes,” in 2015 IEEE 56th Annual Symposium on F oundations of Computer Science, pp. 810–824, IEEE, 2015

    2015

  8. [15]

    Constant o verhead quantum fault tolerance with quantum expander code s,

    O. Fawzi, A. Grospellier, and A. Leverrier, “Constant o verhead quantum fault tolerance with quantum expander code s,” Communications of the ACM , vol. 64, no. 1, pp. 106–114, 2020

    2020

  9. [16]

    A scheme for effi cient quantum computation with linear optics,

    E. Knill, R. Laflamme, and G. J. Milburn, “A scheme for effi cient quantum computation with linear optics,” nature, vol. 409, no. 6816, pp. 46–52, 2001

    2001

  10. [17]

    Fusion-based quantum computation,

    S. Bartolucci, P . Birchall, H. Bombin, H. Cable, C. Daws on, M. Gimeno-Segovia, E. Johnston, K. Kieling, N. Nickerso n, M. Pant, et al. , “Fusion-based quantum computation,” Nature Communications, vol. 14, no. 1, p. 912, 2023

    2023

  11. [18]

    Erasur e conversion for fault-tolerant quantum computing in alkal ine earth Rydberg atom arrays,

    Y . Wu, S. Kolkowitz, S. Puri, and J. D. Thompson, “Erasur e conversion for fault-tolerant quantum computing in alkal ine earth Rydberg atom arrays,” Nature communications, vol. 13, no. 1, p. 4657, 2022

    2022

  12. [19]

    Quantum error c orrection with metastable states of trapped ions using eras ure conversion,

    M. Kang, W. C. Campbell, and K. R. Brown, “Quantum error c orrection with metastable states of trapped ions using eras ure conversion,” PRX Quantum , vol. 4, no. 2, p. 020358, 2023

    2023

  13. [20]

    Erasure qubits: Overcoming the T 1 limit in superconducting circuits,

    A. Kubica, A. Haim, Y . V aknin, H. Levine, F. Brand˜ ao, an d A. Retzker, “Erasure qubits: Overcoming the T 1 limit in superconducting circuits,” Physical Review X , vol. 13, no. 4, p. 041022, 2023

    2023

  14. [21]

    Error-detectable bosonic entangling gates with a noisy an cilla,

    T. Tsunoda, J. D. Teoh, W. D. Kalfus, S. J. de Graaf, B. J. C hapman, J. C. Curtis, N. Thakur, S. M. Girvin, and R. J. Schoel kopf, “Error-detectable bosonic entangling gates with a noisy an cilla,” PRX Quantum , vol. 4, no. 2, p. 020354, 2023

    2023

  15. [22]

    Linear-time decoding of regular expande r codes,

    M. Viderman, “Linear-time decoding of regular expande r codes,” ACM Transactions on Computation Theory (TOCT) , vol. 5, no. 3, pp. 1–25, 2013

    2013

  16. [23]

    Viderman’ s algorithm for quantum ldpc codes,

    A. Krishna, I. Livni Navon, and M. Wootters, “Viderman’ s algorithm for quantum ldpc codes,” in Proceedings of the 2024 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA) , pp. 2481–2507, SIAM, 2024

    2024

  17. [24]

    Linear-time maximum likeli hood decoding of surface codes over the quantum erasure chan nel,

    N. Delfosse and G. Z´ emor, “Linear-time maximum likeli hood decoding of surface codes over the quantum erasure chan nel,” Physical Review Research, vol. 2, no. 3, p. 033042, 2020

    2020

  18. [25]

    Almost-linear time de coding algorithm for topological codes,

    N. Delfosse and N. H. Nickerson, “Almost-linear time de coding algorithm for topological codes,” Quantum, vol. 5, p. 595, 2021. 22

    2021

  19. [26]

    Toward a uni on-find decoder for quantum ldpc codes,

    N. Delfosse, V . Londe, and M. E. Beverland, “Toward a uni on-find decoder for quantum ldpc codes,” IEEE Transactions on Information Theory, vol. 68, no. 5, pp. 3187–3199, 2022

    2022

  20. [27]

    Trimming decoding of co lor codes over the quantum erasure channel,

    S. Lee, M. Mhalla, and V . Savin, “Trimming decoding of co lor codes over the quantum erasure channel,” in 2020 IEEE International Symposium on Information Theory (ISIT) , pp. 1886–1890, IEEE, 2020

    2020

  21. [28]

    Decoding topologic al subsystem color codes over the erasure channel using gaug e fixing,

    H. M. Solanki and P . K. Sarvepalli, “Decoding topologic al subsystem color codes over the erasure channel using gaug e fixing,” IEEE Transactions on Communications , vol. 71, no. 7, pp. 4181–4192, 2023

    2023

  22. [29]

    Correcting erasure s with topological subsystem color codes,

    H. M. Solanki and P . K. Sarvepalli, “Correcting erasure s with topological subsystem color codes,” in 2020 IEEE Information Theory W orkshop (ITW), pp. 1–5, IEEE, 2021

    2020

  23. [30]

    Cluster decompo sition for improved erasure decoding of quantum ldpc codes,

    H. Y ao, M. G¨ okduman, and H. D. Pfister, “Cluster decompo sition for improved erasure decoding of quantum ldpc codes, ” arXiv preprint arXiv:2412.08817, 2024

    2024 arXiv

  24. [31]

    Degenerate quantum erasure de coding,

    K.-Y . Kuo and Y . Ouyang, “Degenerate quantum erasure de coding,” arXiv preprint arXiv:2411.13509 , 2024

    2024 arXiv

  25. [32]

    Erasure decodin g for quantum ldpc codes via belief propagation with guided d ecimation,

    M. G¨ okduman, H. Y ao, and H. D. Pfister, “Erasure decodin g for quantum ldpc codes via belief propagation with guided d ecimation,” in 2024 60th Annual Allerton Conference on Communication, Con trol, and Computing , pp. 1–8, IEEE, 2024

    2024

  26. [33]

    Optimizin g hypergraph product codes with random walks, simulated ann ealing and reinforcement learning,

    B. C. Freire, N. Delfosse, and A. Leverrier, “Optimizin g hypergraph product codes with random walks, simulated ann ealing and reinforcement learning,” arXiv preprint arXiv:2501.09622 , 2025

    2025 arXiv

  27. [34]

    Efficient encoding o f low-density parity-check codes,

    T. J. Richardson and R. L. Urbanke, “Efficient encoding o f low-density parity-check codes,” IEEE transactions on information theory , vol. 47, no. 2, pp. 638–656, 2001

    2001

  28. [35]

    Good quantum error-cor recting codes exist,

    A. R. Calderbank and P . W. Shor, “Good quantum error-cor recting codes exist,” Physical Review A , vol. 54, no. 2, p. 1098, 1996

    1996

  29. [36]

    Error correcting codes in quantum theory ,

    A. M. Steane, “Error correcting codes in quantum theory ,” Physical Review Letters , vol. 77, no. 5, p. 793, 1996

    1996

  30. [38]

    Efficient erasure correcting codes,

    M. G. Luby, M. Mitzenmacher, M. A. Shokrollahi, and D. A. Spielman, “Efficient erasure correcting codes,” IEEE Transactions on Information Theory , vol. 47, no. 2, pp. 569–584, 2001

    2001

  31. [39]

    Low-density parity-check codes,

    R. Gallager, “Low-density parity-check codes,” IRE Transactions on information theory , vol. 8, no. 1, pp. 21–28, 1962

    1962

  32. [40]

    Grospellier, Constant time decoding of quantum expander codes and applic ation to fault-tolerant quantum computation

    A. Grospellier, Constant time decoding of quantum expander codes and applic ation to fault-tolerant quantum computation . PhD thesis, Sorbonne Universit´ e, 2019

    2019

  33. [41]

    F ast erasure decoder for a class of quantum ldpc codes,

    N. Connolly, V . Londe, A. Leverrier, and N. Delfosse, “F ast erasure decoder for a class of quantum ldpc codes,”

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.