Search

An error-correcting code is said to be locally decodable if a randomized algorithm can recover any single bit of a message by reading only a small number of symbols of a possibly corrupted encoding of the message. Katz and Trevisan [On the efficiency of local decoding procedures for error correcting codes, STOC, 2000, pp. 80-86] showed that any such code C : {0, 1}n → Σm with a decoding algorithm that makes at most q probes must satisfy m = Ω((n/log |Σ|)q/(q-1)). They assumed that the decoding algorithm is non-adaptive, and left open the question of proving similar bounds for adaptive decoders. We show m = Ω((n/log |Σ|)q/(q-1)) without assuming that the decoder is nonadaptive.

Locally decodable codes (LDC) [1,9] are error correcting codes that allow decoding (any) individual symbol of the message, by reading only few symbols of the codeword. LDC’s, originally considered in the setting of PCP’s [1], have found other additional applications in theory of CS, such as PIR in cryptography, generating a lot of fascinating work (see [12] and references within). In one straightforward practical application to storage, such codes provide enormous efficiency gains over standard error correcting codes (ECCs), that need to read the entire encoded message to learn even a single bit of the encoded message. Typically, LDC’s, as well as standard ECC’s are designed to decode the encoded message if up to some bounded fraction of the symbols had been modified. This corresponds to decoding strings of bounded Hamming distance from a valid codeword. A stronger natural metric is the edit distance, measuring the shortest sequence of insertions and deletions (indel.) of symbols leading from one word to another. Standard ECC’s for edit distance have been previously considered [11]. Furthermore, [11] devised codes with rate and distance (error tolerance) optimal up to constants, with efficient encoding and decoding procedures. However, combining these two useful settings of LDC, and robustness against indel. errors has never been considered.

A construction of polynomial-time decodable codes for discrete memoryless multiple access channels (MACs) is proposed based on concatenated codes. Concatenated codes, originally developed by Forney, can achieve any rate below capacity for the single-user discrete memoryless channel while requiring only polynomial-time decoding complexity in the code length. In this letter, Forney's construction together with multi-level concatenation is generalized to MACs. An error exponent for the constructed code is derived, and it is shown that the constructed code can achieve any rate in the capacity region.

A locally decodable source code (LDSC) allows the recovery of arbitrary parts of an unencoded message from its encoded version, using only a part of the encoded message as input, a challenge that arises when searching within compressed data sets. Simple source codes such as Huffman codes or Lempel-Ziv compression are not well suited to this task: A decoder starting at an arbitrary point within the compressed sequence generally cannot determine its position with respect to the boundaries between encoded symbols, or requires information found before the starting point in order to be able to decode. In this paper, we propose the use of subsets of self-synchronising variable-length T-codes as source codes and show that local decoding is feasible and practical using subsets of T-codes with bounded synchronisation delay (BSD).

This paper presents an iterative multi-step decoding algorithm for a class of multi-step majority-logic (MS-MLG) decodable cyclic codes. The proposed algorithm is capable of efficient decoding the MS-MLG decodable cyclic codes with large number of short cycles of length 4. In addition, we decompose the parity-check matrices into several submatrices by utilizing the orthogonal structure of the codes. The decomposition scheme allows efficient decoding for MS-MLG decodable cyclic codes. Simulation results demonstrate that the MS-MLG decodable cyclic codes decoded with the proposed algorithm outperform BCH codes with similar lengths and rates decoded with the hard-decision algorithm.

In the framework of write-once memory (WOM) codes, it is important to distinguish between codes that can be decoded directly and those that require that the decoder knows the current generation to successfully decode the state of the memory. A widely used approach to construct WOM codes is to design first nondecodable codes that approach the boundaries of the capacity region, and then make them decodable by appending additional cells that store the current generation, at an expense of a rate loss. In this paper, we propose an alternative method to make nondecodable WOM codes decodable by appending cells that also store some additional data. The key idea is to append to the original (nondecodable) code a short synchronous WOM code and write generations of the original code and of the synchronous code simultaneously. We consider both the binary and the nonbinary case. Furthermore, we propose a construction of synchronous WOM codes, which are then used to make nondecodable codes decodable. For short-to-moderate block lengths, the proposed method significantly reduces the rate loss as compared to the standard method., Comment: To appear in IEEE Transactions on Communications. The material in this paper was presented in part at the 2012 IEEE International Symposium on Information Theory, Cambridge, MA, July 2012

