Search

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)$ have 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 {\em good} if it is possible to have $k, Comment: The Computer Journal

We construct locally decodable codes (LDCs) to correct insertion-deletion errors in the setting where the sender and receiver share a secret key or where the channel is resource-bounded. Our constructions rely on a so-called "Hamming-to-InsDel" compiler (Ostrovsky and Paskin-Cherniavsky, ITS '15 & Block et al., FSTTCS '20), which compiles any locally decodable Hamming code into a locally decodable code resilient to insertion-deletion (InsDel) errors. While the compilers were designed for the classical coding setting, we show that the compilers still work in a secret key or resource-bounded setting. Applying our results to the private key Hamming LDC of Ostrovsky, Pandey, and Sahai (ICALP '07), we obtain a private key InsDel LDC with constant rate and polylogarithmic locality. Applying our results to the construction of Blocki, Kulkarni, and Zhou (ITC '20), we obtain similar results for resource-bounded channels; i.e., a channel where computation is constrained by resources such as space or time.

Locally correctable codes (LCCs) and locally testable codes (LTCs) are error-correcting codes that admit local algorithms for correction and detection of errors. Those algorithms are local in the sense that they only query a small number of entries of the corrupted codeword. The fundamental question about LCCs and LTCs is to determine the optimal tradeoff among their rate, distance, and query complexity. In this work, we construct the first LCCs and LTCs with constant rate, constant relative distance, and sub-polynomial query complexity. Specifically, we show that there exist LCCs and LTCs with block length n , constant rate (which can even be taken arbitrarily close to 1), and constant relative distance, whose query complexity is exp(Õ(√log n )) (for LCCs) and (log n ) O (log log n ) (for LTCs). In addition to having small query complexity, our codes also achieve better tradeoffs between the rate and the relative distance than were previously known to be achievable by LCCs or LTCs. Specifically, over large (but constant size) alphabet, our codes approach the Singleton bound, that is, they have almost the best-possible relationship between their rate and distance. Over the binary alphabet, our codes meet the Zyablov bound. Such tradeoffs between the rate and the relative distance were previously not known for any o ( n ) query complexity. Our results on LCCs also immediately give locally decodable codes with the same parameters.

Affine-invariant codes are codes whose coordinates form a vector space over a finite field and which are invariant under affine transformations of the coordinate space. They form a natural, well-studied class of codes; they include popular codes such as Reed-Muller and Reed-Solomon. A particularly appealing feature of affine-invariant codes is that they seem well suited to admit local correctors and testers. In this work, we give lower bounds on the length of locally correctable and locally testable affine-invariant codes with constant query complexity. We show that if a code C ⊂ Σ K n is an r -query affine invariant locally correctable code (LCC), where K is a finite field and Σ is a finite alphabet, then the number of codewords in C is at most exp( O K,r,|Σ| ( n r −1)) . Also, we show that if C ⊂ Σ K n is an r -query affine invariant locally testable code (LTC), then the number of codewords in C is at most exp( O K,r,|Σ| ( n r −2)) . The dependence on n in these bounds is tight for constant-query LCCs/LTCs, since Guo, Kopparty, and Sudan (ITCS’13) constructed affine-invariant codes via lifting that have the same asymptotic tradeoffs. Note that our result holds for non-linear codes, whereas previously, Ben-Sasson and Sudan (RANDOM’11) assumed linearity to derive similar results. Our analysis uses higher-order Fourier analysis. In particular, we show that the codewords corresponding to an affine-invariant LCC/LTC must be far from each other with respect to Gowers norm of an appropriate order. This then allows us to bound the number of codewords, using known decomposition theorems, which approximate any bounded function in terms of a finite number of low-degree non-classical polynomials, up to a small error in the Gowers norm.

A locally decodable code (LDC) C from {0,1} to the k to {0,1} to the n is an error correcting code wherein individual bits of the message can be recovered by only querying a few bits of a noisy codeword. LDCs found a myriad of applications both in theory and in practice, ranging from probabilistically checkable proofs to distributed storage. However, despite nearly two decades of extensive study, the best known constructions of O(1)-query LDCs have super-polynomial block length.\ud The notion of relaxed LDCs is a natural relaxation of LDCs, which aims to bypass the foregoing barrier by requiring local decoding of nearly all individual message bits, yet allowing decoding failure (but not error) on the rest. State of the art constructions of O(1)-query relaxed LDCs achieve blocklength n is order of k to the power of 1 plus gamma for an arbitrarily small constant.\ud We prove a lower bound which shows that O(1)-query relaxed LDCs cannot achieve blocklength n = k to the power of 1 + o(1). This resolves an open problem raised by Goldreich in 2004.

