Prolog Implementation Research Articles

Metaphors, logic and type theory

Metaphorical use of language is often thought to be at odds with compositional, truth-conditional approaches to semantics: After all, most metaphors are literally false. In this article we sketch an approach to metaphors based on standard type theory. Our approach is classical: We do not invent a new logic. The approach models sense extension in a simple and elegant way: The properties (supertypes) shared between tenor and vehicle include the extensions of at least both. The original predicates remain unchanged. Our approach captures an asymmetry between metaphor and simile. The literal interpretation of a metaphor comes out as (mostly) false, whereas its nonliteral interpretation is that of a corresponding reduced simile. A compositional syntax-semantics interface is provided and a deductive account of metaphor resolution is outlined. The approach readily translates into a simple computational implementation in Prolog. We discuss how our approach addresses issues of generalization, feature selection, asy...

Taming Paraconsistent (and Other) Logics

We develop a fully algorithmic approach to “taming” logics expressed Hilbert style, that is, reformulating them in terms of analytic sequent calculi and useful semantics. Our approach applies to Hilbert calculi extending the positive fragment of propositional classical logic with axioms of a certain general form that contain new unary connectives. Our work encompasses various results already obtained for specific logics. It can be applied to new logics, as well as to known logics for which an analytic calculus or a useful semantics has so far not been available. A Prolog implementation of the method is described.

The use of Prolog language family for image recognition

The paper is devoted to the investigation of Prolog language family possibility for its use in the solving of the display image recognition. Diculti appeared in the Prolog implementation of the approach are marked out . It is shown the way in which the number of deduction algorithm steps allows to overcome the appeared diculties. Examples of the Prolog programs implementation to the separation of an etalon image from a complex one are done. Peculiarities of the use of dierent recognizable image formats are analized.

Exploiting Parallelism in Coalgebraic Logic Programming

We present a parallel implementation of Coalgebraic Logic Programming (CoALP) in the programming language Go. CoALP was initially introduced to reflect coalgebraic semantics of logic programming, with coalgebraic derivation algorithm featuring both corecursion and parallelism. Here, we discuss how the coalgebraic semantics influenced our parallel implementation of logic programming.

DESIGN AND IMPLEMENTATION OF AN EDITOR/INTERPRETER FOR A VISUAL LOGIC PROGRAMMING LANGUAGE

The design and implementation of a programming environment including an editor, a debugger and an interpreter engine for Lograph, a general-purpose visual logic programming language, is discussed. The rationale for user-interface design decisions is presented, the goal of which is to increase cognitive support for the creation, exploration and debugging of Lograph programs. The design of the interpreter engine allows for animation of execution in the debugger. The engine takes full advantage of an efficient implementation of Prolog, and operates on a Prolog translation of Lograph programs and queries. The translated Lograph programs are probed with instrumentation code at appropriate places so that applications of Lograph rules are reported to the visual interface of the Lograph debugger as a side effect of the execution of a program.

Meta-interpretive learning: application to grammatical inference

Despite early interest Predicate Invention has lately been under-explored within ILP. We develop a framework in which predicate invention and recursive generalisations are implemented using abduction with respect to a meta-interpreter. The approach is based on a previously unexplored case of Inverse Entailment for Grammatical Inference of Regular languages. Every abduced grammar H is represented by a conjunction of existentially quantified atomic formulae. Thus ¬H is a universally quantified clause representing a denial. The hypothesis space of solutions for ¬H can be ordered by ?-subsumption. We show that the representation can be mapped to a fragment of Higher-Order Datalog in which atomic formulae in H are projections of first-order definite clause grammar rules and the existentially quantified variables are projections of first-order predicate symbols. This allows predicate invention to be effected by the introduction of first-order variables. Previous work by Inoue and Furukawa used abduction and meta-level reasoning to invent predicates representing propositions. By contrast, the present paper uses abduction with a meta-interpretive framework to invent relations. We describe the implementations of Meta-interpretive Learning (MIL) using two different declarative representations: Prolog and Answer Set Programming (ASP). We compare these implementations against a state-of-the-art ILP system MC-TopLog using the dataset of learning Regular and Context-Free grammars as well learning a simplified natural language grammar and a grammatical description of a staircase. Experiments indicate that on randomly chosen grammars, the two implementations have significantly higher accuracies than MC-TopLog. In terms of running time, Metagol is overall fastest in these tasks. Experiments indicate that the Prolog implementation is competitive with the ASP one due to its ability to encode a strong procedural bias. We demonstrate that MIL can be applied to learning natural grammars. In this case experiments indicate that increasing the available background knowledge, reduces the running time. Additionally ASPM (ASP using a meta-interpreter) is shown to have a speed advantage over Metagol when background knowledge is sparse. We also demonstrate that by combining MetagolR (Metagol with a Regular grammar meta-interpreter) and MetagolCF (Context-Free meta-interpreter) we can formulate a system, MetagolRCF, which can change representation by firstly assuming the target to be Regular, and then failing this, switch to assuming it to be Context-Free. MetagolRCF runs up to 100 times faster than MetagolCF on grammars chosen randomly from Regular and non-Regular Context-Free grammars.

