Distilling Knowledge from Search: Decoder Model Factory for Quantum LDPC Codes

Anil Bilgin; Wanda Hou; Pranav Srinivas; Yi-Zhuang You

quant-phOct 30, 2026

Distilling Knowledge from Search: Decoder Model Factory for Quantum LDPC Codes

Authors: Anil Bilgin, Wanda Hou, Pranav Srinivas, Yi-Zhuang You

Organizations: EdenCode Inc., San Jose, CA 95134, USA · Department of Physics, University of California, San Diego, CA 92093, USA

Abstract

We introduce GraphMP, a learning-based message-passing decoder for quantum low-density parity-check codes that transfers without fine-tuning across code families, code sizes, physical error rates, and noise models. GraphMP uses local message passing to keep computation scalable as the decoding graph grows. Guided by its predictions, beam search progressively refines candidate error patterns, trading additional decoding time for lower logical error rates. We develop the decoder model factory as a paradigm for training successive models on experience generated by earlier models during decoding. Model-guided search supplies verified trajectories for knowledge distillation, folding computation spent on decoding into reusable training data. Repeated collection and distillation improve the decoder across generations and adapt its strategy as the noise changes. These results motivate a coupled quantum--classical architecture with two interacting cycles: rapid decoding protects quantum information, while slower learning renews the models from operating experience. The long-term vision is a scalable decoder model factory that produces high-performance, low-latency decoders and continually adapts them to evolving quantum hardware.

Figures & tables

Figure 1: AI model factories connect a source of training data to new models and their applications. The language-model analogy motivates a corresponding process for quantum computing, with quantum hardware providing experimentally testable outcomes. The return arrows represent model assistance to humans or quantum hardware. In the illustrated approach, data generation supplies training examples, and distillation trains later models on these examples. This paper develops the decoding instance through supervised distillation from search trajectories, with outcome verification supplied by simulation; hardware learning, control, and calibration are prospective applications.

Figure 2: Proposed coupled quantum–classical deployment of a local learned decoder. Circles represent qubits and square groups represent local classical memory. Solid and dashed links indicate quantum couplings and classical message passing; vertical arrows carry measurement data and recovery feedback between the layers.

Figure 3: Detector error model. Hidden error events connect to the syndrome bits and logical observables they flip. The decoder sees the syndrome and predicts an error pattern. Highlighted nodes illustrate one realization and its syndrome and logical outcome.

Figure 4: GraphMP predicts errors through local message passing. The syndrome enters at detector nodes; shared learned updates update node states and messages, and error nodes read out probabilities. The same learned functions operate on different decoding graphs. Hidden states and logits are illustrative.

Figure 5: BP distillation supplies a transferable starting decoder, while leaving a gap to stronger classical methods. The three shaded code-capacity tasks supply training data; the other nine evaluate the same model without fine-tuning. Logical error rates use

2048

realizations per task. Bars above

0.15

are truncated. Training and comparison settings are in Appendix B .

Figure 6: Search turns successive conditional predictions into a coordinated error pattern. Each branch fixes an uncertain variable and predicts the rest again; pruning bounds the computation. The green frame marks the returned completion. This illustrative BP-guided tree shows the mechanism; the GraphMP implementation is specified in Appendix C.2 .

Figure 7: Inference-time search trades computation for accuracy. With the starting GraphMP model fixed, broader and deeper search lowers logical error while increasing decoding time. The surfaces aggregate the three training tasks; measurements and budgets are given in Appendix C.3 .

Figure 8: Outcome feedback selects search trajectories for training. The collector retains syndrome-consistent, logically correct final predictions together with the intermediate states along their search paths. This work obtains logical feedback in simulation, while dedicated quantum-memory experiments provide a route to device-based verification.

Figure 9: The GraphMP implementation alternates trajectory collection and model training. The current model guides search, selected trajectories are added to the accumulated data, and distillation produces its successor.

