List Recovery Codes Overview

Updated 10 October 2025

List recovery codes are error-correcting methods that use candidate symbol lists per coordinate to recover codewords, generalizing unique and list decoding.
They follow a formal model where decoding requires matching candidate lists in nearly all positions, with capacity theorems delineating rate and error trade-offs.
These codes are pivotal in applications such as soft-decision decoding, compressive sensing, and robust algorithmic constructions in theoretical computer science.

List recovery codes are a fundamental class of error-correcting codes that generalize both unique decoding and list decoding by enabling the decoder to resolve uncertainty in each coordinate through input lists of candidate symbols. In the list recovery model, the decoder is provided, for each coordinate, with a list of at most ℓ possible symbols, and must output all codewords that agree with these lists in all but a fraction ρ of the positions. This powerful generalization admits robust recovery in “soft decision” or compression scenarios and underlies many modern advances in both coding theory and theoretical computer science.

1. Formal Notion of List Recovery

Let Σ be a finite alphabet of size q and fix positive integers n (block length) and ℓ (input list size). For a code $\mathcal{C} \subseteq \Sigma^n$ , and a tuple of subsets %%%%1%%%% with $S_i \subseteq \Sigma$ and $|S_i| \leq \ell$ , define the agreement set of a codeword $c = (c_1, \ldots, c_n)$ with $S$ as $\operatorname{agr}(c, S) := |\{i \in [n] : c_i \in S_i\}|$ . The code $\mathcal{C}$ is said to be $(\rho, \ell, L)$ –list recoverable if, for every S, the number of codewords $c \in \mathcal{C}$ with $\operatorname{agr}(c, S) \geq (1-\rho)n$ is at most L.

This paradigm interpolates:

Unique decoding ( $\ell=1$ , $L=1$ )
List decoding ( $\ell=1$ , $L > 1$ )
Erasure recovery (many $S_i = \Sigma$ , allowing coordinate erasures)
Soft-decision decoding (arbitrary small lists)

Given this generality, list recovery serves as an underlying primitive in a broad array of settings, including concatenated code design, expander codes, and algorithmic primitives for compressive sensing and group testing (Hemenway et al., 2015).

2. Capacity Theorems, Bounds, and Asymptotic Regimes

2.1 Capacity Upper and Lower Bounds

The list recovery capacity theorem determines the optimal tradeoff between rate, list size, list size per coordinate, and error fraction. For an alphabet of size $q$ and fixed input list size $\ell < q$ , the $q,\ell$ -ary entropy function is given by

$h_{q,\ell}(x) = x \log_q\left(\frac{q-\ell}{x}\right) + (1-x)\log_q\left(\frac{\ell}{1-x}\right)$

for $x \in (0, 1-\ell/q)$ . Then, for $\rho \in (0, 1-\ell/q)$ , a random code of rate $R < 1 - h_{q,\ell}(\rho) - \varepsilon$ is, with high probability, $(\rho, \ell, O(\ell/\varepsilon))$ –list recoverable (Resch et al., 8 Oct 2025, Resch et al., 2022, Resch et al., 2023).

Conversely, for $R > 1 - h_{q,\ell}(\rho) + \epsilon$ , no code of positive rate can be $(\rho, \ell, L)$ –list recoverable for constant $L$ (Resch et al., 2022). This establishes a sharply-defined list-recovery capacity threshold. The zero-rate “Plotkin threshold” $p_*(q, \ell, L)$ characterizes the maximal fraction of errors $p$ for which infinite families of positive-rate $(p, \ell, L)$ –list-recoverable codes exist. Above this threshold, such codes must be of constant size (and consequently have zero asymptotic rate) (Resch et al., 2022, Resch et al., 2023).

2.2 List Size Lower Bounds for Linear Codes

Random linear codes exhibit fundamentally different behavior compared to fully random (nonlinear) codes. For random linear codes of rate close to capacity, the minimal achievable list size L must obey $L \geq \ell^{\Omega(1/\epsilon)}$ when the rate is $1 - \log_q \ell - \epsilon$ (Guruswami et al., 2020, Li et al., 19 Feb 2025). In contrast, fully random codes achieve $L = O(\ell/\epsilon)$ . This exponential gap is particularly salient for erasure-type list recovery and for codes over extension fields or low-characteristic fields (Doron et al., 9 May 2025).

3. List Recovery Code Constructions and Notable Families

3.1 Folded Reed–Solomon and Algebraic-Geometric Constructions

Folding, originally devised for Reed–Solomon codes, groups sequence positions into “super-symbols” via an automorphism—in the case of folded RS, this is closely connected to the Artin–Frobenius automorphism in cyclotomic function fields and the Carlitz module (0811.4139). This produces codes whose algebraic structure supports powerful interpolation-based list recovery algorithms, achieving list recovery capacity with a significantly smaller (polylogarithmic) alphabet size compared to standard folded RS codes. This technique extends to folded algebraic–geometric codes and concatenated designs, supporting constructions of binary codes that reach the Zyablov radius without brute-force search for inner codes.

Algebraic–geometric (AG) codes and their subcodes also support efficient list recovery, which is crucial in both high-rate and high-distance regimes (Guruswami et al., 2015, Hemenway et al., 2017).

3.2 Expander-Based and Tensor Codes

Codes built from spectral expanders, especially via the Alon–Edmonds–Luby distance amplification technique and Tanner code constructions (Srivastava et al., 29 Apr 2025, Hemenway et al., 2015), allow “lifting” of the local list recovery properties of small base codes to global codes of high rate and good list recovery properties. Recent frameworks applying graph regularity lemmas enable efficient combinatorial and algorithmic list recovery up to capacity and provide near-linear time decoding algorithms.

