Guessing Codeword Decoding (GCD)

• Guessing Codeword Decoding (GCD) is a universal, ML-optimal strategy that generates and tests candidate codewords in order of decreasing likelihood for binary linear codes.
• It leverages soft-weight metrics and structural constraints to reduce query complexity, particularly benefiting low to moderate code rate scenarios.
• Variants incorporating list decoding, soft-output techniques, and early stopping rules provide precise performance guarantees and enhanced hardware efficiency.

Guessing Codeword Decoding (GCD) is a universal, maximum-likelihood (ML)-optimal decoding approach for binary linear codes, as well as a rigorous information-theoretic framework for analyzing the guesswork required to identify codewords in both channel and source coding contexts. GCD algorithms operate by generating and testing codeword candidates (or structured hypotheses regarding the information part of codewords) in order of decreasing likelihood, rather than directly guessing the noise pattern as in GRAND (Guessing Random Additive Noise Decoding). GCD is particularly effective at low to moderate code rates, and has connections to the statistical mechanics of guesswork, Rényi entropy, large deviations, and practical soft-input/soft-output decoding methodologies. Its variants, including list-based, soft-output, abandonment/truncation, and structural augmentations (SPC, syndrome constraints, codeword constraints), yield substantial complexity reductions and provide precise performance guarantees.

1. Theoretical Foundations and Definitions

The GCD paradigm generalizes the notion of guesswork to the identification of codewords or source words given probabilistic or channel observations. For a finite alphabet $\mathcal{A}$, a word $X^n=(X_1,\dots,X_n)$ is produced i.i.d. with $\Pr\{X_i=a\}=p(a)$. The guesswork $G(X^n)$ is the ranking of $X^n$ among all possible words under a guessing order optimal for the known source law (or under specified constraints). The expected guesswork is characterized by a scaled cumulant-generating function,

$$\Lambda(\alpha) = \lim_{n\rightarrow\infty} \frac{1}{n} \log \mathbb{E}[G(X^n)^\alpha], \qquad \alpha > -1,$$

which is directly linked to the Rényi entropy, $R(\beta)$, via

$$\Lambda(\alpha) = \alpha R\left( \tfrac{1}{1 + \alpha} \right).$$

For words drawn from the typical set $T_\epsilon^n$, the exponential rate at which the average guesswork grows is governed by the true conditional law $\Lambda_{\rm true}(1)$, not by the naive uniform approximation $\Lambda_{\rm unif}(1)$, and the difference is exponential in blocklength $n$ (Christiansen et al., 2013).

In the context of channel coding, the GCD algorithm for linear block codes operates by generating information-part “partial error patterns” or “test codewords” in non-decreasing order of soft weight (as measured by, e.g., $\sum e_i |\mathrm{LLR}_i|$), extending these via the generator matrix to full codeword candidates, and stopping when subsequent candidates cannot surpass the current ML metric (Ma, 30 Jan 2024, Wang et al., 15 Nov 2025). This principled ordering yields ML-optimal decoding with greatly reduced search space compared to grand-style noise guessing for low and moderate rate codes.

2. Algorithmic Implementations and Early-Stopping Rules

The standard GCD procedure begins by transforming the parity-check matrix $H$ into systematic form, allowing the error pattern $e$ to be partitioned as $(e_I, e_P)$. For each $K$-bit hypothesis $e_P$, the corresponding parity component $e_I$ is uniquely determined by the syndrome, and the full candidate codeword is evaluated. Efficient enumeration strategies, such as Flipping Pattern Tree (FPT) search and Hamming/soft-weight-ordered generators (e.g., ORBGRAND), traverse the $K$-bit guess space in optimal order (Zheng et al., 6 May 2024, Wang et al., 15 Nov 2025, Griffin et al., 14 Nov 2024).

Early stopping criteria play a central role in practical GCD:

• Trivial (ML-safe) rule: halt when the cost of the next information-part hypothesis is no longer lower than the best full candidate seen so far. This guarantees ML-optimality (Ma, 30 Jan 2024, Wang et al., 15 Nov 2025).
• Dynamic Approximate Ideal (DAI) and truncation: stop based on thresholds or budget limits on number of queries, cumulative soft weight, or cumulative posterior probability. Truncation-induced performance loss can be tightly upper bounded using saddlepoint/large-deviation techniques (Zheng et al., 6 May 2024, Wang et al., 15 Nov 2025).

Algorithmic complexity per query for GCD is $O((n-k)k)$ (syndrome-based re-encode) versus $O((n-k)n)$ for GRAND/GND, with worst-case $O(2^k)$ queries, but average search size can be orders of magnitude smaller, especially at low rate or high SNR (Ma, 30 Jan 2024, Wang et al., 15 Nov 2025).

3. Optimality, Abandonment, and Source Coding Connections

GCD decoding is provably ML-optimal for any binary linear code, as established via injectivity (every untried information hypothesis yields no lower metric than the best so far) (Ma, 30 Jan 2024). In source coding and cryptanalysis, the average guesswork required to identify a codeword from a typical set is strictly sub-exponential compared to the uniform approximation, and precise asymptotic (and refined non-asymptotic) exponent formulas are available via Rényi entropy and large deviations (Christiansen et al., 2013, Sason et al., 2018).

Abandonment GCD—decoding with enforced query budget $m_n$—has its first- and second-order performance characterized precisely. The achievable region in $(R_n, r_n)$ (code rate vs. abandonment rate) is fully described: $$0 \leq R \leq C(W), \qquad H_{P_X \times W}(X|Y) \leq r \leq H(P_X),$$ with error probability converging to zero or one depending on location in this region (Tan et al., 9 Feb 2025). This sharp characterization confirms that GCD with abandonment is rate-wise optimal over DMCs.

