Prolog Interpreter Research Articles

SetLog, a tool for experimenting with new semantics

SetLog is a software system that can be used to experiment on several semantics for extensions of Prolog with sets. A first prototype of SetLog has been implemented including the features of a standard Prolog interpreter and of an interpreter for finite set expressions (SETL). Examples of uses of the system are also presented.

An evaluation of APT: an Animated Program Tracer for novice Prolog programmers

This paper describes an approach to evaluating the usefulness of an Animated Program Tracer (APT) in communicating run-time information to novice Prolo programmers. The method used in the evaluation consists of a set of programs which have been specially designed to elicit how novices think Prolog programs are executed, and thus to reveal how accurate their model of program execution is. Two experiments are reported. The first determines the misconceptions that novices hold about the runtime actions of the Prolog interpreter, and produces six different categories of misconception. The second experiment investigates the ability of APT to communicate run-time information to novice Prolog programmers. A scoring technique was used to interpret subjects' answers, and shows that there was a significant improvement in the scores of the group who saw programs traced by APT when compared with a control group who saw no trace.

Unifications, deunifications, and their complexity

The execution of a Prolog program can be viewed as a sequence of unifications and backtracks over unifications. We study the time requirement of executing a sequence of such operations (the unify-deunify problem). It is shown that the well-known set union problem is reducible to this problem, even in the case when no function symbols are allowed (the Datalog unify-deunify problem). As the set union problem requires nonlinear time on a large class of algorithms, the same holds for the unify-deunify problem. Thus the linearity of single unifications does not give a complete picture of the time complexity of Prolog primitives. We discuss the methods for executing sequences of Datalog unifications used in Prolog interpreters and show that some of them require even quadratic time in the worst case. Complementing these results, we show that if the number of variables occurring in one clause is bounded by a constant, then the Datalog unify-deunify problem can be solved in linear time.

Teaching, learning and using Prolog: Understanding Prolog

Prolog is an excellent language with many fine features. It is the foundation of the Japanese Fifth Generation project and is one of the main languages in which Artificial Intelligence systems are implemented. Prolog is now being used widely at all levels of education from primary school through to university level. Much of the knowledge about the problems associated with teaching and using Prolog has been disseminated informally through seminars, word of mouth and so on. Both this special issue and a companion special issue (to appear in the next volume) are devoted to fundamental research that informs the teaching commu nity about some of the issues and problems that should help readers to increase their awareness when embarking on teaching (or learning) and using Prolog. This issue, "part A", features seven papers that provide different analyses of the prob lems in understanding Prolog and some progress in supporting Prolog novices in their attempts to understand their programs. The companion special issue, "part B", provides six papers that deal more directly with the problems of supporting program construction and debugging (Pain et cd, forthcoming) In both special issues, the focus is on the improvement of our understanding in order to encourage the best use of Prolog. Here, there is no concerted attack on Prolog but a determination to improve the learning and application of a language which has some considerable promise. The idea for this stemmed from a workshop held in 1987 at Coseners House, Abingdon, UK, and funded by the UK's Alvey programme. Fifteen academic and industrial researchers met to discuss the current state of research relating to the use of Prolog by programmers with the main emphasis on issues relating to learn ing Prolog. Many of the papers in these two special issues were the result of dis cussions that happened at this workshop which had an unusual structure in that people were encouraged to form groups with the express purpose of generating outline papers. In particular, three papers owe a great debt to the cooperation of the participants, initially at the workshop, and then afterwards: "Towards a Taxonomy of Novices' Misconceptions of the Prolog Interpreter" by Fung et al (part A), "Prolog Programming Techniques" by Brna et al (part B), and "An Overview of Prolog Debugging Tools" by Brna et al (part B).

Towards a taxonomy of novices' misconceptions of the Prolog interpreter

A series of novice programmers' misconceptions of Prolog flow-of-control and variable unification are identified on the basis of existing empirical evidence, and informal observation. This classification is intended to serve as a first pass attempt towards an understanding of these errors and as a basis for future empirical work.

Structure sharing for quantified terms: Fundamentals

Structure sharing is used in symbolic computation to share a common top level between terms with different lower levels. It is widely used in the implementation of Prolog interpreters and is of interest for the implementation of automatic theorem provers, interactive proof editors and verification systems. Previously, structure sharing has been applied only to free-variable terms. In this paper we extend the structure sharing technique to quantified terms. We give an efficient unification algorithm of our structure sharing representation of quantified terms, and we prove the correctness of the algorithm.

Design and distributed implementation of the parallel logic language shared Prolog

