Results 1  10
of
19
Natural termination
 Theoretical Computer Science
"... Abstract. We generalize the various path orderings and the conditions under which they work, and describe an implementation of this general ordering. We look at methods for proving termination of orthogonal systems and give a new solution to a problem of Zantema's. 1 ..."
Abstract

Cited by 83 (11 self)
 Add to MetaCart
Abstract. We generalize the various path orderings and the conditions under which they work, and describe an implementation of this general ordering. We look at methods for proving termination of orthogonal systems and give a new solution to a problem of Zantema's. 1
Writing Larch Interface Language Specifications
 ACM Transactions on Programming Languages and Systems
, 1987
"... Current research in specifications is emphasizing the practical use of formal specifications in program design. One way to encourage their use in practice is to provide specification languages that are accessible to both designers and programmers. With this goal in mind, the Larch family of formal s ..."
Abstract

Cited by 72 (2 self)
 Add to MetaCart
Current research in specifications is emphasizing the practical use of formal specifications in program design. One way to encourage their use in practice is to provide specification languages that are accessible to both designers and programmers. With this goal in mind, the Larch family of formal specification languages has evolved to support a twotiered approach to writing specifications. This approach separates the specification of state transformations and programming language dependencies from the specification of underlying abstractions. Thus, each member of the Larch family has a subset derived from a programming language and another subset independent of any programming languages. We call the former interface languages, and the latter the Larch Shared Language. This paper focuses on Larch interface language specifications. Through examples, we illustrate some salient features of Larch/CLU, a Larch interface language for the programming language CLU. We give an example of writing an interface specification following the twotiered approach and discuss in detail issues involved in writing interface specifications and their interaction with their Shared Language components.
A Transformational Methodology for Proving Termination of Logic Programs
, 1991
"... this paper, we present a transformational approach for proving termination of logic programs by reducing the termination problem of logic programs to that of term rewriting systems. The termination problem of term rewriting systems has been well studied and many useful techniques and tools have been ..."
Abstract

Cited by 34 (5 self)
 Add to MetaCart
this paper, we present a transformational approach for proving termination of logic programs by reducing the termination problem of logic programs to that of term rewriting systems. The termination problem of term rewriting systems has been well studied and many useful techniques and tools have been developed for proving termination of term rewriting systems. The prime motivation of our approach is to facilitate the use of this vast source of termination techniques and tools in proving termination of logic programs.
Mechanical Translation of Set Theoretic Problem Specifications Into Efficient RAM Code  A Case Study
 Proc. EUROCAL 85
, 1985
"... This paper illustrates a fully automatic topdown approach to program development in which formal problem specifications are mechanically translated into efficient RAM code. This code is guaranteed to be totally correct and an upper bound on its worst case asymptotic running time is automatically de ..."
Abstract

Cited by 26 (8 self)
 Add to MetaCart
This paper illustrates a fully automatic topdown approach to program development in which formal problem specifications are mechanically translated into efficient RAM code. This code is guaranteed to be totally correct and an upper bound on its worst case asymptotic running time is automatically determined. The user is only required to supply the system with a formal problem specification, and is relieved of all responsibilities in the rest of the program development process. These results are obtained, in part, by greatly restricting the system to handle a class of determinate, set theoretic, tractable problems. The most essential transformational techniques that are used are fixed point iteration, finite differencing, and data structure selection. Rudimentary forms of these techniques have been implemented and used effectively in the RAPTS transformational programming system. This paper explains the conceptual underpinnings of our approach by considering the problem of attribute closure for relational databases and systematically deriving a program that implements a linear time solution. 1.
The termination competition
 In Proc. RTA ’07, LNCS 4533
, 2007
"... Abstract. Since 2004, a Termination Competition is organized every year. This competition boosted a lot the development of automatic termination tools, but also the design of new techniques for proving termination. We present the background, results, and conclusions of the three first editions, and ..."
Abstract

Cited by 14 (0 self)
 Add to MetaCart
Abstract. Since 2004, a Termination Competition is organized every year. This competition boosted a lot the development of automatic termination tools, but also the design of new techniques for proving termination. We present the background, results, and conclusions of the three first editions, and discuss perspectives and challenges for the future. 1 Motivation and
Proving Termination using Recursive Path Orders and SAT solving
 IN PROC. FROCOS ’07, LNAI 4720
, 2007
"... We introduce a propositional encoding of the recursive path order with status (RPO). RPO is a combination of a multiset path order and a lexicographic path order which considers permutations of the arguments in the lexicographic comparison. Our encoding allows us to apply SAT solvers in order to d ..."
Abstract

Cited by 14 (9 self)
 Add to MetaCart
