Martin Sauerhoff

Quantum branching programs and space-bounded nonuniform quantum complexity

In this paper, the space complexity of non-uniform quantum algorithms is investigated using the model of quantum branching programs (QBPs). In order to clarify the relationship between QBPs and non-uniform quantum Turing machines, simulations between these two models are presented which allow to transfer upper and lower bound results. Exploiting additional insights about the connection between the running time and the precision of amplitudes, it is shown that non-uniform quantum Turing machines with algebraic amplitudes and QBPs with a suitable analogous set of amplitudes are equivalent in computational power if both models work with bounded or unbounded error. Furthermore, quantum ordered binary decision diagrams (QOBDDs) are considered, which are restricted QBPs that can be regarded as a non-uniform analog of one-way quantum finite automata. Upper and lower bounds are proved that allow a classification of the computational power of QOBDDs in comparison to usual deterministic and randomized variants of the model. Finally, an extension of QBPs is proposed where the performed unitary operation may depend on the result of a previous measurement. A simulation of randomized BPs by this generalized QBP model as well as exponential lower bounds for its ordered variant are presented.

Lower bounds for randomized read-k-times branching programs

Randomized branching programs are a probabilistic model of computation defined in analogy to the well-known probabilistic Turing machines. In this paper, we contribute to the complexity theory of randomized read-k-times branching programs.

Hierarchy theorems for k OBDDs and k IBDDs

Almost the same types of restricted branching programs (or binary decision diagrams BDDs) are considered in complexity theory and in applications like hardware verification. These models are read-once branching programs (free BDDs) and certain types of oblivious branching programs (ordered and indexed BDDs with k layers). The complexity of the satisfiability problem for these restricted branching programs is investigated and tight hierarchy results are proved for the classes of functions representable by k layers of ordered or indexed BDDs of polynomial size.

On the complexity of minimizing the OBDD size for incompletely specified functions

The problem of constructing an OBDD cover of minimal size for an incompletely specified Boolean function arises in several applications in the CAD domain, e.g., the verification of sequential machines and the construction of OBDDs for incompletely specified circuits. The complexity of this problem is determined. The decision problem is NP-complete. Efficient approximation algorithms exist only if NP=P.

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

Abstract. 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

On the complexity of the hidden weighted bit function for various BDD models

{\rm P \subsetneqq ZPP \cap NP \cap coNP}

Tradeoffs between Nondeterminism and Complexity for Communication Protocols and Branching Programs

for the analogs of these classes defined in terms of the size of read-once branching programs.

The Power of Nondeterminism and Randomness for Oblivious Branching Programs

Ordered binary decision diagrams (OBDDs) and several more general BDD models have turned out to be representations of Boolean functions which are useful in applications like verification, timing analysis, test pattern generation or combinatorial optimization. The hidden weighted bit function (HWB) is of particular interest, since it seems to be the simplest function with exponential OBDD size. The complexity of this function with respect to different circuit models, formulas, and various BDD models is discussed.

Relating branching program size and formula size over the full binary basis

In this paper, lower bound and tradeoff results relating the computational power of determinism, nondeterminism, and randomness for communication protocols and branching programs are presented. The main results can be divided into the following three groups. (i) One of the few major open problems concerning nondeterministic communication complexity is to prove an asymptotically exact tradeoff between complexity and the number of available advice bits. This problem is solved here for the case of one-way communication. (ii) Multipartition protocols are introduced as a new type of communication protocols using a restricted form of non-obliviousness. In order to be able to study methods for proving lower bounds on multilective and/or non-oblivious computation, these protocols are allowed to either deterministically or nondeterministically choose between different partitions of the input. Here, the first results showing the potential increase of the computational power by nonobliviousness as well as boundaries on this power are derived. (iii) The above results (and others) are applied to obtain several new exponential lower bounds for different types of oblivious branching programs, which also yields new insights into the power of nondeterminism and randomness for the considered models. The proofs rely on a general technique described here which allows to prove explicit lower bounds on the size of oblivious branching programs in an easy and transparent way.

Complexity Theoretical Aspects of OFDDs

AbstractAbstract. This paper abstracts and generalizes the known approaches for proving lower bounds on the size of various variants of oblivious branching programs (oblivious BPs for short), providing an easy-to-use technique which works for all nondeterministic and randomized modes of acceptance. The technique is applied to obtain the following results concerning the power of nondeterminism and randomness for oblivious BPs: — Oblivious read-once BPs, better known as OBDDs (ordered binary decision diagrams), are used in many applications and their structure is well understood in the deterministic case. It has been open so far to compare the power of nondeterministic OBDDs with so-called partitioned BDDs which are a variant of nondeterministic branching programs also used in practice. A k -partitioned BDD has a nondeterministic node at the top by which one out of k deterministic OBDDs with possibly different variable orders is chosen. It is proven here that the two models are incomparable as long as k is bounded by a logarithmic function in the input length. — It is shown that deterministic oblivious read-k -times BPs for an explicitly defined function require superpolynomial size, for k logarithmic in the input length, while there are Las Vegas oblivious read-twice BPs of linear size for this function. This is in contrast to the situation for OBDDs, for which the respective size measures are polynomially related. — Furthermore, an explicitly defined function is presented for which randomized oblivious read-k -times BPs with bounded error require exponential size, while the function as well as its complement can be represented in polynomial size by nondeterministic oblivious read-k -times BPs and deterministic oblivious read-(k+1) -times BPs, where k=o(log n) .