Forward Reasoning via Sequential Queries in Logic Programming

Most Prolog implementations are based on backward chaining techniques. However, there are many applications in which forward chaining ones are desirable such as in dynamic programming. In this paper, we first introduce a variant of a Prolog interpreter that computes interpolations and then introduce the notion of sequential queries. These two notions allow a combination of both forms of reasoning in Prolog. DOI: http://dx.doi.org/10.5755/j01.itc.41.4.2364

Representation sharing for Prolog

AbstractRepresentation sharing can reduce the memory footprint of a program by sharing one representation between duplicate terms. The most common implementation of representation sharing in functional programming systems is known as hash-consing. In the context of Prolog, representation sharing has been given little attention. Some current techniques that deal with representation sharing are reviewed. The new contributions are (1) an easy implementation ofinput sharingforfindall/3; and (2) a description of asharermodule that introduces representation sharing at runtime. Their realization is shown in the context of the Warren Abstract Machine (WAM) as implemented by hProlog. Both can be adapted to any WAM-like Prolog implementation. The sharer works independently of the garbage collector, but it can be made to cooperate with the garbage collector. Benchmark results show that the sharer has a cost comparable to the heap garbage collector, that its effectiveness is highly application-dependent, and that its policy must be tuned to the collector.

CSL-lean: A Theorem-prover for the Logic of Comparative Concept Similarity

The logic CSL of the comparative concept similarity has been introduced by Sheremet, Tishkovsky, Wolter and Zakharyaschev to capture a form of qualitative similarity comparison between concepts and/or objects. In this logic we can formulate assertions of the form “objects A are more similar to B than to C”. This kind of assertions can be added to an ontology to express qualitative comparisons between concepts. In this work we present CSL-lean, the first theorem-prover for this logic. It is a direct Prolog implementation of a tableaux-based decision procedure recently proposed for this logic. The Prolog program is inspired by the lean-methodology. CSL-lean also contains a graphical interface written in Java and it is available for free download at http://www.di.unito.it/~pozzato/csllean/.

Difference lists in Prolog

Prolog is taught at Bradford University within the two-semester module Symbolic and Declarative Computing/Artificial Intelligence. Second year undergraduate students are taught here the basics of the functional and the logic programming paradigms, the latter by using the Linux implementation of SWI Prolog [6]. The topic 'Difference lists' is mentioned in traditional textbooks such as [2] and [5] but it was felt that the available texts do not quite serve our purposes. We present here a lecture handout and a laboratory sheet for the teaching sessions on Difference lists. It is believed that the lectures and lab sessions together with the handouts shown here are a gentle, self-contained and reasoned introduction into the topic. The figures here shown to illustrate the concepts are considered a special feature of the handouts which in this form do not seem to be well known.

Executable specification of open multi-agent systems

Multi-agent systems where the agents are developed by parties with competing interests, and where there is no access to an agent’s internal state, are often classified as ‘open’. The members of such systems may inadvertently fail to, or even deliberately choose not to, conform to the system specification. Consequently, it is necessary to specify the normative relations that may exist between the members, such as permission, obligation, and institutional power. We present a framework being developed for executable specification of open multi-agent systems. We adopt a bird’s eye view of these systems, as opposed to an agent’s perspective whereby it reasons about how it should act. This paper is devoted to the presentation of various examples from the NetBill protocol formalised in terms of institutional power, permission and obligation. We express the system specification in the Event Calculus and execute the specification by means of a logic programming implementation. We also give several example formalisations of sanctions for dealing with violations of permissions and obligations. We distinguish between an open multi-agent system and the procedure by which an agent enters and leaves the system. We present examples from the specification of a role-management protocol for NetBill, and demonstrate the interplay between such a protocol and the corresponding multi-agent system.