We survey the state of the art in constructions of locally testable codes, locally decodable codes and locally correctable codes of high rate.

In this study, the authors consider the designing of a new set of uniquely decodable codes for uncoded synchronous overloaded code division multiple access for the number of codes exceeding the assigned code length. For the construction, the proposed recursive method at iteration-k generates a matrix that can be classified into k orthogonal subsets of different dimensions. Out of them, all besides the largest (binary Hadamard) one are ternary in nature. There resides an inbuilt twin tree structured cross-correlation hierarchy that facilitates an advantageous balance between the auto and intergroup cross-correlation for the signatures in a subset. This opportunity is further leveraged by the proposed multi-stage detector to maintain the uniquely decodable (errorless) nature of the matrices for noiseless transmission. The simple logic of matched filtering serving as the basic designing block of the decoder provides an enormous saving over the complexity of optimum maximum likelihood decoder. For the noisy channel, the authors derive the theoretical expression of the average bit error rate for the individual subset. Moreover, the authors explain the role of the two factors (cardinality of the subset, and net level of interference) in being responsible for the non-uniformity in the order of their error performance.

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).

The study of locally testable codes (LTCs) has benefited from a number of nontrivial constructions discovered in recent years. Yet, we still lack a good understanding of what makes a linear error correcting code locally testable and as a result we do not know what is the rate-limit of LTCs and whether asymptotically good linear LTCs with constant query complexity exist. In this paper, we provide a combinatorial characterization of smooth locally testable codes, which are locally testable codes whose associated tester queries every bit of the tested word with equal probability. Our main contribution is a combinatorial property defined on the Tanner graph associated with the code tester (“well-structured tester”). We show that a family of codes is smoothly locally testable if and only if it has a well-structured tester. As a case study we show that the standard tester for the Hadamard code is “well-structured,” giving an alternative proof of the local testability of the Hadamard code, originally proved by (Blum, Luby, Rubinfeld, J. Comput. Syst. Sci. 47 (1993) 549–595) (STOC 1990). Additional connections to the works of (Ben-Sasson, Harsha, Raskhodnikova, SIAM J. Comput 35 (2005) 1–21) (SICOMP 2005) and of (Lachish, Newman and Shapira, Comput Complex 17 (2008) 70–93) are also discussed. © 2016 Wiley Periodicals, Inc. Random Struct. Alg., 2016

In a locally recoverable or repairable code, any symbol of a codeword can be recovered by reading only a small (constant) number of other symbols. The notion of local recoverability is important in the area of distributed storage where a most frequent error-event is a single storage node failure (erasure). A common objective is to repair the node by downloading data from as few other storage nodes as possible. In this paper, we bound the minimum distance of a code in terms of its length, size, and locality. Unlike the previous bounds, our bound follows from a significantly simple analysis and depends on the size of the alphabet being used. It turns out that the binary Simplex codes satisfy our bound with equality; hence, the Simplex codes are the first example of an optimal binary locally repairable code family. We also provide achievability results based on random coding and concatenated codes that are numerically verified to be close to our bounds.

In this paper, we propose three constructions of locally repairable codes based on fractional repetition (FR) codes. We also derive the bounds on the maximum file size stored with locally repairable FR codes with locality 2 and 3, respectively. Construction 1 results in a locally repairable FR code with locality 2. It has repetition degree ρ = 2, and attains the bound on the maximum file size we derived. The availability of this code is designed to be ρ − 1 = 1. Construction 2 results in a code which has larger availability ρ − 1 = 2 so that multiple node failures can be ‘locally’ repaired. This code also attains the bound on the maximum file size but with larger number of storage nodes. Construction 3 is a result of reducing the number of storage nodes.

In this work we present a strong analysis of the testability of a broad, and to date the most interesting known, class of “affine-invariant” codes. Affine-invariant codes are codes whose coordinates are associated with a vector space and are invariant under affine transformations of the coordinate space. Affine-invariant linear codes form a natural abstraction of algebraic properties such as linearity and low-degree, which have been of significant interest in theoretical computer science in the past. The study of affine-invariance is motivated in part by its relationship to property testing: Affine-invariant linear codes tend to be locally testable under fairly minimal and almost necessary conditions.