\mathsf{G_{x}}

and

\mathsf{G_{x}^{+}}

are the single-pass and search-enhanced decoders, and

\mathsf{D_{x}}

labels each trajectory dataset.

Figure 10: Successive models improve single-pass decoding and transfer that improvement to an unseen task. Dashed green curves show single-pass decoding; solid green curves show beam-search decoding. Horizontal lines show reference decoders. Curves are means over five independent model factory runs; bands are the range across those runs. Full generation results are in Appendix E.2 .

Figure 11: The final search-enhanced model

\mathsf{G_{3}^{+}}

compared with established decoders on

12

tasks. The three shaded tasks supply training data; the other nine test the same model without further training. Comparisons use the same

2048

error realizations per task, except for shorter Tesseract runs on the largest tasks. Bars above

0.04

are truncated. Decoder settings and evaluation procedures are specified in Appendix E.4 .

Figure 12: Accuracy and decoding time on a training task and an unseen task. Logical-error curves are fitted to measured data; bands are

90\%

bootstrap intervals conditional on that model. Times compare GPU GraphMP with single-core CPU reference decoders. They measure time per shot in a stream of syndromes. Fit diagnostics and timing procedures are in Appendices E.5 and E.6 .

Figure 13: Adaptation after the noise changes at

\mathsf{G_{3}}

. The same model is evaluated immediately before and after the switch from depolarizing to XZ noise;

\mathsf{G_{4}}

–

\mathsf{G_{6}}

learn from newly collected trajectories. (a)

\mathrm{Mitten}_{150}

supplies training data; (b)

\mathrm{LP}_{20}^{3,5}

tests adaptation without further training on that task. Dashed green curves show single-pass decoding; solid green curves show beam-search decoding. Relay-BP is evaluated with its original and updated noise priors; GraphMP’s beam-search candidate selector retains the original prior. Bands are

90\%

Wilson intervals. The full experiment is described in Appendix E.7 .

Appendix figures & tables29 assets

Supplementary material from the paper’s appendix.

Appendix

Family	Instance	$[[n,k,d]]$	Training	Ref.
Bivariate bicycle	$\mathrm{BB}_{144}$	$[[144,12,12]]$	yes	[ 6 ]
Bivariate bicycle	$\mathrm{BB}_{288}$	$[[288,12,18]]$	no	[ 6 ]
Generalized bicycle	$\mathrm{GB}_{180}$	$[[180,10,\leq 18]]$	yes	[ 5 ]
Generalized bicycle	$\mathrm{GB}_{900}$	$[[900,50,15]]$	no	[ 5 ]
Mitten	$\mathrm{Mitten}_{150}$	$[[150,30,10]]$	yes	[ 9 ]
Mitten	$\mathrm{Mitten}_{200}$	$[[200,40,12]]$	no	[ 9 ]

Appendix

Table 1: Code instances studied in the experiments. A yes marks a code used to train the decoder model. Distances written

\leq d

are the published upper bounds.

Panel of Figure 14 — Figure 14: Detector error model. The fault $e$ is drawn from the error-variable prior. The syndrome $s=He$ is observed; the logical error $l=Le$ is not.

	logical success ( $Lr=0$ )	logical error ( $Lr\neq 0$ )
syndrome consistent ( $Hr=0$ )	success	miscorrection
syndrome inconsistent ( $Hr\neq 0$ )	escape	failure

Appendix

Table 2: Classification of the residual

r=e\oplus\hat{e}

along syndrome consistency and logical outcome.

Objective	Probability model	Decision
$l$	$p(l\mid s)$	$\hat{l}=\arg\max_{l}p(l\mid s)$	MLD
$e$	$p(e\mid s)$	$\hat{e}=\arg\max_{e:\,He=s}p(e\mid s)$ , $\hat{l}=L\hat{e}$	MLE
$e_{i}$	$\prod_{i}p(e_{i}\mid s)$	$\hat{e}_{i}=\mathds{1}[\,p(e_{i}\mid s)\geq\tfrac{1}{2}\,]$ , $\hat{l}=L\hat{e}$	bit-wise MAP

