Results 1  10
of
19
3Query Locally Decodable Codes of Subexponential Length
, 2008
"... Locally Decodable Codes (LDC) allow one to decode any particular symbol of the input message by making a constant number of queries to a codeword, even if a constant fraction of the codeword is damaged. In a recent work [Yek08] Yekhanin constructs a log n log log n 3query LDC with subexponential l ..."
Abstract

Cited by 56 (2 self)
 Add to MetaCart
(Show Context)
Locally Decodable Codes (LDC) allow one to decode any particular symbol of the input message by making a constant number of queries to a codeword, even if a constant fraction of the codeword is damaged. In a recent work [Yek08] Yekhanin constructs a log n log log n 3query LDC with subexponential length of size exp(exp(O ())). However, this construction requires a conjecture that there are infinitely many Mersenne primes. In this paper we give the first unconditional constant query LDC construction with subexponantial codeword length. In addition our construction reduces codeword length. We give construction of 3query LDC with codeword length exp(exp(O ( √ log n log log n))). Our construction also could be extended to higher number of queries. We give a 2rquery LDC with length of exp(exp(O ( r √ log n(log log n) r−1))). 1
QUERYEFFICIENT LOCALLY DECODABLE CODES OF SUBEXPONENTIAL LENGTH
, 2013
"... A kquery locally decodable code (LDC) C: Σn → ΓN encodes each message x into a codeword C(x) such that each symbol of x can be probabilistically recovered by querying only k coordinates of C(x), even after a constant fraction of the coordinates has been corrupted. Yekhanin (in J ACM 55:1–16, 2008 ..."
Abstract

Cited by 15 (2 self)
 Add to MetaCart
A kquery locally decodable code (LDC) C: Σn → ΓN encodes each message x into a codeword C(x) such that each symbol of x can be probabilistically recovered by querying only k coordinates of C(x), even after a constant fraction of the coordinates has been corrupted. Yekhanin (in J ACM 55:1–16, 2008) constructed a 3query LDC of subexponential length, N = exp(exp(O(logn / log logn))), under the assumption that there are infinitely many Mersenne primes. Efremenko (in Proceedings of the 41st annual ACM symposium on theory of computing, ACM, New York, 2009) constructed a 3query LDC of length N2 = exp(exp(O( log n log logn))) with no assumption, and a 2rquery LDC of length Nr = exp(exp(O ( r logn(log logn)r−1))), for every integer r ≥ 2. Itoh and Suzuki (in IEICE Trans Inform Syst E93D 2:263– 270, 2010) gave a composition method in Efremenko’s framework and
Matching Vector Codes
"... An (r, δ, ɛ)locally decodable code encodes a kbit message x to an Nbit codeword C(x), such that for every i ∈ [k], the ith message bit can be recovered with probability 1 − ɛ, by a randomized decoding procedure that queries only r bits, even if the codeword C(x) is corrupted in up to δN location ..."
Abstract

Cited by 11 (4 self)
 Add to MetaCart
