The Bonami-Beckner hypercontractive inequality is a powerful tool in Fourier analysis of real-valued functions on the Boolean cube. In this paper we present a version of this inequality for matrix-valued functions on the Boolean cube. Its proof is based on a powerful inequality by Ball, Carlen, and Lieb. We also present a number of applications. First, we analyze maps that encode n classical bits into m qubits, in such a way that each set of k bits can be recovered with some probability by an appropriate measurement on the quantum encoding; we show that if m<0.7n, then the success probability is exponentially small in k. This result may be viewed as a direct product version of Nayak’s quantum random access code bound. It in turn implies strong direct product theorems for the one-way quantum communication complexity of Disjointness and other problems. Second, we prove that error-correcting codes that are locally decodable with 2 queries require length exponential in the length of the encoded string. This gives what is arguably the first “non-quantum” proof of a result originally derived by Kerenidis and de Wolf using quantum information theory.

We show that random sparse binary linear codes are locally testable and locally decodable (under any linear encoding) with constant queries (with probability tending to one). By sparse, we mean that the code should have only polynomially many codewords. Our results are the first to show that local decodability and testability can be found in random, unstructured, codes. Previously known locally decodable or testable codes were either classical algebraic codes, or new ones constructed very carefully. We obtain our results by extending the techniques of Kaufman and Litsyn [11] who used the MacWilliams Identities to show that “almost-orthogonal ” binary codes are locally testable. Their definition of almost orthogonality ex-pected codewords to disagree in n 2 ± O( √ n) coordinates in codes of block length n. The only families of codes known to have this property were the dual-BCH codes. We extend their techniques, and simplify them in the process, to in-clude codes of distance at least n 2 −O(n1−γ) for any γ> 0, provided the number of codewords is O(n t) for some constant t. Thus our results derive the local testability of linear codes from the classical coding theory parameters, namely the rate and the distance of the codes. More significantly, we show that this technique can also be used to prove the “self-correctability ” of sparse codes of sufficiently large distance. This allows us to show that random linear codes under linear encoding functions are locally decodable. This ought to be surprising in that the definition of a code doesn’t specify the encoding function used! Our results effectively say that any linear function of the bits of the codeword can be locally decoded in this case.

We show that the N P-Complete language 3SAT has a PCP verifier that makes two queries to a proof of almost-linear size and achieves sub-constant probability of error o(1). The verifier performs only projection tests, meaning that the answer to the first query determines at most one accepting answer to the second query. Previously, by the parallel repetition theorem, there were PCP Theorems with two-query projection tests, but only (arbitrarily small) constant error and polynomial size [29]. There were also PCP Theorems with sub-constant error and almost-linear size, but a constant number of queries that is larger than 2 [26]. As a corollary, we obtain a host of new results. In particular, our theorem improves many of the hardness of approximation results that are proved using the parallel repetition theorem. A partial list includes the following: 1. 3SAT cannot be efficiently approximated to within a factor of 7 8 + o(1), unless P = N P. This holds even under almost-linear reductions. Previously, the best known N P-hardness

Locally Decodable codes(LDC) support decoding of any particular symbol of the input message by reading constant number of symbols of the codeword, even in presence of constant fraction of errors. In a recent breakthrough [9], Yekhanin constructed-query LDCs that hugely improve over earlier constructions. Specifically, for a Mersenne prime, binary LDCs of length for infinitely many were obtained. Using the largest known Mersenne prime, this implies LDCs of length less than. Assuming infinitude of Mersenne primes, the construction yields LDCs of length for infinitely many. Inspired by [9], we construct-query binary LDCs with same parameters from Mersenne primes. While all the main technical tools are borrowed from [9], we give a self-contained simple construction of LDCs. Our bounds do not improve over [9], and have worse soundness of the decoder. However the LDCs are simpler and generalize naturally to prime fields other than. The LDCs presented also translate directly in to three server Private Information Retrieval(PIR) protocols with communication! complexities for a database of size, starting with a Mersenne prime.

Despite its many applications, to program checking, probabilistically checkable proofs, locally testable and locally decodable codes, and cryptography, “algebraic property testing ” is not wellunderstood. A significant obstacle to a better understanding, was a lack of a concrete definition that abstracted known testable algebraic properties and reflected their testability. This obstacle was removed by [Kaufman and Sudan, STOC 2008] who considered (linear) “affine-invariant properties”, i.e., properties that are closed under summation, and under affine transformations of the domain. Kaufman and Sudan showed that these two features (linearity of the property and its affine-invariance) play a central role in the testability of many known algebraic properties. However their work does not give a complete characterization of the testability of affine-invariant properties, and several technical obstacles need to be overcome to obtain such a characterization. Indeed, their work left open the tantalizing possibility that locally testable codes of rate dramatically better than that of the family of Reed-Muller codes (the most popular form of locally testable codes, which also happen to be affine-invariant) could be found by systematically exploring the space of affine-invariant properties.

