arXiv subjects

Noga Ron-Zewi

Publications and source records attributed to Noga Ron-Zewi.

17 recordsLinked to original sources

arXiv2026

Time- and Space-Efficient List Decoding up to Capacity

In the theory of error correcting codes, list-decoding refers to the following problem. Given a code $C \subseteq Σ^N$ and a received word $y \in Σ^N$, find all codewords $c \in C$ so that $δ(c,y) \leq ρ$, where $δ$ is relative Hamming distance and $ρ\in (0,1)$. Codes that approach the optimal trade-off between the rate $R := \log_{|Σ|}(|C|) / N$ and the list-decoding radius $ρ$ are said to achieve capacity.By now, there are constructions of capacity-achieving list-decodable codes with fast near-linear-time list-decoding algorithms, but most existing work has not considered space complexity. In a recent line of work, Cook and Moshkovitz (2024, 2025, 2026) initiated the study of low-space deterministic algorithms for error correcting codes. In particular, in their 2026 paper, they gave a construction of list-decodable codes with deterministic near-linear-time and sublinear space list-decoding algorithms. However, these codes were far from achieving capacity. In this paper, we present list-decodable codes approaching capacity with deterministic time- and space-efficient list-decoding algorithms. More precisely, for any $R \in (0,1)$ and any arbitrarily small constant $τ> 0$, we present a family of codes $C\subseteq Σ^N$ with rate $R$ that are deterministically list-decodable up to radius $ρ= 1 - R - τ$, in time $N^{1 + τ}$ and space $N^τ$ with constant output list size and constant alphabet size. Our results can be extended to capacity-achieving list-recoverable codes.

cs.IT↗

arXiv2026

A Note on the Equivalence Between Zero-knowledge and Quantum CSS Codes

Zero-knowledge codes, introduced by Decatur, Goldreich, and Ron (ePrint 1997), are error-correcting codes in which few codeword symbols reveal no information about the encoded message, and have been extensively used in cryptographic constructions. Quantum CSS codes, introduced by Calderbank and Shor (Phys. Rev. A 1996) and Steane (Royal Society A 1996), are error-correcting codes that allow for quantum error correction, and are also useful for applications in quantum complexity theory. In this short note, we show that (linear, perfect) zero-knowledge codes and quantum CSS codes are equivalent. We demonstrate the potential of this equivalence by using it to obtain explicit asymptotically-good zero-knowledge locally-testable codes.

cs.IT↗

arXiv2026

Advances in List Decoding of Polynomial Codes

Error-correcting codes are a method for representing data, so that one can recover the original information even if some parts of it were corrupted. The basic idea, which dates back to the revolutionary work of Shannon and Hamming about a century ago, is to encode the data into a redundant form, so that the original information can be decoded from the redundant encoding even in the presence of some noise or corruption. One prominent family of error-correcting codes are Reed-Solomon Codes which encode the data using evaluations of low-degree polynomials. Nearly six decades after they were introduced, Reed-Solomon Codes, as well as some related families of polynomial-based codes, continue to be widely studied, both from a theoretical perspective and from the point of view of applications. Besides their obvious use in communication, error-correcting codes such as Reed-Solomon Codes are also useful for various applications in theoretical computer science. These applications often require the ability to cope with many errors, much more than what is possible information-theoretically. List-decodable codes are a special class of error-correcting codes that enable correction from more errors than is traditionally possible by allowing a small list of candidate decodings. These codes have turned out to be extremely useful in various applications across theoretical computer science and coding theory. In recent years, there have been significant advances in list decoding of Reed-Solomon Codes and related families of polynomial-based codes. This includes efficient list decoding of such codes up to the information-theoretic capacity, with optimal list-size, and using fast nearly-linear time, and even sublinear-time, algorithms. In this book, we survey these developments.

cs.IT↗

arXiv2025

Efficient Decoding of Double-circulant and Wozencraft Codes from Square-root Errors

We present efficient decoding algorithms from square-root errors for two known families of double-circulant codes: A construction based on Sidon sets (Bhargava, Taveres, and Shiva, \emph{IEEE IT 74}; Calderbank, \emph{IEEE IT 83}; Guruswami and Li, \emph{IEEE IT 2025}), and a construction based on cyclic codes (Chen, Peterson, and Weldon, \emph{Information and Control 1969}). We further observe that the work of Guruswami and Li implicitly gives a transformation from double-circulant codes of certain block lengths to Wozencraft codes which preserves that distance of the codes, and we show that this transformation also preserves efficiency of decoding. By instantiating this transformation with the first family of double-circulant codes based on Sidon sets, we obtain an explicit construction of a Wozencraft code that is efficiently decodable from square-root errors. We also discuss limitations on instantiating this transformation with the second family of double-circulant codes based on cyclic codes.

