In this paper we will be concerned with such reasoning in its most general form, that is, in inferences that are defeasible: given more information, we may retract them. The purpose of this paper is to introduce a form of non-monotonic inference based on the notion of a partial model of the world. We take partial models to reflect our partial knowledge of the true state of affairs. We then define non-monotonic inference as the process of filling in unknown parts of the model with conjectures: statements that could turn out to be false, given more complete knowledge. To take a standard example from default reasoning: since most birds can fly, if Tweety is a bird it is reasonable to assume that she can fly, at least in the absence of any information to the contrary. We thus have some justification for filling in our partial picture of the world with this conjecture. If our knowledge includes the fact that Tweety is an ostrich, then no such justification exists, and the conjecture must be retracted.

A problem simplification approach that generates heuristics for constraint-satisfaction problems ' 125 R. DECHTER and J. PEARL 7. The relation between programming and specification languages with particular reference to Anna 157 A. D. MCGETTRICK and J. G. STELL LOGIC PROGRAMMING TOOLS AND APPLICATIONS 8. YAPES: yet another PROLOG expert system Decision trees and multi-valued attributes 305 J. R. QUINLAN 14. RuleFactory: a new inductive learning shell 319 S. RENNER 15.

It provides inference and explanation facilities, and incorporates a novel form of plausible inference. YAPES is a specialized interpreter for logic programs. Figure 1 illustrates its top level structure. A PROLOG interpreter (or compiler) executes such programs consisting of sets of Horn clauses, a form of first-order logic. The YAPES system also executes such programs, as well as programs in an extended version of Horn clause logic which uses certainties as truth values, rather than just true and false.

The initial plan for LOGLISP [1] was simply that it would offer, within LISP, a Horn-clause relational programming facility akin to PROLOG. This it does, but with some differences from PROLOG, notably the use of a breadth-first, rather than depth-first, elaboration of the underlying tree of alternative linear proofs, and the consequent avoidance of explicit backtracking as a control mechanism. It was because of these differences that the facility was called LOGIC rather than PROLOG, which would have been misleading. The name LOGLISP then refers to the combined system: LOGIC LISP. It soon became apparent, however, that the main interest of LOGLISP lay rather in its (relatively crude, but genuine) attempt to merge the functional programming style of LISP with the relational programming style of LOGIC and PROLOG. This was done by introducing the notion of'Lisp-transforms' into LOGIC.

It is a rich source of difficult and challenging problems which involve issues of knowledge representation, the analysis of natural language, and the automation of practical and common-sense reasoning.

This paper describes some work on automatically generating finite counterexamples in topology, and the use of counterexamples to speed up proof discovery in intermediate analysis, and gives some examples theorems where human provers are aided in proof discovery by the use of examples.

Work of the Soviet school (approximately half the book) in this explosively growing area of machine intelligence is thus made accessible for the first time to Western readers, in addition to the latest Western advances. The emergent theme of knowledge-representation is supported on the theoretical and experimental sides by recent work in inductive inference and theory-formation.

PROLOG is a simple and powerful progamming language based on first-order logic. This paper examines two possible extensions to the language which would generally be considered "higher-order".t The first extension introduces lambda expressions and predicate variables so that functions and relations can be treated as'first class' data objects. We argue that this extension does not add anything to the real power of the language. The other extension concerns the introduction of set expressions to denote the set of all (provable) solutions to some goal. We argue that this extension does indeed fill a real gap in the language, but must be defined with care.

Seven years or so after it was first proposed (Kowalski 1974), the technique of'logic programming' today has an enthusiastic band of users and an increasingly impressive record of applications. For most of these people, logic progamming means PROLOG, the system defined and originally implemented by the Marseille group (Roussel 1975). PROLOG has since been implemented in several other places, most notably at Edinburgh (Warren et al. 1977). Much of the rapid success of logic progamming is due to these implementations of PROLOG (as well as to the inspired missionary work of Kowalski, van Emden, Clark and others). The Edinburgh PROLOG system is in particular a superb piece of software engineering which allows the logic progammer to compile assertions into DEC-10 machine code and thus run logic programs with an efficiency which compares favourably with that of compiled LISP. All other implementations of logic programming (including our own, which we describe in this paper) are based on interpreters.