SLD Resolution Research Articles

Flexible coinductive logic programming

AbstractRecursive definitions of predicates are usually interpreted either inductively or coinductively. Recently, a more powerful approach has been proposed, called flexible coinduction, to express a variety of intermediate interpretations, necessary in some cases to get the correct meaning. We provide a detailed formal account of an extension of logic programming supporting flexible coinduction. Syntactically, programs are enriched by coclauses, clauses with a special meaning used to tune the interpretation of predicates. As usual, the declarative semantics can be expressed as a fixed point which, however, is not necessarily the least, nor the greatest one, but is determined by the coclauses. Correspondingly, the operational semantics is a combination of standard SLD resolution and coSLD resolution. We prove that the operational semantics is sound and complete with respect to declarative semantics restricted to finite comodels.

Proximity-Based Unification: An Efficient Implementation Method

Unification is a central concept in logic systems based on the resolution principle. As well, in knowledge representation, proximity relations (i.e., reflexive, symmetric, fuzzy binary relations) are useful for introducing semantics into a syntactic level by modeling the semantic closeness of different syntactic objects and managing vague or imprecise information. Proximity relations, in combination with the unification algorithm, make possible expressing certain forms of approximate reasoning in a logic programming framework. In this article, we use proximity relations in the context of a (fuzzy) logic programming system, called Bousi ~ Prolog, as a way of solving the limitations introduced by similarity relations (i.e., transitive proximity relations) to correctly represent fuzzy information. Recently, we introduced an accurate definition of proximity between expressions (terms or atomic formulas) and a new unification algorithm able to manage proximity relations properly. However, the so-called weak unification algorithm, which is an extension of Martelli and Montanari's unification algorithm supported by the new notion of proximity, does not have an efficient implementation. In this article, we present a method that facilitates such an efficient implementation, including an adaptation of the weak SLD resolution rule based on the new unification algorithm, and its integration and implementation into the fuzzy logic programming system Bousi ~ Prolog. A performance analysis to show its efficiency is also presented.

A Fuzzy Datalog Deductive Database System

This paper describes a proposal for a deductive database system with fuzzy Datalog as its query language. Concepts supporting the fuzzy logic programming system Bousi~Prolog are tailored to the needs of the deductive database system DES. We develop a version of fuzzy Datalog where programs and queries are compiled to the DES core Datalog language. Weak unification and weak SLD resolution are adapted for this setting, and extended to allow rules with truth degree annotations. We provide a public implementation in Prolog, which is open source, multiplatform, portable, and in-memory, featuring a graphical user interface. A distinctive feature of this system is that, unlike others, we have formally demonstrated that our implementation techniques fit the proposed operational semantics. We also study the efficiency of these implementation techniques through a series of detailed experiments. Moreover, a database example for a recommender system is used to illustrate some of the features of the system and its usefulness.

A framework for computing finite SLD trees

The search space of SLD resolution, usually represented by means of a so-called SLD tree, is often infinite. However, there are many applications that must deal with possibly infinite SLD trees, like partial evaluation or some static analyses. In this context, being able to construct a finite representation of an infinite SLD tree becomes useful.In this work, we introduce a framework to construct a finite data structure representing the (possibly infinite) SLD derivations for a goal. This data structure, called closed SLD tree, is built using four basic operations: unfolding, flattening, splitting, and subsumption. We prove some basic properties for closed SLD trees, namely that both computed answers and calls are preserved. We present a couple of simple strategies for constructing closed SLD trees with different levels of abstraction, together with some examples of its application. Finally, we illustrate the viability of our approach by introducing a test case generator based on exploring closed SLD trees.

Synthesis of list algorithms by mechanical proving

We address the automation of the processes of algorithm synthesis and systematic exploration of the theory of lists. Our focus is on methods, techniques, inference rules and strategies for computer based synthesis of list algorithms based on proving. Starting from the specification of the problem (input and output conditions), a synthesis statement is built: “for any list satisfying the input condition, there exists a list satisfying the output condition”. The main difficulty is to find a constructive proof of this statement, from which the corresponding algorithm is easily extracted as a set of conditional equalities.In more detail, we aim at computer automation of the proof of the existence of the sorted version of the input list. By using different proof methods we automatically synthesize five sorting algorithms: Selection-Sort, Insertion-Sort, Quick-Sort, Merge-Sort, and a novel algorithm, which we call Unbalanced-Merge-Sort, as well as the auxiliary functions used in the sorting algorithms. The theory we use is first order, and mostly contains formulae which are equivalent to Horn clauses. Therefore, except for induction, SLD resolution style inferences are in principle sufficient for performing the proofs. However, for most of the proofs this leads to a very large search space. Therefore we introduce several novel inference rules and specific strategies, which are based on the properties of lists, and which we developed in the course of this case study on sorting.Moreover, during the process of algorithm synthesis we explore the theory of lists by introducing (automatically prove, and then use) the necessary properties.When the knowledge base does not contain the auxiliary functions needed for the respective version of the algorithm, then the proof fails and from this failure a new proof goal is created, which is the synthesis statement for the missing auxiliary functions (“cascading”).

