Lars Kuhtz

LTL Path Checking Is Efficiently Parallelizable

We present an AC 1(logDCFL) algorithm for checking LTL formulas over finite paths, thus establishing that the problem can be efficiently parallelized. Our construction provides a foundation for the parallelization of various applications in monitoring, testing, and verification.

Monitor Circuits for LTL with Bounded and Unbounded Future

Synthesizing monitor circuits for LTL formulas is expensive, because the number of flip-flops in the circuit is exponential in the length of the formula. As a result, the IEEE standard PSL recommends to restrict monitoring to the simple subset and use the full logic only for static verification. We present a novel construction for the synthesis of monitor circuits from specifications in LTL. In our construction, only subformulas with unbounded-future operators contribute to the exponential blowup. We split the specification into a bounded and an unbounded part, apply specialized constructions for each part, and then compose the results into a monitor for the original specification. Since the unbounded part in practical specifications is often very small, we argue that, with the new construction, it is no longer necessary to restrict runtime verification to the simple subset.

Model checking finite paths and trees

This thesis presents efficient parallel algorithms for checking temporal logic formulas over finite paths and trees. We show that LTL path checking is in AC1(logDCFL) and CTL tree checking is in AC2(logDCFL). For LTL with pastime and bounded modalities, which is an exponentially more succinct logic, we show that the path checking problem remains in AC1(logDCFL). Our results provide a foundation for efficient algorithms of various applications in monitoring, testing, and verification as well as for query processing for tree-datastructures, e.g. XML documents. The presented path and tree checking algorithms are based on efficient parallel evaluation strategies for monotone Boolean circuits. We reduce the evaluation of product circuits to the problem of evaluating one-input-face monotone planar Boolean circuits: for a monotone Boolean circuit that is a product of a tree and a path, we provide an AC1-reduction; for a monotone Boolean circuit that is a product of two trees, we provide an AC2-reduction. We develop a classification of Kripke structures with respect to the complexity of LTL model checking: Kripke structures for which the problem is PSPACE- complete, Kripke structures for which the problem is coNP-complete, and Kripke structures for which the problem is in NC. Wir prasentieren effiziente parallele Algorithmen zum Uberprufen der Erfulltheit von temporal logischen Formeln auf Pfaden und Baumen. Wir zeigen, dass fur die Logik LTL das Uberprufen von Ausfuhrungspfaden in der Komplexitatsklasse AC1(logDCFL) liegt. Fur die Logik CTL ist das Uberprufen von Baumen in AC2(logDCFL). Fur Erweiterungen von LTL mit Vergangenheit und beschrankten zeitlichen Modalitaten beweisen wir, dass Pfade ebenfalls in AC1(logDCFL) uberpruft werden konnen, obwohl die Logik exponentiell kompakter ist als einfaches LTL. Unsere Resultate bielden eine Grundlage fur effiziente Algorithmen fur verschiedene Anwendungen in den Bereichen der Systemuberwachung, des Testens und der Verfikation sowie fur die Anfragebearbeitung fur Baumdatenstrukturen, wie zum Beispiel XML Dokumente. Die prasentierten Algorithmen zum Uberprufen von Pfaden und Baumen basieren auf effizient parallelen Strategien zur Evaluierung von monotonen Boolschen Schaltkreisen. Wir reduzieren die Evaluierung von Produkt-Schaltkreisen auf das Problem der Evaluierung von monoton planaren Boolschen Schaltkreisen, bei denen sich alle Eingaben auf dem auseren Rand befinden. Fur monotone Boolsche Schaltkreise, die das Produkt von einem Baum und einem Pfad sind, geben wir eine AC1-Reduktion an. Fur monotone Boolsche Schaltkreise, die das Produkt von zwei Baumen sind, geben wir eine AC2-Reduktion an. Wir entwickeln eine Klassifizierung von Kripkestrukturen im Hinblick auf die Komplexitat des Erfulltheitsproblems fur LTL: Kripkestrukturen, fur die das Problem PSPACE-vollstandig ist, Kripkestrukturen, fur die das Problem coNP- vollstandig ist, und Kripkestrukturen, fur die das Problem in NC liegt.

Efficient Parallel Path Checking for Linear-Time Temporal Logic With Past and Bounds

Path checking, the special case of the model checking problem where the model under consideration is a single path, plays an important role in monitoring, testing, and verification. We prove that for linear-time temporal logic (LTL), path checking can be efficiently parallelized. In addition to the core logic, we consider the extensions of LTL with bounded-future (BLTL) and past-time (LTL+Past) operators. Even though both extensions improve the succinctness of the logic exponentially, path checking remains efficiently parallelizable: Our algorithm for LTL, LTL+Past, and BLTL+Past is in AC^1(logDCFL) \subseteq NC.

Weak Kripke structures and LTL

We revisit the complexity of the model checking problem for formulas of linear-time temporal logic (LTL). We show that the classic PSPACE-hardness result is actually limited to a subclass of the Kripke frames, which is characterized by a simple structural condition: the model checking problem is only PSPACE-hard if there exists a strongly connected component with two distinct cycles. If no such component exists, the problem is in coNP. If, additionally, the model checking problem can be decomposed into a polynomial number of finite path checking problems, for example if the frame is a tree or a directed graph with constant depth, or the frame has an SCC graph of constant depth, then the complexity reduces further to NC.

An improved algorithm for approximating the chromatic number of G n,p

Answering a question of Krivelevich and Vu [M. Krivelevich, V.H. Vu, Approximating the independence number and the chromatic number in expected polynomial time, J. Combin. Optimization 6 (2002) 143-155], we present an algorithm for approximating the chromatic number of random graphs Gn, p within a factor of O(√np/ln(np)) in polynomial expected time. The algorithm applies to edge probabilities c0/n ≤ p ≤ 0.99, where c0 > 0 is a certain constant.