Bounded-width polynomial-size branching programs recognize exactly those languages in NC1

AbstractWe show that any language recognized by an NC1 circuit (fan-in 2, depth O(log n)) can be recognized by a width-5 polynomial-size branching program. As any bounded-width polynomial-size branching program can be simulated by an NC1 circuit, we have that the class of languages recognized by such programs is exactly nonuniform NC1. Further, following Ruzzo (J. Comput. System Sci. 22 (1981), 365–383) and Cook (Inform. and Control 64 (1985) 2–22), if the branching programs are restricted to be ATIME(logn)-uniform, they recognize the same languages as do ATIME(log n)-uniform NC1 circuits, that is, those languages in ATIME(log n). We also extend the method of proof to investigate the complexity of the word problem for a fixed permutation group and show that polynomial size circuits of width 4 also recognize exactly nonuniform NC1

BOUNDED-WIDTH POLYNOMIAL-SIZE BRANCHING PROGRAMS RECOGNIZE EXACTLY THOSE LANGUAGES IN NC

AbstractWe show that any language recognized by an NC1 circuit (fan-in 2, depth O(log n)) can be recognized by a width-5 polynomial-size branching program. As any bounded-width polynomial-size branching program can be simulated by an NC1 circuit, we have that the class of languages recognized by such programs is exactly nonuniform NC1. Further, following Ruzzo (J. Comput. System Sci. 22 (1981), 365–383) and Cook (Inform. and Control 64 (1985) 2–22), if the branching programs are restricted to be ATIME(logn)-uniform, they recognize the same languages as do ATIME(log n)-uniform NC1 circuits, that is, those languages in ATIME(log n). We also extend the method of proof to investigate the complexity of the word problem for a fixed permutation group and show that polynomial size circuits of width 4 also recognize exactly nonuniform NC1

Leaf languages and string compression

AbstractTight connections between leaf languages and strings compressed by straight-line programs (SLPs) are established. It is shown that the compressed membership problem for a language L is complete for the leaf language class defined by L via logspace machines. A more difficult variant of the compressed membership problem for L is shown to be complete for the leaf language class defined by L via polynomial time machines. As a corollary, it is shown that there exists a fixed linear visibly pushdown language for which the compressed membership problem is PSPACE-complete. For XML languages, it is shown that the compressed membership problem is coNP-complete.Furthermore it is shown that the embedding problem for SLP-compressed strings is hard for PP (probabilistic polynomial time)

An algebra and a logic for NC1

Presented here are an algebra and a logic characterizing the complexity class NC1, which consists of functions computed by uniform families of polynomial size, log depth circuits. In both characterizations, NC1 functions are regarded as functions from one class of finite relational structures to another. In the algebraic characterization a recursion scheme called upward tree recursion is applied to a class of simple functions. In the logical characterization, first-order logic is augmented by an operator for defining relations by primitive recursion where it is assumed that every structure has an underlying relation BIT giving the binary representations of integers.Peer Reviewedhttp://deepblue.lib.umich.edu/bitstream/2027.42/28501/1/0000298.pd

Delegating computation reliably : paradigms and constructions

Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2009.Cataloged from PDF version of thesis.Includes bibliographical references (p. 285-297).In an emerging computing paradigm, computational capabilities, from processing power to storage capacities, are offered to users over communication networks as a service. This new paradigm holds enormous promise for increasing the utility of computationally weak devices. A natural approach is for weak devices to delegate expensive tasks, such as storing a large file or running a complex computation, to more powerful entities (say servers) connected to the same network. While the delegation approach seems promising, it raises an immediate concern: when and how can a weak device verify that a computational task was completed correctly? This practically motivated question touches on foundational questions in cryptography and complexity theory. The focus of this thesis is verifying the correctness of delegated computations. We construct efficient protocols (interactive proofs) for delegating computational tasks. In particular, we present: e A protocol for delegating any computation, where the work needed to verify the correctness of the output is linear in the input length, polynomial in the computation's depth, and only poly-logarithmic in the computation's size. The space needed for verification is only logarithmic in the computation size. Thus, for any computation of polynomial size and poly-logarithmic depth (the rich complexity class N/C), the work required to verify the correctness of the output is only quasi-linear in the input length. The work required to prove the output's correctness is only polynomial in the original computation's size. This protocol also has applications to constructing one-round arguments for delegating computation, and efficient zero-knowledge proofs. * A general transformation, reducing the parallel running time (or computation depth) of the verifier in protocols for delegating computation (interactive proofs) to be constant. Next, we explore the power of the delegation paradigm in settings where mutually distrustful parties interact. In particular, we consider the settings of checking the correctness of computer programs and of designing error-correcting codes. We show: * A new methodology for checking the correctness of programs (program checking), in which work is delegated from the program checker to the untrusted program being checked. Using this methodology we obtain program checkers for an entire complexity class (the class of N/C¹-computations that are WNC-hard), and for a slew of specific functions such as matrix multiplication, inversion, determinant and rank, as well as graph functions such as connectivity, perfect matching and bounded-degree graph isomorphism. * A methodology for designing error-correcting codes with efficient decoding procedures, in which work is delegated from the decoder to the encoder. We use this methodology to obtain constant-depth (AC⁰) locally decodable and locally-list decodable codes. We also show that the parameters of these codes are optimal (up to polynomial factors) for constant-depth decoding.by Guy N. Rothblum.Ph.D