Appendix

Table 3: Three training objectives and their probability models. MLD is optimal [ 10 , 23 ] ; MLE and bit-wise MAP are successive approximations.

Figure 15: Gradient signal of the two objectives at random initialization: SNR ( 8 ) of the gradient signal on the shared model parameters, estimated over

8

minibatches of

64

syndromes (mean over

5

initializations, bars the range), for

15

qLDPC codes at code-capacity depolarizing noise

p=0.05

. The dashed line marks

\mathrm{SNR}=1

. Codes sharing a distance are offset horizontally.

Decoder	Model input representation	Prediction target
AlphaQubit [ 27 ]	Roundwise stabilizer observations and positional information; optional soft readout and leakage features	Logical-observable errors
Astra [ 28 ]	Code Tanner graph and syndrome-node features	Per-error probabilities
GraphQEC [ 29 ]	Syndrome history on an extended code Tanner graph with data, check, and logical nodes	Logical flips
Foundation decoders [ 30 ]	Transformer: detector histories and relation embeddings; Neural-BP: DEM graph, priors, and syndrome	Transformer: logical flips; Neural-BP: error mechanisms
GraphMP (this work)	DEM detector–error graph, syndrome, and optional pin mask	Per-error probabilities

Appendix

Table 4: Representative model interfaces. Input representations and output targets are separate design choices. The demonstrated range of parameter reuse depends on the training and evaluation protocol.

Panel of Figure 16 — Figure 16: GraphMP forward pass. The syndrome $s$ and the mask $\mu$ are encoded. The decoding graph $H$ specifies the bipartite support of the $T$ check $\leftrightarrow$ variable message-passing rounds (dashed). Readout emits logits $z$ ; per-variable probabilities are $\sigma(z_{i})$ , with $\sigma$ the logistic sigmoid Eq. ( 10 ).

Label type	Input	Label	Teacher
Hard	$s$	$e^{\mathrm{tch}}\in\mathbb{F}_{2}^{n}$	simulator or a decoder
Soft	$s$	$z^{\mathrm{tch}}\in\mathbb{R}^{n}$	a decoder

Appendix

Table 5: Supervised formats. GraphMP distills from a simulator or a decoder teacher. A simulator supplies a hard label; a decoder may supply a hard label, a soft label, or both.

Figure 17: Logical error rate

p_{L}

of GraphMP, its BP teacher, and reference decoders on the decoding tasks of Appendix A.1 , with

2048

samples per task. The shaded band marks the three code-capacity training tasks. The same model is applied without fine-tuning to the unshaded unseen tasks. The BP teacher, BP+OSD/LSD, and Relay-BP configurations are those of Section A.5 .

Figure 18: Decoding-outcome profiles of GraphMP in single-pass decoding, its BP teacher, and Relay-BP. Each profile classifies decoding outcomes as in Table 2 . Columns report the fraction of error realizations in each category. The logarithmic scale keeps rare outcomes visible. The shaded bands between columns follow groups of error realizations from their bucket under GraphMP to their bucket under each reference decoder; band width shows how many realizations take that path. Percentages are pooled over three code-capacity training tasks.

Panel of Figure 19 — Figure 19: Beam search on a toy decoding task. Each box is a search state on the code’s Tanner graph. Squares are checks, filled according to the residual syndrome left by the predicted error. Circles are error variables, shaded by their predicted error probability from cream at $0$ to orange at $1$ . The soft decoder runs two rounds of belief propagation. A thick border marks a pinned variable. Each step pins the least-confident variable to $0$ and to $1$ . A state with no residual syndrome is completed (thick frame). The search returns the completed state of lowest weight, and the green edges mark the trajectory that leads to it.

