---
title: List Recovery Codes Overview
url: https://www.emergentmind.com/topics/list-recovery-codes
type: topic
---

# List Recovery Codes Overview

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 $S = (S_1, S_2, \ldots, S_n)$ 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 [1503.01955].

## 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 [2510.07597, 2210.07754, 2309.01800].

Conversely, for $R > 1 - h_{q,\ell}(\rho) + \epsilon$, no code of positive rate can be $(\rho, \ell, L)$–list recoverable for constant $L$ [2210.07754]. 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) [2210.07754, 2309.01800].

### 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$ [2004.13247, 2502.13877]. 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 [2505.05935].

## 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 [1508.00603, 1706.03383].

### 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 [2504.20333, 1503.01955], 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 [1706.03383].

### 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)}$ [2502.13877], 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 [2404.00206]. Permutation code constructions, such as alphabet-permutation (AP) codes [2502.05858], 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}
$$
[2112.05592]. 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 [2112.05592]. 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, 1503.01955, 1706.03383].
- Constructions of explicit matrices for compressive sensing and group testing, where list recovery guarantees yield efficient, robust measurement designs [1503.01955].
- Expander and Tanner code designs, supplying explicit low-density parity-check (LDPC) families with near-linear decoding [2504.20333].
- Primitives for compressed sensing, cryptography, and streaming algorithms [2510.07597].

### 5.2 Cryptography, Secret Sharing, and Pseudorandomness

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 [2510.07597]. Connections with perfect hash families, expanders, and condensers/extractors reveal its foundational role in pseudorandomness and combinatorial constructions [2011.04453, 2510.07597].

### 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 [2505.02452].

## 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 [2510.07597, 2502.13877, 2505.05935].
- Tightening the upper and lower bounds for list size in random linear codes to resolve the precise dependence on $\ell$ and $\epsilon$ [2309.01800, 2502.13877, 2505.05935].
- Extending list recovery bounds and constructions to other error metrics (e.g., beyond Hamming or for the Lee/ℓ₁ metrics as suggested in [2309.01800]).
- 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 [2502.05858, 2504.20333].
- Exploring the short-length regime and leakage-resilient constructions for applications in secret sharing [2510.07597].

## 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 [2004.13247, 2210.07754, 2309.01800, 2505.05935].

---

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 study continues to shape the landscape of high-performance, robust, and efficient error-correcting codes and their applications across theoretical computer science.

Source: https://www.emergentmind.com/topics/list-recovery-codes