Read-once Branching Programs Research Articles

Perspective on complexity measures targeting read-once branching programs

A model of computation for which reasonable yet still incomplete lower bounds are known is the read-once branching program. Here variants of complexity measures successful in the study of read-once branching programs are defined and studied. Some new or simpler proofs of known bounds are uncovered. Branching program resources and the new measures are compared extensively. The new variants are developed in part in the hope of tackling read-k branching programs for the tree evaluation problem [8]. Other computation problems are studied as well. In particular, a common view of a function studied by Gál [11] and a function studied by Bollig and Wegener [3] leads to the general combinatorics of blocking sets. Technical combinatorial results of independent interest are obtained. New leads towards further progress are discussed. An exponential lower bound for non-deterministic read-k branching programs for the GEN function [17] is also derived, independently from the new measures.

A Polynomial-Time Construction of a Hitting Set for Read-Once Branching Programs of Width 3

Recently, an interest in constructing pseudorandom or hitting set generators for restricted branching programs has increased, which is motivated by the fundamental issue of derandomizing space-bounded computations. Such constructions have been known only in the case of width 2 and in very restricted cases of bounded width. In this paper, we characterize the hitting sets for read-once branching programs of width 3 by a so-called richness condition. Namely, we show that such sets hit the class of read-once conjunctions of DNF and CNF (i.e. the weak richness). Moreover, we prove that any rich set extended with all strings within Hamming distance of 3 is a hitting set for read-once branching programs of width 3. Then, we show that any almost O(log n)-wise independent set satisfies the richness condition. By using such a set due to Alon et al. (1992) our result provides an explicit polynomial-time construction of a hitting set for read-once branching programs of width 3 with acceptance probability ɛ > 5/6. We announced this result at conferences more than ten years ago, including only proof sketches, which motivated a number of subsequent results on pseudorandom generators for restricted read-once branching programs. This paper contains our original detailed proof that has not been published yet.

On Tseitin Formulas, Read-Once Branching Programs and Treewidth

We show that any nondeterministic read-once branching program that decides a satisfiable Tseitin formula based on an n × n grid graph has size at least 2Ω(n). Then using the Excluded Grid Theorem by Robertson and Seymour we show that for an arbitrary graph G(V, E) any nondeterministic read-once branching program that computes a satisfiable Tseitin formula based on G has size at least $2^{\Omega (\text {tw}(G)^{\delta })}$ for all δ < 1/36, where tw(G) is the treewidth of G (for planar graphs and some other classes of graphs the statement holds for δ = 1). We apply the mentioned results to the analysis of the complexity of derivations in the proof system OBDD(∧,reordering) and show that any OBDD(∧,reordering)-refutation of an unsatisfiable Tseitin formula based on a graph G has size at least $2^{\Omega (\text {tw}(G)^{\delta })}$ . We also show an upper bound O(|E|2pw(G)) on the size of OBDD representations of a satisfiable Tseitin formula based on G and an upper bound $O(|E||V| 2^{\text {pw}(G)}+|\text {TS}_{G,c}|^{2})$ on the size of OBDD(∧)-refutation of an unsatisifable Tseitin formula TSG, c, where pw(G) is the pathwidth of G.

Special Section on the Fiftieth Annual ACM Symposium on Theory of Computing (STOC 2018)

This issue of SICOMP contains 10 specially selected papers from the Fiftieth Annual ACM Symposium on Theory of Computing, otherwise known as STOC 2018, held June 25 to 29 in Los Angeles, California...

Coin Theorems and the Fourier Expansion

In this note we compare two measures of the complexity of a class $\mathcal F$ of Boolean functions studied in (unconditional) pseudorandomness: $\mathcal F$'s ability to distinguish between biased and uniform coins (the coin problem), and the norms of the different levels of the Fourier expansion of functions in $\mathcal F$ (the Fourier growth). We show that for coins with low bias $\varepsilon = o(1/n)$, a function's distinguishing advantage in the coin problem is essentially equivalent to $\varepsilon$ times the sum of its level $1$ Fourier coefficients, which in particular shows that known level $1$ and total influence bounds for some classes of interest (such as constant-width read-once branching programs) in fact follow as a black-box from the corresponding coin theorems, thereby simplifying the proofs of some known results in the literature. For higher levels, it is well-known that Fourier growth bounds on all levels of the Fourier spectrum imply coin theorems, even for large $\varepsilon$, and we discuss here the possibility of a converse.

