We present techniques to prove termination and innermost termination of term rewriting systems automatically. In contrast to previous approaches, we do not compare left- and right-hand sides of rewrite rules, but introduce the notion of dependency pairs to compare left-hand sides with special subterms of the right-hand sides. This results in a technique which allows to apply existing methods for automated termination proofs to term rewriting systems where they failed up to now. In particular, there are numerous term rewriting systems where a direct termination proof with simplification orderings is not possible, but in combination with our technique, well-known simplification orderings (such as the recursive path ordering, polynomial orderings, or the Knuth-Bendix ordering) can now be used to prove termination automatically. Unlike previous methods, our technique for proving innermost termination automatically can also be applied to prove innermost termination of term rewriting systems that are not terminating. Moreover, as innermost termination implies termination for certain classes of term rewriting systems, this technique can also be used for termination proofs of such systems.

Abstract. The dependency pair approach is one of the most powerful techniques for automated termination proofs of term rewrite systems. Up to now, it was regarded as one of several possible methods to prove termination. In this paper, we show that dependency pairs can instead be used as a general concept to integrate arbitrary techniques for termination analysis. In this way, the benefits of different techniques can be combined and their modularity and power are increased significantly. We refer to this new concept as the “dependency pair framework ” to distinguish it from the old “dependency pair approach”. Moreover, this framework facilitates the development of new methods for termination analysis. To demonstrate this, we present several new techniques within the dependency pair framework which simplify termination problems considerably. We implemented the dependency pair framework in our termination prover AProVE and evaluated it on large collections of examples. 1

Context-sensitive rewriting is a computational restriction of term rewriting used to model non-strict (lazy) evaluation in functional programming. The goal of this paper is the study and development of techniques to analyze the termination behavior of context-sensitive rewrite systems. For that purpose, several methods have been proposed in the literature which transform context-sensitive rewrite systems into ordinary rewrite systems such that termination of the transformed ordinary system implies termination of the original context-sensitive system. In this way, the huge variety of existing techniques for termination analysis of ordinary rewriting can be used for context-sensitive rewriting, too. We analyze the existing transformation techniques for proving termination of context-sensitive rewriting and we suggest two new transformations. Our first method is simple, sound, and more powerful than the previously proposed transformations. However, it is not complete, i.e., there are terminating context-sensitive rewrite systems that are transformed into non-terminating term rewrite systems. The second method that we present in this paper is both sound and complete. All these observations also hold for rewriting modulo associativity and commutativity.

To prove termination of term rewriting systems (TRSs), several methods have been developed to synthesize suitable well-founded orderings automatically. However, virtually all orderings that are amenable to automation are so-called simplification orderings. Unfortunately, there exist numerous interesting and relevant TRSs that cannot be oriented by orderings of this restricted class and therefore their termination cannot be proved automatically with the existing techniques. In this paper we present a new automatic approach which allows to apply the standard techniques for automated termination proofs to those TRSs where these techniques failed up to now. For that purpose we have developed a procedure which, given a TRS, generates a set of inequalities (constraints) automatically. If there exists a well-founded ordering satisfying these constraints, then the TRS is terminating. It turns out that for many TRSs where a direct application of standard techniques fails, these standard techniq...

We present two new transformation techniques for proving termination of context-sensitive rewriting. Our first method is simple, sound, and more powerful than previously suggested transformations. However, it is not complete, i.e., there are terminating context-sensitive rewrite systems that are transformed into non-terminating term rewrite systems. The second method that we present in this paper is both sound and complete. This latter result can be interpreted as stating that from a termination perspective there is no reason to study context-sensitive rewriting.

We present a technique to prove innermost normalisation of term rewriting systems (TRSs) automatically. In contrast to previous methods, our technique is able to prove innermost normalisation of TRSs that are not terminating. Our technique can also be used for termination proofs of all TRSs where innermost normalisation implies termination, such as non-overlapping TRSs or locally confluent overlay systems. In this way, termination of many (also non-simply terminating) TRSs can be verified automatically. 1. Introduction Innermost rewriting, i.e. rewriting where only innermost redexes are contracted, can be used to model call-by-value computation semantics. For that reason, there has been an increasing interest in innermost normalisation (also called innermost termination), i.e. in proving that the length of every innermost reduction is finite. Techniques for proving innermost normalisation can for example be utilized for termination proofs of functional programs (modelled by TRSs) or o...

The dependency pair approach is one of the most powerful techniques for automated (innermost) termination proofs of term rewrite systems (TRSs). For any TRS, it generates inequality constraints that have to be satisfied by well-founded orders. However, proving innermost termination is considerably easier than termination, since the constraints for innermost termination are a subset of those for termination.

. 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...

The dependency pair approach [2, 11, 12] is one of the most powerful techniques for termination and innermost termination proofs of term rewrite systems (TRSs). For any TRS, it generates inequality constraints that have to be satisfied by weakly monotonic well-founded orders. We improve the dependency pair approach by considerably reducing the number of constraints produced for (innermost) termination proofs. Moreover,

We present a tool for automatically proving termination of first-order rewrite systems. The tool is based on the dependency pair method of Arts and Giesl [1]. It incorporates several new ideas that make the method more efficient. The tool produces high-quality output and has a convenient web interface. If T T T succeeds in proving termination, it outputs a proof script which explains in considerable detail how termination was proved. This script is available in both HTML and L ATEX format. In the latter, the approximated dependency graph is visualized using the dot tool of the Graphviz toolkit. T T T is written in Objective Caml. We tested the various options of T T T on numerous examples. The results, as well as a comparison with other tools that implement the dependency pair method and some implementation details, can be found in [2, 3]. We describe some of the features of the tool (T T T in the sequel) by means of its web interface, displayed in Fig. 1. TRS The user inputs a TRS by typing the rules into the upper right text area or by uploading a file via the browse button. The exact input format is obtained by clicking the TRS link. Comment and Bibtex Anything typed into the upper right text area will appear as a footnote in the generated L ATEX code. This is useful to identify TRSs. L ATEX \cite commands may be included. In order for this to work correctly, a corresponding bibtex entry should be supplied. This can be done by typing the entry into the appropriate text area or by uploading an appropriate bibtex file via the browse button. Base Order The current version of T T T supports the following three base orders: LPO with strict precedence, LPO with quasi-precedence, and KBO with strict precedence. Dependency Pairs T T T supports the basic features of the dependency pair technique (argument filtering, dependency graph, cycle analysis) described below. Advanced features like narrowing, rewriting, and instantiation are not yet available. Also innermost termination analysis is not yet implemented.