Peter Rossmanith

Efficient Algorithms for Model Checking Pushdown Systems

We study model checking problems for pushdown systems and linear time logics. We show that the global model checking problem (computing the set of configurations, reachable or not, that violate the formula) can be solved in (O({g_{cal P}}{g_{cal P}}^3{g_{cal B}}{g_{cal B}}^3)) time and (O({g_{cal P}}{g_{cal P}}^2{g_{cal B}}{g_{cal B}}^2)) space, where ({g_{cal P}}{g_{cal P}}) and ({g_{cal B}}{g_{cal B}}) are the size of the pushdown system and the size of a Buchi automaton for the negation of the formula. The global model checking problem for reachable configurations can be solved in (O({g_{cal P}}{g_{cal P}}^4{g_{cal B}}{g_{cal B}}^3)) time and (O({g_{cal P}}{g_{cal P}}^4{g_{cal B}}{g_{cal B}}^2)) space. In the case of pushdown systems with constant number of control states (relevant for our application), the complexity becomes (O({g_{cal P}}{g_{cal P}}{g_{cal B}}{g_{cal B}}^3)) time and (O({g_{cal P}}{g_{cal P}}{g_{cal B}}{g_{cal B}}^2)) space and (O({g_{cal P}}{g_{cal P}}^2{g_{cal B}}{g_{cal B}}^3)) time and (O({g_{cal P}}{g_{cal P}}^2{g_{cal B}}{g_{cal B}}^2)) space, respectively. We show applications of these results in the area of program analysis and present some experimental results.

Upper bounds for vertex cover further improved

The problem instance of Vertex Cover consists of an undirected graph G = (V, E) and a positive integer k, the question is whether there exists a subset C ⊆ V of vertices such that each edge in E has at least one of its endpoints in C with |C| ≤ k. We improve two recent worst case upper bounds for Vertex Cover. First, Balasubramanian et al. showed that Vertex Cover can be solved in time O(kn+1:32472kk2), where n is the number of vertices in G. Afterwards, Downey et al. improved this to O(kn+1:31951kk2). Bringing the exponential base significantly below 1:3, we present the new upper bound O(kn+1:29175kk2).

A general method to speed up fixed-parameter-tractable algorithms

A fixed-parameter-tractable algorithm, or FPT algorithm for short, gets an instance (I,k) as its input and has to decide whether (I,k)∈L for some parameterized problem L. Many parameterized algorithms work in two stages: reduction to a problem kernel and bounded search tree. Their time complexity is then of the form O(p(|I|)+q(k)ξk), where q(k) is the size of the problem kernel. We show how to modify these algorithms to obtain time complexity O(p(|I|)+ξk), if q(k) is polynomial.

On efficient fixed-parameter algorithms for weighted vertex cover

We investigate the fixed-parameter complexity of WEIGHTED VERTEX COVER. Given a graph G = (V, E), a weight function ω: V → R+, and k ∈ R+, WEIGHTED VERTEX COVER (WVC for short) asks for a vertex subset C ⊆ V of total weight at most k such that every edge of G has at least one endpoint in C. WVC and its natural variants are NP-complete. We observe that, when restricting the range of ω to positive integers, the so-called INTEGER-WVC can be solved as fast as unweighted VERTEX COVER. Our main result is that if the range of ω is restricted to positive reals ≥ 1, then so-called REAL-WVC can be solved in time O(1.3954k + k|V|). By way of contrast, unless P = NP, the problem is not fixed-parameter tractable if arbitrary weights > 0 are allowed. Using dynamic programming, at the expense of exponential memory use, we can improve the running time of REALWVC to O(1.3788k + k|V|). The same technique applied to a known algorithm yields the so far fastest algorithm for unweighted VERTEX COVER, running in time O(1.2832kk + k|V|).

New Upper Bounds for Maximum Satisfiability

The (unweighted) Maximum Satisfiability problem (MaxSat) is: Given a Boolean formula in conjunctive normal form, find a truth assignment that satisfies the largest number of clauses. This paper describes exact algorithms that provide new upper bounds for MaxSat. We prove that MaxSat can be solved in time O(|F|·1.3803K), where |F| is the length of a formula F in conjunctive normal form and K is the number of clauses in F. We also prove the time bounds O(|F|·1.3995k), where k is the maximum number of satisfiable clauses, and O(1.1279|F|), for the same problem. For Max2Sat this implies a bound of O(1.2722K).

