Multi-adjoint Logic Programming Research Articles

Fuzzy logic programs as hypergraphs. Termination results

Graph theory has been a useful tool for logic programming in many aspects. In this paper, we propose an equivalent representation of multi-adjoint logic programs using hypergraphs, which are a generalization of classical graphs that allows the use of hypergraph theory in logic programming. Specifically, this representation has been considered in this paper to increase the level and flexibility of different termination results of the computation of the least model of fuzzy logic programs via the immediate consequence operator. Consequently, the least model of more general and versatile fuzzy logic programs can be obtained after finitely many iterations, although infinite programs or programs with loops and general aggregators will be considered.

Extended multi-adjoint logic programming

Extended multi-adjoint logic programming arises as an extension of multi-adjoint normal logic programming where constraints and a special type of aggregator operator have been included. The use of this general aggregator operator permits to consider, for example, different negation operators in the body of the rules of a logic program. We have introduced the syntax and the semantics of this new paradigm, as well as an interesting mechanism for obtaining a multi-adjoint normal logic program from an extended multi-adjoint logic program. This mechanism will allow us to establish technical properties relating the different stable models of both logic programming frameworks. Moreover, it makes possible that the already developed and future theory associated with stable models of multi-adjoint normal logic programs can be applied to extended multi-adjoint logic programs.

Syntax and semantics of multi-adjoint normal logic programming

Multi-adjoint logic programming is a general framework with interesting features, which involves other positive logic programming frameworks such as monotonic and residuated logic programming, generalized annotated logic programs, fuzzy logic programming and possibilistic logic programming. One of the most interesting extensions of this framework is the possibility of considering a negation operator in the logic programs, which will improve its flexibility and the range of real applications. This paper introduces multi-adjoint normal logic programming, which is an extension of multi-adjoint logic programming including a negation operator in the underlying lattice. Beside the introduction of the syntax and semantics of this paradigm, we will provide sufficient conditions for the existence of stable models defined on a convex compact set of an euclidean space. Finally, we will consider a particular algebraic structure in which sufficient conditions can be given in order to ensure the unicity of stable models of multi-adjoint normal logic programs.

Multi-adjoint Relation Equations: A Decision Support System for Fuzzy Logic

Fuzzy relation equations (FRE) are an important decision support system (DSS), for example, in fuzzy logic. FRE have recently been extended to a more general framework, called multiadjoint relation equations (MARE). This paper shows MARE as a fundamental DSS in multi-adjoint logic programming. For that purpose, multi-adjoint logic programs will be interpreted as a MARE, and the solvability of them will be given in terms of concept lattice theory. Furthermore, two approximations (optimistic and pessimistic approximations) of unsolvable equations will be obtained from a multiadjoint object-oriented concept lattice. Finally, a real-life example will be studied.

On reductants in the framework of multi-adjoint logic programming

Reductants are a special kind of fuzzy rules which constitute an essential theoretical tool for proving correctness properties. As it has been reported, when interpreted on a partially ordered structure, a multi-adjoint logic program has to include all its reductants in order to preserve the approximate completeness property. After a short survey of the different notions of reductant that have been developed for multi-adjoint logic programs, we introduce a new and more adequate notion of reductant in the multi-adjoint framework. We study some of its properties and its relationships with other notions of reductants, and provide an algorithm for computing all the reductants associated with a multi-adjoint logic program.

A Fuzzy Logic Programming Environment for Managing Similarity and Truth Degrees

FASILL (acronym of "Fuzzy Aggregators and Similarity Into a Logic Language") is a fuzzy logic programming language with implicit/explicit truth degree annotations, a great variety of connectives and unification by similarity. FASILL integrates and extends features coming from MALP (Multi-Adjoint Logic Programming, a fuzzy logic language with explicitly annotated rules) and Bousi~Prolog (which uses a weak unification algorithm and is well suited for flexible query answering). Hence, it properly manages similarity and truth degrees in a single framework combining the expressive benefits of both languages. This paper presents the main features and implementations details of FASILL. Along the paper we describe its syntax and operational semantics and we give clues of the implementation of the lattice module and the similarity module, two of the main building blocks of the new programming environment which enriches the FLOPER system developed in our research group.

Beyond multi-adjoint logic programming

In ‘multi-adjoint logic programming’, MALP in brief, each fuzzy logic program is associated with its own ‘multi-adjoint lattice’ for modelling truth degrees beyond the simpler case of true and false, where a large set of fuzzy connectives can be defined. On this wide repertoire, it is crucial to connect each implication symbol with a proper conjunction thus conforming constructs of the form (←i, &i) called ‘adjoint pairs’, whose use directly affects both declarative and operational semantics of the MALP framework. In this work, we firstly show how the strong dependence of adjoint pairs can be largely weakened for an interesting ‘sub-class’ of MALP programs. Then, we reason in a similar way till conceiving a ‘super-class’ of fuzzy logic programs beyond MALP, which definitively drops out the need for using adjoint pairs, since the new semantics behaviour relies on much more relaxed lattices than multi-adjoint ones.

