Abstract: Introduction, by J. Minker Part I - Negation and Stratified Databases Chapter 1 Negation in Logic Programming, by J.C. Shepherdson Chapter 2 Towards a Theory of Declarative Knowledge, by K.R. Apt, H.A. Blair, and A. Walker Chapter 3 Negation as Failure Using Tight Derivations for General Logic Programs, by A. Van Gelder Chapter 4 On the Declarative Semmantics of Logic Programs with Negation, by V. Lifschitz Chapter 5 On the Declarative Semantics of Deductive Databases and Logic Programs, by T.C. Przymusinski Chapter 6 On Domain Independent Databases, by R.W. Topor and E.A. Sonenberg Part II - Fundamental Issues in Deductive Databases and Implementation Chapter 7 Foundations of Semantic Query Optimization for Deductive Databases, by U.S. Chakravarthy, J. Grant, and J. Minker Chapter 8 Intelligent Query Answering in Rule Based Systems, by T. Imielinski Chapter 9 A Theorem-Proving Approach to Database Integrity, by F. Sadri and R. Kowalski Chapter 10 A Logic-based Language for Database Updates, by S. Manchanda and D.S. Warren Chapter 11 Compiling the GCWA in Indefinite Deductive Databases, by L. Henschen and H. Park Chapter 12 Performance Evaluation of Data Intensive Logic Programs, by F. Bancilhon and R. Ramakrishnan Chapter 13 A Superjoin Algorithm for Deductive Databases, by J.A. Thom, K. Ramamohanarao, and L. Naish Part III - Unification and Logic Programs Chapter 14 Logic Programming and Parallel Complexity, by P.C. Kanellakis Chapter 15 Unification Revisited, by J-L Lassez, M.J. Maher, and K. Marriott Chapter 16 Equivalences of Logic Programs, by M.J. Maher Chapter 17 Optimizing Datalog Programs, by Y. Sagiv Chapter 18 Converting AND-Control to OR-Control by Program Transformation, by M.H. van Emden and P. Szeredi Authors Referees Author Index Subject Index

Abstract: Checking Proofs in the Metamathematics of First Order Logic (M. Aiello, R. Weyhrauch). Foundations. Issues in Computational Reflection (P. Maes). Meta in Logic (D. Perlis). Meaning in Knowledge Representation (L. Steels). Reasoning by Introspection (K. Konolige). Introspective Fidelity (M. Genesereth). Commonsense Set Theory (D. Perlis). Implementations. Control-Related Meta-Level Facilities in LISP (J. des Rivieres). The Mystery of the Tower Revealed: A Non-Reflective Description of the Reflective Tower (M. Wand, D. Friedman). Communication between LISP and Horn Clauses by Mutual Reflection (R. Ghislanzoni, L. Spampinato, G. Tornielli). The ObjVlisp Kernel: A Reflective Lisp Architecture to Define a Uniform Object-Oriented System (P. Cointe). Conceptual Reflection and Actor Languages (J. Ferber). Evaluation and Reflection in FOL (D. Nardi). OMEGA: An Integrated Reflective Framework (M. Simi, E. Motta). Meta-Levels in SOAR (P. Rosenbloom, J. Laird, A. Newell). Applications. The Uses of Metaknowledge in AI Systems (L. Aiello, G. Levi). Reasoning about Self-Control (J. Batali). A Multi-Context Monotonic Axiomatization of Inessential Non-Monotonicity (F. Giunchiglia, R. Weyhrauch). Declaratively Programmable Interpreters and Meta-Level Inference (B. Welham). A Meta-Level Architecture for Expert Systems (L. Sterling). Object Level Reflection of Inference Rules by Partial Evaluation (P. Coscia et al.). Functional Meta-Level for Logic Programming (P. Mancarella, D. Pedreschi, F. Turini). Meta-Level Extensions of Logic and Machine Learning (P. Brazdil).