For deletion/insertion synchronization codes, GCD instantiated as "guess and check" codes (GC codes) enables polynomial-time list decoding with optimal redundancy scaling $O(\delta \log k)$, average list size near 1, and bounded maximum list size—even for constant $\delta$ (number of deletions) (Hanna et al., 2018).

4. Soft-Output, List Decoding, and Accuracy Enhancement

Modern GCD algorithms provide not only a hard decision, but also blockwise and bitwise soft output (SO-GCD) by leveraging the knowledge of all tested and untested candidate codewords (Duffy et al., 17 Jun 2024, Feng et al., 20 Mar 2025). The per-candidate a posteriori probability is estimated as

$$p_{C^n|R^n}(c^{n,i}|r^n) \approx \frac{p_{N^n|R^n}(Z^{n,i}|r^n)} {\sum_{j=1}^L p_{N^n|R^n}(Z^{n,j}|r^n) + (1 - S_N) \frac{2^k - 1}{2^n - 1} }$$

where $S_N$ is the cumulative likelihood of all guesses made. Bitwise soft outputs (LLRs) are then constructed by appropriate pooling of these probabilities with the channel priors.

Enhanced soft-output precision is available by integrating code constraints (e.g., parity, even code, etc.) into the "missing mass" probability for unqueried codeword candidates. This refinement is quickly computable and, as shown by blockwise Brier Score analysis, brings SO-GCD within 0.2 dB of the ML soft output with only a short list of candidates ($L\leq 2$) (Feng et al., 20 Mar 2025).

Parallelization strategies, such as two-stage factorization of information bits, enable substantial reductions in latency by distributing the search over $2^\delta$ concurrent processes (Zheng et al., 6 May 2024).

5. Exploiting Code and Channel Structure

GCD is especially amenable to improvements that leverage codebook or correlation structure:

• Single-parity-check (SPC) augmentation: Introducing a full-message parity bit enables skipping half of all information-pattern queries, yielding up to $2\times$ speed-up in guesswork at low SNR without performance loss (Griffin et al., 14 Nov 2024). This requires a pattern generator that can restrict enumeration by parity (e.g., ORBGRAND).
• Exploiting channel correlations: ORBGRAND-AI allows GCD to utilize both intra- and inter-block noise correlation. Partial correlation (GP variant) reduces query count by up to $90\%$ versus fully uncorrelated search, while full total-correlation exploitation (GT variant) yields additional $0.75$ dB BLER improvement at moderate computational overhead (Feng et al., 10 Nov 2025).
• Hybrid and structured variants: OSD-type variants (LC-OSD, ROSD, Quasi-OSD) trade Gaussian elimination burden for search size adjustment, targeting application-specific latency, hardware complexity, and SNR regime optimization (Ma, 30 Jan 2024).

A summarizing table of GCD enhancements:

Enhancement	Key Effect	Reference
SPC-aided GCD	$\leq 2\times$ fewer guesses	(Griffin et al., 14 Nov 2024)
ORBGRAND-AI	Exploit channel correlation	(Feng et al., 10 Nov 2025)
Parallel GCD	Reduced latency	(Zheng et al., 6 May 2024)
Code constraints in SO-GCD	Sharper soft output	(Feng et al., 20 Mar 2025)

6. Complexity, Trade-offs, and Comparison to Other Decoders

The average number of GCD queries is governed by the code rate, SNR, and ordering metric. Saddlepoint approximations provide tractable and tight complexity forecasts for practical regimes (Wang et al., 15 Nov 2025).

• Versus GRAND/GND: For low-rate codes, GCD requires significantly fewer queries and the per-query cost is lower ($O((n-k)k)$ vs. $O((n-k)n)$) (Ma, 30 Jan 2024, Wang et al., 15 Nov 2025).
• Versus OSD: GCD eliminates the need for online Gaussian elimination; the number of partial-pattern queries is usually less, and the implementation is hardware-efficient (Zheng et al., 6 May 2024).
• Versus SOGRAND-assisted dynamic list decoders: Recent work shows SOGRAND and related list-decoders can match GCD's BLER while reducing guesswork by up to a factor of $32$, by dynamically terminating the search based on precise error probability estimates (Rapp et al., 28 Mar 2025).

For arbitrary codes, the recommended regime for GCD is at rate $k/n<0.5$, where it vastly outpaces noise-guessing approaches; at very high rates, GRAND becomes preferable (Wang et al., 15 Nov 2025).

7. Broader Context: Source Coding, Typical Sets, and Reliability Functions

The guesswork exponent for GCD in source identification or cryptographic settings is strictly controlled by the actual conditional law, not the uniform distribution over the typical set. Using the uniform approximation overestimates both security and query requirements by an exponential factor (Christiansen et al., 2013). For lossless source coding, refined non-asymptotic bounds for guessing moments obtained via Rényi entropy immediately yield tighter cumulant generating function and reliability function bounds for variable-to-fixed and almost-lossless source codes (Sason et al., 2018).

In summary, Guessing Codeword Decoding offers a mathematically principled and practically flexible family of universal decoders and source identifers that harness code and channel structure for efficient, ML-optimal inference. The GCD framework subsumes and extends both classical list/constrained and noise-centric algorithms, admits rigorous performance and complexity guarantees, and is directly adaptable to a wide range of structured and unstructured channel models, making it an essential component of next-generation short-blocklength, low-latency, or reliability-critical communication and storage systems.