Prolog Programs Research Articles

A prolog program for decomposing clothing orders into lays

We describe a Prolog program for solving a problem occurring in the clothing industry. The input of the problem is a clothing "order," consisting of a number of requested garments for each size. The output is a decomposition of the given order into "lays," producing exactly the requested number of garments per size. We wish to minimize both the fabric and the labor costs. For each lay we are only interested in knowing how many copies of the set of pieces of each size are to be placed (we do not deal with the geometrical problem of placing such pieces). Computing an optimal decomposition can be viewed as a generalization of the bin-packing problem.Our system uses an enumerative, branch-and-bound method to traverse a search space. This approach resulted practical only for orders with up to seven sizes. However, since most of the orders in the firm where we found this problem have exactly this number of sizes, our system is useful in spite of having this limitation.

A practical object-oriented analysis engine for CLP

The incorporation of global program analysis into recent compilers for Constraint Logic Programming (CLP) languages has greatly improved the efficiency of compiled programs. We present a global analyser based on abstract interpretation. Unlike traditional optimizers, whose designs tend to be ad hoc, the analyser has been designed with flexibility in mind. The analyser is incremental, allowing substantial program transformations by a compiler without requiring redundant re-computation of analysis data. The analyser is also generic in that it can perform a large number of different program analyses. Furthermore, the analyser has an object-oriented design, enabling it to be adapted to different applications easily and allowing it to be used with various CLP languages with simple modifications. As an example of this generality, we sketch the use of the analyser in two different applications involving two distinct CLP languages: an optimizing compiler for CLP(R) programs and an application for detecting occur-check problems in Prolog programs. © 1998 John Wiley & Sons Ltd.

Lean TAP revisited

A sequent calculus of a new sort is extracted from the Prolog program lean7AP. This calculus is sound and complete, even though it lacks almost all structural rules. Thinking of lean7AP as a sequent calculus provides a new perspective on it and, in some ways, makes it easier to understand. It is also easier to verify correctness and completeness of the Prolog implementation. In addition, it suggests extensions to other logics, some of which are considered here.

An expert system for the interpretation of pyrolysis mass spectra of condensation polymers

The PROLOG programming language was used for the construction of the Expert System (ES) HEPHESTUS used in the interpretation of pyrolysis mass spectra of condensation polymers, such as polyamides, polycarbonates, polyethers, polyesters, polyureas, polyurethanes, polyimides, polysulphides, polysulfones, polyschiff bases, polysiloxanes and polyphosphagenes. The ES can be applied to Pyrolysis Mass Spectrometry (PyMS) spectra of polymers using Electron Impact, Chemical Ionisation or Desorption Chemical Ionisation modes. The sample is introduced and pyrolysed directly in the source of the mass spectrometer. The ES knowledge base is organised in a tree form, based on polymer structures. The inference mechanism uses empirical algorithms and the autocorrelation algorithm to determine important information present in the unknown polymer spectrum. Possible solutions are proposed using the Certainty Factor model and based on the rules of the knowledge base. The autocorrelation algorithm, used to determine the repeating unit, gave 57.3% of successes and 42.7% not best choices. Among the not best choices the 23.3% were failures. For the same purpose, the empirical algorithm gave 68.5% successes and 31.5% not best choices (among them 35.7% were failures). User interaction improves the ES's performance to propose the correct polymer (94.4% of the trials were the best choices).

Elimination of Self-Resolving Clauses

It is shown how self-resolving clauses like symmetry or transitivity, or even clauses like condensed detachment, can faithfully be deleted from the clause set, thus eliminating or at least reducing recursiveness and circularity in clause sets. Possible applications are reducing the search space for automated theorem provers, eliminating loops in Prolog programs, parallelizing simple closure computation algorithms, and supporting automated complexity analysis.

Discovering Error Classes from Discrepancies in Novice Behaviors Via Multistrategy Conceptual Clustering

