List Decoding for Concatenated Codes

• List decoding concatenated codes is a decoding paradigm that outputs all codewords within a specified Hamming error radius, approaching information-theoretic limits.
• It leverages inner codes with robust list decoding and outer codes with list recovery, enabling capacity-achieving constructions like folded Reed–Solomon and AG codes.
• Recent advancements utilize algebraic interpolation, combinatorial proofs, and efficient kernel computations to reduce complexity and enhance practical decoding performance.

List decoding concatenated codes refers to decoding schemes and algorithms for concatenated code constructions that output not just a single most-likely codeword, but all codewords within a specified error radius, possibly up to the information-theoretic capacity limit. Concatenated codes—introduced to overcome limitations with alphabet size, decode-ability, and minimum distance—have become a foundational tool in constructing explicit codes with strong list decoding guarantees. The paper of list decoding for concatenated codes covers explicit constructions, algorithmic trade-offs, capacity-achieving results, complexity reductions, and advances in decoding architectures from both algebraic and probabilistic perspectives.

1. Principles of List Decoding and Concatenated Code Structure

List decoding generalizes unique decoding by seeking all codewords within a Hamming radius up to a fraction $\tau$ of the block length (often up to the “list decoding capacity” $1-R-\epsilon$ for rate $R$ and $\epsilon > 0$). Concatenated coding involves an outer code over a large alphabet and an inner code converting each symbol to a block over a smaller alphabet, allowing for high-rate, long, small-alphabet codes with explicit structure.

The central observation is that, for concatenated codes, if:

• The inner code is $(\rho, \ell)$–list decodable: every received block has at most $\ell$ codewords up to error fraction $\rho$;
• The outer code is $(\xi, \ell, L)$–list recoverable: for every collection of lists $S_1, ..., S_N$ (each of size $\leq \ell$), at most $L$ outer codewords agree with $S_i$ in $\geq$ $(1-\xi)N$ positions;

then the concatenated code is $(\rho\xi, L)$–list decodable. This framework, formalized in (Resch et al., 8 Oct 2025), enables powerful reductions: constructing codes with strong list decodability from components with appropriate list recovery or list decoding properties.

2. Capacity-Achieving and Efficient Explicit Constructions

Explicit capacity-achieving list decodable concatenated codes are a central achievement:

• Folded Reed–Solomon codes and algebraic-geometry (AG) codes evaluated on subfields or with folded/block/grouped evaluation achieve capacity in the list decoding model, i.e., correct up to a $1-R-\epsilon$ fraction of errors for any desired $R$ and $\epsilon>0$ (0811.4139, Guo et al., 2020, Berman et al., 26 Jan 2024).
• (Berman et al., 26 Jan 2024) introduces explicit subcodes of Reed–Solomon codes via a “permuted product code” (tensor product of two RS codes, with cyclic row shifts or via bivariate polynomial evaluation over orbits of two affine maps with coprime orders), yielding codes that are decodable up to the Singleton bound $1-R-\epsilon$ and with constant output list sizes, while enabling efficient linear-algebraic decoding instead of factorization-heavy root finding.

This unified approach generalizes earlier capacity-achieving codes, avoiding large polynomial alphabet expansions or pre-coding via sophisticated subspace designs. It enables the code length to approach the field size without being limited by folding/derivative/multiplicity constraints.

A summary table highlighting several capacity-achieving explicit constructions:

Construction (paper)	Code Type	List Decoding Radius	Output List Size	Alphabet Size	Decoding Complexity
Folded RS (e.g., (0811.4139))	Folded RS, AG	$1-R-\epsilon$	Poly($1/\epsilon$)	Poly(block length)	Poly($n$)
Permuted Product RS (Berman et al., 26 Jan 2024)	Permuted (tensor) RS, subcode	$1-R-\epsilon$	Constant in $w$	$\sim$ field size	Poly($n$)
AG codes + subspace designs (Guo et al., 2020)	AG with subfield eval	$1-R-\epsilon$	$\exp(\text{poly}(1/\epsilon))$	Constant in $1/\epsilon$	Poly($n$,$1/\epsilon$)

3. List Recovery and Its Role in Concatenated List Decoding

List recovery is a property of a code $C \subseteq \Sigma^N$: given a collection of input lists $S_1, ..., S_N$ (each $|S_i| \leq \ell$), $C$ has at most $L$ codewords which agree with $S_i$ at all but a $\xi$ fraction of positions. This property is crucial for outer codes in concatenated list decoding (Resch et al., 8 Oct 2025).