cs.IT↗

arXiv2024

Efficient List-decoding of Polynomial Ideal Codes with Optimal List Size

In a recent breakthrough [BGM23, GZ23, AGL23], it was shown that randomly punctured Reed-Solomon codes are list decodable with optimal list size with high probability, i.e., they attain the Singleton bound for list decoding [ST20, Rot22, GST22]. We extend this result to the family of polynomial ideal codes, a large class of error-correcting codes which includes several well-studied families of codes such as Reed-Solomon, folded Reed-Solomon, and multiplicity codes. More specifically, similarly to the Reed-Solomon setting, we show that randomly punctured polynomial ideal codes over an exponentially large alphabet exactly achieve the Singleton bound for list-decoding; while such codes over a polynomially large alphabet approximately achieve it. Combining our results with the efficient list-decoding algorithm for a large subclass of polynomial ideal codes of [BHKS21], implies as a corollary that a large subclass of polynomial ideal codes (over random evaluation points) is efficiently list decodable with optimal list size. To the best of our knowledge, this gives the first family of codes that can be efficiently list decoded with optimal list size (for all list sizes), as well as the first family of linear codes of rate $R$ that can be efficiently list decoded up to a radius of $1 -R-ε$ with list size that is polynomial (and even linear) in $1/ε$. Our result applies to natural families of codes with algebraic structure such as folded Reed-Solomon or multiplicity codes (over random evaluation points). Our proof follows the general framework of [BGM23, GZ23, AGL23], but several new ingredients are needed. The main two new ingredients are a polynomial-ideal GM-MDS theorem (extending the algebraic GM-MDS theorem of [YH19, Lov21]), as well as a duality theorem for polynomial ideal codes, both of which may be of independent interest.

cs.IT↗

arXiv2024

Query complexity lower bounds for local list-decoding and hard-core predicates (even for small rate and huge lists)

A binary code Enc$:\{0,1\}^k \to \{0,1\}^n$ is $(0.5-ε,L)$-list decodable if for all $w \in \{0,1\}^n$, the set List$(w)$ of all messages $m \in \{0,1\}^k$ such that the relative Hamming distance between Enc$(m)$ and $w$ is at most $0.5 -ε$, has size at most $L$. Informally, a $q$-query local list-decoder for Enc is a randomized procedure Dec$:[k]\times [L] \to \{0,1\}$ that when given oracle access to a string $w$, makes at most $q$ oracle calls, and for every message $m \in \text{List}(w)$, with high probability, there exists $j \in [L]$ such that for every $i \in [k]$, with high probability, Dec$^w(i,j)=m_i$. We prove lower bounds on $q$, that apply even if $L$ is huge (say $L=2^{k^{0.9}}$) and the rate of Enc is small (meaning that $n \ge 2^{k}$): 1. For $ε\geq 1/k^ν$ for some universal constant $0< ν< 1$, we prove a lower bound of $q=Ω(\frac{\log(1/δ)}{ε^2})$, where $δ$ is the error probability of the local list-decoder. This bound is tight as there is a matching upper bound by Goldreich and Levin (STOC 1989) of $q=O(\frac{\log(1/δ)}{ε^2})$ for the Hadamard code (which has $n=2^k$). This bound extends an earlier work of Grinberg, Shaltiel and Viola (FOCS 2018) which only works if $n \le 2^{k^γ}$ for some universal constant $0<γ<1$, and the number of coins tossed by Dec is small (and therefore does not apply to the Hadamard code, or other codes with low rate). 2. For smaller $ε$, we prove a lower bound of roughly $q = Ω(\frac{1}{\sqrtε})$. To the best of our knowledge, this is the first lower bound on the number of queries of local list-decoders that gives $q \ge k$ for small $ε$. We also prove black-box limitations for improving some of the parameters of the Goldreich-Levin hard-core predicate construction.

cs.CC↗

arXiv2024

Simple Constructions of Unique Neighbor Expanders from Error-correcting Codes