The automatic discovery of classes of errors that represent misconceptions and other knowledge errors underlying discrepancies in novice behavior is not a trivial task. A novel approach to this problem is described, in which relationships among behavioral discrepancies are analyzed and inductively generalized via an unsupervised, incremental, relational multistrategy conceptual clustering method that takes into account similarities as well as causalities in the data. Performance results on the classification of discrepancy sets and discovery of error classes from discrepancies of buggy PROLOG programs demonstrate the potential of the approach.

Schema induction for logic program synthesis

Prolog program synthesis can be made more efficient by using schemata which capture similarities in previously-seen programs. Such schemata narrow the search involved in the synthesis of a new program. We define a generalization operator for forming schemata from programs and a downward refinement operator for constructing programs from schemata. These operators define schema-hierarchy graphs which can be used to aid in the synthesis of new programs. Algorithms are presented for efficiently obtaining least generalizations of schemata, for adding new schemata to a schema-hierarchy graph, and for using schemata to construct new programs.

Transformational methodology for proving termination of logic programs

A methodology for proving the termination of well-moded logic programs is developed by reducing the termination problem of logic programs to that of term rewriting systems. A transformation procedure is presented to derive a term rewriting system from a given well-moded logic program such that the termination of the derived rewrite system implies the termination of the logic program for all well-moded queries under a class of selection rules. This facilitates applicability of a vast source of termination orderings proposed in the literature on term rewriting, for proving termination of logic programs. The termination of various benchmark programs has been established with this approach. Unlike other mechanizable approaches, the proposed approach does not require any preprocessing and works well, even in the presence of mutual recursion. The transformation has also been implemented as a front end to Rewrite Rule Laboratory (RRL) and has been used in establishing termination of nontrivial Prolog programs such as a prototype compiler for ProCoS, PL 0 language.

Directional types and the annotation method

A directonal type for a Prolog program expresses certain properties of the operational semantics of the program. This paper shows that the annotation proof method, proposed by Deransart for proving declarative properties of logic programs, is also applicable for proving correctness of directional types. In particular, the sufficient correctness criterion of well-typedness by Bronsard et al., turns out to be a specialization of the annotation method. The comparison shows a general mechanism for construction of similar specializations, which is applied to derive yet another concept of well-typedness. The usefulness of the new correctness criterion is shown on examples of Prolog programs, where the traditional notion of well-typedness is not applicable. We further show that the new well-typing condition can be applied to different execution models. This is illustrated by an example of an execution model where unification is controlled by directional types, and where our new well-typing condition is applied to show the absence of deadlock.

Meta-programming in CLP(R)

A widely used property of Prolog is that it is possible to write Prolog programs to construct and manipulate other Prolog programs in a very general manner. Unfortunately, this property is not carried over to richer languages such as CLP(R>)—the manipulation of CLP(R) programs in CLP(R) is quite limited. The reason is that the equality of terms in CLP(R) is not based on their syntactic structure. We propose an extended language, CLP( R + M), in which programs may be represented and structurally manipulated. Importantly, CLP( R + M) is not just a meta-language for CLP(R), but it can also be used as its own meta-language. We present a decision algorithm for ( R + M) constraints, discuss implementation issues, and describe the implementation of a subclass of ( R + M) constraints. Finally, by building on the extended language, we present an integrated set of system predicates and a methodology for practical meta-programming.

Reasoning system with fuzzy uncertainty

In this paper we present a system of uncertain inference for expert systems which works with knowledge represented in form of production rules accompanied by uncertainty degrees expressed by fuzzy numbers. Our system generates a Turbo Prolog program which has included the operations for uncertainty management.

Prosum-Prolog system for uncertainty management

In this paper we present a system which uses knowledge represented in the form of production rules accompanied by uncertainty degrees. The uncertainty of a rule is given by using the method from SLOP and FRIL: a support pair, which comprises a necessary and possible support and can be interpreted as an interval in which the unknown probability lies. Giving the knowledge in this form, our system generates a Turbo Prolog program which has included the operations for uncertainty management. In this version, two kinds of rules for support logic programming are implemented but the user can propose the other ones, by using the dialogue with the system. Semantic unification differs from that used in FRIL; we use generalized belief functions.