A locally decodable code is a code such that any coordinate of a message can be determined with high probability by looking up a small subset of coordinates of the message’s corresponding codeword, even when the codeword has a constant fraction of its coordinates corrupted. In certain applications, a stronger property, called local correctability, is required. A locally correctable code (LCC) is a code such that any coordinate of a corrupted codeword can be determined with high probability by looking up a small subset of coordinates of the corrupted codeword. The concept of LCC originates in the works of Blum and Kannan [2], and Lipton [3] on program checking. We now introduce LCC more formally. Let X and Y be finite sets. The set of all functions from X to Y is denoted Y X . The finite field of q elements is denoted by Fq. A q-ary code on coordinate set D is a function space C Fq D . The length of the code C is L(C) = jDj, the size of D, and its rate is R(C) = log qjCj

We prove that 3-query linear locally correctable codes over the Reals of dimension d require block length n > d2+λ for some fixed, positive λ > 0. Geometrically, this means that if n vectors in Rd are such that each vector is spanned by a linear number of disjoint triples of others, then it must be that n > d2+λ. This improves the known quadratic lower bounds (e.g. [20, 28]). While a modest improvement, we expect that the new techniques introduced in this work will be useful for further progress on lower bounds of locally correctable and decodable codes with more than 2 queries. At a high level, our proof has two parts, clustering and random restriction. The clustering step uses a powerful geometric theorem of Barthe which finds a basis change (and rescaling) putting the code in nearly isotropic position. This together with the fact that any LCC must have many 'correlated' pairs of points, lets us deduce that the vectors must have a surprisingly strong geometric clustering, and hence also combinatorial clustering with respect to the spanning triples. In the restriction step, we devise a new variant of the dimension reduction technique used in previous lower bounds, which is able to take advantage of the combinatorial clustering structure above. The analysis of our random projection method reduces to a simple (weakly) random graph process, and works over any field.

A Uniquely Decodable (UD) Code is a code such that any vector of the ambient space has a unique closest codeword. In this paper we begin a study of the structure of UD codes and identify perfect subcodes. In particular we determine all linear UD codes of covering radius \leq 2.

The binary input N-user adder channel models a communicant ion media accessed simultaneously by N users. In this model each user transmits binary sequences and the channel's output on each bit slot equals the sum of the corresponding N inputs. A uniquely decodable code for this channel is a set of N codes - a code for each of the N users - such that the receiver can determine all possible combinations of transmitted codewords from their sum. Van-Tilborg presented a method for determining an upper bound on the size of a uniquely decodable code for the two-user binary adder channel. He showed that for sufficiently large block length this combinatorial bound converges to the corresponding capacity region boundary. In the present work we use a similar method to derive an upper bound on the size of a uniquely decodable code for the binary input N-user adder channel. The new combinatorial bound is iterative - i.e., the bound for the (N - I)-user case can be obtained by projecting the N-user bound on (N - 1) combinatorial variables and in particular it subsumes the two-user result. For sufficiently large block length the N-user bound converges to the capacity region boundary of the binary input N-user adder channel.

For a given set of codeword lengths, there are many different optimal variable-length codes, which are all Huffman (1952) equivalent codes. Some of these codes may contain a synchronizing codeword which resynchronizes the code whenever it is transmitted. The shorter the synchronizing codeword, the quicker the code will resynchronize. Ferguson and Rabinowitz (1984) suggest the problem of finding, for a given set of codeword lengths, the binary Huffman equivalent code with the shortest synchronizing codeword. We consider binary Huffman equivalent codes whose shortest codeword has length m>1 and which contain a synchronizing codeword of length m+1, the shortest possible in this case. We provide an algorithm for constructing these codes for a given set of codeword lengths, if such a code exists. We study further properties of these codes and show that when in m/spl ges/3 the codes contain more than one synchronizing codeword. Finally, we suggest ways of improving the synchronization properties of the codes and provide some example codes.

In this paper, we study codes with locality that can recover from two erasures via a sequence of two local, parity-check computations. By a local parity-check computation, we mean recovery via a single parity-check equation associated to small Hamming weight. Earlier approaches considered recovery in parallel; the sequential approach allows us to potentially construct codes with improved minimum distance. These codes, which we refer to as locally 2-reconstructible codes, are a natural generalization along one direction, of codes with all-symbol locality introduced by Gopalan \textit{et al}, in which recovery from a single erasure is considered. By studying the Generalized Hamming Weights of the dual code, we derive upper bounds on the minimum distance of locally 2-reconstructible codes and provide constructions for a family of codes based on Tur\'an graphs, that are optimal with respect to this bound. The minimum distance bound derived here is universal in the sense that no code which permits all-symbol local recovery from $2$ erasures can have larger minimum distance regardless of approach adopted. Our approach also leads to a new bound on the minimum distance of codes with all-symbol locality for the single-erasure case., Comment: 14 pages, 3 figures, Updated for improved readability

