Characterizations of stable model semantics for logic programs with arbitrary constraint atoms

We show that stable models of logic programs may be viewed as minimal models of programs that satisfy certain additional constraints. To do so, we transform the normal programs into disjunctive logic programs and sets of integrity constraints. We show that the stable models of the normal program coincide with the minimal models of the disjunctive program thatsatisfy the integrity constraints. As a consequence, the stable model semantics can be characterized using theextended generalized closed world assumption for disjunctive logic programs. Using this result, we develop a bottomup algorithm for function-free logic programs to find all stable models of a normal program by computing the perfect models of a disjunctive stratified logic program and checking them for consistency with the integrity constraints. The integrity constraints provide a rationale as to why some normal logic programs have no stable models.

We establish a novel relation between delete-free planning, an important task for the AI Planning community also known as relaxed planning, and logic programming. We show that given a planning problem, all subsets of actions that could be ordered to produce relaxed plans for the problem can be bijectively captured with stable models of a logic program describing the corresponding relaxed planning problem. We also consider the supported model semantics of logic programs, and introduce one causal and one diagnostic encoding of the relaxed planning problem as logic programs, both capturing relaxed plans with their supported models. Our experimental results show that these new encodings can provide major performance gain when computing optimal relaxed plans.

We present a model for deductive object oriented query languages with inheritance and overriding. In this model, we consider a DAG like dynamic isa hierarchy and we account for both value or attribute inheritance and method inheritance or code sharing. We show that these two types of inheritance can be treated uniformly within an elegant declarative setting. We then propose a novel semantics for the non-monotonic behavior resulting from the combination of overriding, dynamic selfbinding and the dynamic structure of the isa hierarchy. This semantics is reminiscent of the stable model semantics of logic programs with negation. We also isolate a syntactic condition that guarantees the existence of a unique stable model for a program. This condition, in its turn, is inspired by the local stratification condition of perfect model semantics for programs with negation. Finally we define a bottom-up procedure that computes the unique stable model of a stratified program.KeywordsLogic ProgramLogic ProgrammingStable ModelUnit ClauseStable Model SemanticThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

M. Bezem defined an extensional semantics for positive higher-order logic programs. Recently, it was demonstrated by Rondogiannis and Symeonidou that Bezem's technique can be extended to higher-order logic programs with negation, retaining its extensional properties, provided that it is interpreted under a logic with an infinite number of truth values. Rondogiannis and Symeonidou also demonstrated that Bezem's technique, when extended under the stable model semantics, does not in general lead to extensional stable models. In this paper, we consider the problem of extending Bezem's technique under the well-founded semantics. We demonstrate that the well-founded extensionfailsto retain extensionality in the general case. On the positive side, we demonstrate that for stratified higher-order logic programs, extensionality is indeed achieved. We analyze the reasons of the failure of extensionality in the general case, arguing that a three-valued setting cannot distinguish between certain predicates that appear to have a different behaviour inside a program context, but which happen to be identical as three-valued relations.

Over recent years, various semantics have been proposed for dealing with updates in the setting of logic programs. The availability of different semantics naturally raises the question of which are most adequate to model updates. A systematic approach to face this question is to identify general principles against which such semantics could be evaluated. In this paper we motivate and introduce a new such principle – the refined extension principle – which is complied with by the stable model semantics for (single) logic programs. It turns out that none of the existing semantics for logic program updates, even though based on stable models, complies with this principle. For this reason, we define a refinement of the dynamic stable model semantics for Dynamic Logic Programs that complies with the principle.

Each stable model of a logic program is computed in isolation. This does not allow one to reason in any stable model with information from other stable models. Such information interchange is needed when computing with full introspection, as performed by Gelfond's epistemic specifications, or when modeling multi-agent reasoning using stable models. In this paper, we define syntactic and semantic structures that allow the use of information from multiple stable models when computing one stable model. Hence a notion of second order stability is introduced and every computed model should be stable at that level. We define a concept of trans-epistemic (te-) logic programs that is reduced to a logic program using information from a trans-epistemic interpretation. The te-interpretation is checked for stability against the set of stable models of the logic program using a consensus function. We discus the properties of trans-epistemic stable models and motivate their use with examples.

