66 research outputs found
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 , constant rate (which can even be
taken arbitrarily close to 1), constant relative distance, and query complexity
. Previously such codes were known to exist
only with query complexity (for constant ), 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 , 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 query
complexity does not require any sacrifice in terms of rate and distance! Such a
result was previously not known for any query complexity.
Our results on LCCs also immediately give locally-decodable codes (LDCs) with
the same parameters
Relaxed Locally Correctable Codes
Locally decodable codes (LDCs) and locally correctable codes (LCCs) are error-correcting codes in which individual bits of the message and codeword, respectively, can be recovered by querying only few bits from a noisy codeword. These codes have found numerous applications both in theory and in practice.
A natural relaxation of LDCs, introduced by Ben-Sasson et al. (SICOMP, 2006), allows the decoder to reject (i.e., refuse to answer) in case it detects that the codeword is corrupt. They call such a decoder a relaxed decoder and construct a constant-query relaxed LDC with almost-linear blocklength, which is sub-exponentially better than what is known for (full-fledged) LDCs in the constant-query regime.
We consider an analogous relaxation for local correction. Thus, a relaxed local corrector reads only few bits from a (possibly) corrupt codeword and either recovers the desired bit of the codeword, or rejects in case it detects a corruption.
We give two constructions of relaxed LCCs in two regimes, where the first optimizes the query complexity and the second optimizes the rate:
1. Constant Query Complexity: A relaxed LCC with polynomial blocklength whose corrector only reads a constant number of bits of the codeword. This is a sub-exponential improvement over the best constant query (full-fledged) LCCs that are known.
2. Constant Rate: A relaxed LCC with constant rate (i.e., linear blocklength) with quasi-polylogarithmic query complexity. This is a nearly sub-exponential improvement over the query complexity of a recent (full-fledged) constant-rate LCC of Kopparty et al. (STOC, 2016)
Relaxed Local Correctability from Local Testing
We cement the intuitive connection between relaxed local correctability and
local testing by presenting a concrete framework for building a relaxed locally
correctable code from any family of linear locally testable codes with
sufficiently high rate. When instantiated using the locally testable codes of
Dinur et al. (STOC 2022), this framework yields the first asymptotically good
relaxed locally correctable and decodable codes with polylogarithmic query
complexity, which finally closes the superpolynomial gap between query lower
and upper bounds. Our construction combines high-rate locally testable codes of
various sizes to produce a code that is locally testable at every scale: we can
gradually "zoom in" to any desired codeword index, and a local tester at each
step certifies that the next, smaller restriction of the input has low error.
Our codes asymptotically inherit the rate and distance of any locally
testable code used in the final step of the construction. Therefore, our
technique also yields nonexplicit relaxed locally correctable codes with
polylogarithmic query complexity that have rate and distance approaching the
Gilbert-Varshamov bound.Comment: 18 page
Outlaw distributions and locally decodable codes
Locally decodable codes (LDCs) are error correcting codes that allow for
decoding of a single message bit using a small number of queries to a corrupted
encoding. Despite decades of study, the optimal trade-off between query
complexity and codeword length is far from understood. In this work, we give a
new characterization of LDCs using distributions over Boolean functions whose
expectation is hard to approximate (in~~norm) with a small number of
samples. We coin the term `outlaw distributions' for such distributions since
they `defy' the Law of Large Numbers. We show that the existence of outlaw
distributions over sufficiently `smooth' functions implies the existence of
constant query LDCs and vice versa. We give several candidates for outlaw
distributions over smooth functions coming from finite field incidence
geometry, additive combinatorics and from hypergraph (non)expanders.
We also prove a useful lemma showing that (smooth) LDCs which are only
required to work on average over a random message and a random message index
can be turned into true LDCs at the cost of only constant factors in the
parameters.Comment: A preliminary version of this paper appeared in the proceedings of
ITCS 201
Efficient Multi-Point Local Decoding of Reed-Muller Codes via Interleaved Codex
Reed-Muller codes are among the most important classes of locally correctable
codes. Currently local decoding of Reed-Muller codes is based on decoding on
lines or quadratic curves to recover one single coordinate. To recover multiple
coordinates simultaneously, the naive way is to repeat the local decoding for
recovery of a single coordinate. This decoding algorithm might be more
expensive, i.e., require higher query complexity. In this paper, we focus on
Reed-Muller codes with usual parameter regime, namely, the total degree of
evaluation polynomials is , where is the code alphabet size
(in fact, can be as big as in our setting). By introducing a novel
variation of codex, i.e., interleaved codex (the concept of codex has been used
for arithmetic secret sharing \cite{C11,CCX12}), we are able to locally recover
arbitrarily large number of coordinates of a Reed-Muller code
simultaneously at the cost of querying coordinates. It turns out that
our local decoding of Reed-Muller codes shows ({\it perhaps surprisingly}) that
accessing locations is in fact cheaper than repeating the procedure for
accessing a single location for times. Our estimation of success error
probability is based on error probability bound for -wise linearly
independent variables given in \cite{BR94}
Relaxed locally correctable codes with nearly-linear block length and constant query complexity
Locally correctable codes (LCCs) are codes C: Σk → Σn which admit local algorithms that can correct any individual symbol of a corrupted codeword via a minuscule number of queries. One of the central problems in algorithmic coding theory is to construct O(1)-query LCC with minimal block length. Alas, state-of-the-art of such codes requires exponential block length to admit O(1)-query algorithms for local correction, despite much attention during the last two decades.
This lack of progress prompted the study of relaxed LCCs, which allow the correction algorithm to abort (but not err) on small fraction of the locations. This relaxation turned out to allow constant-query correction algorithms for codes with polynomial block length. Specifically, prior work showed that there exist O(1)-query relaxed LCCs that achieve nearly-quartic block length n = k4+α, for an arbitrarily small constant α > 0.
We construct an O(1)-query relaxed LCC with nearly-linear block length n = k1+α, for an arbitrarily small constant α > 0. This significantly narrows the gap between the lower bound which states that there are no O(1)-query relaxed LCCs with block length n = k1+o(1). In particular, this resolves an open problem raised by Gur, Ramnarayan, and Rothblum (ITCS 2018)
- …