General Logic Programs Research Articles

Partial Instantiation Methods for Inference in First-Order Logic

Satisfiability algorithms for propositional logic have improved enormously in recently years. This improvement increases the attractiveness of satisfiability methods for first-order logic that reduce the problem to a series of ground-level satisfiability problems. R. Jeroslow introduced a partial instantiation method of this kind that differs radically from the standard resolution-based methods. This paper lays the theoretical groundwork for an extension of his method that is general enough and efficient enough for general logic programming with indefinite clauses. In particular we improve Jeroslow's approach by (1) extending it to logic with functions, (2) accelerating it through the use of satisfiers, as introduced by Gallo and Rago, and (3) simplifying it to obtain further speedup. We provide a similar development for a “dual” partial instantiation approach defined by Hooker and suggest a primal–dual strategy. We prove correctness of the primal and dual algorithms for full first-order logic with functions, as well as termination on unsatisfiable formulas. We also report some preliminary computational results.

SLT-Resolution for the Well-Founded Semantics

Global SLS-resolution and SLG-resolution are two representative mechanisms for top-down evaluation of the well-founded semantics of general logic programs. Global SLS-resolution is linear for query evaluation but suffers from infinite loops and redundant computations. In contrast, SLG-resolution resolves infinite loops and redundant computations by means of tabling, but it is not linear. The principal disadvantage of a nonlinear approach is that it cannot be implemented by using a simple, efficient stack-based memory structure nor can it be easily extended to handle some strictly sequential operators such as cuts in Prolog. In this paper, we present a linear tabling method, called i>SLT-resolution, for top-down evaluation of the well-founded semantics. SLT-resolution is a substantial extension of SLDNF-resolution with tabling. Its main features are the following. First, it resolves infinite loops and redundant computations while preserving the linearity. Second, it is terminating and is sound and complete w.r.t. the well-founded semantics for programs with the bounded-term-size property with nonfloundering queries. Its time complexity is comparable with SLG-resolution and polynomial for function-free logic programs. Third, because of its linearity for query evaluation, SLT-resolution bridges the gap between the well-founded semantics and standard Prolog implementation techniques. It can be implemented by an extension to any existing Prolog abstract machines such as WAM or ATOAM.

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.

Complexity and expressive power of logic programming

This article surveys various complexity and expressiveness results on different forms of logic programming. The main focus is on decidable forms of logic programming, in particular, propositional logic programming and datalog, but we also mention general logic programming with function symbols. Next to classical results on plain logic programming (pure Horn clause programs), more recent results on various important extensions of logic programming are surveyed. These include logic programming with different forms of negation, disjunctive logic programming, logic programming with equality, and constraint logic programming.

Maximal state independent approximations to minimal real change

This paper is devoted to the problem of consistency enforcement for logical databases. The enforcement methods we propose compute the minimal real change in a given DB state, which is sufficient to accomplish the input update and preserve the integrity constraints (IC). For IC expressed in the form of a generalized logic program, this problem is proven to be hard. Meanwhile, we show that it is solvable in linear time under partial interpretations. We propose a method of computing DB state independent correct expansions of the input update and simultaneous optimization of IC with respect to this expansion. We show that under partial interpretations, optimal pairs (greatest correct update expansion/simplest equivalent IC) always exist and can be incrementally computed in square time. This partial solution being correct with respect to the total interpretations, we use it as an approximation in the total case. Moreover, for the class of IC without negation in clause bodies, we prove that this approximation constitutes the optimal pair (greatest correct update expansion/simplest equivalent IC).

Dynamic updates of non-monotonic knowledge bases

In this paper we investigate updates of knowledge bases represented by logic programs. In order to represent negative information, we use generalized logic programs which allow default negation not only in rule bodies but also in their heads. We start by introducing the notion of an update P⊕U of one logic program P by another logic program U. Subsequently, we provide a precise semantic characterization of P⊕U, and study some basic properties of program updates. In particular, we show that our update programs generalize the notion of interpretation update. We then extend this notion to compositional sequences of logic programs updates P 1⊕P 2⊕⋯, defining a dynamic program update, and thereby introducing the paradigm of dynamic logic programming. This paradigm significantly facilitates modularization of logic programming, and thus modularization of non-monotonic reasoning as a whole. Specifically, suppose that we are given a set of logic program modules, each describing a different state of our knowledge of the world. Different states may represent different time points or different sets of priorities or perhaps even different viewpoints. Consequently, program modules may contain mutually contradictory as well as overlapping information. The role of the dynamic program update is to employ the mutual relationships existing between different modules to precisely determine, at any given module composition stage, the declarative as well as the procedural semantics of the combined program resulting from the modules.

Some aspects of the comparative analysis of legal knowledge bases

