Locally Decodable Codes Research Articles

On the Modulus in Matching Vector Codes

Abstract A $k$-query locally decodable code (LDC) $C$ allows one to encode any $n$-symbol message $x$ as a codeword $C(x)$ of $N$ symbols such that each symbol of $x$ can be recovered by looking at $k$ symbols of $C(x)$, even if a constant fraction of $C(x)$ has been corrupted. Currently, the best known LDCs are matching vector codes (MVCs). A modulus $m=p_1^{\alpha _1}p_2^{\alpha _2}\cdots p_r^{\alpha _r}$ may result in an MVC with $k\leq 2^r$ and $N=\exp (\exp (O((\log n)^{1-1/r} (\log \log n)^{1/r})))$. The $m$ is good if it is possible to have $k<2^r$. The good numbers yield more efficient MVCs. Prior to this work, there are only finitely many good numbers. All of them were obtained via computer search and have the form $m=p_1p_2$. In this paper, we study good numbers of the form $m=p_1^{\alpha _1}p_2^{\alpha _2}$. We show that if $m=p_1^{\alpha _1}p_2^{\alpha _2}$ is good, then any multiple of $m$ of the form $p_1^{\beta _1}p_2^{\beta _2}$ must be good as well. Given a good number $m=p_1^{\alpha _1}p_2^{\alpha _2}$, we show an explicit method of obtaining smaller good numbers that have the same prime divisors. Our approach yields infinitely many new good numbers.

Strong Locally Testable Codes with Relaxed Local Decoders

Locally testable codes (LTCs) are error-correcting codes that admit very efficient codeword tests. An LTC is said to be strong if it has a proximity-oblivious tester, that is, a tester that makes only a constant number of queries and rejects non-codewords with a probability that depends solely on their distance from the code. Locally decodable codes (LDCs) are complementary to LTCs. While the latter allow for highly efficient rejection of strings that are far from being codewords, LDCs allow for highly efficient recovery of individual bits of the information that is encoded in strings that are close to being codewords. Constructions of strong-LTCs with nearly-linear length are known, but the existence of a constant-query LDC with polynomial length is a major open problem. In an attempt to bypass this barrier, Ben-Sasson et al. (SICOMP 2006) introduced a natural relaxation of local decodability, called relaxed-LDCs. This notion requires local recovery of nearly all individual information-bits, yet allows for recovery-failure (but not error) on the rest. Ben-Sasson et al. constructed a constant-query relaxed-LDC with nearly-linear length (i.e., length k 1+α for an arbitrarily small constant α > 0, where k is the dimension of the code). This work focuses on obtaining strong testability and relaxed decodability simultaneously . We construct a family of binary linear codes of nearly-linear length that are both strong-LTCs (with one-sided error) and constant-query relaxed-LDCs. This improves upon the previously known constructions, which either obtain only weak LTCs or require polynomial length. Our construction heavily relies on tensor codes and PCPs. In particular, we provide strong canonical PCPs of proximity for membership in any linear code with constant rate and relative distance. Loosely speaking, these are PCPs of proximity wherein the verifier is proximity oblivious (similarly to strong-LTCs) and every valid statement has a unique canonical proof. Furthermore, the verifier is required to reject non-canonical proofs (even for valid statements). As an application, we improve the best known separation result between the complexity of decision and verification in the setting of property testing.

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 L∞ 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 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.

On the Capacity of Locally Decodable Codes

A locally decodable code (LDC) maps $K$ source symbols, each of size $L_{w}$ bits, to $M$ coded symbols, each of size $L_{x}$ bits, such that each source symbol can be decoded from $N \leq M$ coded symbols. A perfectly smooth LDC further requires that each coded symbol is uniformly accessed when we decode any one of the messages. The ratio $L_{w}/L_{x}$ is called the symbol rate of an LDC. The highest possible symbol rate for a class of LDCs is called the capacity of that class. It is shown that given $K, N$ , the maximum value of capacity of perfectly smooth LDCs, maximized over all code lengths $M$ , is $C^{*}=N\left ({1+1/N+1/N^{2}+\cdots +1/N^{K-1}}\right)^{-1}$ . Furthermore, given $K, N$ , the minimum code length $M$ for which the capacity of a perfectly smooth LDC is $C^{*}$ is shown to be $M = N^{K}$ . Both of these results generalize to a broader class of LDCs, called universal LDCs. The results are then translated into the context of PIRmax, i.e., Private Information Retrieval subject to maximum (rather than average) download cost metric. It is shown that the minimum upload cost of capacity achieving PIRmax schemes is $(K-1)\log N$ . The results also generalize to a variation of the PIR problem, known as Repudiative Information Retrieval (RIR).