Exact Solutions for CLOSEST STRING and Related Problems

CLOSEST STRING is one of the core problems in the field of consensus word analysis with particular importance for computational biology. Given k strings of same length and a positive integer d, find a closest string s such that none of the given strings has Hamming distance greater than d from s. Closest String is NP-complete. We show how to solve CLOSEST STRING in linear time for constant d (the exponential growth is O(d d . We extend this result to the closely related problems d-MISMATCH and DISTINGUISHING STRING SELECTION. Moreover, we discuss fixed parameter tractability for parameter k and give an efficient linear time algorithm for CLOSEST STRING when k = 3. Finally, the practical usefulness of our findings is substantiated by some experimental results.

Worst-case upper bounds for MAX-2-SAT with an application to MAX-CUT

The maximum 2-satisfiability problem (MAX-2-SAT) is: given a Boolean formula in 2-CNF, find a truth assignment that satisfies the maximum possible number of its clauses. MAX-2-SAT is MAX-SNP-complete. Recently, this problem received much attention in the contexts of (polynomial-time) approximation algorithms and (exponential-time) exact algorithms. In this paper, we present an exact algorithm solving MAX-2-SAT in time poly(L) ċ 2K/5, where K is the number of clauses and L is their total length. In fact, the running time is only poly(L) ċ 2K2/5, where K2 is the number of clauses containing two literals. This bound implies the bound poly(L) ċ 2L/10. Our results significantly improve previous bounds: poly(L) ċ 2K/2.88 (J. Algorithms 36 (2000) 62-88) and poly(L) ċ 2K/3.44 (implicit in Bansal and Raman (Proceedings of the 10th Annual Conference on Algorithms and Computation, ISAAC99, Lecture Notes in Computer Science, VoL 1741, Springer, Berlin, 1999, pp. 247-258.))As an application, we derive upper bounds for the (MAX-SNP-complete) maximum cut problem (MAX-CUT), showing that it can be solved in time poly(M) ċ 2M/3, where M is the number of edges in the graph. This is of special interest for graphs with low vertex degree.

Unambiguity and Fewness for Logarithmic Space

We consider various types of unambiguity and fewness for log space bounded Turing machines and polynomial time bounded log space auxiliary pushdown automata. In particular, we introduce the notions of (general), reach, and strong unambiguity and fewness. We demonstrate that closure under complement of unambiguous classes implies equivalence of unambiguity and “unambiguous fewness”. This, as we will show, applies in the cases of reach and strong unambiguity for log space. Among the many relations we exhibit, we show that the unambiguous linear contextfree languages, which are not known to be contained in deterministic log space, nevertheless are contained in strongly unambiguous log space, and, consequently, are log space reducible to deterministic contextfree languages.

The Emptiness Problem for Intersections of Regular Languages

Given m finite automata, the emptiness of intersection problem is to determine whether there exists a string which is accepted by all m automata. In the following we consider the case, when m is bounded by a function in the input length, i.e., in the size and number of the automata. In this way we get complete problems for nondeterministic space-bounded and timespace-bounded complexity classes. Further on, we get close relations to nondeterministic sublinear time classes and to classes which are defined by bounding the number of nondeterministic steps.

Stochastic Finite Learning of the Pattern Languages

AbstractThe present paper proposes a new learning model—called stochastic finite learning—and shows the whole class of pattern languages to be learnable within this model.This main result is achieved by providing a new and improved average-case analysis of the Lange–Wiehagen (New Generation Computing, 8, 361–370) algorithm learning the class of all pattern languages in the limit from positive data. The complexity measure chosen is the total learning time, i.e., the overall time taken by the algorithm until convergence. The expectation of the total learning time is carefully analyzed and exponentially shrinking tail bounds for it are established for a large class of probability distributions. For every pattern π containing k different variables it is shown that Lange and Wiehagens algorithm possesses an expected total learning time of n