On List Recovery of High-Rate Tensor Codes

We continue the study of list recovery properties of high-rate tensor codes, initiated by Hemenway, Ron-Zewi, and Wootters (FOCS’17). In that work it was shown that the tensor product of an efficient (poly-time) high-rate globally list recoverable code is <italic>approximately</italic> locally list recoverable, as well as globally list recoverable in <italic>probabilistic</italic> near-linear time. This was used in turn to give the first capacity-achieving list decodable codes with (1) local list decoding algorithms, and with (2) <italic>probabilistic</italic> near-linear time global list decoding algorithms. This also yielded constant-rate codes approaching the Gilbert-Varshamov bound with <italic>probabilistic</italic> near-linear time global unique decoding algorithms. In the current work we obtain the following results: 1) The tensor product of an efficient (poly-time) high-rate globally list recoverable code is globally list recoverable in <italic>deterministic</italic> near-linear time. This yields in turn the first capacity-achieving list decodable codes with <italic>deterministic</italic> near-linear time global list decoding algorithms. It also gives constant-rate codes approaching the Gilbert-Varshamov bound with <italic>deterministic</italic> near-linear time global unique decoding algorithms. 2) If the base code is additionally locally correctable, then the tensor product is (genuinely) locally list recoverable. This yields in turn (non-explicit) constant-rate codes approaching the Gilbert-Varshamov bound that are <italic>locally correctable</italic> with query complexity and running time <inline-formula> <tex-math notation="LaTeX">$N^{o(1)}$ </tex-math></inline-formula>. This improves over prior work by Gopi et. al. (SODA’17; IEEE Transactions on Information Theory’18) that only gave query complexity <inline-formula> <tex-math notation="LaTeX">$N^{ \varepsilon }$ </tex-math></inline-formula> with rate that is exponentially small in <inline-formula> <tex-math notation="LaTeX">$1/ \varepsilon $ </tex-math></inline-formula>. 3) A nearly-tight combinatorial lower bound on output list size for list recovering high-rate tensor codes. This bound implies in turn a nearly-tight lower bound of <inline-formula> <tex-math notation="LaTeX">$N^{\Omega (1/\log \log N)}$ </tex-math></inline-formula> on the product of query complexity and output list size for locally list recovering high-rate tensor codes.


I. INTRODUCTION
E RROR-CORRECTING codes enable protection of data from errors. They allow one to encode a message so that even after some symbols of the encoding get changed, the original message can still be recovered.
Formally, an error-correcting code of blocklength n over a finite alphabet Σ is a subset C ⊆ Σ n . If k is such that |C| = |Σ| k , then a k symbol message can be encoded using this code. The redundancy of the code is measured by the rate ρ = k/n (so that |C| = |Σ| ρn ). The robustness to errors is measured by its relative distance δ, defined to be the minimum, over all distinct x, y ∈ C, of the relative Hamming distance dist(x, y). A basic but important observation is that for codes with relative distance δ, for every w ∈ Σ n , there is at most one codeword c ∈ C for which dist(w, c) < δ/2. Finding this codeword given w is the algorithmic problem of unique decoding C up to half the minimum distance.
Given this setup, we now state some central goals of coding theory. First, we would like to understand the best possible tradeoffs for ρ and δ that are achievable. Next, we would like to have explicit constructions of codes that achieve this best possible tradeoff. Finally, we would like efficient algorithms for decoding such optimal codes up to half their minimum distance -this would give codes correcting the maximum possible fraction of (worst-case) errors for their rate.
For the case of |Σ| = 2 (the binary alphabet), the Gilbert-Varshamov bound states that for all δ ≤ 1/2 and γ > 0 there exist codes with n → ∞ for which 1 ρ ≥ 1−H 2 (δ)−γ. In fact, a random linear code satisfies this with high probability. The Gilbert-Varshamov bound is the best known tradeoff in the setting where δ = Ω(1), and surprisingly, it is not known to be tight. Furthermore, despite their abundance, we do not know how to explicitly construct codes achieving the Gilbert-Varshamov bound. For growing alphabets, |Σ| = ω(1), the picture is almost completely understood. We know that the best tradeoff achievable is ρ = 1 − δ − γ, and furthermore we know how to explicitly construct codes achieving this tradeoff that can be efficiently unique decoded up to half their minimum distance.

A. The Cast
In recent years, several important variations of the problem of unique decoding have been considered. We will need many 1 Here H 2 is the binary entropy function. 0018-9448 © 2020 IEEE. Personal use is permitted, but republication/redistribution requires IEEE permission.
of these, so we give below a quick and gentle introduction (without formal definitions). a) List decoding: In list decoding we attempt to decode from an even larger fraction α of errors than δ/2 -now there may be more than one nearby codeword, and our goal is to find the list of all of them. A basic limitation is that efficient list decoding is only possible if the number of nearby codewords is guaranteed to be polynomially bounded.
Unlike the case of unique decoding, the optimal tradeoff between the rate ρ and the list decoding radius α (for polynomial-size lists) is known for all alphabet sizes. The optimal rate for a given α is known as the list decoding capacity. For |Σ| = 2, the list decoding capacity is ρ = 1 − H 2 (α) − γ, while for |Σ| = ω(1), the list decoding capacity is ρ = 1 − α − γ. Over large alphabets, this tradeoff can be achieved by explicit codes with efficient list decoding algorithms [1] (see also [2] for the state of the art). Over binary alphabet, we do not know how to explicitly construct codes achieving list decoding capacity. b) List recovery: List recovery is a generalization of list decoding where we are given a small list of candidate alphabet symbols at each coordinate (these lists are called the input lists) and the goal is to find the output list of all codewords that are consistent with many of these input lists. In other words, we want all codewords such that for a (1 − α)-fraction of coordinates, the symbol of the codeword at that coordinate lies within the input list for that coordinate (we call these the "nearby codewords"). When the input list size is 1, then list recovery is the same as list decoding. c) Local decoding: In local decoding, we want to unique decode in sublinear time. Standard decoding has linear output size, so we need to aim lower. For a given w ∈ Σ n and a given message coordinate i ∈ [k], we only ask to recover symbol i of the message underlying the codeword c near w. We would like to run in sublinear time (and hence use only a sublinear number of queries to w), so we allow the algorithm to use randomness and allow a small probability of error.
Local correction is a variation of local decoding where one is required to recover codeword symbols as opposed to message symbols. In approximate local decoding (local correction, resp.) one is only required to recover correctly most of the message (codeword, resp.) coordinates. d) Local list decoding: Local list decoding combines the notions of local decoding and list decoding. We are given some w ∈ Σ n , and the goal is that for any nearby codeword, one can in sublinear time recover the ith symbol of the message corresponding to the codeword for any i ∈ [k]. In order to make this precise, the local list decoding algorithm first does some preprocessing and then produces as output a collection of algorithms A j . For any nearby codeword c, with high probability one of these algorithms corresponds to it. 2 These algorithms then behave like local decoding algorithms. On input i ∈ [k], if the algorithm corresponded to a codeword c, then by making queries to only a sublinear number of coordinates, the algorithm with high probability outputs the correct value of the ith symbol of the message corresponding to c.
The above definition of local list decoding can be extended to local list recovery in a straightforward way where now the algorithms A j correspond to all codewords that agree with most of the input lists. As above, we can also define a local correction version of local list decoding (or local list recovery) where the algorithms A j are required to recover codeword symbols as opposed to message symbols. Finally, we can also define approximate local list decoding (or local list recovery) where the algorithms A j are only required to recover correctly most of the message (or codeword in the local correction version) coordinates.

B. The Context
The starting point for this paper is the recent result of [3] on high-rate list recoverable tensor codes, and its corollaries. Tensoring is a natural operation on codes that significantly enhances their local properties [4]- [14].
The main technical result of [3] was that the tensor product of an efficient (poly-time) high-rate globally list recoverable code is approximately locally list recoverable (in either the local decoding or local correction version). They then observed that the 'approximately' modifier can be eliminated by pre-encoding the tensor product with a locally decodable code. This gave the first construction of codes with rate arbitrarily close to 1 that are locally list recoverable from an Ω(1) fraction of errors (however, only in the local decoding version). Finally, using the expander-based distance amplification method of [15], [16] (specialized to the setting of local list recovery [17], [18]), this gave the first capacity-achieving locally list recoverable (and in particular, list decodable) codes with sublinear (and in fact NÕ (1/ log log N ) ) query complexity and running time (once more, in the local decoding version).
The above result also yielded further consequences for global decoding. Specifically, [3] observed that the approximate local list recovery algorithm for tensor codes naturally gives a probabilistic near-linear time global list recovery algorithm. Once more, using the expander-based distance amplification method of [15]- [17], this gave the first capacity-achieving list recoverable (and in particular, list decodable) codes with probabilistic near-linear time global list recovery algorithms. Finally, via the random concatenation method of [19], [20], this yielded in turn a (randomized) construction of constant-rate binary codes approaching the Gilbert-Varshamov bound with a probabilistic near-linear time algorithm for global unique decoding up to half the minimum distance.
One could potentially hope (following [18] which implemented a local version of [19], [20]) for an analogous result that would give constant-rate codes approaching the Gilbert-Varshamov bound that are locally correctable (or locally decodable) with query complexity and running time N o (1) . However, what prevented [3] from obtaining such a result was the fact that their capacity-achieving locally list recoverable codes only worked in the local decoding version (i.e., they were only able to recover message coordinates).