We study data structures in the presence of adversarial noise. We want to encode a given object in a succinct data structure that enables us to efficiently answer specific queries about the object, even if the data structure has been corrupted by a constant fraction of errors. This model is the common generalization of (static) data structures and locally decodable errorcorrecting codes. The main issue is the tradeoff between the space used by the data structure and the time (number of probes) needed to answer a query about the encoded object. We prove a number of upper and lower bounds on various natural error-correcting data structure problems. In particular, we show that the optimal length of error-correcting data structures for the Membership problem (where we want to store subsets of size s from a universe of size n) is closely related to the optimal length of locally decodable codes for s-bit strings. 1

In this paper, we introduce the notion of a Public-Key Encryption (PKE) Scheme that is also a Locally-Decodable Error-Correcting Code. In particular, our construction simultaneously satisfies all of the following properties: • Our Public-Key Encryption is semantically secure under a certain number-theoretic hardness assumption (a specific variant of the Φ-hiding assumption). • Our Public-Key Encryption function has constant expansion: it maps plaintexts of length n (for any n polynomial in k, where k is a security parameter) to ciphertexts of size O(n + k). The size of our Public Key is also linear in n and k. • Our Public-Key Encryption is also a constant rate binary error-correcting code against any polynomial-time Adversary. That is, we allow a polynomial-time Adversary to read the entire ciphertext, perform any polynomial-time computation and change an arbitrary (i.e. adversarially chosen) constant fraction of all bits of the ciphertext. The goal of the Adversary is to cause error in decoding any bit of the plaintext. Nevertheless, the decoding algorithm can decode all bits of the

Abstract. A (q, δ, ɛ)-locally decodable code (LDC) C: {0, 1} n → {0, 1} m is an encoding from n-bit strings to m-bit strings such that each bit xk can be recovered with probability at least 1 + ɛ from C(x) by a random-2 ized algorithm that queries only q positions of C(x), even if up to δm positions of C(x) are corrupted. If C is a linear map, then the LDC is linear. We give improved constructions of LDCs in terms of the corruption parameter δ and recovery parameter ɛ. The key property of our LDCs is that they are non-linear, whereas all previous LDCs were linear. 1. For any δ, ɛ ∈ [Ω(n −1/2), O(1)], we give a family of (2, δ, ɛ)-LDCs with length m = poly(δ −1, ɛ −1) exp (max(δ, ɛ)δn). For linear (2, δ, ɛ)-LDCs, Obata has shown that m ≥ exp (δn). Thus, for small enough constants δ, ɛ, two-query non-linear LDCs are shorter than two-query linear LDCs. 2. We improve the dependence on δ and ɛ of all constant-query LDCs by providing general transformations to non-linear LDCs. Taking Yekhanin’s linear (3, δ, 1/2 − 6δ)-LDCs with m = exp � n 1/t � for any prime of the form 2 t − 1, we obtain non-linear (3, δ, ɛ)-LDCs with m = poly(δ −1, ɛ −1) exp � (max(δ, ɛ)δn) 1/t �. Now consider a (q, δ, ɛ)-LDC C with a decoder that has n matchings M1,..., Mn on the complete q-uniform hypergraph, whose vertices are identified with the positions of C(x). On input k ∈ [n] and received word y, the decoder chooses e = {a1,..., aq} ∈ Mk uniformly at random and outputs �q j=1 yaj. All known LDCs and ours have such a decoder, which we call a matching sum decoder. We show that if C is a two-query LDC with such a decoder, then m ≥ exp (max(δ, ɛ)δn). Interestingly, our techniques used here can further improve the dependence on δ of Yekhanin’s three-query LDCs. Namely, if δ ≥ 1/12 then Yekhanin’s three-query LDCs become trivial (have recovery probability less than half), whereas we obtain three-query LDCs of length exp � n 1/t � for any prime of the form 2 t − 1 with non-trivial recovery probability for any δ < 1/6. 1

We construct efficient data structures that are resilient against a constant fraction of adversarial noise. Our model requires that the decoder answers most queries correctly with high probability and for the remaining queries, the decoder with high probability either answers correctly or declares “don’t know.” Furthermore, if there is no noise on the data structure, it answers all queries correctly with high probability. Our model is the common generalization of an error-correcting data structure model proposed recently by de Wolf, and the notion of “relaxed locally decodable codes” developed in the PCP literature. We measure the efficiency of a data structure in terms of its length (the number of bits in its representation), and query-answering time, measured by the number of bit-probes to the (possibly corrupted) representation. We obtain results for the following two data structure problems: • (Membership) Store a subset S of size at most s from a universe of size n such that membership queries can be answered efficiently, i.e., decide if a given element from the universe is in S. We construct an error-correcting data structure for this problem with length nearly linear in s log n that answers membership queries with O(1) bit-probes. This nearly matches the asymptotically optimal parameters for the noiseless case: length O(s log n) and one bit-probe, due to

We consider the problem of constructing efficient locally decodable codes in the presence of a computationally bounded adversary. Assuming the existence of one-way functions, we construct efficient locally decodable codes with positive information rate and low (almost optimal) query complexity which can correctly decode any given bit of the message from constant channel error rate ρ. This compares favorably to our state of knowledge locally-decodable codes without cryptographic assumptions. For all our constructions, the probability for any polynomial-time adversary, that the decoding algorithm incorrectly decodes any bit of the message is negligible in the security parameter.