Code	$p$	Single-pass	Search ( $W=8$ )	Search ( $W=32$ )
$\mathrm{BB}_{144}$	$0.08$	$2.21^{+0.28}_{-0.25}\%$	$0.55^{+0.15}_{-0.12}\%$	$0.46^{+0.14}_{-0.11}\%$
$\mathrm{Mitten}_{150}$	$0.05$	$4.06^{+0.37}_{-0.34}\%$	$0.67^{+0.17}_{-0.13}\%$	$0.33^{+0.12}_{-0.09}\%$
$\mathrm{GB}_{180}$	$0.08$	$3.91^{+0.37}_{-0.34}\%$	$0.73^{+0.17}_{-0.14}\%$	$0.51^{+0.15}_{-0.11}\%$
Pooled	—	$3.39^{+0.20}_{-0.18}\%$	$0.65^{+0.09}_{-0.08}\%$	$0.44^{+0.07}_{-0.06}\%$

Appendix

Table 6: Logical error rate

p_{L}

of GraphMP

\mathsf{G_{3}}

, with pointwise

90\%

Wilson confidence intervals. Each code is evaluated on

8192

sampled errors. Single-pass decoding and both search settings process the same samples; the pooled row contains

24\,576

samples. Single-pass decoding consists of one GraphMP forward pass. Search repeatedly queries that model with width

W

and maximum depth

R=10

Figure 20: The BP-distilled starting model

\mathsf{G_{0}}

at fixed search width

W=8

on the three code-capacity training tasks. The left endpoint is single-pass decoding; the remaining points increase the search depth. Residual-syndrome density of the predicted error pattern is shown above logical error rate, which is decomposed into failures and miscorrections. Shaded bands are

90\%

confidence intervals;

8192

shots per task, the same shots at every search depth.

Figure 21: Accuracy–cost tradeoff of beam search with the BP-distilled starting model $\mathsf{G_{0}}$ . (a) Pooled logical error rate $p_{L}$ over search width $W$ and depth $R$ on the three training tasks at nominal evaluation error-rate settings $0.08$ on $\mathrm{BB}_{144}$ , $0.05$ on $\mathrm{Mitten}_{150}$ , and $0.08$ on $\mathrm{GB}_{180}$ ; $24\,576$ shots per cell, with the same sampled errors in every cell. (b) Throughput-level decoding time (s/shot), averaged over the same three tasks. Circles mark the primary evaluation setting $W=8$ , $R=10$ .

	Failure rate when evaluated at
Model	root state	pinned states	final state
Root-state-trained	$95.7\pm 2.8\%$	$76.4\pm 6.3\%$	$47.5\pm 11.6\%$
Trajectory-trained	$88.0\pm 1.0\%$	$48.3\pm 3.6\%$	$15.5\pm 2.9\%$

Appendix

Table 7: The misalignment measured at the states a search visits. Two GraphMP models trained on the same trajectories, one on their root records only and one on every record, are evaluated at the recorded states of

622

held-out successful searches on

\mathrm{Mitten}_{150}

(nominal error-rate setting

0.06

, search width

W=32

). The root-state-trained model fails on most pinned states even though the pinned values are correct; the trajectory-trained model turns the pinned values into completions. The pinned-state column averages over the states of a trajectory and then over trajectories. Mean

\pm

standard deviation over

3

training seeds. A prediction fails when it is syndrome-inconsistent or logically incorrect. The probe evaluates students on selected teacher states that supply correct partial information.

	Single-pass		Search ( $W=8$ , $R=10$ )
	Root-state	Trajectory	Root-state	Trajectory
Joint failure rate	$3.62\pm 1.22\%$	$1.94\pm 0.16\%$	$0.68\pm 0.26\%$	$0.11\pm 0.02\%$

Appendix

Table 8: The same two models as Table 7 , deployed as decoders on

\mathrm{Mitten}_{150}