The parallel logic language Shared Prolog embeds Prolog as its sequential component. A program is Shared Prolog is composed of a set of logic agents, i.e. Prolog programs, that communicate associatively via a shared workspace called blackboard. The distinct features that characterize Shared Prolog with respect to other parallel (logic) languages are: scheduling of agents and granularity of parallelism explicitly controlled; Prolog embedded in the language; intrinsic modularity; associative send/receive of messages among agents with a simple operational semantics in terms of assert/retract of clauses. The model of communication puts Shared Prolog in the Linda family of parallel languages. The current prototype implementation is exposed. The architecture of the system is a distributed network of extended Prolog interpreters running under Unix and communicating via Internet sockets, and was obtained refining a specification written in SP itself.

An effective representation of complex clauses in a relational database

A mechanism for storing and retrieving arbitrary complex PROLOG clauses from a relational database is presented. This mechanism can be used to implement a filter module that sits on top of the database management system (DBMS) and offers clause retrieval functions to the PROLOG interpreter. The filter module accepts arbitrary complex goal literals as input and returns all clauses (potentially) matching the goal. The presented mechanism is able to handle ground and non-ground facts as well as rules. For clause retrieval it derives search predicates from the constants of goal literals as well as multiple occurrences of goal variables. The presented method is flexible enough to support a wide range of filter selectivity, i.e. it can be used to implement highly-selective as well as arbitrary coarse filters. The structures needed to represent clauses in the DBMS are simple: each clause is entirely stored in a single tuple, which also contains all information needed for selection purposes. To retrieve the clauses matching a given goal, one DBMS query operating on a single table is to be executed, independent of the complexity of the stored clauses and the degree of selectivity provided by the filter.

Transformational programming: the derivation of a Prolog interpretation algorithm

In this paper we will present a case study for the transformational programming technique. The problem we intend to study is the construction of an interpreter for the logic programming language Prolog. We will start from a formal algebraic semantic definition of Prolog, through a series of transformations, step by step, reach a compact and efficient implementation written in programming language Ada. The whole development process are carried out with the support of a software development system called AUTO STAR (AUTOmatic Specification To Ada Realization).

Design and performance measurements of a parallel machine for the unification algorithm

Unification is known to be the most repeated operation in logic programming and PROLOG interpreters. To speed up the execution of logic programs, the performance of unification must be improved. We propose a parallel unification machine for speeding up the unification algorithm. The machine is simulated at the register transfer level and the simulation results as well as performance comparison with a serial unification coprocessor are presented.

The use of prolog for improving the rigour and accessibility of ecological modelling

We introduce three concepts that offer considerable benefit to the process of ecological modelling: the descriptive representation of models; the explicit representation of knowledge about how to model; and the development of knowledge-based systems that can help ecologists construct models. Prolog, a computer language based on formal logic, has much to offer in realising these ideas. We introduce the concept of a ‘model blueprint’, a complete, formal specification of the structure of a model, and show how a blueprint can be represented as a Prolog program, basing our analysis on system dynamics models for simplicity. We consider ways in which the Prolog interpreter can be used selectively to retrieve information about the model, to check for errors in the formulation of the model, and to evaluate the model mathematically. However, there are drawbacks with this approach, so we discuss ways of overcoming these by implementing - also in Prolog - programs which buffer the user from the difficulties of working at the level of the Prolog interpreter. These include the generation of descriptions of model structure, and the development of a program to help in the construction of simulation models.

Implementing a parallel PROLOG interpreter by using OCCAM and transputers

occam is a message-based parallel language that allows programs to be written with a large number of living processes. The transputer, which supports occam very efficiently, allows parallel systems to be built in a simple and modular way. occam and the transputer were chosen for the implementation and evaluation of a parallel prolog interpreter made up of a set of parallel processes communicating according to a message-passing protocol. The parallel execution model adopted exploits full OR parallelism and pipeline AND parallelism, while preserving the depth-first search technique of the classical sequential model. The aim of the implementation was to evaluate the actual degree of parallelism exploited by the execution model, and the efficiency of the used resolution algorithm. The number of living processes was found to be consistent with the number of processors in the architecture used (four), and the additional workload produced by the message exchanges between processes was found not to be excessively time consuming.

Efficient database access from Prolog

In designing the interface between a relational database and a Prolog interpreter, efficiency is a major issue. The authors present a method for loading into the memory-resident database of Prolog facts permanently stored in secondary storage. The rationale of the method is to save access to the database by never repeating the same query and by storing in main memory, in a compact and efficient way, information about the past interaction with the database. The authors discuss how to reduce subsumption rests required by the method to pattern matching in many relevant cases. They also describe a simulator of the method, which validates their approach, and they discuss the results of the simulation. >

A prolog-based decision support system for computer capacity planning

This paper describes a project to implement a decision support system for computer capacity planning. The system provides an intelligent interface to the various models needed for this type of planning by assisting the user in model formulation, data manipulation, model execution, interpretation and manipulation of results. The implementation strategy is based on the integration of relational model and database management with logic. A modified version of a Prolog interpreter is utilized as the vehicle for this integrated strategy.

