- Computing Reviews 9504-0226, 1995
- Natural Language Engineering 1(4): 389-390, 1995
- Journal of Logic and Computation 6(1), 1996

This book is divided into three parts. The first, on logic and logic programming, introduces both the theoretical foundations of clausal form logic and the fundamental aspects of Prolog programming. The second addresses classical AI issues such as search and knowledge representation using Prolog. The third considers more advanced reasoning techniques in Prolog, such as natural language interpretation, default reasoning, and inductive reasoning.

The book stresses the uses of examples to illustrate the application of formal logic methods for reasoning. In this case, Prolog is the vehicle that was chosen to build the tools for studying these concepts. As such, the book contains a fair amount of Prolog code (which is available separately on diskette from the publisher). Answers to related exercises are included. This book would make a nice addition to a course on the methods of Al or computational logic.

R.W. Wilkerson, Rolla, MO

This book contains an introduction to intelligent reasoning. This topic is introduced from a practical viewpoint: the author aims to familiarise the reader with the implementation of intelligent reasoning using Prolog programs. The practical nature of the book is supplemented by a wealth of theoretical foundations. Most of these are based on recent journal articles and conference papers in the computational logic and artificial intelligence fields. To underline the practical character of the book, it is accompanied by a computer disk containing the Prolog programs from the book.

The book's author, Peter Flach, is an Assistant Professor at the Faculty of Economics of Tilburg University, and a Researcher at the Institute for Language Technology and Artificial Intelligence (ITK). Flach has written a fair number of papers, many of which deal with inductive logic programming.

This book contains a foreword written by Professor Robert Kowalski, author of the book Logic for Problem Solving.

The book consists of three main parts, dealing with Logic and Logic Programming (part I), Reasoning with Structured Knowledge (part II), and Advanced Reasoning Techniques (part III). Each of the parts contains three chapters.

In part I, Logic Programming and its foundations are introduced. The opening chapter deals with the main concepts in logic programming, and introduces the basics of Prolog. Chapter two is mainly theoretical in nature, and deals with resolution theorem proving in clausal logic. Concepts like Herbrand models, resolution refutation, soundness and completeness are introduced in a gradual way, starting with relational clausal logic. and working through to full clausal logic and definite clause logic. To conclude the first part, chapter three is a thorough discussion of Prolog programming. Bcsides the basic concepts every Prolog programmer should know, the author also discusses more complex issues like meta-interpreters.

Whereas in part I the focus was on logic programming, part II takes an artificial intelligence point of view. In this part, the building-blocks of Al systems are introduced: graphs and search. Chapter four discusses graphs, and their use to represent structured knowledge in Prolog. Special treatment is given to the topic of inheritance hierarchies. Chapters five and six deal with blind and informed searching techniques. In particular, chapter five looks at the use of breadth-first and depth-first search in a logic programming environment. In the discussion of these, the author highlights completeness, optimality and efficiency of each search strategy. Chapter six has Informed Search as its topic, and focuses especially on best-first search. In this final chapter of part II, Flach also briefly deals with optimal best-first search and non-exhaustive informed search.

Part III departs from the introductory nature of the first six chapters. It is devoted to advanced topics in intelligent reasoning. Chapter seven contains an interesting treatment of reasoning with natural language. Flach discusses natural language parsing and interpretation by introducing a program that acts as a front-end to a small rule base. This program uses a small grammar to interpret queries, and also generates a natural language response to them.

As usual in this book, the program is built up in a step-wise manner, and the full (Prolog) source of the program is included. Chapter eight discusses a number of topics related to reasoning with incomplete information. Attention is given to default reasoning, the semantics of incomplete information, and abductive reasoning. To conclude the book, chapter nine is devoted to inductive reasoning. Using recent material from the inductive logic programming field, Flach discusses inductive inference of logic programs from examples, at the same time discussing subjects like anti-unification and generality between clauses.

The book contains three appendices. The first offers a catalogue of useful predicates. In the second, two programs for logical conversion are presented: one that converts predicate logic to clausal logic, and one that performs predicate completion. The book contains various exercises, and the final appendix provides answers to selected ones.

The author stresses that it is his aim to teach the subjects in the book 'by example', rather than give an encyclopaedic coverage of Logic programming and intelligent reasoning. By giving his book a very practical character and by using a very intuitive step-wise program development method, the author succeeds very well in this respect. The book is a good introduction to the computational logic and artificial intelligence field. As the author does not presuppose a thorough background in logic, this book is very suitable for use as a textbook in (advanced) undergraduate courses on computational logic or logic in artificial intelligence.

Although his book has a practical inclination, the author makes sure that all the necessary theoretical backgrounds of clausal logic and logic programming are provided. Together with the good references provided, this makes the book also suitable for researchers or practitioners in the logic programming and artificial intelligence fields, who might be looking for a more in-depth coverage of the topics.

