Abstract not found

Current norm-based automatic... In this paper we present a new termination analysis which integrates the various components and produces a set of constraints that, when solvable, identifies successful termination proofs. The proposed method is both efficient and precise. The use of constraint sets enables the propagation of information over all different phases while the need for multiple analyses is considerably reduced.

At present, the field of declarative programming is split into two main areas based on different formalisms; namely, functional programming, which is based on lambda calculus, and logic programming, which is based on firstorder logic. There are currently several language proposals for integrating the expressiveness of these two models of computation. In this thesis we work towards an integration of the methodology from the two research areas. To this end, we propose an algebraic approach to reasoning about logic programs, corresponding to the approach taken in functional programming. In the first half of the thesis we develop and discuss a framework which forms the basis for our algebraic analysis and transformation methods. The framework is based on an embedding of definite logic programs into lazy functional programs in Haskell, such that both the declarative and the operational semantics of the logic programs are preserved. In spite of its conciseness and apparent simplicity, the embedding proves to have many interesting properties and it gives rise to an algebraic semantics of logic programming. It also allows us to reason about logic programs in a simple calculational style, using rewriting and the algebraic laws of combinators. In the embedding, the meaning of a logic program arises compositionally from the meaning of its constituent subprograms and the combinators that connect them. In the second half of the thesis we explore applications of the embedding to the algebraic transformation of logic programs. A series of examples covers simple program derivations, where our techniques simplify some of the current techniques. Another set of examples explores applications of the more advanced program development techniques from the Algebra of Programming by Bird and de Moor [18], where we expand the techniques currently available for logic program derivation and optimisation. To my parents, Sandor and Erzsebet. And the end of all our exploring Will be to arrive where we started And know the place for the first time.

This paper studies the relationship between logic programs and term rewriting systems (TRSs). A compositional transform is defined which given a logic program computes a TRS. For a relevant class of logic programs, called Simply Well Moded (SWM), there is a one-to-one correspondence between computed answer substitutions of the logic program and normal forms of the corresponding TRS. Moreover the transform preserves termination, i.e., a logic program terminates iff the corresponding TRS terminates. This transform is refined in such a way that the above results hold for a relevant class of unification free programs containing SWM, the class of Flatly Well Moded (FWM) programs. Note: This work was done during an author's stay at CWI, Amsterdam. 1 Introduction The study of transforms from logic programs into term rewriting systems (TRSs for short) is an important topic. Theoretically, it is interesting to analyze which classes of logic programs can be regarded as TRSs in disguise. Practic...

. We introduce a transformation of well-moded logic programs into constructor systems, a subclass of term rewrite systems, such that left-termination of the logic program follows from termination of the derived constructor system. Thereafter, we present a new technique to prove termination of constructor systems. In the technique semantic unification is used. Thus, surprisingly, semantic unification can be used for giving termination proofs for logic programs. Parts of the technique can be automated very easily. Other parts can be automated for subclasses of constructor systems. The technique is powerful enough to prove termination of some constructor systems that are not simply terminating, and therefore, the technique is suitable to prove termination of some difficult logic programs. 1 Introduction Several approaches to prove termination of logic programs are proposed (for a survey see [SD93]). One of the approaches, introduced by Krishna Rao et al. [KKS91], is to transf...

The Constraint Logic Programming (CLP) Scheme merges logic programming with constraint solving over predefined domains. In this paper, we study proof methods for universal left termination of constraint logic programs. We provide a sound and complete characterization of left termination for ideal CLP languages which generalizes acceptability of logic programs. The characterization is then refined to the notion of partial acceptability, which is well-suited for automatic modular inference. We describe a theoretical framework for automation of the approach, which is implemented. For non-ideal CLP languages and without any assumption on their incomplete constraint solvers, even the most basic sound termination criterion from logic programming does not lift. We focus on a specific system, namely CLP(R), by proposing some additional conditions that make (partial) acceptability sound

We propose automatically proving termination of logic programs by transforming them into term rewrite systems (TRS). We describe such a transformation for which termination of the logic program follows from innermost termination of the TRS, which is stronger than previous results. Semantic labelling turns out to be a powerful tool for proving termination of this kind of TRSs: we use it to prove termination of the TRS corresponding to any structural recursive logic program, and also for proving termination of implementations of quick-sort and generation of permutations.

In this paper, we describe a methodology for proving termination of logic programs. First, we introduce U-graphs as an abstraction of logic programs and establish that SLDNFderivations can be realized by instances of paths in the U-graphs. Such a relation enables us to use U-graphs for establishing the universal termination of logic programs. In our method, we associate pre- and post-assertions 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 self-specifying as they are non-procedural, 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...

Abstract. The most important open problem in the study of termination for logic programs is that of existential termination. Inthispaperwepresentapow erful transformational methodology that provides necessary (and, under some conditions, su cient) criteria for existential termination. The followed approach is to develop a suitable transformation from logic programs to Term Rewriting Systems (TRSs), such that proving termination of the obtained TRS implies existential termination of the original logic program. Thus, all the extensive amountofwork on termination for TRSs can be automatically used in the logic programming setting. Moreover, the approach isalsoabletocopewiththe dual notion of universal termination: in fact, a whole spectrum of termination properties, said k-termination,isinvestigated, of which universal and existential termination are the extremes. Also, a satisfactory treatment to the problem of termination for logic programming with negation is achieved. This way we provide a unique, uniform approachcovering all these di erent notions of termination. 1

We present a new approach to termination analysis of logic programs. The essence of the approach is that we make use of general orderings (instead of level mappings), like it is done in transformational approaches to logic program termination analysis, but we apply these orderings directly to the logic program and not to the term-rewrite system obtained through some transformation. We define some variants of acceptability, based on general orderings, and show how they are equivalent to LD-termination. We develop a demand driven, constraint-based approach to verify these acceptability-variants. The advantage