#### Filter Results:

- Full text PDF available (20)

#### Publication Year

2003

2017

- This year (1)
- Last 5 years (13)
- Last 10 years (19)

#### Publication Type

#### Co-author

#### Journals and Conferences

#### Key Phrases

Learn More

Termination is an important and well-studied property for logic programs. However, almost all approaches for automated termination analysis focus on definite logic programs, whereas real-world Prolog programs typically use the cut operator. We introduce a novel pre-processing method which automatically transforms Prolog programs into logic programs without… (More)

- Thomas Ströder, Maurice Pagnucco
- IJCAI
- 2009

This paper considers the problem of composing or scheduling several (non-deterministic) behaviors so as to conform to a specified target behavior as well as satisfying constraints imposed by the environment in which the behaviors are to be performed. This problem has already been considered by several works in the literature and applied to areas such as web… (More)

- Marc Brockschmidt, Thomas Ströder, Carsten Otto, Jürgen Giesl
- FoVeOOS
- 2011

Recently, we developed an approach for automated termination proofs of Java Bytecode (JBC), which is based on constructing and analyzing termination graphs. These graphs represent all possible program executions in a finite way. In this paper, we show that this approach can also be used to detect non-termination or NullPointerExceptions. Our approach… (More)

- Jürgen Giesl, Marc Brockschmidt, +8 authors René Thiemann
- IJCAR
- 2014

AProVE is a system for automatic termination and complexity proofs of Java, C, Haskell, Prolog, and term rewrite systems (TRSs). To analyze programs in high-level languages, AProVE automatically converts them to TRSs. Then, a wide range of techniques is employed to prove termination and to infer complexity bounds for the resulting TRSs. The generated proofs… (More)

- Thomas Ströder, Fabian Emmes, Peter Schneider-Kamp, Jürgen Giesl, Carsten Fuhs
- LOPSTR
- 2011

We present a new operational semantics for Prolog which covers all constructs in the corresponding ISO standard (including “nonlogical” concepts like cuts, meta-programming, “all solution” predicates, dynamic predicates, and exception handling). In contrast to the classical operational semantics for logic programming, our semantics is linear and not based… (More)

AProVE is a system for automatic termination and complexity proofs of C, Java, Haskell, Prolog, and term rewrite systems. The particular strength of AProVE when analyzing C is its capability to reason about pointer arithmetic combined with direct memory accesses (as, e.g., in standard implementations of string algorithms). As a prerequisite for termination,… (More)

There exist many powerful techniques to analyze <i>termination</i> and <i>complexity</i> of <i>term rewrite systems</i> (TRSs). Our goal is to use these techniques for the analysis of other programming languages as well. For instance, approaches to prove termination of definite logic programs by a transformation to TRSs have been studied for decades.… (More)

- Jürgen Giesl, Cornelius Aschermann, +10 authors René Thiemann
- Journal of Automated Reasoning
- 2016

In this system description, we present the tool AProVE for automatic termination and complexity proofs of Java, C, Haskell, Prolog, and rewrite systems. In addition to classical term rewrite systems (TRSs), AProVE also supports rewrite systems containing built-in integers (int-TRSs). To analyze programs in high-level languages, AProVE automatically converts… (More)

We present the first approach to deduce lower bounds for innermost runtime complexity of term rewrite systems (TRSs) automatically. Inferring lower runtime bounds is useful to detect bugs and to complement existing techniques that compute upper complexity bounds. The key idea of our approach is to generate suitable families of rewrite sequences of a TRS and… (More)

- Thomas Ströder, Jürgen Giesl, +4 authors Peter Schneider-Kamp
- 2014

Proving termination automatically for programs with explicit pointer arithmetic is still an open problem. To close this gap, we introduce a novel abstract domain that can track allocated memory in detail. We use it to automatically construct a symbolic execution graph that represents all possible runs of the program and that can be used to prove memory… (More)