C. Results
We revisit the technique of [3] and show the following.
• The tensor product of an efficient (poly-time) high-rate globally list recoverable code is globally list recoverable in deterministic near-linear time. Plugging this into the machinery of [15]- [17], we get the first capacity-achieving list recoverable (and in particular, list decodable) codes with deterministic near-linear time global list recovery algorithms. Plugging this into the machinery of [19], [20], yields in turn constant-rate binary codes (with a randomized construction) approaching the Gilbert-Varshamov bound with deterministic near-linear time global unique decoding algorithms. Our deterministic global list recovery algorithm is obtained by derandomizing the random choices of the [3] algorithm using appropriate samplers. • An instantiation of the base code to produce tensor product codes which are themselves genuinely locally list recoverable (i.e., not just approximately locally list recoverable) in the local correction version. Once more, plugging this into the machinery of [15], [16], [18], we get capacity-achieving locally list recoverable codes, but now in the local correction version. This now plugs in turn into the machinery of [18]- [20] to give constant-rate binary codes (with a randomized construction) approaching the Gilbert-Varshamov bound that are locally decodable with query complexity and running time N o (1) . This improves over prior work [18] that only gave query complexity N ε with rate that is exponentially small in 1/ε. We obtain our result by taking the base code to be the intersection of an efficient (poly-time) high-rate globally list recoverable code and a high-rate locally correctable code. Assuming both codes are linear, we have that the intersection is a high-rate code that is both! The result of [3] already guarantees that this tensor product is approximately locally list recoverable (in the local correction version), and we use the fact that the tensor product of a locally correctable codes is also locally correctable [11] to remove the 'approximately' modifier. 3 • A combinatorial lower bound showing the limitations on the list recoverability of high-rate tensor codes. Specifically, we show that when the rate of the base code is high, every t-wise tensor product of this code has output list size doubly-exponential in t. This means that taking t to be more than log log N leads to superpolynomial output list size, precluding the possibility of efficient list recovery.
Instantiating this appropriately, this implies in turn that there is a base code such that for every tensor power with block length N , the product of the query complexity and output list size for local list recovery is at least A key observation that we use is that a high-rate code has many codewords with pairwise-disjoint supports.
We combine this along with other linear-algebraic arguments to design a list recovery instance for the tensor product of a high-rate code, which has many codewords that are consistent with it. Finally, we note that the recent work [2] has shown that high-rate multiplicity codes are also genuinely (nonapproximately) locally list recoverable in the local correction version with N o(1) query complexity. However, these codes do not suffice for our GV bound application, as this application requires the codes to also be locally testable, and we do not currently know a local testing procedure for multiplicity codes. Moreover, we do not know how to derandomize the local list recovery procedure for multiplicity codes.
Below we give formal statements of our results. For formal definitions of the various notions of decoding in the following theorem statements, see Section II.

1) Deterministic Near-Linear Time Global List Recovery:
Our first main result shows that the tensor product of an efficient (poly-time) high-rate globally list recoverable code is globally list recoverable in deterministic near-linear time.
Theorem I.1 (Deterministic Near-Linear Time List Recovery of High-Rate Tensor Codes): The following holds for any δ, α > 0, and s = poly(1/δ, 1/α). Suppose that C ⊆ F n is a linear code of relative distance δ that is (α, , L)-globally list In the theorem statement, one should think of all parameters δ, α, L, t, and consequently also s, as constants (or more generally, as slowly increasing/decreasing functions of n). In that case, the theorem says that if C ⊆ F n is (α, , L)-globally list recoverable deterministically in time T = poly(n), then the t-iterated tensor product C ⊗t of length N := n t is Applying the expander-based distance amplification method of [15]- [17] on the codes given by the above theorem, we obtain the first capacity-achieving list recoverable ( (1) , rate ρ, is encodable in time N 1+o(1) , and is (1 − ρ − γ, , N o(1) )-globally list recoverable deterministically in time N 1+o (1) .
Applying the random concatenation method of [19], [20], the above corollary yields in turn constant-rate codes approaching the Gilbert (1) , and is globally uniquely decodable deterministically from 2) Local List Recovery: Our second main result shows that if the base code is both globally list recoverable and locally correctable, then the tensor product is (genuinely) locally list recoverable (in the local correction version). For the precise definition of local list recovery, please see Section II-C.
Theorem I.4 (Local List Recovery of High-Rate Tensor Codes): The following holds for any δ, α > 0, and s = poly(1/δ, 1/α). Suppose that C ⊆ F n is a linear code of relative distance δ that is (α, , L)-globally list recoverable, and locally correctable from (δ/2)-fraction of errors with query complexity Q, and t ≥ 3.
Remark I.5: A reader may notice the list sizes guaranteed in Theorem I.1 and Theorem I.4 are slightly different (namely, an L t term in the exponent of Theorem I.1 becomes a log t L term in Theorem I.4). This difference results from our derandomization techniques for the global list recovery algorithm, which we do not need to employ in the local list recovery case.
Once more, applying the expander-based distance amplification method of [15]- [18], as well as the random concatenation method of [18]- [20], the above theorem yields constant-rate codes approaching the Gilbert-Varshamov bound that are locally correctable with query complexity N o (1) .
Corollary I.6 (Local Correction Up to the GV Bound): For any constants ρ ∈ [0, 0.02] and γ > 0 there exists an infinite family of binary linear codes {C N } N , where C N has block length N , rate ρ, is encodable in time N 1+o(1) , and is locally correctable from -fraction of errors with query complexity N o (1) .
3) Combinatorial Lower Bound on Output List Size: Our final main result shows a nearly-tight combinatorial lower bound on output list size for list recovering high-rate tensor codes.
Theorem I.7 (Output List Size for List Recovering High-Rate Tensor Codes): Suppose that C ⊆ F n is a linear code of rate 1 − γ, and that C ⊗t ⊆ F n t is (0, , L)-list recoverable. Then L ≥ 1/γ t . The above bound can be instantiated concretely as follows. Proposition I.8: For any δ > 0 and > 1 there exists L > 1 such that the following holds for any sufficiently large n. There exists a linear code C ⊆ F n of relative distance δ that is (Ω(δ), , L)-list recoverable, but C ⊗t ⊆ F n t is only (0, , L )-list recoverable for L ≥ exp((2δ) −(t−3/2) · √ log L). Finally, we also obtain a nearly-tight lower bound of N Ω(1/ log log N ) on the product of query complexity and output list size for locally list recovering high-rate tensor codes.
Proposition I. 9: For any δ > 0 and sufficiently large n there exists a linear code C ⊆ F n of relative distance δ such that the following holds. Suppose that C ⊗t ⊆ F N is ( 1 N, 2, L)locally list recoverable with query complexity Q. Then Q·L ≥ N Ω δ (1/ log log N ) . 4

II. PRELIMINARIES
For a prime power q we denote by F q the finite field of q elements. For any finite alphabet Σ and for any pair of strings x, y ∈ Σ n , the relative distance between x and y is the fraction of coordinates i ∈ [n] on which x and y differ, and is denoted by dist(x, y) := |{i ∈ [n] : x i = y i }| /n. For a subset Y ⊆ Σ n , we denote by dist(x, Y ) the minimum relative distance of a string y ∈ Y from x. For a positive integer we denote by Σ the collection of all subsets of Σ of size and by Σ ≤ the collection of all nonempty subsets of Σ of size at most . For any string x ∈ Σ n and tuple S ∈ Σ ≤ n we denote by dist(x, S) the fraction of coordinates i ∈ [n] for which For a string x ∈ Σ n and a subset T ⊆ [n], we use x| T ∈ Σ |T | to denote the restriction of x to the coordinates in T . Throughout the paper, we use exp(n) to denote 2 Θ(n) , and whenever we use log, it is base 2, unless noted otherwise. We use the notation O ε (·), Ω ε (·) to indicate that ε is constant.

A. Error-Correcting Codes
An error-correcting code is simply a subset C ⊆ Σ n . We call Σ the alphabet of the code, and n its block length.
The elements of C are called codewords. If F is a finite field and Σ is a vector space over F, we say that a code C ⊆ Σ n is F-linear if it is an F-linear subspace of the F-vector space Σ n . If Σ = F, we simply say that C is linear.
The rate of a code is the ratio ρ := log |C| log(|Σ| n ) , which for F-linear codes equals dim F (C) n·dim F (Σ) . The relative distance dist(C) of C is the minimum δ > 0 such that for every pair of distinct codewords c 1 , c 2 ∈ C it holds that dist(c 1 , c 2 ) ≥ δ. We denote by Δ(C) := dist(C) · n the (absolute) distance of C.
The best known general trade-off between rate and distance of codes is the Gilbert-Varshamov bound, attained by ran- denote the q-ary entropy function.
An encoding map for C is a bijection E C : Σ k → C, where |Σ| k = |C|. We call the elements in the domain of E C messages, and k the message length. We say that C is encodable in time T if an encoding map for C can be computed in time T . For a code C ⊆ Σ n of relative distance δ and a given parameter α < δ/2, we say that C is decodable from α-fraction of errors in time T if there exists an algorithm, running in time T , that given a received word w ∈ Σ n , computes the unique codeword c ∈ C (if any) which satisfies dist(c, w) ≤ α.
Fact II.3 (Reed-Solomon Codes, [31], [32]): For any prime power q and integers k ≤ n ≤ q, there exists a linear code C ⊆ F n q of rate ρ := k/n and relative distance at least 1 − ρ that is encodable and decodable from 1−ρ 2 -fraction of errors in time poly(n, log q).
Let C ⊆ F n be a linear code of dimension k. A generating matrix for C is an n × k matrix G such that Im(G) = C.
A parity-check matrix for C is an (n − k) × n matrix H such that ker(H) = C. The dual code C ⊥ ⊆ F n is given by It is well-known that C ⊥ ⊥ = C, and that a matrix G is a generating matrix for C if and only if G T is a parity-check matrix for C ⊥ .