Tight lower bounds for linear 2-query LCCs over finite fields

A Locally Correctable Code (LCC) is an error correcting code that has a probabilistic self-correcting algorithm that, with high probability, can correct any coordinate of the codeword by looking at only a few other coordinates, even if a ? fraction of the coordinates is corrupted. LCCs are a stronger form of LDCs (Locally Decodable Codes) which have received a lot of attention recently due to their many applications and surprising constructions. In this work, we show a separation between linear 2-query LDCs and LCCs over finite fields of prime order. Specifically, we prove a lower bound of the form pΩ(?d) on the length of linear 2-query LCCs over Fp, that encode messages of length d. Our bound improves over the known bound of 2Ω(?d) [8,10,6] which is tight for LDCs. Our proof makes use of tools from additive combinatorics which have played an important role in several recent results in theoretical computer science. We also obtain, as corollaries of our main theorem, new results in incidence geometry over finite fields. The first is an improvement to the Sylvester-Gallai theorem over finite fields [14] and the second is a new analog of Beck's theorem over finite fields. The paper also contains an appendix, written by Sergey Yekhanin, showing that there do exist nonlinear LCCs of size 2O(d) over Fp, thus highlighting the importance of the linearity assumption for our result.

Query Complexity Lower Bounds for Reconstruction of Codes

We investigate the problem of local reconstruction, as deflned by Saks and Seshadhri (2008), in the context of error correcting codes. The flrst problem we address is that of message reconstruction, where given oracle access to a corrupted encoding w 2 f0;1g n of some message x 2 f0;1g k our goal is to probabilistically recover x (or some portion of it). This should be done by a procedure (reconstructor) that given an index i as input, probes w at few locations and outputs the value of xi. The reconstructor can (and indeed must) be randomized, with all its randomness specifled in advance by a single random seed, and the main requirement is that for most random seeds, all values are reconstructed correctly (notice that swapping the order of \for most random seeds and \for all x1;:::;xk makes the deflnition equivalent to standard Local Decoding). A message reconstructor can serve as a \fllter that allows evaluating certain classes of algorithms on x safely and e-ciently. For instance, to run a parallel algorithm, one can initialize several copies of the reconstructor with the same random seed, and then they can autonomously handle decoding requests while producing outputs that are consistent with the original message x. Another motivation for studying message reconstruction arises from the theory of Locally Decodable Codes. The second problem that we address is codeword reconstruction, which is similarly deflned, but instead of reconstructing the message the goal is to reconstruct the codeword itself, given an oracle access to its corrupted version. Error correcting codes that admit message and codeword reconstruction can be obtained from Locally Decodable Codes (LDC) and Self Correctible Codes (SCC) respectively. The main contribution of this paper is a proof that in terms of query complexity, these are close to be the best possible constructions, even when we disregard the length of the encoding.

New Bounds for Matching Vector Families

A matching vector (MV) family modulo $m$ is a pair of ordered lists $U=(u_1,\ldots,u_t)$ and $V=(v_1,\ldots,v_t)$ where $u_i$, $v_j \in \mathbb{Z}_m^n$ with the following inner product pattern: for any $i$, $\langle u_i,v_i\rangle=0$, and for any $i \ne j$, $\langle u_i,v_j\rangle \ne 0$. An MV family is called $q$-restricted if inner products $\langle u_i,v_j\rangle$ 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, $q$-restricted 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 behavior is dramatically different. A recent work by Efremenko [SIAM J. Comput., 40 (2011), pp. 1154--1178] (based on an approach initiated by Yekhanin [J. ACM, 55 (2008), pp. 1--16]) gives the first sube...

Upper Bounds on Matching Families in <formula formulatype="inline"> <tex Notation="TeX">$\BBZ_{pq}^{n}$</tex></formula>

Matching families are one of the major ingredients in the construction of locally decodable codes (LDCs) and the best known constructions of LDCs with a constant number of queries are based on matching families. The determination of the largest size of any matching family in Z <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">m</sub> <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">n</sup> , where Z <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">m</sub> is the ring of integers modulo m, is an interesting problem. In this paper, we show an upper bound of O ((pq) <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">0.625n+0.125</sup> ) for the size of any matching family in Z <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">pq</sub> <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">n</sup> , where p and q are two distinct primes. Our bound is valid when n is a constant, p → ∞, and p/q → 1. Our result improves an upper bound of Dvir and coworkers.