Pseudorandom Pseudo-distributions with Near-Optimal Error for Read-Once Branching Programs

Nisan [Combinatorica, 12 (1992), pp. 449--461] constructed a pseudorandom generator for length $n$, width $n$ read-once branching programs (ROBPs) with error $\varepsilon$ and seed length $O(\log^2...

Simple Optimal Hitting Sets for Small-Success RL

We give a simple explicit hitting set generator for read-once branching programs of width $w$ and length $r$ with known variable order and acceptance probability at least $\epsilon$. When $r = w$, our generator has seed length $O(\log^2 r + \log(1/\epsilon))$. When $r = \text{polylog } w$, our generator has optimal seed length $O(\log w + \log(1/\epsilon))$. For intermediate values of $r$, our generator's seed length smoothly interpolates between these two extremes. Our generator's seed length improves on recent work by Braverman, Cohen, and Garg [SIAM J. Comput., (2020), doi:10.1137/18M1197734]. In addition, our generator and its analysis are dramatically simpler than the work by Braverman et al. When $\epsilon$ is small, our generator's seed length improves on all the classic generators for space-bounded computation [N. Nisan, Combinatorica, 12 (1992), pp. 449--461; R. Impagliazzo, N. Nisan, and A. Wigderson, in Proceedings of the 26th Annual ACM Symposium on Theory of Computing, ACM, 1994, pp. 356--364; N. Nisan and D. Zuckerman, J. Comput. System Sci., 52 (1996), pp. 43--52]. However, all of these other works construct more general objects than we do. As a corollary of our construction, we show that every ${RL}$ algorithm that uses $r$ random bits can be simulated by an ${NL}$ algorithm that uses only $O(r/\log^c n)$ nondeterministic bits, where $c$ is an arbitrarily large constant. Finally, we show that any ${RL}$ algorithm with small success probability $\epsilon$ can be simulated deterministically in space $O(\log^{3/2} n + \log n \log \log(1/\epsilon))$. This space bound improves on work by Saks and Zhou [J. Comput. System Sci., 58 (1999), pp. 376--403], who gave an algorithm for the more general “two-sided” problem that runs in space $O(\log^{3/2} n + \sqrt{\log n} \log(1/\epsilon))$.

Proofs of proximity for context-free languages and read-once branching programs

Proofs of proximity are proof systems wherein the verifier queries a sublinear number of bits, and soundness only asserts that inputs that are far from valid will be rejected. In their minimal form, called MA proofs of proximity (MAP), the verifier receives, in addition to query access to the input, also free access to a short (sublinear) proof. A more general notion is that of interactive proofs of proximity (IPP), wherein the verifier is allowed to interact with an omniscient, yet untrusted prover.We construct proofs of proximity for two natural classes of properties: (1) context-free languages, and (2) languages accepted by small read-once branching programs. Our main results are:1.MAPs for these two classes, in which, for inputs of length n, both the verifier's query complexity and the length of the MAP proof are O˜(n).2.IPPs for the same two classes with constant query complexity, poly-logarithmic communication complexity, and logarithmically many rounds of interaction.

Pseudorandomness and Fourier-Growth Bounds for Width-3 Branching Programs

We present an explicit pseudorandom generator for oblivious, read-once, width-3 branching programs, which can read their input bits in any order. The generator has seed length ˜ O(log 3 n). The previously best known seed length for this model is n 1/2+o(1) due to Impagliazzo, Meka, and Zuckerman (FOCS ’12). Our work generalizes a recent result of Reingold, Steinke, and Vadhan (RANDOM ’13) for permutation branching programs. The main technical novelty underlying our generator is a new bound on the Fourier growth of width-3, oblivious, read-once branching programs. Specifically, we show that for any f :{0, 1} n !{0, 1} computed by such a branching program, and k2 [n], X s [n]:|s|=k b f[s] n 2 · (O(logn)) k ,

Foreword: Special Issue on IPEC 2014

We are pleased to present this special issue of Algorithmica, which contains the extended journal versions of selected papers previously presented at the 9th International Symposium on Parameterized and Exact Computation, IPEC 2014, September 10–12, Wroclaw, Poland. The symposium is an established annual meeting of the multivariate and exact algorithms communities. This issue consists of nine papers, reviewed thoroughly according to the usual, high standard of the journal. In The Parameterized Complexity of Geometric Graph Isomorphism, V. Arvind and Gaurav Rattan present improved FPT algorithm for Geometric Graph Isomorphism problem, where one is to decide whether there is a distance preserving bijection between two sets of points in k-dimensional euclidian space. Igor Razgon in On the read-once property of branching programs and CNFs of bounded treewidthproves a space lower bound for non-deterministic read-oncebranching programs on functions expressible as CNFswith treewidth at most k of their primal graphs. In Finding Shortest Paths between Graph Colourings, Matthew Johnson, Dieter Kratsch, Stefan Kratsch, Viresh Patel, and Daniel Paulusma give a complete picture of the parameterized complexity of the k-colouring reconfiguration problem, where the goal is to modify one proper colouring into another one, by changing the colour of one vertex at a time. Given a system of linear equations Ax = b over the binary field one can ask whether there is a solution of weight at most t , exactly t or at least t . In Solving Linear

On the Read-Once Property of Branching Programs and CNFs of Bounded Treewidth

In this paper we prove a space lower bound of $$n^{\varOmega (k)}$$ for non-deterministic (syntactic) read-once branching programs (nrobps) on functions expressible as cnfs with treewidth at most k of their primal graphs. This lower bound rules out the possibility of fixed-parameter space complexity of nrobps parameterized by k. We use lower bound for nrobps to obtain a quasi-polynomial separation between Free Binary Decision Diagrams and Decision Decomposable Negation Normal Forms, essentially matching the existing upper bound introduced by Beame et al. (Proceedings of the twenty-ninth conference on uncertainty in artificial intelligence, Bellevue, 2013) and thus proving the tightness of the latter.

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 superpolynomial lower bound for the size of nondeterministic thrifty branching programs would be an important step toward separating NL from P using the tree evaluation problem. First, we show that Read-Once Nondeterministic Thrifty BPs 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 nondeterministic thrifty branching programs called Bitwise Independence . The best known [Cook et al. 2012] nondeterministic thrifty branching programs (of size O ( k h /2 + 1 )) for the tree evaluation problem are Bitwise Independent. As our main result, we show that any Bitwise Independent Nondeterministic Thrifty Branching Program solving BT 2 (h, k) must have at least (k2) h/2 states. Prior to this work, lower bounds were known for nondeterministic thrifty branching programs only for fixed heights h = 2, 3, 4 [Cook et al. 2012]. We prove our results by associating a fractional black-white pebbling strategy with any bitwise independent nondeterministic thrifty branching program 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ák [2001] originally in the context of proving lower bounds for read-once branching programs. We also show that the previous lower bounds known [Cook et al. 2012] for deterministic branching programs for the 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 the Tree Evaluation Problem when the instances are restricted to have the same group operation in all internal nodes.

Pseudorandom Generators for Regular Branching Programs

We give new pseudorandom generators for regular read-once branching programs of small width. A branching program is regular if the in-degree of every vertex in it is either 0 or 2, except for the first layer. For every width $d$ and length $n$, our pseudorandom generator uses a seed of length $O((\log d + \log\log n + \log(1/\epsilon))\log n)$ to produce $n$ bits that cannot be distinguished from a uniformly random string by any regular width $d$ length $n$ read-once branching program, except with probability $\epsilon$. We also give a result for general read-once branching programs, in the case that there are no vertices that are reached with small probability. We show that if a (possibly nonregular) branching program of length $n$ and width $d$ has the property that every vertex in the program is traversed with probability at least $\gamma$ on a uniformly random input, then the error of the generator above is at most $2 \epsilon/\gamma^2$. Finally, we show that the set of all binary strings with less th...

Pseudorandom Generators for Polynomial Threshold Functions

We study the natural question of constructing pseudorandom generators (PRGs) for low-degree polynomial threshold functions (PTFs). We give a PRG with seed length $\log n/\epsilon^{O(d)}$ fooling degree $d$ PTFs with error at most $\epsilon$. Previously, no nontrivial constructions were known even for quadratic threshold functions and constant error $\epsilon$. For the class of degree $1$ threshold functions or halfspaces, previously only PRGs with seed length $O(\log n \log^2(1/\epsilon)/\epsilon^2)$ were known. We improve this dependence on the error parameter and construct PRGs with seed length $O(\log n + \log^2 (1/\epsilon))$ that $\epsilon$-fool halfspaces. We also obtain PRGs with similar seed lengths for fooling halfspaces over the $n$-dimensional unit sphere. The main theme of our constructions and analysis is the use of invariance principles to construct PRGs. We also introduce the notion of monotone read-once branching programs, which is key to improving the dependence on the error rate $\epsilo...

On Computational Power of Quantum Read-Once Branching Programs

In this paper we review our current results concerning the computational power of quantum read-once branching programs. First of all, based on the circuit presentation of quantum branching programs and our variant of quantum fingerprinting technique, we show that any Boolean function with linear polynomial presentation can be computed by a quantum read-once branching program using a relatively small (usually logarithmic in the size of input) number of qubits. Then we show that the described class of Boolean functions is closed under the polynomial projections.

Algorithms for Quantum Branching Programs Based on Fingerprinting

In the paper we develop a method for constructing quantum algorithms for computing Boolean functions by quantum ordered read-once branching programs (quantum OBDDs). Our method is based on fingerprinting technique and representation of Boolean functions by their characteristic polynomials. We use circuit notation for branching programs for desired algorithms presentation. For several known functions our approach provides optimal QOBDDs. Namely we consider such functions as Equality, Palindrome, and Permutation Matrix Test. We also propose a generalization of our method and apply it to the Boolean variant of the Hidden Subgroup Problem.

The optimal read-once branching program complexity for the direct storage access function

Branching programs are computation models measuring the space of (Turing machine) computations. Read-once branching programs (BP1s) are the most general model where each graph-theoretical path is the computation path for some input. Exponential lower bounds on the size of read-once branching programs are known since a long time. Nevertheless, there are only few functions where the BP1 size is asymptotically known exactly. In this paper, the exact BP1 size of a fundamental function, the direct storage access function, is determined.

On the Incompressibility of Monotone DNFs

We prove optimal lower bounds for multilinear circuits and for monotone circuits with bounded depth. These lower bounds state that, in order to compute certain functions, these circuits need exactly as many OR gates as the respective DNFs. The proofs exploit a property of the functions that is based solely on prime implicant structure. Due to this feature, the lower bounds proved also hold for approximations of the considered functions that are similar to slice functions. Known lower bound arguments cannot handle these kinds of approximations. In order to show limitations of our approach, we prove that cliques of size n - 1 can be detected in a graph with n vertices by monotone formulas with O(log n) OR gates. Our lower bound for multilinear circuits improves a lower bound due to Borodin, Razborov and Smolensky for nondeterministic read-once branching programs computing the clique function.

Bounds on the Fourier coefficients of the weighted sum function

We estimate Fourier coefficients of a Boolean function which has recently been introduced in the study of read-once branching programs. Our bound implies that this function has rather “flat” Fourier spectrum and thus implies several lower bounds on some of its complexity measures.

Parity graph-driven 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. Exponential lower bounds for read-once branching programs are known for a long time. On the other hand, the problem of proving superpolynomial lower bounds for parity read-once branching programs is still open. In this paper restricted parity read-once branching programs are considered and an exponential lower bound on the size of the so-called well-structured parity graph-driven read-once branching programs for integer multiplication is proven. This is the first strongly exponential lower bound on the size of a parity nonoblivious read-once branching program model for an explicitly defined Boolean function. In addition, more insight into the structure of integer multiplication is yielded.