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.

Abstract This paper introduces techniques to integrate WordNet into a Fuzzy Logic Programming system. Since WordNet relates words but does not give graded information on the relation between them, we have implemented standard similarity measures and new directives allowing the proximity equations linking two words to be generated with an approximation degree. Proximity equations are the key syntactic structures which, in addition to a weak unification algorithm, make a flexible query-answering process possible in this kind of programming language. This addition widens the scope of Fuzzy Logic Programming, allowing certain forms of lexical reasoning, and reinforcing Natural Language Processing (NLP) applications.

Abstract This paper explores the integration of hypothetical reasoning into an efficient implementation of the fuzzy logic language Bousi∼Prolog. To this end, we first analyse what would be expected from a logic inference system, equipped with what is called embedded implication, to model solving goals with respect to assumptions. We start with a propositional system and incrementally build more complex systems and implementations to satisfy the requirements imposed by a system like Bousi∼Prolog. Finally, we propose an inference system, operational semantics and the translation function to generate efficient Prolog programmes from Bousi∼Prolog programmes.

This paper presents a system implementing a novel addition to a fuzzy deductive database: hypothetical queries. Such queries allow users to dynamically make assumptions on a given database instance, either by adding or removing data, without changing the instance. Further, since a fuzzy database includes fuzzy relations, these relations can also be changed with assumptions. This ability for dynamic change seamlessly enables writing "what-if" applications such as decision-support systems. Here, the new language Fuzzy Hypothetical Datalog is presented, along with an operational semantics and stratified inference. It has been implemented in a working system DES readily available on-line.

Abstract This paper proposes the use of Constraint Logic Programming (CLP) to model SQL queries in a data-independent abstract layer by focusing on some semantic properties for signalling possible errors in such queries. First, we define a translation from SQL to Datalog, and from Datalog to CLP, so that solving this CLP program will give information about inconsistency, tautology, and possible simplifications. We use different constraint domains which are mapped to SQL types, and propose them to cooperate for improving accuracy. Our approach leverages a deductive system that includes SQL and Datalog, and we present an implementation in this system which is currently being tested in classroom, showing its advantages and differences with respect to other approaches, as well as some performance data.

Unification is a central concept in deductive systems based on the resolution principle. Recently, we introduced a newweak unification algorithmbased on proximity relations (i.e., reflexive, symmetric, fuzzy binary relations). Proximity relations are able to manage vague or imprecise information and, in combination with the unification algorithm, allow certain forms of approximate reasoning in a logic programming framework. In this paper, we present a reformulation of the weak unification algorithm and an elaborated method to implement it efficiently.

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.

This article describes the implementation of the fuzzy deductive database system FuzzyDES, where concepts underlying the fuzzy logic programming system Bousi~Prolog are adapted and improved to be transferred to the DES deductive database system. We take advantage of the DES tabled-based implementation to propose new methods for rule compiling and t-closure computing, developing a terminating query answering system with graded rules. A description of the system, an example, and a link to a publicly-available, comprehensive system are provided.

This paper presents a proposal for debugging deductive database programs. Although inspired in the logic programming paradigm, these programs have the particularity of involving large sets of data. In this context, debugging tools employed usually in logic programs, such as traditional trace debuggers, become impractical. Our technique is based on the principles of algorithmic debugging but adapted to the particularities of the deductive database query language Datalog. The debugging process starts when the user detects an initial erroneous result. Then, the debugger asks questions about the validity/nonvalidity of some intermediate results until a bug is located. The debugger allows the user to report the existence of wrong or missing answers. This information is employed for simplifying the following questions using different forms of slicing. During the debugging process the information provided by the user or inferred by the debugger is stored in the form of constraints in a CHR program that combines all the data in order to detect the source of the error as soon as possible. The debugger has been implemented as part of the Datalog system DES.

Hypothetical Datalog is based on an intuitionistic semantics rather than a classical logic semantics, and allows embedded implications in rule bodies. While the usual implication (i.e., the neck of a Horn clause) stands for inferencing facts, an embedded implication plays the role of assuming its premise for deriving its consequence. Although this topic has received considerable attention along time and nowadays is gaining renewed interest, there has not been a tabled implementation of hypothetical Datalog. We present here such a proposal including the formal background and its application to a goal-oriented tabled setting with negation, where non-monotonicity due to negation and implication is handled via stratification and contexts. In addition, we implement it in the deductive system DES, also providing support to duplicates and integrity constraints in the hypothetical framework.