• If the inner code is $(\rho, \ell)$–list decodable and the outer code is $(\xi, \ell, L)$–list recoverable, the concatenated code is $(\rho\xi, L)$–list decodable.
• Random, folded, and expander-based outer codes can achieve nearly optimal list recovery bounds, while explicit AG code designs offer this property with small alphabet sizes (0811.4139, Guo et al., 2020).
• Limitations for linear outer codes (“bad” results), such as unavoidable exponential list sizes in $1/\epsilon$ near capacity over small alphabets or for certain field extensions, are a fundamental challenge in improving explicit constructions (Resch et al., 8 Oct 2025).

List recovery thus determines the efficiency and feasibility of concatenated list decoding, affecting both complexity and attainable radius.

4. Algorithmic Advancements, Complexity, and Practical Decoding

Several algorithmic improvements and trade-offs have been realized:

• Algebraic list decoding is achieved via interpolation and root-finding for polynomials or their linearized variants (0811.4139, Berman et al., 26 Jan 2024). For modern bivariate or product constructions, interoperability and block structure (e.g., block-triangular–Toeplitz matrices (Guo et al., 2020)), allow for efficient kernel computations and candidate enumeration in polynomial time, except for the final (typically constant-size) list extraction.
• List decoding up to the Johnson bound for Tanner, expander-amplified, and concatenated codes is possible via semidefinite relaxations in the Sum-of-Squares (SoS) hierarchy, converting spectral distance proofs into algorithmic “distance certificates” and covering in $n^{O(1/\epsilon^4)}$ time for degree and alphabet size kept constant (Jeronimo et al., 2023).
• For low-rate codes of moderate block length, concatenated schemes (e.g., RS outer + SISO-decoded binary convolutional inner codes) allow for “improved MRIP” selection during OSD/A* search, significantly reducing typical search complexity for list decoding (e.g., for $[128,36]$ codes, the list search can be truncated at lower error order $\lambda$ relative to BCH, with matching or better block error rate) (Lin et al., 15 May 2025).

These advances close the complexity-performance gap and enable practical decoding for high-reliability, low-latency, and moderate alphabet size settings.

5. Extensions: Expander-Based Codes, Applications, and Open Problems

Expander and distance-amplified codes provide new insights:

• Codes constructed via bipartite spectral expanders (e.g., Tanner codes, AEL distance-amplified codes), as well as locally testable codes from Cayley complexes, can be list decoded up to the Johnson bound by exploiting expansion properties and distance certificates, even without reliance on algebraic structure (Jeronimo et al., 2023).
• This “proofs to algorithms” paradigm—transforming combinatorial/spectral proofs of distance into convex relaxations (SoS solutions)—allows for explicit, deterministic algorithms for families such as LDPC codes and related sparse graph codes.
• These developments also impact other domains: in cryptography (e.g., leakage-resilient secret-sharing), pseudorandomness (via extractors/condensers), and streaming/group testing, the capacity-achieving and list recoverable properties are tightly intertwined (Resch et al., 8 Oct 2025).

Open questions include constructing explicit linear codes matching information-theoretic list recovery/list decoding capacity with polynomial (not exponential) list sizes, as well as optimizing trade-offs in rate, field size, and algorithmic complexity for short block lengths or small gaps to capacity.

6. Mathematical Formulations

Key formulas and constructs from the literature include:

• List recovery ball:

$$B_\rho(S) = \{ x \in \Sigma^n : \Delta(x, S) \leq \rho \},\quad \Delta(x,S) = \frac{1}{n}|\{ i: x_i \notin S_i \}|$$

• Concatenation result (folklore proposition, (Resch et al., 8 Oct 2025)): If the inner code is $(\rho, \ell)$–list decodable, and the outer code is $(\xi, \ell, L)$–list recoverable, the concatenated code is $(\xi\rho, L)$–list decodable.
• Product code with affine shift evaluation (from (Berman et al., 26 Jan 2024)):

$$\text{ev}_j(f) = \big( f(\ell_1^{jm+i}(\alpha),\ \ell_2^{jm+i}(\beta))\ :\ i=0,\dots, m-1 \big)$$

and $$Q(x,y, z_0,\ldots,z_{w-1}) = \sum_{i=0}^{w-1} p_i(x,y) z_i$$

• List size bounds often depend exponentially (or polynomially for some constructions) on $1/\epsilon$, the gap to capacity.

7. Impact, Limitations, and Directions

List decoding of concatenated codes is now understood not only as a powerful method for capacity-achieving error correction, but also as a linchpin in bridging algebraic, combinatorial, and probabilistic approaches in coding theory. Its efficiency depends critically on both the list decodability of the inner code and the list recovery of the outer code, with modern constructions leveraging sophisticated algebraic, combinatorial, and algorithmic tools.

Boolean limitations remain (especially for linearity or for specific field sizes), and achieving polynomial list sizes with explicit constructions at capacity is unresolved in some regimes. Continued research in the interplay of list recovery, expander amplification, and practical decoder architectures is ongoing, with anticipated applications across communication, computational complexity, and cryptography.