We show that any q-ary code with sufficiently good distance can be randomly punctured to obtain, with high probability, a code that is list decodable up to radius $1 - 1/q - \epsilon$ with near-optimal rate and list sizes. Our results imply that "most" Reed-Solomon codes are list decodable beyond the Johnson bound, settling the long-standing open question of whether any Reed Solomon codes meet this criterion. More precisely, we show that a Reed-Solomon code with random evaluation points is, with high probability, list decodable up to radius $1 - \epsilon$ with list sizes $O(1/\epsilon)$ and rate $\Omega(\epsilon)$. As a second corollary of our argument, we obtain improved bounds on the list decodability of random linear codes over large fields. Our approach exploits techniques from high dimensional probability. Previous work used similar tools to obtain bounds on the list decodability of random linear codes, but the bounds did not scale with the size of the alphabet. In this paper, we use a chaining argument to deal with large alphabet sizes.

For a family of Space-Time Block Codes (STBCs) C-1, C-2,..., with increasing number of transmit antennas N-i, with rates R-i complex symbols per channel use, i = 1, 2,..., we introduce the notion of asymptotic normalized rate which we define as lim(i ->infinity) R-i/N-i, and we say that a family of STBCs is asymptotically-good if its asymptotic normalized rate is non-zero, i. e., when the rate scales as a non-zero fraction of the number of transmit antennas. An STBC C is said to be g-group decodable, g >= 2, if the information symbols encoded by it can be partitioned into g groups, such that each group of symbols can be ML decoded independently of the others. In this paper we construct full-diversity g-group decodable codes with rates greater than one complex symbol per channel use for all g >= 2. Specifically, we construct delay-optimal, g-group decodable codes for number of transmit antennas N-t that are a multiple of g2left perpendicular(g-1/2)right perpendicular with rate N-t/g2(g-1) + g(2)-g/2N(t). Using these new codes as building blocks, we then construct non-delay-optimal g-group decodable codes with rate roughly g times that of the delay-optimal codes, for number of antennas N-t that are a multiple of 2left perpendicular(g-1/2)right perpendicular, with delay gN(t) and rate Nt/2(g-1) + g-1/2N(t). For each g >= 2, the new delay-optimal and non-delay- optimal families of STBCs are both asymptotically-good, with the latter family having the largest asymptotic normalized rates among all known families of multigroup decodable codes with delay T = 3, these are the first instances of g-group decodable codes with rates greater than 1 reported in the literature.

STBC is a technique to achieve transmit diversity. QO-STBC is full rate STBC constructed from relaxing orthogonality, and requires a decoder to search symbol pairs with ML decoding. Motivated by this, we have proposed single symbol decodable QO-STBC with full diversity. This code achieves full transmit rate and low system complexity. However, the proposed QO-STBC can achieve a throughput performance like SISO. In order to exploit the advantages of single symbol decodable QO-STBC, the combination of the proposed QO-STBC and an adaptive modulation has been considered. The system performances of non-adaptive QO-STBC, adaptive single symbol decodable QO-STBC are evaluated and compared. It is shown that the proposed scheme can greatly improve the performance of non-adaptive QO-STBC system.

We consider the scenario of broadcasting for realtime applications and loss recovery via instantly decodable network coding. Past work focused on minimizing the completion delay, which is not the right objective for real-time applications that have strict deadlines. In this work, we are interested in finding a code that is instantly decodable by the maximum number of users. First, we prove that this problem is NP-Hard in the general case. Then we consider the practical probabilistic scenario, where users have i.i.d. loss probability, and the number of packets is linear or polynomial in the number of users. In this case, we provide a polynomial-time (in the number of users) algorithm that finds the optimal coded packet. Simulation results show that the proposed coding scheme significantly outperforms an optimal repetition code and a COPE-like greedy scheme.