We propose C4, a four-valued semantics for normal, logic programs. Using this semantics, we define two types of entailment: strong and weak. We show that a normal, logic program strongly entails a sentence under C4 if, and only if, the program entails that sentence under the well founded semantics and it weakly entails a sentence if, and only if, the program entails that sentence under the two-valued stable model semantics in case the program has any stable models. We argue that this shows that the difference between the well founded semantics and the stable model semantics can be characterized in terms of their attitude to what we call contested information. We use this insight to propose a general theory of contested reasoning.

Hybrid MKNF knowledge bases are one of the most prominent tightly integrated combinations of open-world ontology languages with closed-world (nonmonotonic) rule paradigms. Based on the logic of minimal knowledge and negation as failure (MKNF), the definition of Hybrid MKNF is parametric on the description logic (DL) underlying the ontology language, in the sense that nonmonotonic rules can extend any decidable DL language. Two related semantics have been defined for Hybrid MKNF: one that is based on the Stable Model Semantics for logic programs and one on the Well-Founded Semantics (WFS). Under WFS, the definition of Hybrid MKNF relies on a bottom-up computation that has polynomial data complexity whenever the DL language is tractable. Here we define a general query-driven procedure for Hybrid MKNF that is sound with respect to the stable model-based semantics, and sound and complete with respect to its WFS variant. This procedure is able to answer a slightly restricted form of conjunctive queries, and is based on tabled rule evaluation extended with an external oracle that captures reasoning within the ontology. Such an (abstract) oracle receives as input a query along with knowledge already derived, and replies with a (possibly empty) set of atoms, defined in the rules, whose truth would suffice to prove the initial query. With appropriate assumptions on the complexity of the abstract oracle, the general procedure maintains the data complexity of the WFS for Hybrid MKNF knowledge bases. To illustrate this approach, we provide a concrete oracle for EL + , a fragment of the lightweight DL EL ++ . Such an oracle has practical use, as EL ++ is the language underlying OWL 2 EL, which is part of the W3C recommendations for the Semantic Web, and is tractable for reasoning tasks such as subsumption. We show that query-driven Hybrid MKNF preserves polynomial data complexity when using the EL + oracle and WFS.

This paper extends fuzzy logic programs [12, 24] to allow the explicit representation of classical negation as well as non-monotonic negation, by introducing the notion of extended fuzzy logic programs. We present the fuzzy answer set semantics for the extended fuzzy logic programs, which is based on the classical answer set semantics of classical extended logic programs [7]. We show that the proposed semantics is a natural extension to the classical answer set semantics of classical extended logic programs [7]. Furthermore, we define fixpoint semantics for extended fuzzy logic programs with and without non-monotonic negation, and study their relationship to the fuzzy answer set semantics. In addition, we show that the fuzzy answer set semantics is reduced to the stable fuzzy model semantics for normal fuzzy logic programs introduced in [42]. The importance of that is computational methods developed for normal fuzzy logic programs can be applied to the extended fuzzy logic programs. Moreover, we show that extended fuzzy logic programs can be intuitively used for representing and reasoning about actions in fuzzy environment.

Although negative conclusions are presented implicitly in Normal Hybrid Probabilistic Programs (NHPP) [26] through the closed world assumption, representing and reasoning with explicit negation is needed in NHPP to allow the ability to reason with incomplete knowledge. In this paper we extend the language of NHPP to explicitly encode classical negation in addition to non-monotonic negation. The semantics of the extended language is based on the answer set semantics of traditional logic programming [9]. We show that the proposed semantics is a natural extension to the answer set semantics of traditional logic programming [9]. In addition, the proposed semantics is reduced to stable probabilistic model semantics of NHPP [26]. The importance of that is computational methods developed for NHPP can be applied to the proposed language. Furthermore, we show that some commonsense probabilistic knowledge can be easily represented in the proposed language.KeywordsLogic ProgramLogic ProgrammingClassical NegationIncomplete KnowledgeProbability IntervalThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