One of the tasks in the process of preparing new legislation is the comparative analysis of different versions of the legislation. In this article we propose how the analysis could be partly automated if the legi­slation is formalized and stored in a knowledge base. The algorithm is proposed to find differences between legislations by using certain test situations. The algorithm is based on derivation by model generation and it is grounded in the case when the knowledge bases are general logic programs.

Embedding prioritized circumscription in disjunctive logic programs

In this paper, we present a method for embedding prioritized circumscription of a clausal theory into general disjunctive logic programs (GDP) with negation as failure in the head. In recent works, Sakama and Inoue show that parallel circumscription can be embedded in GDP. They also show that prioritized circumscription of a clausal theory can be represented in the framework of GDP extended with priorities. Wang et al. recently have also shown that prioritized circumscription can be expressed in their priority logic by applying monotonic inference rules constrained by a priority relation among the rules. In our method, the priorities of minimization in the circumscription policy are translated into the syntactical form of logic program rules, and the models of the circumscription are precisely captured by the stable models of the program. Thus we show that prioritized circumscription can be directly embedded in GDP without extending the GDP logic programming framework. This result further asserts the expressive power of the class of general disjunctive programs and supports its use for knowledge representation in Artificial Intelligence. The results of this paper also lead to embeddings of prioritized circumscription into the MBNF logic of Lifschitz and AE logic of Moore.

Stable generated models, partial temporal logic and disjunctive defaults

Stable generated models for extended generalized logic programs with two kinds of negation provide a semantics for logic programming in its (up to now) most general form. We show that stable generated semantics for extended logic programs coincides with the semantics obtained by translating programs into a minimal partial temporal logic. Then we introduce several new versions of (disjunctive) default logic and show that there are strong (semantical) connections between default logic and logic programming with stable generated models.

Compiling defeasible inheritance networks to general logic programs

We present a method of compiling arbitrary defeasible (inheritance) networks to general logic programs. We show a one-to-one correspondence between the credulous extensions of a defeasible network and the stable models of the translated logic program. This result leads to the discovery that an elegant query answering procedure for Horty's credulous extensions had long existed: the abductive proof procedure formulated by Eshghi and Kowalski for general logic programs is sound and complete for acyclic defeasible networks under the proposed translation. Since the translation is faithful to the commonly accepted notion of specificity, it leads to a novel transformational approach: any semantics defined for general logic programs yields an extension semantics for networks, and any query answering procedure developed for general logic programs can be used to answer queries for networks under the same semantics. This approach also yields new insights into the difficulties confronting path-based formalisms. Essentially, reasoning with logic programs overcomes the difficulty with path-based formalisms in dealing with the interactions of cascaded effects of link sequences, possibly compounded by preemption of paths. This difficulty has been particularly evident in the past in trying to understand the meaning of the networks that involve cycles, both semantically and proof-theoretically, and in the “directly skeptical” approach to defeasible inheritance.

Programming by combining general logic programs

The program composition approach can be fruitfully applied to combine general logic programs, i.e. logic programs possibly containing negative premises. We show how the introduction of a basic set of (meta-level) composition operations over general programs increases the knowledge representation capabilities of logic programming for non-monotonic reasoning. Examples of modular programming, hierarchical reasoning, constraints and rules with exceptions will be illustrated. The semantics of programs and program compositions is defined in terms of three-valued logic. The computational interpretation of program compositions is formalised by an equivalence preserving syntactic transformation of arbitrary program compositions into standard general programs.

A semantics for modular general logic programs

Modular programs are built as a combination of separate modules, which may be developed and verified separately. Therefore, in order to reason over such programs, compositionality plays a crucial role: the semantics of the whole program must be obtainable as a simple function from the semantics of its individual modules. In the field of logic programming, the need for a compositional semantics has been long recognized, however, while for definite (i.e. negationfree) logic programs a few such semantics have been proposed, in the literature of normal logic programs (programs which employ the negation operator), compositionality has received scarce attention. This is mainly due to the fact that normal programs typically have a nonmonotonic behavior, which is difficult to fit in a compositional framework. Here we propose a declarative compositional semantics for general logic programs. First, a compositional semantics for first-order modules is presented and proved correct wrt the set of logical consequences of the module in three-valued logic. In a second stage, the obtained results are applied to modular normal logic programs, obtaining a semantics which is correct with respect to the set of logical consequences of the completion of the program and — in contrast with the other approaches — which is always computable. This semantics might be regarded as a compositional counterpart of Kunen's semantics. Finally we discuss and show how these results have to be modified in order to be applied to normal constraint logic programs.

Expanding queries to incomplete databases by interpolating general logic programs

