Answer Substitutions Research Articles

Proof-relevant Horn Clauses for Dependent Type Inference and Term Synthesis

AbstractFirst-order resolution has been used for type inference for many years, including in Hindley-Milner type inference, type-classes, and constrained data types. Dependent types are a new trend in functional languages. In this paper, we show that proof-relevant first-order resolution can play an important role in automating type inference and term synthesis for dependently typed languages. We propose a calculus that translates type inference and term synthesis problems in a dependently typed language to a logic program and a goal in the proof-relevant first-order Horn clause logic. The computed answer substitution and proof term then provide a solution to the given type inference and term synthesis problem. We prove the decidability and soundness of our method.

Making abstract domains condensing

In this article, we show that reversible analyses of logic languages by abstract interpretation can be performed without loss of precision by systematically refining abstract domains. This is obtained by adding to the abstract domain the minimal amount of concrete semantic information so that this refined abstract domain becomes rich enough to allow goal-driven and goal-independent analyses agree. These domains are known as condensing abstract domains. Essentially, an abstract domain A is condensing when the goal-driven analysis performed on A for a program P and a given query can be retrieved with no loss of precision from the goal-independent analysis on A of P . We show that condensation is an abstract domain property and that the problem of making an abstract domain condensing boils down to the problem of making the corresponding abstract interpretation complete, in a weakened form, with respect to unification. In the case of abstract domains for logic program analysis approximating computed answer substitutions, we provide a clean logical characterization of condensing domains as fragments of propositional linear logic. We apply our methodology to the systematic design of condensing domains for freeness and independence analysis.

Rules + strategies for transforming lazy functional logic programs

This work introduces a transformation methodology for functional logic programs based on needed narrowing, the optimal and complete operational principle for modern declarative languages which integrate the best features of functional and logic programming. We provide correctness results for the transformation system w.r.t. the set of computed values and answer substitutions and show that the prominent properties of needed narrowing—namely, the optimality w.r.t. the length of derivations and the number of computed solutions—carry over to the transformation process and the transformed programs. We illustrate the power of the system by taking on in our setting two well-known transformation strategies ( composition and tupling). We also provide an implementation of the transformation system which, by means of some experimental results, highlights the potentiality of our approach.

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.

Resolution for Skeptical Stable Model Semantics

An extension of resolution for skeptical stable model semantics is introduced. Unlike previous approaches, our calculus is not derived from credulous inference and enjoys a number of properties that are not satisfied by current nonmonotonic reasoning systems. Skeptical resolution is top down, in general, and goal directed on call-consistent programs. It does not need the given program to be instantiated before reasoning. It may compute nonground answer substitutions efficiently. It is compatible with different implementations of negation as failure. Some inferences, which depend on nonground negative goals, can be drawn without resorting to negation-as-failure; as a consequence, many goals that flounder in the standard setting have a successful skeptical derivation. The paper contains a preliminary study of some interesting derivation strategies and a sketch of a prototype implementation of the calculus.

Data integration using similarity joins and a word-based information representation language

The integration of distributed, heterogeneous databases, such as those available on the World Wide Web, poses many problems. Herer we consider the problem of integrating data from sources that lack common object identifiers. A solution to this problem is proposed for databases that contain informal, natural-language “names” for objects; most Web-based databases satisfy this requirement, since they usually present their information to the end-user through a veneer of text. We describe WHIRL, a “soft” database management system which supports “similarity joins,” based on certain robust, general-purpose similarity metrics for text. This enables fragments of text (e.g., informal names of objects) to be used as keys. WHIRL includes textual objects as a built-in type, similarity reasoning as a built-in predicate, and answers every query with a list of answer substitutions that are ranked according to an overall score. Experiments show that WHIRL is much faster than naive inference methods, even for short queries, and efficient on typical queries to real-world databases with tens of thousands of tuples. Inferences made by WHIRL are also surprisingly accurate, equaling the accuracy of hand-coded normalization routines on one benchmark problem, and outerperforming exact matching with a plausible global domain on a second.

Justifying control for logic programs