at nominal error-rate setting

0.03

. Trajectory training improves both modes, with the larger relative gain inside beam search. A prediction fails when it is syndrome-inconsistent or logically incorrect. Every model is scored on the same

32\,768

error realizations; mean

\pm

standard deviation over

3

training seeds. The comparison includes differences in source sampling as well as conditional-state training.

Panel of Figure 22 — Figure 22: The GraphMP collection-and-training loop for $x\geq 1$ . Accumulated data train $\mathsf{G_{x}}$ ; $\mathsf{G_{x}^{+}}$ collects verified trajectories that supply records $\mathsf{D_{x+1}}$ . Appending those records and advancing $x$ starts the next round. The labels B, C, and D refer to the preceding appendices.

Generation	Initialization	Training data	Data collection
$\mathsf{G_{0}}$	random	BP teacher	$\mathsf{G_{0}^{+}}$ collects $\mathsf{D_{1}}$
$\mathsf{G_{1}}$	random	$\mathsf{D_{1}}$	$\mathsf{G_{1}^{+}}$ collects $\mathsf{D_{2}}$
$\mathsf{G_{2}}$	$\mathsf{G_{1}}$	$\mathsf{D_{1}}$ $\cup$ $\mathsf{D_{2}}$	$\mathsf{G_{2}^{+}}$ collects $\mathsf{D_{3}}$
$\mathsf{G_{3}}$	$\mathsf{G_{2}}$	$\mathsf{D_{1}}$ $\cup$ $\mathsf{D_{2}}$ $\cup$ $\mathsf{D_{3}}$	—

Appendix

Table 9: Model initialization, training data, and subsequent data collection. Every model trains for

20\,000

updates on the three target tasks. The model factory run ends at

\mathsf{G_{3}}

Figure 23: Logical error rate of GraphMP versus generation. Dashed: single-pass decoder GraphMP

\mathsf{G_{x}}

; solid: search-enhanced decoder GraphMP

\mathsf{G_{x}^{+}}

. Horizontal lines: BP teacher, BP+OSD (BP+LSD on the phenomenological tasks), and Relay-BP. Curves are means over five independent model factory runs; bands are the range across those runs. The phenomenological panels have their own vertical axis.

Transition	Single-pass reduction	Search-enhanced reduction
$\mathsf{G_{0}}$ $\to$ $\mathsf{G_{1}}$	$3.495\;[3.072,3.975]$	$2.872\;[2.612,3.182]$
$\mathsf{G_{1}}$ $\to$ $\mathsf{G_{2}}$	$0.858\;[0.663,1.050]$	$0.242\;[0.199,0.293]$
$\mathsf{G_{2}}$ $\to$ $\mathsf{G_{3}}$	$0.309\;[0.224,0.480]$	$0.068\;[0.037,0.110]$

Appendix

Table 10: Reduction in the equal-task mean logical error rate, in percentage points, on the three code-capacity target tasks,

\mathrm{BB}_{144}

\mathrm{Mitten}_{150}

, and

\mathrm{GB}_{180}

. Each entry is the mean reduction over five independent model factory runs, followed by the range across those runs. Every model is evaluated on the same

8192

realizations per task.

	Single-pass $\mathsf{G_{3}}$			Search-enhanced $\mathsf{G_{3}^{+}}$
Task	Logical	Syndrome	Joint	Logical	Syndrome	Joint
Code-capacity $\mathrm{BB}_{144}$	$0.02239$	$0.02346$	$0.02439$	$0.005469$	$0.000073$	$0.005469$
Code-capacity $\mathrm{Mitten}_{150}$	$0.04216$	$0.06333$	$0.06343$	$0.006445$	$0.004028$	$0.006543$
Code-capacity $\mathrm{GB}_{180}$	$0.04131$	$0.04438$	$0.04438$	$0.007031$	$0.007080$	$0.007080$
Code-capacity $\mathrm{LP}_{20}^{3,5}$	$0.06807$	$0.07605$	$0.07605$	$0.004370$	$0.004419$	$0.004419$
Phenomenological $\mathrm{BB}_{144}$	$0.03054$	$0.04644$	$0.04712$	$0.002271$	$0.000220$	$0.002368$