In this note, we give very simple constructions of unique neighbor expander graphs starting from spectral or combinatorial expander graphs of mild expansion. These constructions and their analysis are simple variants of the constructions of LDPC error-correcting codes from expanders, given by Sipser-Spielman [SS96] (and Tanner [Tan81]), and their analysis. We also show how to obtain expanders with many unique neighbors using similar ideas. There were many exciting results on this topic recently, starting with Asherov-Dinur [AD23] and Hsieh-McKenzie-Mohanty-Paredes [HMMP23], who gave a similar construction of unique neighbor expander graphs, but using more sophisticated ingredients (such as almost-Ramanujan graphs) and a more involved analysis. Subsequent beautiful works of Cohen-Roth-TaShma [CRT23] and Golowich [Gol23] gave even stronger objects (lossless expanders), but also using sophisticated ingredients. The main contribution of this work is that we get much more elementary constructions of unique neighbor expanders and with a simpler analysis.

cs.CC↗

arXiv2023

Finer-grained Reductions in Fine-grained Hardness of Approximation

We investigate the relation between $δ$ and $ε$ required for obtaining a $(1+δ)$-approximation in time $N^{2-ε}$ for closest pair problems under various distance metrics, and for other related problems in fine-grained complexity. Specifically, our main result shows that if it is impossible to (exactly) solve the (bichromatic) inner product (IP) problem for vectors of dimension $c \log N$ in time $N^{2-ε}$, then there is no $(1+δ)$-approximation algorithm for (bichromatic) Euclidean Closest Pair running in time $N^{2-2ε}$, where $δ\approx (ε/c)^2$ (where $\approx$ hides $\polylog$ factors). This improves on the prior result due to Chen and Williams (SODA 2019) which gave a smaller polynomial dependence of $δ$ on $ε$, on the order of $δ\approx (ε/c)^6$. Our result implies in turn that no $(1+δ)$-approximation algorithm exists for Euclidean closest pair for $δ\approx ε^4$, unless an algorithmic improvement for IP is obtained. This in turn is very close to the approximation guarantee of $δ\approx ε^3$ for Euclidean closest pair, given by the best known algorithm of Almam, Chan, and Williams (FOCS 2016). By known reductions, a similar result follows for a host of other related problems in fine-grained hardness of approximation. Our reduction combines the hardness of approximation framework of Chen and Williams, together with an MA communication protocol for IP over a small alphabet, that is inspired by the MA protocol of Chen (Theory of Computing, 2020).

cs.DS↗

arXiv2021

LDPC Codes Achieve List Decoding Capacity

We show that Gallager's ensemble of Low-Density Parity Check (LDPC) codes achieves list-decoding capacity with high probability. These are the first graph-based codes shown to have this property. This result opens up a potential avenue towards truly linear-time list-decodable codes that achieve list-decoding capacity. Our result on list decoding follows from a much more general result: any $\textit{local}$ property satisfied with high probability by a random linear code is also satisfied with high probability by a random LDPC code from Gallager's distribution. Local properties are properties characterized by the exclusion of small sets of codewords, and include list-decodability, list-recoverability and average-radius list-decodability. In order to prove our results on LDPC codes, we establish sharp thresholds for when local properties are satisfied by a random linear code. More precisely, we show that for any local property $\mathcal{P}$, there is some $R^*$ so that random linear codes of rate slightly less than $R^*$ satisfy $\mathcal{P}$ with high probability, while random linear codes of rate slightly more than $R^*$, with high probability, do not. We also give a characterization of the threshold rate $R^*$.

cs.IT↗

arXiv2021

Efficient List-Decoding with Constant Alphabet and List Sizes

We present an explicit and efficient algebraic construction of capacity-achieving list decodable codes with both constant alphabet and constant list sizes. More specifically, for any $R \in (0,1)$ and $ε>0$, we give an algebraic construction of an infinite family of error-correcting codes of rate $R$, over an alphabet of size $(1/ε)^{O(1/ε^2)}$, that can be list decoded from a $(1-R-ε)$-fraction of errors with list size at most $\exp(\mathrm{poly}(1/ε))$. Moreover, the codes can be encoded in time $\mathrm{poly}(1/ε, n)$, the output list is contained in a linear subspace of dimension at most $\mathrm{poly}(1/ε)$, and a basis for this subspace can be found in time $\mathrm{poly}(1/ε, n)$. Thus, both encoding and list decoding can be performed in fully polynomial-time $\mathrm{poly}(1/ε, n)$, except for pruning the subspace and outputting the final list which takes time $\exp(\mathrm{poly}(1/ε))\cdot\mathrm{poly}(n)$. Our codes are quite natural and structured. Specifically, we use algebraic-geometric (AG) codes with evaluation points restricted to a subfield, and with the message space restricted to a (carefully chosen) linear subspace. Our main observation is that the output list of AG codes with subfield evaluation points is contained in an affine shift of the image of a block-triangular-Toeplitz (BTT) matrix, and that the list size can potentially be reduced to a constant by restricting the message space to a BTT evasive subspace, which is a large subspace that intersects the image of any BTT matrix in a constant number of points. We further show how to explicitly construct such BTT evasive subspaces, based on the explicit subspace designs of Guruswami and Kopparty (Combinatorica, 2016), and composition.

