Spatially coupled LDPC codes are a family of error-correcting codes built as a long chain of linked small graphs. When decoding works, it spreads along that chain like a wave. On the binary erasure channel, where every bit arrives either intact or marked as lost, this wave has an exact one-number description: the fraction of bits still missing. That description supports analytical scaling laws. These laws predict the frame error rate, meaning the fraction of codewords the decoder fails to recover, at any code length and any cap on decoding iterations, in minutes on a laptop. Real links add continuous Gaussian noise instead of clean erasures. There the decoder's state becomes a distribution of real-valued reliabilities, and the one-number description is lost. Engineers therefore fall back on Monte Carlo simulation, which is expensive because the quantity of interest is a rare event. At a frame error rate of $10^{-5}$, a million simulated frames yield about ten useful "labels," that is, ten observed failures.
This note treats that situation as a label-efficiency problem. Failures are the scarce labels. The decoding trajectory of every frame, including the many that succeed, is abundant unlabeled data. We propose to learn, without any failure labels, a scalar coordinate of the Gaussian-channel decoder state whose dynamics behave like the drifting, diffusing wave front of erasure theory. We then reuse the erasure-channel first-passage machinery on that learned coordinate to predict frame error rates. The idea in two sentences: every successful decode still shows how fast and how erratically the decoding wave moves, and on the erasure channel those two numbers already determine the error rate. We learn which compression of the Gaussian-channel decoder state makes those two numbers well defined, so that the same simulations give a much better error-rate estimate than counting failures.
Core Claim
Finite-Length Scaling of SC-LDPC Codes With a Limited Number of Decoding Iterations models iteration-limited decoding on the erasure channel as a race. A decoding front moves with a drift (average speed per iteration) and a jitter, modeled as an Ornstein–Uhlenbeck process or a Gaussian process. Failure is the event that the front does not finish before the iteration deadline. For sliding-window decoding, failure is the window edge overtaking the front, which reduces to a Fokker–Planck first-passage problem. The authors state two limits. Their variance parameter must be "primed" with simulations, and the models are not shown to predict Gaussian-channel performance. We claim that the race structure itself transfers to the Gaussian channel once the front is read from a suitable learned scalar summary of the decoder messages. We further claim that the race parameters can be estimated from trajectory increments of ordinary simulated frames rather than from failure counts. This yields frame-error predictions well below $1/B$ from a budget of $B$ frames, a regime where direct Monte Carlo usually observes zero errors.
What would be new is the following. No paper in our file estimates finite-length or finite-iteration error rates on continuous channels from unlabeled decoder trajectories. No paper learns the reduced state with a predictability objective in the spirit of self-supervised forecasting, such as contrastive predictive coding (CPC), rather than with supervised error labels.
Research Program
We first instrument a belief-propagation decoder for coupled codes, in both iteration-limited flooding and sliding-window modes, so that it records a per-position summary of the messages at every iteration. Each spatial position of the chain contributes a small vector, for example a binned histogram of posterior reliability magnitudes. An encoder $\phi$ maps each such vector to a scalar $u \in [0,1]$, read as an "effective erased fraction." The front position $x_t$ at iteration $t$ is the point along the chain where $u$ crosses one half.
The encoder has two anchors that prevent it from collapsing to an uninformative constant. On the erasure channel, $\phi$ must reproduce the true erased fraction, so the erasure theory is recovered exactly as a special case. At the endpoints, a fully decoded position must map to 0 and an untouched channel prior must map to its known capacity-equivalent value.
Within these anchors, $\phi$ and the race parameters are fit jointly. The objective is to make front increments as predictable as possible under a one-dimensional drift-diffusion model:
$$ \min_{\phi,\,v,\,\sigma}\; \sum_{\text{frames}}\sum_{t} \left[ \frac{(\Delta x_t - v)^2}{2\sigma^2} + \log \sigma \right], $$
Here $\Delta x_t$ is the front displacement between iterations $t$ and $t+1$, $v$ is the drift, and $\sigma$ is the per-iteration jitter. Both $v$ and $\sigma$ may depend on the channel parameter and on the local coupling structure. The objective is the Gaussian negative log-likelihood of the increments. It plays the role of a pretext task: it rewards a summary whose future is predictable from its present, and it uses no information about whether the frame was decoded correctly.
Given $(v,\sigma)$, we compute the frame error rate as the first-passage probability. For iteration-limited flooding this is the probability that the front fails to traverse the chain within $T$ iterations. For sliding-window decoding it is the probability of hitting the absorbing boundary set by the window, using the Fokker–Planck solution of the existing paper unchanged.
The analysis has a second, scientific output that matters regardless of whether the predictor wins. On the Gaussian channel, decoders can confidently flip bits the wrong way. These miscorrections violate the independence assumptions of density evolution, the standard method for tracking message distributions across iterations. In our coordinate they should show up as backward or heavy-tailed front steps. We will measure how far the learned increments depart from Gaussian and Markov behavior as a function of noise level. That measurement maps where erasure-style reasoning stops working on continuous channels. If the departure is large near threshold, we will replace the Gaussian increment model with a two-component mixture (normal steps plus occasional setbacks). We will report how much that change costs in simplicity.
Channel generalization is tested by fitting $\phi$ once on AWGN (additive white Gaussian noise) and reusing it, with only $(v,\sigma)$ re-estimated from new trajectories, on block-fading and impulsive-noise channels simulated in the differentiable Sionna stack used by PyJama.
Baselines
The naive reference is direct Monte Carlo on the same $B$ frames our method sees: count failures and divide by $B$, with Clopper–Pearson intervals. This baseline is fair by construction, because both estimators consume identical simulations and differ only in what they extract from them. We beat it if, at matched $B$, our log-error-rate estimate has smaller error against a high-budget reference. The cases that matter most are those where the true rate is below $1/B$ and Monte Carlo returns zero.
The strongest existing analytical competitor is the Shifted Gaussian race model of Finite-Length Scaling of SC-LDPC Codes With a Limited Number of Decoding Iterations, transplanted to AWGN. We will fit its variance parameter from a single Monte Carlo priming point on the Gaussian channel, exactly as the authors do on the erasure channel, and give it the same frame budget for that priming point. The paper reports accurate modeling of the iteration-limited waterfall on the erasure channel for $(5,10,L,N)$ and $(4,12,L,N)$ ensembles, as the iteration limit drops from 300 to 175. For a Gaussian-channel version of this baseline we found no reported result on Lacuna, so its accuracy there must be measured in this project. We beat it if our predictions track the reference across code lengths and iteration limits that were not used for priming, where a single-point calibration is expected to drift.
The strongest learned competitor is a supervised error-rate surrogate in the style of Using Deep Neural Networks to Predict and Improve the Performance of Polar Codes. That work regresses Monte Carlo error rates with a residual network and reports an average inflation of error, the relative gap between predicted and simulated error rate, of 2.65% on (256,128) polar codes and 5.46% on (1024,512). Those numbers are for polar codes at a single noise level, so they indicate the precision a supervised surrogate can reach, not a figure we can compare to directly. We will train such a surrogate on (length, iteration limit, window size, noise level) to measured error rates, using the same total frame budget split across its training points, with equal hyperparameter-search budget. We beat it if we match or exceed its accuracy at a fraction of the frames, and if we extrapolate below the error rates present in its training labels, which it cannot do by design.
The ablation that isolates the key ingredient keeps everything identical but replaces the learned $\phi$ with a hand-defined front. Candidates are the per-position fraction of unsatisfied parity checks, and the fraction of variable nodes whose reliability magnitude is below a fixed threshold. A second ablation keeps $\phi$ but drops the erasure-channel anchor, to test whether that anchor is what makes the coordinate transfer.
Why not just…?
Why not just use density evolution or the Gaussian approximation? These track message distributions without simulation. However, they assume unlimited iterations and infinite length, and the finite-iteration paper above shows that asymptotic analysis does not capture the waterfall shift when iterations are capped. The Léonardon–Gripon work also notes that the Gaussian approximation breaks down for list decoding. Our method keeps the finite-length, finite-iteration race structure that these tools discard. We will still include the Gaussian approximation's threshold as a sanity check on the learned drift going to zero.
Why not just run more Monte Carlo, perhaps with importance sampling? For the waterfall region of a single code, brute force is often affordable. The cost appears when sweeping length, coupling depth, window size and iteration cap jointly, as code designers must. A biased-noise importance sampler would be a legitimate competitor, but none appears in our file, and designing a good biasing distribution for a long coupled chain is its own open problem. Because our estimator reuses the same frames as plain Monte Carlo, it can be combined with importance sampling later rather than competing with it.
Why not just use a hand-picked front such as the unsatisfied-check profile? This is the real threat. If a hand-defined front already yields near-Gaussian increments and accurate first-passage predictions, the learned encoder adds little. The contribution would then reduce to "estimate race parameters from trajectories, not failures," which is still useful but smaller. The hand-front ablation decides this directly, and we will report it as the headline comparison rather than bury it. Our expectation is that hand-defined fronts are noisy near threshold, where miscorrections make check counts unreliable, but this is a prediction to test, not evidence.
Why not just learn a better decoder instead of predicting the old one? Supervised neural decoders such as Neural Window Decoder for SC-LDPC Codes reduce error rates (a reported 3x lower frame error rate at 2.5 dB on a (3,6) protograph code of length 20,000). They do not tell a designer how a code will behave at other lengths or iteration caps, and they themselves need error-rate evaluation. Our predictor is complementary and can be applied to that neural decoder's trajectories as a further test.
Proposed Experiments
The primary benchmark is the $(5,10,L,N)$ and $(4,12,L,N)$ coupled ensembles from the finite-iteration study, run on AWGN with iteration caps between 175 and 300. The secondary benchmark is the protograph (3,6) code of length 20,000 under sliding-window decoding from the neural window decoder paper, which tests the window-overtaking variant. Reference error rates come from high-budget cluster Monte Carlo down to about $10^{-6}$. We restrict the study to the waterfall region and state plainly that error floors caused by trapping sets lie outside what a front-diffusion model can describe.
Accuracy is reported as inflation of error and as absolute error in $\log_{10}$ error rate, plotted against frame budget from $10^3$ to $10^6$.
Three checks are decisive. First, at a fixed small budget, the learned-front predictor must beat direct Monte Carlo and the AWGN-primed Shifted Gaussian model on held-out lengths and iteration caps. Second, it must beat the hand-defined front ablation, or we concede the encoder is unnecessary. Third, with $\phi$ frozen from AWGN, re-estimating only drift and jitter on fading and impulsive channels must keep the prediction error within a factor comparable to the AWGN case.
A failure of the third check, combined with strongly non-Gaussian increments, would itself show that miscorrection dynamics, not only the dimensionality of the message state, limit the transfer of erasure-channel theory to continuous channels.