B. List Recoverable Codes
List recovery is a generalization of the standard error-correction setting where each entry w i of the received word w is replaced with a list S i of possible symbols of Σ. Formally, for α ∈ [0, 1] and integers , L we say that a code C ⊆ Σ n is (α, , L)-list recoverable if for any tuple Theorem II.4 ([33], Theorem 5.3): For any prime power q, α ∈ (0, 1− 1 q), ρ ∈ (0, 1−H q (α)−1/ log q (L+1)), a random linear code C ⊆ F n q of rate ρ is (α, L)-list decodable with probability 1 − exp(−n).
We say that C is (α, , L)-list recoverable in time T if there exists an algorithm, running in time T , that given a tuple S ∈ Σ n , returns all codewords c ∈ C (if any) which satisfy dist(c, S) ≤ α. The following theorem from [3], [25], [35] gives a family of high-rate linear codes which are efficiently list recoverable with constant alphabet size and nearly-constant output list size.
Theorem II.7 ([34], Theorem A.1): There exists an absolute constant b 0 so that the following holds. For any γ > 0, ≥ 1, q ≥ b0/γ that is an even power of a prime, 5 and integer n ≥ q b0/γ , there exists a linear code C ⊆ F n q of rate 1−γ and relative distance Ω(γ 2 ) that is (Ω(γ 2 ), , L)-list recoverable for L = q q (/γ)·exp(log * n) . Moreover, C can be encoded in time poly(n, log q) and list recovered in time poly(n, L).
C. Local Codes a) Locally testable codes: Intuitively, a code is said to be locally testable [36]- [38] if, given a string w ∈ Σ n , it is possible to determine whether w is a codeword of C, or rather far from C, by reading only a small part of w. For our purposes, we shall also require an additional tolerance property of determining whether w is sufficiently close to the code.
Definition II.8 (Tolerant Locally Testable Code (Tolerant LTC)): We say that a code C ⊆ Σ n is (Q, α, β)-tolerantly locally testable if there exists a randomized algorithm A that satisfies the following requirements: • Input: A gets oracle access to a string w ∈ Σ n . • Query complexity: A makes at most Q non-adaptive queries to the oracle w. • Completeness: If dist(w, C) ≤ α, then A accepts with probability at least 2 3 . • Soundness: If dist(w, C) ≥ β, then A rejects with probability at least 2 3 . Remark II.9: The definition requires 0 ≤ α < β ≤ 1. The above success probability of 2 3 can be amplified using sequential repetition, at the cost of increasing the query complexity. Specifically, amplifying the success probability to 1 − exp(−t) requires increasing the query complexity by a multiplicative factor of O(t).
b) Locally correctable codes: Intuitively, a code is said to be locally correctable [39]- [41] if, given a codeword c ∈ C that has been corrupted by some errors, it is possible to decode any coordinate of c by reading only a small part of the corrupted version of c.
Definition II.10 (Locally Correctable Code (LCC)): We say that a code C ⊆ Σ n is (Q, α)-locally correctable if there exists a randomized algorithm A that satisfies the following requirements: • Input: A takes as input a coordinate i ∈ [n], and also gets oracle access to a string w ∈ Σ n that is α-close to a codeword c ∈ C. • Query complexity: A makes at most Q non-adaptive queries to the oracle w. • Output: A outputs c i with probability at least 2 3 . Remark II.11: The definition requires α < dist(C)/2. The above success probability of 2 3 can be amplified using sequential repetition, at the cost of increasing the query complexity. Specifically, amplifying the success probability to 1−exp(−t) requires increasing the query complexity by a multiplicative factor of O(t).
c) Locally list recoverable codes: The following definition from [18], [40], [42] generalizes the notion of locally correctable codes to the setting of list decoding/recovery. In this setting, the local list recovery algorithm is required to output in an implicit sense all codewords that are consistent with most of the input lists.
Definition II.12 (Locally List Recoverable Code): We say that a code C ⊆ Σ n is (Q, α, ε, , L)-locally list recoverable if there exists a randomized algorithm A that satisfies the following requirements: • Input: A gets oracle access to a string S ∈ Σ ≤ n . This oracle, on input i ∈ [n], returns the set S i . • Query complexity: A makes at most Q non-adaptive queries to the oracle S.
, makes at most Q queries to the oracle S, and outputs a symbol in Σ. • Completeness: For any codeword c ∈ C which satisfies dist(c, S) ≤ α, with probability at least 1 − ε over the randomness of A, the following event happens: there exists some j ∈ [L] such that for all i ∈ [n], where the probability is over the internal randomness of A j . • Soundness: With probability at least 1 − ε over the randomness of A, the following event happens: for every j ∈ [L], there exists some c ∈ C such that for all i ∈ [n], where the probability is over the internal randomness of A j . We say that A has preprocessing time T pre if A outputs the description of the algorithms A 1 , . . . , A L in time at most T pre , and has running time T if each A j has running time at most T . As before, we say that the code C is Remark II. 13: The above definition of locally list recoverable code differs from that given in [3,Definition 4.5] in two ways. First, our definition requires that the local algorithms A 1 , . . . , A L in the output list of A locally decode codeword coordinates as opposed to message coordinates. Second, following [18], we require an additional soundness property that guarantees that with high probability, each local algorithm in the output list locally decodes a true codeword. These two requirements will be crucial for our GV bound local correction application (Corollary I.6).

D. Tensor Codes
In this paper we study the list recovery properties of the high-rate tensor product codes, defined as follows.
Definition II.14 (Tensor Product Codes): Let C 1 ⊆ F n1 , C 2 ⊆ F n2 be linear codes. Their tensor product code C 1 ⊗ C 2 ⊆ F n1×n2 consists of all matrices M ∈ F n1×n2 such that all the rows of M are codewords of C 2 and all the columns are codewords of C 1 .
The following are some well-known facts about the tensor product operation, and its effect on the classical parameters of a code.
Moreover, if C 1 , C 2 are encodable in times T 1 , T 2 , respectively, then C 1 ⊗ C 2 is encodable in time n 1 T 2 + n 2 T 1 , and if C 1 , C 2 are uniquely decodable from α 1 , α 2 -fraction of errors in times T 1 , T 2 , respectively, then C 1 ⊗ C 2 is uniquely decodable from (α 1 · α 2 )-fraction of errors in time For a linear code C, let C ⊗1 := C and C ⊗t := C⊗C ⊗(t−1) . By induction on t we have the following.
Corollary II. 16: Suppose that C ⊆ F n is a linear code of rate ρ and relative distance δ. Then the tensor product code C ⊗t ⊆ F n t is a linear code of rate ρ t and relative distance δ t . Moreover, if C is encodable in time T enc then C ⊗t is encodable in time t · n t−1 · T enc , and if C ⊗t is uniquely decodable from α-fraction of errors in time T dec then C ⊗t is uniquely decodable from α t -fraction of errors in time For a pair of matrices G 1 ∈ F n1×k1 and G 2 ∈ F n2×k2 , their Fact II.17: Suppose that G 1 , G 2 are generating matrices of linear codes

A. Deterministic Near-Linear Time List Recovery of High-Rate Tensor Codes
In this section we prove Theorem I.1, restated below, which shows that the tensor product of an efficient (polytime) high-rate globally list recoverable code is globally list recoverable in deterministic near-linear time.

(Deterministic Near-Linear Time List Recovery of High-Rate Tensor Codes):
The following holds for any δ, α > 0, and s = poly(1/δ, 1/α). Suppose that C ⊆ F n is a linear code of relative distance δ that is (α, , L)-globally list recoverable deterministically in time T . Then C ⊗t ⊆ F n t is (α · s −t 2 , , L s t 3 ·L t )-globally list recoverable deterministically in time n t · T · L s t 3 ·L t . Theorem I.1 follows by applying the lemma below iteratively.
Lemma III.1: The following holds for any δ, α, α , δ dec , δ dec ∈ (0, 1), ands = poly(1/δ, 1/α, 1/δ dec , 1/δ dec ). Suppose that C ⊆ F n is a linear code of relative distance δ that is (α, , L)-globally list recoverable deterministically in time T , and C ⊆ F n is a linear code that is (α , , L )globally list recoverable deterministically in time T . Suppose furthermore that C, C are uniquely decodable deterministically from δ dec , δ dec -fraction of errors in times T dec , T dec , respectively. Then Before we prove the above lemma, we first show how it implies Theorem I.1.
Proof of Theorem I.1: We start with the code C, and iteratively tensor with a new copy of C for t − 1 times. Specifically, we initially set C := C, and at each step we apply Lemma III.1 with the code C being the code constructed so far, and the code C being a new copy of C.
On each iteration, we can set in Lemma III.1 δ dec := min{α, δ/2} and T dec := T since the code C can be uniquely decoded from δ dec -fraction of errors by running the list recovery algorithm for C on the received word, and returning the codeword from the output list that is closest to the received word. Moreover, by Corollary II.16, on the i-th iteration we can set δ dec := δ t dec and T dec := i · n i−1 · T . We conclude that on each iteration we can apply Lemma III.1 withs := s t for s = poly(1/δ, 1/α).
In the above setting of parameters, we have that the list recovery radius of C ⊗t is at leastα := α/s t = α/s t 2 , and that the output list size is at mostL := Ls Finally, on the i-th iteration the running time is increased by an additive factor of n · (T + T dec ) + n · T dec = O(i · n i · T ), and then by a multiplicative factor of at mostL · n, yielding a total running time of at most So the desired conclusion holds by slightly enlarging the size of the polynomial s. We now proceed to the proof of Lemma III.1. Our plan is to derandomize the approximate local list recovery algorithm for high-rate tensor codes of [3]. Recall that an approximate local list recovery algorithm (local correction version) is a randomized algorithm A that outputs a collection of (without loss of generality, deterministic) local algorithms A j satisfying the following: for any codeword c that is consistent with most of the input lists, with high probability (over the randomness of A) one of the local algorithms A j locally corrects most of the coordinates of c.
As observed in [3], an approximate local list recovery algorithm naturally gives a probabilistic near-linear time global list recovery algorithm as follows. First run the algorithm A to obtain the collection of local algorithms A j . Then for each A j , output a codeword that is obtained by applying A j on each codeword coordinate, and then uniquely decoding the resulting word to the closest codeword. The guarantee now is that any codeword that is consistent with most of the input lists will be output with high probability.
To derandomize the probabilistic global algorithm described above, we note that the preprocessing algorithm A in [3] produces the collection of local algorithms A j by choosing a random subset of rows in the tensor product, 6 that is chosen uniformly at random amongst all subsets of the appropriate size. We then observe that this subset can be alternatively chosen using a randomness-efficient sampler without harming much the performance. Finally, since the sampler uses a small amount of randomness (logarithmic in the blocklength of C), we can afford to iterate over all seeds and return the union of all output lists. This gives a deterministic near-linear time global list recovery algorithm that outputs all codewords that are consistent with most of the input lists.
1) Samplers: We start by defining the appropriate samplers we use.
Definition III.2 ((Averaging) Sampler): An (n, η, γ)sampler with randomness r and sample size m is a randomized algorithm that tosses r random coins and outputs a subset I ⊆ [n] of size m such that the following holds. For any function f : [n] → [0, 1], with probability at least 1 − η over the choice of I, We shall use the following construction from Goldreich [43].
2) Randomness-Efficient Algorithm: We first describe a randomness-efficient global list recovery algorithmÃ for C ⊗ C that is obtained by replacing the choice of a uniform random subset of rows made in [3] with a sample from Γ. We will later observe that the randomness can be eliminated by iterating over all seeds of Γ and returning the union of all output lists.
The algorithmÃ behaves as follows.
. . , c m ∈ L im , the algorithmÃ outputs a codewordc ∈ C⊗C that is obtained as follows.
For each column j ∈ [n ], the algorithmÃ runs the list recovery algorithm A for C on the j-th column S| [n]×{j} ; let L 1 , L 2 , . . . L n ⊆ C denote the lists output by A on each of the n columns. Then the algorithmÃ chooses for each column j ∈ [n ] the codeword c j ∈ L j whose restriction to . . , c m to the j-th column). Finally, the algorithmÃ sets the value of each column j ∈ [n ] to c j , and uniquely decodes the resulting wordc 0 to the nearest codewordc ∈ C ⊗ C , assuming there is one at distance at most δ dec · δ dec . If dist(c, S) ≤ α /s, thenÃ includesc in the output listL. The formal description is given in Algorithm 1.
3) Output List Size, Randomness, and Running Time: The output list size is at most the number of choices of , and the randomness is r ≤ log (n ·s/α ). As to running time, the algorithmÃ invokes the sampler Γ, followed by m invocations of the list recovery algorithm A for C , and (L ) m · n invocations of the list recovery algorithm A for C. Furthermore it chooses the codeword Run the list recovery algorithm A for C on the j-th column S| [n]×{j} , and let L j ⊆ C be the list of codewords output by A.
Choose a codeword c j ∈ L j for which c j | I is clos- . Set the j-th column ofc 0 to c j . end for Uniquely decodec 0 from (δ dec ·δ dec )-fraction of errors (using Fact II.15), and letc ∈ C ⊗ C be the resulting codeword (if it exists). If dist(c, S) ≤ α /s, addc toL. end for returnL end function the unique decoding algorithm for C ⊗ C which can be implemented to run in time n · T dec + n · T dec by Fact II.15. Thus the total running time is at most where the inequality holds for a sufficiently large polynomials. 4) Correctness: Next we establish the following. Claim III.4: Suppose thatc ∈ C ⊗C has dist(c, S) ≤ α /s. Then with probability at least 2/3, the codewordc is included inL.
Note that the above claim in particular implies that there are if M denotes the number of such codewords, Claim III.4 promises that the expected size ofL is at least To prove the above claim, it is enough to show that with probability at least 2/3 over the choice of Once we establish this, the unique decoding algorithm for C ⊗ C will successfully decodec fromc 0 . For a row i ∈ [n], letĉ i be the codeword in L i that is closest to the i-th row ofc (breaking ties arbitrarily), that is, ) is minimal. We will show that with probability at least 2/3 over the choice of I = {i 1 , . . . , i m }, at the iteration corresponding to the choice ofĉ i1 ∈ L i1 ,ĉ i2 ∈ L i2 , . . . ,ĉ im ∈ L im , the wordc 0 will satisfy that dist(c 0 ,c) ≤ δ dec · δ dec . Following [3], to establish the above, we show that with high probability over the choice of I, a large fraction of the columns j ∈ [n ] are "good", in the sense thatc 0 andc agree on all of these columns at the iteration corresponding In what follows, letc 1 ,c 2 . . . ,c n denote the columns ofc.
Definition III.5 (Good Column): be a subset of m rows. We say that a column j ∈ [n ] is good with respect to I if it satisfies the following properties: 1) The codewordc is consistent with all but an α-fraction of the input lists on column j, that is, dist(c j , S| [n]×{j} ) ≤ α. 2) Let L j denote the list of all codewords in C that are consistent with all but an α-fraction of the input lists on column j. Then for any Claim III.6 below shows that at the iteration corresponding to the choice ofĉ i1 ∈ L i1 ,ĉ i2 ∈ L i2 , . . . ,ĉ im ∈ L im ,c 0 and c agree on all of the good columns. Claim III.7 complements this by showing that with probability at least 2/3 over the choice of I, at least a (1 − δ dec · δ dec )-fraction of the columns are good with respect to I. The combination of these claims yields the desired conclusion.
Claim III. 6: be a subset of m rows, and suppose that a column j ∈ [n ] is good with respect to I. Then at the iteration corresponding to the choice ofĉ i1 ∈ L i1 ,ĉ i2 ∈ L i2 , . . . ,ĉ im ∈ L im it holds thatc 0 | [n]×{j} =c j . Proof: By Property (1) in the definition of a good column, c is consistent with all but an α-fraction of the input lists on column j, and soc j ∈ L j . By Property (3), On the other hand, by Property (2) for any other codeword c ∈ L j we have that Thus,c j is the codeword in L j whose restriction to I is closest to ((ĉ i1 ) j , . . . , (ĉ im ) j ), and so the algorithmÃ will set c j :=c j at the iteration corresponding to the choice of Consequently, the j-th column ofc 0 will be set to the j-th column ofc.
Claim III.7: With probability at least 2/3 over the choice of I, at least a (1 − δ dec · δ dec )-fraction of the columns are good with respect to I.
For the proof of the above claim we shall also use the notion of a "good row".
is good if the codewordc is consistent with all but an α -fraction of the input We claim that with high probability over the choice of I, a large fraction of the rows in I are good.
Claim III.9: With probability at least 0.9 over the choice of I, at least a 1 − δ·δ dec ·δ dec 12 -fraction of the rows in I are good.
Proof of Claim III. 9: ), and note that by the sampling property of Γ, with probability at least 0.9 over the choice of I we have that where the last inequality holds by assumption that γ = α · δ·δ dec ·δ (which holds assuming thats is a sufficiently large polynomial). An averaging argument yields that in this case, for at least a Finally, we provide the proof of Claim III.7.
Proof of Claim III.7: We will show that each of the three properties in the definition of a good column holds for at least a (1 −  )-fraction of the columns j ∈ [n ] it holds that dist (c j | I , ((ĉ i1 ) j , . . . , (ĉ im ) j )) ≤ δ/4. 5) Deterministic Algorithm: Lastly, to obtain a deterministic global list recovery algorithm, we simply iterate over the randomness of Γ, and output the union of all output lists. This increases the running time by a multiplicative factor of 2 r = n ·s/α . Moreover, Claim III.4 guarantees that any codeword that is consistent with all but (α /s)-fraction of the input lists will be output in one of the invocations, and consequently will be included in the final output list (which is of size at most (L )s ·L/(α ) 2 by the same claim).

