Evolving logic programs

Computational Logic: Logic Programming and Beyond, 2002

In this work we review and synthesize, in a selective way, a series of recent developments concerning the dynamics of the evolution of logic programs by means of updates. We do so because this comparatively new and expanding area merits the attention of more researchers and more teachers alike, though there does not exist a single integrative source to induct them to the topic.

ACM Transactions on Computational Logic, 2005

Recently, several approaches to updating knowledge bases modeled as extended logic programs have been introduced, ranging from basic methods to incorporate (sequences of) sets of rules into a logic program, to more elaborate methods which use an update policy for specifying how updates must be incorporated. In this paper, we introduce a framework for reasoning about evolving knowledge bases, which are represented as extended logic programs and maintained by an update policy. We first describe a formal model which captures various update approaches, and we define a logical language for expressing properties of evolving knowledge bases. We then investigate semantical and computational properties of our framework, where we focus on properties of knowledge states with respect to the canonical reasoning task of whether a given formula holds on a given evolving knowledge base. In particular, we present finitary characterizations of the evolution for certain classes of framework instances, which can be exploited for obtaining decidability results. In more detail, we characterize the complexity of reasoning for some meaningful classes of evolving knowledge bases, ranging from polynomial to double exponential space complexity.

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).

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

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...

2001

Recently, several approaches for updating knowledge bases represented as logic programs have been proposed. In this paper, we present a generic framework for declarative specifications of update policies, which is built upon such approaches. It extends the LUPS language for update specifications and incorporates the notion of events into the framework. An update policy allows an agent to flexibly react upon new information, arriving as an event, and perform suitable changes of its knowledge base. The framework compiles update policies to logic programs by means of generic translations, and can be instantiated in terms of different concrete update approaches. It thus provides a flexible tool for designing adaptive reasoning agents.

Logics for Databases and Information Systems, 1998

Traditional logic-based speci cation approaches x the structure and the dynamics of an object system at speci cation time. Information systems are applications with a very long life-time. Therefore, object and speci cation evolution to react on changing requirements is a relevant aspect of describing information systems as object societies.