Conference Paper

Separating the Eraser Turing Machine Classes L

Authors:
To read the full-text of this research, you can request a copy directly from the authors.

No full-text available

Request Full-text Paper PDF

To read the full-text of this research,
you can request a copy directly from the authors.

... Hence, the traditional approach results in reducibility concepts which enable to relate merely highly similar problems (e.g., BW96]). Since complexity classes de ned by such restricted models are interesting for the theory { they occur in connection with our limited abilities in proving lower bounds e.g., KMW88,KW87,Mei89] { and of practical importance { ordered binary decision diagrams are the state of the art data structure for computer aided circuit design Bry86] { it is highly desirable to develop more powerful reducibility concepts. Here, we consider the case of complexity classes de ned by ordered binary decision diagrams (OBDDs, i.e., read-once binary decision diagrams with a xed variable ordering). ...
... In KMW88], it was proven that the function PERM requires exponentially large OBDDs for any variable ordering. (This lower bound holds even for a more general model). ...
Article
Full-text available
Reducibility concepts are fundamental in complexity theory. Usually, they are defined as follows: A problem Π is reducible to a problems Σ if Π can be computed using a program or device for Σ as a subroutine. However, this approach has its limitations if restricted computational models are considered. In the case of ordered binary decision diagrams (OBDDs), it allows the use of merely the almost unmodified original program for the subroutine. Here we propose a new reducibility for OBDDs: We say that Π is reducible to Σ if and OBDD for Π can be constructed by applying a sequence of elementary operations to an OBDD for Σ. In contrast to traditional reducibility notions, the newly introduced reduction is able to reflect the real needs of a reducibility concept in the context of OBDD-based complexity classes: it allows the reduction of problems to others which are computable with the same amount of OBDD-resources and it gives a tool to carry over lower and upper bounds.
Conference Paper
We investigate the width complexity of nondeterministic unitary OBDDs (NUOBDDs). Firstly, we present a generic lower bound on their widths based on the size of strong 1-fooling sets. Then, we present classically “cheap” functions that are “expensive” for NUOBDDs and vice versa by improving the previous gap. We also present a function for which neither classical nor unitary nondeterminism does help. Moreover, based on our results, we present a width hierarchy for NUOBDDs. Lastly, we provide the bounds on the widths of NUOBDDs for the basic Boolean operations negation, union, and intersection.
Conference Paper
In proving exponential lower and polynomial upper bounds for parity decision trees and collecting similar bounds for nondeterministic and co-nondeterministic decision trees we completely separate the complexity classes related to polynomial size deterministic, nondeterministic, co-nondeterministic, parity, and alternating decision trees.
Article
This work is settled in the area of complexity theory for restricted variants of branching programs. Today, branching programs can be considered one of the standard nonuniform models of computation. One reason for their popularity is that they allow to describe computations in an intuitively straightforward way and promise to be easier to analyze than the traditional models. In complexity theory, we are mainly interested in upper and lower bounds on the size of branching programs. Although proving superpolynomial lower bounds on the size of general branching programs still remains a challenging open problem, there has been considerable success in the study of lower bound techniques for various restricted variants, most notably perhaps read-once branching programs and OBDDs (ordered binary decision diagrams). Surprisingly, OBDDs have also turned out to be extremely useful in practical applications as a data structure for Boolean functions. So far, research has concentrated on determinis...
Article
. We prove that the graph of integer multiplication requires nondeterministic read-k-times branching programs of exponential size. On the other hand we show that one can add polynomially many integers by small deterministic read-once-only branching programs. This shows that the reason for the hardness of multiplication is not the necessity to add many integers (and hence, to get rid of the carry numbers) but the necessity to add different subsets of these integers. Key words. Branching programs, integer addition, integer multiplication, linear codes, circuit complexity, lower bounds problem. 1. Introduction It is known that the graph of multiplication is hard for depth-2 threshold circuits (Hajnal et al. 1987) and for AC 0 circuits (Buss 1992). In this paper 2 we prove that the graph of integer multiplication function is hard for non-deterministic read-k-times branching programs. Read-k-times branching programs have gained a considerable attention during the last decade. There a...
Conference Paper
We show that the satisfiability problem for bounded error probabilistic ordered branching programs is NP-complete. If the error is very small however (more precisely, if the error is bounded by the reciprocal of the width of the branching program), then we have a polynomial-time algorithm for the satisfiability problem
Article
Ordered binary decision diagrams (OBDDs) are one of the most common dynamic data structures for Boolean functions. Among the many areas of application are hardware verification, model checking, and symbolic graph algorithms. Threshold functions are the basic functions for discrete neural networks and are used as building blocks in the design of some symbolic graph algorithms. In this paper the first exponential lower bound on the size of a more general model than OBDDs and the first nontrivial asymptotically optimal bound on the OBDD size for a threshold function are presented.
Article
Ordered binary decision diagrams (OBDDs) are one of the most common dynamic data structures for Boolean functions. Nevertheless, many basic graph problems are known to be PSPACE-hard if their input graphs are represented by OBDDs. Computing the set of nodes that are reachable from some source s∈V in a digraph G=(V,E) is an important problem in computer-aided design, hardware verification, and model checking. Until now only exponential lower bounds on the space complexity of a restricted class of OBDD-based algorithms for the reachability problem have been known. Here, the result is extended by presenting an exponential lower bound for the general reachability problem. As a by-product a general exponential lower bound is obtained for the computation of OBDDs representing all connected node pairs in a graph, the transitive closure.
Article
Using algebraic arguments we derive lower bounds for parity branching programs. Several exponential lower bounds on the width of linear length bounded oblivious parity branching programs are obtained, so for the graph accessibility problem of directed graphs, and the word problem of free groups and one-relator-groups of finite rank. Using well-known results on the simulation of logspace-bounded Turing machines by sequences of branching programs we complete the separation of the complexity classes L, NL, co-NL, ⊕L, AL=P for oblivious Turing machines of linear access time.
Article
It is proved that oblivious simultaneously linear access-time and logarithmic space-bounded nondeterministic Turing machines are more powerful than deterministic ones. All the corresponding complexity classes are separated from each other
Article
In the following new types of branching programs, so-called Ω-branching programs, , are introduced. The complexity classes related to polynomial-size Ω-branching programs will be completely classified. In addition to identifying a new class {⊕} − BP = ⊕L/poly between L/poly and P/poly, new characterizations of such fundamental space complexity classes like NL/poly = co-NL/poly and P/poly are obtained. Using these characterizations we relate the complexity of the mentioned classes to those of some extremely restricted problems resembling the graph accessibility problem.
Article
Input oblivious decision graphs of linear length are considered. Among other concerns the computational complexity of three graph accessibility problems and the word problem of the free group are investigated. Several exponential lower bounds are proved.
Article
Full-text available
We develop a theory of communication within branching programs that provides exponential lower bounds on the size of branching programs that are bounded alternating. Our theory is based on the algebraic concept of Ω-branching programs, ω: ℕ → ℝ, a semiring homomorphism, that generalizes ordinary branching programs, Ω-branching programs [M2] andMOD p-branching programs [DKMW]. Due to certain exponential lower and polynomial upper bounds on the size of bounded alternating ω-branching programs we are able to separate the corresponding complexity classesNℒba ,co-Nℒba ⊕ℒba , andMOD p -ℒba ,p prime, from each other, and from that classes corresponding to oblivious linear length-bounded branching programs investigated in the past.
Conference Paper
We present a survey of the communication point of view for a complexity lower bounds proof technique for classical (deterministic, nondeterministic and randomized) and quantum models of branching programs.
Chapter
We present a new lower bound argument for oblivious parity-branching programs which allows to prove exponential lower bounds on the width if the length is restricted to be linear or at most o(n · log(n)). This solves an open problem because "Cut & Paste" arguments which provided bounds of the same quality in the case of determinism, nondeterminism, and co-nondeterminism [AM86] [KMW89] do not work in the case of parity-acceptation. Our technique is applicable to some well-known decision problems such as the graph-accessibility-problem of directed graphs, and the word problems of free groups of finite rank. Using well-known results on the simulation of logspace-bounded Turing machines by sequences of branching programs we give at least the complete separation of the complexity classes L, NL, co-NL, ⊕L, and AL=P for oblivious Turing machines of linear access time.
Article
We first consider the so-called (1, +s)-branching programs in which along every consistent path at most s variables are tested more than once. We prove that any such program computing a characteristic function of a linear code C has size at least ), where d1 and d2 are the minimal distances of C and its dual C⊥. We apply this criterion to explicit linear codes and obtain a super-polynomial lower bound for .Then we introduce a natural generalization of read-k-times and (1, +s)-branching programs that we call semantic branching programs. These programs correspond to corrupting Turing machines which, unlike eraser machines, are allowed to read input bits even illegally, i.e. in excess of their quota on multiple readings, but in that case they receive in response an unpredictably corrupted value. We generalize the above-mentioned bound to the semantic case, and also prove exponential lower bounds for semantic read-once nondeterministic branching programs.
Article
Full-text available
A syntactic read-k-times branching program has the restriction that no variable occurs more than k times on any path (whether or not consistent) of the branching program. We first extend the result in [31], to show that the "n/2 clique only function", which is easily seen to be computable by deterministic polynomial size read-twice programs, cannot be computed by nondeterministic polynomial size read-once programs, although its complement can be so computed. We then exhibit an explicit Boolean function f such that every nondeterministic syntactic read-k-times branching program for computing f has size exp {Mathematical expression}
Conference Paper
We investigate the question whether equipping some of the nodes of a width-bounded branching program with devices for evaluating Boolean functions does increase its computational power. In contrast to the situation for unbounded width branching programs, in the bounded width case we have to negate this question generalizing a result of Barrington.
Conference Paper
Full-text available
By means of algebraical rank arguments we derive some exponential lower bounds on the size of bounded alternating -branching programs. Together with some polynomial upper bounds these lower bounds make possible the complete separation of the restricted complexity classes NL ba, co-NL ba, L ba, MOD p-L ba, p prime.
Article
For (1,+k)-branching programs and read-k-times branching programs syntactic and nonsyntactic variants can be distinguished. The nonsyntactic variants correspond in a natural way to sequential computations with restrictions on reading the input while lower bound proofs are easier for the syntactic variants. In this paper it is shown that nonsyntactic (1,+k)-branching programs are really more powerful than syntactic (1,+k)-branching programs by presenting an explicitly defined function with polynomial size nonsyntactic (1,+1)-branching programs but only exponential size syntactic (1,+k)-branching programs. Another separation of these variants of branching programs is obtained by comparing the complexity of the satisfiability test for both variants.
Article
We show that the satisfiability problem for bounded-error probabilistic ordered branching programs is \NP -complete. If the error is very small, however (more precisely, if the error is bounded by the reciprocal of the width of the branching program), then we have a polynomial-time algorithm for the satisfiability problem.
Article
By proving exponential lower and polynomial upper bounds for parity decision trees and collecting similar bounds for nondeterministic and co-nondeterministic decision trees, the complexity classes related to polynomial-size deterministic, nondeterministic, co-nondeterministic, parity, and alternating decision trees are completely separated. Considering alternating decision trees, it is shown that the number of alternations between, say, ⋎-nodes and ⋏-nodes strongly influences their computational power.
Article
We investigate the relationship between probabilistic and nondeterministic complexity classes PP, BPP, NP and coNP with respect to ordered read-once branching programs (OBDDs). We exhibit two explicit Boolean functions qn; Rn such that: (1) qn : {0,1}n → { 0,1} belongs to BPP (NP (semi-circle up) coNP) in the context of OBDDs; (2) Rn : {0,1}n → {0,1} belongs to PP \ (BPP(semi-circle up) NP (semi-circle up) coNP) in the context of OBDDs. Both of these functions are not in AC0.
Article
A Boolean function in n variables is presented that is computable in depth 2 monotone AC0 and has prime implicants of length 2 only but requires 2Ω(√n) size read-once branching programs. The function considered is defined using (1, 1)-disjoint Boolean sums and the solution of the famous problem of Zarankiewicz.
Preprint
Full-text available
We prove that the graph of integer multiplication requires non-determi- nistic read-k-times branching programs of exponential size. On the other hand we show that one can add polynomially many integers by small deter- ministic read-once-only branching programs. This shows that the reason for the hardness of multiplication is not the necessity to add many in- tegers (and hence, to get rid of the carry numbers) but the necessity to add different subsets of these integers.
ResearchGate has not been able to resolve any references for this publication.