B. Deterministic Nearly-Linear Time Capacity-Achieving List Recoverable Codes
In this section we prove the following lemma, which implies Corollary I.2 from the introduction.
• C N is an F 2 -linear code of block length N and alphabet size N o(1) . • C N has rate ρ and relative distance at (1) . To prove the above lemma, we first use Theorem I.1 to obtain deterministic nearly-linear time high-rate list recoverable codes, and then use the Alon-Edmonds-Luby (AEL) distance amplification method [15], [16] to turn these codes into deterministic nearly-linear time capacity-achieving list recoverable codes. Specifically, we shall use the following version of the AEL method for list recovery from [17] that roughly says the following. Given an efficient "outer" code C of rate approaching 1 that is list recoverable from a tiny fraction of errors, and a small "inner" code C that is a (possibly non-efficient) capacity-achieving list recoverable code, they can be combined to get a new code C AEL that on the one hand, inherits the tradeoff between rate and error correction that C enjoys, and on the other hand, is almost as efficient as C is.
Suppose that C ⊆ (Σ ρ·t ) n is an outer code of rate 1−γ and relative distance δ that is (α, , L)globally list recoverable in time T , and C ⊆ Σ t is an inner code of rate ρ and relative distance 1 − ρ − γ that is (1 − ρ − γ, , )-globally list recoverable in time T . Then there exists a code C AEL ⊆ (Σ t ) n of rate ρ − γ and relative distance at least 1 − ρ − 2γ that is (1 − ρ − 2γ, , L)-globally list recoverable in time T + n · (T + poly(t, log n)).
Moreover, • If C, C have encoding times T enc , T enc , respectively, then C AEL has encoding time T enc + n·(T enc +poly(t, log n)).
• If C, C are F-linear then so is C AEL . Remark III.12: Lemma 6 in [17] is stated for the special case of = 1, and for a more specific choice of list recovery radii and running times. Also, it does not mention explicitly relative distance, encoding time, and linearity. However, these can be deduced from the proof of the lemma, combined with the expander graph construction described in [14,Lemma 2.12] (See also [18,Lemma 5.4] for a similar transformation for the setting of local list recovery.) Next we prove Lemma III.10, based on Theorem I.1 and Lemma III.11.
Proof of Lemma III.10: We shall first apply Theorem I.1 on a suitable base code C to obtain a deterministic nearly-linear time high-rate list recoverable code C , and then use the transformation given by Lemma III.11 to obtain a deterministic nearly-linear time capacity-achieving list recoverable code C . a) Base code C: The code C will be the efficient high-rate list recoverable code given by Theorem II.7, in an appropriate setting of parameters.
Specifically, in what follows, we let β := (log log log N ) −o(1) (where the o(1) term in the exponent is a sufficiently slowly decreasing function of N ), and we choose the block length of C to be N β , and the rate to be 1 − γβ/4. As we will see in a moment, the rationale for these choices is that if we raise C to the tensor power of 1/β, Theorem I.1 will yield a code of block length N with running time N 1+O(β) = N 1+o(1) and rate greater than 1 − γ.
Theorem II.7 then guarantees, for any constant ≥ 1, the existence of a linear code C as above that has relative distance (log log log N ) −o (1) , and is ((log log log N ) −o (1) , , exp exp((log log log N ) o(1) ))-globally list recoverable in time N O(β) , provided that the alphabet size is sufficiently large even power of a prime exp((log log log N ) o(1) ). Also, as C is linear, it can be encoded in time quadratic in its block length, that is, O(N 2β ).
b) High-rate list recoverable code C : Let C be the code obtained by raising C to a tensor power of 1/β = (log log log N ) o (1) . Then C has block length N , alphabet size exp((log log log N ) o (1) ), rate at least 1 − γ/4, and relative distance exp(−(log log log N ) o(1) ). Furthermore, by Theo- (1) . Morever, by Corollary II.16, it can be encoded in time c) Capacity-achieving list recoverable code C : Let C be the code obtained by applying Lemma III.11 with the outer code being the code C constructed so far, and the inner code being a capacity-achieving list recoverable code D of rate ρ + γ/4 and relative distance at least 1 − ρ − γ/2. (This code can be constructed by a brute-force search.) Corollaries II.2 and II.6 guarantee the existence of a code D as above that is (1 − ρ − γ/2, , )-globally list recoverable for some constant , provided that the alphabet size is a sufficiently large constant prime power, and the block length is sufficiently large. To satisfy the conditions of Lemma III.11, we further require that the block length of D is sufficiently large exp((log log log N ) o(1) ), and that the alphabet size of C is exp exp((log log log N ) o(1) )-the size of D -which can be achieved by grouping together consecutive symbols of C .
Finally, it can be verified that the encoding time is as claimed. Indeed, the encoding time of C is N 1+o(1) and the encoding time of D is N o(1) (as the code is linear, it can be encoded in time quadratic in its block-length, which is N o(1) ), so Lemma III.11 implies the desired result. Moreover, observe that all codes in the process can be taken to be F 2 -linear, and all transformations preserve F 2 -linearity, so the final code can be guaranteed to be F 2 -linear as well.

