Prolog Procedures Research Articles

Near-Horn Prolog and the ancestry family of procedures

The Near-Horn Prolog procedures have been proposed as effective procedures in the area of disjunctive logic programming, an extension of logic programming to the (first-order) non-Horn clause domain. In this paper, we show that these case-analysis based procedures may be viewed as members of a class of procedures called the ``ancestry family,'''' which also includes Model Elimination (and its variants), the Positive Refinement of Model Elimination, and SLWV. The common feature which binds these procedures is the extension of SLD-resolution to full first-order logic with the addition of an ancestor cancellation rule. Procedures in the ancestry family are all sound and complete first-order procedures that can be seen to vary along three parameters: (1) the number of clause contrapositives required, (2) the amount of ancestor checking that must occur, and (3) the use (if any) of a Restart rule. Using a sequent-style presentation format for all procedures, we highlight the close relationships between these procedures and compare their relative advantages.

Simulation of communications architecture specifications using Prolog

The design of the Cara simulator, a Prolog-based simulator for communications architecture specifications, is described. Unlike other Prolog-based simulation methods, the Cara simulator supports “exploratory simulation”, in which high-level, incomplete specifications may be simulated, and various specification alternatives and elaborations added to the specification during the course of the simulation. Unlike other simulation methods, which construct Prolog procedures whose behavior models that of the specification, our simulator maintains execution traces of simulated protocol behavior and adds to these traces through the application of rules of inference reflecting the protocol behavior. This method provides a flexibility not found in other approaches.

Performance of Muse on switch-based multiprocessor machines

The Muse (multiple sequential Prolog engines) approach has been used to make a simple and efficient OR-parallel implementation of the full Prolog language. The performance results of the Muse system on bus-based multiprocessor machines have been presented in previous chapters, papers. This chapter paper discusses the implementation and performance results of the Muse system on switch-based multiprocessors (the BBN Butterfly GP1000 and TC2000). The results of Muse execution show that high real speedups can be achieved for Prolog programs that exhibit coarse-grained parallelism. The scheduling overhead is equivalent to around 8 -- 26 Prolog procedure calls per task on the TC2000. The chapter paper also compares the Muse results with corresponding results for the Aurora OR-parallel Prolog system. For a large set of benchmarks, the results are in favor of the Muse system.

A recursive techniques editor for Prolog

We describe an editor geared to recursive Prolog procedures. It is similar to the structure editors built for many programming languages, except that instead of just ensuring the correctness of the syntax of the procedures built by the editor, the editor also ensures the correct use of recursion. By correct here we mean that the recursive procedure is guaranteed to terminate and to be well-defined. Within these constraints we have tried to ensure that the range of procedures that can be built is as complete as possible.

Bagof/3 to ZF expression

There is sometimes the requirement in logic programming applications to collect all the solutions of a non-deterministic program and associated goal. A manual technique is given for translating an example Prolog procedure, append/3, used by the predicate bagof/3, to a functionally equivalent program expressed in the functional programming language Miranda which uses a ZF (Zermelo Frankel) expression.

Prolog in ‘C’

This paper describes a procedural definition of Prolog based on the features of the 'C' programming language. Our motivation to exploit the complementary nature of procedural and declarative programming lead to the objective of a dual Prolog and 'C' programming environment. A translator has been built which accepts Prolog programs and produces sets of 'C' functions which can be integrated into a 'C' program to form a single, common language target system. Each 'C' function corresponds to a single Prolog procedure. The emphasis of the translation is placed on producing a consistent and readable format for PIC ( Prolog in 'C' ) code which allows the user to optimize the code by tuning. Examples are provided to demonstrate the benefit of optimizations versus their programming effort. The PIC code produced by the translator has been tested for accuracy, coverage, and efficiency, and exhibited acceptable results.

Using Prolog for building frog, a hybrid knowledge representation system

FROG (FRames in ProlOG) is a Prolog based hybrid knowledge representation system which combines frames, production rules and Prolog at various levels. In this paper we shall first describe the particular technique we used for buiding the FROG system in Prolog. This technique is based on the use of apreprocessor which is able to produce the effective Prolog implementation of the system from an appropriate high level description of the knowledge of a given domain. We shall then describe the main features of the FROG system. The system supplies the knowledge engineer with a veryflexible frame structure in which each frame can contain either slots or production rules (with various kinds of inference strategies) and gives the possibility of using Prolog procedures in various places within each frame. Some hints on the Prolog implementation will also be given. Finally, the FROG high level language will be described. Both syntax and semantics of such a language are based on Prolog, thus assuring a uniform and precise description of a knowledge base. The language also allows control strategies in the system to be explicitly defined by the knowledge engineer.

Please: a language combining imperative and logic programming

PLEASE is an Ada®-based, executable specification language which supports a formal development method similar to VDM. Like ANNA, PLEASE allows software to be annotated with formulae written in predicate logic; annotations can be used in proofs of correctness and to generate run-time assertion checks. PLEASE differs from ANNA by restricting the logic used in annotations to Horn clauses; therefore, PLEASE specifications can also be transformed into prototypes which use Prolog to "execute" pre- and post-conditions. We believe the early production of executable prototypes will enhance the development process. We also believe the restriction to Horn clauses will allow us to build on the significant research being performed on logic-based programming languages and databases. In this paper we give an overview of PLEASE, present an example specification, describe the translation of PLEASE specifications into Prolog procedures, and discuss some of the techniques used to obtain acceptable efficiency in the resultant prototypes.