An implementation of a dual tableaux system for order-of-magnitude qualitative reasoning

Logic programming has been used as a natural framework to automate deduction in the logic of order-of-magnitude reasoning. Specifically, we introduce a Prolog implementation of the Rasiowa–Sikorski proof system associated with the relational translation Re(OM) of the multi-modal logic of order-of-magnitude qualitative reasoning OM.

Molecular implementation of simple logic programs

Autonomous programmable computing devices made of biomolecules could interact with a biological environment and be used in future biological and medical applications. Biomolecular implementations of finite automata and logic gates have already been developed. Here, we report an autonomous programmable molecular system based on the manipulation of DNA strands that is capable of performing simple logical deductions. Using molecular representations of facts such as Man(Socrates) and rules such as Mortal(X) <-- Man(X) (Every Man is Mortal), the system can answer molecular queries such as Mortal(Socrates)? (Is Socrates Mortal?) and Mortal(X)? (Who is Mortal?). This biomolecular computing system compares favourably with previous approaches in terms of expressive power, performance and precision. A compiler translates facts, rules and queries into their molecular representations and subsequently operates a robotic system that assembles the logical deductions and delivers the result. This prototype is the first simple programming language with a molecular-scale implementation.

Implementing Constructive Intensional Negation

Although negation is an active area of research in logic programming, sound and complete implementations are still absent from actual Prolog systems. One of the most promising techniques in the literature is intensional negation (IN), which follows a transformational approach: for each predicate p in a program its negative counterpart intneg(p) is generated. However, implementations of IN have not been included in Prolog environments due, in part, to the lack of details and explicit techniques, such as the treatment of universally quantified goals. In this paper, we describe a variant of IN, which we have called constructive intensional negation (CIN). Unlike earlier proposals, CIN does not resort to a dedicated resolution strategy when dealing with universally quantified formulae, which has been instrumental in having an effective implementation. Therefore, pure SLD resolution is used, what enables the reuse of existing Prolog implementation technology. Among the contributions of this work we can mention not only a full implementation being tested for its integration in the Ciao Prolog system but also some formal results ensuring soundness and completeness with their associated proofs.

Maintenance goals of agents in a dynamic environment: Formulation and policy construction

The notion of maintenance often appears in the AI literature in the context of agent behavior and planning. In this paper, we argue that earlier characterizations of the notion of maintenance are not intuitive to characterize the maintenance behavior of certain agents in a dynamic environment. We propose a different characterization of maintenance and distinguish it from earlier notions such as stabilizability. Our notion of maintenance is more sensitive to a good-natured agent which struggles with an “adversary” environment, which hinders her by unforeseeable events to reach her goals (not in principle, but in case). It has a parameter k, referring to the length of non-interference (from exogenous events) needed to maintain a goal; we refer to this notion as k-maintainability. We demonstrate the notion on examples, and address the important but non-trivial issue of efficient construction of maintainability control functions. We present an algorithm which in polynomial time constructs a k-maintainable control function, if one exists, or tells that no such control is possible. Our algorithm is based on SAT Solving, and employs a suitable formulation of the existence of k-maintainable control in a fragment of SAT which is tractable. For small k (bounded by a constant), our algorithm is linear time. We then give a logic programming implementation of our algorithm and use it to give a standard procedural algorithm, and analyze the complexity of constructing k-maintainable controls, under different assumptions such as k = 1 , and states described by variables. On the one hand, our work provides new concepts and algorithms for maintenance in dynamic environment, and on the other hand, a very fruitful application of computational logic tools. We compare our work with earlier works on control synthesis from temporal logic specification and relate our work to Dijkstra's notion of self-stabilization and related notions in distributed computing.

On deducing causality in metabolic networks