This work is aimed to show a concrete implementation of a deductive database system based on the scheme HH_(C) (Hereditary Harrop Formulas with Negation and Constraints) following a fixpoint semantics proposed in a previous work. We have developed a Prolog implementation for this scheme that is constraint system independent, therefore allowing to use it as a base for any instance of the formal scheme. We have developed several specific constraint systems: Real numbers, integers, Boolean and user-defined enumerated types. We have added types to the database so that relations become typed (as tables in relational databases) and each constraint is mapped to its corresponding constraint system. The predicates that compute the fixpoint giving the meaning to a database are described. In particular, we show the implementation of a forcing relation (for derivation steps) and highlight how the inherent difficulties have been overcome in a system allowing hypothetical queries, which make the database dynamically grow.

Abstract This paper presents a computational model for the cooperation of constraint domains and an implementation for a particular case of practical importance. The computational model supports declarative programming with lazy and possibly higher-order functions, predicates, and the cooperation of different constraint domains equipped with their respective solvers, relying on a so-called constraint functional logic programming (CFLP) scheme. The implementation has been developed on top of theCFLPsystem , supporting the cooperation of the three domains ℋ, ℛ, and ℱ , which supply equality and disequality constraints over symbolic terms, arithmetic constraints over the real numbers, and finite domain constraints over the integers, respectively. The computational model has been proved sound and complete w.r.t. the declarative semantics provided by theCFLPscheme, while the implemented system has been tested with a set of benchmarks and shown to behave quite efficiently in comparison to the closest related approach we are aware of.

This paper presents a computational model for the cooperation of constraint domains, based on a generic Constraint Functional Logic Programming (CFLP) Scheme and designed to support declarative programming with functions, predicates and the cooperation of different constraint domains equipped with their respective solvers. We have developed an implementation in the CFLP system TOY, supporting an instance of the scheme which enables the cooperation of symbolic Herbrand constraints, finite domain integer constraints, and real arithmetic constraints. We provide a theoretical result and an analysis of benchmarks showing a good performance with respect to the closest related approach we are aware of

Semantic relations are an important element in the construction of ontologies and models of problem domains. Nevertheless, they remain fuzzy or under-specified. This is a pervasive problem in software engineering and artificial intelligence. Thus, we find semantic links that can have multiple interpretations in wide-coverage ontologies, semantic data models with abstractions that are not enough to capture the relation richness of problem domains, and improperly structured taxonomies. However, if relations are provided with precise semantics, some of these problems can be avoided, and meaningful operations can be performed on them. In this paper we present some insightful issues about the modeling, representation and usage of relations including the available taxonomy structuring methodologies as well as the initiatives aiming to provide relations with precise semantics. Moreover, we explain and propose the control of relations as a key issue for the coherent construction of ontologies.

Abstract In this paper, we present our proposal to Constraint Functional Logic Programming over Finite Domains (CFLP( $\fd$ )) with a lazy functional logic programming language which seamlessly embodies finite domain ( $\fd$ ) constraints. This proposal increases the expressiveness and power of constraint logic programming over finite domains (CLP( $\fd$ )) by combining functional and relational notation, curried expressions, higher-order functions, patterns, partial applications, non-determinism, lazy evaluation, logical variables, types, domain variables, constraint composition, and finite domain constraints. We describe the syntax of the language, its type discipline, and its declarative and operational semantics. We also describe \toy(fd)$ , an implementation forCFLP( $\fd$ ), and a comparison of our approach with respect toCLP( $\fd$ ) from a programming point of view, showing the new features we introduce. And, finally, we show a performance analysis which demonstrates that our implementation is competitive with respect to existingCLP( $\fd$ ) systems and that clearly outperforms the closer approach toCFLP( $\fd$ ).

A novel approach for the integration of evolution programs and constraint-solving techniques over finite domains is presented. This integration provides a problem-independent optimization strategy for large-scale constrained optimization problems over finite domains. In this approach, genetic operators are based on an arc-consistency algorithm, and chromosomes are arc-consistent portions of the search space of the problem. The paper describes the main issues arising in this integration: chromosome representation and evaluation, selection and replacement strategies, and the design of genetic operators. We also present a parallel execution model for a distributed memory architecture of the previous integration. We have adopted a global parallelization approach that preserves the properties, behavior, and fundamentals of the sequential algorithm. Linear speedup is achieved since genetic operators are coarse grained as they perform a search in a discrete space carrying out arc consistency. The implementation has been tested on a GRAY T3E multiprocessor using a complex constrained optimization problem.