In this work, we give the first construction of high-rate locally list-recoverable codes. List-recovery has been an extremely useful building block in coding theory, and our motivation is to use these codes as such a building block. In particular, our construction gives the first capacity-achieving locally list-decodable codes (over constant-sized alphabet); the first capacity achieving} globally list-decodable codes with nearly linear time list decoding algorithm (once more, over constant-sized alphabet); and a randomized construction of binary codes on the Gilbert-Varshamov bound that can be uniquely decoded in near-linear-time, with higher rate than was previously known.Our techniques are actually quite simple, and are inspired by an approach of Gopalan, Guruswami, and Raghavendra (Siam Journal on Computing, 2011) for list-decoding tensor codes. We show that tensor powers of (globally) list-recoverable codes are approximately locally list-recoverable, and that the approximately modifier may be removed by pre-encoding the message with a suitable locally decodable code. Instantiating this with known constructions of high-rate globally list-recoverable codes and high-rate locally decodable codes finishes the construction.

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_\infty$~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 from 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., Comment: A preliminary version of this paper appeared in the proceedings of ITCS 2017

Instantly Decodable Network Codes are of great interest in broadcast applications because of their properties like low decoding delay, low encoding and decoding complexities, and simple receiver requirements. This work explores two different multicast broadcast scenarios and gives instantly decodable index codes that perform better than codes in existing literature. First, we describe our novel Unequal Error Protection scheme that achieves theoretical optimality and illustrate it through examples. In order sensitive or delay sensitive applications, based on an earlier decodability at the receivers' end, a packet can be classified as high priority (HP) packets or low priority (LP) packets. We introduce a practical algorithm that improves the packet retransmission technique of Muhammed et al. (Proceedings of the 2013 IEEE International Conference on Communications (ICC), Budapest, pp. 5120-5125) for reliable multicast in the instantly decodable network coding framework. Our scheme improves the delay and total completion time by optimizing the number of instantly decodable network code packet transmissions from the source. Further, simulation results with a comparative study show considerable improvement in Quality of Experience (QoE) for the end-users.

Locally decodable codes are error-correcting 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 ∈ Ω(1/ ∈ ), where k is the length of the message. Furthermore, for codes of rate > 1/2, no nontrivial locality had been achieved. In this article, 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. These codes, which we call multiplicity codes, are based on evaluating multivariate polynomials and their derivatives. Multiplicity codes extend traditional multivariate polynomial codes; they inherit the local-decodability of these codes, and at the same time achieve better tradeoffs and flexibility in the rate and minimum distance.

In a recent result, Dachman-Soled et al. (TCC 2015) proposed a new notion called locally decodable and updatable non-malleable codes, which informally, provides the security guarantees of a non-malleable code while also allowing for efficient random access. They also considered locally decodable and updatable non-malleable codes that are leakage-resilient, allowing for adversaries who continually leak information in addition to tampering. Unfortunately, the locality of their construction in the continual setting was \(\varOmega (\log n)\), meaning that if the original message size was n blocks, then \(\varOmega (\log n)\) blocks of the codeword had to be accessed upon each decode and update instruction.

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 x1;:::;xk 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.

In this paper, we obtain a composition theorem that allows us to construct locally testable codes (LTCs) by repeated two-wise tensor products. This is the first composition theorem showing that repeating the two-wise tensor operation any 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. To obtain our results, we define a new tester for tensor products. Our tester uses the distribution of the "inner 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. We show that if the base code is any 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. In particular, this answers a question posed in the paper of Dinur et al. (2006) by expanding the class of allowed base codes to include all LTCs and not just so-called uniform LTCs whose associated tester queries all codeword entries with equal probability. One corollary of our composition theorem is a simple construction of high-rate LTCs with sublinear query complexity. More formally, we show that for every ?, ? > 0 there exists a family of LTCs over the binary field with query complexity n? and rate at least 1 ? ?.

A cyclic code is called single-syndrome decodable if its decoding up to error-correcting capability is completely based on the single syndrome. This letter proposes a construction method of the unusual general error locator polynomial (GELP) for the triple- and quadruple-error-correcting single-syndrome decodable cyclic (SSDC) codes and gives an upper bound on the computational complexity of the unusual GELP. Both theoretical and experimental results show that the unusual GELP has lower computational complexity than the conventional GELP for triple-error-correcting SSDC codes.