An (r, δ, ɛ)locally decodable code encodes a kbit message x to an Nbit codeword C(x), such that for every i ∈ [k], the ith message bit can be recovered with probability 1 − ɛ, by a randomized decoding procedure that queries only r bits, even if the codeword C(x) is corrupted in up to δN locations. Recently a new class of locally decodable codes, based on families of vectors with restricted dot products has been discovered. We refer to those codes as Matching Vector (MV) codes. Several families of (r, δ, Θ(rδ))locally decodable MV codes have been obtained. While codes in those families were shorter than codes of earlier generations, they suffered from having large values of ɛ = Ω(rδ), which meant that rquery MV codes could only handle errorrates below 1 r. Thus larger query complexity gave shorter length codes but at the price of less errortolerance. No MV codes of superconstant number of queries capable of tolerating a constant fraction of errors were known to exist. In this paper we present a new view of matching vector codes and uncover certain similarities between MV codes and classical Reed Muller codes. Our view allows us to obtain deeper insights into the power and limitations of MV codes. Specifically, 1. We show that existing families of MV codes can be enhanced to tolerate a large constant fraction of errors, independent of the number of queries. Such enhancement comes at a price of a moderate increase in the number of queries; 2. Our construction yields the first families of matching vector codes of superconstant query complexity that can tolerate a constant fraction of errors. Our codes are shorter than Reed Muller LDCs for all values of r ≤ log k/(log log k) c, for some constant c; 3. We show that any MV code encodes messages of length k to codewords of length at least k2 Ω( √ log k). Therefore MV codes do not improve upon Reed Muller LDCs for r ≥ (log k) Ω ( √ log k)
Locally Decodable Codes From Nice Subsets of Finite Fields and Prime Factors of Mersenne Numbers
"... A kquery Locally Decodable Code (LDC) encodes an nbit message x as an Nbit codeword C(x), such that one can probabilistically recover any bit xi of the message by querying only k bits of the codeword C(x), even after some constant fraction of codeword bits has been corrupted. The major goal of LD ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
A kquery Locally Decodable Code (LDC) encodes an nbit message x as an Nbit codeword C(x), such that one can probabilistically recover any bit xi of the message by querying only k bits of the codeword C(x), even after some constant fraction of codeword bits has been corrupted. The major goal of LDC related research is to establish the optimal tradeoff between length and query complexity of such codes. Recently upper bounds for the length of LDCs were vastly improved via constructions that rely on existence of certain special (nice) subsets of finite fields. In this work we extend the constructions of LDCs from nice subsets. We argue that further progress on upper bounds for LDCs via these methods is tied to progress on an old number theory question regarding the size of the largest prime factors of Mersenne numbers. Specifically, we show that every Mersenne number m = 2 t − 1 that has a prime factor p>m γ yields a family of k(γ)query locally decodable codes of length exp � n 1/t �. Conversely, if for some fixed k and all ɛ>0 one can use the nice subsets technique to obtain a family of kquery LDCs of length exp (n ɛ);then infinitely many Mersenne numbers have prime factors larger than known currently.
Highrate codes with sublineartime decoding
, 2010
"... Locally decodable codes are errorcorrecting codes that admit efficient decoding algorithms; any bit of the original message can be recovered by looking at only a small number of locations of a corrupted codeword. The tradeoff between the rate of a code and the locality/efficiency of its decoding al ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
Locally decodable codes are errorcorrecting codes that admit efficient decoding algorithms; any bit of the original message can be recovered by looking at only a small number of locations of a corrupted codeword. The tradeoff between the rate of a code and the locality/efficiency of its decoding algorithms has been well studied, and it has widely been suspected that nontrivial locality must come at the price of low rate. A particular setting of potential interest in practice is codes of constant rate. For such codes, decoding algorithms with locality O(k ɛ) were known only for codes of rate exp(1/ɛ), where k is the length of the message. Furthermore, for codes of rate> 1/2, no nontrivial locality has been achieved. In this paper we construct a new family of locally decodable codes that have very efficient local decoding algorithms, and at the same time have rate approaching 1. We show that for every ɛ> 0 and α> 0, for infinitely many k, there exists a code C which encodes messages of length k with rate 1 − α, and is locally decodable from a constant fraction of errors using O(k ɛ) queries and time. The high rate and local decodability are evident even in concrete settings (and not just in asymptotic behavior), giving hope that local decoding techniques may have practical implications. These codes, which we call multiplicity codes, are based on evaluating high degree multivariate polynomials and their derivatives. Multiplicity codes extend traditional multivariate polynomial based codes; they inherit the localdecodability of these codes, and at the same time achieve better tradeoffs and flexibility in their rate and distance.
Local list decoding with a constant number of queries
, 2010
"... Recently Efremenko showed locallydecodable codes of subexponential length. That result showed that these codes can handle up to 1 3 fraction of errors. In this paper we show that the same codes can be locally uniquedecoded from error rate 1 2 − α for any α> 0 and locally listdecoded from erro ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
Recently Efremenko showed locallydecodable codes of subexponential length. That result showed that these codes can handle up to 1 3 fraction of errors. In this paper we show that the same codes can be locally uniquedecoded from error rate 1 2 − α for any α> 0 and locally listdecoded from error rate 1 − α for any α> 0, with only a constant number of queries and a constant alphabet size. This gives the first subexponential codes that can be locally listdecoded with a constant number of queries. 1
New Bounds for Matching Vector Families
"... A Matching Vector (MV) family modulo m is a pair of ordered lists U = (u1,..., ut) and V = (v1,..., vt) where ui, vj ∈ Zn m with the following inner product pattern: for any i, 〈ui, vi 〉 = 0, and for any i = j, 〈ui, vj 〉 = 0. A MV family is called qrestricted if inner products 〈ui, vj〉 take at mo ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
A Matching Vector (MV) family modulo m is a pair of ordered lists U = (u1,..., ut) and V = (v1,..., vt) where ui, vj ∈ Zn m with the following inner product pattern: for any i, 〈ui, vi 〉 = 0, and for any i = j, 〈ui, vj 〉 = 0. A MV family is called qrestricted if inner products 〈ui, vj〉 take at most q different values. Our interest in MV families stems from their recent application in the construction of subexponential locally decodable codes (LDCs). There, qrestricted MV families are used to construct LDCs with q queries, and there is special interest in the regime where q is constant. When m is a prime it is known that such constructions yield codes with exponential block length. However, for composite m the behaviour is dramatically different. A recent work by Efremenko [Efr09] (based on an approach initiated by Yekhanin [Yek08]) gives the first subexponential LDC with constant queries. It is based on a construction of a MV family of superpolynomial size by Grolmusz [Gro00] modulo composite m. In this work, we prove two lower bounds on the block length of LDCs which are based on black box construction using MV families. When q is constant (or sufficiently small), we prove that such LDCs must have a quadratic block length. When the modulus m is constant (as it is in the construction of Efremenko [Efr09]) we prove a superpolynomial lower bound on the blocklength of the LDCs, assuming a wellknown conjecture in additive combinatorics, the polynomial FreimanRuzsa conjecture over Zm.
A note on amplifying the errortolerance of locally decodable codes
 COLLOQ. COMPUT. COMPLEX