A Quadratic Lower Bound for Three-Query Linear Locally Decodable Codes over Any Field

A linear (q, δ, ϵ,m(n))-locally decodable code (LDC) C : $ {\mathbb F} $ n → $ {\mathbb F} $ m(n) is a linear transformation from the vector space $ {\mathbb F} $ n to the space $ {\mathbb F} $ m(n) for which each message symbol x i can be recovered with probability at least $ \frac{1}{{\left| \mathbb{F} \right|}} + \varepsilon $ from C(x) by a randomized algorithm that queries only q positions of C(x), even if up to δm(n) positions of C(x) are corrupted. In a recent work of Dvir, the author shows that lower bounds for linear LDCs can imply lower bounds for arithmetic circuits. He suggests that proving lower bounds for LDCs over the complex or real field is a good starting point for approaching one of his conjectures. Our main result is an m(n) = Ω(n 2) lower bound for linear 3-query LDCs over any, possibly infinite, field. The constant in the Ω(·) depends only on e and δ. This is the first lower bound better than the trivial m(n) = Ω(n) for arbitrary fields and more than two queries.

3-Query Locally Decodable Codes of Subexponential Length

Locally decodable codes (LDCs) 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 [J. ACM, 55 (2008), article 1], Yekhanin constructs a 3-query LDC with subexponential length. 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 subexponential codeword length. In addition, our construction reduces codeword length.

Query-Efficient Locally Decodable Codes of Subexponential Length

A k-query 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 3-query LDC of subexponential length, N = exp(exp(O(log n/log log n))), 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 3-query LDC of length $${N_{2}={\rm exp}({\rm exp} (O(\sqrt{\log n\log\log n})))}$$ with no assumption, and a 2 r -query LDC of length $${N_{r}={\rm exp}({\rm exp}(O(\sqrt[r]{\log n(\log \log n)^{r-1}})))}$$ , for every integer r ? 2. Itoh and Suzuki (in IEICE Trans Inform Syst E93-D 2:263---270, 2010) gave a composition method in Efremenko's framework and constructed a 3 · 2 r-2-query LDC of length N r , for every integer r ? 4, which improved the query complexity of Efremenko's LDC of the same length by a factor of 3/4. The main ingredient of Efremenko's construction is the Grolmusz construction for super-polynomial size set-systems with restricted intersections, over $${\mathbb{Z}_m}$$ , where m possesses a certain property (related to the algebraic niceness property of Yekhanin in J ACM 55:1---16, 2008). Efremenko constructed a 3-query LDC based on m = 511 and left as an open problem to find other numbers that offer the same property for LDC constructions. In this paper, we develop the theory behind the constructions of Yekhanin (in J ACM 55:1---16, 2008) and Efremenko (in Proceedings of the 41st annual ACM symposium on theory of computing, ACM, New York, 2009), in an attempt to understand the algebraic niceness phenomenon in $${\mathbb{Z}_m}$$ . We show that every integer m = pq = 2 t ?1, where p, q, and t are prime, possesses the same good property as m = 511 that allows savings in query complexity. We identify 50 numbers of this form by computer search, which together with 511, are then applied to gain improvements on query complexity via Itoh and Suzuki's composition method. More precisely, we construct a $${3^{\lceil r/2\rceil}}$$ -query LDC for every positive integer r < 104 and a $${\left\lfloor (3/4)^{51} \cdot 2^{r}\right\rfloor}$$ -query LDC for every integer r ? 104, both of length N r , improving the 2 r queries used by Efremenko (in Proceedings of the 41st annual ACM symposium on theory of computing, ACM, New York, 2009) and 3 · 2 r-2 queries used by Itoh and Suzuki (in IEICE Trans Inform Syst E93-D 2:263---270, 2010). We also obtain new efficient private information retrieval (PIR) schemes from the new query-efficient LDCs.

Matching Vector Codes