Comparison of contrasting Prolog trace output formats

This paper reports on a comparative study of three Prolog trace packages. Forty-three students of an introductory Prolog course solved five different Prolog programming problems in each of three different conditions (using isomorphic problem variants to disguise recurring tasks). Each of the three conditions provided subjects with static screen-snapshot-mockups derived from one of three different trace packages (“conventional” Spy; “graphical AND/OR tree-based” TPM*; “informative textual” EPTB). When traces explicitly displayed the information asked for in the problem, subjects solved the problems more quickly. Conversely, when trace output obscured the required information (or necessitated difficult detective work to uncover the information), solution times were longer and answers less accurate. Deciding on a “good” format for display is thus a task-dependent decision, and impacts directly on the user's cognitive ability to solve a problem.

On the completeness of naive memoing in Prolog

Memoing is often used in logic programming to avoid redundant evaluation of similar goals, often on programs that are inherently recursive in nature. The interaction between memoing and recursion, however, is quite complex. There are several top-down evaluation strategies for logic programs that utilize memoing to achieve completeness in the presence of recursion. This paper’s focus, however, is on the use ofnaive memoing in Prolog. Using memoingnaively in conjunction with recursion in Prolog may not produce expected results. For example, adding naive memoing to Prolog’s evaluation of a right-recursive transitive closure may be incomplete, whereas adding naive memoing to Prolog’s evaluation of a left-recursive transitive closure may be terminating and complete. This paper examines the completeness of naive memoing in linear-recursive, function-free logic programs evaluated with Prolog’s top-down evaluation strategy. In addition, we assume that the program is definite and safe, having finite base relations and exactly one recursive predicate. The goal of the paper is a theoretical study of the completeness of naive memoing and recursion in Prolog, illustrating the limitations imposed even for this simplified class of programs. The naive memoing approach utilized for this study is based on extension tables, which provide a memo mechanism with immediate update view semantics for Prolog programs, through a source transformation known as ET. We introduce the concept ofET-complete, which refers to the completeness of the evaluation of a query over a Prolog program that memos selected predicates through the ET transformation. We show that left-linear recursions defined by a single recursive rule are ET-complete. We generalize the class of left-linear recursions that are ET-complete by introducing pseudo-left-linear recursions, which are also defined by a single linear recursive rule. To add left-linear recursions defined bymultiple linear recursive rules to the class of ET-complete recursions, we present a left-factoring algorithm that converts left-linear recursions defined by multiple recusive rules into pseudo-left-linear recursions defined by a single recursive rule. Based on these results, the paper concludes by identifying research directions for expanding the class of Prolog programs to be examined in future work.

Algebraic computational models of OR-parallel execution of Prolog

A specification of the OR-parallel execution of Prolog programs, using CHOCS (calculus of higher order communicating systems) [24], is presented in the paper. A translation is defined from Prolog programs and goals to CHOCS processes: the execution of the CHOCS process corresponding to a goal mimics the OR-parallel execution of the original Prolog goal. In the translation, clauses and predicate definitions of a Prolog program correspond to processes. To model OR-parallelism, the processes \(P^1, \cdots , P^n\), corresponding to clauses \(C_1, \cdots , C_n\) (having the same head predicate \(p\)) start their execution concurrently, but, in order to respect the depth-first search rule, each \(P^i\) is guarded by the termination of the executions of processes \(P^j\)'s, \(j < i\). The computational model is proved correct with respect to the semantics of Prolog, as given in [4, 5]. Our model, because of its algebraic specification, can be easily used to prove properties of the parallel execution of Prolog programs. Moreover, the model exploits the maximum degree of parallelism, by giving the Prolog solutions in parallel, without any order among them. However, this model, being close to the Prolog semantics definition, contains sources of inefficiency which make it unpractical as a guide for the implementation. To overcome these problems, a new computational model is defined. This model is obtained by modifications of the basic one and thus its correctness can be easily proved. Finally, we show how to obtain models of different real implementations of OR-parallel Prolog by slight modification of the new model. The relations among all these models, in terms of parallelism degree, are studied by using the concepts of bisimulation and simulation, developed for concurrent calculi.