We consider Reed-Solomon (RS) codes whose evaluation points belong to a subfield, and give a linear-algebraic list decoding algorithm that can correct a fraction of errors approaching the code distance, while pinning down the candidate messages to a well-structured affine space of dimension a constant factor smaller than the code dimension. By pre-coding the message polynomials into a subspace-evasive set, we get a Monte Carlo construction of a subcode of Reed-Solomon codes that can be list decoded from a fraction (1-R-e) of errors in polynomial time (for any fixed e > 0) with a list size of O(1/e). Our methods extend to algebraic-geometric (AG) codes, leading to a similar claim over constant-sized alphabets. This matches parameters of recent results based on folded variants of RS and AG codes. but our construction here gives subcodes of Reed-Solomon and AG codes themselves (albeit with restrictions on the evaluation points).Further, the underlying algebraic idea also extends nicely to Gabidulin's construction of rank-metric codes based on linearized polynomials. This gives the first construction of positive rate rank-metric codes list decodable beyond half the distance, and in fact gives codes of rate R list decodable up to the optimal (1-R-e) fraction of rank errors. A similar claim holds for the closely related subspace codes studied by Koetter and Kschischang.We introduce a new notion called subspace designs as another way to pre-code messages and prune the subspace of candidate solutions. Using these, we also get a deterministic construction of a polynomial time list decodable subcode of RS codes. By using a cascade of several subspace designs, we extend our approach to AG codes, which gives the first deterministic construction of an algebraic code family of rate R with efficient list decoding from 1-R-e fraction of errors over an alphabet of constant size (that depends only on e). The list size bound is almost a constant (governed by log* (block length)), and the code can be constructed in quasi-polynomial time.