We introduce a propositional encoding of the recursive path order with status (RPO). RPO is a combination of a multiset path order and a lexicographic path order which considers permutations of the arguments in the lexicographic comparison. Our encoding allows us to apply SAT solvers in order to determine whether a given term rewrite system is RPOterminating. Furthermore, to apply RPO within the dependency pair framework, we combined our novel encoding for RPO with an existing encoding for argument filters. We implemented our contributions in the termination prover AProVE. Our experiments show that due to our encoding, combining termination provers with SAT solvers improves the performance of RPOimplementations by orders of magnitude.
A Methodology For Proving Termination Of Logic Programs
 JLP
, 1991
"... In this paper, we describe a methodology for proving termination of logic programs. First, we introduce Ugraphs as an abstraction of logic programs and establish that SLDNFderivations can be realized by instances of paths in the Ugraphs. Such a relation enables us to use Ugraphs for establishing ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
In this paper, we describe a methodology for proving termination of logic programs. First, we introduce Ugraphs as an abstraction of logic programs and establish that SLDNFderivations can be realized by instances of paths in the Ugraphs. Such a relation enables us to use Ugraphs for establishing the universal termination of logic programs. In our method, we associate pre and postassertions to the nodes of the graph and ordered assertions to selected edges of the graph. With this as the basis, we develop a simple method for establishing the termination of logic programs. The simplicity/practicality of the method is illustrated through examples. 1 Introduction One of the most important features of logic programming is its declarative semantics. That is, one can consider the programs to be selfspecifying as they are nonprocedural, and hence do not need elaborate correctness proofs. There can be a debate about whether it is meaningful to talk about verifying logic programs. It wil...
A Survey of Formal Software Development Methods
 SOFTWARE ENGINEERING
, 1988
"... This paper is a survey of the current state of the art of research on methods for formal software development. The scope of this paper is necessarily restricted so as to avoid discussion of a great many approaches at a very superficial level. First, although some of the ideas discussed below could b ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
This paper is a survey of the current state of the art of research on methods for formal software development. The scope of this paper is necessarily restricted so as to avoid discussion of a great many approaches at a very superficial level. First, although some of the ideas discussed below could be (and have been) applied to hardware development as well as to software development, this topic will not be treated here. Second, the special problems involved in the development of concurrent systems will not be discussed here although again many of the approaches mentioned below could be applied in this context. Third, no attempt is made to treat programming methodologies such as Jackson's method and program development systems such as the MIT Programmer's Apprentice which are not formally based. Finally, this survey does not claim to be fully exhaustive although an attempt has been made to cover most of the main approaches. Many of the technical details of the different approaches discussed have been glossed over or simplified for the purposes of this presentation; full details may be found in the cited references.
Proving Termination of GHC Programs
, 1997
"... A transformational approach for proving termination of parallel logic programs such as GHC programs is proposed. A transformation from GHC programs to term rewriting systems is developed; it exploits the fact that unications in GHCresolution correspond to matchings. The termination of a GHC program ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
A transformational approach for proving termination of parallel logic programs such as GHC programs is proposed. A transformation from GHC programs to term rewriting systems is developed; it exploits the fact that unications in GHCresolution correspond to matchings. The termination of a GHC program for a class of queries is implied by the termination of the resulting rewrite system. This approach facilitates the applicability of a wide range of termination techniques developed for rewrite systems in proving termination of GHC programs. The method consists of three steps: (a) deriving moding information from a given GHC program, (b) transforming the GHC program into a term rewriting system using the moding information, and nally (c) proving termination of the resulting rewrite system. Using this method, the termination of many benchmark GHC programs such as quicksort, mergesort, merge, split, fairsplit and append, etc., can be proved.
Verification Tools in the Development of Provably Correct Compilers
 Proc. of 5 th Symp. on Formal Methods Europe, FME'93, Lecture Notes in Computer Science 670
, 1993
"... The paper presents a practical verification tool that helps in the development of provably correct compilers. The tool is based on the approach of proving termination of PROLOGlike programs using termrewriting techniques and a technique of testing whether a given PROLOG program can be soundly exec ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
The paper presents a practical verification tool that helps in the development of provably correct compilers. The tool is based on the approach of proving termination of PROLOGlike programs using termrewriting techniques and a technique of testing whether a given PROLOG program can be soundly executed on PROLOG interpreters without the Occurcheck test. The tool has been built on top of the theorem prover, RRL (Rewrite Rule Laboratory). The tool is effective for compilers developed using Hoare's refinement algebra approach. The utility of the tool is illustrated through a case study on correctness of a prototype compiler of the ProCoS level 0 language PL0.