An $(r,\delta,\epsilon)$-locally decodable code encodes a $k$-bit message $x$ to an $N$-bit codeword $C(x)$, such that for every $i\in[k]$, the $i$th message bit can be recovered with probability $1-\epsilon$, by a randomized decoding procedure that queries only $r$ bits, even if the codeword $C(x)$ is corrupted in up to $\delta N$ locations. Recently a new class of locally decodable codes (LDCs), 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,\delta,\Theta(r\delta))$-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 $\epsilon=\Omega(r\delta)$, which meant that $r$-query MV codes could only handle error rates below $\frac{1}{r}$. Thus larger query complexity gave shorter length codes but at the price of less error tolerance. No MV codes of a 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 (RM) codes. Our view allows us to obtain deeper insights into the power and limitations of MV codes. Specifically, we obtain the following: (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 MV codes of superconstant query complexity that can tolerate a constant fraction of errors. Our codes are shorter than RM LDCs for all values of $r\leq\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^{\Omega(\sqrt{\log k})}$. Therefore MV codes do not improve upon RM LDCs for $r\geq(\log k)^{\Omega(\sqrt{\log k})}$.

On Locally Decodable Codes, Self-Correctable Codes, and t-Private PIR

A k-query locally decodable code (LDC) allows to probabilistically decode any bit of an encoded message by probing only k bits of its corrupted encoding. A stronger and desirable property is that of self-correction, allowing to efficiently recover not only bits of the message but also arbitrary bits of its encoding. In contrast to the initial constructions of LDCs, the recent and most efficient constructions are not known to be self-correctable. The existence of self-correctable codes of comparable efficiency remains open. A closely related problem with a very different motivation is that of private information retrieval (PIR). A k-server PIR protocol allows a user to retrieve the i-th bit of a database, which is replicated among k servers, without revealing information about i to any individual server. A natural generalization is t -private PIR, which keeps i hidden from any t colluding servers. In contrast to the initial PIR protocols, it is not known how to generalize the recent and most efficient protocols to yield t-private protocols of comparable efficiency. In this work we study both of the above questions, showing that they are in fact related. We start by presenting a general transformation of any 1-private PIR protocol (equivalently, LDC) into a t-private protocol with a similar amount of communication per server. Combined with the recent result of Yekhanin (STOC 2007), this yields an improvement over previous t-private PIR protocols. A major weakness of our transformation is that the number of servers grows exponentially with t. We show that if the underlying LDC satisfies the stronger self-correction property, then there is a similar transformation in which the number of servers grows only linearly with t, which is the best one can hope for. Finally, we explore the possibility of improving current constructions of self-correctable codes and relate this question to a conjecture of Hamada concerning the algebraic rank of combinatorial designs.

Locally Decodable Codes from Nice Subsets of Finite Fields and Prime Factors of Mersenne Numbers

A $k$-query locally decodable code (LDC) encodes an $n$-bit message $x$ as an $N$-bit codeword $C(x)$, such that one can probabilistically recover any bit $x_i$ 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 trade-off between length and query complexity of such codes. Recently vast improvements in upper bounds for the length of LDCs were achieved 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^\gamma$ yields a family of $k(\gamma)$-query LDCs of length $\exp(n^{1/t})$. Conversely, if for some fixed $k$ and all $\epsilon>0$ one can use the “nice” subsets technique to obtain a family of $k$-query LDCs of length $\exp(n^\epsilon)$, then infinitely many Mersenne numbers have prime factors larger than currently known.

Towards 3-query locally decodable codes of subexponential length

A q -query Locally Decodable Code (LDC) encodes an n -bit message x as an N -bit codeword C ( x ), such that one can probabilistically recover any bit x i of the message by querying only q bits of the codeword C ( x ), even after some constant fraction of codeword bits has been corrupted. We give new constructions of three query LDCs of vastly shorter length than that of previous constructions. Specifically, given any Mersenne prime p = 2 t − 1, we design three query LDCs of length N = exp( O ( n 1/ t )), for every n . Based on the largest known Mersenne prime, this translates to a length of less than exp( O ( n 10 − 7 )) compared to exp( O ( n 1/2 )) in the previous constructions. It has often been conjectured that there are infinitely many Mersenne primes. Under this conjecture, our constructions yield three query locally decodable codes of length N = exp( n O (1/log log n ) ) for infinitely many n . We also obtain analogous improvements for Private Information Retrieval (PIR) schemes. We give 3-server PIR schemes with communication complexity of O ( n 10 − 7 ) to access an n -bit database, compared to the previous best scheme with complexity O ( n 1/5.25 ). Assuming again that there are infinitely many Mersenne primes, we get 3-server PIR schemes of communication complexity n O (1/log log n ) ) for infinitely many n . Previous families of LDCs and PIR schemes were based on the properties of low-degree multivariate polynomials over finite fields. Our constructions are completely different and are obtained by constructing a large number of vectors in a small dimensional vector space whose inner products are restricted to lie in an algebraically nice set.