Appendix

Table 11: Final-generation logical error rate, syndrome-inconsistency rate, and joint failure rate. Entries are mean probabilities over five independently trained models, each evaluated on the same

8192

realizations per task at the settings of Figure 23 . Joint failure means that the predicted error has a wrong logical outcome, a nonzero residual syndrome, or both.

Figure 24: Later datasets challenge a fixed decoder, while later models achieve higher label-relative completion on fixed datasets. Figure 24 (a): the highest nominal error-rate setting used for collection. Figure 24 (b) and Figure 24 (c): completion relative to the recorded final label, the fraction of states on which the prediction matches that label’s syndrome and logical outcome. Each cell pools up to $8192$ sampled records per target task; root and pinned states are sampled separately. Columns $\mathsf{D_{1}}$ – $\mathsf{D_{3}}$ are the new datasets defined in Appendix E.1 . These are diagnostics on the archived training buffers. $\mathsf{G_{0}}$ has no pin-conditioned input and is examined only at root states.

Figure 25: Logical error rate of the trained students, single pass (top) and beam search (bottom). Each panel pools three training seeds. Filled points pool the seeds; open points are the individual seeds. The

95\%

Wilson intervals summarize pooled shot-level variation; open points show variation across training runs. Scores follow Eq. ( 36 ) from the first legend entry to the second. In panel (c) both sets are

\mathsf{D_{2}}

collected by

\mathsf{G_{1}}

, one at a fixed error rate and one at an adaptive error rate. An escape counts as a logical success.

Figure 26: GraphMP

\mathsf{G_{3}^{+}}

against classical decoders on

12

decoding tasks at the nominal error-rate setting under each task; the same tasks and realizations as Figure 17 , except for shorter Tesseract prefixes (

256

realizations on code-capacity

\mathrm{GB}_{900}

\mathrm{LP}_{20}^{3,5}

and

\mathrm{LP}_{16}^{3,7}

, and

128

on phenomenological

\mathrm{LP}_{20}^{3,5}

). The three shaded tasks form the model factory’s target portfolio and supply its training data. The other tasks are unseen during training and evaluate transfer beyond that portfolio. Baseline configurations are defined in Section A.5 . Bars above

0.04

are truncated.

Code-capacity tasks
Task	GraphMP $\mathsf{G_{3}^{+}}$ $p_{L}$ [ $95\%$ CI]	BP+OSD/LSD $p_{L}$ [ $95\%$ CI]	Holm-adjusted paired $p$
$\mathrm{BB}_{144}$	$0.0083$ $[0.00519,0.0133]$	$0.0205$ $[0.0152,0.0276]$	$7.65\times 10^{-5}$
$\mathrm{Mitten}_{150}$	$0.00879$ $[0.00557,0.0139]$	$0.0215$ $[0.016,0.0287]$	$6.36\times 10^{-4}$
$\mathrm{GB}_{180}$	$0.0103$ $[0.00672,0.0156]$	$0.0376$ $[0.0302,0.0467]$	$3.33\times 10^{-16}$
$\mathrm{BB}_{288}$	$0.000977$ $[0.000268,0.00355]$	$0.00635$ $[0.00371,0.0108]$	$0.0047$
$\mathrm{Mitten}_{200}$	$0.00586$ $[0.00335,0.0102]$	$0.0244$ $[0.0186,0.032]$	$1.62\times 10^{-8}$

Appendix

Table 12: Statistical support for the fixed-model benchmark in Figure 26 . Entries give logical error probabilities and pointwise

95\%