Abstract: It is shown that the basic operations of object-oriented programming languages — creating an, object, sending and receiving messages, modifying an object’s state, and forming class-superclass hierarchies — can be implemented naturally in Concurrent Prolog. In addition, a new object-oriented programming paradigm, called incomplete messages, is presented. This paradigm subsumes stream communication, and greatly simplifies the complexity of programs defining communication networks and protocols for managing shared resources. Several interesting programs are presented, including a multiple-window manager. All programs have been developed and tested using the Concurrent Prolog interpreter described in.1)

Abstract: An augmented and ⧸ or tree representation of logic programs is presented as the basis for an advanced graphical tracing and debugging facility for PROLOG. An extension of our earlier work on “retrospective zooming”, this representation offers several distinct advantages over existing tracing and debugging facilities: (1) it naturally incorporates traditional and ⧸ or trees and Byrd box models (call⧸exit⧸fail⧸redo procedural models) as special cases; (2) it can be run in slow-motion, close-up mode for novices or high-speed, long-distance mode for experts with no attendant conceptual change; (3) it serves as the uniform basis for textbook material, video-based teaching material, and an advanced user interface for experienced PROLOG programmers; (4) it tells the truth about clause head matching and deals correctly with the cut. One of the key insights underlying the work is the realization that it is possible to display an execution space of several thousand nodes in a meaningful way on a modern graphics workstation. By enhancing and ⧸ or trees to include “status boxes” rather than simple “nodes”, it is possible to display both a long-distance view of execution and the full details of clause-head matching. Graphical “collapsing” techniques enable the model to deal with user-defined abstractions, higher-order predicates such as setof, and definite-clause grammars. The current implementation runs on modern graphics workstations and is written in PROLOG.

Abstract: Since logic programming systems directly implement search and unification and since these operations are essential for the implementation of most theorem provers, logic programming languages should make ideal implementation languages for theorem provers. We shall argue that this is indeed the case if the logic programming language is extended in several ways. We present an extended logic programming language where first-order terms are replaced with simply-typed λ-terms, higher-order unification replaces first-order unification, and implication and universal quantification are allowed in queries and the bodies of clauses. This language naturally specifies inference rules for various proof systems. The primitive search operations required to search for proofs generally have very simple implementations using the logical connectives of this extended logic programming language. Higher-order unification, which provides sophisticated pattern matching on formulas and proofs, can be used to determine when and at what instance an inference rule can be employed in the search for a proof. Tactics and tacticals, which provide a framework for high-level control over search, can also be directly implemented in this extended language. The theorem provers presented in this paper have been implemented in the higher-order logic programming language λProlog.

Abstract: A predicate/transition net model for a subset of Horn clause logic programs is presented. The syntax, transformation procedure, semantics, and deduction process for the net model are discussed. A possible parallel implementation for the net model is described, which is based on the concepts of communicating processes and relations. The proposed net model offers a syntactical variant of Horn clause logic and has two distinctions from other existing schemes for the logic programs: representation formalism and the deduction method. The net model provides an approach towards the solutions of the separation of logic from control and the improvement of the execution efficiency through parallel processing for the logic programs. The abstract nature of the net model also lends itself to different implementation strategies. >

Abstract: We propose a logic programming language for writing database update programs. The language is called DLP, for Dynamic Logic Programming. Update programs in the language are logic programs augmented with simple update operations; they have a declarative semantics in a dynamic logic of updates. This semantics provides a logical theory of database updates. DLP supports data-definition, view definition, querying, updating, and general computing; therefore, it can serve as a uniform interface to a logic database. We present an application of DLP and its semantics to the view update problem. A view update translator is an update program in DLP and must satisfy certain conditions for correctly translating update requests on a particular view. It is shown that very simple syntactic transformations on a view definition can be used to obtain correct view update translators for the view.

Abstract: PARLOG is a logic programming language in the sense that nearly every definition and query can be read as a sentence of predicate logic. It differs from PROLOG in incorporating parallel modes of evaluation. For reasons of efficient implementation, it distinguishes and separates and-parallel and or-parallel evaluation.PARLOG relations are divided into two types: single-solution relations and all-solutions relations. A conjunction of single-solution relation calls can be evaluated in parallel with shared variables acting as communication channels for the passing of partial bindings. Only one solution to each call is computed, using committed choice nondeterminism.A conjunction of all-solutions relation calls is evaluated without communication of partial bindings, but all the solutions may be found by an or-parallel exploration of the different evaluation paths. A set constructor provides the main interface between single-solution relations and all-solutions relations.This paper is a tutorial introduction to PARLOG. It assumes familiarity with logic programming. Categories and Subject Descriptors: D.l.l [Programming Techniques]: Applicative (Functional)