Tensor product codes constructed from a base (globally) list-recoverable code inherit approximate local list recovery, which, when combined with high-rate locally decodable codes, yields explicit locally list-recoverable codes meeting capacity (Hemenway et al., 2017).

3.3 Random Linear and Permutation Codes

Random linear codes over general alphabets achieve list recovery capacity with list sizes $L=(\ell/\epsilon)^{O(\ell/\epsilon)}$ when $q=\ell^{\Omega(1/\epsilon)}$ (Li et al., 19 Feb 2025), a parameter regime shown to be optimal among linear codes. Random Reed–Solomon codes with random evaluation points achieve $L=O(\ell/\epsilon)$ over $q = \exp(\ell, 1/\epsilon) \cdot n^2$ and therefore meet optimal bounds (Doron et al., 30 Mar 2024). Permutation code constructions, such as alphabet-permutation (AP) codes (Komech et al., 9 Feb 2025), use coordinate-wise random permutations to bridge the gap between structure and randomness, attaining the optimal list recovery trade-off with polynomially-bounded randomness.

4. Singleton-Type and Combinatorial Bounds

Singleton-type bounds generalize the classic rate-distance trade-off to the list recovery context. For a $q$ -ary $(r, \ell, L)$ –list-recoverable code,

$|\mathcal{C}| \leq L \left(\frac{q}{\ell}\right)^{\, n - \lfloor \tfrac{L+1}{L+1-\ell} \, r n \rfloor}$

(Goldberg et al., 2021). This bound is tight up to constant factors and delineates explicit trade-offs between rate, list size, and recovery radius. A notable innovation is the explicit demonstration that nonlinear codes can outperform linear codes in the list recovery regime: the maximal size of list-recoverable nonlinear codes exceeds that of linear codes for a wide range of parameters, a phenomenon not observed in unique decoding (Goldberg et al., 2021). These separations are further illustrated by connections with the extremal combinatorics of sparse hypergraphs.

5. Connections, Applications, and Impact

5.1 Coding Theory and Computer Science

List recovery is essential in:

List decoding concatenated and folded codes to achieve capacity or the Zyablov radius (0811.4139, Hemenway et al., 2015, Hemenway et al., 2017).
Constructions of explicit matrices for compressive sensing and group testing, where list recovery guarantees yield efficient, robust measurement designs (Hemenway et al., 2015).
Expander and Tanner code designs, supplying explicit low-density parity-check (LDPC) families with near-linear decoding (Srivastava et al., 29 Apr 2025).
Primitives for compressed sensing, cryptography, and streaming algorithms (Resch et al., 8 Oct 2025).

List recovery—particularly in the zero-error regime—is closely connected to the resilience of secret sharing schemes to leakage. The bounds on list size and rate have direct impact on the entropy and security properties in leakage-resilient Shamir secret sharing (Resch et al., 8 Oct 2025). Connections with perfect hash families, expanders, and condensers/extractors reveal its foundational role in pseudorandomness and combinatorial constructions (Guo et al., 2020, Resch et al., 8 Oct 2025).

5.3 Insertions/Deletions and Novel Channels

List recovery has recently been used as a decoding primitive for codes subject to insertions and deletions (insdel errors). The reduction shows that any $(\rho, 2\rho n+1, L)$ –list-recoverable code is automatically a $(\rho, L)$ –insdel code, enabling efficient decoding of RS codes from both adversarial and random insdel errors, and adaptation of the Koetter–Vardy algorithm to synchronization error models (Banerjee et al., 5 May 2025).

6. Open Problems and Future Directions

Significant open questions remain:

Constructing explicit capacity-achieving list-recoverable codes with optimal (e.g., linear in $\ell$ ) list size, especially over small alphabets (Resch et al., 8 Oct 2025, Li et al., 19 Feb 2025, Doron et al., 9 May 2025).
Tightening the upper and lower bounds for list size in random linear codes to resolve the precise dependence on $\ell$ and $\epsilon$ (Resch et al., 2023, Li et al., 19 Feb 2025, Doron et al., 9 May 2025).
Extending list recovery bounds and constructions to other error metrics (e.g., beyond Hamming or for the Lee/ℓ₁ metrics as suggested in (Resch et al., 2023)).
Further understanding the fundamental price of linearity and the regimes where nonlinear or additive codes can surpass linear codes.
Derandomizing permutation code constructions or discovering additional structured code families (e.g., via expanders or algebraic-geometric techniques) that attain capacity with polynomial decoding complexity (Komech et al., 9 Feb 2025, Srivastava et al., 29 Apr 2025).
Exploring the short-length regime and leakage-resilient constructions for applications in secret sharing (Resch et al., 8 Oct 2025).

7. Representative Theoretical Table

Context	List Size $L$ (Random Codes)	List Size $L$ (Linear Codes)
Near list recovery capacity	$O(\ell/\epsilon)$	$\ell^{\Omega(1/\epsilon)}$
List recovery from erasures	$O(1/\epsilon)$	$O(1/\epsilon)$ over large primes
Zero-rate threshold regime	$O_{q,\ell,L}(1/\epsilon)$	$O_{q,\ell,L}(1/\epsilon)$

This table summarizes the dependence of achievable list size on the regime and code structure; see (Guruswami et al., 2020, Resch et al., 2022, Resch et al., 2023, Doron et al., 9 May 2025).

List recovery codes have thus emerged as a central concept unifying coding theory, combinatorial constructions, and algorithmic applications. Their theoretical power lies in generalizing and strengthening classical error correction guarantees, while their ongoing paper continues to shape the landscape of high-performance, robust, and efficient error-correcting codes and their applications across theoretical computer science.