Abstract

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

Highlights

  • Testable codes (LTCs) are error-correcting codes that can be tested very efficiently

  • A code is said to be an Locally testable codes (LTCs) if there exists a probabilistic algorithm, called a tester, that is given a proximity parameter ε > 0 and oracle access to an input string, makes a small number (e.g., poly(1/ε)) of queries to the input and is required to accept valid codewords, and reject with high probability input strings that are ε-far from being a codeword

  • The tester of a strong-LTC does not get a proximity parameter as an input, and is instead required to make only a constant number of queries and reject non-codewords with probability that is related to their distance from the code

Read more

Summary

Introduction

Testable codes (LTCs) are error-correcting codes that can be tested very efficiently. Throughout this work we will only consider codes with constant relative distance, and so our main parameter of interest is the length, which measures the amount of redundancy of information in each codeword By this criterion, constructing a strong-LTC with linear length (and constant relative distance) is the holy grail of designing efficient locally testable codes. Recently Viderman [23] constructed a strong-LTC with constant relative distance and quasilinear length (i.e., length k · polylogk) Another natural local property of codes is local decodability. Ben-Sasson et al [1] constructed a relaxed-LDC with nearly-linear length They showed that for every constant α > 0 there exists a relaxed-LDC (with constant relative distance) that maps k-bit messages to k1+α-bit codewords and has query complexity O 1/α2. While these relaxed-LDCs are dramatically shorter than any known LDC, they do not break the currently known lower bound on LDCs (cf. [17]), and it is it still an open question whether relaxed-LDC are a strict relaxation of LDCs

Obtaining Local Testability and Decodability Simultaneously
Strong Canonical PCPs of Proximity
Previous Works and Techniques
Our Techniques
Applications to Property Testing
Organization
Preliminaries
Error Correcting Codes
Local Testability and Decodability
Success Rate
Tensor Codes
PCPs of Proximity
The Main Construction
Establishing the Relaxed-LDC Property
Modified Relaxed Soundness
Warm-up
The General Case
Obtaining Average Smoothness
Establishing the Strong-LTC Property
Outline of the Tester and its Analysis
The point-line scPCPP consistency test
The Full Proof
Application to Property Testing
A Obtaining Strong LTCs from LIPS
B Concatenating Multiple Encodings of Strong LTCs
The common codeword consistency test
C Robustness of Tensor Codes
D Average Smoothness and Error Reduction for Relaxed LDCs
Full Text
Published version (Free)

Talk to us

Join us for a 30 min session where you can share your feedback and ask us any queries you have

Schedule a call