C. Deterministic Near-Linear Time Unique Decoding up to the GV Bound
In this section we prove the following lemma, which implies Corollary I.3 from the introduction.
Lemma III.13: For any constants ρ ∈ [0, 0.02] and γ > 0 there exists an infinite family of binary linear codes {C N } N , where C N has block length N and rate ρ, and is globally uniquely decodable deterministically from Furthermore, there exists a randomized algorithm which, on input N , runs in time N 1+o(1) and outputs with high probability a description of a code C N with the properties above. Given the description, the code C N can be encoded deterministically in time N 1+o (1) .
To prove the above lemma, we rely on the following lemma from [3], [19], which says that one can turn a code that approximately satisfies the Singleton bound into one that approximately satisfies the GV bound via random concatenation. In what follows let θ(x) : Claim III. 14 . Suppose that C ⊆ (F ρ ·t 2 ) n is an F 2 -linear code of rate ρ and relative distance 1−ρ− γ 2 b0 , and C con ⊆ F tn 2 is a code obtained from C by applying a random linear code C (i) ⊆ F t 2 of rate ρ on each coordinate i ∈ [n] of C independently. Then C con has relative distance at least H −1 We shall also use the following lemma that states the effect of concatenation on list recovery properties.
Lemma III. 16 (Concatenation for List Recovery, [34], Lemma 7.4): Suppose that C ⊆ (Σ ρ ·t ) n is (α, , L)-globally list recoverable in time T , and C con ⊆ Σ tn is a code obtained from C by applying a code C (i) ⊆ Σ t of rate ρ on each coordinate i ∈ [n] of C. Suppose furthermore that at least (1 − γ)-fraction of the codes C (i) are (α , , )-globally list recoverable in time T . Then C con is ((α−γ)·α , , L)-globally list recoverable in time T + n · T .
Next we prove Lemma III.13, based on Lemma III.10 and the above Lemmas III.15 and III. 16.
Proof of Lemma III. 13: We apply random concatenation on the deterministic nearly-linear time capacity-achieving list recoverable code C given by Lemma III.10. By Lemma III.15, the resulting codeC will approach the Gilbert-Varshamov bound with high probability, while by Lemma III.16, the codẽ C will also be nearly-linear time list recoverable (and in particular, list decodable) with high probability. Thus, whenever the list decoding radius exceeds half the minimum distance (which turns to be the case whenever the rate is smaller than 0.02), the codeC can be uniquely decoded from half the minimum distance in near-linear time by first running the list decoding algorithm, and then choosing the codeword from the output list that is closest to the received word. Details follow.
Assuming that (2) holds, one can globally uniquely decodeC up to half the minimum distance in time N 1+o(1) by list decodingC, and outputting the codeword in the output list that is closest to the received word.

A. Local List Recovery of High-Rate Tensor Codes
In this section we prove the following lemma, which implies Theorem I.4 from the introduction.
The above lemma relies on the following lemma from [3], which says that the tensor product of a high-rate globally list recoverable code (which is not necessarily locally correctable) is approximately locally list recoverable. Approximate local list recovery is a relaxation of local list recovery, where the local algorithms in the output list are not required to recover all the codeword coordinates, but only most of them. Formally, a β-approximately (Q, α, ε, , L)-locally list recoverable code C ⊆ Σ n satisfies all the requirements of Definition II.12, except that the requirement (1) is replaced with the relaxed condition that where the probability is over the choice of uniform random i ∈ [n], 7 and the soundness requirement is eliminated. Lemma IV.2 (Approximate Local List Recovery of High-Rate Tensor Codes, [34], Lemma 4.1): The following holds for any δ, α, β, ε > 0 and s = poly(1/δ, 1/α, 1/β). Suppose that C ⊆ F n is a linear code of relative distance δ that is (α, , L)globally list recoverable. Then C ⊗t ⊆ F n t is β-approximately (n · (s t 2 log t L), α · s −t 2 , ε, , L s t 2 ·log t L · log(1/ε))-locally list recoverable.
Moreover, if C is globally list recoverable in time poly(n), then the approximate local list recovery algorithm for C ⊗t has preprocessing time log(n) · L s t 2 ·log t L · log(1/ε) and running time poly(n) · (s t 2 log t L).
To turn the approximate local list recovery algorithm given by the above lemma into a local list recovery algorithm we shall use the fact that the tensor product of a locally correctable code is also locally correctable with slightly worse parameters. A similar observation was made in [11, Proposition 3.15.], but for completeness we provide a full proof below in Section IV-A.1. 7 A simple averaging argument shows that in the case of approximate local list recovery, each of the local algorithms A 1 , . . . , A L can be assumed to be deterministic.

Lemma IV.3 (Local Correction of Tensor Codes):
Suppose that C ⊆ F n is a linear code that is (Q, α)-locally correctable.
Moreover, if C is locally correctable in time T , then the local correction algorithm for C ⊗t runs in time (O(T log T )) t .
To guarantee the soundness property we shall also use the following lemma which says that high-rate tensor codes are tolerantly locally testable. We prove this lemma in Section IV-A.2, based on a robust local testing procedure for high-rate tensor codes given in [11].
Lemma IV.4 (Tolerant Local Testing of High-Rate Tensor Codes): Suppose that C ⊆ F n is a linear code of relative distance δ, and t ≥ 3.
Moreover, if C is globally decodable from (δ/2)-fraction of errors in time T , then the tolerant local testing algorithm for C ⊗t runs in time T · n · δ −O(t) .
Finally, we show a general transformation that turns an approximately locally list recoverable code that is also locally correctable and tolerantly locally testable into a (genuinely) locally list recoverable code.
Lemma IV.5: Suppose that C ⊆ Σ n is a β-approximately (Q, α, ε, , L)-locally list recoverable code that is also (Q corr , γ)-locally correctable and (Q test , β, γ)tolerantly locally testable. Then C is (Q, α, 2ε, , L)-locally list recoverable for Moreover, if the approximate local list recovery algorithm has preprocessing time T pre and running time T , and the local correction and tolerant local testing algorithms run in times T test , T corr , respectively, then the local list recovery algorithm has preprocessing time T pre + T · T test · O(|L| log(|L|/ε)) and running time T · T corr .
Proof: First note that by Remark II.9, we may assume that the tolerant local testing algorithm A test fails with probability at most ε/|L|, at the cost of increasing the query complexity and running time by a multiplicative factor of O(log(|L|/ε)).
The local list recovery algorithmÃ first runs the approximate local list recovery algorithm A, let A 1 , A 2 , . . . , A L be the (deterministic) output local algorithms. Then for any j = 1, . . . |L|, the local list recovery algorithmÃ runs the tolerant local testing algorithm A test on A j , and outputs A corr (A j ) if and only if the test passes, where A corr is the local correction algorithm.
It can be verified that query complexity, output list size, and running times are as claimed. For completeness, suppose that c ∈ C satisfies dist(c, S) ≤ α. Then with probability at least 1 − ε the approximate local list recovery algorithm A will output some A j for which dist(A j , c) ≤ β. Consequently, the tolerant local testing algorithm A test will accept A j with probability at least 1 − ε. So we conclude that with probability at least 1 − 2ε the local algorithm A corr (A j ) will be included in the output list ofÃ, and furthermore, by properties of A corr it will be consistent with the codeword c.
For soundness, suppose that A corr (A j ) is not consistent with some codeword c ∈ C. Then by properties of A corr , it holds that dist(A j , C) > γ. But in this case the tolerant local testing algorithm A test will reject A j with probability at least 1 − ε/|L|. So by union bound, with probability at least 1 − ε, each local algorithm in the output list ofÃ is consistent with some codeword c ∈ C.
Next we prove Lemma IV.1 based on the above transformation and Lemmas IV.2, IV.3, and IV.4.
1) Local Correction of Tensor Codes -Proof of Lemma IV.3: Lemma IV.3 can be easily deduced from the following lemma using induction: specifically, take C to be the code constructed thus far (that is, C ⊗j for some j < t) and take C to be a fresh copy.
Moreover, if C, C are locally correctable in times T, T , respectively, then the local correction algorithm for C ⊗ C runs in time T · O(T log T ).
Proof: First note that by Remark II.11, we may assume that the local correction algorithm A for C fails with probability at most 1/6, at the cost of increasing the query complexity and running time by some multiplicative constant b 0 . Similarly, we may also assume that the local correction algorithm A for C fails with probability at most 1/(6b 0 Q ), at the cost of increasing the query complexity and running time by a multiplicative factor of O(log Q ).
Let w ∈ F n×n be a string that is (α · α )-close to some codeword c ∈ C ⊗ C . Recall that the local correction algorithmÃ for C⊗C is given as input a codeword coordinate (i, j) ∈ [n]×[n ] in the tensor product code C ⊗C , is allowed to query the received word w at every coordinate of C ⊗ C , and must produce a guess for c i,j , the codeword value indexed by (i, j).
To this end, the local correction algorithmÃ for C ⊗ C first runs the local correction algorithm A for C on input j ∈ [n ], let J = {j 1 , . . . , j m } ⊆ [n ] be the set of query locations for m := b 0 ·Q . Next for each query location j r ∈ J, the algorithmÃ obtains a guess for the symbol at position (i, j r ) by running the local correction algorithm A for C on input i with oracle access to the column j r . Let v r be the guess for the symbol at position (i, j r ) produced by A. At this point we have candidate symbols (v 1 , . . . , v m ) for all positions in {i} × J. Finally, the algorithmÃ responds with the output of  A on query locations j 1 , . . . , j m and values v 1 , . . . , v m . The Algorithm 2 The Local Correction AlgorithmÃ for C ⊗ C .

functionÃ((i, j) ∈ [n] × [n ])
Ã receives oracle access to a matrix w ∈ F n×n . Run the local correction algorithm A for C on input j, let J = {j 1 , . . . , j m } ⊆ [n ] be the query locations for m = b 0 · Q .
for r = 1, . . . , m do Run the local correction algorithm A for C on input i and oracle access to the j r -th column w| [n]×{jr } .
Let v r ← A(i). v r is a candidate for the symbol at position (i, j r ) ∈ The algorithmÃ invokes the algorithm A once, followed by m = O(Q ) invocations of the algorithm A. Thus, the query complexity ofÃ is

and the running time is
In the above, we used that query complexity is always at most time complexity, hence Q ≤ T .) As for correctness, recall that by assumption the received word w is (α · α )-close to the codeword c ∈ C ⊗ C . Let us call a column "good" if w and c are α-close on this column, and note that by Markov's inequality, at least (1 − α )-fraction of the columns are good. Furthermore, by our assumptions on each good column the local correction algorithm A for C succeeds with probability at least 1 − 1 6m , and so by union bound, with probability at least 5/6 the values (v 1 , . . . , v m ) will be computed correctly on each good column. Conditioned on this, the local correction algorithm A for C computes v correctly with probability at least 5/6, so the total success probability is 2/3.