, 2010
"... Trevisan [Tre03] suggested a transformation that allows amplifying the error rate a code can handle. We observe that this transformation, that was suggested in the nonlocal setting, works also in the local setting and thus gives a generic, simple way to amplify the errortolerance of locally decoda ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
Trevisan [Tre03] suggested a transformation that allows amplifying the error rate a code can handle. We observe that this transformation, that was suggested in the nonlocal setting, works also in the local setting and thus gives a generic, simple way to amplify the errortolerance of locally decodable codes. Specifically, this shows how to transform a locally decodable code that can tolerate a constant fraction of errors to a locally decodable code that can recover from a much higher errorrate, and how to transform such locally decodable codes to locally listdecodable codes. The transformation of [Tre03] involves a simple composition with an approximately locally (list) decodable code. Using a construction of such codes by Impagliazzo et al. [IJKW10], the transformation incurs only a negligible growth in the length of the code and in the query complexity.
Noisy interpolation of sparse polynomials, and applications
 In IEEE Conference on Computational Complexity (2011), IEEE Computer Society
"... Let f ∈ Fq[x] be a polynomial of degree d ≤ q/2. It is wellknown that f can be uniquely recovered from its values at some 2d points even after some small fraction of the values are corrupted. In this paper we establish a similar result for sparse polynomials. We show that a ksparse polynomial f ∈ ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
Let f ∈ Fq[x] be a polynomial of degree d ≤ q/2. It is wellknown that f can be uniquely recovered from its values at some 2d points even after some small fraction of the values are corrupted. In this paper we establish a similar result for sparse polynomials. We show that a ksparse polynomial f ∈ Fq[x] of degree d ≤ q/2 can be recovered from its values at O(k) randomly chosen points, even if a small fraction of the values of f are adversarially corrupted. Our proof relies on an iterative technique for analyzing the rank of a random minor of a matrix. We use the same technique to establish a collection of other results. Specifically, • We show that restricting any linear [n, k, δn]q code to a randomly chosen set of O(k) coordinates with high probability yields an asymptotically good code. • We improve the state of the art in locally decodable codes, showing that similarly to Reed Muller codes matching vector codes require only a constant increase in query complexity in order to tolerate a constant fraction of errors. This result yields a moderate reduction in the query complexity of the currently best known codes. • We improve the state of the art in constructions of explicit rigid matrices. For any prime power q and integers n and d we construct an explicit matrix M with exp(d) · n rows and n columns such that the rank of M stays above n/2 even if every row of M is arbitrarily altered in up to d coordinates. Earlier, such constructions were available only for q = O(1) or q = Ω(n). 1