A space-time block code (STBC) is said to be multigroup decodable if the information symbols encoded by it can be partitioned into two or more groups such that each group of symbols can be maximum-likelihood (ML) decoded independently of the other symbol groups. In this paper, we show that the upper triangular matrix R encountered during the sphere decoding of a linear dispersion STBC can be rank-deficient even when the rate of the code is less than the minimum of the number of transmit and receive antennas. We then show that all known families of high-rate (rate greater than 1) multigroup decodable codes have rank-deficient R matrix even when the rate is less than the number of transmit and receive antennas, and this rank-deficiency problem arises only in asymmetric MIMO systems when the number of receive antennas is strictly less than the number of transmit antennas. Unlike the codes with full-rank R matrix, the complexity of the sphere decoding-based ML decoder for STBCs with rank-deficient R matrix is polynomial in the constellation size, and hence is high. We derive the ML sphere decoding complexity of most of the known high-rate multigroup decodable codes, and show that for each code, the complexity is a decreasing function of the number of receive antennas.

The construction of asymmetric error-correcting codes is a topic that was studied extensively, however; the existing approach for code construction assumes that every codeword should tolerate t asymmetric errors. Our main observation is that in contrast to symmetric errors, asymmetric errors are content dependent. For example, in Z-channels, the all-1 codeword is prone to have more errors than the all-0 codeword. This motivates us to develop nonuniform codes whose codewords can tolerate different numbers of asymmetric errors depending on their Hamming weights. The idea in a nonuniform codes' construction is to augment the redundancy in a content-dependent way and guarantee the worst case reliability while maximizing the code size. In this paper, we first study nonuniform codes for Z-channels, namely, they only suffer one type of errors, say 1→ 0. Specifically, we derive their upper bounds, analyze their asymptotic performances, and introduce two general constructions. Then, we extend the concept and results of nonuniform codes to general binary asymmetric channels, where the error probability for each bit from 0 to 1 is smaller than that from 1 to 0.

Ben-Sasson and Sudan (RSA 2006) showed that repeated tensor products of linear codes with a very large distance are locally testable. Due to the requirement of a very large distance the associated tensor products could be applied only over sufficiently large fields. Then Meir (SICOMP 2009) used this result (as a black box) to present a combinatorial construction of locally testable codes that match best known parameters. As a consequence, this construction was obtained over sufficiently large fields. In this paper we improve the result of Ben-Sasson and Sudan and show that for \emph{any} linear codes the associated tensor products are locally testable. Consequently, the construction of Meir can be taken over any field, including the binary field. Moreover, a combination of our result with the result of Spielman (IEEE IT, 1996) implies a construction of linear codes (over any field) that combine the following properties: have constant rate and constant relative distance; have blocklength $n$ and testable with $n^{\epsilon}$ queries, for any constant $\epsilon > 0$; linear time encodable and linear-time decodable from a constant fraction of errors. Furthermore, a combination of our result with the result of Guruswami et al. (STOC 2009) implies a similar corollary regarding the list-decodable codes.

This study presents an orthogonal design of space-time block code (STBC) that is single symbol decodable and enables full diversity and full rate transmission in a quasi-static channel environment. In the proposed scheme, full diversity is achieved by use of constellation rotation and co-ordination interpolation as is the case for the co-ordinate interleaved orthogonal design, whereas the transmission matrix of the proposed code consists of orthogonal columns with all non-zero elements, alleviating the concern about high peak-to-average power ratio. In particular, the proposed code offers lower complexity of channel estimation, and exhibits lower symbol error rate than the conventional quasi-orthogonal STBC when an maximum-likelihood decision-directed channel estimator is assumed. The advantages of the proposed code over the conventional codes are demonstrated through computer simulations. In addition, the selection of the angle of rotation for the proposed design is also presented, regarding the impact of channel estimation error.

