Javier Álvez

Constructive negation by bottom-up computation of literal answers

In this paper, we present a new proposal for an efficient implementation of constructive negation. In our approach the answers for a literal are bottom-up computed by solving equality constraints, instead of by handling frontiers of subsidiary computation trees. The required equality constraints are given by Shepherdsons operators which are, in a sense, similar to bottom-up immediate consequence operators. However, in order to make the procedure efficient two main techniques are applied. First, we restrict our constraints to a class of success-answers (resp. fail-answers) which are easy to manipulate and to solve (or to prove their unsatisfiability). And, second, we take advantage of the monotonic nature of Shepherdsons operators to make the procedure incremental and to avoid recalculations that are typical in frontiers-based methods. Then, goal computation is made in the usual top-down CLP scheme of collecting the answers for the selected literal into the constraint of the goal. The procedural mechanism for constructive negation is designed not only to generate every correct answer of a goal, but also to detect failure. That is, in spite of the bottom-up nature of the calculation of literal answers, goal computation is not necessarily infinite. The operational semantics that makes use of these ideas, called BCN, is sound and complete with respect to three-valued program completion for the whole class of normal logic programs. A prototype implementation of this approach has been developed and the experimental results are very promising.

Elimination of Local Variables from Definite Logic Programs

In logic programming, a variable is said to be local if it occurs in a clause body but not in its head atom. It is well-known that local variables are the main cause of inefficiency (sometimes even incompleteness) in negative goal computation. The problem is twofold. First, the negation of a clause body that contains a local variables is not expressible without universal quantification, whereas the abscence of local variables guarantees that universal quantification can be avoided to compute negation. Second, computation of universal quantification is an intrinsically difficult task. In this paper, we introduce an effective method that takes a definite logic program and transforms it into a local variable free (definite) program. Source and target programs are equivalent w.r.t. three-valued logical consequences of program completion. In further work, we plan to extend our results to normal logic programs.

Equational constraint solving via a restricted form of universal quantification

In this paper, we present a syntactic method for solving first-order equational constraints over term algebras. The presented method exploits a novel notion of quasi-solved form that we call answer. By allowing a restricted form of universal quantification, answers provide a more compact way to represent solutions than the purely existential solved forms found in the literature. Answers have been carefully designed to make satisfiability test feasible and also to allow for boolean operations, while maintaining expressiveness and user-friendliness. We present detailed algorithms for (1) satisfiability checking and for performing the boolean operations of (2) negation of one answer and (3) conjunction of nanswers. Based on these three basic operations, our solver turns any equational constraint into a disjunction of answers. We have implemented a prototype that is available on the web.

Evaluating the Competency of a First-Order Ontology

We report on the results of evaluating the competency of a first-order ontology for its use with automated theorem provers (ATPs). The evaluation follows the adaptation of the methodology based on competency questions (CQs) [4] to the framework of first-order logic, which is presented in [2], and is applied to Adimen-SUMO [1]. The set of CQs used for this evaluation has been automatically generated from a small set of semantic patterns and the mapping of WordNet to SUMO. Analysing the results, we can conclude that it is feasible to use ATPs for working with Adimen-SUMO v2.4, enabling the resolution of goals by means of performing non-trivial inferences.

A generalization of the folding rule for the Clark-Kunen semantics

In this paper, we propose more flexible applicability conditions for the folding rule that increase the power of existing unfold/fold systems for normal logic programs. Our generalized folding rule enables new transformation sequences that, in particular, are suitable for recursion introduction and local variable elimination. We provide some illustrative examples and give a detailed proof of correctness w.r.t. the Clark-Kunen semantics.

A New Proposal Of Quasi-Solved Form For Equality Constraint Solving

Most well-known algorithms for equational solving are based on quantifier elimination. This technique iteratively eliminates the innermost block of existential/universal quantifiers from prenex formulas whose matrices are in some normal form (mostly DNF). Traditionally used notions of normal form satisfy that every constraint (in normal form) different from false is trivially satisfiable. Hence, they are called solved forms. However, the manipulation of such constraints require hard transformations, especially due to the use of the distributive and the explosion rules, which increase the number of constraints at intermediate stages of the solving process. On the contrary, quasi-solved forms allow for simpler transformations by means of a more compact representation of solutions, but their satisfiability test is not so trivial. Nevertheless, the total cost of checking satisfiability and manipulating constrains using quasi-solved forms is cheaper than using simpler solved forms. Therefore, they are suitable for improving the efficiency of constraint solving procedures. In this paper, we present a notion of quasi-solved form that provides a good trade-off between the cost of checking satisfiability and the effort required to manipulate constraints. In particular, our new quasi-solved form has been carefully designed for efficiently handling conjunction and negation, which are the main Boolean operations necessary to keep matrices of formulas in normal form.

An algorithm for local variable elimination in normal logic programs

A variable is local if it occurs in a clause body but not in its head. Local variables appear naturally in practical logic programming, but they complicate several aspects such as negation, compilation, memoization, static analysis, program approximation by neural networks etc. As a consequence, the absence of local variables yields better performance of several tools and is a prerequisite for many technical results. In this paper, we introduce an algorithm that eliminates local variables from a wide proper subclass of normal logic programs. The proposed transformation preserves the Clark-Kunen semantics for normal logic programs.