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 $n$, constant rate (which can even be taken arbitrarily close to 1), constant relative distance, and query complexity $\exp(\tilde{O}(\sqrt{\log n}))$. Previously such codes were known to exist only with $\Omega(n^{\beta})$ query complexity (for constant $\beta > 0$), 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 $\exp(\tilde{O}(\sqrt{\log n}))$, 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 $\exp(\tilde{O}(\sqrt{\log n}))$ query complexity does not require any sacrifice in terms of rate and distance! Such a result was previously not known for any $o(n)$ query complexity. Our results on LCCs also immediately give locally-decodable codes (LDCs) with the same parameters

Linear-time list recovery of high-rate expander codes

We show that expander codes, when properly instantiated, are high-rate list recoverable codes with linear-time list recovery algorithms. List recoverable codes have been useful recently in constructing efficiently list-decodable codes, as well as explicit constructions of matrices for compressive sensing and group testing. Previous list recoverable codes with linear-time decoding algorithms have all had rate at most 1/2; in contrast, our codes can have rate $1 - \epsilon$ for any $\epsilon > 0$. We can plug our high-rate codes into a construction of Meir (2014) to obtain linear-time list recoverable codes of arbitrary rates, which approach the optimal trade-off between the number of non-trivial lists provided and the rate of the code. While list-recovery is interesting on its own, our primary motivation is applications to list-decoding. A slight strengthening of our result would implies linear-time and optimally list-decodable codes for all rates, and our work is a step in the direction of solving this important problem

A Storage-Efficient and Robust Private Information Retrieval Scheme Allowing Few Servers

Since the concept of locally decodable codes was introduced by Katz and Trevisan in 2000, it is well-known that information the-oretically secure private information retrieval schemes can be built using locally decodable codes. In this paper, we construct a Byzantine ro-bust PIR scheme using the multiplicity codes introduced by Kopparty et al. Our main contributions are on the one hand to avoid full replica-tion of the database on each server; this significantly reduces the global redundancy. On the other hand, to have a much lower locality in the PIR context than in the LDC context. This shows that there exists two different notions: LDC-locality and PIR-locality. This is made possible by exploiting geometric properties of multiplicity codes

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

Complexity Theory

Computational Complexity Theory is the mathematical study of the intrinsic power and limitations of computational resources like time, space, or randomness. The current workshop focused on recent developments in various sub-areas including arithmetic complexity, Boolean complexity, communication complexity, cryptography, probabilistic proof systems, pseudorandomness and randomness extraction. Many of the developments are related to diverse mathematical fields such as algebraic geometry, combinatorial number theory, probability theory, representation theory, and the theory of error-correcting codes

Fault-tolerant gates on hypergraph product codes