Especially due to its unique combination of computational logic and artificial intelligence material, and its learning-by-example nature, this book has the potential to become a valuable textbook for teachers and researchers in these areas.

JAN J. IJDENSSchool of Computing and Mathematical Sciences

The Robert Gordon University

email: `jjy@scms.rgu.ac.uk`

This is a book full of ideas and it makes a good read, though I don't think it would be a particularly easy read for a true novice. I certainly enjoyed the approach, which is very practical.

So, what can be found in it? The subtitle of the text is 'Intelligent Reasoning by Example', which gives a broad hint to the approach. Part I covers some basic ideas relevant to the theory behind logic programming, though formality is kept under wraps as much as possible, and gives a grounding in basic Prolog, warts and all. In Parts II and III there are many application topics in the broad area of reasoning introduced and motivated through examples. Lest one should be worried by the lack of formality, there are plenty of references for further reading. And for a first general read, I believe the informality used here works.

Part I is the place to start if you have no experience of logic programming. Otherwise, Part II is probably a good starting point, although the subsequent chapters are reasonably self- contained and can be dipped into in any order.

Let's look into Part I in a little more detail. The text is quite informal and could therefore have done with some summaries at the end of sections and chapters of the main notions introduced. There are plenty of small exercises interspersed with the text encouraging the reader to get on and check at intervals that everything is all clear so far. Moreover, many of these have solutions at the back of the book.

There are some minor annoyances, for instance the rather liberal interpretation
of `married if adult` as a person is married if he is an adult.
I am not quibbling about the sentence, rather, why not go straight for
atoms using predcates and terms? There is also a restrictive definition
of the Herbrand Universe of a program, which can cause problems if a query
used terms not in the program. Right at the beginning some proof trees
are given which do not rename variables and the same variable is given
two substitutions. This is corrected in the section on SLD trees however.
The discussion on models is limited to Herbrand models, which leads to
confusion when models for full first order are mentioned. The section on
unification and resolution might have been improved by the inclusion of
the algorithm more precisely and a definition of resolution.

But these are minor quibbles and the chapter includes most of the notions needed to make sense of the refutational approach embodied in logic programming. It would be fun to try out the approach. I suspect though, that it would suit those who currently introduce Prolog together with little of the formal background, rather than those who include alot of formality first. But for the students (at whatever their level)ÑI think they will rather enjoy it!

Part I concludes with a chapter covering all the procedural aspects of logic programming, including several useful practical techniques such as 'the cut', 'negation as failure', 'difference lists' and so on. The chapter ends with a meta-interpreterÑa superb choice!

So what of Parts II and III? Part II looks at various methods of searching
for solutions to problems, including an extended meta-interpreter, and
at data representation, for example using *isa *hierarchies. Much
of the material in Part III has not previously been in any text accessible
to the general reader and it is this section that may well appeal the most.
Interesting applications of logic programming are discussed and I think
the material will interest the practcal minded. For, these chapters include
some quite complex programs, although don't worry, the reader is led carefully
through them and there are judiciously placed exercises along the way to
reinforce the point as they are made.

The three chapters in Part III introduce, respectively, natural language processing, reasoning with incomplete knowledge, and inductive reasoning. These are all especially suitable topics, the first for its fun, the second for its timeliness and relation with negation as failure, and the third because it is probably not at all widely known about.

Yes, natural language is a fun application, but it is also a serious one; after all translation and automated question-answering systems are not dreams any more and logic programming is well suited. Reasoning with incomplete knowledge includes both default reasoning and fault diagnosis using abduction. By encouraging the reader to write and understand programs that implement a fault diagnoser and a default reasoner, the book should be able to achieve its aim of introducing interesting applications to a new audience. The choice of topics for the last two chapters reflects again the sub-title of the book. The only drawback is that a newcomer might be deceived into believing that logic programming is not a general purpose language.

To summarize then, this is an ambitious text which, nevertheless will, I hope, be used with classes of beginner logic programmers. For beginners, the background material in Chapter 2 is probably adequate. Indeed, it may even be too much for some! For someone well versed in standard logical notions, wanting to use the book as an introduction to logic programming, the chapter is a useful pot- pouri of the main ideas, but would probably not be formal enough for their liking. The later chapters introduce, through programs, many interesting applications of logic programming in the area of reasoning. Don' t be mislead by the titleÑwhether you are a novice or not, by the end of the book there are several not so simple concepts that have been investigated through the medium of logic programming.

It's well worth a browse!

KRYSIA BRODA Imperial College, London

Back / Peter Flach

Peter Flach, Peter.Flach@bristol.ac.uk. Last modified on Monday 17 January 2000 at 15:09. © 2000 University of Bristol