Abstract: We present an extension of Prolog-style Horn clause logic programming to full first order logic. This extension has some advantages over other such extensions that have been proposed. We compare this method with the model elimination strategy which Stickel has recently implemented very efficiently, and with Loveland's extension of Prolog to near-Horn clauses. This new method is based on the author's “simplified problem reduction format” but permits a better control of the splitting rule than does the simplified problem reduction format. In contrast to model elimination, this new method does not require the use of contrapositives of clauses, permitting a better control of the search. This method has been implemented in C Prolog and has turned out to be a respectable and surprisingly compact first-order theorem prover. This implementation uses depth-first iterative deepening and caching of answers to avoid repeated solution of the same subgoal. We show that the time and space used by this method are polynomial functions of certain natural parameters of the search space, unlike other known methods. We discuss the relation of these upper bounds to Savitch's theorem relating nondeterministic time to deterministic space.

Abstract: Two-volume set These two volumes collect papers presented at the first joint meeting of the two principal logic programming conferences, held in August of 1988. The more than fifty contributions cover all aspects of the field, including applications (particularly those that exploit the unique character of logic programming), the role of logic programming in artificial intelligence, deductive databases, relations to other computational paradigms, language issues, methodology, implementations on sequential and parallel architectures, and theory. Logic Programming is included in the Logic Programming series Research Reports and Notes, edited by Ehud Shapiro.

Abstract: This monograph places design in a theoretical context which applies developments in knowledge-based systems, logic programming and planning to design. It addresses two important design issues: the interpretation of designs, which concerns the discovery of implicit design attributes, a key activity in design evaluation that can be modelled by deductive inference in logic programming; and the process of generation, whereby a design description is produced which exhibits these implicit design attributes. Implicit attributes can be seen as analogous to the semantic content of natural language utterances. The work presented here is mainly concerned with design generation, and an operational model of design is investigated in which operations on processes are treated in a similar way to operations on form. It is argued that there are advantages in representing control knowledge as rules in a design system, and that logic is an effective medium for this purpose. This is demonstrated by means of programs developed in Prolog and C using the example of spatial layout in buildings. Primarily, this book is directed at those in artificial intelligence (AI) involved in logic programming, planning and expert systems. However, since AI techniques are finding widespread application in industry, the use of an architectural design example makes this work relevant to architects, designers, engineers and developers of intelligent architectural design software.

Abstract: A system of software, named CODER, has been written which can analyze the solid model of a part and generate a group technology part code through the identification of form features. The CODER algorithm is bottom-up in nature, first searching for small form-features and then constructing macro-features from the small elements. The program has been implemented using logic programming techniques and consists of facts, describing the part, which must be searched to satisfy rules defining the form-features. The rules and facts are written in Prolog. The facts are generated automatically in Prolog from the ROMULUS2 solid modeler. Rules can define form-features specific to a particular coding scheme and, therefore, form a code-specific knowledge base. The significance of this research is seen when applied to the many designs which have been generated on wire frame CAD systems in the past and, which, if converted to solid models, could be automatically coded for variant process planning, design retrieval and other applications germane to part coding. The algorithm is written in a combination of Prolog, Lisp and S.I™3 .

Abstract: PROLOG, logic programming based languages, became very popular in the eighties, taking a circuitous route to the United States; from Europe to Japan to mainstream American computer science.

Abstract: This paper presents an approach to specialising logic programs which is based on abstract interpretation. Program specialisation involves two stages, the construction of an abstract computation tree and a program construction stage. For the tree construction stage, abstract OLDT resolution is defined and used to construct a complete and finite tree corresponding to a given logic program and a goal. In the program construction stage, a specialised program is extracted from this tree.

