Read-once Branching Programs Research Articles

Lower bounds for restricted read-once parity branching programs

We prove the first lower bounds for restricted read-once parity branching programs with unlimited parity nondeterminism where for each input the variables may be tested according to several orderings. Namely, sums of k graph-driven ⊕ BP1s with polynomial size graph-orderings are under consideration. We prove lower bounds for the characteristic function of linear codes. We generalize a lower bound by Savický and Sieling (see [P. Savický, D. Sieling, A hierarchy result for read-once Branching programs with restricted parity nondeterminism, Theoret. Comput. Sci. 340 (2005) 594–605]) and recent results on graph-driven parity branching programs.

A hierarchy result for read-once branching programs with restricted parity nondeterminism

Restricted branching programs are considered in complexity theory in order to study the space complexity of sequential computations and in applications as a data structure for Boolean functions. In this paper ( ⊕ , k ) -branching programs and ( ∨ , k ) -branching programs are considered, i.e., branching programs starting with a ⊕ - (or ∨ -)node with a fan-out of k whose successors are k read-once branching programs. This model is motivated by the investigation of the power of nondeterminism in branching programs and of similar variants that have been considered as a data structure. Lower bound methods and hierarchy results for polynomial size ( ⊕ , k ) - and ( ∨ , k ) -branching programs with respect to k are presented.

A Lower Bound Technique for Nondeterministic Graph-Driven Read-Once-Branching Programs and Its Applications

We present a new lower bound technique for a restricted branching program model, namely for nondeterministic graph-driven read-once branching programs (g.d.-BP1s). The technique is derived by drawing a connection between ω-nondeterministic g.d.-BP1s and ω-nondeterministic communication complexity (for the nondeterministic acceptance modes ω∈{⋁,⋀,⊕}). We apply the technique in order to prove an exponential lower bound for integer multiplication for ω-nondeterministic well-structured g.d.-BP1s. (For ω=⊕ an exponential lower bound was already obtained in [5] by using a different technique.) Further, we use the lower bound technique to prove for an explicitly defined function which can be represented by polynomial size ω-nondeterministic BP1s that it has exponential complexity in the ω-nondeterministic well-structured g.d.-BP1 model for ω∈{⋁,⊕}. This answers an open question from Brosenne et al., whether the nondeterministic BP1 model is in fact more powerful than the well-structured graph-driven variant.

On multi-partition communication complexity

We study k-partition communication protocols, an extension of the standard two-party best-partition model to k input partitions. The main results are as follows. 1. A strong explicit hierarchy on the degree of non-obliviousness is established by proving that, using k + 1 partitions instead of k may decrease the communication complexity from Θ ( n ) to Θ (log k ). 2. Certain linear codes are hard for k -partition protocols even when k may be exponentially large (in the input size). On the other hand, one can show that all characteristic functions of linear codes are easy for randomized OBDDs. 3. It is proved that there are subfunctions of the triangle-freeness function and the function ⊕ Clique 3, n that are hard for multi-partition protocols. As an application, strongly exponential lower bounds on the size of nondeterministic read-once branching programs for these functions are obtained, solving an open problem of Razborov [Proceedings of eighth FCT NCS 529, Springer, 1991, pp. 47–60].

A lower bound for integer multiplication on randomized ordered read-once branching programs

We prove an exponential lower bound 2 Ω(n/ log n) on the size of any randomized ordered read-once branching program computing integer multiplication . Our proof depends on proving a new lower bound on Yao’s randomized one-way communication complexity of certain Boolean functions. It generalizes to some other models of randomized branching programs. In contrast, we prove that testing integer multiplication , contrary even to a nondeterministic situation, can be computed by randomized ordered read-once branching program in polynomial size. It is also known that computing the latter problem with deterministic read-once branching programs is as hard as factoring integers.

Functions that have read-once branching programs of quadratic size are not necessarily testable

A property of binary strings is constructed that has a representation by a collection of read-once branching programs of quadratic size but which is not ε-testable for some fixed ε>0. This shows that Newman's result [Proc. 41st FOCS, 2000, pp. 251–258] cannot be generalized to functions representable by read-once branching programs of polynomial size.

A very simple function that requires exponential size nondeterministic graph-driven read-once branching programs

Branching programs are a well-established computation model for Boolean functions, especially read-once branching programs (BP1s) have been studied intensively. A very simple function f in n 2 variables is exhibited such that both the function f and its negation ¬ f can be computed by Σ 3 p -circuits, the function f has nondeterministic BP1s (with one nondeterministic node) of linear size and ¬ f has size O( n 4) for oblivious nondeterministic BP1s but f requires nondeterministic graph-driven BP1s of size 2 Ω(n) . This answers an open question stated by Jukna, Razborov, Savický, and Wegener [Comput. Complexity 8 (1999) 357–370].

Approximation of boolean functions by combinatorial rectangles

