Results 1  10
of
33
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.
Rules and Strategies for Transforming Functional and Logic Programs
 ACM Computing Surveys
, 1996
"... We present an overview of the program transformation methodology, focusing our attention on the socalled `rules + strategies' approach in the case of functional and logic programs. The paper is intended to offer an introduction to the subject. The various techniques we present are illustrated via s ..."
Abstract

Cited by 76 (4 self)
 Add to MetaCart
We present an overview of the program transformation methodology, focusing our attention on the socalled `rules + strategies' approach in the case of functional and logic programs. The paper is intended to offer an introduction to the subject. The various techniques we present are illustrated via simple examples. A preliminary version of this report has been published in: Moller, B., Partsch, H., and Schuman, S. (eds.): Formal Program Development. Lecture Notes in Computer Science 755, Springer Verlag (1993) 263304. Also published in: ACM Computing Surveys, Vol 28, No. 2, June 1996. 3 1 Introduction The program transformation approach to the development of programs has first been advocated by [BurstallDarlington 77], although the basic ideas were already presented in previous papers by the same authors [Darlington 72, BurstallDarlington 75]. In that approach the task of writing a correct and efficient program is realized in two phases: the first phase consists in writing an in...
Optimal Normalization in Orthogonal Term Rewriting Systems
 In: Proc. of the 5 th International Conference on Rewriting Techniques and Applications, RTA'93
, 1993
"... . We design a normalizing strategy for orthogonal term rewriting systems (OTRSs), which is a generalization of the callbyneed strategy of HuetL'evy [4]. The redexes contracted in our strategy are essential in the sense that they have "descendants" under any reduction of a given term. There is an ..."
Abstract

Cited by 24 (20 self)
 Add to MetaCart
. We design a normalizing strategy for orthogonal term rewriting systems (OTRSs), which is a generalization of the callbyneed strategy of HuetL'evy [4]. The redexes contracted in our strategy are essential in the sense that they have "descendants" under any reduction of a given term. There is an essential redex in any term not in normal form. We further show that contraction of the innermost essential redexes gives an optimal reduction to normal form, if it exists. We classify OTRSs depending on possible kinds of redex creation as noncreating, persistent, insidecreating, nonleftabsorbing, etc. All these classes are decidable. TRSs in these classes are sequential, but they do not need to be strongly sequential. For noncreating and persistent OTRSs, we show that our optimal strategy is efficient as well. 1 Introduction In this paper, we study correct and optimal computations in Orthogonal Term Rewriting Systems (OTRSs). We only consider onestep rewriting strategies, which selec...
On Higher Order Recursive Program Schemes
 In: Proc. of the 19 th International Colloquium on Trees in Algebra and Programming, CAAP'94
"... . We define Higher Order Recursive Program Schemes (HRPSs) by allowing metasubstitutions (as in the calculus) in righthand sides of function and quantifier definitions. A study of several kinds of similarity of redexes makes it possible to lift properties of (first order) Recursive Program Schemes ..."
Abstract

Cited by 20 (16 self)
 Add to MetaCart
. We define Higher Order Recursive Program Schemes (HRPSs) by allowing metasubstitutions (as in the calculus) in righthand sides of function and quantifier definitions. A study of several kinds of similarity of redexes makes it possible to lift properties of (first order) Recursive Program Schemes to the higher order case. The main result is the decidability of weak normalization in HRPSs, which immediately implies that HRPSs do not have full computational power. We analyze the structural properties of HRPSs and introduce several kinds of persistent expression reduction systems (PERSs) that enjoy similar properties. Finally, we design an optimal evaluation procedure for PERSs. 1 Introduction Higher Order Recursive Program Schemes (HRPSs) are recursive definitions of functions, predicates, and quantifiers, considered as rewriting systems. Similar definitions are used when one extends a theory by introducing new symbols [16]. 9aA , (øa(A)=a)A and 9!aA , 9aA 8a8b(A (b=a)A ) a = b) a...
Space Usage in Functional Query Languages
 in "LNCS 893: Proceedings of 5th International Conference on Database Theory," 439454
, 1995
"... We consider evaluation strategies for database queries expressed in three functional query languages: the complex value algebra, the simply typed lambda calculus, and method schemas. Each of these query languages derives its expressive power from a different primitive: the complex value algebra fr ..."
Abstract

Cited by 16 (2 self)
 Add to MetaCart
We consider evaluation strategies for database queries expressed in three functional query languages: the complex value algebra, the simply typed lambda calculus, and method schemas. Each of these query languages derives its expressive power from a different primitive: the complex value algebra from the powerset operator, the simply typed lambda calculus from list iteration, and method schemas from recursion. We show that "natural" evaluation strategies for these primitives may lead to very inefficient space usage, but that with some simple optimizations many queries can be evaluated with little or no space overhead. In particular, we show: (1) In the complex value algebra, all expressions with set nesting depth at most 2 can be evaluated in pspace, and this set of expressions is sufficient to express all queries in the polynomial hierarchy; (2) In the simply typed lambda calculus with equality and constants, all query terms of order at most 5 (where "query term" is a syntactic condition on types) can be evaluated in pspace, and this set of terms expresses exactly the pspace queries; (3) There exists a set of secondorder method schemas (with no simple syntactic characterization) that can be evaluated in pspace, and this set of schemas is sufficient to express all pspace queries.
Pushing the Frontiers of Combining Rewrite Systems Farther Outwards
 In Proceedings of the Second International Workshop on Frontiers of Combining Systems, FroCos '98, Applied Logic Series
, 1998
"... It is well known that simple termination is modular for certain kinds of combinations of term rewriting systems (TRSs). This result is of practical relevance because most techniques for (automated) termination proofs use simplification orderings, so they show in fact simple termination. On the other ..."
Abstract

Cited by 11 (3 self)
 Add to MetaCart
It is well known that simple termination is modular for certain kinds of combinations of term rewriting systems (TRSs). This result is of practical relevance because most techniques for (automated) termination proofs use simplification orderings, so they show in fact simple termination. On the other hand, in practice many systems are nonsimply terminating. In order to cope with such systems, Arts and Giesl developed the dependency pair approach. By using (quasi)simplification orderings in combination with dependency pairs, it is possible to prove termination of nonsimply terminating systems automatically. It is natural to ask whether modularity of simple termination can be extended to the class of those systems which can be handled by this technique. In this paper we show that this is indeed the case. In this way, the class of TRSs for which termination can be proved in a modular way is extended significantly. 1 Introduction Modularity is a wellknown paradigm in computer science. ...
Perpetuality and Strong Normalization in Orthogonal Term Rewriting Systems
 In: Proc. of 11 th Symposium on Theoretical Aspects of Computer Science, STACS'94
, 1994
"... . We design a strategy that for any given term t in an Orthogonal Term Rewriting System (OTRS) constructs a longest reduction starting from t if t is strongly normalizable, and constructs an infinite reduction otherwise. For some classes of OTRSs the strategy is easily computable. We develop a metho ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
. We design a strategy that for any given term t in an Orthogonal Term Rewriting System (OTRS) constructs a longest reduction starting from t if t is strongly normalizable, and constructs an infinite reduction otherwise. For some classes of OTRSs the strategy is easily computable. We develop a method for finding the least upper bound of lengths of reductions starting from a strongly normalizable term. We give also some applications of our results. 1 Introduction It is shown in O'Donnell [12] that the innermost strategy is perpetual for orthogonal term rewriting systems (OTRSs). That is, contraction of innermost redexes gives an infinite reduction of a given term whenever such a reduction exists. In fact, a strategy that only contracts redexes that do not erase any other redex is perpetual. Moreover, one can even reduce redexes whose erased arguments are strongly normalizable (Klop [10]). For the lambdacalculus, a more subtle perpetual strategy was invented in Barendregt et al. [1]. H...
Hierarchies in Classes of Program Schemes
, 1999
"... We begin by proving that the class of problems accepted by the program schemes of NPS is exactly the class of problems defined by the sentences of transitive closure logic (program schemes of NPS are obtained by generalizing basic nondeterministic whileprograms whose tests within while instruction ..."
Abstract

Cited by 9 (9 self)
 Add to MetaCart
We begin by proving that the class of problems accepted by the program schemes of NPS is exactly the class of problems defined by the sentences of transitive closure logic (program schemes of NPS are obtained by generalizing basic nondeterministic whileprograms whose tests within while instructions are quantifierfree firstorder formulae). We then show that our program schemes form a proper infinite hierarchy within NPS whose analogy in transitive closure logic is a proper infinite hierarchy, the union of which is full transitive closure logic but for which every level of the hierarchy has associated with it a firstorder definable problem not in that level. We then proceed to add a stack to our program schemes, so obtaining the class of program schemes NPSS, and characterize the class of problems accepted by the program schemes of NPSS as the class of problems defined by the sentences of path system logic. We show that there is a proper infinite hierarchy within NPSS, with an analo...
Cones and Foci for Protocol Verification Revisited
 In Proc. 6th Conference on Foundations of Software Science and Computation Structures, LNCS 2620
, 2003
"... Abstract. We define a cones and foci proof method, which rephrases the question whether two system specifications are branching bisimilar in terms of proof obligations on relations between data objects. Compared to the original cones and foci method from Groote and Springintveld [22], our method is ..."
Abstract

Cited by 9 (4 self)
 Add to MetaCart
Abstract. We define a cones and foci proof method, which rephrases the question whether two system specifications are branching bisimilar in terms of proof obligations on relations between data objects. Compared to the original cones and foci method from Groote and Springintveld [22], our method is more generally applicable, and does not require a preprocessing step to eliminate τloops. We prove soundness of our approach and give an application. 1
Finite Model Theory In The Simply Typed Lambda Calculus
, 1994
"... Church's simply typed calculus is a very basic framework for functional programming language research. However, it is common to augment this framework with additional programming constructs, because its expressive power for functions over the domain of Church numerals is very limited. In this thesi ..."
Abstract

Cited by 8 (5 self)
 Add to MetaCart
Church's simply typed calculus is a very basic framework for functional programming language research. However, it is common to augment this framework with additional programming constructs, because its expressive power for functions over the domain of Church numerals is very limited. In this thesis: (1) We reexamine the expressive power of the "pure" simply typed calculus, but over encodings of finite relational structures, i. e., finite models or databases . In this novel framework the simply typed calculus expresses all elementary functions from finite models to finite models. In addition, many common database query languages, e. g., relational algebra, Datalog : , and the Abiteboul/Beeri complex object algebra, can be embedded into it. The embeddings are feasible in the sense that the terms corresponding to PTIME queries can be evaluated in polynomial time. (2) We examine fixedorder fragments of the simply typed calculus to determine machine independent characterizations of complexity classes. For this we augment the calculus with atomic constants and equality among atomic constants. We show that over ordered structures, the order 3, 4, 5, and 6 fragments express exactly the firstorder, PTIME, PSPACE, and EXPTIME queries, respectively, and we conjecture that for general k 1, order 2 k + 4 expresses exactly the kEXPTIME queries and order 2 k + 5 expresses exactly the kEXPSPACE queries. (3) We also reexamine other functional characterizations of PTIME and we show that method schemas with ordered objects express exactly PTIME. This is a firstorder framework proposed for objectoriented databasesas opposed to the above higherorder frameworks. In summary, this research provides a link between finite model theory (and thus computational complexity), dat...