Tools for mapping, load balancing and monitoring in the LOGFLOW parallel Prolog project

LOGFLOW is an all-solution parallel logic programming system able to exploit OR-parallelism and pipeline AND-parallelism of Prolog programs. The LOGFLOW project is intended to implement Prolog on massively parallel distributed memory multicomputers. Porting LOGFLOW to a workstation cluster resulted in a variant of LOGFLOW called WS-LOGFLOW. Implementation of LOGFLOW both on multi-transputers and on workstation clusters required to solve many parallel software engineering problems like load balancing, mapping, monitoring, debugging, etc. In this paper the load balancing, mapping and monitoring techniques applied in multi-transputer based LOGFLOW systems have been described. The concept of WS-LOGFLOW and its Distributed Token Scheduler scheme for load balancing is also explained in the paper.

Determination of Topo-Geometrical Equivalence Classes of Atoms

In this paper we present a Prolog program which generates a molecular code that identifies the topological and geometrical equivalence classes of atoms in molecules. The initial partitioning of atoms is based on the list of successive extended connectivity and on the chromatism of the molecular graph. The definitive topological classes are obtained by matching all canonical labeled mapping trees exhaustively generated during the construction of a unique one-to-one topological code. Further, the geometric classes of atoms are identified on the basis of the lists of successive interatomic Euclidean distances generated following the molecular topology. The resulting topo-geometrical equivalence classes of atoms allow the construction of a molecular canonical code which maintains the distinction between the topology and the geometry. Thus stereoisomers and conformers share the same topological part of the canonical code but differ by their geometrical parts. The method developed in this work has a wide range ...

Design and Simulation of the Aquarius-II Multiprocessor

Aquarius-II is a cache coherent multiprocessor system designed for the parallel execution of Prolog programs. It contains two tiers of memory: synchronization memory and high bandwidth (HB) memory. The synchronization memory consists of snooping caches connected to a bus and is used to store rendezvous points, synchronization bits, synchronization variables such as locks and semaphores and most of the write shared data. The HB memory is used to store the bulk of the application program code and data. It contains caches and an inexpensive VLSI chip based crossbar interconnection network to memory. The caches connected to the crossbar do not have full snooping capability. The architecture is evaluated by a full simulation of parallel execution of Prolog programs on Aquarius-II. The design details of the components of the architecture and simulation results are presented. Simulation results indicate that the two tier memory system significantly reduces memory interference and speeds up synchronization when compared to a single bus multi. This shared memory multiprocesor architecture has the potential to support other parallel programming paradigms.

An Abstract Approach to Some Loop Detection Problems

The abstract approach proposed here encompasses both the detection of some periodic loops during the execution of Prolog programs and the detection of some periodic loops during recursive computations (an attempt to look at the loop detection problem for Prolog from an abstract point of view has been done previously in a paper by the same author published in 1993).

High-level characteristics of or- and independent and-parallelism in prolog

Although studies of a number of parallel implementations of logic programming languages are now available, their results are difficult to interpret due to the multiplicity of factors involved, the effect of each of which is difficult to separate. In this paper we present the results of a high-level simulation study of or- and independent and-parallelism with a wide selection of Prolog programs that aims to determine the intrinsic amount of parallelism, independently of implementation factors, thus facilitating this separation. We expect this study will be instrumental in better understanding and comparing results from actual implementations, as shown by some examples provided in the paper. In addition, the paper examines some of the issues and tradeoffs associated with the combination of and- and or-parallelism and proposes reasonable solutions based on the simulation data obtained.