Browse Books

Reviewer: Ehud Shapiro

The back cover of this book rightly states, “This is the first book to give an account of the mathematical foundations of Logic Programming.” Kowalski [1] provided the basic idea of logic programming, albeit in a rather intuitive and informal manner. Two books, one by Clocksin and Mellish [2], and the other by Clark and McCabe [3], investigated the pragmatics of PROLOG programming. Following these earlier efforts, a well-founded, theoretical book was badly needed. Lloyd's book covers, in four chapters and less than 120 pages, the declarative semantics of logical programming, its procedural semantics, and the semantics of negation as failure, as well as an initial investigation into the semantics of logic programs specifying perpetual processes. Lloyd does this in a clear, ordered, and meticulous manner. The book is an important contribution to the logic programming literature. There are, however, several problems with the book. The first is that the book is just too short. The author has sacrificed breadth in favor of timeliness. This is understandable, given the current interest in logic programming and the lack of any other books in this area. However, to do justice to the wealth of results in the area, and to justify the comprehensive title, this book should be followed by a second, greatly enlarged edition that addresses some of the questions missing from the current volume. (A list of these questions is given later in this review.) The second problem is the author's point of view. The book is biased in terms of the material chosen and, to a lesser extent, its tone, emphasis, terminology, and notation. Logic programming can be investigated from at least two different perspectives: that of a mathematician or logician, and that of a computer scientist. From a logician's perspective, logic programming offers a (rather dull) subset of first-order logic. Questions of the correctness and completeness of a proof procedure for it can be investigated, as well as extensions to the language (such as negation as failure), which attempt to compensate for the inherent weakness of this logic. I am afraid that this book adopts this perspective. One-quarter of the book, for example, is devoted to the semantics of extending logic programs by negation as failure. However, from the computer science perspective, logic programs are a computation model, similar to Turing machines, recursive functions, programmable random access machines, and rewrite systems. Rather than being a dull subset of first-order logic, it is a complete (in the technical sense of being as powerful as any other) computational model, having a unique blend of features: it is convenient for humans to program in; it is the basis for practical programming languages; it has inherent parallelism in it; and it has a logical, declarative reading for its programs, in addition to the operational reading. I think that logic programming is much more interesting and relevant from the computer scientist's point of view. Unfortunately, the author of this volume disagrees. The third problem with this book is that it still entertains the naive belief that if only we would have the “right” control mechanism for logic programs then, from now to eternity, we would be writing pure, declarative axioms. We could then let the computers do the dirty job of dressing them up with appropriate control, thus making the written axioms behave as efficient algorithms. This belief is naive for two reasons. First, there are many sophisticated algorithms that cannot be expressed simply by imposing sophisticated control over a logic program that defines a solution. No smart control will turn the exponential slowsort program shown in the book into a quicksort algorithm. Second, the search for the ultimate control facility is just the search for the “philosophers' stone” in disguise. It is similar to the search for the general problem solver, or for the general efficient theorem prover, which simply do not exist. We have strong evidence today that many classes of seemingly simple problems have no general, efficient solution. The general problem of imposing efficient control over logic programs could be just as hard. So what is a sensible attitude towards logic programming__ __ I believe that one should make the best out of their declarative reading, exploiting the advanced programming techniques and programming tools they provide. But remember that logic programming is still programming, and not specification. If the programmer is not smart enough, or the algorithm is not efficient enough, then there is no place to go to for help. Yet. The list below reflects some of those points of interest of a computer scientist in logic programming that were not explored in this volume. I have attempted to order them according to importance. A book on the foundations of logic programming is not complete unless it addresses these problems: (1)Foundations of meta-programming—The question of how easy it is for humans to construct, grasp, and modify programs is important, and logic programs score well on it, compared to other computation models. However, the question of how easy it is for the computer to construct, transform, and simulate programs written in a language is at least as important, and, in the long run, may prove to be even more important. We call such programs, which treat other programs as data, meta-programs. At the heart of the most interesting meta-programs lies a meta-interpreter, which is an interpreter for a language, which is written in that language. The soundness and completeness of meta-interpreters need to be addressed, as well as the accuracy with which they preserve the procedural semantics of the underlying program. (2)Foundations of source-to-source transformation—Conventional compilers translate programs from a high-level language to a low-level one. Although not presently available for the most part, future compilers would include a transformation phase, which would perform optimizations at the source level before compiling into the lower-level language. The question of equivalence of logic programs deserves special attention in a book on their foundation. (3)Complexity of logic programs, and relation to other computational models—The evaluation of the performance of logic programs cannot be considered without defining complexity measures. There is, however, a disturbing gap between complexity measures for abstract logic programs and those needed for analysis programs written in a concrete logic programming language (e.g., PROLOG). Finer tools are yet to be developed. (4)Semantics of concrete logic programming languages—A gap exists between the operational semantics of logic programs and those of concrete logic programming languages (e.g., PROLOG, Concurrent PROLOG, etc.) (5)Type and module concepts for logic programs—An essential component of most modern programming languages is a type system. The logic programming computation model and PROLOG do not include an explicit type system. Module systems are no less important than type systems, from a software engineering point of view. The questions of what is a module, and how modules interact with other modules, closely relates to questions of meta-programming. (6)Function-free logic programs and the relational database model—In computer science, in contrast to mathematics, it is often more rewarding to study a restriction on a model, or a concept, rather than a generalization of it. Function-free logic programs seem to be such a restriction. (7)Logic programs with uncertainties—Extending logic programs to cope with uncertain information is essential if logic programs are to be used at the foundations of systems, such as several expert systems, which can provide only uncertain knowledge as the basis for computation and deduction. In conclusion, writing a book requires the concentration of great intellectual effort and energy, especially if the book attempts to not only summarize the results in a certain domain, but also to take an active part in structuring its concepts, coining the terminology, choosing the appropriate notation, and isolating the important ideas. It is my hope that the required energy will be summoned to continue and supplement this book, so that it will do justice to the important and interesting subject of the foundations of logic programming. Lloyd's work is certainly a good and solid starting point.