This paper deals with the number of monochromatic combinatorial rectangles required to approximate a boolean function on a constant fraction of all inputs, where each rectangle may use its own partition of the input variables. The main result of the paper is that the number of rectangles required for the approximation of boolean functions in this model is very sensitive to the allowed error. There is an explicitly defined sequence of boolean functions fn on n variables such that fn has rectangle approximations with a constant number of rectangles and one-sided error 13+o(1) or two-sided error 14+o(1), but, on the other hand, fn requires exponentially many rectangles if the error bounds are decreased by an arbitrarily small constant.As applications of this result, the following separation results for read-once branching programs are obtained. The functions from the main result require only linear size for nondeterministic read-once branching programs and randomized read-once branching programs with two-sided error 13+o(1), while randomized read-once branching programs with constant two-sided error smaller than 13 and unambiguous nondeterministic read-once branching programs require exponential size.

Almost k-wise independence and hard Boolean functions

We construct Boolean functions (computable by polynomial-size circuits) with large lower bounds for read-once branching program (1-b.p.'s): a function in P with the lower bound 2 n−polylog( n) , a function in quasipolynomial time with the lower bound 2 n− O( log n) , and a function in LINSPACE with the lower bound 2 n− log n− O(1) . Our constructions are simpler than those of Andreev et al. (Electronic Colloq. on Computational Complexity, TR97-053, 1997), as we apply the idea of almost k-wise independence more directly, without the use of discrepancy set generators for large affine subspaces. The simplicity of our constructions also allows us to observe that there exists a Boolean function in AC 0[2] (computable by a depth 3, polynomial-size circuit over the basis {∧,⊕,1}) with the optimal lower bound 2 n− log n− O(1) for 1-b.p.'s.

Complexity Theoretical Results on Nondeterministic Graph-driven Read-Once Branching Programs

Branching programs are a well-established computation model for boolean functions, especially read-once branching programs (BP1s) have been studied intensively. Recently two restricted nondeterministic (parity) BP1 models, called nondeterministic (parity) graph-driven BP1s and well-structured nondeterministic (parity) graph-driven BP1s, have been investigated. The consistency test for a BP-model M is the test whether a given BP is really a BP of model M. Here it is proved that the consistency test is co-NP-complete for nondeterministic (parity) graph-driven BP1s. Moreover, a lower bound technique for nondeterministic graph-driven BP1s is presented. The method generalizes a technique for the well-structured model and is applied in order to answer in the affirmative the open question whether the model of nondeterministic graph-driven BP1s is a proper restriction of nondeterministic BP1s (with respect to polynomial size).

Read-Once Branching Programs, Rectangular Proofs of the Pigeonhole Principle and the Transversal Calculus

We investigate read-once branching programs for the following search problem: given a Boolean m × n matrix with m > n, find either an all-zero row, or two 1’s in some column. Our primary motivation is that this models regular resolution proofs of the pigeonhole principle $$PHP^{m}_{n}$$, and that for m > n2 no lower bounds are known for the length of such proofs. We prove exponential lower bounds (for arbitrarily large m!) if we further restrict this model by requiring the branching program either to finish one row of queries before asking queries about another row (the row model) or put the dual column restriction (the column model).Then we investigate a special class of resolution proofs for $$PHP^{m}_{n}$$ that operate with positive clauses of rectangular shape; we call this fragment the rectangular calculus. We show that all known upper bounds on the size of resolution proofs of $$PHP^{m}_{n}$$ actually give rise to proofs in this calculus and, inspired by this fact, also give a remarkably simple “rectangular” reformulation of the Haken–Buss–Turan lower bound for the case m ≪ n2. Finally we show that the rectangular calculus is equivalent to the column model on the one hand, and to transversal calculus on the other hand, where the latter is a natural proof system for estimating from below the transversal size of set families. In particular, our exponential lower bound for the column model translates both to the rectangular and transversal calculi.

On uncertainty versus size in branching programs

We propose an information-theoretic approach to proving lower bounds on the size of branching programs. The argument is based on Kraft type inequalities for the average amount of uncertainty about (or entropy of) a given input during the various stages of computation. The uncertainty is measured by the average depth of so-called ‘splitting trees’ for sets of inputs reaching particular nodes of the program.We first demonstrate the approach for read-once branching programs. Then, we introduce a strictly larger class of so-called ‘balanced’ branching programs and, using the suggested approach, prove that some explicit Boolean functions cannot be computed by balanced programs of polynomial size. These lower bounds are new since some explicit functions, which are known to be hard for most previously considered restricted classes of branching programs, can be easily computed by balanced branching programs of polynomial size.

Testing Membership in Languages that Have Small Width Branching Programs

Combinatorial property testing, initiated formally by Goldreich, Goldwasser, and Ron in [J. ACM, 45 (1998), pp. 653--750] and inspired by Rubinfeld and Sudan [SIAM J. Comput., 25 (1996), pp. 252--271], deals with the following relaxation of decision problems: Given a fixed property and an input x, one wants to decide whether x has the property or is "far" from having the property. The main result here is that, if ${\cal G}= \{ g_n:\{0,1\}^n \rightarrow \{0,1\} \}$ is a family of Boolean functions which have oblivious read-once branching programs of width w, then, for every n and $\epsilon > 0$, there is a randomized algorithm that always accepts every $x \in \{0,1\}^n$ if $g_n(x)=1$ and rejects it with high probability if at least $\epsilon n$ bits of x should be modified in order for it to be in gn-1 (1). The algorithm makes $(\frac{2^{w}}{\epsilon})^{O(w)}$ queries. In particular, for constant $\epsilon$ and w, the query complexity is O(1). This generalizes the results of Alon et al.\ [Proceedings of the40th IEEE Symposium on Foundations of Computer Science, IEEE Computer Society, 1999, pp. 645--655] asserting that regular languages are $\epsilon$-testable for every $\epsilon > 0$.

Decision tree approximations of Boolean functions

Decision trees are popular representations of Boolean functions. We show that, given an alternative representation of a Boolean function f, say as a read-once branching program, one can find a decision tree T which approximates f to any desired amount of accuracy. Moreover, the size of the decision tree is at most that of the smallest decision tree which can represent f and this construction can be obtained in quasi-polynomial time. We also extend this result to the case where one has access only to a source of random evaluations of the Boolean function f instead of a complete representation. In this case, we show that a similar approximation can be obtained with any specified amount of confidence (as opposed to the absolute certainty of the former case.) This latter result implies proper PAC-learnability of decision trees under the uniform distribution without using membership queries.

On the size of randomized OBDDs and read-once branching programs for k -stable functions

In this paper, a simple technique which unifies the known approaches for proving lower bound results on the size of deterministic, nondeterministic, and randomized OBDDs and kOBDDs is described.¶As an application of this technique, a generic lower bound on the size of randomized OBDDs with bounded error is established for a class of functions which has been studied in the literature on branching programs for a long time. These functions have been called “k-stable” by Jukna. It follows that several standard functions are not contained in the analog of the class BPP for OBDDs. Furthermore, exponential lower bounds on the size of randomized kOBDDs are presented.¶It is well known that k-stable functions with large k are hard for deterministic read-once branching programs. This is no longer true in the randomized case. It is shown here that a certain k-stable function due to Jukna, Razborov, Savický, and Wegener has randomized branching programs of polynomial size, even with zero error. It follows that $ {\rm P \subsetneqq ZPP \cap NP \cap coNP} $ for the analogs of these classes defined in terms of the size of read-once branching programs.

On BPP versus [formula omitted] for ordered read-once branching programs

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 q n,R n such that: (1) q n : {0,1} n→{0,1} belongs to BPP⧹( NP∪ coNP) in the context of OBDDs; (2) R n : {0,1} n→{0,1} belongs to PP⧹( BPP∪ NP∪ coNP) in the context of OBDDs. Both of these functions are not in AC 0 .

Restricted Nondeterministic Read-Once Branching Programs and an Exponential Lower Bound for Integer Multiplication

Branching programs are a well established computation model for Boolean functions, especially read-once branching programs have been studied intensively. In this paper the expressive power of nondeterministic read-once branching programs, more precisely the class of functions representable in polynomial size, is investigated. For that reason two restricted models of nondeterministic read-once branching programs are defined and a lower bound method is presented. Furthermore, the first exponential lower bound for integer multiplication on the size of a nondeterministic nonoblivious read-once branching program model is proven.

An Improved Hierarchy Result for Partitioned BDDs

One of the great challenges of complexity theory is the problem of analyzing the dependence of the complexity of Boolean functions on the resources nondeterminism and randomness. So far this problem could be solved only for very few models of computation. For so-called partitioned binary decision diagrams , which are a restricted variant of nondeterministic read-once branching programs, Bollig and Wegener have proven an astonishing hierarchy result which shows that the smallest possible decrease of the available amount of nondeterminism may incur an exponential blow-up of the branching program size. They have shown that k -partitioned BDDs which may nondeterministically choose between k alternative subprograms may be exponentially larger than (k+1) -partitioned BDDs for the same function if k = o(( log n / log log n) 1/2 ) , where n is the input size. In this paper an improved hierarchy result is established which still works if the number of nondeterministic decisions is O((n/ log 1+e n) 1/4 ) , where e > 0 is an arbitrary small constant.

On P versus NP $ \cap $ co-NP for decision trees and read-once branching programs

It is known that if a Boolean function f in n variables has a DNF and a CNF of size $ \le N $ then f also has a (deterministic) decision tree of size exp(O(log n log2 N)). We show that this simulation cannot be made polynomial: we exhibit explicit Boolean functions f that require deterministic trees of size exp $ (\Omega({\rm log^2} N)) $ where N is the total number of monomials in minimal DNFs for f and ¬f. Moreover, we exhibit new examples of explicit Boolean functions that require deterministic read-once branching programs of exponential size whereas both the functions and their negations have small nondeterministic read-once branching programs. One example results from the Bruen—Blokhuis bound on the size of nontrivial blocking sets in projective planes: it is remarkably simple and combinatorially clear. Other examples have the additional property that f is in AC0.

Linear codes are hard for oblivious read-once parity branching programs

We show that the characteristic functions of linear codes are exponentially hard for the model of oblivious read-once branching programs with parity accepting mode, known also as Parity OBDDs. The proof is extremely simple, and employs a particular combinatorial property of linear codes—their universality.