Knowledge base management systems (KBMS) are designed to efficiently retrieve and manipulate large shared knowledge bases. A significant subclass of KBMS consisting of a combination of logic programming and database is often called a logic oriented knowledge base system (LOKBS). These systems must possess considerable processing and I/O capabilities so many approaches have been taken to the improvement of their performance. In this paper we review the current performance enhancing hardware approaches for LOKBS. We include parallelism, both in processing and I/O, algorithms, caching, and physical data organizations.

This paper attempts to assess the practical utility of nonmonotonic logic in diagnostic problem solving. We begin with a brief review of the main assumptions which motivate work in this area, and discuss two logic-based approaches which involve nonmonotonic arguments. Then we consider two recent proposals for the application of default logic to diagnosis, as well as a proposal based on counterfactual logic. In conclusion, we briefly compare these methods with other diagnostic reasoning paradigms found in the Artificial Intelligence literature.

Progress in software engineering has led to system development following models of the system life cycle. These models incorporate the use of prototyping and formal methods of program verification. They are becoming supported by integrated project support environments and permit the planning and monitoring of software development projects.

In contrast, knowledge based systems (KBS) are developed using informal views of the system life cycle. Tools have been developed to support some stages of the life cycle in an undisciplined manner. The commercial use of KBS needs development projects to be planned and monitored. This requires methods and tools based on systematic life cycle models to be established for KBS.

This paper reviews the current state of life cycle approaches to software engineering and KBS development projects in order to provide a direction for the development of methodical KBS life cycle models.

This paper surveys a variety of deductive database theories. Such theories differ from one another in the set of axioms and metarules that they allow and use. The following theories are discussed: relational, Horn, and stratified in the text; protected, disjunctive, typed, extended Horn, and normal in the appendix. Connections with programming in terms of the declarative, fixpoint, and procedural semantics are explained. Negation is treated in several different ways: closed world, completed database, and negation as failure. For each theory examples are given and implementation issues are considered.

The execution model of Prolog, the first popular language based on Horn Clauses, was designed for efficient evaluation on von Neumann architectures. An alternative process model of execution, better suited for parallel evaluation and reactive programming, has given rise to a new class of languages based on Horn Clause logic, concurrent logic languages. There appears to be a profusion of languages which claim to fall into this class and it is difficult for an initiate to appreciate why each is the way it is. One notable member of this class, FGHC, forms the cornerstone of the Japanese 5th Generation Initiative. Fortunately, the seemingly exponential growth in these languages is only an illusion. A finite number of synchronization mechanisms arise from attempting (or sometimes not attempting) to control two principle synchronization difficulties: the premature binding problem and the binding conflict problem. Suitable combinations of these synchronization mechanisms reproduce the languages of this family. A background knowledge of Prolog is assumed and some familiarity with the difficulties encountered in concurrency would be advantageous.

First-generation expert systems have significant limitations, often attributed to their not being sufficiently deep. However, a generally accepted answer to “What is a deep expert system?” is still to be given. To answer this question one needs to answer “Why do first-generation systems exhibit the limitations they do?” thus identifying what is missing from first-generation systems and therefore setting the design objectives for second-generation (i.e. deep) systems. Several second-generation architectures have been proposed; inherent in each of these architectures is a definition of deepness. Some of the proposed architectures have been designed with the objective of alleviating a subset, rather than the whole set, of the first-generation limitations. Such approaches are prone to local, non-robust solutions.In this paper we analyze the limitations (under the categories: human-computer interaction, problem-solving flexibility, and extensibility) of the first-generation expert systems thus setting design goals for second-generation systems. On the basis of this analysis proposed second-generation architectures are reviewed and compared. The paper concludes by presenting requirements for a generic second-generation architecture.

AI researchers are becoming increasingly aware of the importance of reasoning about knowledge and belief. This paper reviews epistemic logic, a logic designed specifically for this type of reasoning. I introduce epistemic logic, and discuss some of the philosophical problems associated with it. I then compare two different styles of implementing theorem provers for epistemic logic. I also briefly discuss autoepistemic logic, a form of epistemic logic intended to model an agent's introspective reasoning, i.e. an agent's reasoning about its own beliefs. Finally, I discuss some of the proposals in the AI literature that are aimed at avoiding some of the philosophical problems that dog both epistemic and autoepistemic logic. This paper is not a full introduction to the field. Rather, it is intended to give the reader some flavour of the problems that research in this area faces, as well as some of the proposals for solving these problems.

This paper describes the interfacing problem that arose in a Product Formulation expert system written in LISP that had to be interfaced to data in a relational database running on a separate mainframe computer. It surveys the different forms of coupling that are possible and emphasizes the advantages of tight navigational coupling over the more popular set-based coupling. It describes how Prolog was used to overcome the interfacing problems and to provide a customized front end to an end user, based on a navigational interface. It reviews the techniques of using Prolog and the likely obstacles, together with a look forward to databases using Frames or Objects.

The application area of knowledge-based expert systems is currently providing the main stimulus for developing powerful, parallel computer architectures. Languages for programming knowledge-based applications divide into four broad classes: Functional languages (e.g. LISP), Logic languages (e.g. PROLOG), Rule-Based languages (e.g. OPS5), and, what we refer to as self-organizing networks (e.g. BOLTZMANN machines).

Despite their many differences, a common problem for all language classes and their supporting machine architectures is parallelism: how to de-compose a single computation into a number of parallel tasks that can be distributed across an ensemble of processors. The aim of this paper is to review the four types of language for programming knowledge-based expert systems, and their supporting parallel machine architectures. In doing so we analyze the concepts and relationships that exist between the programming languages and their parallel machine architectures in terms of their strengths and limitations for exploiting parallelization.

A series of temporal reasoning tasks are identified which motivate the consideration and application of temporal logics in artificial intelligence. There follows a discussion of the broad issues involved in modelling time and constructing a temporal logic. The paper then presents a detailed review of the major approaches to temporal logics: first-order logic approaches, modal temporal logics and reified temporal logics. The review considers the most significant exemplars within the various approaches, including logics due to Russell, Hayes and McCarthy, Prior, McDermott, Allen, Kowalski and Sergot. The logics are compared and contrasted, particularly in their treatments of change and action, the roles they seek to fulfil and the underlying models of time on which they rest. The paper concludes with a brief consideration of the problem of granularity—a problem of considerable significance in temporal reasoning, which has yet to be satisfactorily treated in a temporal logic.

Recent approaches to providing advisory knowledge-based systems with explanation capabilities are reviewed. The importance of explaining a system's behaviour and conclusions was recognized early in the development of expert systems. Initial approaches were based on the presentation of an edited proof trace to the user, but while helpful for debugging knowledge bases, these explanations are of limited value to most users. Current work aims to expand the kinds of explanation which can be offered and to embed explanations into a dialogue so that the topic of the explanation can be negotiated between the user and the system. This raises issues of mutual knowledge and dialogue control which are discussed in the review.