Wilson intervals, including an upper bound when no logical error is observed. BP+OSD is used on the code-capacity tasks and BP+LSD on the phenomenological tasks. Paired

p

-values are adjusted across the

12

comparisons shown; this family excludes the other decoder arms.

Figure 27: Logical error rate against physical error rate on the six decoding tasks of Figure 23 , for GraphMP

\mathsf{G_{0}^{+}}

\mathsf{G_{3}^{+}}

, BP+OSD (BP+LSD on phenomenological tasks), and Relay-BP. Curves are fitted to the measured points; bands are pointwise

90\%

parametric-bootstrap intervals conditional on the fit family.

Figure 28: Decoding time per shot on the six tasks of Figure 27 . GraphMP runs on one GPU with the inference implementation described in the text (single-pass

\mathsf{G_{3}}

dashed, search-enhanced

\mathsf{G_{0}^{+}}

\mathsf{G_{3}^{+}}

solid, beam search in decoding mode); BP+OSD, BP+LSD, and Relay-BP run on one CPU core with one thread. Points above

1

s per shot are clipped, and BP+LSD is omitted on

\mathrm{LP}_{20}^{3,5}

above

p=0.03

, where it is excluded from the accuracy evaluation as well.

Figure 29: Generation progress after the noise model changes from the depolarizing noise model to the XZ noise model at

\mathsf{G_{3}}

. The nominal error-rate setting and decoding graph remain fixed. Dashed: single-pass decoder GraphMP

\mathsf{G_{x}}

; solid: search-enhanced decoder GraphMP

\mathsf{G_{x}^{+}}

; bands are

90\%

Wilson intervals on

8192

realizations per task. The BP teacher and Relay-BP step at

\mathsf{G_{3}}

to their logical error rate under the original prior; the faint lines give their rate under the updated prior. The model factory collects on the first three target tasks only;

\mathrm{LP}_{20}^{3,5}

is unseen during adaptation.

Figure 30: Training data for noise adaptation. Starting from the same

\mathsf{G_{3}}

collector, equal-budget continuations train on fresh depolarizing data or fresh XZ data. Logical error rate is shown for a single pass (top) and for beam search (bottom), on the same

8192

realizations per task under each noise model, averaged over three training seeds. Wilson intervals summarize the pooled shot-level variation; the mean weights the three target tasks equally. Each panel reports

Z_{A\to B}

of Eq. ( 36 ) from the depolarizing-data student to the XZ-data student. The unmodified

\mathsf{G_{3}}

mean is marked for reference. An escape counts as a logical success.

Quantum Error Correction Decoding

See all 17 papers

May 17, 2026

Maximum Likelihood Decoding of Quantum Error Correction Codes