cs.CC↗

arXiv2020

Locally testable codes via high-dimensional expanders

Locally testable codes (LTC) are error-correcting codes that have a local tester which can distinguish valid codewords from words that are "far" from all codewords by probing a given word only at a very few (sublinear, typically constant) number of locations. Such codes form the combinatorial backbone of PCPs. A major open problem is whether there exist LTCs with positive rate, constant relative distance and testable with a constant number of queries. In this paper, we present a new approach towards constructing such LTCs using the machinery of high-dimensional expanders. To this end, we consider the Tanner representation of a code, which is specified by a graph and a base code. Informally, our result states that if this graph is part of a high-dimensional expander then the local testability of the code follows from the local testability of the base code. This work unifies and generalizes the known results on testability of the Hadamard, Reed-Muller and lifted codes on the Subspace Complex, all of which are proved via local self correction. However, unlike previous results, constant rounds of self correction do not suffice as the diameter of the underlying test graph can be logarithmically large in a high-dimensional expander and not constant as in all known earlier results. We overcome this technical hurdle by performing iterative self correction with logarithmically many rounds and tightly controlling the error in each iteration using properties of the high-dimensional expander. Given this result, the missing ingredient towards constructing a constant-query LTC with positive rate and constant relative distance is an instantiation of a base code that interacts well with a constant-degree high-dimensional expander.

cs.CC↗

arXiv2020

Linear-time Erasure List-decoding of Expander Codes

We give a linear-time erasure list-decoding algorithm for expander codes. More precisely, let $r > 0$ be any integer. Given an inner code $C_0$ of length $d$, and a $d$-regular bipartite expander graph $G$ with $n$ vertices on each side, we give an algorithm to list-decode the expander code $C = C(G, C_0)$ of length $nd$ from approximately $δδ_r nd$ erasures in time $n \cdot \mathrm{poly}(d2^r / δ)$, where $δ$ and $δ_r$ are the relative distance and the $r$'th generalized relative distance of $C_0$, respectively. To the best of our knowledge, this is the first linear-time algorithm that can list-decode expander codes from erasures beyond their (designed) distance of approximately $δ^2 nd$. To obtain our results, we show that an approach similar to that of (Hemenway and Wootters, Information and Computation, 2018) can be used to obtain such an erasure-list-decoding algorithm with an exponentially worse dependence of the running time on $r$ and $δ$; then we show how to improve the dependence of the running time on these parameters.

cs.IT↗

arXiv2018

Improved decoding of Folded Reed-Solomon and Multiplicity Codes

In this work, we show new and improved error-correcting properties of folded Reed-Solomon codes and multiplicity codes. Both of these families of codes are based on polynomials over finite fields, and both have been the sources of recent advances in coding theory. Folded Reed-Solomon codes were the first explicit constructions of codes known to achieve list-decoding capacity; multivariate multiplicity codes were the first constructions of high-rate locally correctable codes; and univariate multiplicity codes are also known to achieve list-decoding capacity. However, previous analyses of the error-correction properties of these codes did not yield optimal results. In particular, in the list-decoding setting, the guarantees on the list-sizes were polynomial in the block length, rather than constant; and for multivariate multiplicity codes, local list-decoding algorithms could not go beyond the Johnson bound. In this paper, we show that Folded Reed-Solomon codes and multiplicity codes are in fact better than previously known in the context of list-decoding and local list-decoding. More precisely, we first show that Folded RS codes achieve list-decoding capacity with constant list sizes, independent of the block length; and that high-rate univariate multiplicity codes can also be list-recovered with constant list sizes. Using our result on univariate multiplicity codes, we show that multivariate multiplicity codes are high-rate, locally list-recoverable codes. Finally, we show how to combine the above results with standard tools to obtain capacity achieving locally list decodable codes with query complexity significantly lower than was known before.

cs.IT↗

arXiv2017

Local List Recovery of High-rate Tensor Codes and Applications