Abstract: Concurrent Prolog [28] combines the logic programming computation model with guarded-command indeterminacy and dataflow synchronization. It will form the basis of the Kernel Language [21] of the Parallel Inference Machine [36], planned by Japan's Fifth Generation Computers Project. This paper explores the feasibility of programming such a machine solely in Concurrent Prolog (in the absence of a lower-level programming language), by implementing in it a representative collection of systems programming problems.

Abstract: We study the possibility of reducing some special cases of circumscription to logic programming. The description of a given circumscriptive theory T can be sometimes transformed into a logic program II, so that, by running II, we can determine whether a given ground literal is provable in T. The method is applicable, in particular, to some formalizations of tree-structured inheritance systems with exceptions.

Abstract: We present a multidatabase management system built in Vienna Integrated Prolog (VIP) for cooperative management of autonomous databases. Data in different databases may differ with respect to naming, structures and value types. VIP-MDBS (VIP MultiDataBase System) allows the ability to manipulate them jointly and in a non-procedural way. Its features are similar to those of the relational multidatabase language MSQL, but adapted to logic programming. We introduce the concept of so-called semantic relations, a concept which stems from the extension of global views by deductiveness. VIP-MDBS allows for representation of intentional data and formulation of recursive multiple queries.

Abstract: Programs typically spend much of their execution time in loops. This makes the generation of efficient code for loops essential for good performance. Loop optimization of logic programming languages is complicated by the fact that such languages lack the iterative constructs of traditional languages, and instead use recursion to express loops. In this paper, we examine the application of unfold/fold transformations to three kinds of loop optimization for logic programming languages: recursion removal, loop fusion and code motion out of loops. We describe simple unfold/fold transformation sequences for these optimizations that can be automated relatively easily. In the process, we show that the properties of unification and logical variables can sometimes be used to generalize, from traditional languages, the conditions under which these optimizations may be carried out. Our experience suggests that such source-level transformations may be used as an effective tool for the optimization of logic programs.

Abstract: It is shown how Horn logic programs can be implemented using database techniques, namely, mostly bottom-up in combination with certain top-down elements (as opposed to the top-down implementations of logic programs prevailing so far). The proposed method is sound and complete. It easily lends itself to a parallel implementation and is free of nonlogical features like backtracking. As an extension to the common approach to deductive databases, function symbols are allowed to appear in programs, and it is shown that much of database query optimization can be applied to optimize logic programs. An important advantage of present approach is its ability to evaluate successfully many programs that terminate under neither pure top-down nor bottom-up evaluation strategies. >

Abstract: The familiar fixed point semantics for Horn clause programs gives both smallest and biggest fixed points fundamental roles. We show how to extend this idea to the family of stratified logic programs, producing a semantics we call weak stratified, that is compatible with but not the same as the conventional stratified semantics. And we show weak stratified semantics coincides with one based on three valued logic, a semantics that is generally applicable, and that does not require stratification assumptions.

Abstract: A method known asclosed environments can be used to represent variable bindings for OR-parellel logic programs without relying on a shared memory or common address space. The representation is based on a procedure that trans-forms stack frames after unification, taking into account problems with common unbound ancestors and shared instances of complex terms. Closed environments were developed for the AND/OR Process Model, but may be applicable to other OR-parallel models.

Abstract: This paper presents an experimental implementation of a self-applicable partial evaluator in Prolog used for compiler generation and compiler generator generation. The partial evaluator is an extension of a simple meta interpreter for Prolog programs, and its self-application is straightforward because of its simplicity. A method of incremental compilation is also described as a promising application of the partial evaluator for knowledge-based systems.

Abstract: We present the experimental language BABEL, designed to achieve integration of functional and logic programming in a simple, flexible, and mathematically well founded way. The language relies on a constructor discipline and the use of narrowing to englobe rewriting and SLD-resolution. It is first-order, type-free and has a lazy operational semantics which supports infinite data structures and is sound w.r.t. a declarative semantics based on Scott domains. The paper includes BABEL's syntactical and semantical specification, some mathematical results on the semantics, and programming examples.