Time-space trade-offs for branching programs

AbstractBranching program depth and the logarithm of branching program complexity are lower bounds on time and space requirements for any reasonable model of sequential computation. In order to gain more insight to the complexity of branching programs and to the problems of time-space trade-offs one considers, on one hand, width-restricted and, on the other hand, depth-restricted branching programs. We present these computation models and the trade-off results already proved. We prove a new result of this type by presenting an effectively defined Boolean function whose complexity in depth-restricted one-time-only branching programs is exponential while its complexity even in width-2 branching programs is polynomial

An exponential lower bound for real-time branching programs

Branching programs are a general model of sequential computation. One of their computational features is their possibility to question (repeatedly) the information from each input bit. Real-time branching programs make at most n questions when computing on an input of length n. The restriction “real-time” allows to find a simple language which requires the lower bound 2√2n/8 on memory (= the state space)

A lower bound on branching programs reading some bits twice

AbstractBy (1, + k(n))-branching programs (b.p.'s) we mean those b.p.'s which during each of their computations are allowed to test at most k(n) input bits repeatedly. For a Boolean function computable within polynomial time a trade-off is presented between the size and the number of repeatedly tested input bits of any b.p. P computing the function. Namely, if at most k(n) repeated tests are allowed, where log2 n ⩽ k(n) ⩽ n(1000 log2 n), then the size of P is at least exp(Ω(n(k(n)log2 n))12). This is exponential whenever k(n) ⩽ nα for a fixed α < 1 and superpolynomial whenever k(n) = o(nlog32 n).The presented result is a step towards a superpolynomial lower bound for 2-b.p.'s which is an open problem since 1984 when the first superpolynomial lower bounds for 1-b.p.'s were proven (Wegener, 1988; Žák, 1984). The present result is an improvement on (Žák, 1995)

Pebbling, Entropy and Branching Program Size Lower Bounds

We contribute to the program of proving lower bounds on the size of branching programs solving the Tree Evaluation Problem introduced by Cook et. al. (2012). Proving a super-polynomial lower bound for the size of nondeterministic thrifty branching programs (NTBP) would separate $NL$ from $P$ for thrifty models solving the tree evaluation problem. First, we show that {\em Read-Once NTBPs} are equivalent to whole black-white pebbling algorithms thus showing a tight lower bound (ignoring polynomial factors) for this model. We then introduce a weaker restriction of NTBPs called {\em Bitwise Independence}. The best known NTBPs (of size $O(k^{h/2+1})$) for the tree evaluation problem given by Cook et. al. (2012) are Bitwise Independent. As our main result, we show that any Bitwise Independent NTBP solving $TEP_{2}^{h}(k)$ must have at least $\frac{1}{2}k^{h/2}$ states. Prior to this work, lower bounds were known for NTBPs only for fixed heights $h=2,3,4$ (See Cook et. al. (2012)). We prove our results by associating a fractional black-white pebbling strategy with any bitwise independent NTBP solving the Tree Evaluation Problem. Such a connection was not known previously even for fixed heights. Our main technique is the entropy method introduced by Jukna and Z{\'a}k (2001) originally in the context of proving lower bounds for read-once branching programs. We also show that the previous lower bounds given by Cook et. al. (2012) for deterministic branching programs for Tree Evaluation Problem can be obtained using this approach. Using this method, we also show tight lower bounds for any $k$-way deterministic branching program solving Tree Evaluation Problem when the instances are restricted to have the same group operation in all internal nodes.Comment: 25 Pages, Manuscript submitted to Journal in June 2013 This version includes a proof for tight size bounds for (syntactic) read-once NTBPs. The proof is in the same spirit as the proof for size bounds for bitwise independent NTBPs present in the earlier version of the paper and is included in the journal version of the paper submitted in June 201

Boolean Expression Diagrams

This paper presents a new data structure called Boolean Expression Diagrams (BEDs) for representing and manipulating Boolean functions. BEDs are a generalization of Binary Decision Diagrams (BDDs) which can represent any Boolean circuit in linear space and still maintain many of the desirable properties of BDDs. Two algorithms are described for transforming a BED into a reduced ordered BDD. One is a generalized version of the BDD apply-operator while the other can exploit the structural information of the Boolean expression. This ability is demonstrated by verifying that two di erent circuit implementations of a 16-bit multiplier implement the same Boolean function. Using BEDs, this veri cation problem is solved in less than a second, while using standard BDD techniques this problem is infeasible. Generally, BEDs are useful in applications, for example tautology checking, where the end-result as a reduced ordered BDD is small

Forms of representation for simple games: sizes, conversions and equivalences

Simple games are cooperative games in which the benefit that a coalition may have is always binary, i.e., a coalition may either win or loose. This paper surveys different forms of representation of simple games, and those for some of their subfamilies like regular games and weighted games. We analyze the forms of representations that have been proposed in the literature based on different data structures for sets of sets. We provide bounds on the computational resources needed to transform a game from one form of representation to another one. This includes the study of the problem of enumerating the fundamental families of coalitions of a simple game. In particular we prove that several changes of representation that require exponential time can be solved with polynomial-delay and highlight some open problems.Peer ReviewedPostprint (author’s final draft