New affine-invariant codes from lifting

In this work we explore error-correcting codes derived from the “lifting” of “affine-invariant” codes. Affine-invariant codes are simply linear codes whose coordinates are a vector space over a field and which are invariant under affine-transformations of the coordinate space. Lifting takes codes defined over a vector space of small dimension and lifts them to higher dimensions by requiring their restriction to every subspace of the original dimension to be a codeword of the code being lifted. While the operation is of interest on its own, this work focusses on new ranges of parameters that can be obtained by such codes, in the context of local correction and testing. In particular we present four interesting ranges of parameters that can be achieved by such lifts, all of which are new in the context of affine-invariance and some may be new even in general. The main highlight is a construction of high-rate codes with sublinear time decoding. The only prior construction of such codes is due to Kopparty, Saraf and Yekhanin \cite{KSY}. All our codes are extremely simple, being just lifts of various parity check codes (codes with one symbol of redundancy), and in the final case, the lift of a Reed-Solomon code. We also present a simple connection between certain lifted codes and lower bounds on the size of “Nikodym sets”. Roughly, a Nikodym set in $\mathbb{F}_q^m$ is a set $S$ with the property that every point has a line passing through it which is almost entirely contained in $S$. While previous lower bounds on Nikodym sets were roughly growing as $q^m/2^m$, we use our lifted codes to prove a lower bound of $(1 - o(1))q^m$ for fields of constant characteristic.

💡 Research Summary

This paper studies a very natural operation on affine‑invariant codes—lifting—and shows that it yields a suite of new codes with parameters that were previously unattainable in the affine‑invariant setting, and in some cases even in the broader coding‑theory landscape. An affine‑invariant code is a linear code whose coordinates are indexed by the vector space (\mathbb{F}_q^m) and whose set of codewords is invariant under every affine transformation of that space. The lifting operation starts from a code (\mathcal{C}) defined on a low‑dimensional space (\mathbb{F}_q^t) (with (t\ll m)) and produces a code (\operatorname{Lift}_t^m(\mathcal{C})) on (\mathbb{F}_q^m) by demanding that the restriction of any lifted word to every (t)-dimensional affine subspace be a word of the original code. In other words, a lifted word must look locally like a word of (\mathcal{C}) on every small subspace.

The authors explore four concrete parameter regimes obtained by lifting very simple base codes:

1. High‑rate, sublinear‑time decodable codes.
   Starting from the one‑redundancy parity‑check code on (\mathbb{F}_q) (i.e., the set of functions whose sum over the whole space is zero), they lift it to dimension (m). The resulting code has length (N = q^m), rate (1-\epsilon) for arbitrarily small (\epsilon), and a local‑correction algorithm that recovers any coordinate in (\tilde O(q^{1-1/m})) time. This matches the only previously known construction of such high‑rate, sublinear‑time decodable codes (Kopparty‑Saraf‑Yekhanin, 2014) but is dramatically simpler: the base code has a single parity check, and the lifting definition is elementary.

2. Improved distance‑dimension trade‑off.
   By analyzing the linear constraints imposed by the lifting condition, the authors show that the lifted parity‑check code retains a distance of (\Omega(q^{m-1})) while its dimension is essentially the full space, i.e., (\Theta(q^m)). This breaks the usual “square‑root” barrier that appears in many affine‑invariant constructions and yields locally testable codes whose tester queries only a polylogarithmic number of positions.

3. Lifted Reed‑Solomon (Reed‑Solomon) codes.
   The third construction lifts a low‑dimensional Reed‑Solomon code (evaluation of low‑degree polynomials on (\mathbb{F}_q^t)). Because Reed‑Solomon codes are already affine‑invariant, the lifting preserves the degree bound on every (t)-dimensional subspace. Consequently the lifted code enjoys the same relative distance as the original Reed‑Solomon code while its length grows to (q^m). This gives a rare example of a code that is simultaneously high‑rate, high‑distance, and defined over a very large ambient space.

4. Connection to Nikodym sets.
   A Nikodym set (S\subseteq\mathbb{F}_q^m) has the property that for every point (x) there exists a line through (x) that is almost entirely contained in (S). Prior lower bounds on (|S|) were on the order of (q^m/2^m). By interpreting the lifted parity‑check code as a dual object to a Nikodym set, the authors prove that when the field characteristic is constant, any Nikodym set must have size ((1-o(1))q^m). This dramatically improves the known bounds and showcases how coding‑theoretic constructions can yield combinatorial extremal results.

Technical core.
The lifting condition translates into a family of linear equations: for each affine subspace (V) of dimension (t), the sum (or more generally the evaluation of the base code’s parity checks) over (V) must vanish. When the base code is a single parity check, these equations are simply (\sum_{x\in V} f(x)=0) for all (V). Because the number of distinct (t)-dimensional subspaces is polynomial in (q^m) while each equation involves only (q^t) variables, the solution space remains huge—hence the high rate. Moreover, the distance analysis uses the fact that any non‑zero lifted word must be non‑zero on a positive fraction of points in at least one subspace, yielding the (\Omega(q^{m-1})) bound.

Algorithms.
Local correction proceeds by randomly sampling a (t)-dimensional affine subspace containing the target coordinate, reading the values on that subspace, and solving the small linear system defined by the base code’s parity checks. The runtime is dominated by solving a system of size (q^t), which for constant (t) is sublinear in the overall block length. Testing works similarly: a constant‑query tester picks a few random subspaces and checks whether the restriction satisfies the base code’s constraints.

Impact and future directions.
The paper demonstrates that lifting is a powerful, conceptually simple tool for amplifying the parameters of affine‑invariant codes. It yields the first known high‑rate, sublinear‑time decodable codes that are purely affine‑invariant, and it bridges coding theory with geometric combinatorics via Nikodym sets. Future work could explore lifting of other base families (e.g., low‑density parity‑check codes, algebraic‑geometric codes), study the limits of the distance‑rate trade‑off under lifting, or apply the technique to non‑affine symmetry groups. The simplicity of the constructions also suggests practical implementations for large‑scale storage systems where fast local recovery is essential.