L’un des défis les plus passionnants auquel nous sommes confrontés aujourd’hui est la perspective de la construction d’un ordinateur quantique de grande échelle. L’information quantique est fragile et les implémentations de circuits quantiques sont imparfaites et su- jettes aux erreurs. Pour réaliser un tel ordinateur, nous devons construire des circuits quan- tiques tolérants aux fautes capables d’opérer dans le monde réel. Comme il sera expliqué plus loin, les circuits quantiques tolérant aux fautes nécessitent plus de ressources que leurs équivalents idéaux, sans bruit. De manière générale, le but de mes recherches est de minimiser les ressources nécessaires à la construction d’un circuit quantique fiable. Les codes de correction d’erreur quantiques protègent l’information des erreurs en l’encodant de manière redondante dans plusieurs qubits. Bien que la redondance requière un plus grand nombre de qubits, ces qubits supplé- mentaires jouent un rôle de protection: cette redondance sert de garantie. Si certains qubits sont endommagés en raison d’un circuit défectueux, nous pourrons toujours récupérer l’informations. Préparer et maintenir des qubits pendant des durées suffisamment longues pour effectuer un calcul s’est révélé être une tâche expérimentale difficile. Il existe un écart important entre le nombre de qubits que nous pouvons contrôler en laboratoire et le nombre requis pour implementer des algorithmes dans lesquels les ordinateurs quantiques ont le dessus sur ceux classiques. Par conséquent, si nous voulons contourner ce problème et réaliser des circuits quantiques à tolérance aux fautes, nous devons rendre nos constructions aussi efficaces que possible. Nous devons minimiser le surcoût, défini comme le nombre de qubits physiques nécessaires pour construire un qubit logique. Dans un article important, Gottesman a montré que, si certains types de codes de correction d’erreur quantique existaient, cela pourrait alors conduire à la construction de circuits quantiques tolérants aux fautes avec un surcoût favorable. Ces codes sont appelés codes éparses. La proposition de Gottesman décrivait des techniques pour exécuter des opérations logiques sur des codes éparses quantiques arbitraires. Cette proposition était limitée à certains égards, car elle ne permettait d’exécuter qu’un nombre constant de portes logiques par unité de temps. Dans cette thèse, nous travaillons avec une classe spécifique de codes éparses quantiques appelés codes de produits d’hypergraphes. Nous montrons comment effectuer des opérations sur ces codes en utilisant une technique appelée déformation du code. Notre technique généralise les codages basés sur les défauts topologiques dans les codes de surface aux codes de produits d’hypergraphes. Nous généralisons la notion de perforation et montrons qu’elle peut être exprimée naturellement dans les codes de produits d’hypergraphes. Comme cela sera expliqué en détail, les défauts de perforation ont eux-mêmes une portée limitée. Pour réaliser une classe de portes plus large, nous intro- duisons un nouveau défaut appelé trou de ver basé sur les perforations. À titre d’exemple, nous illustrons le fonctionnement de ce défaut dans le contexte du code de surface. Ce défaut a quelques caractéristiques clés. Premièrement, il préserve la propriété éparses du code au cours de la déformation, contrairement à une approche naïve qui ne garantie pas cette propriété. Deuxièmement, il généralise de manière simple les codes de produits d’hypergraphes. Il s’agit du premier cadre suffisamment riche pour décrire les portes tolérantes aux fautes de cette classe de codes. Enfin, nous contournons une limitation de l’approche de Gottesman qui ne permettait d’effectuer qu’un certain nombre de portes logiques à un moment donné. Notre proposition permet d’opérer sur tous les qubits encodés à tout moment.One of the most exciting challenges that faces us today is the prospect of building a scalable quantum computer. Implementations of quantum circuits are imperfect and prone to error. In order to realize a scalable quantum computer, we need to construct fault-tolerant quantum circuits capable of working in the real world. As will be explained further below, fault-tolerant quantum circuits require more resources than their ideal, noise-free counterparts. Broadly, the aim of my research is to minimize the resources required to construct a reliable quantum circuit. Quantum error correcting codes protect information from errors by encoding our information redundantly into qubits. Although the number of qubits that we require increases, this redundancy serves as a buffer – in the event that some qubits are damaged because of a faulty circuit, we will still be able to recover our information. Preparing and maintaining qubits for durations long enough to perform a computation has proved to be a challenging experimental task. There is a large gap between the number of qubits we can control in the lab and the number required to implement algorithms where quantum computers have the upper hand over classical ones. Therefore, if we want to circumvent this bottleneck, we need to make fault-tolerant quantum circuits as efficient as possible. To be precise, we need to minimize the overhead, defined as the number of physical qubits required to construct a logical qubit. In an important paper, Gottesman showed that if certain kinds of quantum error correcting codes were to exist, then this could lead to constructions of fault-tolerant quantum circuits with favorable overhead. These codes are called quantum Low-Density Parity-Check (LDPC) codes. Gottesman’s proposal described techniques to perform gates on generic quantum LDPC codes. This proposal limited the number of logical gates that could be performed at any given time. In this thesis, we work with a specific class of quantum LDPC codes called hypergraph product codes. We demonstrate how to perform gates on these codes using a technique called code deformation. Our technique generalizes defect-based encodings in the surface code to hypergraph product codes. We generalize puncture defects and show that they can be expressed naturally in hypergraph product codes. As will be explained in detail, puncture defects are themselves limited in scope; they only permit a limited set of gates. To perform a larger class of gates, we introduce a novel defect called a wormhole that is based on punctures. As an example, we illustrate how this defect works in the context of the surface code. This defect has a few key features. First, it preserves the LDPC property of the code over the course of code deformation. At the outset, this property was not guaranteed. Second, it generalizes in a straightforward way to hypergraph product codes. This is the first framework that is rich enough to describe fault-tolerant gates on this class of codes. Finally, we circumvent a limitation in Gottesman’s approach which only allowed a limited number of logical gates at any given time. Our proposal allows to access the entire code block at any given time