A language for updating logic programs and its implementation

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.

Lecture Notes in Computer Science, 2004

Over the last years various semantics have been proposed for dealing with updates of logic programs by (other) logic programs. Most of these semantics extend the stable models semantics of normal, extended (with explicit negation) or generalized (with default negation in rule heads) logic programs. In this paper we propose a well founded semantics for logic programs updates. We motivate our proposal with both practical and theoretical argumentations. Various theoretical results presented here show how our proposal is related to the stable model approach and how it extends the well founded semantics of normal and generalized logic programs.

2005

We consider the problem of updating of an agent's knowledge. We propose a formal method of knowledge update on the basis of the semantics of modal logic S5. In our method, an update is specified according to the minimal change on both the agent's actual world and knowledge. We discuss general minimal change properties of knowledge update and show that our knowledge update operator satisfies all the update postulates of Katsuno and Mendelzon.

1990

Because they are extra-logical and procedural, the conventional updating facilities of Logic Programming are not convenient for all applications. In particular, it is desirable to give database and expert System users the possibility to specify Updates without having to define their execution. We propose the concept of 'intensional update' as a formal basis for declarative update languages. Intensional Updates express in first-order logic changes of the consequences of logic programs. They generalize database 'view Updates'. The modifications of the logic program that actually realize an intensional update are derived through abductive reasoning. We show that this form of abduction can be reduced to deduction in a non-disjunctive, definite theory, thus giving rise to implementations in Logic Programming. First, we formalize abduction as deduction in a disjunctive theory. Second, we apply the theorem prover Satchmo [22], which express deduction in disjunctive theories through definite meta-clauses. This approach gives rise to effkiently taking static and dynamic integrity constraints into account and to achieving completeness.

2001

Abstract We consider the problem of how an agent's knowledge can be updated. We propose a formal method of knowledge update on the basis of the semantics of modal logic S5. In our method, an update is specified according to the minimal change on both the agent's actual world and knowledge. We then investigate the semantics of knowledge update and characterize several specific forms of knowledge update which have important applications in reasoning about change of agents' knowledge.

Journal of Philosophical Logic, 1995

Logical frameworks for analysing the dynamics of information processing abound [4, S, 8, 10, 12, 14, 20, 22]. Some of these frameworks focus on the dynamics of the interpretation process, some on the dynamics of the process of drawing inferences, and some do both of these. Formalisms galore, so it is felt that some conceptual streamlining would pay off. This paper is part of a larger scale enterprise to pursue the obvious parallel between information processing and imperative programming. We demonstrate that logical tools from theoretical computer science are relevant for the logic of information flow. More specifically, we show that the perspective of Hoare logic [13, 18] can fruitfully be applied to the conceptual simplification of information flow logics. Part one of this program consisted of the analysis of 'dynamic interpretation' in this way, using the example of dynamic predicate logic [10]; the results were published in [7). The present paper constitutes the second part of the program, the analysis of 'dynamic inference'. Here we focus on Veltrnan's update logic [22]. Update logic is an example of a logical framework which takes the dynamics of drawing inferences into account by modelling information growth as discarding of possibilities. This paper shows how information logics like update logic can fruitfully be studied by linking their dynamic principles to static 'correctness descriptions'. Our theme is exemplified by providing a sound and complete Hoare/Pratt style deduction system for update logic. The Hoare/Pratt correctness statements use modal propositional dynamic logic as assertion language and connect update logic to the modal propositional logic SS. The connection with SS provides a clear link between the dynamic and the static semantics of update logic. The fact that update logic is decidable was noted already in [2]; the connection with SS provides an alternative proof. The SS connection can also be used for rephrasing the validity notions of update logic and for performing consistency checks. In conclusion, it is argued that interpreting the dynamic statements of information logics as dynamic modal operators has much wider applicability. In fact, the method can be used to axiomatize quite a wide range of information logics.

2002

Dynamic Logic Programming (DLP) was introduced to deal with knowledge about changing worlds, by assigning semantics to sequences of generalized logic programs, each of which represents a state of the world. These states permit the representation, not only of time, but also of specificity, strength of updating instance, hierarchical position of the knowledge source, etc. Subsequently, the Language of Updates LUPS was introduced to allow for the association, with each state, of a set of transition rules.

Computational Logic in Multi-Agent Systems, 2004