Application of Logic Programming in Linear System Identification

An experimental CAD system is built, demonstrating the utility of coupling numerical and logic programming in solving model identification problems. The feasibility study is performed on a software package for model based signal processing (SIG) coupled together with a standard Edinburgh PROLOG interpreter. The rule-based advisor written in PROLOG helps the identification algorithm written in the SIG command language to choose the structure of an ARMAX model that fits best a given time series sequence. Simulation experiments confirm the utility of coupling the numerical and logic programming packages for this purpose.

A common-LISP implementation of an extended Prolog system

This paper presents an extended Common LISP implementation of a PROLOG interpreter named CL-Prolog, giving a detailed description of the major problems met and the principal data structures and algorithms used for their solution.A sort of PROLOG virtual processor has been implemented whose instructions are defined using LISP as microcode; particular attention is payed to the the Memory Management Unit and the basic Control Mechanism.The reader is supposed to be accustomed with PROLOG Programming and the evaluation of the first order Logic Predicates.The main characteristics of CL-Prolog are:- Clean separation from the host language.- Tail recursion handling and binding mechanism optimization.- Portability, flexibility, and extendibility of basic model.- Interaction between PROLOG code and host LISP interpreter.Interpreter's core is separated in three big modules in order to cut off the different issues :- the reader, the evaluator, and the resources manager -Finally the introduction of a double-stack recursion management has sped up the Backtracking mechanism; the resulting overall performances of this interpreter are really comparable to other commercial one even when they are implemented using procedural languages, supposed faster, confirming the possibility of using very high level languages as effective tools for real implementations.

A PROLOG-BASED CHINESE EXPERT SYSTEM

This paper presents the design and implementation of a Chinese Expert System Shell which is based on a Chinese Prolog interpreter. The system is divided into three parts: the knowledge acquisition module, the knowledge application module and the inference engine. The knowledge engineer defines the syntax of the language to be used by himself and by the users when they interact with the system. The natural language interface is table driven and can be modified easily. The system also caters for the case when the domain expert finds it difficult to articulate the rules, but is able to give examples. An inductive engine is included to extract rules from examples.

Book review: Prolog for Programmers by Feliks Kluzniak and Stanislaw Szpakowicz (Academic Press)

Prolog for Programmers (PP) delivers what it promises by introducing Prolog to programmers from other languages; I know of no better introduction for this audience. (The dialect used is a slight variant of DEC-10 Prolog.) Yet even the experienced Prolog programmer can gain from PP's first-rate treatment of data structures, control, programming techniques, and implementation. The style is clear and concise, and a dry wit makes it fun to read. PP could be used as language text in an introductory Al course; for example, we have used it along with Genesereth and Nilsson's Logical Foundations of Artificial Intelligence. PP also addresses broader issues such as language extensibility with a chapter on definite-clause grammars; database with a case study of relational databases in Prolog; planning with an analysis of a STRIPS problem in WARPLAN; and implementation and optimization with a discussion of the authors' own Prolog interpreter. PP furnishes source for the interpreter and case studies in listings as well as on a floppy diskette.

Ariadne's thread: An introduction to logic programming

Ariadne's Thread is a package composed of a self-instruction text addressed to high school students coupled with a commercially available prolog interpreter. The material is aimed at introducing computer novices to the concepts of logic programming. The examples and tasks in the package are based on the metaphor of Theseus in Crete with the subject matter presented through a series of dialogues between Ariadne and Theseus, introducing Prolog, a “genius” who will help him to find a way out of the labyrinth. Thirty secondary school teachers of different subjects with little or no computer experience attended a week-long summer school based on Ariadne's Thread. During the first two days they were introduced to Prolog in lectures, in the remaining three days they developed small Prolog applications in groups in the lab. with one computer and a tutor assigned to each group. Data was collected through questionnaires. The results showed that the material was quite easily understood and motivating, and the participants were able to devise applications in their subject area but only with substantial help from the tutors. Prolog alone did not prove to be a suitable vehicle for an introduction to logic programming concepts. While simple examples were easily learnt, more difficult problems required mastery of the language far beyond the level attained. This study indicates that the learning environment needs to be developed to facilitate the use of problem solving techniques, and the course requires to be extended to two weeks duration.

A distributed Prolog system with AND parallelism

Design details and benchmark results are given for a Prolog interpreter that can be executed across a network by using message passing to implement AND-parallelism. The system is simple and easy to use, yet significantly speeds up existing programs. The system hardware is a group of Sun 3/50 workstations connected to a 10-Mb/s Ethernet. The number of machines actually used by the system is determined when it is initialized. The benchmark programs to test the system are a Prolog compiler, a recursive Fibonacci program, an implementation of the standard quicksort algorithm, and a simple chess program.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>