
@article{huang_improved_2023,
	title = {Improved {Noisy} {Syndrome} {Decoding} of {Quantum} {LDPC} {Codes} with {Sliding} {Window}},
	url = {http://arxiv.org/abs/2311.03307},
	doi = {10.48550/arXiv.2311.03307},
	abstract = {Quantum error correction (QEC) with single-shot decoding enables reduction of errors after every single round of noisy stabilizer measurement, easing the time-overhead requirements for fault tolerance. Notably, several classes of quantum low-density-parity-check (qLDPC) codes are known which facilitate single-shot decoding, potentially giving them an additional overhead advantage. However, the perceived advantage of single-shot decoding is limited because it can significantly degrade the effective code distance. This degradation may be compensated for by using a much larger code size to achieve the desired target logical error rate, at the cost of increasing the amount of syndrome information to be processed, as well as, increasing complexity of logical operations. Alternatively, in this work we study sliding-window decoding, which corrects errors from previous syndrome measurement rounds while leaving the most recent errors for future correction. We observe that sliding-window decoding significantly improves the logical memory lifetime and hence the effective distance compared to single-shot decoding on hypergraph-product codes and lifted-product codes. Remarkably, we find that this improvement may not cost a larger decoding complexity. Thus, the sliding-window strategy can be more desirable for fast and accurate decoding for fault-tolerant quantum computing with qLDPC codes.},
	urldate = {2025-12-15},
	publisher = {arXiv},
	author = {Huang, Shilin and Puri, Shruti},
	month = nov,
	year = {2023},
	note = {arXiv:2311.03307 [quant-ph]},
	keywords = {/unread, Quantum Physics, \#QEC, \#SWIND},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/2DQB5JWZ/Huang and Puri - 2023 - Improved Noisy Syndrome Decoding of Quantum LDPC Codes with Sliding Window.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/MUCKWCZV/2311.html:text/html},
}

@article{huang_increasing_2024,
	title = {Increasing memory lifetime of quantum low-density parity check codes with sliding-window noisy syndrome decoding},
	volume = {110},
	url = {https://link.aps.org/doi/10.1103/PhysRevA.110.012453},
	doi = {10.1103/PhysRevA.110.012453},
	abstract = {Quantum error correction (QEC) with single-shot decoding enables the reduction of errors after every single round of noisy stabilizer measurement, easing the time-overhead requirements for fault tolerance. Notably, several classes of quantum low-density parity check (qLDPC) codes are known which facilitate single-shot decoding, potentially giving them an additional overhead advantage. However, the perceived advantage of single-shot decoding is limited because it can significantly degrade the effective code distance. This degradation may be compensated for by using a much larger code size to achieve the desired target logical error rate, at the cost of increasing the amount of syndrome information to be processed, as well as increasing complexity of logical operations. Alternatively, in this paper we study sliding-window decoding, which corrects errors from previous syndrome measurement rounds while leaving the most recent errors for future correction. We observe that sliding-window decoding significantly improves the logical memory lifetime and hence the effective distance compared to single-shot decoding on hypergraph-product codes and lifted-product codes. Remarkably, we find that this improvement may not cost a larger decoding complexity. Thus, the sliding-window strategy can be more desirable for fast and accurate decoding for fault-tolerant quantum computing with qLDPC codes.},
	number = {1},
	urldate = {2025-12-15},
	journal = {Physical Review A},
	publisher = {American Physical Society},
	author = {Huang, Shilin and Puri, Shruti},
	month = jul,
	year = {2024},
	keywords = {/unread, \#QEC, \#SWIND},
	pages = {012453},
	file = {APS Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/G4IH5BUD/PhysRevA.110.html:text/html;Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/6C4MY2LV/Huang and Puri - 2024 - Increasing memory lifetime of quantum low-density parity check codes with sliding-window noisy syndr.pdf:application/pdf},
}

@article{xu_batched_2025,
	title = {Batched high-rate logical operations for quantum {LDPC} codes},
	url = {http://arxiv.org/abs/2510.06159},
	doi = {10.48550/arXiv.2510.06159},
	abstract = {High-rate quantum LDPC (qLDPC) codes reduce memory overhead by densely packing many logical qubits into a single block of physical qubits. Here we extend this concept to high-rate computation by constructing {\textbackslash}emph\{batched\} fault-tolerant operations that apply the same logical gate across many code blocks in parallel. By leveraging shared physical resources to execute many logical operations in parallel, these operations realize high rates in space-time and significantly reduce computational costs. For {\textbackslash}emph\{arbitrary\} CSS qLDPC codes, we build batched gadgets with {\textbackslash}emph\{constant space-time overhead\} (assuming fast classical computation) for (i) single-shot error correction, state preparation, and code surgeries (ii) code switching, and (iii) addressable Clifford gates. Using these batched gadgets we also construct parallel non-Clifford gates with low space-time cost. We outline principles for designing parallel quantum algorithms optimized for a batched architecture, and show in particular how lattice Hamiltonian dynamical simulations can be compiled efficiently. We also propose a near-term implementation using new self-dual Bivariate-Bicycle codes with high encoding rates (\${\textbackslash}sim 1/10\$), transversal Clifford gates, and global \$T\$ gates via parallel magic state cultivation, enabling Hamiltonian simulations with a lower space-time cost than analogous surface-code protocols and low-rate qLDPC protocols. These results open new paths toward scalable quantum computation via co-design of parallel quantum algorithms and high-rate fault-tolerant protocols.},
	urldate = {2025-12-15},
	publisher = {arXiv},
	author = {Xu, Qian and Zhou, Hengyun and Bluvstein, Dolev and Cain, Madelyn and Kalinowski, Marcin and Preskill, John and Lukin, Mikhail D. and Maskara, Nishad},
	month = oct,
	year = {2025},
	note = {arXiv:2510.06159 [quant-ph]},
	keywords = {/unread, Quantum Physics, \#QEC, \#SYNCODE},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/SRQ243RL/Xu et al. - 2025 - Batched high-rate logical operations for quantum LDPC codes.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/AZ2ZJUNR/2510.html:text/html},
}

@article{gidney_stability_2022,
	title = {Stability {Experiments}: {The} {Overlooked} {Dual} of {Memory} {Experiments}},
	volume = {6},
	issn = {2521-327X},
	shorttitle = {Stability {Experiments}},
	url = {http://arxiv.org/abs/2204.13834},
	doi = {10.22331/q-2022-08-24-786},
	abstract = {Topological quantum computations are built on a foundation of two basic tasks: preserving logical observables through time and moving logical observables through space. Memory experiments, which check how well logical observables are preserved through time, are a well established benchmark. Strangely, there is no corresponding well established benchmark for moving logical observables through space. This paper tries to fill that gap with "stability experiments", which check how well a quantum error correction system can determine the product of a large region of stabilizers. Stability experiments achieve this by testing on a region that is locally a normal code but globally has a known product of stabilizers.},
	urldate = {2025-12-09},
	journal = {Quantum},
	author = {Gidney, Craig},
	month = aug,
	year = {2022},
	note = {arXiv:2204.13834 [quant-ph]
TLDR: Stability experiments are tries to fill the gap with "stability experiments", which check how well a quantum error correction system can determine the product of a large region of stabilizers.},
	keywords = {/unread, Quantum Physics, \#QEC, \#IMPL},
	pages = {786},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/ZCQW86Q9/Gidney - 2022 - Stability Experiments The Overlooked Dual of Memory Experiments.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/TGDZZZ2V/2204.html:text/html},
}

@article{koutsioumpas_colour_2025,
	title = {Colour {Codes} {Reach} {Surface} {Code} {Performance} using {Vibe} {Decoding}},
	url = {http://arxiv.org/abs/2508.15743},
	doi = {10.48550/arXiv.2508.15743},
	abstract = {Two-dimensional quantum colour codes hold significant promise for quantum error correction, offering advantages such as planar connectivity and low overhead logical gates. Despite their theoretical appeal, the practical deployment of these codes faces challenges due to complex decoding requirements compared to surface codes. This paper introduces vibe decoding which, for the first time, brings colour code performance on par with the surface code under practical decoding. Our approach leverages an ensemble of belief propagation decoders - each executing a distinct serial message passing schedule - combined with localised statistics post-processing. We refer to this combined protocol as VibeLSD. The VibeLSD decoder is highly versatile: our numerical results show it outperforms all practical existing colour code decoders across various syndrome extraction schemes, noise models, and error rates. By estimating qubit footprints through quantum memory simulations, we show that colour codes can operate with overhead that is comparable to, and in some cases lower than, that of the surface code. This, combined with the fact that localised statistics decoding is a parallel algorithm, makes VibeLSD suitable for implementation on specialised hardware for real-time decoding. Our results establish the colour code as a practical architecture for near-term quantum hardware, providing improved compilation efficiency for both Clifford and non-Clifford gates without incurring additional qubit overhead relative to the surface code.},
	urldate = {2025-11-13},
	publisher = {arXiv},
	author = {Koutsioumpas, Stergios and Noszko, Tamas and Sayginel, Hasan and Webster, Mark and Roffe, Joschka},
	month = aug,
	year = {2025},
	note = {arXiv:2508.15743 [quant-ph]
TLDR: The results establish the colour code as a practical architecture for near-term quantum hardware, providing improved compilation efficiency for both Clifford and non-Clifford gates without incurring additional qubit overhead relative to the surface code.},
	keywords = {Computer Science - Information Theory, /s2, Quantum Physics, \#QEC},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/C4K3XG2S/Koutsioumpas et al. - 2025 - Colour Codes Reach Surface Code Performance using Vibe Decoding.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/76EXKH3S/2508.html:text/html},
}

@article{koutsioumpas_automorphism_2025,
	title = {Automorphism {Ensemble} {Decoding} of {Quantum} {LDPC} {Codes}},
	language = {en},
	author = {Koutsioumpas, Stergios and Sayginel, Hasan and Webster, Mark and Browne, Dan E},
	month = mar,
	year = {2025},
	keywords = {/s2, \#QEC},
	file = {PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/SHUGDAU8/Koutsioumpas et al. - Automorphism Ensemble Decoding of Quantum LDPC Codes.pdf:application/pdf},
}

@article{gottesman_heisenberg_1998,
	title = {The {Heisenberg} {Representation} of {Quantum} {Computers}},
	url = {http://arxiv.org/abs/quant-ph/9807006},
	doi = {10.48550/arXiv.quant-ph/9807006},
	abstract = {Since Shor's discovery of an algorithm to factor numbers on a quantum computer in polynomial time, quantum computation has become a subject of immense interest. Unfortunately, one of the key features of quantum computers - the difficulty of describing them on classical computers - also makes it difficult to describe and understand precisely what can be done with them. A formalism describing the evolution of operators rather than states has proven extremely fruitful in understanding an important class of quantum operations. States used in error correction and certain communication protocols can be described by their stabilizer, a group of tensor products of Pauli matrices. Even this simple group structure is sufficient to allow a rich range of quantum effects, although it falls short of the full power of quantum computation.},
	urldate = {2025-12-02},
	publisher = {arXiv},
	author = {Gottesman, Daniel},
	month = jul,
	year = {1998},
	note = {arXiv:quant-ph/9807006},
	keywords = {/unread, \#FND, Quantum Physics, \#QC},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/CLREP9JY/Gottesman - 1998 - The Heisenberg Representation of Quantum Computers.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/9YKEHCRR/9807006.html:text/html},
}

@article{gidney_stim_2021,
	title = {Stim: a fast stabilizer circuit simulator},
	volume = {5},
	shorttitle = {Stim},
	url = {https://quantum-journal.org/papers/q-2021-07-06-497/},
	doi = {10.22331/q-2021-07-06-497},
	abstract = {Craig Gidney,
Quantum 5, 497 (2021).
This paper presents “Stim", a fast simulator for quantum stabilizer circuits. The paper explains how Stim works and compares it to existing tools. With no foreknowledge, Stim can analyze a d…},
	language = {en-GB},
	urldate = {2025-12-01},
	journal = {Quantum},
	publisher = {Verein zur Förderung des Open Access Publizierens in den Quantenwissenschaften},
	author = {Gidney, Craig},
	month = jul,
	year = {2021},
	note = {TLDR: Stim is a fast simulator for quantum stabilizer circuits that improves the asymptotic complexity of deterministic measurement from quadratic to linear by tracking the inverse of the circuit’s stabilizer tableau.},
	keywords = {/s1, \#QEC, \#IMPL},
	pages = {497},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/BM6YATNB/Gidney - 2021 - Stim a fast stabilizer circuit simulator.pdf:application/pdf},
}

@phdthesis{higgott_practical_2024,
	type = {Doctoral},
	title = {Practical and {Efficient} {Quantum} {Error} {Correction}},
	copyright = {open},
	url = {https://discovery.ucl.ac.uk/id/eprint/10186408/},
	abstract = {Building a scalable quantum computer requires the use of quantum error correction, which protects components and quantum operations from noise and imperfections that would otherwise corrupt the computation. However, quantum error correcting codes add significant redundancy, with a large number of physical qubits used to encode each logical qubit. Furthermore, the control software used to operate a quantum error correcting code, called the decoder, must be fast enough to keep up with the hardware and accurate enough to identify which errors occurred with high probability.

In Part I of this thesis, we focus on methods for decoding topological quantum codes including the surface code, which currently forms the basis of many experimental efforts to build a quantum computer. We also introduce optimal local unitary circuits for encoding unknown states in surface codes. We present sparse blossom, a decoder which can process data fast enough to keep up with superconducting quantum computers in a regime of practical interest. We also introduce belief-matching, a computationally efficient decoder which has improved accuracy, and schedule-induced gauge fixing, a technique for decoding subsystem surface codes more effectively by improving the circuits used for their implementation.

In Part II we construct quantum error correcting codes derived from tilings of negatively curved surfaces. These constructions exploit properties of hyperbolic geometry to improve the encoding efficiency. By reducing the size of operators that must be measured, we find efficient parallelised quantum circuits implementing our constructions, which we show outperform the surface code for practical physical error rates.},
	language = {eng},
	urldate = {2025-11-26},
	school = {UCL (University College London)},
	author = {Higgott, Oscar},
	month = jan,
	year = {2024},
	note = {Publication Title: Doctoral thesis, UCL (University College London).},
	keywords = {/unread, \#QEC, \#DEM},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/7646XMBR/Higgott - 2024 - Practical and Efficient Quantum Error Correction.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/2BD9A2PU/10186408.html:text/html},
}

@misc{noauthor_css_2025,
	title = {{CSS} codes},
	url = {https://quantum.cloud.ibm.com/learning/en/courses/foundations-of-quantum-error-correction/quantum-code-constructions/quantum.cloud.ibm.com/learning/en/courses/foundations-of-quantum-error-correction/quantum-code-constructions/css-codes},
	abstract = {A free IBM course on quantum information and computation},
	language = {en},
	urldate = {2025-11-24},
	journal = {IBM Quantum Learning},
	month = nov,
	year = {2025},
	keywords = {/s2, \#FND, \#QEC},
	file = {Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/GQ57FT6B/css-codes.html:text/html},
}

@misc{gong_toward_2024,
	title = {Toward {Low}-latency {Iterative} {Decoding} of {QLDPC} {Codes} {Under} {Circuit}-{Level} {Noise}},
	url = {https://arxiv.org/abs/2403.18901v1},
	abstract = {We introduce a sliding window decoder based on belief propagation (BP) with guided decimation for the purposes of decoding quantum low-density parity-check codes in the presence of circuit-level noise. Windowed decoding keeps the decoding complexity reasonable when, as is typically the case, repeated rounds of syndrome extraction are required to decode. Within each window, we employ several rounds of BP with decimation of the variable node that we expect to be the most likely to flip in each round, Furthermore, we employ ensemble decoding to keep both decimation options (guesses) open in a small number of chosen rounds. We term the resulting decoder BP with guided decimation guessing (GDG). Applied to bivariate bicycle codes, GDG achieves a similar logical error rate as BP with an additional OSD post-processing stage (BP+OSD) and combination-sweep of order 10. For a window size of three syndrome cycles, a multi-threaded CPU implementation of GDG achieves a worst-case decoding latency of 3ms per window for the [[144,12,12]] code.},
	language = {en},
	urldate = {2025-11-24},
	journal = {arXiv.org},
	author = {Gong, Anqi and Cammerer, Sebastian and Renes, Joseph M.},
	month = mar,
	year = {2024},
	keywords = {/s2, \#QEC, \#SWIND},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/6NZRBE4U/Gong et al. - 2024 - Toward Low-latency Iterative Decoding of QLDPC Codes Under Circuit-Level Noise.pdf:application/pdf},
}

@article{miao_quaternary_2025,
	title = {Quaternary {Neural} {Belief} {Propagation} {Decoding} of {Quantum} {LDPC} {Codes} with {Overcomplete} {Check} {Matrices}},
	volume = {13},
	issn = {2169-3536},
	url = {http://arxiv.org/abs/2308.08208},
	doi = {10.1109/ACCESS.2025.3539475},
	abstract = {Quantum low-density parity-check (QLDPC) codes are promising candidates for error correction in quantum computers. One of the major challenges in implementing QLDPC codes in quantum computers is the lack of a universal decoder. In this work, we first propose to decode QLDPC codes with a belief propagation (BP) decoder operating on overcomplete check matrices. Then, we extend the neural BP (NBP) decoder, which was originally studied for suboptimal binary BP decoding of QLPDC codes, to quaternary BP decoders. Numerical simulation results demonstrate that both approaches as well as their combination yield a low-latency, high-performance decoder for several short to moderate length QLDPC codes.},
	urldate = {2025-10-28},
	journal = {IEEE Access},
	author = {Miao, Sisi and Schnerring, Alexander and Li, Haizheng and Schmalen, Laurent},
	month = feb,
	year = {2025},
	note = {arXiv:2308.08208 [quant-ph]
TLDR: This work proposes to decode QLDPC codes with a belief propagation (BP) decoder operating on overcomplete check matrices and extends the neural BP decoder, which was originally studied for suboptimal binary BP decoding of QLPDC codes, to quaternary BP decoders.},
	keywords = {Computer Science - Information Theory, Mathematics - Information Theory, /s1, Quantum Physics, \#QEC},
	pages = {25637--25649},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/SJXAPQ9Z/Miao et al. - 2025 - Quaternary Neural Belief Propagation Decoding of Quantum LDPC Codes with Overcomplete Check Matrices.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/ZVHBIEHR/2308.html:text/html},
}

@misc{tsouchlos_ccam_2024,
	title = {{CCAM} {Summary}},
	author = {Tsouchlos, Andreas},
	month = oct,
	year = {2024},
	keywords = {\#FND, /s1, \#CC},
	file = {PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/34JESQ2N/Tsouchlos - 2024 - CCAM Summary.pdf:application/pdf},
}

@article{kschischang_factor_2001,
	title = {Factor graphs and the sum-product algorithm},
	volume = {47},
	issn = {1557-9654},
	url = {https://ieeexplore.ieee.org/abstract/document/910572},
	doi = {10.1109/18.910572},
	abstract = {Algorithms that must deal with complicated global functions of many variables often exploit the manner in which the given functions factor as a product of "local" functions, each of which depends on a subset of the variables. Such a factorization can be visualized with a bipartite graph that we call a factor graph, In this tutorial paper, we present a generic message-passing algorithm, the sum-product algorithm, that operates in a factor graph. Following a single, simple computational rule, the sum-product algorithm computes-either exactly or approximately-various marginal functions derived from the global function. A wide variety of algorithms developed in artificial intelligence, signal processing, and digital communications can be derived as specific instances of the sum-product algorithm, including the forward/backward algorithm, the Viterbi algorithm, the iterative "turbo" decoding algorithm, Pearl's (1988) belief propagation algorithm for Bayesian networks, the Kalman filter, and certain fast Fourier transform (FFT) algorithms.},
	number = {2},
	urldate = {2025-11-24},
	journal = {IEEE Transactions on Information Theory},
	author = {Kschischang, F.R. and Frey, B.J. and Loeliger, H.-A.},
	month = feb,
	year = {2001},
	note = {TLDR: A generic message-passing algorithm, the sum-product algorithm, that operates in a factor graph, that computes-either exactly or approximately-various marginal functions derived from the global function.},
	keywords = {/unread, \#FND, \#CC, Graph theory},
	pages = {498--519},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/GZY6AD8A/Kschischang et al. - 2001 - Factor graphs and the sum-product algorithm.pdf:application/pdf},
}

@book{griffiths_introduction_1995,
	title = {Introduction to {Quantum} {Mechanics}},
	isbn = {0-13-124405-1},
	abstract = {Changes and additions to the new edition of this classic textbook include a new chapter on symmetries, new problems and examples, improved explanations, more numerical problems to be worked on a computer, new applications to solid state physics, and consolidated treatment of time-dependent potentials.},
	language = {en},
	publisher = {Prentice Hall},
	author = {Griffiths, David J.},
	year = {1995},
	keywords = {\#FND, \#MAT, \#QM},
	file = {PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/ZLP4S5EB/Griffiths and Schroeter - 2018 - Introduction to Quantum Mechanics.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/V7B6J8YI/990799CA07A83FC5312402AF6860311E.html:text/html},
}

@misc{bradley_tensor_2018,
	title = {The {Tensor} {Product}, {Demystified}},
	url = {https://www.math3ma.com/blog/the-tensor-product-demystified},
	urldate = {2025-11-11},
	author = {Bradley, Tai-Danae},
	month = nov,
	year = {2018},
	keywords = {\#FND, \#MAT},
	file = {Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/JWTQ4W7G/the-tensor-product-demystified.html:text/html},
}

@book{nielsen_quantum_2010,
	address = {Cambridge},
	title = {Quantum {Computation} and {Quantum} {Information}: 10th {Anniversary} {Edition}},
	isbn = {978-0-511-97666-7},
	shorttitle = {Quantum {Computation} and {Quantum} {Information}},
	url = {https://www.cambridge.org/highereducation/books/quantum-computation-and-quantum-information/01E10196D0A682A6AEFFEA52D53BE9AE},
	doi = {10.1017/CBO9780511976667},
	abstract = {One of the most cited books in physics of all time, Quantum Computation and Quantum Information remains the best textbook in this exciting field of science. This 10th anniversary edition includes an introduction from the authors setting the work in context. This comprehensive textbook describes such remarkable effects as fast quantum algorithms, quantum teleportation, quantum cryptography and quantum error-correction. Quantum mechanics and computer science are introduced before moving on to describe what a quantum computer is, how it can be used to solve problems faster than 'classical' computers and its real-world implementation. It concludes with an in-depth treatment of quantum information. Containing a wealth of figures and exercises, this well-known textbook is ideal for courses on the subject, and will interest beginning graduate students and researchers in physics, computer science, mathematics, and electrical engineering.},
	language = {en},
	urldate = {2025-10-28},
	publisher = {Cambridge University Press},
	author = {Nielsen, Michael A. and Chuang, Isaac L.},
	month = dec,
	year = {2010},
	note = {Publisher: Cambridge University Press},
	keywords = {\#FND, \#QEC, \#QM},
	file = {PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/2FGWZ5CC/Nielsen and Chuang - 2010 - Quantum Computation and Quantum Information 10th Anniversary Edition.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/RFPYY4AS/01E10196D0A682A6AEFFEA52D53BE9AE.html:text/html},
}

@article{geiselhart_automorphism_2021,
	title = {Automorphism {Ensemble} {Decoding} of {Reed}–{Muller} {Codes}},
	volume = {69},
	issn = {1558-0857},
	url = {https://ieeexplore.ieee.org/document/9492151},
	doi = {10.1109/TCOMM.2021.3098798},
	abstract = {Reed–Muller (RM) codes are known for their good maximum likelihood (ML) performance in the short block-length regime. Despite being one of the oldest classes of channel codes, finding a low complexity soft-input decoding scheme is still an open problem. In this work, we present a versatile decoding architecture for RM codes based on their rich automorphism group. The decoding algorithm can be seen as a generalization of multiple-bases belief propagation (MBBP) and may use any polar or RM decoder as constituent decoders. We provide extensive error-rate performance simulations for successive cancellation (SC)-, SC-list (SCL)- and belief propagation (BP)-based constituent decoders. We furthermore compare our results to existing decoding schemes and report a near-ML performance for the RM(3,7)-code (e.g., 0.04 dB away from the ML bound at BLER of 10−3) at a competitive computational cost. Moreover, we provide some insights into the automorphism subgroups of RM codes and SC decoding and, thereby, prove the theoretical limitations of this method with respect to polar codes.},
	number = {10},
	urldate = {2025-11-13},
	journal = {IEEE Transactions on Communications},
	author = {Geiselhart, Marvin and Elkelesh, Ahmed and Ebada, Moustafa and Cammerer, Sebastian and Brink, Stephan ten},
	month = jul,
	year = {2021},
	note = {TLDR: A versatile decoding architecture for RM codes based on their rich automorphism group is presented and the theoretical limitations of this method with respect to polar codes are proved.},
	keywords = {/unread, \#FND, Complexity theory, Encoding, Generators, Iterative decoding, \#QEC, Belief propagation, belief propagation decoding, code automorphisms, ensemble decoding, list decoding, Maximum likelihood decoding, polar codes, Polar codes, Reed-Muller Codes, successive cancellation decoding},
	pages = {6424--6438},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/KV3JR3MS/Geiselhart et al. - 2021 - Automorphism Ensemble Decoding of Reed–Muller Codes.pdf:application/pdf},
}

@article{derks_designing_2025,
	title = {Designing fault-tolerant circuits using detector error models},
	url = {http://arxiv.org/abs/2407.13826},
	doi = {10.48550/arXiv.2407.13826},
	abstract = {Quantum error-correcting codes, such as subspace, subsystem, and Floquet codes, are typically constructed within the stabilizer formalism, which does not fully capture the idea of fault-tolerance needed for practical quantum computing applications. In this work, we explore the remarkably powerful formalism of detector error models, which fully captures fault-tolerance at the circuit level. We introduce the detector error model formalism in a pedagogical manner and provide several examples. Additionally, we apply the formalism to three different levels of abstraction in the engineering cycle of fault-tolerant circuit designs: finding robust syndrome extraction circuits, identifying efficient measurement schedules, and constructing fault-tolerant procedures. We enhance the surface code's resistance to measurement errors, devise short measurement schedules for color codes, and implement a more efficient fault-tolerant method for measuring logical operators.},
	urldate = {2025-10-28},
	publisher = {arXiv},
	author = {Derks, Peter-Jan H. S. and Townsend-Teague, Alex and Burchards, Ansgar G. and Eisert, Jens},
	month = oct,
	year = {2025},
	note = {arXiv:2407.13826 [quant-ph]},
	keywords = {/s2, Quantum Physics, \#QEC, \#DEM},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/NLEMWTH8/Derks et al. - 2025 - Designing fault-tolerant circuits using detector error models.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/QEBN4FJT/2407.html:text/html},
}

@phdthesis{klinke_neural_2025,
	address = {Karlsruhe},
	type = {Bachelor's {Thesis}},
	title = {Neural {Belief} {Propagation} {Ensemble} {Decoding} of {Quantum} {LDPC} {Codes}},
	language = {English},
	school = {KIT},
	author = {Klinke, Jeremi},
	month = sep,
	year = {2025},
	keywords = {/s1, \#QEC},
	file = {PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/ENJG2F8D/Klinke - Neural Belief Propagation Ensemble Decoding of Quantum LDPC Codes.pdf:application/pdf},
}

@article{camps-moreno_toward_2024,
	title = {Toward {Quantum} {CSS}-{T} {Codes} from {Sparse} {Matrices}},
	url = {http://arxiv.org/abs/2406.00425},
	doi = {10.48550/arXiv.2406.00425},
	abstract = {CSS-T codes were recently introduced as quantum error-correcting codes that respect a transversal gate. A CSS-T code depends on a pair \$(C\_1, C\_2)\$ of binary linear codes \$C\_1\$ and \$C\_2\$ that satisfy certain conditions. We prove that \$C\_1\$ and \$C\_2\$ form a CSS-T pair if and only if \$C\_2 {\textbackslash}subset {\textbackslash}operatorname\{Hull\}(C\_1) {\textbackslash}cap {\textbackslash}operatorname\{Hull\}(C\_1{\textasciicircum}2)\$, where the hull of a code is the intersection of the code with its dual. We show that if \$(C\_1,C\_2)\$ is a CSS-T pair, and the code \$C\_2\$ is degenerated on \${\textbackslash}\{i{\textbackslash}\}\$, meaning that the \$i{\textasciicircum}\{th\}\$-entry is zero for all the elements in \$C\_2\$, then the pair of punctured codes \$(C\_1{\textbar}\_i,C\_2{\textbar}\_i)\$ is also a CSS-T pair. Finally, we provide Magma code based on our results and quasi-cyclic codes as a step toward finding quantum LDPC or LDGM CSS-T codes computationally.},
	urldate = {2025-11-13},
	publisher = {arXiv},
	author = {Camps-Moreno, Eduardo and López, Hiram H. and Matthews, Gretchen L. and McMillon, Emily},
	month = jun,
	year = {2024},
	note = {arXiv:2406.00425 [cs]},
	keywords = {/unread, Computer Science - Information Theory, \#QEC},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/C634YE7N/Camps-Moreno et al. - 2024 - Toward Quantum CSS-T Codes from Sparse Matrices.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/TD3KFLFZ/2406.html:text/html},
}

@article{roffe_quantum_2019,
	title = {Quantum error correction: an introductory guide},
	volume = {60},
	issn = {0010-7514},
	shorttitle = {Quantum error correction},
	url = {https://doi.org/10.1080/00107514.2019.1667078},
	doi = {10.1080/00107514.2019.1667078},
	abstract = {Quantum error correction protocols will play a central role in the realisation of quantum computing; the choice of error correction code will influence the full quantum computing stack, from the layout of qubits at the physical level to gate compilation strategies at the software level. As such, familiarity with quantum coding is an essential prerequisite for the understanding of current and future quantum computing architectures. In this review, we provide an introductory guide to the theory and implementation of quantum error correction codes. Where possible, fundamental concepts are described using the simplest examples of detection and correction codes, the working of which can be verified by hand. We outline the construction and operation of the surface code, the most widely pursued error correction protocol for experiment. Finally, we discuss issues that arise in the practical implementation of the surface code and other quantum error correction codes.},
	number = {3},
	urldate = {2025-11-04},
	journal = {Contemporary Physics},
	publisher = {Taylor \& Francis},
	author = {Roffe, Joschka},
	month = jul,
	year = {2019},
	note = {\_eprint: https://doi.org/10.1080/00107514.2019.1667078
TLDR: This review provides an introductory guide to the theory and implementation of quantum error correction codes, and outlines the construction and operation of the surface code, the most widely pursued error correction protocol for experiment.},
	keywords = {\#FND, /s1, \#QEC},
	pages = {226--245},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/DW4EYDQ8/Roffe - 2019 - Quantum error correction an introductory guide.pdf:application/pdf},
}

@article{gottesman_introduction_2009,
	title = {An {Introduction} to {Quantum} {Error} {Correction} and {Fault}-{Tolerant} {Quantum} {Computation}},
	url = {http://arxiv.org/abs/0904.2557},
	doi = {10.48550/arXiv.0904.2557},
	abstract = {Quantum states are very delicate, so it is likely some sort of quantum error correction will be necessary to build reliable quantum computers. The theory of quantum error-correcting codes has some close ties to and some striking differences from the theory of classical error-correcting codes. Many quantum codes can be described in terms of the stabilizer of the codewords. The stabilizer is a finite Abelian group, and allows a straightforward characterization of the error-correcting properties of the code. The stabilizer formalism for quantum codes also illustrates the relationships to classical coding theory, particularly classical codes over GF(4), the finite field with four elements. To build a quantum computer which behaves correctly in the presence of errors, we also need a theory of fault-tolerant quantum computation, instructing us how to perform quantum gates on qubits which are encoded in a quantum error-correcting code. The threshold theorem states that it is possible to create a quantum computer to perform an arbitrary quantum computation provided the error rate per physical gate or time step is below some constant threshold value.},
	urldate = {2025-11-06},
	publisher = {arXiv},
	author = {Gottesman, Daniel},
	month = apr,
	year = {2009},
	note = {arXiv:0904.2557 [quant-ph]},
	keywords = {\#FND, /s1, Quantum Physics, \#QEC},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/AGETMT4C/Gottesman - 2009 - An Introduction to Quantum Error Correction and Fault-Tolerant Quantum Computation.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/UHAPPP5S/0904.html:text/html},
}

@article{gottesman_theory_1998,
	title = {Theory of fault-tolerant quantum computation},
	volume = {57},
	url = {https://link.aps.org/doi/10.1103/PhysRevA.57.127},
	doi = {10.1103/PhysRevA.57.127},
	abstract = {In order to use quantum error-correcting codes to improve the performance of a quantum computer, it is necessary to be able to perform operations fault-tolerantly on encoded states. I present a theory of fault-tolerant operations on stabilizer codes based on symmetries of the code stabilizer. This allows a straightforward determination of which operations can be performed fault-tolerantly on a given code. I demonstrate that fault-tolerant universal computation is possible for any stabilizer code. I discuss a number of examples in more detail, including the five-quantum-bit code.},
	number = {1},
	urldate = {2025-11-06},
	journal = {Physical Review A},
	publisher = {American Physical Society},
	author = {Gottesman, Daniel},
	month = jan,
	year = {1998},
	note = {TLDR: It is demonstrated that fault-tolerant universal computation is possible for any stabilizer code, including the five-quantum-bit code.},
	keywords = {\#FND, /s1, \#QEC},
	pages = {127--137},
	file = {APS Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/BP7CHBIU/PhysRevA.57.html:text/html;Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/7E5TUIMN/Gottesman - 1998 - Theory of fault-tolerant quantum computation.pdf:application/pdf},
}

@article{calderbank_quantum_1997,
	title = {Quantum {Error} {Correction} via {Codes} over {GF}(4)},
	url = {http://arxiv.org/abs/quant-ph/9608006},
	doi = {10.48550/arXiv.quant-ph/9608006},
	abstract = {The problem of finding quantum error-correcting codes is transformed into the problem of finding additive codes over the field GF(4) which are self-orthogonal with respect to a certain trace inner product. Many new codes and new bounds are presented, as well as a table of upper and lower bounds on such codes of length up to 30 qubits.},
	urldate = {2025-11-05},
	publisher = {arXiv},
	author = {Calderbank, A. R. and Rains, E. M. and Shor, P. W. and Sloane, N. J. A.},
	month = sep,
	year = {1997},
	note = {arXiv:quant-ph/9608006},
	keywords = {\#FND, /s1, Quantum Physics, \#QEC},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/5IM4A6FA/Calderbank et al. - 1997 - Quantum Error Correction via Codes over GF(4).pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/LLQUFH76/9608006.html:text/html},
}

@article{gottesman_stabilizer_1997,
	title = {Stabilizer {Codes} and {Quantum} {Error} {Correction}},
	url = {http://arxiv.org/abs/quant-ph/9705052},
	doi = {10.48550/arXiv.quant-ph/9705052},
	abstract = {Controlling operational errors and decoherence is one of the major challenges facing the field of quantum computation and other attempts to create specified many-particle entangled states. The field of quantum error correction has developed to meet this challenge. A group-theoretical structure and associated subclass of quantum codes, the stabilizer codes, has proved particularly fruitful in producing codes and in understanding the structure of both specific codes and classes of codes. I will give an overview of the field of quantum error correction and the formalism of stabilizer codes. In the context of stabilizer codes, I will discuss a number of known codes, the capacity of a quantum channel, bounds on quantum codes, and fault-tolerant quantum computation.},
	urldate = {2025-11-06},
	publisher = {arXiv},
	author = {Gottesman, Daniel},
	month = may,
	year = {1997},
	note = {arXiv:quant-ph/9705052},
	keywords = {\#FND, /s1, Quantum Physics, \#QEC},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/JT582GBB/Gottesman - 1997 - Stabilizer Codes and Quantum Error Correction.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/5GCZHHTH/9705052.html:text/html},
}

@article{shor_fault-tolerant_1997,
	title = {Fault-tolerant quantum computation},
	url = {http://arxiv.org/abs/quant-ph/9605011},
	doi = {10.48550/arXiv.quant-ph/9605011},
	abstract = {Recently, it was realized that use of the properties of quantum mechanics might speed up certain computations dramatically. Interest in quantum computation has since been growing. One of the main difficulties of realizing quantum computation is that decoherence tends to destroy the information in a superposition of states in a quantum computer, thus making long computations impossible. A futher difficulty is that inaccuracies in quantum state transformations throughout the computation accumulate, rendering the output of long computations unreliable. It was previously known that a quantum circuit with t gates could tolerate O(1/t) amounts of inaccuracy and decoherence per gate. We show, for any quantum computation with t gates, how to build a polynomial size quantum circuit that can tolerate O(1/(log t){\textasciicircum}c) amounts of inaccuracy and decoherence per gate, for some constant c. We do this by showing how to compute using quantum error correcting codes. These codes were previously known to provide resistance to errors while storing and transmitting quantum data.},
	urldate = {2025-11-05},
	publisher = {arXiv},
	author = {Shor, Peter W.},
	month = mar,
	year = {1997},
	note = {arXiv:quant-ph/9605011},
	keywords = {\#FND, /s1, Quantum Physics, \#QEC},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/CSLTPZU5/Shor - 1997 - Fault-tolerant quantum computation.pdf:application/pdf},
}

@article{divincenzo_fault-tolerant_1996,
	title = {Fault-{Tolerant} {Error} {Correction} with {Efficient} {Quantum} {Codes}},
	volume = {77},
	issn = {0031-9007, 1079-7114},
	url = {http://arxiv.org/abs/quant-ph/9605031},
	doi = {10.1103/PhysRevLett.77.3260},
	abstract = {We exhibit a simple, systematic procedure for detecting and correcting errors using any of the recently reported quantum error-correcting codes. The procedure is shown explicitly for a code in which one qubit is mapped into five. The quantum networks obtained are fault tolerant, that is, they can function successfully even if errors occur during the error correction. Our construction is derived using a recently introduced group-theoretic framework for unifying all known quantum codes.},
	number = {15},
	urldate = {2025-11-05},
	journal = {Physical Review Letters},
	author = {DiVincenzo, David P. and Shor, Peter W.},
	month = oct,
	year = {1996},
	note = {arXiv:quant-ph/9605031
TLDR: This work exhibits a simple, systematic procedure for detecting and correcting errors using any of the recently reported quantum error-correcting codes, derived using a recently introduced group-theoretic framework for unifying all known quantum codes.},
	keywords = {/unread, \#FND, Quantum Physics, \#QEC},
	pages = {3260--3263},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/KNGHIXB3/DiVincenzo and Shor - 1996 - Fault-Tolerant Error Correction with Efficient Quantum Codes.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/6JURUG3K/9605031.html:text/html},
}

@article{calderbank_good_1996,
	title = {Good quantum error-correcting codes exist},
	volume = {54},
	url = {https://link.aps.org/doi/10.1103/PhysRevA.54.1098},
	doi = {10.1103/PhysRevA.54.1098},
	abstract = {A quantum error-correcting code is defined to be a unitary mapping (encoding) of k qubits (two-state quantum systems) into a subspace of the quantum state space of n qubits such that if any t of the qubits undergo arbitrary decoherence, not necessarily independently, the resulting n qubits can be used to faithfully reconstruct the original quantum state of the k encoded qubits. Quantum error-correcting codes are shown to exist with asymptotic rate k/n=1-2𝐻2(2t/n) where 𝐻2(p) is the binary entropy function -plog2p-(1-p)log2(1-p). Upper bounds on this asymptotic rate are given. © 1996 The American Physical Society.},
	number = {2},
	urldate = {2025-11-06},
	journal = {Physical Review A},
	publisher = {American Physical Society},
	author = {Calderbank, A. R. and Shor, Peter W.},
	month = aug,
	year = {1996},
	note = {TLDR: The techniques investigated in this paper can be extended so as to reduce the accuracy required for factorization of numbers large enough to be difficult on conventional computers appears to be closer to one part in billions.},
	keywords = {\#FND, /s1, \#QEC},
	pages = {1098--1105},
	file = {APS Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/IK4DH994/PhysRevA.54.html:text/html;Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/RLKB7SKX/Calderbank and Shor - 1996 - Good quantum error-correcting codes exist.pdf:application/pdf},
}

@article{shor_scheme_1995,
	title = {Scheme for reducing decoherence in quantum computer memory},
	volume = {52},
	copyright = {http://link.aps.org/licenses/aps-default-license},
	issn = {1050-2947, 1094-1622},
	url = {https://link.aps.org/doi/10.1103/PhysRevA.52.R2493},
	doi = {10.1103/PhysRevA.52.R2493},
	language = {en},
	number = {4},
	urldate = {2025-11-05},
	journal = {Physical Review A},
	author = {Shor, Peter W.},
	month = oct,
	year = {1995},
	note = {TLDR: In the mid-1990s, theorists devised methods to preserve the integrity of quantum bits{\textbackslash}char22\{\}techniques that may become the key to practical quantum computing on a large scale.},
	keywords = {/s2, \#FND, \#QEC},
	pages = {R2493--R2496},
	file = {PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/DG6QT7UX/Shor - 1995 - Scheme for reducing decoherence in quantum computer memory.pdf:application/pdf},
}

@article{terhal_quantum_2015,
	title = {Quantum {Error} {Correction} for {Quantum} {Memories}},
	volume = {87},
	issn = {0034-6861, 1539-0756},
	url = {http://arxiv.org/abs/1302.3428},
	doi = {10.1103/RevModPhys.87.307},
	abstract = {Active quantum error correction using qubit stabilizer codes has emerged as a promising, but experimentally challenging, engineering program for building a universal quantum computer. In this review we consider the formalism of qubit stabilizer and subsystem stabilizer codes and their possible use in protecting quantum information in a quantum memory. We review the theory of fault-tolerance and quantum error-correction, discuss examples of various codes and code constructions, the general quantum error correction conditions, the noise threshold, the special role played by Clifford gates and the route towards fault-tolerant universal quantum computation. The second part of the review is focused on providing an overview of quantum error correction using two-dimensional (topological) codes, in particular the surface code architecture. We discuss the complexity of decoding and the notion of passive or self-correcting quantum memories. The review does not focus on a particular technology but discusses topics that will be relevant for various quantum technologies.},
	number = {2},
	urldate = {2025-12-26},
	journal = {Reviews of Modern Physics},
	author = {Terhal, Barbara M.},
	month = apr,
	year = {2015},
	note = {arXiv:1302.3428 [quant-ph]},
	keywords = {/unread, Quantum Physics, \#QEC},
	pages = {307--346},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/8KI6W99Z/Terhal - 2015 - Quantum Error Correction for Quantum Memories.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/FDPBC552/1302.html:text/html},
}

@inproceedings{wohlin_guidelines_2014,
	address = {New York, NY, USA},
	series = {{EASE} '14},
	title = {Guidelines for snowballing in systematic literature studies and a replication in software engineering},
	isbn = {978-1-4503-2476-2},
	url = {https://doi.org/10.1145/2601248.2601268},
	doi = {10.1145/2601248.2601268},
	abstract = {Background: Systematic literature studies have become common in software engineering, and hence it is important to understand how to conduct them efficiently and reliably.Objective: This paper presents guidelines for conducting literature reviews using a snowballing approach, and they are illustrated and evaluated by replicating a published systematic literature review.Method: The guidelines are based on the experience from conducting several systematic literature reviews and experimenting with different approaches.Results: The guidelines for using snowballing as a way to search for relevant literature was successfully applied to a systematic literature review.Conclusions: It is concluded that using snowballing, as a first search strategy, may very well be a good alternative to the use of database searches.},
	urldate = {2025-12-26},
	booktitle = {Proceedings of the 18th {International} {Conference} on {Evaluation} and {Assessment} in {Software} {Engineering}},
	publisher = {Association for Computing Machinery},
	author = {Wohlin, Claes},
	month = may,
	year = {2014},
	note = {TLDR: It is concluded that using snowballing, as a first search strategy, may very well be a good alternative to the use of database searches.},
	keywords = {/s1, \#REV},
	pages = {1--10},
	file = {Full Text:/home/andreas/workspace/work/hiwi/Zotero/storage/UPIYTM3I/Wohlin - 2014 - Guidelines for snowballing in systematic literature studies and a replication in software engineerin.pdf:application/pdf},
}

@article{keshav_how_2007,
	title = {How to read a paper},
	volume = {37},
	issn = {0146-4833},
	url = {https://doi.org/10.1145/1273445.1273458},
	doi = {10.1145/1273445.1273458},
	abstract = {Researchers spend a great deal of time reading research papers. However, this skill is rarely taught, leading to much wasted effort. This article outlines a practical and efficient three-pass method for reading research papers. I also describe how to use this method to do a literature survey.},
	number = {3},
	urldate = {2025-12-26},
	journal = {SIGCOMM Comput. Commun. Rev.},
	author = {Keshav, S.},
	month = jul,
	year = {2007},
	note = {TLDR: This article outlines a practical and efficient three-pass method for reading research papers and describes how to use this method to do a literature survey.},
	keywords = {/s1, \#REV},
	pages = {83--84},
	file = {PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/X6A998BW/Keshav - 2007 - How to read a paper.pdf:application/pdf},
}

@article{blume-kohout_estimating_2025,
	title = {Estimating detector error models from syndrome data},
	url = {http://arxiv.org/abs/2504.14643},
	doi = {10.48550/arXiv.2504.14643},
	abstract = {Protecting quantum information using quantum error correction (QEC) requires repeatedly measuring stabilizers to extract error syndromes that are used to identify and correct errors. Syndrome extraction data provides information about the processes that cause errors. The collective effects of these processes can be described by a detector error model (DEM). We show how to estimate probabilities of individual DEM events, and of aggregated classes of DEM events, using data from multiple cycles of syndrome extraction.},
	urldate = {2025-12-26},
	publisher = {arXiv},
	author = {Blume-Kohout, Robin and Young, Kevin},
	month = apr,
	year = {2025},
	note = {arXiv:2504.14643 [quant-ph]},
	keywords = {/unread, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/36QM2XPP/Blume-Kohout and Young - 2025 - Estimating detector error models from syndrome data.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/BUGIN4MC/2504.html:text/html},
}

@inproceedings{chatterjee_quantum_2023,
	title = {Quantum {Error} {Correction} {For} {Dummies}},
	volume = {01},
	url = {https://ieeexplore.ieee.org/abstract/document/10313604},
	doi = {10.1109/QCE57702.2023.00017},
	abstract = {In the current Noisy Intermediate Scale Quantum (NISQ) era of quantum computing, qubit technologies are prone to imperfections, giving rise to various errors such as gate errors, decoherence/dephasing, measurement errors, leakage, and crosstalk. These errors present challenges in achieving error-free computation within NISQ devices. A proposed solution to this issue is Quantum Error Correction (QEC), which aims to rectify the corrupted qubit state through a three-step process: (i) detection: identifying the presence of an error, (ii) decoding: pinpointing the location(s) of the affected qubit(s), and (iii) correction: restoring the faulty qubits to their original states. QEC is an expanding field of research that encompasses intricate concepts. In this paper, we aim to provide a comprehensive review of the historical context, current state, and future prospects of Quantum Error Correction, tailored to cater to computer scientists with limited familiarity with quantum physics and its associated mathematical concepts. In this work, we, (a) explain the foundational principles of QEC and explore existing Quantum Error Correction Codes (QECC) designed to correct errors in qubits, (b) explore the practicality of these QECCs with regard to implementation and error correction quality, and (c) highlight the challenges associated with implementing QEC within the context of the current landscape of NISQ computers.},
	urldate = {2025-12-27},
	booktitle = {2023 {IEEE} {International} {Conference} on {Quantum} {Computing} and {Engineering} ({QCE})},
	author = {Chatterjee, Avimita and Phalak, Koustubh and Ghosh, Swaroop},
	month = sep,
	year = {2023},
	note = {TLDR: A comprehensive review of the historical context, current state, and future prospects of Quantum Error Correction is provided, tailored to cater to computer scientists with limited familiarity with quantum physics and its associated mathematical concepts.},
	keywords = {/unread, Encoding, Error correction codes, Quantum computing, Logic gates, Fault diagnosis, Mathematics, Measurement errors, Quantum error correction, Qubit, Repetition codes, Topological codes},
	pages = {70--81},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/L959ZKSX/Chatterjee et al. - 2023 - Quantum Error Correction For Dummies.pdf:application/pdf},
}

@inproceedings{petersen_systematic_2008,
	title = {Systematic {Mapping} {Studies} in {Software} {Engineering}},
	url = {https://www.scienceopen.com/hosted-document?doi=10.14236/ewic/EASE2008.8},
	doi = {10.14236/ewic/EASE2008.8},
	abstract = {BACKGROUND: A software engineering systematic map is a defined method to build a classification scheme and structure a software engineering field of interest. The analysis of results focuses on frequencies of publications for categories within the scheme. Thereby, the coverage of the research field can be determined. Different facets of the scheme can also be combined to answer more specific research questions. OBJECTIVE: We describe how to conduct a systematic mapping study in software engineering and provide guidelines. We also compare systematic maps and systematic reviews to clarify how to chose between them. This comparison leads to a set of guidelines for systematic maps. METHOD: We have defined a systematic mapping process and applied it to complete a systematic mapping study. Furthermore, we compare systematic maps with systematic reviews by systematically analyzing existing systematic reviews. RESULTS: We describe a process for software engineering systematic mapping studies and compare it to systematic reviews. Based on this, guidelines for conducting systematic maps are defined. CONCLUSIONS: Systematic maps and reviews are different in terms of goals, breadth, validity issues and implications. Thus, they should be used complementarily and require different methods (e.g., for analysis).},
	language = {en},
	urldate = {2025-12-27},
	publisher = {BCS Learning \& Development},
	author = {Petersen, Kai and Feldt, Robert and Mujtaba, Shahid and Mattsson, Michael},
	month = jun,
	year = {2008},
	note = {TLDR: This work describes how to conduct a systematic mapping study in software engineering and provides guidelines for conducting systematic maps, and compares systematic maps with systematic reviews by systematically analyzing existing systematic reviews.},
	keywords = {/s2, \#REV},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/7LWHV5W9/Petersen et al. - 2008 - Systematic Mapping Studies in Software Engineering.pdf:application/pdf},
}

@article{postler_demonstration_2024,
	title = {Demonstration of {Fault}-{Tolerant} {Steane} {Quantum} {Error} {Correction}},
	volume = {5},
	url = {https://link.aps.org/doi/10.1103/PRXQuantum.5.030326},
	doi = {10.1103/PRXQuantum.5.030326},
	abstract = {Encoding information redundantly using quantum error-correcting (QEC) codes allows one to overcome the inherent sensitivity to noise in quantum computers to ultimately achieve large-scale quantum computation. The Steane QEC method involves preparing an auxiliary logical qubit of the same QEC code as used for the data register. The data and auxiliary registers are then coupled with a logical controlled-not (cnot) gate, enabling a measurement of the auxiliary register to reveal the error syndrome. This study presents the implementation of multiple rounds of fault-tolerant (FT) Steane QEC on a trapped-ion quantum computer. Various QEC codes are employed and the results are compared to a previous experimental approach utilizing flag qubits. Our experimental findings show improved logical fidelities for Steane QEC and accompanying numerical simulations indicate an even larger performance advantage for quantum processors limited by entangling-gate errors. This establishes experimental Steane QEC as a competitive paradigm for FT quantum computing.},
	number = {3},
	urldate = {2025-12-27},
	journal = {PRX Quantum},
	publisher = {American Physical Society},
	author = {Postler, Lukas and Butt, Friederike and Pogorelov, Ivan and Marciniak, Christian D. and Heußen, Sascha and Blatt, Rainer and Schindler, Philipp and Rispler, Manuel and Müller, Markus and Monz, Thomas},
	month = aug,
	year = {2024},
	note = {TLDR: Improved logical fidelities for Steane QEC and accompanying numerical simulations indicate an even larger performance advantage for quantum processors limited by entangling-gate errors, establishing experimental Steane QEC as a competitive paradigm for FT quantum computing.},
	keywords = {/unread},
	pages = {030326},
	file = {APS Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/GFZH8CLQ/PRXQuantum.5.html:text/html;Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/6MKFACXT/Postler et al. - 2024 - Demonstration of Fault-Tolerant Steane Quantum Error Correction.pdf:application/pdf},
}

@article{cao_exact_2025,
	title = {Exact {Decoding} of {Quantum} {Error}-{Correcting} {Codes}},
	volume = {134},
	url = {https://link.aps.org/doi/10.1103/PhysRevLett.134.190603},
	doi = {10.1103/PhysRevLett.134.190603},
	abstract = {We study the exact maximum-likelihood decoding of quantum error-correcting codes. Our primary focus is on the repetition code under circuit-level noise, which serves as a fundamental basis for quantum error correction experiments and is the only code that has achieved large distances and extremely low error rates. We uncover that the repetition code under circuit-level noise has an exact solution and propose an optimal maximum-likelihood decoding algorithm called “planar.” This algorithm is based on the exact solution of the spin-glass partition function on planar graphs and has polynomial computational complexity. Through extensive numerical experiments, we demonstrate that our algorithm uncovers the exact threshold for depolarizing noise and realistic superconductor SI1000 noise. Furthermore, we apply our method to analyze data from recent quantum memory experiments conducted by Google Quantum AI, revealing that part of the error floor was attributed to the decoding algorithm used by Google. Finally, we implemented the repetition code quantum memory on superconducting systems using a 72-qubit quantum chip lacking reset gates, demonstrating that even with an unknown error model, the proposed algorithm achieves a significantly lower logical error rate than the matching-based algorithm. We also discuss the application of our approach to quantum codes whose maximum-likelihood decoding problem corresponds to a spin-glass problem, including the surface code under independent code-capacity noise.},
	number = {19},
	urldate = {2025-12-27},
	journal = {Physical Review Letters},
	publisher = {American Physical Society},
	author = {Cao, Hanyan and Zhao, Shoukuan and Feng, Dongyang and Shen, Zisong and Yan, Haisheng and Su, Tang and Sun, Weijie and Xu, Huikai and Pan, Feng and Yu, Haifeng and Zhang, Pan},
	month = may,
	year = {2025},
	keywords = {/unread},
	pages = {190603},
	file = {APS Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/I4HTCUMA/PhysRevLett.134.html:text/html;PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/IE7RSASR/Cao et al. - 2025 - Exact Decoding of Quantum Error-Correcting Codes.pdf:application/pdf},
}

@misc{beni_tesseract_2025,
	title = {Tesseract: {A} {Search}-{Based} {Decoder} for {Quantum} {Error} {Correction}},
	shorttitle = {Tesseract},
	url = {http://arxiv.org/abs/2503.10988},
	doi = {10.48550/arXiv.2503.10988},
	abstract = {Tesseract is a Most-Likely Error decoder designed for low-density-parity-check quantum error-correcting codes. Tesseract conducts a search through a graph on the set of all subsets of errors to find the lowest cost subset of errors consistent with the input syndrome. Although this graph is exponentially large, the search can be made efficient in practice for random errors using \$A{\textasciicircum}*\$ search technique along with a few pruning heuristics. We show through benchmark circuits for surface, color, and bivariate-bicycle codes that Tesseract is significantly faster than integer programming-based decoders while retaining comparable accuracy at moderate physical error rates. We also find that Tesseract can decode transversal CNOT protocols for surface codes on neutral atom quantum computers. Finally, we compare surface code and bivariate bicycle code circuits, finding that the [[144,12,12]] bivariate bicycle code is \$14{\textbackslash}times\$ to \$19{\textbackslash}times\$ more efficient than surface codes using our most-likely error decoding, whereas using correlated matching and BP+OSD decoders would have implied only a \$10{\textbackslash}times\$ improvement. Assuming instead that long-range couplers are \$10{\textbackslash}times\$ noisier, the improvement drops to around \$4{\textbackslash}times\$ using Tesseract or \$2{\textbackslash}times\$ using correlated matching and BP+OSD.},
	urldate = {2025-12-27},
	publisher = {arXiv},
	author = {Beni, Laleh Aghababaie and Higgott, Oscar and Shutty, Noah},
	month = aug,
	year = {2025},
	note = {arXiv:2503.10988 [quant-ph]},
	keywords = {/unread, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/GFFLQ3JR/Beni et al. - 2025 - Tesseract A Search-Based Decoder for Quantum Error Correction.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/6CB2JL9K/2503.html:text/html},
}

@article{bausch_learning_2024,
	title = {Learning high-accuracy error decoding for quantum processors},
	volume = {635},
	copyright = {2024 The Author(s)},
	issn = {1476-4687},
	url = {https://www.nature.com/articles/s41586-024-08148-8},
	doi = {10.1038/s41586-024-08148-8},
	abstract = {Building a large-scale quantum computer requires effective strategies to correct errors that inevitably arise in physical quantum systems1. Quantum error-correction codes2 present a way to reach this goal by encoding logical information redundantly into many physical qubits. A key challenge in implementing such codes is accurately decoding noisy syndrome information extracted from redundancy checks to obtain the correct encoded logical information. Here we develop a recurrent, transformer-based neural network that learns to decode the surface code, the leading quantum error-correction code3. Our decoder outperforms other state-of-the-art decoders on real-world data from Google’s Sycamore quantum processor for distance-3 and distance-5 surface codes4. On distances up to 11, the decoder maintains its advantage on simulated data with realistic noise including cross-talk and leakage, utilizing soft readouts and leakage information. After training on approximate synthetic data, the decoder adapts to the more complex, but unknown, underlying error distribution by training on a limited budget of experimental samples. Our work illustrates the ability of machine learning to go beyond human-designed algorithms by learning from data directly, highlighting machine learning as a strong contender for decoding in quantum computers.},
	language = {en},
	number = {8040},
	urldate = {2025-12-27},
	journal = {Nature},
	publisher = {Nature Publishing Group},
	author = {Bausch, Johannes and Senior, Andrew W. and Heras, Francisco J. H. and Edlich, Thomas and Davies, Alex and Newman, Michael and Jones, Cody and Satzinger, Kevin and Niu, Murphy Yuezhen and Blackwell, Sam and Holland, George and Kafri, Dvir and Atalaya, Juan and Gidney, Craig and Hassabis, Demis and Boixo, Sergio and Neven, Hartmut and Kohli, Pushmeet},
	month = nov,
	year = {2024},
	note = {TLDR: A recurrent, transformer-based neural network, called AlphaQubit, learns high-accuracy error decoding to suppress the errors that occur in quantum systems, opening the prospect of using neural-network decoders for real quantum hardware.},
	keywords = {/unread, Computational science, Information theory and computation, Qubits},
	pages = {834--840},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/CKGX9CSX/Bausch et al. - 2024 - Learning high-accuracy error decoding for quantum processors.pdf:application/pdf},
}

@misc{bhardwaj_adaptive_2025,
	title = {Adaptive {Estimation} of {Drifting} {Noise} in {Quantum} {Error} {Correction}},
	url = {http://arxiv.org/abs/2511.09491},
	doi = {10.48550/arXiv.2511.09491},
	abstract = {Advancing quantum information processors and building fault-tolerant architectures rely on the ability to accurately characterize the noise sources and suppress their impact on quantum devices. In practice, noise often drifts over time, whereas conventional noise characterization and decoding methods typically assume stationarity or provide only a time-average behavior of the noise. This treatment can result in suboptimal decoding performance. In this work, we present a rigorous analytical framework to capture time-dependent Pauli noise, by exploiting the syndrome statistics of quantum error correction experiments. We propose a sliding-window estimation method which allows us to recover the frequency components of the noise, by using optimal window sizes that we derive analytically. We prove the noise-filtering behavior of sliding windows, linking window size to spectral cutoff frequencies, and provide an iterative algorithm that captures multiple drift frequencies. We further introduce an overlapping window algorithm that enables us to capture rapid multi-frequency noise drifts in a single-pass fashion. Simulations for both phenomenological and circuit-level noise models validate our framework, demonstrating robust tracking of multi-frequency drift. The logical error rate obtained from our estimated models consistently align with the ground-truth logical error rate, and we find suppression of logical errors compared to static error models. Our window-based estimation methods and adaptive decoding offer new insights into noise spectroscopy and decoder optimization under drift using only syndrome data.},
	urldate = {2025-12-27},
	publisher = {arXiv},
	author = {Bhardwaj, Devansh and Takou, Evangelia and Lin, Yingjia and Brown, Kenneth R.},
	month = nov,
	year = {2025},
	note = {arXiv:2511.09491 [quant-ph]},
	keywords = {/unread, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/4WH5A5T4/Bhardwaj et al. - 2025 - Adaptive Estimation of Drifting Noise in Quantum Error Correction.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/C926WVVE/2511.html:text/html},
}

@article{roffe_decoding_2020,
	title = {Decoding across the quantum low-density parity-check code landscape},
	volume = {2},
	url = {https://link.aps.org/doi/10.1103/PhysRevResearch.2.043423},
	doi = {10.1103/PhysRevResearch.2.043423},
	abstract = {We show that belief propagation combined with ordered statistics post-processing is a general decoder for quantum low-density parity-check codes constructed from the hypergraph product. To this end, we run numerical simulations of the decoder applied to three families of hypergraph product code: topological codes, fixed-rate random codes, and a new class of codes that we call semitopological codes. Our new code families share properties of both topological and random hypergraph product codes, with a construction that allows for a finely controlled trade-off between code threshold and stabilizer locality. Our results indicate thresholds across all three families of hypergraph product code, and provide evidence of exponential suppression in the low error regime. For the toric code, we observe a threshold in the range 9.9\%±0.2\%. This result improves upon previous quantum decoders based on belief propagation, and approaches the performance of the minimum-weight perfect-matching algorithm. We expect semitopological codes to have the same threshold as toric codes, as they are identical in the bulk, and we present numerical evidence supporting this observation.},
	number = {4},
	urldate = {2026-01-06},
	journal = {Physical Review Research},
	publisher = {American Physical Society},
	author = {Roffe, Joschka and White, David R. and Burton, Simon and Campbell, Earl},
	month = dec,
	year = {2020},
	keywords = {/unread},
	pages = {043423},
	file = {APS Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/MXQMI4S6/PhysRevResearch.2.html:text/html;Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/J7R8L8DC/Roffe et al. - 2020 - Decoding across the quantum low-density parity-check code landscape.pdf:application/pdf},
}

@article{marton_optimal_2025,
	title = {Optimal number of stabilizer measurement rounds in an idling surface code patch},
	volume = {9},
	url = {https://quantum-journal.org/papers/q-2025-06-12-1767/},
	doi = {10.22331/q-2025-06-12-1767},
	abstract = {Áron Márton and János K. Asbóth,
Quantum 9, 1767 (2025).
Logical qubits can be protected against environmental noise by encoding them into a highly entangled state of many physical qubits and actively intervening in the dynamics with stabilizer me…},
	language = {en-GB},
	urldate = {2026-01-06},
	journal = {Quantum},
	publisher = {Verein zur Förderung des Open Access Publizierens in den Quantenwissenschaften},
	author = {Márton, Áron and Asbóth, János K.},
	month = jun,
	year = {2025},
	keywords = {/unread},
	pages = {1767},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/B8T5DH62/Márton and Asbóth - 2025 - Optimal number of stabilizer measurement rounds in an idling surface code patch.pdf:application/pdf},
}

@article{bausch_learning_2024-1,
	title = {Learning to {Decode} the {Surface} {Code} with a {Recurrent}, {Transformer}-{Based} {Neural} {Network}},
	volume = {635},
	issn = {0028-0836, 1476-4687},
	url = {http://arxiv.org/abs/2310.05900},
	doi = {10.1038/s41586-024-08148-8},
	abstract = {Quantum error-correction is a prerequisite for reliable quantum computation. Towards this goal, we present a recurrent, transformer-based neural network which learns to decode the surface code, the leading quantum error-correction code. Our decoder outperforms state-of-the-art algorithmic decoders on real-world data from Google's Sycamore quantum processor for distance 3 and 5 surface codes. On distances up to 11, the decoder maintains its advantage on simulated data with realistic noise including cross-talk, leakage, and analog readout signals, and sustains its accuracy far beyond the 25 cycles it was trained on. Our work illustrates the ability of machine learning to go beyond human-designed algorithms by learning from data directly, highlighting machine learning as a strong contender for decoding in quantum computers.},
	number = {8040},
	urldate = {2026-01-06},
	journal = {Nature},
	author = {Bausch, Johannes and Senior, Andrew W. and Heras, Francisco J. H. and Edlich, Thomas and Davies, Alex and Newman, Michael and Jones, Cody and Satzinger, Kevin and Niu, Murphy Yuezhen and Blackwell, Sam and Holland, George and Kafri, Dvir and Atalaya, Juan and Gidney, Craig and Hassabis, Demis and Boixo, Sergio and Neven, Hartmut and Kohli, Pushmeet},
	month = nov,
	year = {2024},
	note = {arXiv:2310.05900 [quant-ph]
TLDR: A recurrent, transformer-based neural network, called AlphaQubit, learns high-accuracy error decoding to suppress the errors that occur in quantum systems, opening the prospect of using neural-network decoders for real quantum hardware.},
	keywords = {/unread, Computer Science - Machine Learning, Quantum Physics},
	pages = {834--840},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/C3DD42GU/Bausch et al. - 2024 - Learning to Decode the Surface Code with a Recurrent, Transformer-Based Neural Network.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/ARYQMA25/2310.html:text/html},
}

@misc{lin_abelian_2025,
	title = {Abelian multi-cycle codes for single-shot error correction},
	url = {http://arxiv.org/abs/2506.16910},
	doi = {10.48550/arXiv.2506.16910},
	abstract = {We construct a family of quantum low-density parity-check codes locally equivalent to higher-dimensional quantum hypergraph-product (QHP) codes. Similarly to QHP codes, the proposed codes have highly redundant sets of low-weight stabilizer generators, which improves decoding accuracy in a fault-tolerant regime and gives them single-shot properties. The advantage of the new construction is that it gives shorter codes. We derive simple expressions for the dimension of the proposed codes in two important special cases, give bounds on the distances, and explicitly construct some relatively short codes. Circuit simulations for codes locally equivalent to 4-dimensional toric codes show a (pseudo)threshold close to 1.1\%, better than for toric or surface codes with a similar noise model.},
	urldate = {2026-01-06},
	publisher = {arXiv},
	author = {Lin, Hsiang-Ku and Lim, Pak Kau and Kovalev, Alexey A. and Pryadko, Leonid P.},
	month = aug,
	year = {2025},
	note = {arXiv:2506.16910 [quant-ph]},
	keywords = {/unread, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/DM4BKPJ8/Lin et al. - 2025 - Abelian multi-cycle codes for single-shot error correction.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/9Q3QIYK9/2506.html:text/html},
}

@misc{fan_accelerating_2025,
	title = {Accelerating {BP}-{OSD} {Decoder} for {QLDPC} {Codes} with {Local} {Syndrome}-{Based} {Preprocessing}},
	url = {http://arxiv.org/abs/2509.01892},
	doi = {10.48550/arXiv.2509.01892},
	abstract = {Due to the high error rate of qubits, detecting and correcting errors is essential for achieving fault-tolerant quantum computing (FTQC). Quantum low-density parity-check (QLDPC) codes are one of the most promising quantum error correction (QEC) methods due to their high encoding rates. Belief Propagation-Ordered Statistics Decoding (BP-OSD) is the state-of-the-art decoder for QLDPC codes, but it suffers from high decoding latency. We find from experiments that a large portion of this latency originates from the iterative BP stage, making BP runtime reduction a key optimization target. In this paper, we propose a lightweight preprocessing step that utilizes local syndrome patterns to detect likely trivial error events and feed them as hints into BP-OSD. These hints reduce the number of BP iterations and the overall decoding time. On Bivariate Bicycle codes, the proposed method achieves more than an 80\% reduction in BP iterations and total decoding time for the \$[[144,12,12]]\$ code at a physical error rate of 0.05\%, while maintaining the original logical error rate of BP-OSD.},
	urldate = {2026-01-06},
	publisher = {arXiv},
	author = {Fan, Wenxuan and Suzuki, Yasunari and Ravi, Gokul Subramanian and Ueno, Yosuke and Inoue, Koji and Tanimoto, Teruo},
	month = sep,
	year = {2025},
	note = {arXiv:2509.01892 [quant-ph]},
	keywords = {/unread, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/T4NVJNTA/Fan et al. - 2025 - Accelerating BP-OSD Decoder for QLDPC Codes with Local Syndrome-Based Preprocessing.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/M6UZENUW/2509.html:text/html},
}

@misc{senior_scalable_2025,
	title = {A scalable and real-time neural decoder for topological quantum codes},
	url = {http://arxiv.org/abs/2512.07737},
	doi = {10.48550/arXiv.2512.07737},
	abstract = {Fault-tolerant quantum computing will require error rates far below those achievable with physical qubits. Quantum error correction (QEC) bridges this gap, but depends on decoders being simultaneously fast, accurate, and scalable. This combination of requirements has not yet been met by a machine-learning decoder, nor by any decoder for promising resource-efficient codes such as the colour code. Here we introduce AlphaQubit 2, a neural-network decoder that achieves near-optimal logical error rates for both surface and colour codes at large scales under realistic noise. For the colour code, it is orders of magnitude faster than other high-accuracy decoders. For the surface code, we demonstrate real-time decoding faster than 1 microsecond per cycle up to distance 11 on current commercial accelerators with better accuracy than leading real-time decoders. These results support the practical application of a wider class of promising QEC codes, and establish a credible path towards high-accuracy, real-time neural decoding at the scales required for fault-tolerant quantum computation.},
	urldate = {2026-01-06},
	publisher = {arXiv},
	author = {Senior, Andrew W. and Edlich, Thomas and Heras, Francisco J. H. and Zhang, Lei M. and Higgott, Oscar and Spencer, James S. and Applebaum, Taylor and Blackwell, Sam and Ledford, Justin and Žemgulytė, Akvilė and Žídek, Augustin and Shutty, Noah and Cowie, Andrew and Li, Yin and Holland, George and Brooks, Peter and Beattie, Charlie and Newman, Michael and Davies, Alex and Jones, Cody and Boixo, Sergio and Neven, Hartmut and Kohli, Pushmeet and Bausch, Johannes},
	month = dec,
	year = {2025},
	note = {arXiv:2512.07737 [quant-ph]},
	keywords = {/unread, Computer Science - Machine Learning, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/9RIBP938/Senior et al. - 2025 - A scalable and real-time neural decoder for topological quantum codes.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/W3UIHVW5/2512.html:text/html},
}

@misc{wang_fully_2025,
	title = {Fully {Parallelized} {BP} {Decoding} for {Quantum} {LDPC} {Codes} {Can} {Outperform} {BP}-{OSD}},
	url = {https://arxiv.org/abs/2507.00254v2},
	abstract = {In this work, we propose a lightweight decoder based solely on belief-propagation (BP), augmented with a speculative post-processing strategy inspired by classical Chase decoding. Our method identifies unreliable bits via BP oscillation statistics, generates a set of modified test patterns, and decodes them in parallel using low-iteration BP. We demonstrate that our approach can achieve logical error rates comparable to or even better than BP-OSD, but has lower latency over its parallelization for a variety of bivariate bicycle codes, which significantly reduces decoding complexity.},
	language = {en},
	urldate = {2026-01-06},
	author = {Wang, Ming and Li, Ang and Mueller, Frank},
	month = jun,
	year = {2025},
	keywords = {/unread},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/6BUB9JLT/Wang et al. - 2025 - Fully Parallelized BP Decoding for Quantum LDPC Codes Can Outperform BP-OSD.pdf:application/pdf},
}

@misc{ye_beam_2025,
	title = {Beam search decoder for quantum {LDPC} codes},
	url = {https://arxiv.org/abs/2512.07057v2},
	abstract = {We propose a decoder for quantum low density parity check (LDPC) codes based on a beam search heuristic guided by belief propagation (BP). Our beam search decoder applies to all quantum LDPC codes and achieves different speed-accuracy tradeoffs by tuning its parameters such as the beam width. We perform numerical simulations under circuit level noise for the \$[[144, 12, 12]]\$ bivariate bicycle (BB) code at noise rate \$p=10{\textasciicircum}\{-3\}\$ to estimate the logical error rate and the 99.9 percentile runtime and we compare with the BP-OSD decoder which has been the default quantum LDPC decoder for the past six years. A variant of our beam search decoder with a beam width of 64 achieves a \$17{\textbackslash}times\$ reduction in logical error rate. With a beam width of 8, we reach the same logical error rate as BP-OSD with a \$26.2{\textbackslash}times\$ reduction in the 99.9 percentile runtime. We identify the beam search decoder with beam width of 32 as a promising candidate for trapped ion architectures because it achieves a \$5.6{\textbackslash}times\$ reduction in logical error rate with a 99.9 percentile runtime per syndrome extraction round below 1ms at \$p=5 {\textbackslash}times10{\textasciicircum}\{-4\}\$. Remarkably, this is achieved in software on a single core, without any parallelization or specialized hardware (FPGA, ASIC), suggesting one might only need three 32-core CPUs to decode a trapped ion quantum computer with 1000 logical qubits.},
	language = {en},
	urldate = {2026-01-06},
	author = {Ye, Min and Wecker, Dave and Delfosse, Nicolas},
	month = dec,
	year = {2025},
	keywords = {/unread},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/78GIFZYF/Ye et al. - 2025 - Beam search decoder for quantum LDPC codes.pdf:application/pdf},
}

@misc{hillmann_localized_2024,
	title = {Localized statistics decoding for quantum low-density parity-check codes},
	url = {https://arxiv.org/abs/2406.18655v2},
	doi = {10.1038/s41467-025-63214-7},
	abstract = {Quantum low-density parity-check codes are a promising candidate for fault-tolerant quantum computing with considerably reduced overhead compared to the surface code. However, the lack of a practical decoding algorithm remains a barrier to their implementation. In this work, we introduce localized statistics decoding, a reliability-guided inversion decoder that is highly parallelizable and applicable to arbitrary quantum low-density parity-check codes. Our approach employs a parallel matrix factorization strategy, which we call on-the-fly elimination, to identify, validate, and solve local decoding regions on the decoding graph. Through numerical simulations, we show that localized statistics decoding matches the performance of state-of-the-art decoders while reducing the runtime complexity for operation in the sub-threshold regime. Importantly, our decoder is more amenable to implementation on specialized hardware, positioning it as a promising candidate for decoding real-time syndromes from experiments.},
	language = {en},
	urldate = {2026-01-06},
	author = {Hillmann, Timo and Berent, Lucas and Quintavalle, Armanda O. and Eisert, Jens and Wille, Robert and Roffe, Joschka},
	month = jun,
	year = {2024},
	note = {TLDR: This work introduces localized statistics decoding, a reliability-guided inversion decoder that is highly parallelizable and applicable to arbitrary quantum low-density parity-check codes, and enables significantly improved scalability.},
	keywords = {/unread},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/LWUWZB8G/Hillmann et al. - 2024 - Localized statistics decoding for quantum low-density parity-check codes.pdf:application/pdf},
}

@misc{iolius_almost-linear_2024,
	title = {An almost-linear time decoding algorithm for quantum {LDPC} codes under circuit-level noise},
	url = {https://arxiv.org/abs/2409.01440v2},
	abstract = {Fault-tolerant quantum computers must be designed in conjunction with classical co-processors that decode quantum error correction measurement information in real-time. In this work, we introduce the belief propagation plus ordered Tanner forest (BP+OTF) algorithm as an almost-linear time decoder for quantum low-density parity-check codes. The OTF post-processing stage removes qubits from the decoding graph until it has a tree-like structure. Provided that the resultant loop-free OTF graph supports a subset of qubits that can generate the syndrome, BP decoding is then guaranteed to converge. To enhance performance under circuit-level noise, we introduce a technique for sparsifying detector error models. This method uses a transfer matrix to map soft information from the full detector graph to the sparsified graph, preserving critical error propagation information from the syndrome extraction circuit. Our BP+OTF implementation first applies standard BP to the full detector graph, followed by BP+OTF post-processing on the sparsified graph. Numerical simulations show that the BP+OTF decoder achieves similar logical error suppression compared to state-of-the-art inversion-based and matching decoders for bivariate bicycle and surface codes, respectively, while maintaining almost-linear runtime complexity across all stages.},
	language = {en},
	urldate = {2026-01-06},
	author = {iOlius, Antonio deMarti and Martinez, Imanol Etxezarreta and Roffe, Joschka and Martinez, Josu Etxezarreta},
	month = sep,
	year = {2024},
	keywords = {/unread},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/EIMNVIXR/iOlius et al. - 2024 - An almost-linear time decoding algorithm for quantum LDPC codes under circuit-level noise.pdf:application/pdf},
}

@article{higgott_improved_2023,
	title = {Improved {Decoding} of {Circuit} {Noise} and {Fragile} {Boundaries} of {Tailored} {Surface} {Codes}},
	volume = {13},
	url = {https://link.aps.org/doi/10.1103/PhysRevX.13.031007},
	doi = {10.1103/PhysRevX.13.031007},
	abstract = {Realizing the full potential of quantum computation requires quantum error correction (QEC), with most recent breakthrough demonstrations of QEC using the surface code. QEC codes use multiple noisy physical qubits to encode information in fewer logical qubits, enabling the identification of errors through a decoding process. This process increases the logical fidelity (or accuracy) making the computation more reliable. However, most fast (efficient run-time) decoders neglect important noise characteristics, thereby reducing their accuracy. In this work, we introduce decoders that are both fast and accurate, and can be used with a wide class of QEC codes including the surface code. Our decoders, named belief-matching and belief-find, exploit all noise information and thereby unlock higher accuracy demonstrations of QEC. Using the surface code threshold as a performance metric, we observe a threshold at 0.94\% error probability for our decoders, outperforming the 0.82\% threshold for a standard minimum-weight perfect matching decoder. We also test our belief-matching decoders in a theoretical case study of codes tailored to a biased noise model. We find that the decoders lead to a much higher threshold and lower qubit overhead in the tailored surface code with respect to the standard, square surface code. Surprisingly, in the well-below-threshold regime, the rectangular surface code becomes more resource efficient than the tailored surface code due to a previously unnoticed phenomenon that we call “fragile boundaries.” Our decoders outperform all other fast decoders in terms of threshold and accuracy, enabling better results in current quantum-error-correction experiments and opening up new areas for theoretical case studies.},
	number = {3},
	urldate = {2026-01-06},
	journal = {Physical Review X},
	publisher = {American Physical Society},
	author = {Higgott, Oscar and Bohdanowicz, Thomas C. and Kubica, Aleksander and Flammia, Steven T. and Campbell, Earl T.},
	month = jul,
	year = {2023},
	note = {TLDR: This work introduces decoders that are both fast and accurate, and can be used with a wide class of QEC codes including the surface code, and leads to a much higher threshold and lower qubit overhead in the tailored surface code with respect to the standard, square surface code.},
	keywords = {/unread},
	pages = {031007},
	file = {APS Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/9PUSMSJY/PhysRevX.13.html:text/html;Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/UGW5IM8M/Higgott et al. - 2023 - Improved Decoding of Circuit Noise and Fragile Boundaries of Tailored Surface Codes.pdf:application/pdf},
}

@misc{tsubouchi_degeneracy_2025,
	title = {Degeneracy {Cutting}: {A} {Local} and {Efficient} {Post}-{Processing} for {Belief} {Propagation} {Decoding} of {Quantum} {Low}-{Density} {Parity}-{Check} {Codes}},
	shorttitle = {Degeneracy {Cutting}},
	url = {http://arxiv.org/abs/2510.08695},
	doi = {10.48550/arXiv.2510.08695},
	abstract = {Quantum low-density parity-check (qLDPC) codes are promising for realizing scalable fault-tolerant quantum computation due to their potential for low-overhead protocols. A common approach to decoding qLDPC codes is to use the belief propagation (BP) decoder, followed by a post-processing step to enhance decoding accuracy. For real-time decoding, the post-processing algorithm is desirable to have a small computational cost and rely only on local operations on the Tanner graph to facilitate parallel implementation. To address this requirement, we propose degeneracy cutting (DC), an efficient post-processing technique for the BP decoder that operates on information restricted to the support of each stabilizer generator. DC selectively removes one variable node with the lowest error probability for each stabilizer generator, significantly improving decoding performance while retaining the favorable computational scaling and structure amenable to parallelization inherent to BP. We further extend our method to realistic noise models, including phenomenological and circuit-level noise models, by introducing the detector degeneracy matrix, which generalizes the notion of stabilizer-induced degeneracy to these settings. Numerical simulations demonstrate that BP+DC achieves decoding performance approaching that of BP followed by ordered statistics decoding (BP+OSD) in several settings, while requiring significantly less computational cost. Our results present BP+DC as a promising decoder for fault-tolerant quantum computing, offering a valuable balance of accuracy, efficiency, and suitability for parallel implementation.},
	urldate = {2026-01-06},
	publisher = {arXiv},
	author = {Tsubouchi, Kento and Yamasaki, Hayata and Tamiya, Shiro},
	month = oct,
	year = {2025},
	note = {arXiv:2510.08695 [quant-ph]},
	keywords = {/unread, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/U8Q3PZR8/Tsubouchi et al. - 2025 - Degeneracy Cutting A Local and Efficient Post-Processing for Belief Propagation Decoding of Quantum.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/DSTMXFB2/2510.html:text/html},
}

@misc{lee_scalable_2025,
	title = {Scalable {Neural} {Decoders} for {Practical} {Real}-{Time} {Quantum} {Error} {Correction}},
	url = {http://arxiv.org/abs/2510.22724},
	doi = {10.48550/arXiv.2510.22724},
	abstract = {Real-time, scalable, and accurate decoding is a critical component for realizing a fault-tolerant quantum computer. While Transformer-based neural decoders such as {\textbackslash}textit\{AlphaQubit\} have demonstrated high accuracy, the computational complexity of their core attention mechanism, which scales as \${\textbackslash}mathcal\{O\}(d{\textasciicircum}4)\$ with code distance \$d\$, results in decoding speeds insufficient for practical real-time applications. In this work, we introduce and evaluate a {\textbackslash}textit\{Mamba\}-based decoder, a state-space model with \${\textbackslash}mathcal\{O\}(d{\textasciicircum}2)\$ complexity. In memory experiments using Sycamore hardware data, our Mamba decoder matches the performance of its Transformer-based counterpart, providing that its superior efficiency does not come at the cost of performance. Crucially, in simulated real-time scenarios that account for decoder-induced noise, the Mamba decoder significantly outperforms the Transformer, exhibiting a higher error threshold of \$0.0104\$ compared to \$0.0097\$. These results demonstrate that Mamba decoders offer a compelling balance between speed and accuracy, making them a promising architecture for scalable, real-time quantum error correction.},
	urldate = {2026-01-06},
	publisher = {arXiv},
	author = {Lee, Changwon and Hur, Tak and Park, Daniel K.},
	month = oct,
	year = {2025},
	note = {arXiv:2510.22724 [quant-ph]
TLDR: In memory experiments using Sycamore hardware data, the Mamba decoder matches the performance of its Transformer-based counterpart, providing that its superior efficiency does not come at the cost of performance.},
	keywords = {/unread, Computer Science - Machine Learning, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/Q4X7WI9T/Lee et al. - 2025 - Scalable Neural Decoders for Practical Real-Time Quantum Error Correction.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/TPAMGPEX/2510.html:text/html},
}

@misc{maan_decoding_2025,
	title = {Decoding {Correlated} {Errors} in {Quantum} {LDPC} {Codes}},
	url = {http://arxiv.org/abs/2510.14060},
	doi = {10.48550/arXiv.2510.14060},
	abstract = {We introduce a decoding framework for correlated errors in quantum LDPC codes under circuit-level noise. The core of our approach is a graph augmentation and rewiring for interference (GARI) method, which modifies the correlated detector error model by eliminating 4-cycles involving Y-type errors, while preserving the equivalence of the decoding problem. We test our approach on the bivariate bicycle codes of distances 6, 10, and 12. A normalized min-sum decoder with a hybrid serial-layered schedule is applied on the transformed graph, achieving high accuracy with low latency. Performance is further enhanced through ensemble decoding, where 24 randomized normalized min-sum decoders run in parallel on the transformed graph, yielding the highest reported accuracy (on par with XYZ-Relay-BP) with unprecedented speed for the tested codes under uniform depolarizing circuit level noise. For the distance 12 (gross) code, our approach yields a logical error rate of \$(6.70 {\textbackslash}pm 1.93) {\textbackslash}times 10{\textasciicircum}\{-9\}\$ at a practical physical error rate of \$10{\textasciicircum}\{-3\}\$. Furthermore, preliminary FPGA implementation results show that such high accuracy can be achieved in real time, with a per-round average decoding latency of 273 ns and sub-microsecond latency in 99.99\% of the decoding instances.},
	urldate = {2026-01-06},
	publisher = {arXiv},
	author = {Maan, Arshpreet Singh and Herrero, Francisco-Garcia and Paler, Alexandru and Savin, Valentin},
	month = oct,
	year = {2025},
	note = {arXiv:2510.14060 [quant-ph]},
	keywords = {/unread, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/Y4VXMEQV/Maan et al. - 2025 - Decoding Correlated Errors in Quantum LDPC Codes.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/N8KGNW62/2510.html:text/html},
}

@article{skoric_parallel_2023,
	title = {Parallel window decoding enables scalable fault tolerant quantum computation},
	volume = {14},
	copyright = {2023 The Author(s)},
	issn = {2041-1723},
	url = {https://www.nature.com/articles/s41467-023-42482-1},
	doi = {10.1038/s41467-023-42482-1},
	abstract = {Large-scale quantum computers have the potential to hold computational capabilities beyond conventional computers. However, the physical qubits are prone to noise which must be corrected in order to perform fault-tolerant quantum computations. Quantum Error Correction (QEC) provides the path for realizing such computations. QEC generates a continuous stream of data that decoders must process at the rate it is received, which can be as fast as 1 μs per QEC round in superconducting quantum computers. If the decoder infrastructure cannot keep up, a data backlog problem is encountered and the computation runs exponentially slower. Today’s leading approaches to quantum error correction are not scalable as existing decoders typically run slower as the problem size is increased, inevitably hitting the backlog problem. Here, we show how to parallelize decoding to achieve almost arbitrary speed, removing this roadblock to scalability. Our parallelization requires some classical feed forward decisions to be delayed, slowing-down the logical clock speed. However, the slow-down is now only polynomial in the size of the QEC code, averting the exponential slowdown. We numerically demonstrate our parallel decoder for the surface code, showing no noticeable reduction in logical fidelity compared to previous decoders and demonstrating the predicted speedup.},
	language = {en},
	number = {1},
	urldate = {2026-01-06},
	journal = {Nature Communications},
	publisher = {Nature Publishing Group},
	author = {Skoric, Luka and Browne, Dan E. and Barnes, Kenton M. and Gillespie, Neil I. and Campbell, Earl T.},
	month = nov,
	year = {2023},
	note = {TLDR: This work numerically demonstrates a parallel decoder for the surface code, showing no noticeable reduction in logical fidelity compared to previous decoders and demonstrating the predicted speedup.},
	keywords = {/unread, \#QEC, \#SWIND, Qubits, Computer science},
	pages = {7040},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/GZEI6ESA/Skoric et al. - 2023 - Parallel window decoding enables scalable fault tolerant quantum computation.pdf:application/pdf},
}

@article{higgott_sparse_2025,
	title = {Sparse {Blossom}: correcting a million errors per core second with minimum-weight matching},
	volume = {9},
	shorttitle = {Sparse {Blossom}},
	url = {https://quantum-journal.org/papers/q-2025-01-20-1600/},
	doi = {10.22331/q-2025-01-20-1600},
	abstract = {Oscar Higgott and Craig Gidney,
Quantum 9, 1600 (2025).
In this work, we introduce a fast implementation of the minimum-weight perfect matching (MWPM) decoder, the most widely used decoder for several important families of quantum error correctin…},
	language = {en-GB},
	urldate = {2026-01-06},
	journal = {Quantum},
	publisher = {Verein zur Förderung des Open Access Publizierens in den Quantenwissenschaften},
	author = {Higgott, Oscar and Gidney, Craig},
	month = jan,
	year = {2025},
	note = {TLDR: This work introduces a fast implementation of the minimum-weight perfect matching decoder, the most widely used decoder for several important families of quantum error correcting codes, including surface codes, and proposes a variant of the blossom algorithm which directly solves the decoding problem relevant to quantum error correction.},
	keywords = {/unread},
	pages = {1600},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/XC8BVZ7Q/Higgott and Gidney - 2025 - Sparse Blossom correcting a million errors per core second with minimum-weight matching.pdf:application/pdf},
}

@article{breuckmann_quantum_2021,
	title = {Quantum {Low}-{Density} {Parity}-{Check} {Codes}},
	volume = {2},
	url = {https://link.aps.org/doi/10.1103/PRXQuantum.2.040101},
	doi = {10.1103/PRXQuantum.2.040101},
	abstract = {Quantum error correction is an indispensable ingredient for scalable quantum computing. In this Perspective we discuss a particular class of quantum codes called “quantum low-density parity-check (LDPC) codes.” The codes we discuss are alternatives to the surface code, which is currently the leading candidate to implement quantum fault tolerance. We introduce the zoo of quantum LDPC codes and discuss their potential for making quantum computers robust with regard to noise. In particular, we explain recent advances in the theory of quantum LDPC codes related to certain product constructions and discuss open problems in the field.},
	number = {4},
	urldate = {2026-01-06},
	journal = {PRX Quantum},
	publisher = {American Physical Society},
	author = {Breuckmann, Nikolas P. and Eberhardt, Jens Niklas},
	month = oct,
	year = {2021},
	note = {TLDR: This Perspective discusses a particular class of quantum codes called low-density parity-check (LDPC) quantum codes, which are alternatives to the surface code and have the potential for making quantum computers robust against noise.},
	keywords = {/unread},
	pages = {040101},
	file = {APS Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/KKXBF8JX/PRXQuantum.2.html:text/html;Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/7446JITF/Breuckmann and Eberhardt - 2021 - Quantum Low-Density Parity-Check Codes.pdf:application/pdf},
}

@inproceedings{gokduman_erasure_2024,
	title = {Erasure {Decoding} for {Quantum} {LDPC} {Codes} via {Belief} {Propagation} with {Guided} {Decimation}},
	issn = {2836-4503},
	url = {https://ieeexplore.ieee.org/document/10735275},
	doi = {10.1109/Allerton63246.2024.10735275},
	abstract = {Quantum low-density parity-check (LDPC) codes are a promising family of quantum error-correcting codes for fault tolerant quantum computing with low overhead. Decoding quantum LDPC codes on quantum erasure channels has received more attention recently due to advances in erasure conversion for various types of qubits including neutral atoms, trapped ions, and superconducting qubits. Belief propagation with guided decimation (BPGD) decoding of quantum LDPC codes has demonstrated good performance in bit-flip and depolarizing noise. In this work, we apply BPGD decoding to quantum erasure channels. Using a natural modification, we show that BPGD offers competitive performance on quantum erasure channels for multiple families of quantum LDPC codes. Furthermore, we show that the performance of BPGD decoding on erasure channels can sometimes be improved significantly by either adding damping or adjusting the initial channel log-likelihood ratio for bits that are not erased. More generally, our results demonstrate BPGD is an effective general-purpose solution for erasure decoding across the quantum LDPC landscape.},
	urldate = {2026-01-06},
	booktitle = {2024 60th {Annual} {Allerton} {Conference} on {Communication}, {Control}, and {Computing}},
	author = {Gökduman, Mert and Yao, Hanwen and Pfister, Henry D.},
	month = sep,
	year = {2024},
	note = {TLDR: This work shows that BPGD offers competitive performance on quantum erasure channels for multiple families of quantum LDPC codes and demonstrates BPGD is an effective general-purpose solution for erasure decoding across the quantum LDPC landscape.},
	keywords = {/unread, Decoding, Codes, Parity check codes, Fault tolerance, Fault tolerant systems, Belief propagation, Qubit, Damping, Superconducting device noise, Trapped ions},
	pages = {1--8},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/ZY6SPSEV/Gökduman et al. - 2024 - Erasure Decoding for Quantum LDPC Codes via Belief Propagation with Guided Decimation.pdf:application/pdf},
}

@misc{swierkowska_eccentric_2025,
	title = {{ECCentric}: {An} {Empirical} {Analysis} of {Quantum} {Error} {Correction} {Codes}},
	shorttitle = {{ECCentric}},
	url = {http://arxiv.org/abs/2511.01062},
	doi = {10.48550/arXiv.2511.01062},
	abstract = {Quantum error correction (QEC) is essential for building scalable quantum computers, but a lack of systematic, end-to-end evaluation methods makes it difficult to assess how different QEC codes perform under realistic conditions. The vast diversity of codes, an expansive experimental search space, and the absence of a standardized framework prevent a thorough, holistic analysis. To address this, we introduce ECCentric, an end-to-end benchmarking framework designed to systematically evaluate QEC codes across the full quantum computing stack. ECCentric is designed to be modular, extensible, and general, allowing for a comprehensive analysis of QEC code families under varying hardware topologies, noise models, and compilation strategies. Using ECCentric, we conduct the first systematic benchmarking of major QEC code families against realistic, mid-term quantum device parameters. Our empirical analysis reveals that intra-QPU execution significantly outperforms distributed methods, that qubit connectivity is a far more critical factor for reducing logical errors than increasing code distance, and that compiler overhead remains a major source of error. Furthermore, our findings suggest that trapped-ion architectures with qubit shuttling are the most promising near-term platforms and that on noisy devices, a strategic and selective application of QEC is necessary to avoid introducing more errors than are corrected. This study provides crucial, actionable insights for both hardware designers and practitioners, guiding the development of fault-tolerant quantum systems.},
	urldate = {2026-01-08},
	publisher = {arXiv},
	author = {Świerkowska, Aleksandra and Pflieger, Jannik and Giortamis, Emmanouil and Bhatotia, Pramod},
	month = nov,
	year = {2025},
	note = {arXiv:2511.01062 [quant-ph]
version: 1},
	keywords = {/unread, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/NGIBGAW3/Świerkowska et al. - 2025 - ECCentric An Empirical Analysis of Quantum Error Correction Codes.pdf:application/pdf;Snapshot:/home/andreas/workspace/work/hiwi/Zotero/storage/GALSQ3TQ/2511.html:text/html},
}

@phdthesis{guernut_fault-tolerant_2025,
	type = {phdthesis},
	title = {Fault-tolerant manipulation of quantum information with {LDPC} stabilizer codes},
	url = {https://hal.univ-lorraine.fr/tel-05101803},
	abstract = {Quantum stabilizer codes, and in particular quantum LDPC codes, are among the main contenders towards quantum error correction, thought to be required for quantum computers to be usable at least in the foreseeable future. Finding stabilizer codes with interesting encoding rates is not quite enough, one must be able to act upon them and decode them efficiently at the same time. In this thesis, we try to solve the technical problems posed by the decoding of stabilizer codes undergoing logical operations and overlooked in the literature by introducing a heuristic to an existing decoder algorithm. This is a matter of utmost importance as error-corrected quantum hardware is starting to emerge. Armed with this decoder, we simulate a full fault-tolerant Clifford logical gate set for the toric code, paving the way for more logical operations of stabilizer codes encoding multiple qubits to be investigated. To this end, we introduce Bell-state simulations that could help to study the correlation between logical errors in these blocks of code. We finally extend our results to find new logical gates for the toric color codes by exploiting the inherent link between them and the toric code, and we define a new family of triangular color codes that we think could offer some advantages compared to concatenated color codes.},
	language = {en},
	urldate = {2026-01-19},
	school = {Université de Lorraine},
	author = {Guernut, Alexandre},
	month = may,
	year = {2025},
	keywords = {/unread},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/W59I8PHW/Guernut - 2025 - Fault-tolerant manipulation of quantum information with LDPC stabilizer codes.pdf:application/pdf},
}

@article{dennis_topological_2002,
	title = {Topological quantum memory},
	volume = {43},
	issn = {0022-2488, 1089-7658},
	url = {http://arxiv.org/abs/quant-ph/0110143},
	doi = {10.1063/1.1499754},
	abstract = {We analyze surface codes, the topological quantum error-correcting codes introduced by Kitaev. In these codes, qubits are arranged in a two-dimensional array on a surface of nontrivial topology, and encoded quantum operations are associated with nontrivial homology cycles of the surface. We formulate protocols for error recovery, and study the efficacy of these protocols. An order-disorder phase transition occurs in this system at a nonzero critical value of the error rate; if the error rate is below the critical value (the accuracy threshold), encoded information can be protected arbitrarily well in the limit of a large code block. This phase transition can be accurately modeled by a three-dimensional Z\_2 lattice gauge theory with quenched disorder. We estimate the accuracy threshold, assuming that all quantum gates are local, that qubits can be measured rapidly, and that polynomial-size classical computations can be executed instantaneously. We also devise a robust recovery procedure that does not require measurement or fast classical processing; however for this procedure the quantum gates are local only if the qubits are arranged in four or more spatial dimensions. We discuss procedures for encoding, measurement, and performing fault-tolerant universal quantum computation with surface codes, and argue that these codes provide a promising framework for quantum computing architectures.},
	number = {9},
	urldate = {2026-01-22},
	journal = {Journal of Mathematical Physics},
	author = {Dennis, Eric and Kitaev, Alexei and Landahl, Andrew and Preskill, John},
	month = sep,
	year = {2002},
	note = {arXiv:quant-ph/0110143},
	keywords = {/unread, Quantum Physics, Condensed Matter - Statistical Mechanics, High Energy Physics - Lattice, High Energy Physics - Theory},
	pages = {4452--4505},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/TZGVRNQR/Dennis et al. - 2002 - Topological quantum memory.pdf:application/pdf},
}

@article{tan_scalable_2023,
	title = {Scalable {Surface}-{Code} {Decoders} with {Parallelization} in {Time}},
	volume = {4},
	url = {https://link.aps.org/doi/10.1103/PRXQuantum.4.040344},
	doi = {10.1103/PRXQuantum.4.040344},
	abstract = {Fast classical processing is essential for most quantum fault-tolerance architectures. We introduce a sliding-window decoding scheme that provides fast classical processing for the surface code through parallelism. Our scheme divides the syndromes in space-time into overlapping windows along the time direction, which can be decoded in parallel with any inner decoder. With this parallelism, our scheme can solve the backlog problem as the code scales up, even if the inner decoder is slow. When using minimum-weight perfect matching and union find as the inner decoders, we observe circuit-level thresholds of 0.68\% and 0.55\%, respectively, which are almost identical to those for the batch decoding.},
	number = {4},
	urldate = {2026-01-22},
	journal = {PRX Quantum},
	publisher = {American Physical Society},
	author = {Tan, Xinyu and Zhang, Fang and Chao, Rui and Shi, Yaoyun and Chen, Jianxin},
	month = dec,
	year = {2023},
	note = {TLDR: This work introduces a sliding-window decoding scheme that provides fast classical processing for the surface code through parallelism, which can solve the decoding throughput problem as the code scales up, even if the inner decoder is slow.},
	keywords = {/s1, \#SWIND},
	pages = {040344},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/67CPJD2W/Tan et al. - 2023 - Scalable Surface-Code Decoders with Parallelization in Time.pdf:application/pdf},
}

@article{bravyi_high-threshold_2024,
	title = {High-threshold and low-overhead fault-tolerant quantum memory},
	volume = {627},
	issn = {0028-0836, 1476-4687},
	url = {http://arxiv.org/abs/2308.07915},
	doi = {10.1038/s41586-024-07107-7},
	abstract = {Quantum error correction becomes a practical possibility only if the physical error rate is below a threshold value that depends on a particular quantum code, syndrome measurement circuit, and decoding algorithm. Here we present an end-to-end quantum error correction protocol that implements fault-tolerant memory based on a family of LDPC codes with a high encoding rate that achieves an error threshold of \$0.8{\textbackslash}\%\$ for the standard circuit-based noise model. This is on par with the surface code which has remained an uncontested leader in terms of its high error threshold for nearly 20 years. The full syndrome measurement cycle for a length-\$n\$ code in our family requires \$n\$ ancillary qubits and a depth-7 circuit composed of nearest-neighbor CNOT gates. The required qubit connectivity is a degree-6 graph that consists of two edge-disjoint planar subgraphs. As a concrete example, we show that 12 logical qubits can be preserved for nearly one million syndrome cycles using 288 physical qubits in total, assuming the physical error rate of \$0.1{\textbackslash}\%\$. We argue that achieving the same level of error suppression on 12 logical qubits with the surface code would require nearly 3000 physical qubits. Our findings bring demonstrations of a low-overhead fault-tolerant quantum memory within the reach of near-term quantum processors.},
	number = {8005},
	urldate = {2026-01-23},
	journal = {Nature},
	author = {Bravyi, Sergey and Cross, Andrew W. and Gambetta, Jay M. and Maslov, Dmitri and Rall, Patrick and Yoder, Theodore J.},
	month = mar,
	year = {2024},
	note = {arXiv:2308.07915 [quant-ph]
TLDR: An end-to-end quantum error correction protocol that implements fault-tolerant memory on the basis of a family of low-density parity-check codes shows the possibility of low-overhead fault-tolerant quantum memory within the reach of near-term quantum processors.},
	keywords = {/unread, Quantum Physics, Computer Science - Emerging Technologies},
	pages = {778--782},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/7IKKJM4Z/Bravyi et al. - 2024 - High-threshold and low-overhead fault-tolerant quantum memory.pdf:application/pdf},
}

@article{kuo_exploiting_2022,
	title = {Exploiting degeneracy in belief propagation decoding of quantum codes},
	volume = {8},
	copyright = {2022 The Author(s)},
	issn = {2056-6387},
	url = {https://www.nature.com/articles/s41534-022-00623-2},
	doi = {10.1038/s41534-022-00623-2},
	abstract = {Quantum information needs to be protected by quantum error-correcting codes due to imperfect physical devices and operations. One would like to have an efficient and high-performance decoding procedure for the class of quantum stabilizer codes. A potential candidate is Gallager’s sum-product algorithm, also known as Pearl’s belief propagation (BP), but its performance suffers from the many short cycles inherent in a quantum stabilizer code, especially highly-degenerate codes. A general impression exists that BP is not effective for topological codes. In this paper, we propose a decoding algorithm for quantum codes based on quaternary BP with additional memory effects (called MBP). This MBP is like a recursive neural network with inhibitions between neurons (edges with negative weights), which enhance the perception capability of a network. Moreover, MBP exploits the degeneracy of a quantum code so that the most probable error or its degenerate errors can be found with high probability. The decoding performance is significantly improved over the conventional BP for various quantum codes, including quantum bicycle, hypergraph-product, surface and toric codes. For MBP on the surface and toric codes over depolarizing errors, we observe error thresholds of 16\% and 17.5\%, respectively.},
	language = {en},
	number = {1},
	urldate = {2026-01-28},
	journal = {npj Quantum Information},
	publisher = {Nature Publishing Group},
	author = {Kuo, Kao-Yueh and Lai, Ching-Yi},
	month = sep,
	year = {2022},
	note = {TLDR: This paper proposes a decoding algorithm for quantum codes based on quaternary BP with additional memory effects (called MBP), which is like a recursive neural network with inhibitions between neurons (edges with negative weights), which enhance the perception capability of a network.},
	keywords = {Quantum information, /s1, Computer science, Electrical and electronic engineering},
	pages = {111},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/KTVJ5BGL/Kuo and Lai - 2022 - Exploiting degeneracy in belief propagation decoding of quantum codes.pdf:application/pdf},
}

@misc{kuo_fault-tolerant_2024,
	title = {Fault-{Tolerant} {Belief} {Propagation} for {Practical} {Quantum} {Memory}},
	url = {http://arxiv.org/abs/2409.18689},
	doi = {10.48550/arXiv.2409.18689},
	abstract = {A fault-tolerant approach to reliable quantum memory is essential for scalable quantum computing, as physical qubits are susceptible to noise. Quantum error correction (QEC) must be continuously performed to prolong the memory lifetime. In QEC, error syndromes are generated rapidly, often within the execution time of a few quantum gates, requiring decoders to process this error data with equal speed. A typical QEC cycle involves multiple rounds of syndrome measurements, causing potential error locations to scale rapidly with the code size and the number of measurement rounds. However, no such decoders currently exist for general quantum low-density parity-check codes. In this paper, we propose a fault-tolerant belief propagation (FTBP) decoder that utilizes a space-time Tanner graph across multiple rounds of syndrome extraction with mixed-alphabet error variables. To enhance FTBP, we introduce a technique of probabilistic error consolidation to mitigate degeneracy effects and short cycles. Additionally, we propose an adaptive sliding window procedure that captures long error events across window boundaries and adjusts the decoding in real time. Our simulations demonstrate high error thresholds of 0.4\%-0.87\% and strong error-floor performance for topological code families, including rotated toric, toric color, and twisted XZZX toric codes.},
	urldate = {2026-01-28},
	publisher = {arXiv},
	author = {Kuo, Kao-Yueh and Lai, Ching-Yi},
	month = sep,
	year = {2024},
	note = {arXiv:2409.18689 [quant-ph]},
	keywords = {/s1, Quantum Physics, \#BP-degen},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/IKFJ36EW/Kuo and Lai - 2024 - Fault-Tolerant Belief Propagation for Practical Quantum Memory.pdf:application/pdf},
}

@misc{poor_ultra_2025,
	title = {Ultra {Low} {Overhead} {Syndrome} {Extraction} for the {Steane} code},
	url = {http://arxiv.org/abs/2511.13700},
	doi = {10.48550/arXiv.2511.13700},
	abstract = {We establish a new performance benchmark for the fault-tolerant syndrome extraction of [[7, 1, 3]] Steane code with a dynamic protocol. Our method is built on two highly optimized circuits derived using fault-equivalent ZX-rewrites: a primary fault-tolerant circuit with 14 CNOTs and an efficient non-fault-tolerant recovery circuit with 11 CNOTs. The protocol uses an adaptive response to internal faults, discarding flagged measurements and falling back to the recovery circuit to correct potentially detrimental errors. Monte Carlo simulations confirm the efficiency of our protocol, reducing the logical error rate per cycle by an average of {\textasciitilde}14.3\% relative to the optimized Steane method [arXiv:2506.17181] and {\textasciitilde}17.7\% compared to the Reichardt's three-qubit method [arXiv:1804.06995], the leading prior techniques.},
	urldate = {2026-01-28},
	publisher = {arXiv},
	author = {Poór, Boldizsár and Rodatz, Benjamin and Kissinger, Aleks},
	month = nov,
	year = {2025},
	note = {arXiv:2511.13700 [quant-ph]},
	keywords = {/unread, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/UUM49WNZ/Poór et al. - 2025 - Ultra Low Overhead Syndrome Extraction for the Steane code.pdf:application/pdf},
}

@article{feynman_simulating_1982,
	title = {Simulating physics with computers},
	volume = {21},
	issn = {1572-9575},
	url = {https://doi.org/10.1007/BF02650179},
	doi = {10.1007/BF02650179},
	language = {en},
	number = {6},
	urldate = {2026-01-28},
	journal = {International Journal of Theoretical Physics},
	author = {Feynman, Richard P.},
	month = jun,
	year = {1982},
	note = {TLDR: The question is, Can physics be simulated by a universal computer? I would like to have the elements of this computer locally interconnected, and therefore sort of think about cellular automata as an example (but I don't want to force it).},
	keywords = {/unread, Calcite, Cellular Automaton, Quantum Mechanic, Quantum System, Wigner Function},
	pages = {467--488},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/8HGIKM75/Feynman - 1982 - Simulating physics with computers.pdf:application/pdf},
}

@inproceedings{shor_algorithms_1994,
	title = {Algorithms for quantum computation: discrete logarithms and factoring},
	shorttitle = {Algorithms for quantum computation},
	url = {https://ieeexplore.ieee.org/abstract/document/365700},
	doi = {10.1109/SFCS.1994.365700},
	abstract = {A computer is generally considered to be a universal computational device; i.e., it is believed able to simulate any physical computational device with a cost in computation time of at most a polynomial factor: It is not clear whether this is still true when quantum mechanics is taken into consideration. Several researchers, starting with David Deutsch, have developed models for quantum mechanical computers and have investigated their computational properties. This paper gives Las Vegas algorithms for finding discrete logarithms and factoring integers on a quantum computer that take a number of steps which is polynomial in the input size, e.g., the number of digits of the integer to be factored. These two problems are generally considered hard on a classical computer and have been used as the basis of several proposed cryptosystems. We thus give the first examples of quantum cryptanalysis.{\textless}{\textgreater}},
	urldate = {2026-01-28},
	booktitle = {Proceedings 35th {Annual} {Symposium} on {Foundations} of {Computer} {Science}},
	author = {Shor, P.W.},
	month = nov,
	year = {1994},
	keywords = {/s1, Quantum computing, Quantum mechanics, Polynomials, Circuit simulation, Computational modeling, Computer simulation, Costs, Cryptography, Mechanical factors, Physics computing},
	pages = {124--134},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/TGVMGU67/Shor - 1994 - Algorithms for quantum computation discrete logarithms and factoring.pdf:application/pdf},
}

@article{preskill_quantum_2018,
	title = {Quantum {Computing} in the {NISQ} era and beyond},
	volume = {2},
	url = {https://quantum-journal.org/papers/q-2018-08-06-79/},
	doi = {10.22331/q-2018-08-06-79},
	abstract = {John Preskill,
Quantum 2, 79 (2018).
Noisy Intermediate-Scale Quantum (NISQ) technology will be available in the near future. Quantum computers with 50-100 qubits may be able to perform tasks which surpass the capabilities of t…},
	language = {en-GB},
	urldate = {2026-01-28},
	journal = {Quantum},
	publisher = {Verein zur Förderung des Open Access Publizierens in den Quantenwissenschaften},
	author = {Preskill, John},
	month = aug,
	year = {2018},
	note = {TLDR: Noisy Intermediate-Scale Quantum (NISQ) technology will be available in the near future, and the 100-qubit quantum computer will not change the world right away - but it should be regarded as a significant step toward the more powerful quantum technologies of the future.},
	keywords = {/s1},
	pages = {79},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/U2L4DNQ7/Preskill - 2018 - Quantum Computing in the NISQ era and beyond.pdf:application/pdf},
}

@misc{google_quantum_ai_quantum_nodate,
	title = {Quantum {Computing} {Roadmap}},
	url = {https://quantumai.google/qecmilestone},
	abstract = {An update on quantum error correction at Google Quantum AI.},
	language = {en},
	urldate = {2026-01-28},
	journal = {Google Quantum AI},
	author = {{Google Quantum AI}},
	keywords = {/unread},
}

@article{fowler_high-threshold_2009,
	title = {High-threshold universal quantum computation on the surface code},
	volume = {80},
	url = {https://link.aps.org/doi/10.1103/PhysRevA.80.052312},
	doi = {10.1103/PhysRevA.80.052312},
	abstract = {We present a comprehensive and self-contained simplified review of the quantum computing scheme of Raussendorf et al. [Phys. Rev. Lett. 98, 190504 (2007); N. J. Phys. 9, 199 (2007)], which features a two-dimensional nearest-neighbor coupled lattice of qubits, a threshold error rate approaching 1\%, natural asymmetric and adjustable strength error correction, and low overhead arbitrarily long-range logical gates. These features make it one of the best and most practical quantum computing schemes devised to date. We restrict the discussion to direct manipulation of the surface code using the stabilizer formalism, both of which we also briefly review, to make the scheme accessible to a broad audience.},
	number = {5},
	urldate = {2026-01-28},
	journal = {Physical Review A},
	publisher = {American Physical Society},
	author = {Fowler, Austin G. and Stephens, Ashley M. and Groszkowski, Peter},
	month = nov,
	year = {2009},
	note = {TLDR: A comprehensive and self-contained simplified review of the quantum computing scheme of Phys.},
	keywords = {/unread},
	pages = {052312},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/JQSG7V59/Fowler et al. - 2009 - High-threshold universal quantum computation on the surface code.pdf:application/pdf},
}

@article{zhang_classical_2023,
	title = {A {Classical} {Architecture} for {Digital} {Quantum} {Computers}},
	volume = {5},
	url = {https://dl.acm.org/doi/10.1145/3626199},
	doi = {10.1145/3626199},
	abstract = {Scaling bottlenecks the making of digital quantum computers, posing challenges from both the quantum and the classical components. We present a classical architecture to cope with a comprehensive list of the latter challenges all at once, and implement it fully in an end-to-end system by integrating a multi-core RISC-V CPU with our in-house control electronics.Our architecture enables scalable, high-precision control of large quantum processors and accommodates evolving requirements of quantum hardware. A central feature is a microarchitecture executing quantum operations in parallel on arbitrary predefined qubit groups. Another key feature is a reconfigurable quantum instruction set that supports easy qubit re-grouping and instructions extensions.As a demonstration, we implement the widely-studied surface code quantum computing workflow, which is instructive for being demanding on both the controllers and the integrated classical computation. Our design, for the first time, reduces instruction issuing and transmission costs to constants, which do not scale with the number of qubits, without adding any overheads in decoding or dispatching.Our system uses a dedicated general-purpose CPU for both qubit control and classical computation, including syndrome decoding. Implementing recent theoretical proposals as decoding firmware that parallelizes general inner decoders, we can achieve unprecedented decoding capabilities of up to distances 47 and 67 with the currently available systems-on-chips for physical error rate p = 0.001 and p = 0.0001, respectively, all in just 1 μs.},
	number = {1},
	urldate = {2026-01-28},
	journal = {ACM Transactions on Quantum Computing},
	author = {Zhang, Fang and Zhu, Xing and Chao, Rui and Huang, Cupjin and Kong, Linghang and Chen, Guoyang and Ding, Dawei and Feng, Haishan and Gao, Yihuai and Ni, Xiaotong and Qiu, Liwei and Wei, Zhe and Yang, Yueming and Zhao, Yang and Shi, Yaoyun and Zhang, Weifeng and Zhou, Peng and Chen, Jianxin},
	month = dec,
	year = {2023},
	note = {TLDR: This work presents a classical architecture to cope with a comprehensive list of the latter challenges all at once, and implements it fully in an end-to-end system by integrating a multi-core RISC-V CPU with the authors' in-house control electronics.},
	keywords = {/unread},
	pages = {3:1--3:24},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/SJTGR3DD/Zhang et al. - 2023 - A Classical Architecture for Digital Quantum Computers.pdf:application/pdf},
}

@misc{caune_demonstrating_2024,
	title = {Demonstrating real-time and low-latency quantum error correction with superconducting qubits},
	url = {http://arxiv.org/abs/2410.05202},
	doi = {10.48550/arXiv.2410.05202},
	abstract = {Quantum error correction (QEC) will be essential to achieve the accuracy needed for quantum computers to realise their full potential. The field has seen promising progress with demonstrations of early QEC and real-time decoded experiments. As quantum computers advance towards demonstrating a universal fault-tolerant logical gate set, implementing scalable and low-latency real-time decoding will be crucial to prevent the backlog problem, avoiding an exponential slowdown and maintaining a fast logical clock rate. Here, we demonstrate low-latency feedback with a scalable FPGA decoder integrated into the control system of a superconducting quantum processor. We perform an 8-qubit stability experiment with up to \$25\$ decoding rounds and a mean decoding time per round below \$1\$ \$μs\$, showing that we avoid the backlog problem even on superconducting hardware with the strictest speed requirements. We observe logical error suppression as the number of decoding rounds is increased. We also implement and time a fast-feedback experiment demonstrating a decoding response time of \$9.6\$ \$μs\$ for a total of \$9\$ measurement rounds. The decoder throughput and latency developed in this work, combined with continued device improvements, unlock the next generation of experiments that go beyond purely keeping logical qubits alive and into demonstrating building blocks of fault-tolerant computation, such as lattice surgery and magic state teleportation.},
	urldate = {2026-01-28},
	publisher = {arXiv},
	author = {Caune, Laura and Skoric, Luka and Blunt, Nick S. and Ruban, Archibald and McDaniel, Jimmy and Valery, Joseph A. and Patterson, Andrew D. and Gramolin, Alexander V. and Majaniemi, Joonas and Barnes, Kenton M. and Bialas, Tomasz and Buğdaycı, Okan and Crawford, Ophelia and Gehér, György P. and Krovi, Hari and Matekole, Elisha and Topal, Canberk and Poletto, Stefano and Bryant, Michael and Snyder, Kalan and Gillespie, Neil I. and Jones, Glenn and Johar, Kauser and Campbell, Earl T. and Hill, Alexander D.},
	month = oct,
	year = {2024},
	note = {arXiv:2410.05202 [quant-ph]},
	keywords = {/unread, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/LGMAEBMB/Caune et al. - 2024 - Demonstrating real-time and low-latency quantum error correction with superconducting qubits.pdf:application/pdf},
}

@misc{ye_beam_2025-1,
	title = {Beam search decoder for quantum {LDPC} codes},
	url = {http://arxiv.org/abs/2512.07057},
	doi = {10.48550/arXiv.2512.07057},
	abstract = {We propose a decoder for quantum low density parity check (LDPC) codes based on a beam search heuristic guided by belief propagation (BP). Our beam search decoder applies to all quantum LDPC codes and achieves different speed-accuracy tradeoffs by tuning its parameters such as the beam width. We perform numerical simulations under circuit level noise for the \$[[144, 12, 12]]\$ bivariate bicycle (BB) code at noise rate \$p=10{\textasciicircum}\{-3\}\$ to estimate the logical error rate and the 99.9 percentile runtime and we compare with the BP-OSD decoder which has been the default quantum LDPC decoder for the past six years. A variant of our beam search decoder with a beam width of 64 achieves a \$17{\textbackslash}times\$ reduction in logical error rate. With a beam width of 8, we reach the same logical error rate as BP-OSD with a \$26.2{\textbackslash}times\$ reduction in the 99.9 percentile runtime. We identify the beam search decoder with beam width of 32 as a promising candidate for trapped ion architectures because it achieves a \$5.6{\textbackslash}times\$ reduction in logical error rate with a 99.9 percentile runtime per syndrome extraction round below 1ms at \$p=5 {\textbackslash}times10{\textasciicircum}\{-4\}\$. Remarkably, this is achieved in software on a single core, without any parallelization or specialized hardware (FPGA, ASIC), suggesting one might only need three 32-core CPUs to decode a trapped ion quantum computer with 1000 logical qubits.},
	urldate = {2026-01-29},
	publisher = {arXiv},
	author = {Ye, Min and Wecker, Dave and Delfosse, Nicolas},
	month = dec,
	year = {2025},
	note = {arXiv:2512.07057 [quant-ph]
TLDR: A beam search decoder for quantum low density parity check (LDPC) codes based on a beam search heuristic guided by belief propagation (BP) is proposed, suggesting one might only need three 32-core CPUs to decode a trapped ion quantum computer with 1000 logical qubits.},
	keywords = {/unread, Computer Science - Information Theory, Quantum Physics},
	file = {Preprint PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/DVFCD2FE/Ye et al. - 2025 - Beam search decoder for quantum LDPC codes.pdf:application/pdf},
}

@misc{noauthor_reproducing_nodate,
	title = {Reproducing repetition and {Shor} code simulations using stim},
	url = {https://textbook.riverlane.com/en/latest/notebooks/ch3-state-of-art-tools/repetition-and-shor-codes-stim.html},
	urldate = {2026-01-29},
	keywords = {/unread},
}

@misc{noauthor_tutorial_nodate,
	title = {Tutorial - {Estimating} the {Surface} {Code} {Threshold} — {NordIQuEst} {Application} {Library}},
	url = {https://nordiquest.net/application-library/training-material/qas2024/notebooks/surface_code_threshold.html},
	urldate = {2026-01-29},
	keywords = {/unread},
}

@misc{noauthor_simulating_nodate,
	title = {Simulating surface codes using stim},
	url = {https://textbook.riverlane.com/en/latest/notebooks/ch5-decoding-surfcodes/simulating-surface-codes-stim.html},
	urldate = {2026-01-29},
	keywords = {/unread},
}

@article{ryan-anderson_realization_2021,
	title = {Realization of {Real}-{Time} {Fault}-{Tolerant} {Quantum} {Error} {Correction}},
	volume = {11},
	url = {https://link.aps.org/doi/10.1103/PhysRevX.11.041058},
	doi = {10.1103/PhysRevX.11.041058},
	abstract = {Correcting errors in real time is essential for reliable large-scale quantum computations. Realizing this high-level function requires a system capable of several low-level primitives, including single-qubit and two-qubit operations, midcircuit measurements of subsets of qubits, real-time processing of measurement outcomes, and the ability to condition subsequent gate operations on those measurements. In this work, we use a 10-qubit quantum charge-coupled device trapped-ion quantum computer to encode a single logical qubit using the [[7,1,3]] color code, first proposed by Steane [Phys. Rev. Lett. 77, 793 (1996)]. The logical qubit is initialized into the eigenstates of three mutually unbiased bases using an encoding circuit, and we measure an average logical state preparation and measurement (SPAM) error of 1.7⁢(2) ×10−3, compared to the average physical SPAM error 2.4⁢(4) ×10−3 of our qubits. We then perform multiple syndrome measurements on the encoded qubit, using a real-time decoder to determine any necessary corrections that are done either as software updates to the Pauli frame or as physically applied gates. Moreover, these procedures are done repeatedly while maintaining coherence, demonstrating a dynamically protected logical qubit memory. Additionally, we demonstrate non-Clifford qubit operations by encoding a ¯𝑇{\textbar} +⟩𝐿 magic state with an error rate below the threshold required for magic state distillation. Finally, we present system-level simulations that allow us to identify key hardware upgrades that may enable the system to reach the pseudothreshold.},
	number = {4},
	urldate = {2026-01-29},
	journal = {Physical Review X},
	publisher = {American Physical Society},
	author = {Ryan-Anderson, C. and Bohnet, J. G. and Lee, K. and Gresh, D. and Hankin, A. and Gaebler, J. P. and Francois, D. and Chernoguzov, A. and Lucchetti, D. and Brown, N. C. and Gatterman, T. M. and Halit, S. K. and Gilmore, K. and Gerber, J. A. and Neyenhuis, B. and Hayes, D. and Stutz, R. P.},
	month = dec,
	year = {2021},
	note = {TLDR: This work uses a ten qubit QCCD trapped-ion quantum computer to encode a single logical qubit using the Steane 1996error color code, and demonstrates non-Clifford qubit operations by encoding a logical magic state with an error rate below the threshold required for magic state distillation.},
	keywords = {/unread},
	pages = {041058},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/CRVKJ6VB/Ryan-Anderson et al. - 2021 - Realization of Real-Time Fault-Tolerant Quantum Error Correction.pdf:application/pdf},
}

@article{nigg_quantum_2014,
	title = {Quantum computations on a topologically encoded qubit},
	volume = {345},
	issn = {0036-8075, 1095-9203},
	url = {https://www.science.org/doi/10.1126/science.1253742},
	doi = {10.1126/science.1253742},
	abstract = {Fault-tolerant quantum computing
            
              Quantum states can be delicate. Attempts to process and manipulate quantum states can destroy the encoded information. Nigg
              et al.
              encoded the quantum state of a single qubit (in this case, a trapped ion) over the global properties of a series of trapped ions. These so-called stabilizers protected the information against noise sources that can degrade the single qubit. The protocol provides a route to fault-tolerant quantum computing.
            
            
              Science
              , this issue p.
              302
            
          , 
            A protocol is implemented that allows for fault-tolerant quantum computing.
          , 
            The construction of a quantum computer remains a fundamental scientific and technological challenge because of the influence of unavoidable noise. Quantum states and operations can be protected from errors through the use of protocols for quantum computing with faulty components. We present a quantum error-correcting code in which one qubit is encoded in entangled states distributed over seven trapped-ion qubits. The code can detect one bit flip error, one phase flip error, or a combined error of both, regardless on which of the qubits they occur. We applied sequences of gate operations on the encoded qubit to explore its computational capabilities. This seven-qubit code represents a fully functional instance of a topologically encoded qubit, or color code, and opens a route toward fault-tolerant quantum computing.},
	language = {en},
	number = {6194},
	urldate = {2026-01-29},
	journal = {Science},
	author = {Nigg, D. and Müller, M. and Martinez, E. A. and Schindler, P. and Hennrich, M. and Monz, T. and Martin-Delgado, M. A. and Blatt, R.},
	month = jul,
	year = {2014},
	note = {TLDR: A quantum error-correcting code in which one qubit is encoded in entangled states distributed over seven trapped-ion qubits, which represents a fully functional instance of a topologically encoded qubit, or color code, and opens a route toward fault-tolerant quantum computing.},
	keywords = {/unread},
	pages = {302--305},
	file = {Submitted Version:/home/andreas/workspace/work/hiwi/Zotero/storage/JK9HDSJE/Nigg et al. - 2014 - Quantum computations on a topologically encoded qubit.pdf:application/pdf},
}

@misc{noauthor_tutorial_nodate-1,
	title = {Tutorial - {Fault}-{Tolerant} {Quantum} {Computing} with {CSS} codes},
	url = {https://nordiquest.net/application-library/training-material/qas2024/notebooks/css_code_steane.html},
	keywords = {/unread},
}

@article{panteleev_degenerate_2021,
	title = {Degenerate {Quantum} {LDPC} {Codes} {With} {Good} {Finite} {Length} {Performance}},
	volume = {5},
	url = {https://quantum-journal.org/papers/q-2021-11-22-585/},
	doi = {10.22331/q-2021-11-22-585},
	abstract = {Pavel Panteleev and Gleb Kalachev,
Quantum 5, 585 (2021).
We study the performance of medium-length quantum LDPC (QLDPC) codes in the depolarizing channel. Only degenerate codes with the maximal stabilizer weight much smaller than their minimum dis…},
	language = {en-GB},
	urldate = {2026-01-29},
	journal = {Quantum},
	publisher = {Verein zur Förderung des Open Access Publizierens in den Quantenwissenschaften},
	author = {Panteleev, Pavel and Kalachev, Gleb},
	month = nov,
	year = {2021},
	note = {TLDR: It is shown that with the help of OSD-like post-processing the performance of the standard belief propagation (BP) decoder on many QLDPC codes can be improved by several orders of magnitude.},
	keywords = {/unread},
	pages = {585},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/WNJDDDCI/Panteleev and Kalachev - 2021 - Degenerate Quantum LDPC Codes With Good Finite Length Performance.pdf:application/pdf},
}

@article{babar_fifteen_2015,
	title = {Fifteen {Years} of {Quantum} {LDPC} {Coding} and {Improved} {Decoding} {Strategies}},
	volume = {3},
	issn = {2169-3536},
	url = {https://ieeexplore.ieee.org/document/7336474},
	doi = {10.1109/ACCESS.2015.2503267},
	abstract = {The near-capacity performance of classical low-density parity check (LDPC) codes and their efficient iterative decoding makes quantum LDPC (QLPDC) codes a promising candidate for quantum error correction. In this paper, we present a comprehensive survey of QLDPC codes from the perspective of code design as well as in terms of their decoding algorithms. We also conceive a modified non-binary decoding algorithm for homogeneous Calderbank-Shor-Steane-type QLDPC codes, which is capable of alleviating the problems imposed by the unavoidable length-four cycles. Our modified decoder outperforms the state-of-the-art decoders in terms of their word error rate performance, despite imposing a reduced decoding complexity. Finally, we intricately amalgamate our modified decoder with the classic uniformly reweighted belief propagation for the sake of achieving an improved performance.},
	urldate = {2026-01-29},
	journal = {IEEE Access},
	author = {Babar, Zunaira and Botsinis, Panagiotis and Alanis, Dimitrios and Ng, Soon Xin and Hanzo, Lajos},
	year = {2015},
	note = {TLDR: This paper conceive a modified non-binary decoding algorithm for homogeneous Calderbank-Shor-Steane-type QLDPC codes, which is capable of alleviating the problems imposed by the unavoidable length-four cycles.},
	keywords = {/unread, Decoding, Complexity theory, Quantum computing, Generators, iterative decoding, Iterative decoding, Quantum error correction, Iterative Decoding, low density parity check codes, Low Density Parity Check Codes, Quantum Error Correction, quantum low density parity check codes, Quantum Low Density Parity Check Codes},
	pages = {2492--2519},
	file = {Full Text PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/TRAQVN6J/Babar et al. - 2015 - Fifteen Years of Quantum LDPC Coding and Improved Decoding Strategies.pdf:application/pdf;PDF:/home/andreas/workspace/work/hiwi/Zotero/storage/K753QNFF/Babar et al. - 2015 - Fifteen Years of Quantum LDPC Coding and Improved Decoding Strategies.pdf:application/pdf},
}
