Michael Viderman

Tensor Products of Weakly Smooth Codes are Robust.

We continue the study of robust tensor codes and expand the class of base codes that can be used as a starting point for the construction of locally testable codes via robust two-wise tensor products. In particular, we show that all unique-neighbor expander codes and all locally correctable codes, when tensored with any other good-distance code, are robust and hence can be used to construct locally testable codes. Previous works by [2] required stronger expansion properties to obtain locally testable codes. Our proofs follow by defining the notion of weakly smooth codes that generalize the smooth codes of [2]. We show that weakly smooth codes are sufficient for constructing robust tensor codes. Using the weaker definition, we are able to expand the family of base codes to include the aforementioned ones.

Composition of Semi-LTCs by Two-Wise Tensor Products

We continue the study of the local testability of error correcting codes constructed by taking the two-wise tensor product of a base-code with itself. We show that if the base-code is any locally testable code (LTC) or any expander code, then the code obtained by taking the repeated two-wise tensor product of the base-code with itself is locally testable. This extends the results of Dinur et al. in [11] in two ways. First, we answer a question posed in that paper by expanding the class of allowed base-codes to include all locally testable code, and not just so-called uniform LTCs whose associated tester queries all codeword entries with equal probability. Second, we show that repeating the two-wise tensor operation a constant number of times still results in a locally testable code, improving upon previous results which only worked when the tensor product was applied once . n nTo obtain our results we define a new tester for the tensor product of LTCs. Our tester uses the distribution of the tester associated with the base-code to sample rows and columns of the product code. This construction differs from previously studied testers for tensor product codes which sampled rows and columns uniformly .

A combination of testability and decodability by tensor products

Ben-Sasson and Sudan (RSA 2006) showed that taking the repeated tensor product of linear codes with very large distance results in codes that are locally testable. Due to the large distance requirement the associated tensor products could be applied only over sufficiently large fields.

Locally Testable Codes Require Redundant Testers

Locally testable codes (LTCs) are error-correcting codes for which membership, in the code, of a given word can be tested by examining it in very few locations. Most known constructions of locally testable codes are linear codes, and give error-correcting codes whose duals have (superlinearly) {em many} small weight codewords. Examining this feature appears to be one of the promising approaches to proving limitation results for (i.e., upper bounds on the rate of) LTCs. Unfortunately till now it was not even known if LTCs need to be non-trivially redundant, i.e., need to have {em one} linear dependency among the low-weight codewords in its dual. In this paper we give the first lower bound of this form, by showing that every positive rate constant query strong LTC must have linearly many redundant low-weight codewords in its dual. We actually prove the stronger claim that the {em actual test itself} must use a linear number of redundant dual codewords (beyond the minimum number of basis elements required to characterize the code); in other words, non-redundant (in fact, low redundancy) local testing is impossible.

Locally testable vs. locally decodable codes

We study the relation between locally testable and locally decodable codes. Locally testable codes (LTCs) are error-correcting codes for which membership of a given word in the code can be tested probabilistically by examining it in very few locations. Locally decodable codes (LDCs) allow to recover each message entry with high probability by reading only a few entries of a slightly corrupted codeword. A linear code C ⊆ F2n is called sparse if n ≥ 2Ω(dim(C)). n nIt is well-known that LTCs do not imply LDCs and that there is an intersection between these two families. E.g. the Hadamard code is both LDC and LTC. However, it was not known whether LDC implies LTC. We show the following results. - Two-transitive codes with a local constraint imply LDCs, while they do not imply LTCs. - Every non-sparse LDC contains a large subcode which is not LTC, while every subcode of an LDC remains LDC. Hence, every nonsparse LDC contains a subcode that is LDC but is not LTC. n nThe above results demonstrate inherent differences between LDCs and LTCs, in particular, they imply that LDCs do not imply LTCs.

Low rate is insufficient for local testability