Quantum error correction (QEC) is indispensable for realizing fault-tolerant quantum computation, yet its effectiveness hinges critically on the classical decoding algorithm that interprets noisy syndrome measurements. Among all possible decoding strategies, maximum likelihood decoding (MLD) is provably optimal, since it identifies the logical group with largest likelihood by summing over all possible errors within logical class consistent with the observed syndrome. Despite its optimality, MLD is computationally intractable in general (#P-hard), motivating a rich landscape of exact and approximate algorithms. In this topical review, we provide a unified perspective on MLD by surveying recent advances through three complementary lenses: statistical mechanics, tensor networks, and artificial intelligence. From the statistical mechanics viewpoint, the MLD problem maps onto evaluating partition functions of disordered spin models, enabling exact solutions for certain codes and noise models as well as threshold estimation via phase-transition analysis. From the tensor network perspective, approximate contraction of tensor networks on the code's factor graph yields decoders that closely approach MLD accuracy with polynomial computational cost. From the artificial intelligence perspective, neural-network-based decoders, including autoregressive generative models and recurrent transformers, learn to approximate the MLD distribution from data, achieving high accuracy with the parallelism afforded by modern hardware accelerators. We discuss the connections among these three approaches, review their application to both simulated and experimental quantum hardware, and outline open challenges including real-time decoding, scalability to large code distances, and generalization to high-rate quantum low-density parity-check codes.

Hanyan Cao, Ge Yan, Yuxuan Du +1

1Science, Mathematics and Technology Cluster, Singapore University of Technology and Design, 8 Somapah Road, 487372, Singapore · College of Computing and Data Science, Nanyang Technological University, Singapore, Singapore · School of Physical and Mathematical Sciences, Nanyang Technological University,2026 Singapore, Singapore

Quantum Error Correction Quantum Error Correction Decoding Error-Correcting Codes

Ask PDF

Jun 23, 2026

Large-Language-Model Discovery of Quantum LDPC Codes through Structured Concept Evolution

Quantum low-density parity-check codes promise low-overhead error correction, but high-performing constructions remain hard to find. Here we introduce structured concept evolution, in which a large language model (LLM) evolves construction programs and their internal search strategies by modifying the finite group, protograph shapes or entry-assignment rule. We search for codes with fewer than

600

data qubits and check weight at most

12

, optimizing

kd^2/n

or the circuit-level logical error rate. Our method improves on published lifted-product benchmarks in selected parameter regimes, with exactly certified distances for the leading results. Circuit-level optimization typically yields lower logical error rates than

kd^2/n

optimization, often despite smaller code distances. With the same evolution framework and step budget, the best LLM outperforms all random-mutation and hill-climbing runs on both objectives. Our results point to LLM-driven program search as an approach to designing general quantum LDPC codes.

Zidu Liu, Florian Marquardt

Max Planck Institute for the Science of Light, 91058 Erlangen, Germany · Department of Physics, Friedrich-Alexander University Erlangen-Nürnberg, 91058 Erlangen, Germany

Quantum LDPC Codes Quantum Error Correction Large Language Model-Guided Scientific Discovery Error-Correcting Codes

Ask PDF

Aug 16, 2026

Machine Learning Approaches to Decoding Topological Quantum Codes

Decoding is an essential component of quantum error correction (QEC), translating stabilizer measurement outcomes into corrective actions that suppress logical errors and preserve logical quantum information. Building fault-tolerant architectures requires increasing the code distance, which in turn places growing demands on decoding accuracy, scalability, and practical deployability. While a wide range of decoding algorithms have been proposed and demonstrated, achieving reliable, scalable, and real-time decoding remains a significant challenge. Machine-learning (ML) approaches are particularly well suited to this setting, as quantum error decoding is fundamentally a problem of processing large volumes of classical data with complex spatiotemporal correlations. This chapter surveys ML-based methods for quantum error decoding, with a focus on topological codes and an emphasis on architectural principles, practical performance, and real-time considerations. We first frame decoding as a learning problem and outline key paradigms, including discriminative, generative, and reinforcement-learning formulations. We then introduce the neural network building blocks that underpin most contemporary neural decoders and discuss how these components can be integrated to balance expressivity, scalability, and latency. Building on this architectural perspective, we review recent progress and benchmarks in neural decoding for memory experiments, and discuss real-time decoding, open challenges, and future directions toward scalable fault-tolerant quantum computing.

Changwon Lee, Tak Hur, Jeongwoo Jae +1

Department of Statistics and Data Science, Yonsei University, Seoul 03722, Republic of Korea · R&D center, Samsung SDS, Seoul 05510, Republic of Korea · Department of Applied Statistics, Yonsei University, Seoul 03722, Republic of Korea +1

Quantum Error Correction Decoding Neural Decoding Quantum Error Correction

Ask PDF

Abstract

Quantum Error Correction Decoding

Explore similar work

Maximum Likelihood Decoding of Quantum Error Correction Codes

Large-Language-Model Discovery of Quantum LDPC Codes through Structured Concept Evolution

Machine Learning Approaches to Decoding Topological Quantum Codes