Fuzzy Logic Programming in Action with <i>FLOPER</i>

During the last years, we have developed the FLOPER platform for providing a practical support to the so-called Multi-Adjoint Logic Programming approach (MALP in brief), which represents an extremely flexible framework into the Fuzzy Logic Programming arena. Nowadays, FLOPER is useful for compiling (to standard Prolog code), executing and debugging (by drawing execution trees) MALP programs, and it is ready for being extended in the near future with powerful transformation and optimization techniques designed in our research group during the recent past. Our last update consists in the integration of a graphical interface for a comfortable interaction with the system which allows, among other capabilities, the use of projects for packing scripts and auxiliary definitions of fuzzy sets/connectives, together with fuzzy programs and their associated lattices modeling truth-degrees beyond the simpler crisp case ﹛true;false﹜.

Dedekind–MacNeille completion and Cartesian product of multi-adjoint lattices

Fuzzy logic programming tries to introduce fuzzy logic into logic programming in order to provide new generation computer languages which incorporate comfortable programming resources for helping the development of applications where uncertainty could play an important role. In this sense, the mathematical concept of multi-adjoint lattice has been successfully exploited into the so-called Multi-Adjoint Logic Programming approach, MALP in brief, for modelling flexible notions of truth-degrees beyond the simpler case of true and false. In this paper, we focus on two relevant mathematical concepts for this kind of domains useful for evaluating MALP. On the one side, we adapt the classical notion of Dedekind–MacNeille completion in order to relax some usual hypothesis on such kind of ordered sets, and next we study the advantages of generating multi-adjoint lattices as the Cartesian product of previous ones. On the practical side, we show that the formal mechanisms described before have direct correspondences with interesting debugging tasks into the ‘Fuzzy Logic Programming Environment for Research’, FLOPER in brief, developed in our research group.

A comparative study of adjoint triples

Adjoint triples are helpful as basic operators used in several domains. For example, adjoint triples play an important role in two important frameworks: multi-adjoint logic programming and multi-adjoint concept lattices. This paper shows that adjoint triples are an interesting generalization of t-norms and their residuated implications, since they preserve their main properties as well as they help to increase the flexibility of the operators used for computation in the considered framework. Furthermore, these operators will be related to other important general triples, specifically implication triples, and the definition of these latter operators will be improved.

Thresholded Tabulation in a Fuzzy Logic Setting

Fuzzy logic programming represents a flexible and powerful declarative paradigm amalgamating fuzzy logic and logic programming, for which there exists different promising approaches described in the literature. In this paper we propose an improved fuzzy query answering procedure for the so called multi-adjoint logic programming approach, which avoids the re-evaluation of goals and the generation of useless computations thanks to the combined use of tabulation with thresholding techniques. The general idea is that, when trying to perform a computation step by using a given program rule R, we firstly analyze if such step might contribute to reach further significant solutions (non tabulated yet). When it is the case, it is possible to avoid a useless computation step via a rule R by using thresholds and filters based on the truth degree of R, as well as a safe, accurate and dynamic estimation of the maximum truth degree associated to its body.

Optimizing Fuzzy Logic Programs by Unfolding, Aggregation and Folding

Multi-adjoint logic programming represents a very recent, extremely flexible attempt for introducing fuzzy logic into logic programming. Inspired by our previous experiences in the field of (declarative) program transformation, in this paper we propose the development of a fold/unfold based transformation system for optimizing such kind of fuzzy logic programs. The starting point is a set of unfolding-based transformations together with a reversible kind of fuzzy folding, that we have designed in the past. The present work substantially improves this last transformation operation by allowing the possibility of using rules belonging to different programs in a transformation sequence when performing a folding step, which is crucial to obtain better, recursive and elegant definitions of fuzzy predicates. In contrast with other declarative paradigms, in the fuzzy setting it is mandatory to pack sets of fuzzy predicates in tuples, if we really want the folding operation to proceed. This implies the need for re-defining the classical “definition introduction” transformation rule and introducing a completely new operation, that we call “aggregation”, which is especially tailored for the new framework. Finally, we illustrate how the effects of appropriately applying our set of transformation rules (definition introduction, aggregation, folding, unfolding and facting) to a given program, are able to improve the execution of goals against transformed programs.

An improved reductant calculus using fuzzy partial evaluation techniques

Partial evaluation (PE) is an automatic program transformation technique aiming to obtain, among other advantages, the optimization of a program with respect to parts of its input: hence, it is also known as program specialization. This paper introduces the subject of PE into the field of fuzzy logic programming. We define the concept of PE for multi-adjoint logic programs and goals, and apart from discussing the benefits achieved by this technique, we also introduce in the fuzzy setting a completely novel application of PE which allows us the computation of reductants guaranteeing completeness properties without harming the computational efficiency. Reductants are a special kind of fuzzy rules which constitute an essential theoretical tool for proving correctness properties. As observed in the specialized literature, a multi-adjoint logic program, when interpreted on a partially ordered lattice, has to include all its reductants in order to preserve the (approximate) completeness property. This introduces severe penalties in the implementation of efficient multi-adjoint logic programming systems: not only the size of programs increases but also their execution time. In this paper we define a refinement to the notion of reductant based on PE techniques, that we call PE- reductant. We establish the main properties of PE-reductants (i.e., the classical concept of reductant and the new notion of PE-reductant are both, semantically and operationally, equivalent) and, what is the best, we demonstrate that our refined notion of PE-reductant is even able to increase the efficiency of multi-adjoint logic programs.

