Results 11  20
of
44
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 8 (1 self)
 Add to MetaCart
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.
MTT: The Maude Termination Tool (System Description) ⋆
"... Despite the remarkable development of the theory of termination of rewriting, its application to highlevel programming languages is far from being optimal. This is due to the need for features such as conditional equations and rules, types and subtypes, (possibly programmable) strategies for contro ..."
Abstract

Cited by 8 (4 self)
 Add to MetaCart
Despite the remarkable development of the theory of termination of rewriting, its application to highlevel programming languages is far from being optimal. This is due to the need for features such as conditional equations and rules, types and subtypes, (possibly programmable) strategies for controlling the execution,
Termination of Programs with Strategy Annotations
, 2003
"... Strategy annotations have been used in a number of programming languages and rewritingbased systems (e.g., OBJ2, OBJ3, CafeOBJ, Maude, JITty, µCRL, . . . ) for improving the termination behavior and avoiding useless computations. Regarding the ability of these annotations to improve the termina ..."
Abstract

Cited by 6 (6 self)
 Add to MetaCart
Strategy annotations have been used in a number of programming languages and rewritingbased systems (e.g., OBJ2, OBJ3, CafeOBJ, Maude, JITty, µCRL, . . . ) for improving the termination behavior and avoiding useless computations. Regarding the ability of these annotations to improve the termination behavior of programs, the possibility of forbidding reductions on some arguments of function symbols play a crucial role. From an abstract
Generalizing Newman’s Lemma for leftlinear rewrite systems
 Proc. RTA’06,, LNCS 4098
, 2006
"... Abstract. Confluence criteria for nonterminating rewrite systems are knowntoberareandnotoriouslydifficulttoobtain.Hereweprovea new result in this direction. Our main result is a generalized version of Newman’s Lemma for leftlinear term rewriting systems that does not need a full termination assump ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
Abstract. Confluence criteria for nonterminating rewrite systems are knowntoberareandnotoriouslydifficulttoobtain.Hereweprovea new result in this direction. Our main result is a generalized version of Newman’s Lemma for leftlinear term rewriting systems that does not need a full termination assumption. We discuss its relationships to previous confluence criteria, its restrictions, examples of application as well as open problems. The whole approach is developed in the (more general) framework of contextsensitive rewriting which thus turns out to be useful also for ordinary (contextfree) rewriting. 1
Termination of innermost contextsensitive rewriting using dependency pairs
 In Proceedings of the 6th International Symposium on Frontiers of Combining Systems. lnai
"... Abstract. Innermost contextsensitive rewriting has been proved useful for modeling computations of programs of algebraic languages like Maude, OBJ, etc. Furthermore, innermost termination of rewriting is often easier to prove than termination. Thus, under appropriate conditions, a useful strategy f ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
Abstract. Innermost contextsensitive rewriting has been proved useful for modeling computations of programs of algebraic languages like Maude, OBJ, etc. Furthermore, innermost termination of rewriting is often easier to prove than termination. Thus, under appropriate conditions, a useful strategy for proving termination of rewriting is trying to prove termination of innermost rewriting. This phenomenon has also been investigated for contextsensitive rewriting (CSR). Up to now, only few transformations have been proposed and used to prove termination of innermost CSR. In this paper, we investigate direct methods for proving termination of innermost CSR. We adapt the recently introduced contextsensitive dependency pairs approach to innermost CSR and show that they can be advantageously used for proving termination of innermost CSR. We have implemented them as part of the termination tool muterm. 1
New Evaluation Commands for Maude Within Full Maude
, 2005
"... Maude is able to deal with infinite data structures and avoid infinite computations by using strategy annotations. However, they can eventually make the computation of the normal form(s) of some input expressions impossible. We have used Full Maude to implement two new commands norm and eval which f ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
Maude is able to deal with infinite data structures and avoid infinite computations by using strategy annotations. However, they can eventually make the computation of the normal form(s) of some input expressions impossible. We have used Full Maude to implement two new commands norm and eval which furnish Maude with the ability to compute (constructor) normal forms of initial expressions even when the use of strategy annotations together with the builtin computation strategy of Maude is not able to obtain them. These commands have been integrated into Full Maude, making them available inside the programming environment like any other of its commands.
Usable Rules for ContextSensitive Rewrite System
, 2008
"... Recently, the dependency pairs (DP) approach has been generalized to contextsensitive rewriting (CSR). Although the contextsensitive dependency pairs (CSDP) approach provides a very good basis for proving termination of CSR, the current developments basically correspond to a tenyearsold DP app ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
Recently, the dependency pairs (DP) approach has been generalized to contextsensitive rewriting (CSR). Although the contextsensitive dependency pairs (CSDP) approach provides a very good basis for proving termination of CSR, the current developments basically correspond to a tenyearsold DP approach. Thus, the task of adapting all recently introduced dependency pairs techniques to get a more powerful approach becomes an important issue. In this direction, usable rules are one of the most interesting and powerful notions. Actually usable rule have been investigated in connection with proofs of innermost termination of CSR. However, the existing results apply to a quite restricted class of systems. In this paper, we introduce a notion of usable rules that can be used in proofs of termination of CSR with arbitrary systems. Our benchmarks show that the performance of the CSDP approach is much better when such usable rules are considered in proofs of termination of CSR.
Completeness and Strictness Analysis for the Evaluation Strategy
 RIEC, Tohoku University
