Results 1  10
of
46
Termination of ondemand rewriting and termination of OBJ programs
 In Proc. of 3rd International Conference on Principles and Practice of Declarative Programming, PPDP'01
, 2001
"... Declarative languages such as OBJ*, CafeOBJ, and Maude use syntactic annotations to introduce replacement restrictions aimed at improving termination or efficiency of computations. Unfortunately, there is a lack of formal techniques for proving such benefits. We show that contextsensitive rewriting ..."
Abstract

Cited by 33 (21 self)
 Add to MetaCart
(Show Context)
Declarative languages such as OBJ*, CafeOBJ, and Maude use syntactic annotations to introduce replacement restrictions aimed at improving termination or efficiency of computations. Unfortunately, there is a lack of formal techniques for proving such benefits. We show that contextsensitive rewriting and ondemand rewriting provide a suitable framework to address this problem. We provide methods to analyze termination of ondemand rewriting and apply them to analyze termination of OBJ*, CafeOBJ, and Maude programs. Keywords Program analysis, replacement restrictions, term rewriting, termination 1.
Contextsensitive dependency pairs
 In the 26th Conference on Foundations of Software Technology and Theoretical Computer Science
, 2006
"... Abstract. Termination is one of the most interesting problems when dealing with contextsensitive rewrite systems. Although there is a good number of techniques for proving termination of contextsensitive rewriting (CSR), the dependency pair approach, one of the most powerful techniques for proving ..."
Abstract

Cited by 33 (14 self)
 Add to MetaCart
Abstract. Termination is one of the most interesting problems when dealing with contextsensitive rewrite systems. Although there is a good number of techniques for proving termination of contextsensitive rewriting (CSR), the dependency pair approach, one of the most powerful techniques for proving termination of rewriting, has not been investigated in connection with proofs of termination of CSR. In this paper, we show how to use dependency pairs in proofs of termination of CSR. The implementation and practical use of the developed techniques yield a novel and powerful framework which improves the current stateoftheart of methods for proving termination of CSR.
muterm: A Tool for Proving Termination of ContextSensitive Rewriting
 Proc. of 15h International Conference on Rewriting Techniques and Applications, RTA’04, LNCS 3091:200209
, 2004
"... Restrictions of rewriting can eventually achieve termination by pruning all in nite rewrite sequences issued from every term. Contextsensitive rewriting (CSR) is an example of such a restriction. In CSR, the replacements in some arguments of the function symbols are permanently forbidden. This ..."
Abstract

Cited by 32 (24 self)
 Add to MetaCart
(Show Context)
Restrictions of rewriting can eventually achieve termination by pruning all in nite rewrite sequences issued from every term. Contextsensitive rewriting (CSR) is an example of such a restriction. In CSR, the replacements in some arguments of the function symbols are permanently forbidden. This paper describes muterm, a tool which can be used to automatically prove termination of CSR. The tool implements the generation of the appropriate orderings for proving termination of CSR by means of polynomial interpretations over the rational numbers.
Operational termination of membership equational programs. the ordersorted way
, 2008
"... Our main goal is automating termination proofs for programs in rewritingbased languages with features such as: (i) expressive type structures, (ii) conditional rules, (iii) matching modulo axioms, and (iv) contextsensitive rewriting. Specifically, we present a new operational termination method for ..."
Abstract

Cited by 24 (11 self)
 Add to MetaCart
Our main goal is automating termination proofs for programs in rewritingbased languages with features such as: (i) expressive type structures, (ii) conditional rules, (iii) matching modulo axioms, and (iv) contextsensitive rewriting. Specifically, we present a new operational termination method for membership equational programs with features (i)(iv) that can be applied to programs in membership equational logic (MEL). The method first transforms a MEL program into a simpler, yet semantically equivalent, conditional ordersorted (OS) program. Subsequent trasformations make the OSprogram unconditonal, and, finally, unsorted. In particular, we extend and generalize to this richer setting an ordersorted termination technique for unconditional OS programs proposed by Ölveczky and Lysne. An important advantage of our method is that it minimizes the use of conditional rules and produces simpler transformed programs whose termination is often easier to prove automatically.
Proving Termination of ContextSensitive Rewriting with MUTERM
, 2007
"... Contextsensitive 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 f ..."
Abstract

Cited by 20 (18 self)
 Add to MetaCart
Contextsensitive 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 MUTERM which we present here implements all currently known techniques. Furthermore, we show how to combine them to furnish MUTERM with an expert which is able to automatically perform the termination proofs. Finally, we provide a first experimental evaluation of the tool.
Lazy Rewriting and ContextSensitive Rewriting
 Electronic Notes in Theoretical Computer Science, volume 64. Elsevier Sciences
, 2002
"... Lazy rewriting (LR) is intended to improve the termination behavior of TRSs. This is attempted by restricting reductions for selected arguments of functions. Similarly, contextsensitive rewriting (CSR) forbids any reduction on those arguments. We show that, under certain conditions, LR and CSR coin ..."
Abstract

Cited by 14 (10 self)
 Add to MetaCart