2) Tolerant Local Testing of High-Rate Tensor Codes -Proof of Lemma IV.4:
The proof of Lemma IV.4 relies on the following robust local testing procedure for high-rate tensor codes from [11] which is a local testing procedure with the property that local view on words far from the code is far on average from an accepting view.
Theorem IV.7 (Robust Local Testing of High-Rate Tensor Codes, [11,Theorem 3.1]): Suppose that C ⊆ F n is a linear code of relative distance δ, and t ≥ 3. Then for any w ∈ F n t , the expected relative distance of w from C ⊗2 on a random axis-parallel plane is at least δ O(t) · dist(w, C ⊗t ).
Proof of Lemma IV.4: Say we are given a string w ∈ F n t and we need to test if it is close to a codeword of C ⊗t . Let τ ≥ δ O(t) be some threshold parameter to be chosen later. The test is to choose a random axis-parallel plane P in F n t and find if there is a codeword c ∈ C ⊗2 which is τ -close to w| P . If yes, then accept, else reject. Clearly this test makes only n 2 queries. Also, by applying Corollary II. 16 to the code C ⊗2 , when τ < (δ/2) 2 this can be implemented in O(T · n) time.
To show completeness, let w ∈ F n t be some string which is α-close to a codeword c ∈ C ⊗t for α ≥ δ O(t) to be chosen later. Since individual points on a random axis-parallel plane are uniform over F n t , by Markov inequality, the probability that w| P is τ -far from c| P ∈ C ⊗2 is at most α/τ . So the probability that the test rejects w is at most p 0 := α/τ .
To show soundness, let w ∈ F n t be some string which is (δ/2) t -far from any codeword c ∈ C ⊗t . Then by Theorem IV.7, the expected relative distance of w| P from C ⊗2 is at least δ O(t) . Thus the probability that the test rejects w is at least sufficiently small so that p 0 < p 1 . Finally to get the acceptance and rejection probabilities to 2/3 as in the definition of tolerant locally testable codes, we repeat the above local test δ −O(t) times and accept a string if it is accepted in at least p0+p1 2fraction of the tests. By Chernoff bound, the new test will have the required soundness and completeness.

B. Capacity-Achieving Locally List Recoverable Codes
In this section we prove the following lemma which shows the existence of capacity-achieving locally list recoverable codes. An analogous lemma was proven in [34,Lemma 5.3], however only for local decoding message coordinates, and without the soundness property. The fact that we are able to locally correct codeword coordinates, as well as guarantee the soundness property, will be crucial for our GV bound local correction application.
• C N is an F 2 -linear code of block length N and alphabet size N o(1) . • C N has rate ρ and relative distance at least 1 − ρ − γ. (N o(1) , 1 − ρ − γ, ε, , N o(1) )-locally list recoverable with preprocessing and running time N o(1) . • C N is encodable in time N 1+o (1) . As in the proof of Lemma III.10, we first use Lemma IV.1 to obtain high-rate locally list recoverable codes, and then use the Alon-Edmonds-Luby (AEL) distance amplification method [15], [16] to turn these codes into capacity-achieving locally list recoverable codes. However, this time we shall use the following version of the AEL method for local list recovery from [18].
Suppose that C ⊆ (Σ ρ·t ) n is an outer code of rate 1 − γ and relative distance δ that is (Q, α, ε, , L)-locally list recoverable, and C ⊆ Σ t is an inner code of rate ρ and relative distance 1 − ρ − γ that is (1 − ρ − γ, , )globally list recoverable. Then there exists a code C AEL ⊆ (Σ t ) n of rate ρ − γ and relative distance 1 − ρ − 2γ that is (Q · poly(t), 1 − ρ − 2γ, ε, , L)-locally list recoverable. Moreover, • If the local list recovery algorithm for C has preprocessing time T pre and running time T , and C can be globally list recovered in time T , then the local list recovery algorithm for C AEL has preprocessing time T pre + Q · (T + poly(t, log n)) and running time T + Q · poly(t) · (T + poly(log n)). • If C, C have encoding times T, T , respectively, then C AEL has encoding time T + n · (T + poly(t, log n)). • If C, C are F-linear then so is C AEL .
To apply Lemma IV.1, we shall also need a high-rate base code that is both globally list recoverable and locally correctable. We obtain such a code by intersecting the high-rate globally list recoverable codes given by Theorem II.7 with the high-rate locally correctable codes given by the following lemma.
Lemma IV.10 (High-Rate Locally Correctable Codes): For any γ, β > 0, and integer N where q := N β is a prime power, there exists a code C N that satisfies the following.
We prove the above lemma in Section IV-B.1, based on the high-rate locally correctable codes of [45]. Next we prove Lemma IV.8, based on Lemmas IV.1, IV.9, and IV. 10.
Proof of Lemma IV.8: The proof is similar to that of Lemma III.10, with the main difference being that now we also need to take care that the base code will also be locally correctable. Specifically, we shall first apply Lemma IV.1 on a suitable high-rate base code C that is both globally list recoverable and locally correctable to obtain a high-rate locally list recoverable code C , and then use the transformation given by Lemma IV.9 to obtain a capacity-achieving locally list recoverable code C . a) Base code C: The code C will be the intersection of the efficient high-rate globally list recoverable code given by Theorem II.7 with the high-rate locally correctable code given by Lemma IV.10, in an appropriate setting of parameters.
Specifically, let β := 1 (log log N ) o(1) (where the o(1) term in the exponent is a sufficiently slowly decreasing function of N , i.e., β is a function that is slightly larger than 1/ log log N , e.g., log log log N log log N ), and we choose the block length of C to be N β , and the rate to be 1 − γβ/4. The code C will be constructed in turn as D 1 ∩ D 2 , where D 1 is the high-rate globally list recoverable code given by Theorem II.7, and D 2 is obtained using the high-rate locally correctable code given by Lemma IV.10, and both codes D 1 , D 2 have block length N β and rate 1 − γβ/8. Details follow.
b) The code D 1 : Let ≥ 1 be a constant to be chosen later on, and let D 1 be the linear code guaranteed by Theorem II.7 of block length N β , rate 1 − γβ/8, and relative distance (log log N ) −o (1) , that is ((log log N ) −o (1) , , exp exp((log log N ) o(1) ))-globally list recoverable. Note that such a code exists provided that the alphabet size is sufficiently large even power of a prime q := exp ((log log N ) o(1) ).
c) The code D 2 : The code D 2 will be constructed in turn as the concatenation of the high-rate locally correctable code D 2 given by Lemma IV.10 with an efficiently encodable and decodable linear code D 2 obtained using Fact II.3. The purpose of the concatenation is to reduce the alphabet size of D 2 to that of D 1 , as well as make the code D 2 linear. We first describe the code D 2 . Suppose that N β 2 is a power of q (which holds for infinite number of N 's). Lemma IV.10 guarantees the existence of an F q -linear code D 2 of length N β · (1 − γβ/16), alphabet size q a for a = (log N ) 1+o(1) , rate 1 − γβ/16, and relative distance (log log N ) −o (1) , that is Next we describe the code D 2 . The code D 2 will be an efficiently encodable and decodable linear code of length 1 1−γβ/16 · a, alphabet size q, rate 1 − γβ/16, and relative distance (log log N ) −o (1) . The code D 2 can be obtained in turn by taking the Reed-Solomon code from Fact II.3 of length 1−γβ/32 1−γβ/16 · a log log N , alphabet size q log log N (noting that q log log N > log 2 N > a), rate 1−γβ/ 16 1−γβ/32 , and relative distance (log log N ) −o (1) , and concatenating it with another Reed-Solomon code of length 1 1−γβ/32 · log log N , alphabet size q, rate 1 − γβ/32, and relative distance (log log N ) −o (1) .
Finally, by concatenating D 2 with D 2 we obtain a linear code D 2 of length N β , alphabet size q = exp((log log N ) o(1) ), rate 1 − γβ/8, and relative distance (log log N ) −o (1) , that is We conclude that C := D 1 ∩ D 2 is a linear code of block length N β , alphabet size exp((log log N ) o(1) ), rate 1 − γβ/4, and relative distance (log log N ) −o (1) , that is d) High-rate locally list recoverable code C : Let C be the code obtained by raising C to a tensor power of 1/β = (log log N ) o (1) . Then C has block length N , alphabet size exp((log log N ) o (1) ), rate at least 1 − γ/4, and relative distance exp(−(log log N ) o(1) ). Furthermore, by Lemma IV.1, it is (N o(1) , exp(−(log log N ) o(1) ), ε, , N o(1) )-locally list recoverable. e) Capacity-achieving locally list recoverable code C : Let C be the code obtained by applying Lemma IV.9 with the outer code being the code C constructed so far, and the inner code being a capacity-achieving globally list recoverable code D of rate ρ + γ/4 and relative distance at least 1 − ρ − γ/2.
Corollaries II.2 and II.6 guarantee the existence of a code D as above that is (1−ρ−γ/2, , )-globally list recoverable for some constant , provided that the alphabet size is a sufficiently large constant prime power, and the block length is sufficiently large. To satisfy the conditions of Lemma IV.9, we further require that the block length of D is sufficiently large exp((log log N ) o(1) ), and that the alphabet size of C is exp exp ((log log N ) o(1) )-the size of D -which can be achieved by grouping together consecutive symbols of C .
Finally, it can be verified that running times are as claimed (using brute-force encoding and decoding of inner code D ), and that all codes in the process can be taken to be F 2 -linear, and all transformations preserve F 2 -linearity, so the final code can be guaranteed to be F 2 -linear as well.
1) High-Rate Locally Correctable Codes -Proof of Lemma IV.10: Lemma IV.10 is a consequence of the following theorem from [45], summarizing the parameters of multiplicity codes.
Theorem IV.11 (Multiplicity Codes, [45], Lemmas 3.5 and 3.6, and [46]): The following holds for any integers s, d, m, and for any prime power q ≥ max{10 · m, d+6·s s , 12 · (s + 1)}. There exists an F q -linear code C of block length q m , alphabet size q ( m+s−1 m ) , relative distance at least δ := 1 − d s·q , and rate at least , δ/10)locally correctable. Moreover, C can be locally corrected in time O(q/δ m ), and encoded in time poly q m , m+s−1 m . Proof of Lemma IV.10: We set the code C N to be the code given by Theorem IV.11 with the following parameters. We choose q := N β to be the field size (which exists whenever q is a prime power), and choose m = 1/β. Note that indeed q m = N . We choose s = 2 m 2 /γ, δ = γ/(2m), and d = s · q · (1 − δ).
The alphabet size of the code is the relative distance is at least δ ≥ Ω(γ · β), and the rate is at least Furthermore, C N is locally correctable from Ω(γβ)-fraction of errors with query complexity as required.
Finally, it can be verified that running times are as required.

C. Local Correction up to the GV Bound
In this section we prove the following lemma which implies Corollary I.6 from the introduction.
Lemma IV.12: For any constants ρ ∈ [0, 0.02] and γ > 0 there exists an infinite family of binary linear codes {C N } N , where C N has block length N and rate ρ, and is locally correctable from -fraction of errors with query complexity N o (1) .