It is well known that, under certain conditions, it is possible to split logic programs under stable model semantics, i.e. to divide such a program into a number of different levels, such that the models of the entire program can be constructed by incrementally constructing models for each level. Similar results exist for other non-monotonic formalisms, such as auto-epistemic logic and default logic. In this work, we present a general, algebraic splitting theory for programs/theories under a fixpoint semantics. Together with the framework of approximation theory, a general fixpoint theory for arbitrary operators, this gives us a uniform and powerful way of deriving splitting results for each logic with a fixpoint semantics. We demonstrate the usefulness of these results, by generalizing Lifschitz and Turner's splitting theorem to other semantics for (non-disjunctive) logic programs.

Logic programming has developed as a rich field, built over a logical substratum whose main constituent is a nonclassical form of negation, sometimes coexisting with classical negation. The field has seen the advent of a number of alternative semantics, with Kripke–Kleene semantics, the well-founded semantics, the stable model semantics, and the answer-set semantics standing out as the most successful. We show that all aforementioned semantics are particular cases of a generic semantics, in a framework where classical negation is the unique form of negation and where the literals in the bodies of the rules can be ‘marked’ to indicate that they can be the targets of hypotheses. A particular semantics then amounts to choosing a particular marking scheme and choosing a particular set of hypotheses. When a literal belongs to the chosen set of hypotheses, all marked occurrences of that literal in the body of a rule are assumed to be true, whereas the occurrences of that literal that have not been marked in the body of the rule are to be derived in order to contribute to the firing of the rule. Hence the notion of hypothetical reasoning that is presented in this framework is not based on making global assumptions, but more subtly on making local, contextual assumptions, taking effect as indicated by the chosen marking scheme on the basis of the chosen set of hypotheses. Our approach offers a unified view on the various semantics proposed in logic programming, classical in that only classical negation is used, and links the semantics of logic programs to mechanisms that endow rule-based systems with the power to harness hypothetical reasoning.

In terms of the arithmetic hierarchy, the complexity of the set of minimal models and of the set of stable models of a propositional general logic program has previously been described. However, not every set of interpretations of this level of complexity is obtained as such a set. In this paper we identify the sets of interpretations which are minimal or stable model classes by their properties in an appropriate topology on the space of interpretations. Closely connected with the topological characterization, in parallel with results previously known for stable model classes we obtain for minimal model classes both a normal-form representation as the set of minimal models of a prerequisite-free program and a logical description in terms of formulas. Our approach centers on the relation which we establish between stable and minimal model classes. We include examples of calculations which can be performed by these methods. Let P be a propositional general logic program over a finite or countably infinite set U of atoms. Recall that an interpretation for P is a subset of U. By a model of P we mean an interpretation S c_ U which is closed under Te; by a minimal model of P we mean a model S of P such that no proper subset S' ~ S is a model of P; and by a stable model of P we mean a set S _C U such that S = least fixpoint of T~Ls(t,), where GLs(P) is the Gelfond-Lifschit z transform of program P with respect to S defined in [3]. Let Mod(P), Min(P), and Stab(P) denote, respectively, the set of models, minimal models, and stable models of P. For a given program P, we see that these classes are related by

Bottom-up computation of perfect models for disjunctive theories

A decision problem is called parameterized if its input is a pair of strings. One of these strings is referred to as a parameter . The following problem is an example of a parameterized decision problem with k serving as a parameter: given a propositional logic program P and a nonnegative integer k , decide whether P has a stable model of size no more than k . Parameterized problems that are NP-complete often become solvable in polynomial time if the parameter is fixed. The problem to decide whether a program P has a stable model of size no more than k , where k is fixed and not a part of input, can be solved in time O ( mn k ), where m is the size of P and n is the number of atoms in P . Thus, this problem is in the class P. However, algorithms with the running time given by a polynomial of order k are not satisfactory even for relatively small values of k .The key question then is whether significantly better algorithms (with the degree of the polynomial not dependent on k ) exist. To tackle it, we use the framework of fixed-parameter complexity. We establish the fixed-parameter complexity for several parameterized decision problems involving models, supported models, and stable models of logic programs. We also establish the fixed-parameter complexity for variants of these problems resulting from restricting attention to definite Horn programs and to purely negative programs. Most of the problems considered in the paper have high fixed-parameter complexity. Thus, it is unlikely that fixing bounds on models (supported models, stable models) will lead to fast algorithms to decide the existence of such models.