On the Nonapproximability of Boolean Functions by OBDDs and Read-k-Times Branching Programs

@article{Bollig2002OnTN,
  title={On the Nonapproximability of Boolean Functions by OBDDs and Read-k-Times Branching Programs},
  author={Beate Bollig and Martin Sauerhoff and Ingo Wegener},
  journal={Inf. Comput.},
  year={2002},
  volume={178},
  pages={263-278}
}
Branching programs are considered as a nonuniform model of computation in complexity theory as well as a data structure for boolean functions in several applications. In many applications (e.g., verification), exact representations are required. For learning boolean functions f on the basis of classified examples, it is sufficient to produce the representation of a function g approximating f . This motivates the investigation of the size of the smallest branching program approximating f… 

Figures from this paper

Approximating Boolean functions by OBDDs

Lower Bounds for Approximate Knowledge Compilation

TLDR
Two notions of approximation are formalized: weak approximation which has been studied before in the decision diagram literature and strong approximation, used in recent algorithmic results, which are shown to show lower bounds for approximation by d-DNNF.

Pseudorandomness for Read-Once Formulas

TLDR
An explicit construction of a pseudorandom generator for read-once formulas whose inputs can be read in arbitrary order is given and it is shown that such branching programs are more powerful distinguishers than those that read their inputs in sequential order.

Information Complexity and Data Stream Algorithms for Basic Problems

References

SHOWING 1-10 OF 39 REFERENCES

Lower Bounds for Depth-Restricted Branching Programs

Approximations by OBDDs and the Variable Ordering Problem

TLDR
Methods from communication complexity and information theory are combined to prove that the direct storage access function and the inner product function have the following property: they have linear π-OBDD size for some variable ordering π and, for most variable orderings π′ all functions which approximate them on considerably more than half of the inputs, need exponential τ′-OB DD size.

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

TLDR
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, and a certain k-stable function due to Jukna, Razborov, Savický, and Wegener has randomized branching programs of polynomial size.

Time-Space Trade-offs for Branching Programs

  • I. Wegener
  • Computer Science
    J. Comput. Syst. Sci.
  • 1986

Approximation of Boolean Functions by Combinatorial Rectangles

Time-space tradeoffs for branching programs

  • P. BeameT. S. JayramM. Saks
  • Computer Science
    Proceedings 39th Annual Symposium on Foundations of Computer Science (Cat. No.98CB36280)
  • 1998
We obtain the first non-trivial time-space tradeoff lower bound for functions f: {0,1}/sup n//spl rarr/{0,1} on general branching programs by exhibiting a Boolean function f that requires exponential

Lower bounds by probabilistic arguments

  • A. Yao
  • Computer Science, Mathematics
    24th Annual Symposium on Foundations of Computer Science (sfcs 1983)
  • 1983
TLDR
It is proved that, to compute the majority function of n Boolean variables, the size of any depth-3 monotone circuit must be greater than 2nε, and thesize of any width-2 branching program must have super-polynomial growth.

A Lower Bound for Randomized Read-k-Times Branching Programs

  • Martin Sauerhoff
  • Mathematics, Computer Science
    Electron. Colloquium Comput. Complex.
  • 1997
TLDR
A lower bound is a lower bound for randomized read-κ-times branching programs with two-sided error, where κ > 1 is allowed, and the bound is exponential for κ < clog n, c an appropriate constant.

Super-linear time-space tradeoff lower bounds for randomized computation

TLDR
This work proves the first time-space lower bound tradeoffs for randomized computation of decision problems and improves the lower bound on time to /spl Omega/(n/spl radic/(log n/log log n)).

On the Complexity of VLSI Implementations and Graph Representations of Boolean Functions with Application to Integer Multiplication

  • R. Bryant
  • Computer Science
    IEEE Trans. Computers
  • 1991
TLDR
It is shown that the same technique used to prove that any VLSI implementation of a single output Boolean function has area-time complexity AT/sup 2/= Omega (n/Sup 2/) also proves that any OBDD representation of the function has Omega (c/sup n/) vertices for some c>1 but that the converse is not true.