Linear-Logic Based Analysis of Constraint Handling Rules with Disjunction

Constraint Handling Rules (CHR) is a declarative rule-based programming language that has cut out its niche over the course of the last 20 years. It generalizes concurrent constraint logic programming to multiple heads, thus closing the gap to multiset transformation systems. Its popular extension CHR with Disjunction (CHR∨) is a multiparadigm declarative programming language that allows embedding of Horn programs with SLD resolution. We analyze the assets and the limitations of the classical declarative semantics of CHR∨ and highlight its natural relationship with linear-logic. We furthermore develop two linear-logic semantics for CHR∨ that differ in the reasoning domain for which they are instrumental. We show their idempotence and their soundness and completeness with respect to the operational semantics. We show how to apply the linear-logic semantics to decide program properties and to reason about operational equivalence of CHR∨ programs.

Batched evaluation of linear tabled logic programs

Logic Programming languages, such as Prolog, provide a highlevel, declarative approach to programming. Despite the power, flexibility and good performance that Prolog systems have achieved, some deficiencies in Prolog?s evaluation strategy - SLD resolution - limit the potential of the logic programming paradigm. Tabled evaluation is a recognized and powerful technique that overcomes SLD?s susceptibility in dealing with recursion and redundant sub-computations. In a tabled evaluation, there are several points where we may have to choose between different tabling operations. The decision on which operation to perform is determined by the scheduling algorithm. The two most successful tabling scheduling algorithms are local scheduling and batched scheduling. In previous work, we have developed a framework, on top of the Yap Prolog system, that supports the combination of different linear tabling strategies for local scheduling. In this work, we propose the extension of our framework to support batched scheduling. In particular, we are interested in the two most successful linear tabling strategies, the DRA and DRE strategies. To the best of our knowledge, no other Prolog system supports both strategies simultaneously for batched scheduling. Our experimental results show that the combination of the DRA and DRE strategies can effectively reduce the execution time for batched evaluation.

Design and implementation of a fuzzy logic programming language using weak unification

Bousi~Prolog is a fuzzy logic programming language with an operational semantics which is an adaptation of the SLD resolution principle, where classical unification has been replaced by a fuzzy unification algorithm based on fuzzy relations. Hence, it is a programming language well suited for dealing with vagueness and approximate reasoning. In this paper we summarize its design and implementation.

Bousi~Prolog: a Prolog Extension Language for Flexible Query Answering

Abstract In this paper we present the main features and implementation details of a programming language that we call Bousi~Prolog . It can be seen as an extension of Prolog able to deal with similarity-based fuzzy unification (“Bousi” is the Spanish acronym for “fuzzy unification by similarity”). The main goal is the implementation of a declarative programming language well suited for flexible query answering. The operational semantics of Bousi~Prolog is an adaptation of the SLD resolution principle where classical unification has been replaced by an algorithm based on similarity relations defined on a syntactic domain. A similarity relation is an extension of the standard notion of equivalence relation and it can be useful in any context where the concept of equality must be weakened. Hence, the syntax of Bousi~Prolog is an extension of the Prolog's language: in general, a Bousi~Prolog program is a set of Prolog clauses plus a set of similarity equations.

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.

Dynamic reordering of alternatives for definite logic programs

Due to their highly declarative nature and efficiency, tabled logic programming systems have been applied to solving many complex problems. Tabled logic programming is essential for extending traditional logic programming with tabled resolution. In this paper, we propose a new tabled resolution scheme, called dynamic reordering of alternatives (DRA) resolution, for definite logic programs. The scheme keeps track of the type of the subgoals during resolution; if the subgoal in the current resolvent is a variant of a former tabled subgoal, tabled answers are used to resolve the subgoal; otherwise, program clauses are used similar to SLD resolution. Program clauses leading to variant subgoals at runtime are dynamically reordered for further computation until the subgoals are completely evaluated. DRA resolution allows query evaluation to be performed in a depth-first, left-to-right traversal order similar to Prolog-typed SLD resolution, thus yielding a simple technique for incorporating tabled resolution in traditional logic programming systems. We show the correctness of DRA resolution.