BackgroundMetabolic networks present a complex interconnected structure, whose understanding is in general a non-trivial task. Several formal approaches have been developed to support the investigation of such networks. One of the relevant problems in this context is the comprehension of causality dependencies amongst the molecules involved in the metabolic process.ResultsWe apply techniques from formal methods and computational logic to develop an abstract qualitative model of metabolic networks in order to determine possible causal dependencies. Keeping in mind both expressiveness and ease of use, we aimed at providing: i) a minimal notation to represent causality in biochemical interactions, and ii) an automated tool allowing human experts to easily vary conditions of in silico experiments. We exploit a reading of chemical reactions in terms of logical implications: starting from a description of a metabolic network in terms of reaction rules and initial conditions, chains of reactions, causally depending one from the another, can be automatically deduced. Both the components of the initial state and the clauses ruling reactions can be easily varied and a new trial of the experiment started, according to a what-if investigation strategy. Our approach aims at exploiting computational logic as a formal modeling framework, amongst the several available, that is naturally close to human reasoning. It directly leads to executable implementations and may support, in perspective, various reasoning schemata. Indeed, our abstractions are supported by a computational counterpart, based on a Prolog implementation, which allows for a representation language closely correspondent to the adopted chemical abstract notation. The proposed approach has been validated by results regarding gene knock-out and essentiality for a model of the metabolic network of Escherichia coli K12, which show a relevant coherence with available wet-lab experimental data.ConclusionsStarting from the presented work, our goal is to provide an effective analysis toolkit, supported by an efficient full-fledged computational counterpart, with the aim of fruitfully driving in vitro experiments by effectively pruning non promising directions.

Theorem proving for conditional logics: CondLean and GOALDUCK

In this paper we focus on theorem proving for conditional logics. First, we give a detailed description of CondLean, a theorem prover for some standard conditional logics. CondLean is a SICStus Prolog implementation of some labeled sequent calculi for conditional logics recently introduced. It is inspired to the so called “lean” methodology, even if it does not fit this style in a rigorous manner. CondLean also comprises a graphical interface written in Java. Furthermore, we introduce a goal-directed proof search mechanism, derived from the above mentioned sequent calculi based on the notion of uniform proofs. Finally, we describe GOALDUCK, a simple SICStus Prolog implementation of the goal-directed calculus mentioned here above. Both the programs CondLean and GOALDUCK, together with their source code, are available for free download at.

PALS: Efficient Or-Parallel execution of Prolog on Beowulf clusters

AbstractThis paper describes the development of thePALSsystem, an implementation of Prolog capable of efficiently exploiting or-parallelism ondistributed-memoryplatforms—specifically Beowulf clusters. PALS makes use of a novel technique, calledincremental stack-splitting. The technique proposed builds on the stack-splitting approach, previously described by the authors and experimentally validated on shared-memory systems, which in turn is an evolution of the stack-copying method used in a variety of parallel logic and constraint systems—e.g., MUSE, YAP, and Penny. The PALS system is the first distributed or-parallel implementation of Prolog based on the stack-splitting method ever realized. The results presented confirm the superiority of this method as a simple yet effective technique to transition from shared-memory to distributed-memory systems. PALS extends stack-splitting by combining it with incremental copying; the paper provides a description of the implementation of PALS, including details of how distributed scheduling is handled. We also investigate methodologies to effectively support order-sensitive predicates (e.g., side-effects) in the context of the stack-splitting scheme. Experimental results obtained from running PALS on both Shared Memory and Beowulf systems are presented and analyzed.

Proving Arrow’s theorem by PROLOG

This paper presented a simple PROLOG implementation for Arrow's Social welfare function (SWF). Arrow (Social choice and individual values, Yale University Press, 1963) proved that any SWF which satisfies a set of conditions IIA, Pareto, and unrestricted domain should be dictatorial. The PROLOG program can prove the theorem for 3-alternative 2-agent case. With a minor modification it proves a version of the theorem without the Pareto condition by Wilson (Journal of Economic Theory, 5, 478---486, 1972).

Rotations in the plane and Prolog

Rotation is a well-known operation on lists. We define its two-dimensional analogue and discuss its implementation in Prolog using difference lists. An application to the iterative solution of a system of linear equations by the Gauss–Seidel method is given.