Elmar Böhler

Bases for Boolean co-clones

The complexity of various problems in connection with Boolean constraints, like, for example, quantified Boolean constraint satisfaction, have been studied recently. Depending on what types of constraints may be used, the complexity of such problems varies. A very interesting observation of the recent past has been that the thus derived classification of constraints can be explained with the help of universal algebra. More precisely, the difficulty of such a constraint problem often depends on the co-clone the constraints are from. A co-clone is a set of Boolean relations that is closed under very natural closure operations. Nearly all these co-clones can be generated by said operators out of a finite set of relations, a so-called base. Knowing a, preferably simple, base for each co-clone can therefore be of great value when studying the complexity of Boolean constraint problems, since this knowledge reduces the infinitely many cases of equivalent problems to a single one--the constraint satisfaction problem for this base. In this paper we give a finite and simple base for every Boolean co-clone, where this is possible. We give evidence that the presented bases are as easy as possible.

Equivalence and Isomorphism for Boolean Constraint Satisfaction

A Boolean constraint satisfaction instance is a set of constraint applications where the allowed constraints are drawn from a fixed set C of Boolean functions. We consider the problem of determining whether two given constraint satisfaction instances are equivalent and prove a dichotomy theorem by showing that for all finite sets C of constraints, this problem is either polynomial-time solvable or coNP-complete, and we give a simple criterion to determine which case holds. A more general problem addressed in this paper is the isomorphism problem, the problem of determining whether there exists a renaming of the variables that makes two given constraint satisfaction instances equivalent in the above sense. We prove that this problem is coNP-hard if the corresponding equivalence problem is coNP-hard, and polynomial-time many-one reducible to the graph isomorphism problem in all other cases.

Error-bounded probabilistic computations between MA and AM

We introduce the probabilistic class SBP. This class emerges from BPP by keeping the promise of a probability gap but decreasing the probability limit from 1/2 to exponentially small values. We show that SBP is in the polynomial-time hierarchy, between MA and AM on the one hand and between BPP and BPPpath on the other hand. We provide evidence that SBP does not coincide with these and other known complexity classes. In particular, in a suitable relativized world SBP is not contained in Σ2P. In the same world, BPPpath is not contained in Σ2P, which solves an open question raised by Han, Hemaspaandra, and Thierauf. We study the question of whether SBP has many-one complete sets. We relate this question to the existence of uniform enumerations and construct an oracle relative to which SBP and AM do not have many-one complete sets. We introduce the operator SB. and prove that, for any class C with certain properties, BP ċ ∃ ċ C contains every class defined by applying an operator sequence over {Uċ, ∃ċ, BPċ, SBċ} to C.

The Complexity of Boolean Constraint Isomorphism

We consider the Boolean constraint isomorphism problem, that is, the problem of determining whether two sets of Boolean constraint applications can be made equivalent by renaming the variables. We show that depending on the set of allowed constraints, the problem is either coNP-hard and GI-hard, equivalent to graph isomorphism, or polynomial-time solvable. This establishes a complete classification of the complexity of the problem, and moreover, it identifies exactly all those cases in which Boolean constraint isomorphism is polynomial-time many-one equivalent to graph isomorphism, the best-known and best-examined isomorphism problem in theoretical computer science.

The Complexity of Problems for Quantified Constraints

In this paper we are interested in quantified propositional formulas in conjunctive normal form with “clauses” of arbitrary shapes. i.e., consisting of applying arbitrary relations to variables. We study the complexity of the evaluation problem, the model checking problem, the equivalence problem, and the counting problem for such formulas, both with and without a bound on the number of quantifier alternations. For each of these computational goals we get full complexity classifications: We determine the complexity of each of these problems depending on the set of relations allowed in the input formulas. Thus, on the one hand we exhibit syntactic restrictions of the original problems that are still computationally hard, and on the other hand we identify non-trivial subcases that admit efficient algorithms.

Error-Bounded Probabilistic Computations between MA and AM

We introduce the probabilistic complexity class SBP. This class emerges from BPP by keeping the promise of a probability gap but decreasing the probability limit to exponentially small values. We locate SBP in the polynomial-time hierarchy, more precisely, between MA and AM. We provide evidence that SBP does not coincide with these and other known complexity classes. We construct an oracle relative to which SBP is not contained in \({\mathrm{\Sigma^P_{2}}}\).

The Complexity of the Descriptiveness of Boolean Circuits over Different Sets of Gates

AbstractAny Boolean function can be defined by a Boolean circuit, provided we may use sufficiently strong functions in its gates. On the other hand, what Boolean functions can be defined depends on these gate functions: Each set B of gate functions defines the class of Boolean functions that can be defined by circuits over B. Although these classes have been known since the 1920s, their computational complexity was never investigated. In this paper we will study how difficult it is to decide for a Boolean function f and a class B, whether f is in B. Moreover, we will provide such a decision algorithm with additional information: How difficult is it to decide whether or not f is in B, provided we already know a circuit for f, but with gates from another class A? Given such a circuit, we know that f is in A. Is the problem harder if we do not have a concrete representation for f, but still know that it is from A? For nearly all possible combinations, we show that this is not the case, and that the problem is either in P or coNP-complete.