Results 1  10
of
31
Termination of Term Rewriting Using Dependency Pairs
 Comput. Sci
, 2000
"... 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 righthand sides of rewrite rules, but introduce the notion of dependency pairs to compare lefthand sides with special subter ..."
Abstract

Cited by 210 (47 self)
 Add to MetaCart
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 righthand sides of rewrite rules, but introduce the notion of dependency pairs to compare lefthand sides with special subterms of the righthand 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, wellknown simplification orderings (such as the recursive path ordering, polynomial orderings, or the KnuthBendix 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.
A General Framework for Automatic Termination Analysis of Logic Programs
, 2000
"... This paper describes a general framework for automatic termination analysis of logic programs, where we understand by "termination" the finiteness of the LDtree constructed for the program and a given query. A general property of mappings from a certain subset of the branches of an infinite LDtree ..."
Abstract

Cited by 41 (9 self)
 Add to MetaCart
This paper describes a general framework for automatic termination analysis of logic programs, where we understand by "termination" the finiteness of the LDtree constructed for the program and a given query. A general property of mappings from a certain subset of the branches of an infinite LDtree into a finite set is proved. From this result several termination theorems are derived, by using different finite sets. The first two are formulated for the predicate dependency and atom dependency graphs. Then a general result for the case of the querymapping pairs relevant to a program is proved (cf. [29,21]). The correctness of the TermiLog system described in [22] follows from it. In this system it is not possible to prove termination for programs involving arithmetic predicates, since the usual order for the integers is not wellfounded. A new method, which can be easily incorporated in TermiLog or similar systems, is presented, which makes it possible to prove termination for programs involving arithmetic predicates. It is based on combining a finite abstraction of the integers with the technique of the querymapping pairs, and is essentially capable of dividing a termination proof into several cases, such that a simple termination function suffices for each case. Finally several possible extensions are outlined. Key words termination of logic programs  abstract interpretation  constraints ? This research has been partially supported by grants from the Israel Science Foundation 2 Nachum Dershowitz et al. 1
Modelling General Recursion in Type Theory
 Mathematical Structures in Computer Science
, 2002
"... Constructive type theory is an expressive programming language where both algorithms and proofs can be represented. However, general recursive algorithms have no direct formalisation in type theory since they contain recursive calls that satisfy no syntactic condition guaranteeing termination. ..."
Abstract

Cited by 38 (6 self)
 Add to MetaCart
Constructive type theory is an expressive programming language where both algorithms and proofs can be represented. However, general recursive algorithms have no direct formalisation in type theory since they contain recursive calls that satisfy no syntactic condition guaranteeing termination.
Termination Checking with Types
, 1999
"... The paradigm of typebased termination is explored for functional programming with recursive data types. The article introduces , a lambdacalculus with recursion, inductive types, subtyping and bounded quanti cation. Decorated type variables representing approximations of inductive types ..."
Abstract

Cited by 28 (6 self)
 Add to MetaCart
The paradigm of typebased termination is explored for functional programming with recursive data types. The article introduces , a lambdacalculus with recursion, inductive types, subtyping and bounded quanti cation. Decorated type variables representing approximations of inductive types are used to track the size of function arguments and return values. The system is shown to be type safe and strongly normalizing. The main novelty is a bidirectional type checking algorithm whose soundness is established formally.
A Collection of Examples for Termination of Term Rewriting Using Dependency Pairs
, 2001
"... This report contains a collection of examples to demonstrate the use and the power of the dependency pair technique developed by Arts and Giesl. This technique allows automated termination and innermost termination proofs for many term rewrite systems for which such proofs were not possible before. ..."
Abstract

Cited by 26 (11 self)
 Add to MetaCart
This report contains a collection of examples to demonstrate the use and the power of the dependency pair technique developed by Arts and Giesl. This technique allows automated termination and innermost termination proofs for many term rewrite systems for which such proofs were not possible before.
Nested General Recursion and Partiality in Type Theory
 Theorem Proving in Higher Order Logics: 14th International Conference, TPHOLs 2001, volume 2152 of Lecture Notes in Computer Science
, 2000
"... We extend Bove's technique for formalising simple general recursive algorithms in constructive type theory to nested recursive algorithms. The method consists in defining an inductive specialpurpose accessibility predicate, that characterises the inputs on which the algorithm terminates. As a resul ..."
Abstract

Cited by 24 (10 self)
 Add to MetaCart
We extend Bove's technique for formalising simple general recursive algorithms in constructive type theory to nested recursive algorithms. The method consists in defining an inductive specialpurpose accessibility predicate, that characterises the inputs on which the algorithm terminates. As a result, the typetheoretic version of the algorithm can be defined by structural recursion on the proof that the input values satisfy this predicate. This technique results in definitions in which the computational and logical parts are clearly separated; hence, the typetheoretic version of the algorithm is given by its purely functional content, similarly to the corresponding program in a functional programming language. In the case of nested recursion, the special predicate and the typetheoretic algorithm must be defined simultaneously, because they depend on each other. This kind of definitions is not allowed in ordinary type theory, but it is provided in type theories extended wit...
Semantic subtyping with an SMT solver
, 2010
"... We study a firstorder functional language with the novel combination of the ideas of refinement type (the subset of a type to satisfy a Boolean expression) and typetest (a Boolean expression testing whether a value belongs to a type). Our core calculus can express a rich variety of typing idioms; ..."
Abstract

Cited by 17 (1 self)
 Add to MetaCart
We study a firstorder functional language with the novel combination of the ideas of refinement type (the subset of a type to satisfy a Boolean expression) and typetest (a Boolean expression testing whether a value belongs to a type). Our core calculus can express a rich variety of typing idioms; for example, intersection, union, negation, singleton, nullable, variant, and algebraic types are all derivable. We formulate a semantics in which expressions denote terms, and types are interpreted as firstorder logic formulas. Subtyping is defined as valid implication between the semantics of types. The formulas are interpreted in a specific model that we axiomatize using standard firstorder theories. On this basis, we present a novel typechecking algorithm able to eliminate many dynamic tests and to detect many errors statically. The key idea is to rely on an SMT solver to compute subtyping efficiently. Moreover, interpreting types as formulas allows us to call the SMT solver at runtime to compute instances of types.
Partial recursive functions in higherorder logic
 Int. Joint Conference on Automated Reasoning (IJCAR 2006), LNCS
, 2006
"... Abstract. Based on inductive definitions, we develop an automated tool for defining partial recursive functions in HigherOrder Logic and providing appropriate reasoning tools for them. Our method expresses termination in a uniform manner and includes a very general form of pattern matching, where p ..."
Abstract

Cited by 12 (2 self)
 Add to MetaCart
Abstract. Based on inductive definitions, we develop an automated tool for defining partial recursive functions in HigherOrder Logic and providing appropriate reasoning tools for them. Our method expresses termination in a uniform manner and includes a very general form of pattern matching, where patterns can be arbitrary expressions. Termination proofs can be deferred, restricted to subsets of arguments and are interchangeable with other proofs about the function. We show that this approach can also facilitate termination arguments for total functions, in particular for nested recursions. We implemented our tool as a definitional specification mechanism for Isabelle/HOL. 1
foetus – Termination Checker for Simple Functional Programs
, 1998
"... We introduce a simple functional language foetus (lambda calculus with tuples, constructors and pattern matching) supplied with a termination checker. This checker tries to find a wellfounded structural order on the parameters on the given function to prove termination. The components of the check ..."
Abstract

Cited by 12 (1 self)
 Add to MetaCart
We introduce a simple functional language foetus (lambda calculus with tuples, constructors and pattern matching) supplied with a termination checker. This checker tries to find a wellfounded structural order on the parameters on the given function to prove termination. The components of the check algorithm are: function call extraction out of the program text, call graph completion and finding a lexical order for the function parameters. The HTML version of this paper contains many readytorun Webbased examples.
Termination Analysis for Partial Functions
 IN PROCEEDINGS OF THE THIRD INTERNATIONAL STATIC ANALYSIS SYMPOSIUM (SAS'96
, 1996
"... This paper deals with automated termination analysis for partial functional programs, i.e. for functional programs which do not terminate for each input. We present a method to determine their domains (resp. nontrivial subsets of their domains) automatically. More precisely, for each functional p ..."
Abstract

Cited by 11 (6 self)
 Add to MetaCart
This paper deals with automated termination analysis for partial functional programs, i.e. for functional programs which do not terminate for each input. We present a method to determine their domains (resp. nontrivial subsets of their domains) automatically. More precisely, for each functional program a termination predicate algorithm is synthesized, which only returns true for inputs where the program is terminating. To ease subsequent reasoning about the generated termination predicates we also present a procedure for their simplification.