Abstract not found

. We consider how mode (such as input and output) and termination properties of typed higher-order constraint logic programming languages may be declared and checked effectively. The systems that we present have been validated through an implementation and numerous case studies. 1 Introduction Just like other paradigms logic programming benefits tremendously from types. Perhaps most importantly, types allow the early detection of errors when a program is checked against a type specification. With some notable exceptions most type systems proposed for logic programming languages to date (see [18]) are concerned with the declarative semantics of programs, for example, in terms of many-sorted, order-sorted, or higher-order logic. Operational properties of logic programs which are vital for their correctness can thus neither be expressed nor checked and errors will remain undetected. In this paper we consider how the declaration and checking of mode (such as input and output) and termina...

This paper shows that the annotation proof method, proposed by Deransart for proving declarative properties of logic programs, is also applicable for proving correctness of directional types. In particular, the sufficient correctness criterion of well-typedness by Bronsard et al, turns out to be a specialization of the annotation method. The comparison shows a general mechanism for construction of similar specializations, which is applied to derive yet another concept of well-typedness. The usefulness of the new correctness criterion is shown on examples of Prolog programs, where the traditional notion of well-typedness is not applicable. We further show that the new well-typing condition can be applied to different execution models. This is illustrated by an example of an execution model where unification is controlled by directional types, and where our new well-typing condition is applied to show the absence of deadlock. / 1. INTRODUCTION

This paper investigates the role of coroutining in the termination of logic programs. We define a variant of SLD resolution, in which the execution of atoms may be suspended indefinitely, and give some basic results concerning success, finite failure and floundering. Next we discuss how correct procedures can be combined to form new procedures using disjunction, conjunction and recursion. We argue that modes are crucial to reasoning about termination and show that cyclic modes are the basic reason for conjunctions looping. When recursion is used we identify another cause of loops: speculative binding of output variables. That is, binding output variables before it is known that a solution to a subcomputation exists. Keywords: mode, flounder, Prolog, stream and-parallelism -- 1 -- 1 Introduction

Linear Logic is gaining momentum in computer science because it offers a unified framework and a common vocabulary for studying and analyzing different aspects of programming and computation. We focus here on models where computation is identified with proof search in the sequent system of Linear Logic. A proof normalization procedure, called "focusing", has been proposed to make the problem of proof search tractable. Correspondingly, there is a normalization procedure mapping formulae of Linear Logic into a syntactic fragment of that logic, called LinLog, and in which the focusing normalization for proofs can be most conveniently expressed. In this paper, we propose to push this compilation/normalization process further, by applying abstract interpretation and partial evaluation techniques to (focused) proofs in LinLog. These techniques provide information concerning the evolution of the computational resources (formulae) during the execution (proof construction). The practical outcome that we expect from this theoretical effort is the definition of a general tool for statically analyzing and reasoning about the runtime behavior of programs in frameworks where computations can be accounted for in terms of proof search in Linear Logic.

Linear Logic is gaining momentum in computer science because it offers a unified framework and a common vocabulary for studying and analyzing different aspects of programming and computation. We focus here on models where computation is identified with proof search in the sequent system of Linear Logic. A proof normalization procedure, called "focusing", has been proposed to make the problem of proof search tractable. Correspondingly,

Abstract not found

In this paper we present a new type system for logic programs. Our system combines ideas of the classical polymorphic, but not very precise, system due to Mycroft and O'Keefe [16], and the complementary system of directional types that has been proposed by Aiken and Lakshman [1].

Abstract. Aldwych is a general purpose programming language which we have developed in order to provide a mechanism for practical programming which can be thought of in an inherently concurrent way. We have described Aldwych elsewhere [13] in terms of a translation to a concurrent logic language. However, it would be more accurate to describe it as translating to a simple operational language which, while able to be represented in a logic-programming like syntax, has lost much of the baggage associated with “logic programming”. This language is only a little more complex than foundational calculi such as the pi-calculus. Its key feature is that all variables are moded with a single producer, and some are linear allowing a reversal of polarity and hence interactive communication.

This paper provides a computational model that uses no parallelism, thus suggesting that there is no inherent link between classical linear logic and parallelism. The involutive negation of classical linear logic is usually given an intuitive explanation in terms of interchanging `questions' and `answers'. The model presented here makes this intuition precise. There are in fact two levels of duality: `values' are dual to `demands', and `yielders' are dual to `acceptors'. In the past, the connective