(Show Context)
Lazy rewriting (LR) is intended to improve the termination behavior of TRSs. This is attempted by restricting reductions for selected arguments of functions. Similarly, contextsensitive rewriting (CSR) forbids any reduction on those arguments. We show that, under certain conditions, LR and CSR coincide. On the basis of this result, we also describe a transformation which permits proving termination of LR as termination of CSR for the transformed system. Since there is a number of different techniques for proving termination of CSR, this provides a (first) formal framework for proving termination of lazy rewriting.
Improving ContextSensitive Dependency Pairs
, 2008
"... Contextsensitive dependency pairs (CSDPs) are currently the most powerful method for automated termination analysis of contextsensitive rewriting. However, compared to DPs for ordinary rewriting, CSDPs suffer from two main drawbacks: (a) CSDPs can be collapsing. This complicates the handling o ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
(Show Context)
Contextsensitive dependency pairs (CSDPs) are currently the most powerful method for automated termination analysis of contextsensitive rewriting. However, compared to DPs for ordinary rewriting, CSDPs suffer from two main drawbacks: (a) CSDPs can be collapsing. This complicates the handling of CSDPs and makes them less powerful in practice. (b) There does not exist a “DP framework” for CSDPs which would allow one to apply them in a flexible and modular way. This paper solves drawback (a) by introducing a new definition of CSDPs. With our definition, CSDPs are always noncollapsing and thus, they can be handled like ordinary DPs. This allows us to solve drawback (b) as well, i.e., we extend the existing DP framework for ordinary DPs to contextsensitive rewriting. We implemented our results in the tool AProVE and successfully evaluated them on a large collection of examples.
Termination of (Canonical) ContextSensitive Rewriting
 Proc. of 13th International Conference on Rewriting Techniques and Applications, RTA'02, LNCS
, 2002
"... Contextsensitive rewriting (CSR) is a restriction of rewriting which forbids reductions on selected arguments of functions. A replacement map discriminates, for each symbol of the signature, the argument positions on which replacements are allowed. If the replacement restrictions are less restr ..."
Abstract

Cited by 10 (6 self)
 Add to MetaCart
(Show Context)
Contextsensitive rewriting (CSR) is a restriction of rewriting which forbids reductions on selected arguments of functions. A replacement map discriminates, for each symbol of the signature, the argument positions on which replacements are allowed. If the replacement restrictions are less restrictive than those expressed by the socalled canonical replacement map, then CSR can be used for computing (infinite) normal forms of terms. Termination of such canonical CSR is desirable when using CSR for these purposes. Existing transformations for proving termination of CSR fulfill a number of new properties when used for proving termination of canonical CSR.
Improving the Contextsensitive Dependency Graph
, 2007
"... The dependency pairs method is one of the most powerful technique for proving termination of rewriting and it is currently central in most automatic termination provers. Recently, it has been adapted to be used in proofs of termination of contextsensitive rewriting. The use of collapsing dependency ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
The dependency pairs method is one of the most powerful technique for proving termination of rewriting and it is currently central in most automatic termination provers. Recently, it has been adapted to be used in proofs of termination of contextsensitive rewriting. The use of collapsing dependency pairs i.e., having a single variable in the righthand side is a novel and essential feature to obtain a correct framework in this setting. Unfortunately, dependency pairs behave as a kind of glue in the contextsensitive dependency graph which makes the cycles bigger, thus making some proofs of termination harder. In this paper we show that this effect can be safely mitigated by removing some arcs from the graph, thus leading to faster and easier proofs. Narrowing dependency pairs is also introduced and used here to eventually simplify the treatment of the contextsensitive dependency graph. We show the practicality of the new techniques with some benchmarks.
Natural narrowing for general term rewriting systems
 Proc. of 16th International Conference on Rewriting Techniques and Applications, RTA’05, Lecture Notes in Computer Science
, 2005
"... Abstract. For narrowing to be an efficient evaluation mechanism, several lazy narrowing strategies have been proposed, although typically for the restricted case of leftlinear constructor systems. These assumptions, while reasonable for functional programming applications, are too restrictive for a ..."
Abstract

Cited by 10 (7 self)
 Add to MetaCart
(Show Context)
Abstract. For narrowing to be an efficient evaluation mechanism, several lazy narrowing strategies have been proposed, although typically for the restricted case of leftlinear constructor systems. These assumptions, while reasonable for functional programming applications, are too restrictive for a much broader range of applications to which narrowing can be fruitfully applied, including applications where rules have a nonequational meaning either as transitions in a concurrent system or as inferences in a logical system. In this paper, we propose an efficient lazy narrowing strategy called natural narrowing which can be applied to general term rewriting systems with no restrictions whatsoever. An important consequence of this generalization is the wide range of applications that can now be efficiently supported by narrowing. We highlight a few such applications including symbolic model checking, theorem proving, programming languages, and partial evaluation. What thus emerges is a general and efficient unified mechanism based on narrowing, that seamlessly integrates a very wide range of applications in programming and proving. 1