Termination of String Rewriting Proved Automatically

African Journal of Mathematics and Computer Science Research, 2012

It is well-known that termination of finite term of rewriting systems is generally undecidable. Notwithstanding, a remarkable result is that, rewriting systems are Turing complete. A number of methods have been developed to establish termination for certain term of rewriting systems, particularly occurring in practical situations. In this paper, we present an overview of the existing methods used for termination proofs. We also outline areas of applications of term rewriting systems along with recent developments in regard to automated termination proofs.

Lecture Notes in Computer Science, 2005

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.

Mathematical Foundations of Software Development, 1985

A new partial ordering scheme for proving uniform termination of term rewriting systems is presented. The basic idea is that two terms are compared by comparing the paths through them. It is shown that the ordering is a well-founded simplification ordering and also a strict extension of the recursive path ordering scheme of Dershowitz. Terms can be compared under this path ordering in polynomial time. 1. I N T R O D U C T I O N Term rewriting systems have been found to be widely applicable in many areas of computer science and mathematics, including word problems, unification problems, decision procedures for equational theories, theorem proving, program transformation and synthesis, polynomial simplification, analysis and design of specifications, proving properties by induction, etc. In most of these applications, the Knuth-Bendix completion procedure [11] and its extensions discussed in [1,8,9,13,15] play a crucial role. However, the successful use of the completion procedure crucially depends upon the ability to prove the termination of term rewriting systems that are generated during the course of the completion procedure to obtain a canonical set of rewrite rules. In this connection, many termination orderings have been proposed in the literature including the original Knuth-Bendix ordering based on weights [11], paths of subterm ordering [16], polynomial ordering [12], recursive path ordering (RPO) [2] and its extension based on lexicogTaphic status (LRPO) [7], and recursive decomposition ordering (RDO) [6] and its extension based on lexicographic status (RDOS) [14].

Electronic Notes in Theoretical Computer Science, 2007

Context-sensitive rewriting (CSR) is a restriction of rewriting which forbids reductions on selected arguments of functions. Proving termination of CSR is an interesting problem with several applications in the fields of term rewriting and programming languages. Several methods have been developed for proving termination of CSR. The new version of MU-TERM which we present here implements all currently known techniques. Furthermore, we show how to combine them to furnish MU-TERM with an expert which is able to automatically perform the termination proofs. Finally, we provide a first experimental evaluation of the tool.

2004

We describe the system AProVE, an automated prover to verify (innermost) termination of term rewrite systems (TRSs). For this system, we have developed and implemented efficient algorithms based on classical simplification orders, dependency pairs, and the size-change principle. In particular, it contains many new improvements of the dependency pair approach that make automated termination proving more powerful and efficient. In AProVE, termination proofs can be performed with a user-friendly graphical interface and the system is currently among the most powerful termination provers available.

2016

We consider unary term rewriting, i.e., term rewriting with unary signatures where all function symbols are either unary or constants. Terms over such signatures can be transformed into strings by just reading all symbols in the term from left to right, ignoring the optional variable. By lifting this transformation to rewrite rules, any unary term rewrite system (TRS) is transformed into a corresponding string rewrite system (SRS). We investigate which properties are preserved by this transfor-mation. It turns out that any TRS over a unary signature is terminating if and only if the corresponding SRS is terminating. In this way tools for proving termination of string rewriting can be applied for proving termination of unary TRSs. For other rewriting

Information and Computation, 2007

We present a new method for proving termination of term rewriting systems automatically. It is a generalization of the match bound method for string rewriting. To prove that a term rewriting system terminates on a given regular language of terms, we first construct an enriched system over a new signature that simulates the original derivations. The enriched system is an infinite system over an infinite signature, but it is locally terminating: every restriction of the enriched system to a finite signature is terminating. We then construct iteratively a finite tree automaton that accepts the enriched given regular language and is closed under rewriting modulo the enriched system. If this procedure stops, then the enriched system is compact: every enriched derivation involves only a finite signature. Therefore, the original system terminates. We present three methods to construct the enrichment: top heights, roof heights, and match heights. Top and roof heights work for left-linear systems, while match heights give a powerful method for linear systems. For linear systems, the method is strengthened further by a forward closure construction. Using these methods, we give examples for automated termination proofs that cannot be obtained by standard methods.

Electronic Notes in Theoretical Computer Science, 2009

Computational systems based on reducing expressions usually have a predefined reduction strategy to break down the nondeterminism which is inherent to reduction relations. The innermost strategy corresponds to call by value or eager computation, that is, the computational mechanism of several programming languages like Maude, OBJ, etc. where the arguments of a function call are always evaluated before calling the function. This strategy usually fails to terminate when nonterminating computations are possible in the programs and many eager programming languages also admit the explicit specification of a particular class of strategy annotations to (try to) avoid them. Context-Sensitive Rewriting provides an abstract model to describe and analyze the operational behavior of such programs. This paper aims at contributing to the development of appropriate techniques and tools for the verification of program termination in the aforementioned programming languages, so we focus on termination of innermost (context-sensitive) rewriting. We adapt the notion of usable argument introduced by Fernández to prove innermost termination by proving termination of context-sensitive rewriting. Thanks to our recent developments for proving termination of (innermost) context-sensitive rewriting using dependency pairs, now we can also relax monotonicity requirements for proving innermost termination of (context-sensitive) rewriting. We have implemented these new improvements in the termination tool mu-term and evaluated the results with some benchmarks.

Proceedings of the 2002 ACM SIGPLAN workshop on Rule-based programming - RULE '02, 2002

Simple termination is the (often indirect) basis of most existing automatic techniques for proving termination of rule-based programs (e.g., Knuth-Bendix, polynomial, or recursive path orderings, but also DP-simple termination, etc.). An interesting framework for such programs is context-sensitive rewriting (CSR) that provides a bridge between the abstract world of general rewriting and the (more) applied setting of declarative specification and programming languages (e.g., OBJ*, CafeOBJ, ELAN, and Maude). In these languages, certain replacement restrictions can be specified in programs by the so-called strategy annotations. They may significantly improve the computational properties of programs, especially regarding their termination behaviour. Context-sensitive rewriting techniques (in particular, the methods for proving termination of CSR) have been proved useful for analyzing the properties of these programs. This entails the need to provide implementable methods for proving termination of CSR. Simplification orderings (corresponding to the notion of simple termination) which are wellknown in term rewriting (and have nice properties) are, then, natural candidates for such an attempt. In this paper we introduce and investigate a corresponding notion of simple termination of CSR. We prove that our notion actually provides a unifying framework for proving termination of CSR by using standard simplification orderings via the existing (transformational) methods, and also covers CSRPO, a very recent proposal that extends the recursive path ordering (RPO) (a well-known simplification ordering) to contextsensitive terms. We also introduce polynomial orderings for dealing with (simple) termination of CSR. Finally, we also give criteria for the modularity of simple termination, for the case of disjoint unions as well as for constructor-sharing rewrite systems.