A DECLARATIVE APPROACH OF DYNAMIC LOGIC OBJECTS
IJESRT Journal
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
The marriage of logic and objects is a very wide-ranging problem, approached with various approaches, depending on the purpose. In this article, we are interested in the modelling of the state and the change of the state of an object in logic programming. After a state of the art on the subject, presenting the various aspects as well as different solutions proposed in the literature, the article then proposes a mechanism of versions of objects based on the mechanism of unification and on the use incomplete structures. Indeed, the overview of an incomplete structure can be used to allow the entry of new information by means of unification and thus to foresee the future. This mechanism makes it possible to construct the history of an object by unification and to undo it by backtracking. The changes of state are thus made and defeated, without effects of edge, in synchronization with the backtrack.
Related papers
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).
Semantics for Dynamic Logic Programming: A Principle-Based Approach
Lecture Notes in Computer Science, 2003
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.
The gamut of dynamic logics
Handbook of the History of Logic, 2006
Dynamic logic, broadly conceived, is the logic that analyses change by decomposing actions into their basic building blocks and by describing the results of performing actions in given states of the world. The actions studied by dynamic logic can be of various kinds: actions on the memory state of a computer, actions of a moving robot in a closed world, interactions between cognitive agents performing given communication protocols, actions that change the common ground between speaker and hearer in a conversation, actions that change the contextually available referents in a conversation, and so on. In each of these application areas, dynamic logics can be used to model the states involved and the transitions that occur between them. Dynamic logic is a tool for both state description and action description. Formulae describe states, while actions or programs express state change. The levels of state descriptions and transition characterisations are connected by suitable operations that allow reasoning about pre-and postconditions of particular changes. From a computer science perspective, dynamic logic is a formal tool for reasoning about programs. Dynamic logics provides the means for formalising correctness specifications, for proving that these specifications are met by a program under consideration, and for reasoning about equivalence of programs. From the perspective of the present paper, this is but one of many application areas. We will also look at dynamic logics for cognitive processing, for communication and information updating, and for various aspects of natural language understanding.
Semantics for dynamic logic programming: a principled based approach
2004
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. This work was partially supported by FEDER financed project FLUX (POSI/40958/SRI/2001) and by project SOCS (IST-2001-32530). Special thanks are due to Pascal Hitzler and Reinhard Kahle for helpful discussions.
The Refined Extension Principle for Semantics of Dynamic Logic Programming
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.
Evolving Logic Programs with Temporal Operators
2000
Logic Programming Update Languages have been proposed as extensions of logic programming that allow specifying and reasoning about knowledge bases where both extensional knowledge (facts) as well as intentional knowledge (rules) may change over time as a result of updates. Despite their generality, these languages are limited in that they do not provide a means to directly access past states
Introduction to the 24th international conference on logic programming special issue
Theory and Practice of Logic Programming, 2011
The ICLP series of conferences provides a technical forum for presenting and disseminating innovative research in the field of logic programming. The 24th International Conference on Logic Programming took place from December 9–13, 2008 in the city of Udine, Italy. The conference attracted 177 submissions and featured a high-quality program focused on the foundations, developments, and applications of logic programming. Of particular significance was the special session celebrating the 20th anniversary of the seminal paper on the stable model semantics.
Propositional Dynamic Logic with Storing, Recovering and Parallel Composition
Electronic Notes in Theoretical Computer Science, 2011
This work extends Propositional Dynamic Logic (PDL) with parallel composition operator and four atomic programs which formalize the storing and recovering of elements in data structures. A generalization of Kripke semantics is proposed that instead of using set of possible states it uses structured sets of possible states. This new semantics allows for representing data structures and using the five new operator one is capable of reasoning about the manipulation of these data structures. The use of the new language (PRSPDL) is illustrated with some examples. We present sound and complete set of axiom schemata and inference rules to prove all the valid formulas for a restricted fragment called RSP DLo.
General Dynamic Dynamic Logic (2012)
in Thomas Bolander, Torben Brauner, Silvio Ghilardi, and Lawrence Moss, eds, Advances in Modal Logic, Volume 9, pp.239--260. College Publications, London, 2012.
Dynamic epistemic logic (DEL) extends purely modal epistemic logic (S5) by adding dynamic operators that change the model structure. Propositional dynamic logic (PDL) extends basic modal logic with programs that allow the de nition of complex modalities. We provide a common generalisation: a logic that is `dynamic' in both senses, and one that is not limited to S5 as its modal base. It also incorporates, and signi cantly generalises, all the features of existing extensions of DEL such as BMS [3] and LCC [21]. Our dynamic operators work in two steps. First, they provide a multiplicity of transformations of the original model, one for each `action' in a purely syntactic `action structure' (in the style of BMS). Second, they specify how to combine these multiple copies to produce a new model. In each step, we use the generality of PDL to specify the transformations. The main technical contribution of the paper is to provide an axiomatisation of this `general dynamic dynamic logic' (GDDL). This is done by providing a computable translation of GDDL formulas to equivalent PDL formulas, thus reducing the logic to PDL, which is decidable. The proof involves switching between representing programs as terms and as automata. We also show that both BMS and LCC are special cases of GDDL, and that there are interesting applications that require the additional generality of GDDL, namely the modelling of private belief update. More recent extensions and variations of BMS and LCC are also discussed.
Building bridges between dynamic and temporal doxastic logics Extended Abstract
2008
Analyzing the behavior of agents in a dynamic environment requires describing the evolution of their knowledge as they receive new information. Moreover agents entertain beliefs that need to be revised after learning new facts. I might be confident that I will find the shop open, but once I found it closed, I should not crash but rather make a decision on the basis of new consistent beliefs. Such beliefs and information may concern ground-level facts, but also beliefs about other agents. I might be a priori confident that the price of my shares will rise, but if I learn that the market is rather pessimistic (say because the shares fell by 10%), this information should change my higher-order beliefs about what other agents believe. Tools from modal logic have been successfully applied to analyze knowledge dynamics in multiagent contexts. Among these, Temporal Epistemic Logic [16], [12]'s Interpreted Systems, and Dynamic Epistemic Logic [2] have been particularly fruitful. A recent line of research [8, 7] compares these alternative frameworks, and [7] presents a representation theorem that shows under which conditions a temporal model can be represented as a dynamic one. Thanks to this link, the two languages also become comparable, and one can merge ideas: for example, a new line of research explores the introduction of protocols into PAL (see [7]). To the best of our knowledge, there are no similar results yet for multi-agent belief revision. One reason is that dynamic logics of belief revision have only been well-understood recently. But right now, there is work on both dynamic doxastic logics [5, 3] and on temporal frameworks for belief revision with [10] as a recent example. The exact connection between these two frameworks is not quite like the case of epistemic update. In this paper we make things clear, by viewing belief revision as priority update over plausibility pre-orders. This correspondence allows for similar language links as in the knowledge case, with similar benefits. We start in section 1 with some relevant background, while section 2 gives the main new definitions needed in the paper. Section 3 presents the key temporal doxastic properties that we will work with. In section 4 we state and prove our main result linking the temporal and the dynamic frameworks, first for the special case of total pre-orders and then in general. We also discuss some variations and extensions. In section 5 we introduce formal languages, providing an axiomatization for our crucial properties, and discussing some related definability issues. We state our conclusions and mention some open problems in the last section. Our key proofs are in the appendix.
Related papers
Updates of Logic Programs by Logic Programs
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...
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 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
Logic programming : proceedings of the seventh international conference
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.
A logic programming system for evolving programs with temporal operators
Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), 2009
Logic Programming Update Languages were proposed as an extension of logic programming that allows modeling the dynamics of knowledge bases where both extensional (facts) and intentional knowledge (rules) may change over time due to updates. Despite their generality, these languages do not provide a means to directly access past states of the evolving knowledge. They are limited to so-called Markovian change, i.e. changes entirely determined by the current state.
Object-Oriented Computations In Logic Programming
Object-Oriented Programming, 1994
Logic programming updating-a guided approach
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.
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
Introduction to the 27th International Conference on Logic Programming Special Issue
Theory and Practice of Logic Programming, 2011
Following the initiative in 2010 taken by the Association for Logic Programming and Cambridge University Press, the full papers accepted for the International Conference on Logic Programming again appear as a special issue of Theory and Practice of Logic Programming (TPLP)—the27th International Conference on Logic Programming Special Issue. Papers describing original, previously unpublished research and not simultaneously submitted for publication elsewhere were solicited in all areas of logic programming including but not restricted to: Theory: Semantic Foundations, Formalisms, Non- monotonic Reasoning, Knowledge Representation. Implementation: Compilation, Memory Management, Virtual Machines, Parallelism. Environments: Program Analysis, Transformation, Validation, Verification, Debugging, Profiling, Testing. Language Issues: Concurrency, Objects, Coordination, Mobility, Higher Order, Types, Modes, Assertions, Programming Techniques. Related Paradigms: Abductive Logic Programming, ...
Hypothetical Updates, Priority and Inconsistency in a Logic Programming Language
Logic Programming and Non-monotonic Reasoning, 1995
In this paper we propose a logic programming language which supports hypothetical updates together with integrity constraints. The language allows sequences of updates by sets of atoms and it makes use of a revision mechanism to restore consistency when an update violates some integrity constraint. The revision policy we adopt is based on the simple idea that more recent information
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.