Locally Decodable Codes with Two Queries and Polynomial Identity Testing for Depth 3 Circuits

In this work we study two, seemingly unrelated, notions. Locally decodable codes (LDCs) are codes that allow the recovery of each message bit from a constant number of entries of the codeword. Polynomial identity testing (PIT) is one of the fundamental problems of algebraic complexity: we are given a circuit computing a multivariate polynomial and we have to determine whether the polynomial is identically zero. We improve known results on LDCs and on polynomial identity testing and show a relation between the two notions. In particular we obtain the following results: (1) We show that if $E: \mathbb{F}^n \mapsto \mathbb{F}^m$ is a linear LDC with two queries, then $m = \exp(\Omega(n))$. Previously this was known only for fields of size $\ll 2^n$ [O. Goldreich et al., Comput. Complexity, 15 (2006), pp. 263–296]. (2) We show that from every depth 3 arithmetic circuit ($\Sigma\Pi\Sigma$ circuit), ${\cal C}$, with a bounded (constant) top fan‐in that computes the zero polynomial, one can construct an LDC. More formally, assume that ${\cal C}$ is minimal (no subset of the multiplication gates sums to zero) and simple (no linear function appears in all the multiplication gates). Denote by d the degree of the polynomial computed by ${\cal C}$ and by r the rank of the linear functions appearing in ${\cal C}$. Then we can construct a linear LDC with two queries that encodes messages of length $r/{\operatorname{polylog}(d)}$ by codewords of length $O(d)$. (3) We prove a structural theorem for $\Sigma\Pi\Sigma$ circuits, with a bounded top fan‐in, that compute the zero polynomial. In particular we show that if such a circuit is simple, minimal, and of polynomial size, then its rank, r, is only polylogarithmic in the number of variables (a priori it could have been linear). (4) We give new PIT algorithms for $\Sigma\Pi\Sigma$ circuits with a bounded top fan‐in: (a) a deterministic algorithm that runs in quasipolynomial time, and (b) a randomized algorithm that runs in polynomial time and uses only a polylogarithmic number of random bits. Moreover, when the circuit is multilinear, our deterministic algorithm runs in polynomial time. Previously deterministic subexponential time algorithms for PIT in bounded depth circuits were known only for depth 2 circuits (in the black box model) [D. Grigoriev, M. Karpinski, and M. F. Singer, SIAM J. Comput., 19 (1990), pp. 1059–1063; M. Ben‐Or and P. Tiwari, Proceedings of the 20th Annual ACM Symposium on Theory of Computing, ACM Press, New York, 1988, pp. 301–309; A. R. Klivans and D. Spielman, Proceedings of the 33rd Annual ACM Symposium on Theory of Computing, ACM Press, New York, 2001, pp. 216–223]. In particular, for the special case of depth 3 circuits with three multiplication gates our result resolves an open question asked by Klivans and Spielman.

Exponential lower bound for 2-query locally decodable codes via a quantum argument

A locally decodable code (LDC) encodes n-bit strings x in m-bit codewords C( x) in such a way that one can recover any bit x i from a corrupted codeword by querying only a few bits of that word. We use a quantum argument to prove that LDCs with 2 classical queries require exponential length: m=2 Ω(n) . Previously, this was known only for linear codes (Goldreich et al., in: Proceedings of 17th IEEE Conference on Computation Complexity, 2002, pp. 175–183). The proof proceeds by showing that a 2-query LDC can be decoded with a single quantum query, when defined in an appropriate sense. It goes on to establish an exponential lower bound on any ‘1-query locally quantum-decodable code’. We extend our lower bounds to non-binary alphabets and also somewhat improve the polynomial lower bounds by Katz and Trevisan for LDCs with more than 2 queries. Furthermore, we show that q quantum queries allow more succinct LDCs than the best known LDCs with q classical queries. Finally, we give new classical lower bounds and quantum upper bounds for the setting of private information retrieval. In particular, we exhibit a quantum 2-server private information retrieval (PIR) scheme with O( n 3/10) qubits of communication, beating the O( n 1/3) bits of communication of the best known classical 2-server PIR.