Furthermore,
• The local correction algorithm for C N runs in time N o (1) . • There exists a randomized algorithm which, on input N , runs in time N 1+o(1) and outputs with high probability a description of a code C N with the properties above. Given the description, the code C N can be encoded deterministically in time N 1+o(1) .
Similar to Lemma III.13, the proof of the above lemma relies on the random concatenation Lemma III.15, as well as the following lemma that is an analogue of Lemma III.16 for the setting of local list recovery.
Moreover, if the local list recovery algorithm for C has preprocessing time T pre and running time T , and each C (i) can be globally list recovered in time T , then the local list recovery algorithm for C con has preprocessing time T pre + Q · T and running time T + Q · T .
We prove the above lemma in Section IV-C.1. Finally, we shall also use the following lemma which shows that a locally list decodable code (satisfying the soundness property) is also locally correctable.
Lemma IV.14: Suppose that C ⊆ Σ n is a code of relative distance δ that is (Q, α, 0.1, L)-locally list decodable for α < δ/2. Then C is O Q · L · log 2 n (δ/2−α) 2 , α -locally correctable. Moreover, if the local list decoding algorithm has preprocessing time T pre and running time T , then the local correction algorithm runs in time T pre + O T · L · log 2 n (δ/2−α) 2 . Proof: We first run the local list decoding algorithm, and then choose a local corrector from the output list that is sufficiently close to the received word (which can be checked via sampling).
Specifically, let A be the local list decoding algorithm for C, by Remark II.11 we may assume that both the completeness and soundness properties of A hold with success probability 1 − 1 n 10 instead of 2 3 at the cost of increasing the query complexity and running time by a multiplicative factor of O(log n).
On oracle access to w ∈ Σ n and input coordinate i ∈ [n], the local correction algorithm A corr for C first runs the local list decoding algorithm A for C, let A 1 , . . . , A L be the local algorithms in the output list of A. Then for each j = 1, . . . , L, the algorithm A corr runs A j on a random subset S j ⊆ [n] of O log n (δ/2−α) 2 coordinates, and computes the fraction δ j of coordinates in S j on which the decoded values differ from the corresponding values of w. Finally, the algorithm A corr finds some A j for which δ j ≤ δ/2 (if such A j exists), and uses A j to locally correct the input coordinate i. Clearly, the query complexity and running time of A corr are as claimed. Next we show that A corr satisfies the required local correction guarantee.
Let c ∈ C be the (unique) codeword which satisfies that dist(w, c) ≤ α. We shall show below that with probability 0.9 − o(1), there exists some A j that computes c and satisfies that δ j ≤ δ/2, and on the other hand, with probability 0.9 − o(1), any A j which does not compute c satisfies that δ j > δ/2. This will imply in turn that the algorithm A corr will succeed in decoding the input coordinate correctly with probability 0.8 − o(1) ≥ 2 3 as required. We first show that with probability 0.9 − o(1), there exists some A j that computes c and satisfies that δ j ≤ δ/2. To see this note that by the completeness property of A, and since dist(w, c) ≤ α, with probability at least 0.9 over the randomness of A there exists some A j that computes c. In this case, by union bound with probability 1 − o(1) it holds that each decoded coordinate of A j in S j equals to the corresponding coordinate in c. Furthermore, by Chernoff bound with probability 1 − o(1) it holds that w and c differ on S j by at most δ 2 -fraction of the coordinates. Consequently, with probability 0.9 − o(1) it holds that δ j ≤ δ/2.
Next we show that with probability 0.9 − o(1), any A j which does not compute c satisfies that δ j > δ/2. For this note that by the soundness property of A, with probability at least 0.9 over the randomness of A, any such A j computes some codeword c ∈ C \ {c}. As above, by union bound with probability 1 − o(1) it holds that for any such A j , each decoded coordinate of A j in S j equals to the corresponding coordinate in c . On the other hand, since C has relative distance δ and dist(w, c) ≤ α, we have that dist(w, c ) ≥ δ − α = δ/2 + (δ/2 − α), and so by Chernoff bound with probability 1 − o(1) for any such A j it holds that w and c differ on S j by more than δ 2 -fraction of the coordinates. Consequently, with probability 0.9−o(1) it holds that δ j > δ/2 for any such A j .
Next we prove Lemma IV.12, based on the above lemma and Lemmas IV.8, III.15, and IV.13.
Proof of Lemma IV.12: The proof is similar to that of Lemma III.13. As in Lemma III.13, we apply random concatenation on the capacity-achieving locally list recoverable code C given by Lemma IV.8. By Lemma III.15, the resulting codeC will approach the Gilbert-Varshamov bound with high probability, while by Lemma IV.13, the codeC will also be locally list recoverable (and in particular, locally list decodable) with high probability. Lemma IV.14 then implies that whenever the list decoding radius exceeds the desired local correction radius, then the codeC can also be locally corrected from this radius. Details follow.
b) The codeC: LetC ⊆ F tN 2 be a binary linear code obtained from C by applying a random linear code Then the codeC has rate ρ, and by Lemma III.15 it also has relative distance at least (1), so with probability 1 − exp(−N ) this property holds for at least (1 − γ 2 /(4b 0 ))fraction of the C (i) 's. Lemma IV.13 implies in turn that the codeC is (N o(1) ,α, 0.1, N o(1) )-locally list decodable for c) Local correction: Next assume that the local list decoding radiusα exceeds the desired local correction radius, i.e., where ρ 0 := ρ θ −1 (ρ+γ/4) and ρ := θ −1 (ρ + γ/4). It was shown in [28,Section 4.4] that this is indeed the case whenever ρ ≤ 0.02 and γ is a sufficiently small constant.
Assuming that (4) holds, Lemma IV.14 implies thatC is locally correctable from -fraction of errors with query complexity N o (1) .
Finally, it can also be verified that running times are as claimed (using brute-force encoding and decoding of inner codes C (i) ).

1) Concatenation for Local List Recovery -Proof of Lemma IV.13:
Proof of Lemma IV.13: The local list recovery algorithm A for C con will run the local list recovery algorithm A for C, and answer the queries of A by globally list recovering the C (i) 's corresponding to the queries of A.
In more detail, on oracle access to a string of input lists S ∈ Σ tn , the local list recovery algorithmÃ for C con runs the local list recovery algorithm A for C, and whenever A asks for some coordinate i ∈ [n], the algorithmÃ globally list recovers the i-th block of S of length t from α -fraction of errors, and feeds the messages corresponding to the first codewords in the output list as an answer to the query of A. Let A 1 , . . . , A L be the resulting output local algorithms of A. ThenÃ outputs L local algorithmsÃ 1 , . . . ,Ã L where each algorithmÃ j is defined as follows.
To locally correct the r-th coordinate in the k-th block of C con of length t (that is, a coordinate of the form (k−1)·t+r ∈ [tn] where 1 ≤ k ≤ n and 1 ≤ r ≤ t), the algorithmÃ j runs the algorithm A j on input coordinate k. As above, whenever A j asks for some coordinate i ∈ [n], the algorithmÃ j globally list recovers the i-th block of S of length t from α -fraction of errors, and feeds the messages corresponding to the first codewords in the output list as an answer to the query of A j . Let σ ∈ Σ ρ ·t be the output symbol of A j . Then the algorithm A j outputs the r-th symbol of C (k) (σ) ∈ Σ t .
Clearly, query complexity, output list size, and running times ofÃ are as claimed. The soundness ofÃ follows from the soundness of A: with probability 1 − ε over the random choices of A, the local algorithms A 1 , . . . , A L are implicitly computing codewords c 1 , . . . , c L ∈ C. In this favorable event, the local algorithmsÃ 1 , . . . ,Ã L are implicitly computing the codewordsc 1 , . . . ,c L ∈ C con , where eachc j is obtained from c j by the concatenation.
To see that the completeness property holds as well note that if dist(c, S) ≤ (α − γ) · α for somec ∈ C con , then by Markov's inequality for at most an (α − γ)-fraction of i ∈ [n] it holds that the i-th block of S of length t is inconsistent with the i-th block ofc of length t by more than an α -fraction of the coordinates. Moreover, since at least a (1 − γ)-fraction of the codes C (i) are (α , , )-list recoverable, list recovery of the C (i) 's fails on at most an α-fraction of the blocks. Completeness then follows since C is locally list recoverable from an α-fraction of errors.
V. COMBINATORIAL LOWER BOUND ON OUTPUT LIST SIZE In this section, we first provide a combinatorial lower bound on the output list size for list recovering a high-rate tensor product C ⊗t , even in the noiseless setting. In particular, we show that the output list size must be doubly-exponential in t. From this, we are able to deduce certain corollaries demonstrating that our algorithms nearly achieve optimal parameters.
Recall that given vectors coordinate is given by the product For the special case of t = 2, the tensor product u ⊗ v can be thought of as the outer product uv T .
We also record the following standard fact regarding tensor products.
Thus, for all k ∈ [n 1 ], we find As v 1 , . . . , v t2 are linearly independent, this implies that for all j ∈ [t 2 ] and k ∈ [n 1 ], which is the same as saying that for all j ∈ [t 2 ], i∈ [t1] α i,j u i = 0 .