An important branch of investigation in the field agents has been the definition of high level languages for representing eects of ac- tions, the programs written in such languages being usually called action programs. Logic programming is an important area in the field of knowl- edge representation and some languages for specifying updates of Logic Programs had been defined. In

Logic Journal of IGPL, 1996

In this paper we propose a logic programming language which s u p p o r t s h ypothetical updates together with integrity constraints. The language makes use of a revision mechanism, which is needed to restore consistency when an update violates some integrity constraint. The revision policy adopted is based on the simple idea that more recent information is preferred to earlier one. We show how this language can be used to represent and perform several types of defeasible reasoning. We develop a logical characterization of the language in a three-valued conditional logic, by i n troducing a completion construction. We s h o w t h a t the operational semantics is sound and complete with respect to the completion construction.

As suggested in the literature, revising and updating beliefs and knowledge bases is an important unsolved topic in knowledge representation and reasoning that requires a solid theoretical basis, particularly in current applications of Artificial Intelligence where an agent can work in an open dynamic environment with incomplete information. Various researchers have combined postulates and Answer Set Programming as key components to set up their approaches. However, many of such proposals still present some shortcomings when dealing with persistence situations, redundant information, contradictions or lack of further properties of knowledge evolution. In need to satisfy more general principles and suggesting a frame of reference, this paper consists of a study of consistency preservation and restoration, and a new AGM-characterisation of a semantics for updates of logic programs. It consists in performing updates of epistemic states that meets well-accepted belief revision postulates. Besides the set of properties that this framework shares with other equivalent update semantics, this proposal is also supported by a solver prototype as an important component of logic programming and automatic testbed of its declarative version. The existence of a solver for a theoretical framework helps to automatically compute agents' knowledge bases for more complex prototypes and frameworks.

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.

Proceedings of the 1998 Joint International Conference and Symposium on Logic Programming (JICSLP-98), 1998

The field of theory update has seen some improvement, in what regards updating, by allowing desired updates to be specified by update programs. The updating of models is governed by update rules, as well as by inertia applied to those literals not directly affected by the update program. Though this is important, it remains necessary to tackle too the updating of theories specified by programs. In this paper we explore logic program updates, namely how to exert inertia on program rules rather than on the literals of their models. We ...

Workshops in Computing, 1995

It has been argued that some sort of control must be introduced in order to perform update operations in deductive databases see e.g. 1, 17. Indeed, many approaches rely on a procedural semantics of rule based languages and often perform updates as side-e ects. Depending on the evaluation procedure, updates are generally performed in the body top-down evaluation or in the head of rules bottom-up evaluation. We demonstrate that updates can be speci ed in a purely declarative manner using standard model based semantics without relying on procedural aspects of program evaluation. The key idea is to incorporate states as rst-class objects into the language. This is the source of the additional expressiveness needed to de ne updates. We i n troduce the update language Statelog +-, discuss various domains of application and outline how to implement computation of the perfect model semantics for Statelog +-programs.

1997

Recently the field of theory update has seen some improvement, in what concerns model updating, by allowing updates to be specified by so-called revision programs. The updating of theory models is governed by their update rules and also by inertia applied to those literals not directly affected by the update program. Though this is important, it remains necessary to tackle as well the updating of programs specifying theories. Some results have been obtained on the issue of updating a logic program which encodes a set of models, to obtain a new program whose models are the desired updates of the initial models. But here the program only plays the rÔle of a means to encode the models. A logic program encodes much more than a set of models: it encodes knowledge in the form of the relationships between the elements of those models. In this paper we advocate that the principle of inertia is advantageously applied to the rules of the initial program rather than to the individual literals in a model. Indeed, we show how this concept of program update generalizes model or interpretation updates. Furthermore, it allows us to conceive what it is to update one program by another, a crucial notion for opening up a whole new range of applications concerning the evolution of knowledge bases. We will consider the updating of normal programs as well as these extended with explicit negation, under the stable semantics.

The use of DL systems to add reasoning capabilities to database is now a major trend in convergence between knowledge base and database system but is still confronted with the issue of data update. DL systems provide fact additions and retractions but no real object update mechanisms. We present a semantics for update that favours attribute values to concept membership and deals with incomplete information. After relating our work to an existing previous one on update semantics we address implementation issues.