Three results are shown regarding locally testable and locally decodable linear codes. All three results rely on the observation that repetition codes have the same local testability and local decodability parameters as the unrepeated base code used to create them. n nThe first two results deal with families of sparse linear codes, i.e., codes with dimension logarithmic in the code blocklength n. Such codes have been shown by Kaufman and Sudan [8] to be locally testable and decodable as long as all nonzero codewords have Hamming weight n ċ (1/2 ± n-Ω(1)). Our first result shows that certain sparse codes are neither locally testable, nor locally decodable. This refutes a conjecture of Kopparty and Saraf [9] which postulated that all sparse codes are locally testable. Our second result shows that the result of Kaufman and Sudan is surprisingly tight, and for any function h(n) = o(1) there exist families of sparse codes all of whose codewords have weight n ċ (1/2 ± n-h(n)) and these codes are neither locally testable, nor locally decodable. n nOur third and final result is about the redundancy of locally testable codes. Informally, the redundancy of a locally testable code is the minimal number of redundant tests sampled by a tester, where a test is said to be redundant if is a linear combination of other tests. Ben-Sasson et al. [1] introduced the notion of redundancy and showed that for every linear locally testable code the redundancy is at least linear in the dimension of the code. Our last result shows that redundancy is indeed a function of the code dimension, not blocklength, and that the bound given in [1] is nearly tight.

Towards Lower Bounds on Locally Testable Codes via Density Arguments

The main open problem in the area of locally testable codes (LTCs) is whether there exists an asymptotically good family of LTCs, and to resolve this question, it suffices to consider the case of query complexity 3. We argue that to refute the existence of such an asymptotically good family, it is sufficient to prove that the number of dual codewords of weight at most 3 is super-linear in the blocklength of the code and they are distributed “naturally”.The main technical contribution of this paper is an improvement of the combinatorial lemma of Goldreich etxa0al. (Comput Complex 15(3):263–296, 2006) which bounds the rate of 2-query locally decodable codes (LDCs) and is used in state-of-the-art rate bounds for linear LDCs. The lemma of Goldreich etxa0al. bounds the rate of 2-query LDCs of blocklength n in terms of the corruption parameter δ(n)—this is the maximal fraction of corrupted codeword bits for which a (2-query) decoder can recover correctly every message bit (with high probability). Our combinatorial lemma gives non-trivial rate bounds for any corruption parameter δ(n) such that δ(n) · n =xa0ω(1), whereas the previous lemma works only for corruption parameter δ(n) such that δ(n) · n ≥xa0log n. The study of LDCs with sublinear corruption parameter is also motivated by Dvir’s (IEEE conference on computational complexity. IEEE Computer Society, pp 291–298, 2010) observation that sufficiently strong bounds on the rate of such LDCs imply explicit constructions of rigid matrices.

Strong LTCs with Inverse Poly-Log Rate and Constant Soundness

An error-correcting code C is called (q, ϵ)-strong locally testable code (LTC) if there exists a tester that makes at most q queries to the input word. This tester accepts all code words with probability 1 and rejects all non-code words x with probability at least ϵ · δ(x, C), where δ(x, C) denotes the relative Hamming distance between the word x and the code C. The parameter q is called the query complexity and the parameter ϵ is called soundness. In this paper we resolve an open question raised by Gold Reich and Sudan (J. ACM 2006) and construct binary linear strong LTCs with query complexity 3, constant relative distance, constant soundness and inverse polylogarithmic rate. Our result is based on the previous paper of the author (Vide man, ECCC TR12-168), which presented binary linear strong LTCs with query complexity 3, constant relative distance, and inverse polylogarithmic soundness and rate. We show that the gap amplification procedure of Dinur (J. ACM 2007) can be used to amplify the soundness of these strong LTCs from inverse polylogarithmic up to a constant, while preserving the other parameters of these codes. Furthermore, we show that under a conceivable conjecture, there exist asymptotically good strong LTCs with poly-log query complexity.

LP decoding of codes with expansion parameter above 2/3

A code C@?F2^n is a (c,@d,@e)-expander code if it has a Tanner graph, where every variable node has degree c, and every subset of variable nodes L0 such that |L0|= 23+13c. In this paper, we provide a slight consolidation of their work and show that this result holds for every expansion parameter @e>23.

Linear time decoding of regular expander codes

Sipser and Spielman (IEEE IT, 1996) showed that any (c, d)-regular expander code with expansion parameter > 3/4 is decodable in linear time from a constant fraction of errors. Feldman et al. (IEEE IT, 2007) proved that expansion parameter > 2/3 + 1/3c is sufficient to correct a constant fraction of errors in polynomial time using LP decoding.n In this work we give a simple combinatorial algorithm that achieves even better parameters. In particular, our algorithm runs in linear time and works for any expansion parameter > 2/3−1/6c. We also prove that our decoding algorithm can be executed in logarithmic time on a linear number of parallel processors.