The polarity designs, introduced in [9], are combinatorial 2-designs having the same parameters as a projective geometry design $PG_s(2s,q)$ formed by the $s$-subspaces of $PG(2s,q)$, $s\ge 2$, $q=p^t$, $p$ prime. If $q=p$ is a prime, a polarity design has also the same $p$-rank as $PG_s(2s,p)$. If $q=2$, any polarity 2-design is extendable to a 3-design having the same parameters and 2-rank as an affine geometry design $AG_{s+1}(2s+1,2)$ formed by the $(s+1)$-subspaces of $AG(2s+1,2)$. It is shown in this paper that a linear code being the null space of the incidence matrix of a polarity design can correct by majority-logic decoding the same number of errors as the projective geometry code based on $PG_s(2s,q)$. In the binary case, any polarity 3-design yields a binary self-dual code with the same parameters, minimum distance, and correcting the same number of errors by majority-logic decoding as the Reed-Muller code of length $2^{2s+1}$ and order $s$.

International audience; Proofs of retrievability (PoR) are probabilistic protocols which ensure that a client can recover a file he previously stored on a server. Good PoRs aim at reaching an efficient trade-off between communication complexity and storage overhead, and should be usable an unlimited number of times. We present a new unbounded-use PoR construction based on a class of locally decodable codes, namely the lifted codes of Guo et. al.. Our protocols feature sublinear communication complexity and very low storage overhead. Moreover, the various parameters can be tuned so as to minimize the communication complexity (resp. the storage overhead) according to the setting of concern.

Consider stationary ergodic measures for which the difference between the expected length of a uniquely decodable code and the block entropy is asymptotically bounded by a constant. Using ergodic decomposition, it is shown that the number of such measures is less than the base of the logarithm raised to the power of that constant. In consequence, an analogous statement is derived for excess lengths of universal codes. The latter was previously communicated without proof.

Complex Orthogonal Design (COD) codes are known to have the lowest detection complexity among Space-Time Block Codes (STBCs). However, the rate of square COD codes decreases exponentially with the number of transmit antennas. The Quasi-Orthogonal Design (QOD) codes emerged to provide a compromise between rate and complexity as they offer higher rates compared to COD codes at the expense of an increase of decoding complexity through partially relaxing the orthogonality conditions. The QOD codes were then generalized with the so called g-symbol and g-group decodable STBCs where the number of orthogonal groups of symbols is no longer restricted to two as in the QOD case. However, the adopted approach for the construction of such codes is based on sufficient but not necessary conditions which may limit the achievable rates for any number of orthogonal groups. In this paper, we limit ourselves to the case of Unitary Weight (UW)-g-group decodable STBCs for 2^a transmit antennas where the weight matrices are required to be single thread matrices with non-zero entries in {1,-1,j,-j} and address the problem of finding the highest achievable rate for any number of orthogonal groups. This special type of weight matrices guarantees full symbol-wise diversity and subsumes a wide range of existing codes in the literature. We show that in this case an exhaustive search can be applied to find the maximum achievable rates for UW-g-group decodable STBCs with g>1. For this purpose, we extend our previously proposed approach for constructing UW-2-group decodable STBCs based on necessary and sufficient conditions to the case of UW-g-group decodable STBCs in a recursive manner., 12 pages, and 5 tables, accepted for publication in IEEE transactions on communications

Locally decodable codes are error-correcting codes with the extra property that, in order to retrieve the value of a single input position, it is sufficient to read a small number of positions of the codeword. We refer to the probability of getting the correct value as the correctness of the decoding algorithm. A breakthrough result by Yekhanin [2007] showed that 3-query linear locally decodable codes may have subexponential length. The construction of Yekhanin, and the three query constructions that followed, achieve correctness only up to a certain limit which is 1 − 3 δ for nonbinary codes, where an adversary is allowed to corrupt up to δ fraction of the codeword. The largest correctness for a subexponential length 3-query binary code is achieved in a construction by Woodruff [2008], and it is below 1 − 3 δ . We show that achieving slightly larger correctness (as a function of δ ) requires exponential codeword length for 3-query codes. Previously, there were no larger than quadratic lower bounds known for locally decodable codes with more than 2 queries, even in the case of 3-query linear codes. Our lower bounds hold for linear codes over arbitrary finite fields and for binary nonlinear codes. Considering larger number of queries, we obtain lower bounds for q-query codes for q > 3, under certain assumptions on the decoding algorithm that have been commonly used in previous constructions. We also prove bounds on the largest correctness achievable by these decoding algorithms, regardless of the length of the code. Our results explain the limitations on correctness in previous constructions using such decoding algorithms. In addition, our results imply trade-offs on the parameters of error-correcting data structures.