Efficient Reductants Calculi using Partial Evaluation Techniques with Thresholding

Reductants are a useful theoretical tool introduced for proving correctness properties in the context of generalized annotated logic programming. This concept was adapted to the more recent and flexible framework of multi-adjoint logic programming for solving a problem of incompleteness that arises when working with some lattices. In order to be complete, multi-adjoint logic programs must be extended with their set of reductants. In general, the notion of reductant may introduce an important efficiency drawback. In this work we provide a more refined version of this concept that we call PE-reductant, by using (threshold) partial evaluation techniques. Our proposal is intended to be semantically equivalent to the classical notion of reductant, and improves previous approaches at least in the following two efficiency criteria. Firstly, using the new definition of reductant, we can obtain computed answers for a given goal with a lesser computational effort than by using its precedent ones. Secondly, the proper construction of a reductant by means of partial evaluation methods, is drastically improved after introducing thresholding techniques which dynamically reduce the size of the underlying unfolding trees.

Operational/Interpretive Unfolding of Multi-adjoint Logic Programs

Operational/Interpretive Unfolding of Multi-adjoint Logic Programs

Termination of logic programs with imperfect information: applications and query procedure

A general logic programming framework allowing for the combination of several adjoint lattices of truth-values is presented. The language is sorted, enabling the combination of several reasoning forms in the same knowledge base. The contribution of the paper is two-fold: on the one hand, sufficient conditions guaranteeing termination of all queries for the fix-point semantics for a wide class of sorted multi-adjoint logic programs are presented and related to some well-known probability-based formalisms; in addition, we specify a general non-deterministic tabulation goal-oriented query procedure for sorted multi-adjoint logic programs over complete lattices. We prove its soundness and completeness as well as independence of the selection ordering. We apply the termination results to probabilistic and fuzzy logic programming languages, enabling the use of the tabulation proof procedure for query answering.

On fuzzy unfolding: A multi-adjoint approach

In the context of (fuzzy) logic programs, ‘unfolding’ means to transform a program rule by replacing an atom call of the body (of that rule) by its definition. Unfolding is a semantics-preserving program transformation technique that is able to improve programs, generating more efficient code, since it anticipates computation steps. Unfolding is the basis for developing sophisticated and powerful programming tools, such as fold/unfold transformation systems or partial evaluators. In this paper we address the problem of extending the classical definition of the unfolding rule (for pure logic programs) to the setting of multi-adjoint logic programming, where a fuzzy computed answer is a pair 〈 truth degree ; substitution 〉 computed by a fuzzy generalization of the modus ponens inference rule. Our main contributions can be summarized as follows: • We proved the independence of the computation rule for multi-adjoint admissible computations. • Moreover, we defined a fuzzy unfolding rule and we demonstrated its strong correctness properties, that is, original and unfolded programs compute the same fuzzy computed answers for a given goal. • We also proved that unfolding transformations increase the efficiency of the residual programs, by reducing the length of fuzzy admissible derivations when solving goals.

A neural implementation of multi-adjoint logic programming

A neural net based implementation of propositional [0,1]-valued multi-adjoint logic programming is presented, which is an extension of earlier work on representing logic programs in neural networks carried out in [A.S. d'Avila Garcez et al., Neural-Symbolic Learning Systems: Foundations and Applications, Springer, 2002; S. Hölldobler et al., Appl. Intelligence 11 (1) (1999) 45–58]. Proofs of preservation of semantics are given, this makes the extension to be well-founded. The implementation needs some preprocessing of the initial program to transform it into a homogeneous program; then, transformation rules carry programs into neural networks, where truth-values of rules relate to output of neurons, truth-values of facts represent input, and network functions are determined by a set of general operators; the net outputs the values of propositional variables under its minimal model.

Similarity-based unification: a multi-adjoint approach

The aim of this paper is to build a formal model for similarity-based fuzzy unification in multi-adjoint logic programs. Specifically, a general framework of logic programming which allows the simultaneous use of different implications in the rules and rather general connectives in the bodies is introduced, then a procedural semantics for this framework is presented, and an approximative-completeness theorem proved. On this computational model, a similarity-based unification approach is constructed by simply adding axioms of fuzzy similarities and using classical crisp unification which provides a semantic framework for logic programming with different notions of similarity.

A Multi-Adjoint Approach to Similarity-Based Unification

A formal model for similarity-based fuzzy unification in multi-adjoint logic programs is presented. On this computational model, a similarity-based unification approach is constructed by simply adding axioms of fuzzy similarities and using classical crisp unification which provides a semantic framework for logic programming with different notions of similarity.