, 2001
"... We propose two analyses of the evaluation strategy (the Estrategy). Firstly, we analyze a completeness of the Estrategy. For a complete Estrategy each evaluated term is guaranteed to be a normal form. In this paper we define the notion of the completeness for the contextsensitive rewriting, c ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
We propose two analyses of the evaluation strategy (the Estrategy). Firstly, we analyze a completeness of the Estrategy. For a complete Estrategy each evaluated term is guaranteed to be a normal form. In this paper we define the notion of the completeness for the contextsensitive rewriting, called completeness, and show a condition of the Estrategy to satisfy the completeness. Secondarily, we give a strictness analysis for the Estrategy. A function is called strict in a certain argument if the evaluation of that argument does not change the termination behaviour. From the analyses, we can define a method to get a more effective default strategy for the Estrategy.
Evaluation Strategies for Term Rewriting Systems
, 2002
"... Term rewriting systems are widely used in computer science as a model of computation to relate syntax and semantics. In order to implement term rewriting system we need to use a strategy since there are many reduction sequences from a term in general. A strategy chooses one from such sequences. It i ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Term rewriting systems are widely used in computer science as a model of computation to relate syntax and semantics. In order to implement term rewriting system we need to use a strategy since there are many reduction sequences from a term in general. A strategy chooses one from such sequences. It is a function that takes a term to be rewritten and returns a term obtained by rewriting from the input term. There are two wellknown strategies: innermost strategies (or eager evaluation) and outermost strategies (or lazy evaluation). Innermost strategies can be implemented much more efficiently than outermost ones, while outermost strategies often have a better termination behavior than innermost ones. The evaluation strategy (the Estrategy), which is adopted by the family of OBJ algebraic specification languages, is one of the compromises between them. The Estrategy is more flexible than other fixed order of evaluation because each function symbol can have its own local strategy...
Termination of Lazy Rewriting Revisited
, 2007
"... Lazy rewriting is a proper restriction of term rewriting that dynamically restricts the reduction of certain arguments of functions in order to obtain termination. In contrast to contextsensitive rewriting, reductions at such argument positions are not completely forbidden but delayed. Based on the ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Lazy rewriting is a proper restriction of term rewriting that dynamically restricts the reduction of certain arguments of functions in order to obtain termination. In contrast to contextsensitive rewriting, reductions at such argument positions are not completely forbidden but delayed. Based on the observation that the only existing (nontrivial) approach to prove termination of such lazy rewrite systems is flawed, we develop a modified approach for transforming lazy rewrite systems into contextsensitive ones that is sound and complete with respect to termination. First experimental results with this transformation based technique are encouraging.