In databases, queries are usually defined on complete databases. In this paper we introduce and motivate the notion of extended queries that are defined on incomplete databases. We argue that the language of extended logic program is appropriate for representing extended queries. We show through examples that given a query, a particular extension of it has important characteristics which corresponds to removal of the CWA from the original specification of the query. We refer to this particular extension as the expansion of the original query. Normally queries are expressed as general logic programs. We develop an algorithm that given a general logic program (satisfying certain syntactic properties) expressing a query constructs an extended logic program that expresses the expanded query. The extended logic program is referred to as the interpolation of the given general logic program.

A logical foundation for logic programming II: Semantics of general logic programs

We suggested in Part I of this study a general logical formalism for Logic Programming based on a four-valued inference. In this paper we give a uniform representation of various semantics for logic programs based on this formalism. The main conclusion from this representation is that the distinction between these semantics can be largely attributed to the difference in their underlying (monotonic) logical systems. Moreover, in most cases the difference can even be reduced to that of the language, that is, to the difference in the logical connectives allowed for representing derivable information.

Characterizations of the Disjunctive Well-Founded Semantics: Confluent Calculi and Iterated GCWA

Recently Brass and Dix introduced the semantics D-WFS for general disjunctive logic programs. The interesting feature of this approach is that it is both semantically and proof-theoretically founded. Semantically, D-WFS is invariant under some natural declarative principles. Proof-theoretically, any program Φ is associated a normalform Φ, called the residual program, by a nontrivial bottom-up construction using least fixpoints of two monotonic operators. We show in this paper that the original calculus, consisting of some simple transformations, has a very strong and appealing property: it is confluent and terminating. This means that all the transformations can be applied in any order: whenever we arrive at an irreducible program (no more transformation is applicable), this program is already uniquely determined and coincides with the normalform res(Φ) Moreover, for fair sequences it is also strongly terminating: every fair sequence of transformations leads to normalform res(Φ). Another feature of our approach is that D-WFS can be read off from res(Φ) immediately in a very simple way. No proper subset of the calculus has these properties – only when we restrict to certain subclasses of programs. We also give an equivalent characterization of D-WFS in terms of iterated minimal model reasoning with respect to positive programs. This construction is a generalization of a description of the well-founded semantics: we introduce a very simple and neat construction of a sequence D_i that eventually stops and represents the set of derivable disjunctions. Both characterizations open the way for efficient implementations. The first does so because the ordering of the transformations does not matter: we are free to choose always the “best” transformation, which maximally reduces the program. The second does so because special methods from circumscription, in particular a sophisticated minimal model reasoner for positive programs, might be useful.

Stable models are generated by a stable chain

We propose a general preference criterion selecting the “intended” models of generalized logic programs which: 1) is a conservative extension of the stable model semantics for normal logic programs of [2], 2) is very close to the answer set semantics of [4] for disjunctive logic programs, and 3) allows for arbitrary formulas in the body and in the head of a rule, i.e., does not depend on the presence of any specific connective, such as negation(-as-failure) or on any specific syntax of rules. Our preference criterion defines a model of a program as intended if it is generated by a stable chain. We show that stable models and answer sets are generated by a stable chain of length ≤ ω.

Négation constructive et axiomatique interne

We propose in this work a mathematical aspect of Constructive Negation for constraint general logic programs. We can then obtain a completion theorem (soundness and completeness) with internal axiomatization of general program, in the classical logic deduction frame: the bivalued models.

Three-valued completion for abductive logic programs

In this paper, we propose a three-valued completion semantics for abductive logic programs, which solves some problems associated with the Console et al. two-valued completion semantics. The semantics is a generalization of Kunen's completion semantics for general logic programs, which is known to correspond very well to a class of effective proof procedures for general logic programs. Secondly, we propose a proof procedure for abductive logic programs, which is a generalization of a proof procedure for general logic programs based on constructive negation. This proof procedure is sound and complete with respect to the proposed semantics. By generalizing a number of results on general logic programs to the class of abductive logic programs, we present further evidence for the idea that limited forms of abduction can be added quite naturally to general logic programs.

ON THE PARALLEL COMPLEXITY OF ACYCLIC LOGIC PROGRAMS

In this paper we investigate the parallel complexity of computing the stable model of acyclic general logic programs. Within this class of logic programs, we consider the cases of negative and definite logic programs. Both cases are proved to be [Formula: see text]-complete. We prove the same for a related problem, namely that of computing the kernel of a directed acyclic graph.

SLDNF resolution with non-safe rule and fixpoint semantics for general logic programs

The SLDNF resolution ( SLD resolution with negation as failure) is often restricted to yield a safe rule, that is, negation as failure rule is adopted only in the case that the selected negative literal in each goal should be in ground. In this paper we investigate extensions of goals in SLDNF resolutions with the case of selecting non-ground negative literals. Since Shepherdson's proposal is thought of as most general [16, 18] we formally show how the success and failure sets by Sherpherdson's SLDNFS resolution are related with a fixpoint semantics, which is generalized to be concerned with atom sets involving the variables.