. The INKA system is a first-order theorem prover with induction based on the explicit induction paradigm. Since 1986 when a first version of the INKA system was developed there have been many improvements. In this description we will give a short overview of the current system state and its abilities. 1 Introduction The original INKA system dates back to 1986 [2]. The current version of the INKA system which will be described below has been developed at DFKI GmbH 1 between 1991 and 1995. The INKA system is a first-order theorem prover with induction based on the explicit induction paradigm. In contrast to Nqthm, the Boyer-Moore prover, [3], the system is based on a full first-order calculus, a special variant of an ordersorted resolution calculus with paramodulation, [7]. However, it is not specialized on inductive proofs but possesses a powerful predicate-logic proof component. INKA is designed to be used for practical applications of inductive theorem proving, for instance, in th...

Abstract not found

This paper deals with automated termination analysis for functional programs. Previously developed methods for automated termination proofs of functional programs often fail for algorithms with nested recursion and they cannot handle algorithms with mutual recursion. We show that termination proofs for nested and mutually recursive algorithms can be performed without having to prove the correctness of the algorithms simultaneously. Using this result, nested and mutually recursive algorithms do no longer constitute a special problem and the existing methods for automated termination analysis can be extended to nested and mutual recursion in a straightforward way. We give some examples of algorithms whose termination can now be proved automatically (including well-known challenge problems such as McCarthy's f_91 function).

To prove the termination of a functional program there has to be a well-founded ordering such that the arguments in each recursive call are smaller than the corresponding inputs. In this paper we present a procedure for automated termination proofs of functional programs. In contrast to previously presented methods a suited well-founded ordering does not have to be fixed in advance by the user, but can be synthesized automatically. For that purpose we use approaches developed in the area of term rewriting systems for the automated generation of suited well-founded term orderings. But unfortunately term orderings cannot be directly used for termination proofs of functional programs which call other algorithms in the arguments of their recursive calls. The reason is that while for the termination of term rewriting systems orderings between terms are needed, for functional programs we need orderings between objects of algebraic data types. Our method solves this problem and enables term orderings to be used for termination proofs of functional programs.

Abstract. There are many powerful techniques for automated termination analysis of term rewriting. However, up to now they have hardly been used for real programming languages. We present a new approach which permits the application of existing techniques from term rewriting in order to prove termination of programs in the functional language Haskell. In particular, we show how termination techniques for ordinary rewriting can be used to handle those features of Haskell which are missing in term rewriting (e.g., lazy evaluation, polymorphic types, and higherorder functions). We implemented our results in the termination prover AProVE and successfully evaluated them on existing Haskell-libraries. 1

. The framework of dependency pairs allows automated termination and innermost termination proofs for many TRSs where such proofs were not possible before. In this paper we present a refinement of this framework in order to prove termination in a modular way. Our modularity results significantly increase the class of term rewriting systems where termination resp. innermost termination can be proved automatically. Moreover, the modular approach to dependency pairs yields new modularity criteria which extend previous results in this area considerably. In particular, existing results for modularity of innermost termination can easily be obtained as direct consequences of our new criteria. 1 Introduction Termination is one of the most important properties of a term rewriting system (TRS). While in general this problem is undecidable [HL78], several methods for proving termination have been developed (for surveys see e.g. [Der87, Ste95b, DH95]). However, most methods that are amenable to a...

. Primitive recursion is a well known syntactic restriction on recursive definitions which guarantees termination. Unfortunately many natural definitions, such as the most common definition of Euclid's GCD algorithm, are not primitive recursive. Walther has recently given a proof system for verifying termination of a broader class of definitions. Although Walther's system is highly automatible, the class of acceptable definitions remains only semi-decidable. Here we simplify Walther's calculus and give a syntactic criterion on definitions which guarantees termination. This syntactic criteria generalizes primitive recursion and handles most of the examples given by Walther. We call the corresponding class of acceptable definitions "Walther recursive". 1 Introduction One of the central problems in verification logics, such as the Boyer-Moore theorem prover [2], [10], is the need to prove termination for recursive definitions. Many logics, such as that of Boyer and Moore, assu...

Abstract. We present a simple method to formally prove termination of recursive functions by searching for lexicographic combinations of size measures. Despite its simplicity, the method turns out to be powerful enough to solve a large majority of termination problems encountered in daily theorem proving practice. 1

We describe novel computational techniques for constructing induction rules for deductive synthesis proofs. Deductive synthesis holds out the promise of automated construction of correct computer programs from specifications of their desired behaviour. Synthesis of programs with iteration or recursion requires inductive proof, but standard techniques for the construction of appropriate induction rules are restricted to recycling the recursive structure of the specifications. What is needed is induction rule construction techniques that can introduce novel recursive structures. We show that a combination of rippling and the use of meta-variables as a least-commitment device can provide such novelty. Key words: deductive synthesis, proof planning, induction, theorem proving, middle-out reasoning. 1

We present TEA, a tool that is able to detect termination of functions written in a non-strict high-level functional programming language like Haskell. Since almost every compiler for lazy functional languages transforms programs into a functional core language, we use such a core language as the source language for the analysis. TEA is able to detect two kinds of termination: nf-termination and lazy termination. Intuitively, nf-termination of f means that given arguments a i in normal form, the normal order evaluation of the expression f a1 : : : an terminates with a normal form. If an expression evaluates to an infinite normal form, we will call it lazy terminating. In order to prove nf-termination of an expression, TEA tries to generate a preclosed tableau using abstract reduction and path analysis. The preclosed tableau issues a set of ordering constraints, which have to be satisfied by some Noetherian ordering. A subsystem is called to generate this Noetherian ordering, and to v...