Updates by Reasoning about States
Bertram Ludaescher1995, Workshops in Computing
Sign up for access to the world's latest research
checkGet notified about relevant papers
checkSave papers to use in your research
checkJoin the discussion with peers
checkTrack your impact
Abstract
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.
Related papers
Transactions and updates in deductive databases
IEEE Transactions on Knowledge and Data Engineering, 1997
Abstract In this paper, we develop a new approach that provides a smooth integration of extensional updates and declarative query languages for deductive databases. The approach is based on a declarative specification of updates in rule bodies. Updates are not executed as soon as evaluated. Instead, they are collected and then applied to the database when the query evaluation is completed. We call this approach nonimmediate update semantics. We provide a top-down and equivalent bottom-up semantics which reflect the ...
A principled 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
On active deductive databases: The statelog approach
Lecture Notes in Computer Science, 1998
After brie y reviewing the basic notions and terminology of active rules and relating them to production rules and deductive rules, respectively, we survey a number of formal approaches to active rules. Subsequently, w e present our own state-oriented logical approach to active rules which combines the declarative semantics of deductive rules with the possibility to de ne updates in the style of production rules and active rules. The resulting language Statelog is surprisingly simple, yet captures many features of active rules including composite event d etection and di erent coupling modes. Thus, it can be used for the formal analysis of rule properties like termination and expressive p o wer. Finally, we s h o w h o w nested transactions can be modeled in Statelog, both from the operational and the model-theoretic perspective.
Active-U-Datalog: Integrating active rules in a logical update language
Transactions and Change in Logic Databases, 1998
Deductive database technology represents an important step towards the goal of developing highly-declarative database programming languages. In order to make deductive databases a practical technology, deductive rules have to be extended to provide a dynamic behavior. In particular, current applications require not only a support for updates and transactions but also the ability to automatically react to the occurrence of particular events. This is possible by integrating typical deductive rules, whose execution is user-dependent, with active ...
LUPS - A Language for Updating Logic Programs
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).
A complete logic for Database Abstract State Machines1
Logic Journal of the IGPL, 2017
In database theory, the term database transformation was used to refer to a unifying treatment for computable queries and updates. Recently, it was shown that non-deterministic database transformations can be captured exactly by a variant of ASMs, the so-called Database Abstract State Machines (DB-ASMs). In this article we present a logic for DB-ASMs, extending the logic of Nanchen and Stärk for ASMs. In particular, we develop a rigorous proof system for the logic for DB-ASMs, which is proven to be sound and complete. The most difficult challenge to be handled by the extension is a proper formalisation capturing non-determinism of database transformations and all its related features such as consistency, update sets or multisets associated with DB-ASM rules. As the database part of a state of database transformations is a finite structure and DB-ASMs are restricted by allowing quantifiers only over the database part of a state, we resolve this problem by taking update sets explicitly into the logic, i.e. by using an additional modal operator [X], where X is interpreted as an update set ∆ generated by a DB-ASM rule. The DB-ASM logic provides a powerful verification tool to study properties of database transformations. Acknowledgements.
Generalizing Updates: From Models to 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.
A method for change computation in deductive databases
… OF THE INTERNATIONAL CONFERENCE ON VERY …, 1992
Change computation is an essential component in several capabilities of a deductive database, such as integrity constraints checking, materialized view maintenance and condition monitoring. In this paper, we present a general method for change computation, which is based on the use of transition and internal events rules. These rules explicitly define the insertions, deletions and modifications induced by a database update. Standard SLDNF resolution can be used to compute the induced changes, but other procedures could be used as well. Our method generalizes and extends previous work on change computation methods, and in some cases computes changes in a more efficient way.
Integrated Treatment of Updates in Deductive Databases: the FOLRE Project (extended abstract) E. Mayol, J. A. Pastor, E. Teniente, T. Urpí
We review in this paper both a framework for integrating the treatment of advanced update problems in deductive databases and the architecture of the FOLRE deductive database management system prototype, which extends the basic updating facilities provided by current deductive database systems.
Well Founded Semantics for Logic Program Updates
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.
Related topics
Related papers
A language for updating logic programs and its implementation
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
FOLRE: A deductive database system for the integrated treatment of updates
Rules in Database Systems, 1997
We present in this paper both a novel theoretically well-founded framework for integrating the treatment of advanced update and rule enforcement problems in deductive databases and the architecture of a new deductive database management system based upon such a ...
A framework for declarative update specifications in logic programs
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.
A Schema for Generating Update Semantics
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.
Integrated Treatment of Updates in Deductive Databases: the FOLRE Project (extended abstract)
1998
We review in this paper both a framework for integrating the treatment of advanced update problems in deductive databases and the architecture of the FOLRE deductive database management system prototype, which extends the basic updating facilities provided by current deductive database systems.
Integrated Treatment of Updates in Deductive Databases: the FOLRE Project
2007
We review in this paper both a framework for integrating the treatment of advanced update problems in deductive databases and the architecture of the FOLRE deductive database management system prototype, which extends the basic updating facilities provided by current deductive database systems.
A Bottom-Up Interpreter for a Database Language with Updates and Transactions
APPIA-GULP-PRODE, 1994
Deductive databases with updates in rule bodies do not allow bottom-up execution model. This is due to the introduction of control in rule bodies. However, bottom-up execution models are very important due to the set oriented queryanswering process of database systems. In 4] we have proposed a rule language to avoid the above drawback and to provide transaction optimization through transaction transformation. In this paper we describe a prototype that provide a bottom-up meta interpreter for the database rule language and will allow to check the validity of future extensions theoretical conjecture about transaction optimization and integrity constraints. The experience in the use of KBMS1 as a tool to develop a run time support for the rule language is reported together with an overview of the system architecture.
FOLRE: Towards a System for the Integrated Treatment of Updates and Rule Enforcement in Deductive Databases
1994
We overview the architecture of a newly-born deductive database management system that is to provide advanced update and rule enforcement capabilities within an integrated and theoretically well-founded framework. The system builds up on previous theoretical results and systems of others -for the semantics, query, storage and transaction management needs-and of our own previous research and prototypes -for the advanced update and rule enforcement purposes. We hope that our approach will help to fill an important gap within current deductive database management systems prototypes and products.
Semantics for Update Rule Programs and Implementation in a Relational Database Management System
Tods, 1991
In this paper we present our research on defining a correct semantics for a class of update rule (UR) programs, and discuss implementing these programs in a DBMS environment. Update rules execute by updating relations in a database which may cause the further execution of rules. A correct semantics must guarantee that the execution of the rules will terminate and that it will produce a minimal updated database. The class of UR programs is syntactically identified, based upon a concept that is similar to stratification. We extend the strict definition of stratification and allow a relaxed criterion for partitioning of the rules in the UR program. This relaxation allows a limited degree of non-determinism in rule execution. We define an execution semantics based upon a monotonic fixpoint operator T UR , resulting in a set of fixpoints for UR. The monotonicity of the operator is maintained by explicitly representing the effect of asserting and retracting tuples in the database. A declarative semantics for the update rule program is obtained by associating a normal logic program UR to represent the UR program. We use the stable model semantics which characterize a normal logic program by a set of minimal models which are called stable models. We show the equivalence between the set of fixpoints for UR and the set of stable models for UR. We briefly discuss implementing the fixpoint semantics of the UR program in a DBMS environment. Relations that can be updated by the rules are updatable relations and they are extended with two flags. An update rule is represented by a database query, which queries the updatable relations as well as database relations, i.e., those relations which are not updated by rules. We describe an algorithm to process the queries and compute a fixpoint in the DBMS environment and obtain a final database.
A common framework for classifying and specifying deductive database updating problems
Proceedings of the Eleventh International Conference on Data Engineering, 1995
In this paper we propose two interpretations of the event rules [Oli91] which provide a common framework for classifying and specifying deductive database updating problems such as view updating, materialized view maintenance, integrity constraints checking, integrity constraints maintenance, repairing inconsistent databases, integrity constraints satisfiability or condition monitoring. Moreover, these interpretations allow us to identify and to specify some problems that have received little attention up to now like enforcing or preventing condition activation. By considering only a unique set of rules for specifying all these problems, we want to show that it is possible to provide general methods able to deal with all these problems as a whole.
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.