e describe a new approach for the problem of finding {\rm rigid} matrices, as posed by Valiant \cite{Val77}, by connecting it to the, seemingly unrelated, problem of proving lower bounds for linear locally self-correctable codes. This approach, if successful, could lead to a non-natural property (in the sense of Razborov and Rudich \cite{RR97}) implying super-linear lower bounds for linear functions in the model of logarithmic-depth arithmetic circuits. Our results are based on a lemma saying that, if the generating matrix of a locally decodable code is {\bf not} rigid, then it defines a locally self-correctable code with rate close to one. Thus, showing that such codes cannot exist will prove that the generating matrix of {\em any} locally decodable code (and in particular Reed Muller codes) is rigid.

Recently, single-symbol maximum-likelihood (ML) decodable distributed space-time block coding (DSTBC) has been developed for use in cooperative diversity networks. However, the symbol rate of the DSTBC decreases with the number of relays. This issue can be addressed if the channel phase information (CPI) of the first-hop is exploited, and such code is referred to as DSTBC-CPI. Some complex single-symbol decodable DSTBCs-CPI were reported in the literature. However, no upper-bound on the symbol rate of such DSTBC-CPI has been derived, although it is a fundamental issue. Furthermore, finding a tight (more preferably achievable) upper-bound is essential to check if any developed code is optimum or not. In this letter, we derive an upper-bound on the symbol rate of real single-symbol decodable DSTBC-CPI and show that the bound is independent of the number of relays in the network. Finally, we demonstrate that our derived bound is actually achievable.

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})}$.

Over 60 years of research in coding theory, that started with the works of Shannon and Hamming, have given us nearly optimal ways to add redundancy to messages, encoding bit strings representing messages into longer bit strings called codewords, in a way that the message can still be recovered even if a certain fraction of the codeword bits are corrupted. Classical error-correcting codes, however, do not work well when messages are modern massive datasets, because their decoding time increases (at least) linearly with the length of the message. As a result in typical applications large datasets are first partitioned into small blocks, each of which is then encoded separately. Such encoding allows efficient randomaccess retrieval of the data, but yields poor noise resilience. Locally decodable codes are codes intended to address this seeming conflict between efficient retrievability and reliability. They are codes that simultaneously provide efficient random-access retrieval and high noise resilience by allowing reliable reconstruction of an arbitrary data bit from looking at only a small number of randomly chosen codeword bits. Apart from the natural application to data transmission and storage such codes have important applications in cryptography and computational complexity theory. This review introduces and motivates locally decodable codes, and discusses the central results of the subject. Locally Decodable Codes assumes basic familiarity with the properties of finite fields and is otherwise self-contained. It will benefit computer scientists, electrical engineers, and mathematicians with an interest in coding theory.

A frequency permutation array (FPA) of length n = mλ and distance d is a set of permutations on a multiset over m symbols, where each symbol appears exactly λ times and the distance between any two elements in the array is at least d. FPA generalizes the notion of permutation array. In this paper, under the Chebyshev distance, we first prove lower and upper bounds on the size of FPA. Then we give several constructions of FPAs, and some of them come with efficient encoding and decoding capabilities. Moreover, we show one of our designs is locally decodable, i.e., we can decode a message bit by reading at most λ+1 symbols, which has an interesting application to private information retrieval.

The performance of iterative decoding algorithm for one-step majority logic decodable (OSMLD) codes is investigated. We introduce a new soft-in soft-out of APP threshold algorithm which is able to decode theses codes nearly as well as belief propagation (BP) algorithm. However the computation time of the proposed algorithm is very low. The developed algorithm can also be applied to product codes and parallel concatenated codes based on block codes. Numerical results on both AWGN and Rayleigh channels are provided. The performance of iterative decoding of parallel concatenated code (17633,8595) with rate 0.5 is only 1.8 dB away from the Shannon capacity limit at a BER of 10. General Terms Information theory and Coding, Signal Processing.

Constrained sequence codes are widely used to meet constraints imposed by digital storage and communication systems. This paper develops an algorithm for the construction of constrained codes that admit state-independent decoding. By partitioning the code into a group of alphabets, one for each state, a codebook is developed using this algorithm that will allow the code to be decoded at the receiver without the need for state information. Finally, we use this algorithm to construct DC-free runlength-limited (RLL) codes, and we present two highly efficient state-independent decodable DC-free RLL codes.