A. Output List Size for List Recovering High-Rate Tensor Codes
In this section we prove Theorem I.7 from the introduction, which we restate here for convenience.
Theorem I.7 (Output List Size for List Recovering High-Rate Tensor Codes): Suppose that C ⊆ F n is a linear code of rate 1 − γ, and that C ⊗t ⊆ F n t is (0, , L)-list recoverable. Then L ≥ 1/γ t . To prove this theorem, we first prove the following proposition. Informally speaking, we iteratively apply the Singleton bound to conclude that linear codes of rate 1−γ contain about 1/γ codewords with pairwise disjoint supports. Recall that, for a vector v ∈ F n , the support of v is Proposition V.2: Let C ⊆ F n be a subspace of dimension k, and let r be a positive integer. Suppose that 1 − 1 Then there exist non-zero vectors c 1 , . . . , c r ∈ C such that for Proof: Let m := n − k + 1, and note that Condition (5) is equivalent to Take a basis for C of the form (e 1 , u 1 ), . . . , (e k , u k ), where e i ∈ F k is the ith standard basis vector, and u 1 , . . . , u k ∈ F n−k are vectors. For j = 1, . . . , r − 1, we can find a nontrivial linear combination of the vectors u (j−1)·m+1 , . . . , u j·m summing to zero, as they are a (multi-)set of m = n − k + 1 vectors lying in F n−k . Taking this linear combination of (e (j−1)·m+1 , u (j−1)·m+1 ), . . . , (e j·m , u j·m ), we obtain a nonzero vector whose support is contained in the interval {(j − 1) · m + 1, . . . , j · m}; denote this vector by c j . In this manner, we obtain r−1 nonzero vectors c 1 , . . . , c r−1 ∈ C with pairwise disjoint support. Finally, we may add the vector c r := (e k , u k ) to this collection, yielding r vectors, as desired.
Next we prove Theorem I.7, based on the above proposition.
Proof of Theorem I.7: Let r := 1/γ, and recall wish to come up with r t codewords in C ⊗t that are contained in the output list for appropriately chosen input lists.
In order to accomplish this, we first use Proposition V.2 to obtain a subset C ⊆ C of r nonzero codewords with pairwise disjoint support. We then consider the subset C ⊆ C ⊗t containing all tensor products c 1 ⊗ c 2 ⊗ · · · ⊗ c t of t (not necessarily distinct) codewords c 1 , . . . , c t ∈ C , and our main observation is that all these r t tensor products are also nonzero with pairwise disjoint support. Finally, we let B ⊆ F be an arbitrary subset of size , and consider the subsetC ⊆ C ⊗t containing all linear combinations of codewords in C with coefficients in B. Since all codewords in C are nonzero with pairwise disjoint support, they are in particular linearly independent, so the setC contains r t distinct codewords in C ⊗t .
Moreover, since codewords in C have pairwise disjoint support, for each coordinate (i 1 , . . . , i t ) ∈ [n] t , there is at most one codeword c ∈ C for which c i1,...,it is nonzero. Therefore this is the only term which can contribute nontrivially to the value in the (i 1 , . . . , i t ) coordinate of a codeword inC. So we can let the corresponding input list S i1,...,it contain all multiples of c i1,...,it by elements in B. Details follow.
a) The set C : Since C has rate 1 − γ, it has dimension k = (1 − γ)n, and so Proposition V.2 guarantees the existence of a subset C ⊆ C of r = 1/γ nonzero codewords with pairwise disjoint support.
b) The set C : Next we let be the subset of C ⊗t containing all tensor products of t (not necessarily distinct) codewords in C . Since all codewords in C are nonzero, their t-wise tensor products are nonzero as well.
To see that all codewords in C have pairwise disjoint support, suppose that c = c 1 ⊗ c 2 ⊗ . . . ⊗ c t ∈ C , and (i 1 , i 2 , . . . , i t ) ∈ Supp(c). Then c) The setC: Now, let B ⊆ F be an arbitrary subset of size , and let C := c∈C β c · c β c ∈ B for all c ∈ C be the subset of C ⊗t containing all linear combinations of codewords in C with coefficients in B. Since all codewords in C are nonzero with pairwise disjoint support, they are in particular linearly independent in F n t , 8 so the setC contains r t distinct codewords in C ⊗t . d) Input lists: Finally, we wish to define input lists S i1,...,it for any coordinate (i 1 , . . . , i t ) ∈ [n] t so that for any codeword c ∈C, and for any coordinate (i 1 , . . . , i t ) ∈ [n] t , it holds that c i1,...,it ∈ S i1,...,it .
To this end, we observe that since codewords in C have pairwise disjoint support, for each coordinate (i 1 , . . . , i t ) ∈ [n] t , there is at most one codeword c ∈ C for which c i1,...,it is nonzero. Therefore this is the only term which can contribute nontrivially to the value in the (i t , . . . , i t ) coordinate of a codeword inC. So we can define the corresponding input list S i1,...,it as S i1,...,it := {β · c i1,...,it | β ∈ B} if such a codeword c exists, and as S i1,...,it = {0} otherwise. Note that each set S i1,...,it has size at most , and that they satisfy the required property.
This yields a set of r t codewords from C ⊗t that are contained in the output list for the input list tuple S defined above, proving the theorem.

B. Concrete Lower Bound on Output List Size
In this section, we demonstrate a setting of parameters that yields Proposition I.8 from the introduction, restated below.
Proposition I. 8: For any δ > 0 and > 1 there exists L > 1 such that the following holds for any sufficiently large n. There exists a linear code C ⊆ F n of relative distance δ that is (Ω(δ), , L)-list recoverable, but C ⊗t ⊆ F n t is only (0, , L )-list recoverable for L ≥ exp((2δ) −(t−3/2) · √ log L). We use the following result on the list-recoverability of random linear codes from [47].

C. Lower Bound for Local List Recovering
We now prove Proposition I.9 from the introduction, restated below. Proposition I. 9: For any δ > 0 and sufficiently large n there exists a linear code C ⊆ F n of relative distance δ such that the following holds. Suppose that C ⊗t ⊆ F N is ( 1 N, 2, L)locally list recoverable with query complexity Q. Then Q·L ≥ N Ω δ (1/ log log N ) . 9 We first recall Lemma IV.14 (restated below in a shorter form) which says that a locally list decodable (and in particular locally list recoverable) code with output list size L and query complexity Q is also locally correctable with query complexity roughly Q · L. Lemma V. 3: Suppose that C ⊆ Σ n is a code of relative distance δ that is (Q, α, 0.1, L)-locally list decodable for α < δ/2. Then C is O Q · L · log 2 n (δ/2−α) 2 , α -locally correctable. So to prove Proposition I.9, it is enough to show a lower bound on the query complexity for local correcting C ⊗t , assuming that the output list for list recovering C ⊗t is small. To show such a lower bound, we first observe that for any linear code C, the (absolute) distance of C ⊥ is a lower bound on the query complexity for local correcting C.
Lemma V. 4: Suppose that C ⊆ F n is a linear code that is (Q, 1 n)-locally correctable. Then Q ≥ Δ(C ⊥ ) − 2. 9 Here and throughout, subscripts in asympotic notation indicate that the implied constant may depend on the subscripted variable(s).
We prove the above lemma in Section V-C.1. To apply this lemma to C ⊗t we further observe that the tensor product preserves the dual distance of the base code.
We prove the above lemma in Section V-C.2. We now proceed to the proof of Corollary I. 9.
Proof of Proposition I. 9: Let C ⊆ F n be a random linear code of rate 1 − 2δ. By Corollary II.2, for sufficiently large field size, the code C will have relative distance at least δ with high probability. Moreover, since C ⊥ has rate 2δ, by the same corollary we also have that C ⊥ has relative distance at least 1 − 3δ with high probability (note that C ⊥ is also a random linear code). We conclude for any sufficiently large n the existence of a linear code C ⊆ F n of rate 1 − 2δ and relative distance at least δ such that C ⊥ has relative distance at least 1 − 3δ.
Next observe that for the code C ⊗t to be (Q, 1 N, 0.1, 2, L)locally list recoverable, it in particular must be (0, 2, L)-list recoverable, so the lower bound from Theorem I.7 implies that L ≥ 2 1/(2δ) t . Now, if 2 1/(2δ) t ≥ N then we have that Q·L ≥ 2 1/(2δ) t ≥ N , and we are done. So we may assume that 2 1/(2δ) t < N which implies in turn that t = O δ (log log N ) and n = N 1/t = N Ω δ (1/ log log N ) .
Moreover, as we have assumed we have a (Q, 1 N , 0.1, 2, L)local list recovery algorithm for C ⊗t , we also have a (Q, 1 N, 0.1, L)-local list decoding algorithm for C ⊗t . Lemma V.3 then promises that we have a (O(Q · L · log 2 N (δ t /2−1/N ) 2 ), 1 N )-local correction algorithm for C ⊗t . Now, by Lemma V.5 we have that (C ⊗t ) ⊥ has (absolute) distance at least (1 − 3δ)n, and consequently Lemma V.4 implies that This implies Q · L ≥ N Ω δ (1/ log log N ) , as desired.

1) Dual Distance Is a Lower Bound on Query
Complexity -Proof of Lemma V.4: First, we recall the standard fact that (absolute) dual distance Δ implies that the uniform distribution over the code is (Δ − 1)-wise independent.
In what follows let Δ := Δ(C ⊥ ), and let q denote the alphabet size of C. Now, making use of Yao's principle, it suffices to show a distribution D over vectors w at absolute distance at most 1 from C such that the following holds. For any deterministic algorithm making at most Δ − 2 queries to its input w sampled according to D, the probability that it correctly computes c 1 is at most 1/3, where c is the unique codeword in C at absolute distance at most 1 from w. We will in fact show that no deterministic query algorithm can correctly compute c 1 with probability greater than 1/q.
Let D denote the distribution that samples c ∈ C uniformly at random and then sets c 1 = 0. Let A be a deterministic algorithm making at most Δ − 2 queries, and let j 1 , . . . , j s ∈ [n] denote the queries made by A, where we assume s ≤ Δ−2. Note that querying 1 does not help A, as it will always read 0. Hence, without loss of generality, 1 / ∈ {j 1 , . . . , j s }. Now, by Fact V .6, for any b 1 , . . . , b s , a ∈ F  Additionally, observe that the distribution of the tuple (c j1 , . . . , c js ) is the same if c is a uniformly random codeword from C or if it is sampled according to D.
Hence, if we think of the query algorithm as implementing a (deterministic) function g : F s q → F q from the responses to its queries to its guess for c 1 , regardless of the responses b 1 , . . . , b s to the queries, we have where c is the unique codeword in C for which dist(c, w) ≤ 1 n. That is, the query algorithm will not be able to guess c 1 with probability greater than 1/q, as claimed.
It is well-known (and not hard to show) that the (absolute) distance of a code C is the minimum number of linearly dependent columns in a parity-check matrix for C. Furthermore, by duality we have that if G is a generating matrix for C then G T is a parity-check matrix for C ⊥ . We conclude that the distance of C ⊥ is the minimum number of linearly dependent rows in a generating matrix for C.
Let G 1 , G 2 be generating matrices for C 1 , C 2 , respectively, and note that by the above, any collection of t 1 < Δ 1 , t 2 < Δ 2 rows of G 1 , G 2 , respectively, are linearly independent. Next recall that G 1 ⊗ G 2 is a generating matrix for C 1 ⊗ C 2 , and so it suffices to show that for any t < min{Δ 1 , Δ 2 }, any collection of t rows of G 1 ⊗ G 2 are linearly independent.
Let u 1 , u 2 , . . . , u n1 and v 1 , v 2 , . . . , v n2 denote the rows of G 1 , G 2 , respectively, and note that each row in G 1 ⊗ G 2 is of the form u i ⊗ v j for some i ∈ [n 1 ], j ∈ [n 2 ]. Fix t < min{Δ 1 , Δ 2 }, and suppose that u i1 ⊗ v j1 , u i2 ⊗ v j2 , . . . , u it ⊗ v jt is a collection of t rows of G 1 ⊗G 2 . Then by the above we have that both collections u i1 , u i2 , . . . , u it and v j1 , v j2 , . . . , v jt are linearly independent (ignoring duplications). Fact V.1 implies in turn that the collection u i1 ⊗v j1 , u i2 ⊗v j2 , . . . , u it ⊗ v jt are also linearly independent which concludes the proof of the lemma.