A pure prolog program (with goal) consists of a definite clause part P and an expression G where P essentially assigns recursive definitions to predicate names and G is evaluated with respect to that assignment. This can be described using a term calculus for defining predicators p:πn and goal expressions g:o. Predicate names can be bound using recursion operators, and programs correspond to expressions without free predicate names. Evaluation of a goal expression g(ξ) with free program variables ξ enumerates a stream of answer substitutions {τ/ξ}.The denotational semantics of this language is employed to show limits of the expressiveness: While pure prolog is computationally complete in the sense that for every partial recursive function there is a closed predicator p so that [p](n,y) = [{f(n)/y}] (here n and f(n) stand for representations of numbers and [α] is a singleton stream), the set of definable functionals λP [[πn]. [t(p)]ϕ[p<-P] is extremely small. It is shown that even simple functionals as λP.λt.[P(t)(1)] (if defined otherwise ⊥), λP.λt.[P(t)(2)],… (i.e. ‘pick the first, second,… answer") are not definable. While ‘pick the first’ is usually obtained by adding the control construct once or cut or if-then-else to pure prolog, this does not in general account for ‘pick the n-th’.In full prolog, where imperative features are available, the situation changes. The classical prolog control, however, like cut etc. prove valuable as well as insufficient.

Efficient access mechanisms for tabled logic programs

The use of tabling in logic programming allows bottom-up evaluation to be incorporated in a top-down framework, combining advantages of both. At the engine level, tabling also introduces issues not present in pure top-down evaluation, due to the need for subgoals and answers to access tables during resolution. This article describes the design, implementation, and experimental evaluation of data structures and algorithms for high-performance table access. Our approach uses tries as the basis for tables. Tries, a variant of discrimination nets, provide complete discrimination for terms, and permit a lookup and possible insertion to be performed in a single pass through a term. In addition, a novel technique of substitution factoring is proposed. When substitution factoring is used, the access cost for answers is proportional to the size of the answer substitution, rather than to the size of the answer itself. Answer tries can be implemented both as interpreted structures and as compiled WAM-like code. When they are compiled, the speed of computing substitutions through answer tries is competitive with the speed of unit facts compiled or asserted as WAM code. Because answer tries can also be created an order of magnitude more quickly than asserted code, they form a promising alternative for representing certain types of dynamic code, even in Prolog systems without tabling.

On goal-directed provability in classical logic

One of the key features of logic programming is the notion of goal-directed provability. In intuitionistic logic, the notion of uniform proof has been used as a proof-theoretic characterization of this property. Whilst the connections between intuitionistic logic and computation are well known, there is no reason per se why a similar notion cannot be given in classical logic. In this paper we show that there are two notions of goal-directed proof in classical logic, both of which are suitably weaker than that for intuitionistic logic. We show the completeness of this class of proofs for certain fragments, which thus form logic programming languages. As there are more possible variations on the notion of goal-directed provability in classical logic, there is a greater diversity of classical logic programming languages than intuitionistic ones. In particular, we show how logic programs may contain disjunctions in this setting. This provides a proof-theoretic basis for disjunctive logic programs, as well as characterising the “disjunctive” nature of answer substitutions for such programs in terms of the provability properties of the classical connectives Λ and Λ.

A Correct Logic Programming Computation of Default Logic Extensions

We present a method of representing some classes of default theories as normal logic programs. The main point is that the standart semantics (i.e., SLDNF-resolution) computes answer substitutions that correspond exactly to the extensions of the represented default theory. This means that we give a correct implementation of default logic. We explain the steps of constructing a logic program LogProg({\rm P},{\rm D}) from a given default theory ({\rm P},{\rm D}), give some examples, and derive soundness and completeness results.

A closer look at declarative interpretations

Three semantics have been proposed as the most promising candidates for a declarative interpretation for logic programs and pure Prolog programs: the least Herbrand model, the least term model, i.e., the C -semantics, and the I -semantics. Previous results show that a strictly increasing information ordering between these semantics exists for the class of all programs. In particular, the I -semantics allows us to model the computed answer substitutions, which is not the case for the other two. We study here the relationship between these three semantics for specific classes of programs. We show that for a large class of programs (which is Turing complete), these three semantics are isomorphic. As a consequence, given a query, we can extract from the least Herbrand model of a program in this class all computed answer substitutions. However, for specific programs the least Herbrand model is tedious to construct and reason about because it contains “ill-typed” facts. Therefore, we propose a fourth semantics that associates with a “correctly typed” program the “well-typed” subset of its least Herbrand model. This semantics is used to reason about partial correctness and absence of failures of correctly typed programs. The results are extended to programs with arithmetic.

On computability by logic programs

The problem of computational completeness of Horn clause logic programs is revisited. The standard results on representability of all computable predicates by Horn clause logic programs are not related to the real universe on which logic programs operate. SLD-resolution, which is the main mechanism to execute logic programs, may give answer substitutions with variables. As the main result we prove that computability by Horn clause logic programs is equivalent to standard computability over the Herbrand universe with variables. The semantics we use isS-semantics introduced by Falaschi et al. [3]. As an application of the main result we prove the existence of a metainterpreter for a sublanguage of real Prolog, written in the language of Horn clauses with the S-semantics. We also show that the traditional semantics of Prolog do not reflect its computational behavior from the viewpoint of recursion theory.

What is failure? An approach to constructive negation

A standard approach to negation in logic programming is negation as failure. Its major drawback is that it cannot produce answer substitutions to negated queries. Approaches to overcoming this limitation are termed constructive negation. This work proposes an approach based on construction offailed trees for some instances of a negated query. For this purpose a generalization of the standard notion of a failed tree is needed. We show that a straightforward generalization leads to unsoundness and present a correct one.

LOGIC PROGRAMMING AND DEFAULT LOGIC

We present several ideas of increasing complexity how to translate default theories to normal logic programs that make direct use of the deductive capacity of logic programming. We show the limitations of simple, ad hoc approaches, and arrive at a more general construction; its main property is that the answer substitutions computed by the logic program via its standard operational semantics correspond exactly to the extensions of the default theory.

The s-semantics approach: Theory and applications

This paper is a general overview of an approach to the semantics of logic programs whose aim is to find notions of models which really capture the operational semantics, and are, therefore, useful for defining program equivalences and for semantics-based program analysis. The approach leads to the introduction of extended interpretations which are more expressive than Herbrand interpretations. The semantics in terms of extended interpretations can be obtained as a result of both an operational (top-down) and a fixpoint (bottom-up) construction. It can also be characterized from the model-theoretic viewpoint, by defining a set of extended models which contains standard Herbrand models. We discuss the original construction modeling computed answer substitutions, its compositional version, and various semantics modeling more concrete observables. We then show how the approach can be applied to several extensions of positive logic programs. We finally consider some applications, mainly in the area of semantics-based program transformation and analysis.

Computing definite logic programs by partial instantiation

Query processing in ground definite deductive is known to correspond precisely to a linear programming problem. However, the “groundedness” requirement is a huge drawback to using linear programming techniques for logic program computations because the ground version of a logic program can be very large when compared to the original program. Furthermore, when we move from propositional logic programs to first-order logic programs, this effectively means that functions symbols may not occur in clauses. In this paper, we develop a theory of “instantiate- by-need” that performs instantiations (not necessarily ground instantiations) only when needed. We prove that this method is sound and complete when computing answer substitutions for non-ground logic programs including those containing function symbols. More importantly, when taken in conjunction with Colmerauer's result that unification can be viewed as linear programming, this means that resolution with unification can be completely replaced by linear programming as an operational paradigm. Additionally, our tree construction method is not rigidly tied to the linear programming paradigm-we will show that given any method M (which some implementors may prefer) that can compute the set of atomic logical consequences of a propositional logic program, our method can use M to compute (in a sense made precise in the paper), the set of all (not necessarily ground) atoms that are consequences of a first-order logic program.

Bottom-up abstract interpretation of logic programs

This paper presents a formal framework for the bottom-up abstract interpretation of logic programs which can be applied to approximate answer substitutions, partial answer substitutions and call patterns for a given program and arbitrary initial goal. The framework is based on a T p -like semantics defined over a Herbrand universe with variables which has previously been shown to determine the answer substitutions for arbitrary initial goals. The first part of the paper reconstructs this semantics to provide a more adequate initial goals. The first part of the paper reconstructs this semantics to provide a more adequate basis for abstract interpretation. A notion of abstract substitution is introduced and shown to determine an abstract semantic function which for a given program can be applied to approximate the answer substitutions for an arbitrary initial goal. The second part of the paper extends the bottom-up approach to provide approximations of both partial answer substitutions and call patterns. This is achieved by applying Magic Sets and other existing techniques to transform a program in such a way that the answer substitutions of the transformed program correspond to the partial answer substitutions and call patterns of the original program. This facilitates the analysis of concurrent logic programs (ignoring synchronization) and provides a collecting semantics which characterizes both success and call patterns.

A compositional semantics for logic programs

This paper considers open logic programs originally as a tool to build an OR-compositional semantics of logic programs. We extend the original semantic definitions in the framework of the general approach to the semantics of logic programs described by Gabbrielli and Levi (1991). We first define an operational semantics O Ω(P) which models computed answer substitutions and which is compositional w.r.t. the union of programs. Next, we consider the semantic domain of Ω- denotations, which are sets of clauses with a suitable equivalence relation. The fixpoint semantics F Ω(P) given by Bossi and Menegus (1991) is proved equivalent to the operational semantics. From the model-theoretic viewpoint, an Ω-denotation is mapped onto a set of Herbrand interpretations, thus leading to a definition of an Ω-model based on the classical notion of truth. Moreover, we consider a particular kind of Ω-models (compositional models), and we show that O Ω(P) is a (nonminimal) compositional Ω-model. A suitable abstraction of O Ω(P) is compositional and fully abstract w.r.t. the equivalence induced by successful derivations. Finally, some applications of our semantics are discussed. In particular, O Ω(P) can be viewed as the foundations of modular program analysis.

Proof methods of declarative properties of definite programs

In this paper we shall consider proof methods for declarative properties of definite programs, i.e. properties holding at the proof-tree roots. It is called the partial correctness of a logic program with respect to a specification. A specification consists of a logical formula associated with each predicate and establishing a relation between its arguments. A definite program is partially correct iff all possible answer substitutions satisfy the specification. This paper generalizes known results in logic programming in three ways: (i) it considers any kind of specification and any kind of domains of interpretation (in particular non-ground-extended Herbrand bases); (ii) its results can be applied to extensions of logic programming such as functions or constraints; (iii) a new proof method (the annotations method) is presented. It gives a unified framework for different kinds of known proof methods like the consequence verification method, the structural induction in definite clauses or the inductive proof of formulas. Two proof methods are presented and proved to be sound and complete. The first is adapted from attribute grammar to logic programming. It defines a specification stronger than the original one, which, furthermore, is inductive. Many aspects of the inductive specification method are investigated. The second method is a refinement of the first one: with every predicate, one associates a finite set of formulas (we call this an annotation), together with implications between formulas. The proofs become more modular and tractable, but the user has to verify the consistency of his proof, which is a decidable property. This method is particularly suitable for proving the validity of specifications which are not inductive. It has the same power as the first method, but it is designed to prove properties holding inside the proof trees.

Finite representation of infinite query answers

We define here a formal notion of finite representation of infinite query answers in logic programs. We apply this notion to Datalog nS programs may be infinite and consequently queries may have infinite answers. We present a method to finitely represent infinite least Herbrand models of Datalog nS program (and its underlying computational engine) can be forgotten. Given a query to be evaluated, it is easy to obtain from the relational specification finitely many answer substitutions that represent infinitely many answer substitutions to the query. The method involved is a combination of a simple, unificationless, computational mechanism (graph traversal, congruence closure, or term rewriting) and standard relational query evaluation methods. Second, a relational specification is effectively computable and its computation is no harder, in the sense of the complexity class, than answering yes-no queries. Our method is applicable to every range-restricted Datalog nS program. We also show that for some very simple non-Datalog nS logic programs, finite representations of query answers do not exist.