We discuss the declarative and computational issues in combining equational, subset, and relational assertions in a logic programming language. The novel feature in this work is the subset assertion, whose interactions with equational and relational assertions are discussed in this paper. The semantics of subset assertions incorporate a collect all capability, which is expressed formally by the completion of the program. When used in conjunction with equational assertions, subset assertions serve to define set-valued functions, and the resulting paradigm is called subset-equational programming. We also present the class of stratified subset-equational programs for formalizing the class of closure functions, which are useful in defining various transitive-closure sets. The declarative and operational semantics of simple and stratified subset-equational programs are the main focus of this paper. The operational semantics of closures is based on memo-tables (or extension tables). When sub...

This paper shows the use of partial-order program clauses and lattice domains for declarative programming. This paradigm is particularly useful for expressing concise solutions to problems from graph theory, program analysis, and database querying. These applications are characterized by a need to solve circular constraints and perform aggregate operations, a capability that is very clearly and efficiently provided by partial-order clauses. We present a novel approach to their declarative and operational semantics, as well as the correctness of the operational semantics. The declarative semantics is model-theoretic in nature, but the least model for any function is not the classical intersection of all models, but the greatest lower bound/least upper bound of the respective terms defined for this function in the different models. The operational semantics combines top-down goal reduction with memo-tables. In the partial-order programming framework, however, memoization is primarily nee...

Machine (WAM) to implement the paradigm and that these changes blend well with the overall machinery of the WAM. A central feature in the implementation of subset-logic programs is that of a monotonic memo-table, i.e., a memo-table whose entries can monotonically grow or shrink in an appropriate partial order. We present in stages the paradigm of subset-logic progams, showing the effect of each feature on the implementation. The implementation has been completed, and we present performance figures to show the efficiency and costs of memoization. Our conclusion is that the monotonic memo-tables are a practical tool for implementing a set-oriented logic programming language. We also compare this system with other closely related systems, especially XSB and CORAL. Keywords: subset and relational program clauses, sets, set matching and unification, memo tables, monotonic aggregation, Warren Abstract Machine, run-time structures, performance analysis / Address correspondence to...

Subset-logic programs are built up of three kinds of program clauses: subset, equational, and relational clauses. Using these clauses, we can program solutions to a broad range of problems of interest in logic programming and deductive databases. In an earlier paper [Jay92], we discussed the implementation of subset and equational program clauses. This paper substantially extends that work, and focuses on the more expressive paradigm of subset and relational clauses. This paradigm supports setof operations, transitive closures, monotonic aggregation as well as incremental and lazy eager enumeration of sets. Although the subset-logic paradigm differs substantially from that of Prolog, we show that few additional changes are needed to the WAM [War83] to implement the paradigm and that these changes blend well with the overall machinery of the WAM. A central feature in the implementation of subset-logic programs is that of a "monotonic memo-table," i.e., a memo-table who entries can monot...

Set-based languages have emerged as a powerful means for expressing not only programs but also requirements, test cases and so on. However, a uniform compilation schema for sets has not yet been completely developed. The present paper tries to overcome this lack using a set-based logic language, SL (set language), as target. The approach is based on an imperative abstract machine, the SAM (set abstract machine). The translation from SL to SAL (SAM assembly language) is described and all the possible optimizations, both at source code level and at assembly code level, are detailed. The potentials for identifying parallel flows of computations are analysed. Several examples of compilations are presented and discussed.

This paper shows the use of partial-order assertions and lattice domains for logic programming. We illustrate the paradigm using a variety of examples, ranging from program analysis to deductive databases. These applications are characterized by a need to solve circular constraints and perform aggregate operations. We show in this paper that defining functions with subset assertions and, more generally, partial-order assertions renders clear formulations to problems involving aggregate operations (first-order and inductive) and recursion. Indeed, as pointed out by Van Gelder [V92], for many problems in which the use of aggregates has been proposed, the concept of subset is what is really necessary. We provide model-theoretic and operational semantics, and prove the correctness of the latter. Our proposed operational semantics employs a mixed strategy: top-down with memoization and bottom-up fixed-point iteration. Keywords: Partial Orders, Lattices, Monotonic Operations, Aggregation, S...

The objective of this thesis is to explore the connections between abstract interpretation and attribute grammars as frameworks in program analysis. Abstract interpretation is a semantics-based program analysis method. A large class of data flow analysis problems can be expressed as non-standard semantics where the “meaning ” contains information about the runtime behaviour of programs. In an abstract interpretation the analysis is proved correct by relating it to the usual semantics for the language. Attribute grammars provide a method and notation to specify code generation and program analysis directly from the syntax of the programming language. They are especially used for describing compilation of programming languages and very efficient evaluators have been developed for subclasses of attribute grammars. By relating abstract interpretation and attribute grammars we obtain a closer connection between the specification and implementation of abstract interpretations which at the same time facilitates the correctness proofs of interpretations. Implementation and specification of abstract interpretations using circular attribute grammars is realised with an evaluator system for a class of domain theoretic attribute grammars. In this system thecircularity of attribute grammars is resolved by fixpoint iteration. The use of finite lattices in abstract interpretations requires automatic generation of specialised fixpoint iterators. This is done using a technique called lazy fixpoint iteration which is presented in the thesis. Methods from abstract interpretation can also be used in correctness proofs of attribute grammars. This proof technique introduces a new class of attribute grammars based on domain theory. This method is illustrated with examples. i ii SUMMARY

Logic programming is generally taken to be synonymous with relational programming; however, this paper argues why a broader basis for logic programming is needed, why existing combinations of equations, relations, and functions do not entirely meet the need, and a promising approach for the broader basis. The proposed broader basis consists of three logical forms: equations, relations, and subset assertions, along with an accompanying set of matching and unification operations. Equations provide the ability to define deterministic operations without Prolog's cut. Subset assertions can be used to define more declaratively Prolog's setof as well as transitive-closure operations, both of which are traditionally expressed using assert and retract. Because functions defined by subset assertions must be invoked with ground arguments, formulating relational clauses by subset assertions allows one to declaratively specify which arguments of a relation are ground, thereby obviating the need for...