Property testing was initially studied from various motivations in 1990’s. A code C ⊂ GF(r) n is locally testable if there is a randomized algorithm which can distinguish with high possibility the codewords from a vector essentially far from the code by only accessing a very small (typically constant) number of the vector’s coordinates. The problem of testing codes was firstly studied by Blum, Luby and Rubinfeld and closely related to probabilistically checkable proofs (PCPs). How to characterize locally testable codes is a complex and challenge problem. The local tests have been studied for Reed-Solomon (RS), Reed-Muller (RM), cyclic, dual of BCH and the trace subcode of algebraicgeometric codes. In this paper we give testers for algebraic geometric codes with linear parameters (as functions of dimensions). We also give a moderate condition under which the family of algebraic geometric codes cannot be locally testable.

A polynomial time construction of binary codes with the currently best known tradeoff between rate and error-correction radius is given. Specifically, linear codes over fixed alphabets are constructed that can be list decoded in polynomial time up to the so-called Blokh-Zyablov bound. The work builds upon earlier work by the authors where codes list decodable up to the Zyablov bound (the standard product bound on distance of concatenated codes) were constructed. The new codes are constructed via a (known) generalization of code concatenation called multilevel code concatenation. A probabilistic argument, which is also derandomized via conditional expectations, is used to show the existence of inner codes with a certain nested list decodability property that is appropriate for use in multilevel concatenated codes. A ldquolevel-by-levelrdquo decoding algorithm, which crucially uses the list recovery algorithm for the outer folded Reed-Solomon codes, enables list decoding up to the designed distance bound, aka the Blokh-Zyablov bound, for multilevel concatenated codes.

A space-time block code (STBC) in K symbols (variables) is called a g-group decodable STBC if its maximum-likelihood (ML) decoding metric can be written as a sum of g terms, for some positive integer g greater than one, such that each term is a function of a subset of the K variables and each variable appears in only one term. In this paper, we provide a general structure of the weight matrices of multigroup decodable codes using Clifford algebras. Without assuming that the number of variables in each group is the same, a method of explicitly constructing the weight matrices of full-diversity, delay-optimal multigroup decodable codes is presented for arbitrary number of antennas. For the special case of 2 a number of transmit antennas, we construct two subclass of codes: 1) a class of 2 a -group decodable codes with rate [(a)/(2( a-1))], which is, equivalently, a class of single-symbol decodable codes, and 2) a class of (2a-2)-group decodable codes with rate [((a-1))/(2( a-2))], i.e., a class of double-symbol decodable codes.

A new twist to the classical problem of compressing a discrete source over noiseless channel alphabets where different code symbols may have different transmission costs is considered. One-to-one or nonsingular codes map each letter from the source alphabet into a distinct codeword consisting of a string of channel alphabet letters; they need not be uniquely decodable. They have been studied for binary code alphabets with equal letter costs since the early 1970s and are extended here to memoryless cost channel alphabets. The study of optimal one-to-one codes is linked in this paper to three other well-known source coding problems. The algorithm to construct the optimal one-to-one code is closely related to the Varn code and the Tunstall code. These relationships and convexity arguments are used to establish some upper and lower bounds on the expected cost per source symbol of the optimal one-to-one code. Finally, the average cost per symbol of the optimal one-to-one code is demonstrated to offer a new lower bound to the average cost per symbol of the optimal uniquely decodable code which is sometimes tighter than the classic bound from Shannon's landmark 1948 paper.

We investigate the performance of iterative decoding algorithms for multistep majority logic decodable (MSMLD) codes of intermediate length. We introduce a new bit-flipping algorithm that is able to decode these codes nearly as well as a maximum-likelihood decoder on the binary-symmetric channel. We show that MSMLD codes decoded using bit-flipping algorithms can outperform comparable Bose-Chaudhuri-Hocquenghem (BCH) codes decoded using standard algebraic decoding algorithms, at least for high bit-flip rates (or low and moderate signal-to-noise ratios (SNRs)).

Locally correctable codes are error-correcting codes that allow a single bit of the codeword to be recovered by looking up a small subset of the coordinates of the received word. In this work, we generalize the concept of traditional locally correcting to locally correcting multiple bits, and present a family of codes which allow multiple bits to be recovered with probability approaching 1 by visiting a small number of locations of the received word, even when a constant fraction of errors exist. Moreover, our codes are of high rate.