In this work, we give the first construction of high-rate locally list-recoverable codes. List-recovery has been an extremely useful building block in coding theory, and our motivation is to use these codes as such a building block. In particular, our construction gives the first capacity-achieving locally list-decodable codes (over constant-sized alphabet); the first capacity achieving globally list-decodable codes with nearly linear time list decoding algorithm (once more, over constant-sized alphabet); and a randomized construction of binary codes on the Gilbert-Varshamov bound that can be uniquely decoded in near-linear-time, with higher rate than was previously known. Our techniques are actually quite simple, and are inspired by an approach of Gopalan, Guruswami, and Raghavendra (Siam Journal on Computing, 2011) for list-decoding tensor codes. We show that tensor powers of (globally) list-recoverable codes are "approximately" locally list-recoverable, and that the "approximately" modifier may be removed by pre-encoding the message with a suitable locally decodable code. Instantiating this with known constructions of high-rate globally list-recoverable codes and high-rate locally decodable codes finishes the construction.

cs.IT↗

arXiv2015

High rate locally-correctable and locally-testable codes with sub-polynomial query complexity

In this work, we construct the first locally-correctable codes (LCCs), and locally-testable codes (LTCs) with constant rate, constant relative distance, and sub-polynomial query complexity. Specifically, we show that there exist binary LCCs and LTCs with block length $n$, constant rate (which can even be taken arbitrarily close to 1), constant relative distance, and query complexity $\exp(\tilde{O}(\sqrt{\log n}))$. Previously such codes were known to exist only with $Ω(n^β)$ query complexity (for constant $β> 0$), and there were several, quite different, constructions known. Our codes are based on a general distance-amplification method of Alon and Luby~\cite{AL96_codes}. We show that this method interacts well with local correctors and testers, and obtain our main results by applying it to suitably constructed LCCs and LTCs in the non-standard regime of \emph{sub-constant relative distance}. Along the way, we also construct LCCs and LTCs over large alphabets, with the same query complexity $\exp(\tilde{O}(\sqrt{\log n}))$, which additionally have the property of approaching the Singleton bound: they have almost the best-possible relationship between their rate and distance. This has the surprising consequence that asking for a large alphabet error-correcting code to further be an LCC or LTC with $\exp(\tilde{O}(\sqrt{\log n}))$ query complexity does not require any sacrifice in terms of rate and distance! Such a result was previously not known for any $o(n)$ query complexity. Our results on LCCs also immediately give locally-decodable codes (LDCs) with the same parameters.

cs.CC↗

arXiv2012

Sampling-based proofs of almost-periodicity results and algorithmic applications

We give new combinatorial proofs of known almost-periodicity results for sumsets of sets with small doubling in the spirit of Croot and Sisask, whose almost-periodicity lemma has had far-reaching implications in additive combinatorics. We provide an alternative (and L^p-norm free) point of view, which allows for proofs to easily be converted to probabilistic algorithms that decide membership in almost-periodic sumsets of dense subsets of F_2^n. As an application, we give a new algorithmic version of the quasipolynomial Bogolyubov-Ruzsa lemma recently proved by Sanders. Together with the results by the last two authors, this implies an algorithmic version of the quadratic Goldreich-Levin theorem in which the number of terms in the quadratic Fourier decomposition of a given function is quasipolynomial in the error parameter, compared with an exponential dependence previously proved by the authors. It also improves the running time of the algorithm to have quasipolynomial dependence instead of an exponential one. We also give an application to the problem of finding large subspaces in sumsets of dense sets. Green showed that the sumset of a dense subset of F_2^n contains a large subspace. Using Fourier analytic methods, Sanders proved that such a subspace must have dimension bounded below by a constant times the density times n. We provide an alternative (and L^p norm-free) proof of a comparable bound, which is analogous to a recent result of Croot, Laba and Sisask in the integers.

cs.DM↗

arXiv2012

A new upper bound on the query complexity for testing generalized Reed-Muller codes

Over a finite field $\F_q$ the $(n,d,q)$-Reed-Muller code is the code given by evaluations of $n$-variate polynomials of total degree at most $d$ on all points (of $\F_q^n$). The task of testing if a function $f:\F_q^n \to \F_q$ is close to a codeword of an $(n,d,q)$-Reed-Muller code has been of central interest in complexity theory and property testing. The query complexity of this task is the minimal number of queries that a tester can make (minimum over all testers of the maximum number of queries over all random choices) while accepting all Reed-Muller codewords and rejecting words that are $δ$-far from the code with probability $Ω(δ)$. (In this work we allow the constant in the $Ω$ to depend on $d$.) In this work we give a new upper bound of $(c q)^{(d+1)/q}$ on the query complexity, where $c$ is a universal constant. In the process we also give new upper bounds on the "spanning weight" of the dual of the Reed-Muller code (which is also a Reed-Muller code). The spanning weight of a code is the smallest integer $w$ such that codewords of Hamming weight at most $w$ span the code.

cs.IT↗