Well Founded Semantics for Logic Program Updates

2000

Over the last years various semantics have been proposed for dealing with updates in the setting of logic programs. The availability of dierent semantics naturally raises the question of which are the most adequate to model updates. A systematic approach to face this question is to identify general principles against which such semantics should be tested. In this paper we

2005

This paper introduces an original 2-valued semantics for Normal Logic Programs (NLP), which conservatively extends the Stable Model semantics (SM) to all normal programs. The distinction consists in the revision of one feature of SM, namely its treatment of odd loops, and of infinitely long support chains, over default negation. This single revised aspect, addressed by means of a Reductio ad Absurdum approach, affords a number of fruitful consequences, namely regarding existence, relevance and top-down querying, cumulativity, and implementation. The paper motivates and defines the Revised Stable Models semantics (rSM), justifying and exemplifying it. Properties of rSM are given and contrasted with those of SM. Furthermore, these results apply to SM whenever odd loops and infinitely long chains over negation are absent, thereby establishing significant, not previously known, properties of SM. Conclusions, further work, terminate the paper.

2004

Abstract This paper introduces an original 2-valued semantics for Normal Logic Programs (NLP), important on its own. Nevertheless, its name draws attention to that it is inspired by and generalizes Stable Model semantics (SM). The definitional distinction consists in the revision of one feature of SM, namely its treatment of odd loops over default negation.

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 Phi U of a logic program P by another logic program U . Subsequently, we provide a precise semantic characterization of P PhiU , 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 P1 Phi P2 Phi : : : , 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, e...

1991

Recently, the well-founded semantics of a logic program P has been strengthened to the well-founded semantics-by-case (WF C ) and then again to the extended well-founded semantics (WF E ). An important concept used in both WF C and WF E is that of derived rules. We extend the notion of derived rules by adding a new type of derivation and define the strong semantics of P, which has the following important property, known as the GCWA-property: if an atom p = false in all minimal models of P, then p = false in the strong semantics of P. In general, the WF C -semantics and the WF E -semantics do not have the GCWA-property. If we first apply the WF E -semantics to P and then apply the strong semantics to a suitably simplified form of P based on its WF E -semantics, then the resulting semantics is stronger than the WF E -semantics and has the GCWA-property.

2006

Abstract. A formalism called partial equilibrium logic (PEL) has recently been proposed as a logical foundation for the well-founded semantics (WFS) of logic programs. In PEL one defines a class of minimal models, called partial equilibrium models, in a non-classical logic, HT2. On logic programs partial equilibrium models coincide with Przymusinski's partial stable (p-stable) models, so that PEL can be seen as a way to extend WFS and p-stable semantics to arbitrary propositional theories.

1995

This paper proposes an update language, called ULL, for knowledge systems based on logic programming. This language is built upon two basic update operators, respectively denoting insertion and deletion of a positive literal (atom). Thus, simple control structures are defined for combining the basic updates into programs capable of expressing complex updates. The semantics of the update language is centered around the idea of executing a basic update by directly modifying the truth valuation of that (intensionally or extensionally defined) atom which is the object of the update. This modification propagates recursively to the truth valuations of those atoms dependent upon the updated one. The expressive power of this language is discussed, its implementation is studied, and an interpreter is given, which is proven correct w.r.t, the defined formal semantics. The computational complexity of the proposed implementation is also analyzed, showing that the update language interpreter runs efficiently. Finally, three extensions to ULL are discussed. The first allows the programmer to insert and delete rules, the second supports a form of hypothetical reasoning about updates, and the last introduces facilities in the language for the definition and the calling of update procedures. <1

International Journal of Advanced Computer Science and Applications, 2012

In this paper, we present a general schema for defining new update semantics. This schema takes as input any basic logic programming semantics, such as the stable semantics, the p-stable semantics or the M M r semantics, and gives as output a new update semantics. The schema proposed is based on a concept called minimal generalized S models, where S is any of the logic programming semantics. Each update semantics is associated to an update operator. We also present some properties of these update operators.

Studia Logica, 2005

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. Such principle 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 generalisations of the stable model semantics, comply 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.

1999

Most of the work conducted so far in the field of logic programming has focused on representing static knowledge, i.e. knowledge that does not evolve with time. To overcome this limitation, in a recent paper, the authors introduced the concept of dynamic logic programming. There, they studied and defined the declarative and operational semantics of sequences of logic programs (or dynamic logic programs), P0 ⊕...⊕Pn. Each such program contains knowledge about some given state, where different states may, e.g., represent different time periods or different sets of priorities. The role of dynamic logic programming is to employ relationships existing between the possibly mutually contradictory sequence of programs to precisely determine, at any given state, the declarative and procedural semantics of their combination. But how, in concrete situations, is a sequence of logic programs built? For instance, in the domain of actions, what are the appropriate sequences of programs that represent the performed actions and their effects? Whereas dynamic logic programming provides a way for determining what should follow, given the sequence of programs, it does not provide a good practical language for the specification of updates or changes in the knowledge represented by successive logic programs. In this paper we define a language designed for specifying changes to logic programs (LUPS - “Language for dynamic updates”). Given an initial knowledge base (in the form of a logic program) LUPS provides a way for sequentially updating it. The declarative meaning of a sequence of sets of update actions in LUPS is defined using the semantics of the dynamic logic program generated by those actions. We also provide a translation of the sequence of update statements sets into a single generalized logic program written in a meta-language, so that the stable models of the resulting program correspond to the previously defined declarative semantics. This meta-language is used in the actual implementation, although his is not the subject of this paper. Finally we briefly mention related work (lack of space prevents us from presenting more detailed comparisons).