A local tester for a code probabilistically views a small set of coordinates of a given word and based on this local view accepts code words with probability one while rejecting words far from the code with constant probability. A local tester for a code is said to be "robust" if the local views of the tester are far from acceptable views when the word being tested is far from the code. Robust testability of codes play a fundamental role in constructions of probabilistically checkable proofs where robustness is a critical element in composition. In this work we consider a broad class of codes, called lifted codes, that include codes formed by low-degree polynomials, and show that an almost natural test, extending a low-degree test proposed by Raz and Safra (STOC 1997), is robust. Our result is clean and general -- the robustness of the test depends only on the distance of the code being lifted, and is positive whenever the distance is positive. We use our result to get the first robust low-degree test that works when the degree of the polynomial being tested is more than half the field size. Our results also show that the high-rate codes of Guo et al. (ITCS 2013) are robustly locally testable with sub linear query complexity. Guo et al. Also show several other interesting classes of locally testable codes that can be derived from lifting and our result shows all such codes have robust testers, at the cost of a quadratic blow up in the query complexity of the tester. Of technical interest is an intriguing relationship between tensor product codes and lifted codes that we explore and exploit.

Locally correctable codes are error-correcting codes with efficient decoding schemes, which can recover any bit of a codeword by visiting a small number of locations of the codeword. Recently Kopparty et. al. [1] and Guo et. al. [2] presented multiplicity codes and lifted Reed-Solomon codes, respectively, which are two families of high-rate locally correctable codes. In this paper, we generalize the method of multiplicities and provide a new construction of locally correctable codes of rate approaching 1, which is also a theoretical connection between the codes in [1] and [2].

In this work, we revisit the structure of weight matrices for Linear Dispersion STBCs to admit ML decoding with low-complexity. We first propose novel sufficient design criteria for linear STBCs considering an arbitrary number of antennas and an arbitrary coding rate. Then we apply the derived criteria to three families of codes, multi-group decodable, fast decodable, and fast-group decodable codes. We provide analytical proofs showing that the ML-decoding complexity of such codes depends only on the weight matrices and their ordering and not on the channel gains or the number of antennas and explaining why the so far used Hurwitz-Radon theory-based approaches do not exactly determine the complexity of all classes of STBCs under ML decoding.

In this work, we present a new upper bound on the minimum distance d of linear locally repairable codes (LRCs) with information locality and availability. The bound takes into account the code length n, dimension k, locality r, availability t, and field size q. We use tensor product codes to construct several families of LRCs with information locality, and then we extend the construction to design LRCs with information locality and availability. Some of these codes are shown to be optimal with respect to their minimum distance, achieving the new bound. Finally, we study the all-symbol locality and availability properties of several classes of one-step majority-logic decodable codes, including cyclic simplex codes, cyclic difference-set codes, and 4-cycle free regular low-density parity-check (LDPC) codes. We also investigate their optimality using the new bound.

We continue the study of the trade-off between the length of probabilistically checkable proofs (PCPs) and their query complexity, establishing the following main results (which refer to proofs of satisfiability of circuits of size $n$): 1. We present PCPs of length $\exp(o(\log\log n)^2)\cdot n$ that can be verified by making $o(\log\log n)$ Boolean queries. 2. For every \epsilon>0, we present PCPs of length $\exp(\log^\epsilon n)\cdot n$ that can be verified by making a constant number of Boolean queries. In both cases, false assertions are rejected with constant probability (which may be set to be arbitrarily close to 1). The multiplicative overhead on the length of the proof, introduced by transforming a proof into a probabilistically checkable one, is just quasi polylogarithmic in the first case (of query complexity $o(\log\log n)$), and is $2^{(\log n)^\epsilon}$, for any $\epsilon > 0$, in the second case (of constant query complexity). Our techniques include the introduction of a new variant of PCPs that we call “robust PCPs of proximity.” These new PCPs facilitate proof composition, which is a central ingredient in the construction of PCP systems. (A related notion and its composition properties were discovered independently by Dinur and Reingold.) Our main technical contribution is a construction of a “length-efficient” robust PCP of proximity. While the new construction uses many of the standard techniques used in PCP constructions, it does differ from previous constructions in fundamental ways, and in particular does not use the “parallelization” step of Arora et al. [J. ACM, 45 (1998), pp. 501-555]. The alternative approach may be of independent interest. We also obtain analogous quantitative results for locally testable codes. In addition, we introduce a relaxed notion of locally decodable codes and present such codes mapping $k$ information bits to codewords of length $k^{1+\epsilon}$ for any $\epsilon>0$.