A Logical Characterization of Forward and Backward Chaining in the Inverse Method

The inverse method is a generalization of resolution that can be applied to non-classical logics. We have recently shown how Andreoli's focusing strategy can be adapted for the inverse method in linear logic. In this paper we introduce the notion of focusing bias for atoms and show that it gives rise to forward and backward chaining, generalizing both hyperresolution (forward) and SLD resolution (backward) on the Horn fragment. A key feature of our characterization is the structural, rather than purely operational, explanation for forward and backward chaining. A search procedure like the inverse method is thus able to perform both operations as appropriate, even simultaneously. We also present experimental results and an evaluation of the practical benefits of biased atoms for a number of examples from different problem domains.

A three-valued semantics for logic programmers

This paper describes a simpler way for programmers to reason about the correctness of their code. The study of semantics of logic programs has shown strong links between the model theoretic semantics (truth and falsity of atoms in the programmer's interpretation of a program), procedural semantics (for example, SLD resolution) and fixpoint semantics (which is useful for program analysis and alternative execution mechanisms). Most of this work assumes that intended interpretations are two-valued: a ground atom is true (and should succeed according to the procedural semantics) or false (and should not succeed). In reality, intended interpretations are less precise. Programmers consider that some atoms “should not occur” or are “ill-typed” or “inadmissible”. Programmers don't know and don't care whether such atoms succeed. In this paper we propose a three-valued semantics for (essentially) pure Prolog programs with (ground) negation as failure which reflects this. The semantics of Fitting is similar but only associates the third truth value with non-termination. We provide tools to reason about correctness of programs without the need for unnatural precision or undue restrictions on programming style. As well as theoretical results, we provide a programmer-oriented synopsis. This work has come out of work on declarative debugging, where it has been recognised that inadmissible calls are important.

On applying or-parallelism and tabling to logic programs

Logic programming languages, such as Prolog, provide a high-level, declarative approach to programming. Logic Programming offers great potential for implicit parallelism, thus allowing parallel systems to often reduce a program's execution time without programmer intervention. We believe that for complex applications that take several hours, if not days, to return an answer, even limited speedups from parallel execution can directly translate to very significant productivity gains. It has been argued that Prolog's evaluation strategy – SLD resolution – often limits the potential of the logic programming paradigm. The past years have therefore seen widening efforts at increasing Prolog's declarativeness and expressiveness. Tabling has proved to be a viable technique to efficiently overcome SLD's susceptibility to infinite loops and redundant subcomputations. Our research demonstrates that implicit or-parallelism is a natural fit for logic programs with tabling. To substantiate this belief, we have designed and implemented an or-parallel tabling engine – OPTYap – and we used a shared-memory parallel machine to evaluate its performance. To the best of our knowledge, OPTYap is the first implementation of a parallel tabling engine for logic programming systems. OPTYap builds on Yap's efficient sequential Prolog engine. Its execution model is based on the SLG-WAM for tabling, and on the environment copying for or-parallelism. Preliminary results indicate that the mechanisms proposed to parallelize search in the context of SLD resolution can indeed be effectively and naturally generalized to parallelize tabled computations, and that the resulting systems can achieve good performance on shared-memory parallel machines. More importantly, it emphasizes our belief that through applying or-parallelism and tabling to logic programs the range of applications for Logic Programming can be increased.

Similarity-based SLD resolution and its role for web knowledge discovery

This work presents the implementation of an extension of SLD resolution towards approximate reasoning and its implementation in an extended Prolog system. The proposed refutation procedure overcomes failures in the unification process by exploiting similarity relations defined between predicate and constant symbols. This enables to compute approximate solutions, with an associated approximation degree, when failures of the exact inference process occur. In this paper we outline the main ideas of this approach and we present an extended PROLOG interpreter, named SiLog, which implements this inference procedure. Then we point out on a web-based platform, usable for knowledge discovery, that exploits as inner feature the similarity-based SLD resolution.

A fuzzy cognitive map approach to support urban design

Abstract This paper is concerned with proposing a fuzzy cognitive map (FCM) driven approach for implementing expert decision support in the area of urban design. Previous research activities modeled a knowledge-based system using first order predicate calculus. The current approach utilizes the inherent analogies between SLD resolution trees and FCMs and proposes the generation of multi-branch map hierarchies in order to model the disjointed conjuncts of the logic-based rules. This research proposes specific algorithms for interpreting the logic-based rules to FCMs as well as specific algorithms and formulas for calculating the values of multi-branch map hierarchies. Finally, this paper presents preliminary experiments and comments on the usefulness of the proposed methodology tool.

Approximate reasoning by similarity-based SLD resolution

In (Gerla and Sessa, Fuzzy Logic and Soft Computing, Kluwer, Norwell, 1999, pp. 19–31) a methodology that allows to manage uncertain and imprecise information in the frame of the declarative paradigm of Logic Programming has been proposed. With this aim, a Similarity relation R between function and predicate symbols in the language of a logic program is considered. Approximate inferences are then possible since similarity relation allows us to manage alternative instances of entities that can be considered “equal” with a given degree. The declarative semantics of the proposed transformation technique of logic programs is analyzed. The notion of fuzzy least Herbrand model is also introduced. In this paper the corresponding operational semantics is provided by introducing a modified version of SLD resolution. This top-down refutation procedure overcomes failure situations in the unification process by using the similarity relation. A generalized notion of most general unifier provides a numeric value which gives a measure of the exploited approximation. In this way, the SLD resolution is enhanced since it is possible both to handle uncertain or imprecise information, and to compute approximate answer substitutions, with an associated approximation-degree, when failures of the exact inference process occur. It can lead to the implementation of a more general PROLOG interpreter, without detracting from the elegance of the language.

Solving constraint optimization problems from CLP-style specifications using heuristic search techniques

Presents a framework for efficiently solving logic formulations of combinatorial optimization problems using heuristic search techniques. In order to integrate cost, lower-bound and upper-bound specifications with conventional logic programming languages, we augment a constraint logic programming (CLP) language with embedded constructs for specifying the cost function and with a few higher-order predicates for specifying the lower and upper bound functions. We illustrate how this simple extension vastly enhances the ease with which optimization problems involving combinations of Min and Max can be specified in the extended language CLP* and we show that CSLDNF (Constraint SLD resolution with Negation as Failure) resolution schemes are not efficient for solving optimization problems specified in this language. Therefore, we describe how any problem specified using CLP* can be converted into an implicit AND/OR graph, and present an algorithm called GenSolve which can branch-and-bound using upper and lower bound estimates, thus exploiting the full pruning power of heuristic search techniques. A technical analysis of GenSolve is provided. We also provide experimental results comparing various control strategies for solving CLP* programs.

A sound and complete procedure for a general logic program in non-floundering derivations with respect to the 3-valued stable model semantics

This paper presents a sound and complete procedure with respect to the 3-valued stable model semantics. The procedure is regarded as an extension of Eshghi and Kowalski abductive proof procedure, involving finite or countably infinite SLD resolution, as well as finite or countably infinite negative recursion caused by negation as failure. The procedure makes use of the set of negative literals (the set of abducibles) for the negation as failure to be implemented. The set of abducibles is not only applicable to the extraction of explanations for abduction as in Kakas et al. (J. Logic Comput. 2 (1992) 719–770) but also specified for what stable model is now computed in the procedure, because a 3-valued stable model is not always the least (that is, the well-founded model). The procedure also contains nondeterminism in the choices of what ground negative literals are used for negation as failure. By the assumptions of some adequate choices, the procedure is well-defined inductively.

Tabling for non-monotonic programming

Nondmonotonic extensions add power to logic programs. However, the main logic programming language, Prolog, is widely recognized as inadequate to implement these extensions due to its weak termination and complexity properties. By extending Prolog’s SLD resolution with tabling, Prolog can be improved in several ways. Tabling can allow a logic programming system to compute the welldfounded semantics for programs with bounded term depth, and to do so with polynomial data complexity. By exploiting these properties, tabling allows a variety of nondmonotonic extensions to be efficiently implemented, and used to solve practical problems. In this paper we describe tabling as it is implemented in the XSB system and show how it can be used to construct metadinterpreters (or preprocessors) for two sample formalisms: the WelldFounded Semantics with Explicit Negation, and Generalized Annotated Logic Programs. We also describe how nondmonotonic extensions are used in practical applications such as psychiatric diagnosis, extraction of information from poorly structured textual data, and model checking.