We describe new constructions of error correcting codes, obtained by "degree-lifting" a short algebraic geometry base-code of block-length q to a lifted-code of block-length qm, for arbitrary integer m. The construction generalizes the way degree-d, univariate polynomials evaluated over the q-element field (also known as Reed-Solomon codes) are "lifted" to degree-d, m-variate polynomials (Reed-Muller codes). A number of properties are established: The rate of the degree-lifted code is approximately a 1/m!-fraction of the rate of the base-code. The relative distance of the degree-lifted code is at least as large as that of the base-code. This is proved using a generalization of the Schwartz-Zippel Lemma to degree-lifted Algebraic-Geometry codes. [Local correction] If the base code is invariant under a group that is "close" to being doubly-transitive (in a precise manner defined later then the degree-lifted code is locally correctable with query complexity at most q2. The automorphisms of the base-code are crucially used to generate query-sets, abstracting the use of affine-lines in the local correction procedure of Reed-Muller codes. Taking a concrete illustrating example, we show that degree-lifted Hermitian codes form a family of locally correctable codes over an alphabet that is significantly smaller than that obtained by Reed-Muller codes of similar constant rate, message length, and distance.

This paper presents a low-complexity network error correction (NEC) code for wireless relay networks (WRN), where the non-binary low density parity check (LDPC) code is jointly designed with a random network code. We give different transmission schemes under which the decoding complexity of the network code can be much reduced by dividing the transfer matrix into smaller decodable sub-matrices. We also propose a complexity optimization algorithm to the non-binary LDPC code based on an upper bound of message error probability. Simulations show that the complexity optimized codes can outperform the threshold optimized codes in higher SNR regime.

The study of self-testing and self-correcting programs leads to the search for robust characterizations of functions. Here the authors make this notion precise and show such a characterization for polynomials. From this characterization, the authors get the following applications. Simple and efficient self-testers for polynomial functions are constructed. The characterizations provide results in the area of coding theory by giving extremely fast and efficient error-detecting schemes for some well-known codes. This error-detection scheme plays a crucial role in subsequent results on the hardness of approximating some NP-optimization problems.

A code is called locally recoverable or repairable if 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. A common objective is to repair the node by downloading data from as few other storage node as possible. In this paper we study the basic error-correcting properties of a locally recoverable code. We provide tight upper and lower bound on the local-recoverability of a code that achieves capacity of a symmetric channel. In particular it is shown that, if the code-rate is e less than the capacity then for the optimal codes, the maximum number of codeword symbols required to recover one lost symbol must scale as log 1/∊.

International audience; While some write once memory (WOM) codes are inherently decodable, others require the added knowledge of the current generation in order to successfully decode the state of the memory. If there is no limit on the code length, n, a binary non-decodable t-write WOM code can be made decodable at an insignificant cost in terms of code rate by adding t - 1 cells to store the current generation after replicating the code enough times for the t - 1 cells to be of negligible weight. This justifies the research on non-decodable WOM codes. However, if n is bounded, the t - 1 additional cells may introduce a significant loss in terms of code rate. In this paper, we propose a new method to make non-decodable WOM codes decodable at a lower price when n is bounded. The main idea is to add cells that do not only store the current generation, but also additional data, by using a synchronous (t - 1)-write WOM code of length t - 1 or slightly above which does not contain the all-zero codeword. A bound on the rate of a simple family of synchronous WOM codes with n = t is given, as well as very short codes from this family. Better codes are then obtained by local manipulations of these codes. Finally, a construction of synchronous WOM codes with good properties is proposed to reach higher values of t.

A q-query Locally Decodable Code (LDC) is an error-correcting code that allows to read any particular symbol of the message by reading only q symbols of the codeword even if the codeword is adversary corrupted. In this paper we present a new approach for the construction of LDCs. We show that if there exists an irreducible representation (ρ, V) of G and q elements g1,g2,..., gq in G such that there exists a linear combination of matrices ρ(gi) that is of rank one, then we can construct a q-query Locally Decodable Code C:V-> FG. We show the potential of this approach by constructing constant query LDCs of sub-exponential length matching the best known constructions.

In this paper, fast-decodable lattice code constructions are designed for the nonorthogonal amplify-and-forward (NAF) multiple-input multiple-output (MIMO) channel. The constructions are based on different types of algebraic structures, e.g. quaternion division algebras. When satisfying certain properties, these algebras provide us with codes whose structure naturally reduces the decoding complexity. The complexity can be further reduced by shortening the block length, i.e., by considering rectangular codes called less than minimum delay (LMD) codes., 5 pages

An n-length block code C is said to be r-query locally correctable, if for any codeword x ∈ C, one can probabilistically recover any one of the n coordinates of the codeword x by querying at most r coordinates of a possibly corrupted version of x. It is known that linear codes whose duals contain 2-designs are locally correctable. In this article, we consider linear codes whose duals contain t-designs for larger t. It is shown here that for such codes, for a given number of queries r, under linear decoding, one can, in general, handle a larger number of corrupted bits. We exhibit to our knowledge, for the first time, a finite length code, whose dual contains 4-designs, which can tolerate a fraction of up to 0.567/r corrupted symbols as against a maximum of 0.5/r in prior constructions. We also present an upper bound that shows that 0.567 is the best possible for this code length and query complexity over this symbol alphabet thereby establishing optimality of this code in this respect. A second result in the article is a finite-length bound which relates the number of queries r and the fraction of errors that can be tolerated, for a locally correctable code that employs a randomized algorithm in which each instance of the algorithm involves t-error correction.

We propose an iterative full-rate code construction for multiple antenna channels, with 6Tx and 3Rx antennas. We start with two 3x 3 codes arising from a cyclic division algebra, and combine them to obtain a 6 x6 codeword. We provide a sufficient criterion for when the resulting code is fully diverse. Furthermore, this construction preserves fast-decodability of the original code. Accepted version

Describes a (d,k)=(1,8) runlength-limited (RLL) rate 8/12 code with fixed codeword length 12. The code is block-decodable; a codeword can be decoded without knowledge of preceding or succeeding codewords. The code belongs to the class of bounded delay block-decodable (BDB) codes with one symbol (8 bits) look-ahead. Due to its format, this code is particularly attractive for use in combination with error-correcting codes such as Reed-Solomon codes over the finite field GF(2/sup 8/). >

The performance of many existing communications systems can be improved simply by replacing the currently used forward error correction (FEC) code with a modern iteratively decodable FEC code. The potential improvements of adding modern FEC are even more pronounced for systems that do not currently employ any FEC. In this paper, we compare the performance of fast frequency hopping with simple diversity schemes using only symbol repetition and diversity schemes that also employ convolutional codes, short-block-length iteratively decodable codes, and long-block-length iteratively decodable codes. Both partial-band noise and multi-tone jamming channels are considered. The most powerful codes-namely, the long block length iteratively decodable codes-are shown to greatly improve link robustness while at the same time allow larger data rates than the traditional diversity approaches. In addition, it is demonstrated that these codes enable a system to realize the full benefit of independent tone hopping.

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 I´ of the coordinates are 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 2-query LDCs and LCCs over finite fields of prime order. Specifically, we prove a lower bound of the form p^{I©(I´d)} on the length of linear 2-query LCCs over $\F_p$, that encode messages of length d. Our bound improves over the known bound of $2^{I©(I´d)} \cite{GKST06, KdW04, DS07} 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. Corollaries of our main theorem are new incidence geometry results over finite fields. The first is an improvement to the Sylvester-Gallai theorem over finite fields \cite{SS10} and the second is a new analog of Beck's theorem over finite fields.

Codes that correct asymmetric errors have important applications in storage systems, including optical disks and Read Only Memories. 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 could sustain t asymmetric errors. Our main observation is that in contrast to symmetric errors, where the error probability of a codeword is context independent (since the error probability for 1s and 0s is identical), asymmetric errors are context dependent. For example, the all-1 codeword has a higher error probability than the all-0 codeword (since the only errors are 1 → 0). We call the existing codes uniform codes while we focus on the notion of nonuniform codes, namely, codes whose codewords can tolerate different numbers of asymmetric errors depending on their Hamming weights. The goal of nonuniform codes is to guarantee the reliability of every codeword, which is important in data storage to retrieve whatever one wrote in. We prove an almost explicit upper bound on the size of nonuniform asymmetric error correcting codes and present two general constructions. We also study the rate of nonuniform codes compared to uniform codes and show that there is a potential performance gain.

Locally decodable codes are error correcting codes that simultaneously provide efficient random-access to encoded data 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. Local decodability comes at the price of certain loss in terms of code efficiency. Specifically, locally decodable codes require longer codeword lengths than their classical counterparts. In this work we briefly survey the recent progress in constructions of locally decodable codes.

We survey known results regarding locally testable codes and locally testable proofs (known as PCPs), with emphasis on the length of these constructs. Local testability refers to approximately testing large objects based on a very small number of probes, each retrieving a single bit in the representation of the object. This yields super-fast approximate-testing of the corresponding property (i.e., be a codeword or a valid proof). We also review the related concept of local decodable codes. The survey consists of two independent (i.e., self-contained) parts that cover the same material at different levels of rigor and detail. Still, in spite of the repetitions, there may be a benefit in reading both parts.

A sender wishes to broadcast an n character word x in F^n (for a field F) to n receivers R_1,...,R_n. Every receiver has some side information on x consisting of a subset of the characters of x. The side information of the receivers is represented by a graph G on n vertices in which {i,j} is an edge if R_i knows x_j. In the index coding problem the goal is to encode x using a minimum number of characters in F in a way that enables every R_i to retrieve the ith character x_i using the encoded message and the side information. An index code is linear if the encoding is linear, and in this case the minimum possible length is known to be equal to a graph parameter called minrank (Bar-Yossef et al., FOCS'06). Several bounds on the minimum length of an index code for side information graphs G were shown in the study of index coding. However, the minimum length of an index code for the random graph G(n,p) is far from being understood. In this paper we initiate the study of the typical minimum length of a linear index code for G(n,p) over a field F. First, we prove that for every constant size field F and a constant p, the minimum length of a linear index code for G(n,p) over F is almost surely Omega(\sqrt{n}). Second, we introduce and study the following two restricted models of index coding: 1. A locally decodable index code is an index code in which the receivers are allowed to query at most q characters from the encoded message. 2. A low density index code is a linear index code in which every character of the word x affects at most q characters in the encoded message. Equivalently, it is a linear code whose generator matrix has at most q nonzero entries in each row., Comment: 16 pages

This work considers locally decodable codes in the computationally bounded channel model. The computationally bounded channel model, introduced by Lipton in 1994, views the channel as an adversary which is restricted to polynomial-time computation. Assuming the existence of IND-CPA secure public-key encryption, we present a construction of public-key locally decodable codes, with constant codeword expansion, tolerating constant error rate, with locality O(λ), and negligible probability of decoding failure, for security parameter λ. Hemenway and Ostrovsky gave a construction of locally decodable codes in the public-key model with constant codeword expansion and locality O(λ2), but their construction had two major drawbacks. The keys in their scheme were proportional to n, the length of the message, and their schemes were based on the F-hiding assumption. Our keys are of length proportional to the security parameter instead of the message, and our construction relies only on the existence of IND-CPA secure encryption rather than on specific number-theoretic assumptions. Our scheme also decreases the locality from O(λ2) to O(λ). Our construction can be modified to give a generic transformation of any private-key locally decodable code to a public-key locally decodable code based only on the existence of an IND-CPA secure public-key encryption scheme.

Despite its many applications, to program checking, probabilistically checkable proofs, locally testable and locally decodable codes, and cryptography, "algebraic property testing" is not well-understood. A significant obstacle to a better understanding, was a lack of a concrete definition that abstracted known testable algebraic properties and reflected their testability. This obstacle was removed by [Kaufman and Sudan, STOC 2008] who considered (linear) "affine-invariant properties", i.e., properties that are closed under summation, and under affine transformations of the domain. Kaufman and Sudan showed that these two features (linearity of the property and its affine-invariance) play a central role in the testability of many known algebraic properties. However their work does not give a complete characterization of the testability of affine-invariant properties, and several technical obstacles need to be overcome to obtain such a characterization. Indeed, their work left open the tantalizing possibility that locally testable codes of rate dramatically better than that of the family of Reed-Muller codes (the most popular form of locally testable codes, which also happen to be affine-invariant) could be found by systematically exploring the space of affine-invariant properties. In this work we rule out this possibility and show that general (linear) affine-invariant properties are contained in Reed-Muller codes that are testable with a slightly larger query complexity. A central impediment to proving such results was the limited understanding of the structural restrictions on affine-invariant properties imposed by the existence of local tests. We manage to overcome this limitation and present a clean restriction satisfied by affine-invariant properties that exhibit local tests. We do so by relating the problem to that of studying the set of solutions of a certain nice class of (uniform, homogenous, diagonal) systems of multivariate polynomial equations. Our main technical result completely characterizes (combinatorially) the set of zeroes, or algebraic set, of such systems.

Fast Maximum Likelihood Decodable Space-Time Block Codes (STBCs) have recently gained a lot of interest for use in wireless communication systems. Several strategies have been introduced in the literature to build such codes, among them we mention the conditional detection strategy, where the code matrix can be expressed as the sum of two Orthogonal STBCs by means of a unitary matrix. Thus, the decoder benefits from the orthogonality by estimating an orthogonal set of symbols assuming knowledge of the other set of symbols. Even if this strategy permits high rates, numerical optimization of the coding gain becomes unrealizable for high-order constellations. Another strategy has been proposed in the literature, the g-group decodable codes, where the minimization of the Maximum Likelihood (ML) metric can be made over several independent subsets of symbols. Moreover, the g-group decodability strategy enables us to optimize the coding gain for each subset of symbols separately which permits the optimization of the coding gain for high-order constellations. On the other hand, the rate of g-group decodable codes is limited. In this paper, we reformulate the problem of finding Unitary Weight (UW)-2-group decodable codes in a simpler way based on necessary and sufficient conditions. Then, a simple routine is used to search for the desired code. We determine the maximum achievable rate for a specified type of weight matrices.

In this paper, we consider coding schemes for computationally bounded channels, which can introduce an arbitrary set of errors as long as (a) the fraction of errors is bounded with high probability by a parameter p and (b) the process which adds the errors can be described by a sufficiently "simple" circuit. Codes for such channel models are attractive since, like codes for standard adversarial errors, they can handle channels whose true behavior is unknown or varying over time. For three classes of channels, we provide explicit, efficiently encodable/decodable codes of optimal rate where only inefficiently decodable codes were previously known. In each case, we provide one encoder/decoder that works for every channel in the class. Unique decoding for additive errors: We give the first construction of a poly-time encodable/decodable code for additive (a.k.a. oblivious) channels that achieve the Shannon capacity 1-H(p). List-decoding for online log-space channels: A space-S(N) bounded channel reads and modifies the transmitted codeword as a stream, using at most S(N) bits of workspace on transmissions of N bits. For constant S, this captures many models from the literature, including "discrete channels with finite memory" and "arbitrarily varying channels". We give an efficient code with optimal rate (arbitrarily close to 1-H(p)) that recovers a short list containing the correct message with high probability for channels which read and modify the transmitted codeword as a stream, using at most O(\log N) bits of workspace on transmissions of N bits. List-decoding for poly-time channels: For any constant c we give a similar list-decoding result for channels describable by circuits of size at most N^c, assuming the existence of pseudorandom generators.

International audience; In this paper, we describe constructions of majority logic decodable codes which stem out description of finite groups. To this end, we generalize some previous studies of Tonchev, Key and Moori on codes from finite groups. We also extend some results obtained by Rudolph for majority logic decodable codes. Finally, we describe applications of these codes in the area of soft-decoding techniques.

A locally testable code allows one to store vast amounts of data, where estimating the fraction of errors in the data takes roughly as much time as takes to read one bit of the data! If the fraction of errors is below a certain threshold, a locally decodeable code would allow one to recover every bit of the original message, again, in time which is roughly the time to read one bit of the data. Are such locally testable/decodeable codes of constant rate possible? So far we don't know, but surprisingly-good codes are known. Following, we survey some of the literature and discuss a connection between these notions to symmetric LDPC codes.

In this paper, we give surprisingly efficient algorithms for list-decoding and testing random linear codes. Our main result is that random sparse linear codes are locally list-decodable and locally testable in the high-error regime with only a constant number of queries. More precisely, we show that for all constants c> 0 and γ > 0, and for every linear code C ⊆ 0,1N which is: sparse: |C| ≤ Nc, and unbiased: each nonzero codeword in C has weight in (1/2 - N-γ, 1/2 + N-γ), C is locally testable and locally list-decodable from (1/2 - e)-fraction worst-case errors using only poly(1/e) queries to a received word. We also give subexponential time algorithms for list-decoding arbitrary unbiased (but not necessarily sparse) linear codes in the high-error regime. In particular, this yields the first subexponential time algorithm even for the problem of (unique) decoding random linear codes of inverse-polynomial rate from a fixed positive fraction of errors. Earlier, Kaufman and Sudan had shown that sparse, unbiased codes can be locally (unique) decoded and locally tested from a constant fraction of errors, where this constant fraction tends to 0 as the number of codewords grows. Our results significantly strengthen their results, while also having significantly simpler proofs. At the heart of our algorithms is a natural "self-correcting" operation defined on codes and received words. This self-correcting operation transforms a code C with a received word w into a simpler code C' and a related received word w', such that w is close to C if and only if w' is close to C'. Starting with a sparse, unbiased code C and an arbitrary received word w, a constant number of applications of the self-correcting operation reduces us to the case of local list-decoding and testing for the Hadamard code, for which the well known algorithms of Goldreich-Levin and Blum-Luby-Rubinfeld are available. This yields the constant-query local algorithms for the original code C. Our algorithm for decoding unbiased linear codes in subexponential time proceeds similarly. Applying the self-correcting operation to an unbiased code C and an arbitrary received word a super-constant number of times, we get reduced to the problem of learning noisy parities, for which non-trivial subexponential time algorithms were recently given by Blum-Kalai-Wasserman and Feldman-Gopalan-Khot-Ponnuswami. Our result generalizes a result of Lyubashevsky, which gave a subexponential time algorithm for decoding random linear codes of inverse-polynomial rate from random errors.

We investigate the construction of prefix-free and fix-free codes with specified codeword compositions. We present a polynomial time algorithm which constructs a fix-free code with the same codeword compositions as a given code for a special class of codes called distinct codes. We consider the construction of optimal fix-free codes which minimize the average codeword cost for general letter costs with uniform distribution of the codewords and present an approximation algorithm to find a near optimal fix-free code with a given constant cost.

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

We survey known results regarding locally testable codes and locally testable proofs (known as PCPs), with emphasis on the length of these constructs. Local testability refers to approximately testing large objects based on a very small number of probes, each retrieving a single bit in the representation of the object. This yields super-fast approximatetesting of the corresponding property (i.e., be a codeword or a valid proof). We also review the related concept of local decodable codes. The survey consists of two independent (i.e., self-contained) parts that cover the same material at different levels of rigor and detail. Still, in spite of the repetitions, there may be a benefit in reading both parts.

This paper describes recent results which revolve around the question of the rate attainable by families of error correcting codes that are locally testable. Emphasis is placed on motivating the problem of proving upper bounds on the rate of these codes and a number of interesting open questions for future research are suggested.

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

We study the local testability of linear codes. Our approach is based on a reformulation of this question in the language of tolerant linearity testing under a non-uniform distribution. We then study the question of linearity testing under non-uniform distributions directly, and give a sufficient criterion for linearity to be tolerantly testable under a given distribution.We show that several natural classes of distributions satisfy this criterion (such as product distributions and low Fourier-bias distributions), thus showing that linearity is tolerantly testable under these distributions. This in turn implies that the corresponding codes are locally testable. For the case of random sparse linear codes, we show the testability and decodability of such codes in the presence of very high noise rates. More precisely, we show that any linear code in F2n which is: - sparse (i.e., has only poly(n) codewords) - unbiased (i.e., each nonzero codeword has Hamming weight in (1/2- n-γ, 1/2 + n-γ for some constant γ ≥ 0) can be locally tested and locally list decoded from (1/2-e)-fraction errors using only poly(1/e) queries to the received word. This simultaneously simplifies and strengthens a result of Kaufman and Sudan, who gave a local tester and local (unique) decoder for such codes from some constant fraction of errors. For the case of Dual BCH codes, our algorithms can also be made to run in sublinear time. Building on the methods used for the local algorithms, we also give sub-exponential time algorithms for list-decoding arbitrary unbiased (but not necessarily sparse) linear codes in the high-error regime.

This chapter contains a detailed exposition of the point removal method for constructing locally decodable codes. The method can be broken into two parts. The first part is a reduction that shows how the existence of subsets of finite fields that simultaneously exhibit “nice” properties of two different kinds yields families of locally decodable codes with good parameters. The second part is a construction of “nice” subsets of finite fields.

A linear (q,δ, e, m(n))-locally decodable code (LDC) C: Fn → Fm(n) is a linear transformation from the vector space Fn to the space Fm(n) for which each message symbol xi can be recovered with probability at least 1/|F| + e 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 anm(n) = Ω(n2) 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.

We develop the algebraic theory behind the constructions of Yekhanin (2008) and Efremenko (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 algebraic 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, to appear in Computational Complexity