On the evolution of the instance level of DL-lite knowledge bases

04/20/2011
by   Maurizio Lenzerini, et al.
0

Recent papers address the issue of updating the instance level of knowledge bases expressed in Description Logic following a model-based approach. One of the outcomes of these papers is that the result of updating a knowledge base K is generally not expressible in the Description Logic used to express K. In this paper we introduce a formula-based approach to this problem, by revisiting some research work on formula-based updates developed in the '80s, in particular the WIDTIO (When In Doubt, Throw It Out) approach. We show that our operator enjoys desirable properties, including that both insertions and deletions according to such operator can be expressed in the DL used for the original KB. Also, we present polynomial time algorithms for the evolution of the instance level knowledge bases expressed in the most expressive Description Logics of the DL-lite family.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

01/25/2020

On Expansion and Contraction of DL-Lite Knowledge Bases

Knowledge bases (KBs) are not static entities: new information constantl...
02/04/2014

Description Logic Knowledge and Action Bases

Description logic Knowledge and Action Bases (KAB) are a mechanism for p...
05/02/2011

Splitting and Updating Hybrid Knowledge Bases (Extended Version)

Over the years, nonmonotonic rules have proven to be a very expressive a...
09/16/2002

Reasoning about Evolving Nonmonotonic Knowledge Bases

Recently, several approaches to updating knowledge bases modeled as exte...
07/01/2020

Signature-Based Abduction for Expressive Description Logics – Technical Report

Signature-based abduction aims at building hypotheses over a specified s...
07/04/2012

A Revision-Based Approach to Resolving Conflicting Information

In this paper, we propose a revision-based approach for conflict resolut...
06/01/2011

What's in an Attribute? Consequences for the Least Common Subsumer

Functional relationships between objects, called `attributes', are of co...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Description Logics (DLs) [3] are logics for expressing knowledge bases (KBs) constituted by two components, namely, the TBox, asserting general properties of concepts and roles (binary relations), and the ABox, which is a set of assertions about individuals that are instances of concepts and roles. It is widely accepted that such logics are well-suited for expressing ontologies, with the TBox capturing the intensional knowledge about the domain of interest, and the ABox expressing the knowledge about the instance level of the predicates defined in the TBox. Following this idea, several Knowledge Representation Systems, called DL systems, have been recently built, providing methods and tools for managing ontologies expressed in DLs 111http://www.cs.man.ac.uk/ sattler/reasoners.html. Notice that numerous DLs have been studied in the last decades, with the goal of analyzing the impact of the expressive power of the DL language to the complexity of reasoning. Consequently, each DL system is tailored towards managing KB expressed in a specific DL.

By referring to the so-called functional view of knowledge representation [13], DL systems should be able to perform two kinds of operations, called ASK and TELL. ASK operations, such as subsumption checking, or query answering, are used to extract information from the KB, whereas TELL operations aim at changing the KB according to new knowledge acquired over the domain. In other words, TELL operations should be able to cope with the evolution of the KB.

There are two types of evolution operators, corresponding to inserting, and deleting chunks of knowledge, respectively. In the case of insertion, the aim is to incorporate new knowledge into the KB, and the corresponding operator should be defined in such a way to compute a consistent KB that supports the new knowledge. In the case of deletion, the aim is to come up with a consistent KB where the retracted knowledge is not valid. In both cases, the crucial aspect to take into account is that evolving a consistent knowledge base should not introduce inconsistencies. We point out that a different approach would be to allow inconsistencies in the KB, and then resorting to sophisticated quesy answering mechanisms, tolerant to such inconsistencies (see, for example, [1, 12], but this is outside the scope of the approach presented here.

Notice that, while ASK operations have been investigated in detail by the DL community, existing DL reasoners do not provide explicit services for KB evolution. Nevertheless, many recent papers demonstrate that the interest towards a well-defined approach to KB evolution is growing significantly [9, 14, 7, 15, 6].

Following the tradition of the work on knowledge revision and update [11], all the above papers advocate some minimality criterion in the changes of the KB that must be undertaken to realize the evolution operations. In other words, the need is commonly perceived of keeping the distance between the original KB and the KB resulting from the application of an evolution operator minimal. There are two main approaches to define such a distance, called model-based and formula-based, respectively. In the model-based approaches, the result of an evolution operation applied to the KB is defined in terms of a set of models, with the idea that such a set should be as close as possible to the models of . One basic problem with this approach is to characterize the language needed to express the KB that exactly captures the resulting set of models. Conversely, in the formula-based approaches, the result is explicitly defined in terms of a formula, by resorting to some minimality criterion with respect to the formula expressing . Here, the basic problem is that the formula constituting the result of an evolution operation is not unique in general.

In this paper, we study the problem of DL KB evolution, by focusing our attention to scenarios characterized by the following elements:

  1. We consider the case where the evolution affects only the instance level of the KB, i.e., the ABox. In other words, we enforce the condition that the KB resulting from the application of the evolution operators has the same TBox as the original KB (similarly to [14, 7]).

  2. We aim at a situation where the KB resulting from the evolution can be expressed in the same DL as the original KB. This is coherent with our goal of providing the foundations for equipping DL systems with evolution operators: indeed, if a DL system is able to manage KBs expressed in a DL , the result of evolving such KBs should be expressible in .

  3. The KBs resulting from the application of an evolution operator on two logically equivalent KBs should be mutually equivalent. In other words, we want the result to be independent of the syntactic form of the original KB.

Assumption (1), although limiting the generality of our approach, captures several interesting scenarios, including ontology-based data management, where the DL KB is used as a logic-based interface to existing information systems (databases, web sources, etc.).

As for item (2), we note that virtually all model-based approaches suffer from the expressibility problem. This has been reported in many recent papers, including [14, 7, 6], for DLs whose expressive power range from DL-Lite to . For this reason, we adopt a formula-based approach, inspired in particular by the work developed in [8] for updating logical theories. As in [8], we consider both insertions and deletions. However, we differ from [8] for an important aspect. We already noted that the formula constituting the result of an evolution operation is not unique in general. While [8] essentially proposes to keep the whole set of such formulas, we take a radical approach, and consider their intersection as the result of the evolution. In other words, we follow the When In Doubt Throw It Out (WIDTIO) [10, 16] principle.

Finally, to deal with item (3), we sanction that the notion of distance between KBs refers to the closure of the ABox of a KB, rather than to the ABox itself. The closure of an ABox with respect to an TBox is defined as the set of all ABox assertions that logically follows from and . By basing the definition of distance on the closure of ABoxes, we achieve the goal of making the result of our operators independent of the form of the original KB.

After a brief introduction to DLs (Section 2), we provide the definition of our evolution operators in Section 3, together with a comparison with related approaches. The remaining sections are devoted to illustrating algorithms for deletion (Section 4), and insertion (Section 5) for KBs expressed in the DL , which is the most expressive logic in the DL-Lite family [4] The DL-Lite family222Not to be confused with the set of DLs studied in [2], which form the family. has been specifically designed to keep all reasoning tasks polynomially tractable, and we show that this property still holds for the evolution operators proposed in this paper. Indeed, we show that computing the result of both insertions and deletions to KBs expressed is tractable.

2 Preliminaries

Let be a signature of symbols for individual (object and value) constants, and atomic elements, i.e., concepts, value-domains, attributes, and roles. If is a DL, then an -KB over is a pair  [3] where , called TBox, is a finite set of intensional assertions over expressed in , and , called ABox, is a finite set of instance assertions, i.e, assertions on individuals, over . Different DLs allow for different kinds of TBox and/or ABox assertions. In this paper we assume that ABox assertions are always atomic, i.e., they correspond to ground atoms, and therefore we omit to refer to when we talk about ABox assertions.

The semantics of a DL KB is given in terms of first-order interpretations [3]. An interpretation is a model of a DL knowledge base if it satisfies all assertions in (the notion of satisfaction depends on the constructs allowed by the specific DL in which is expressed). We denote the set of models of with .

Let be a TBox in , and let be an ABox. We say that is -consistent if is satisfiable, i.e. if , -inconsistent otherwise. The -closure of with respect to , denoted , is the set of all atomic ABox assertion that are formed with individuals in , and are logically implied by . Obviously, is logically equivalent to . is said to be -closed if . Finally, for an ABox assertion , we denote by the set of atoms such that .

The description logic .   The DL-Lite family [4] is a family of low complexity DLs particularly suited for dealing with KBs with very large ABoxes, and forms the basis of OWL 2 QL, one of the profile of OWL 2, the official ontology specification language of the World-Wide-Web Consortium (W3C)333 http://www.w3.org/TR/2008/WD-owl2-profiles-20081008/.

We now present the DL , which is the most exprressive logic in the family. Expressions in are formed according to the following syntax:

where , , and are symbols in denoting respectively an atomic concept name, an atomic role name and an attribute name, are all the value-domains allowed in the logic (those corresponding to the data types adopted by Resource Description Framework (RDF)444http://www.w3.org/RDF/), denotes the union of all domain values, denotes the inverse of , denotes the objects related to by the role , denotes negation, denotes the domain of , i.e., the set of objects that relates to values, and denotes the range of , i.e., the set of values related to objects by .

A TBox contains intensional assertions of three types, namely inclusion assertions, functionality assertions, and identification assertions [5] (IDs). More precisely, assertions are of the form:

In the identification assertions, denotes a path, which is an expression built according to the following syntax rule:

where denotes an atomic role, the inverse of an atomic role, or an atomic attribute, denotes the composition of the paths and , and , called test relation, represents the identity relation on instances of the concept . In our logic, identification assertions are local, i.e., at least one has length 1, i.e., it is an atomic role, the inverse of an atomic role, or an atomic attribute. In what follows, we only refer to IDs which are local.

A concept inclusion assertion expresses that a (basic) concept is subsumed by a (general) concept . Analogously for the other types of inclusion assertions. Inclusion assertions that do not contain (resp. contain) the symbols ’’ in the right-hand side are called positive inclusions (resp. negative inclusions). Attribute functionality assertions are used to impose that attributes are actually functions from objects to domain values. Finally, an ID asserts that for any two different instances , of , there is at least on such that and differ in the set of their -fillers. Note that IDs can be used to assert functionality of roles. Specifically, the assertion imposes that is functional.

The set of positive (resp., negative) inclusions in will be denoted by (resp., ), whereas the set of identification assertions in will be denoted by .

A ABox is a finite set of assertions of the form , , and , where , , and are as above, and are object constants in , and is a value constant in .

Example 1

We consider a portion of the Formula One domain. We know that official drivers () and test drivers () are both team members (), and official drivers are not test drivers. Every team member is a member of () a exactly one team (), and every team has at most one official driver. Finally, no race director () is a member of a team. We also know that is the official driver of team , that is a test driver, and that is a team member. The corresponding -KB is:


  •     

We conclude this section with a brief discussione on the complexity of reasoning about a -KB . Satisfiability can be checked in polynomial time with respect to and , and in NP with respect to . Moreover, if is satisfiable, then answering a query posed to can be done in polynomial time with respect to and , and in NP with respect to . Finally, can be computed in quadratic time with respect to and .

3 WIDTIO approach to KB evolution in DLs

In this section we first present our semantics for the evolution of DL knowledge bases at the instance level, and then we provide a comparison between our operator and other work in the literature.

Semantics.  In what follows, is a DL, and is a satisfiable -KB. In other words, we do not consider the evolution of unsatisfiable KBs. In addition, is a finite set of atomic ABox assertions in .

The following definition specifies when a set of ABox assertions “realizes” the insertion or deletion of a set of ABox assertions with respect to .

Definition 1

Let be a finite set of ABox assertions in . Then, we say that accomplishes the insertion of into if is satisfiable, and (i.e., ). Similarly, accomplishes the deletion of from if is satisfiable, and (i.e., ).

Obviously, we are interested in KBs which accomplish the evolution of a KB with a minimal change. In order to formalize the notion of minimal change, we first need to provide some definitions.

Let and be two finite sets of ABox assertions in . Then, we say that has fewer insertions than with respect to if ; and has fewer deletions than with respect to if . Also, we say that and have the same deletions with respect to if .

Definition 2

Let and be two finite sets of ABox assertions in . Then, has fewer changes than with respect to if has fewer deletions than with respect to , or and have the same deletions with respect to , and has fewer insertions than with respect to .

Now that we have defined the relation of fewer changes between two KBs w.r.t. another one, we can define the notion of a KB which accomplishes the insertion (resp. deletion) of a set of facts into (resp. from) another KB minimally.

Definition 3

The -KB accomplishes the insertion (deletion) of into (from) minimally if accomplishes the insertion (deletion) of into (from) , and there is no -KB that accomplishes the insertion (deletion) of into (from) , and has fewer changes than with respect to .

With these notions in place, we can now define our evolution operator.

Definition 4

Let be the set of all -KBs accomplishing the insertion (deletion) of into (from) minimally, and let be an -KB. Then, is the result of changing with the insertion (deletion) of if    is empty, and , or    is nonempty, and .

It is immediate to verify that, up to logical equivalence, the result of changing with the insertion or the deletion of is unique. In the rest of this paper, the result of changing with the insertion (resp. deletion) of according to our semantics will be denoted by (resp. ). Notice that, by definition of our operator, in the case where is inconsistent with , the result of changing with both the insertion and the deletion of is logically equivalent to itself.

Example 2

Consider the KB of the Example 1, and suppose that becomes now a race director, and becomes the new official driver ofq team . To reflect this new information, we change with the insertion of . Since the TBox implies that a race director cannot be a team member, contradicts . Also, since every team has at most one official driver, and contradict . According to Definition 3, the KBs accomplishing the insertion of into minimally are:

  • = ,,,,

  • = ,,,,

Thus, is:

  • = ,,,.

Now, suppose that we do not know anymore whether is a member of , and, even more, whether is a team member at all. Then, we change with the deletion of , thus obtaining

  • = ,,.     

Comparison with related work.   We mentioned in the introduction several model-based approaches to DL KB evolution, and noticed that they all suffer from the expressibility problem. This problem is also shared by [15], that uses features instead of models, and proposes the notion of approximation to cope with the expressibility problem, similarly to [7].

Related to our proposal are several formula-based approaches proposed in the literature. We already pointed out that our proposal is inspired by [8], although the problem studied in [8] is evolution in propositional logic, whereas the context dealt with in our work is instance-level evolution in DLs. Perhaps, the closest approach to the one proposed in this paper is that reported in [6], where formula-based evolution (actually, insertion) of DL-Lite KBs is studied. The main difference with our work is that we base our semantics on the WIDTIO principles, and therefore we compute the intersection of all KBs accomplishing the change minimally. Conversely, in the bold semantics discussed in [6], the result of the change is chosen non-deterministically among the KBs accomplishing the change minimally. Another difference is that while [6] addresses the issue of evolution of both the TBox and the ABox, we only deal with the case of fixed TBox (in the terminology of [6], this corresponds to keep the TBox protected). It is interesting to observe that the specific DL considered in [6] is , and for this logic, exactly one KB accomplishes the insertion of a set of ABox assertions minimally. It follows that for instance-level insertion, their bold semantics coincides with ours. On the other hand, the presence of identification assertions in changes the picture considerably, since with such assertions in the TBox, many KBs may exist accomplishing the insertion minimally. In this case, the two approaches are indeed different. Finally, [6] proposes a variant of the bold semantics, called careful semantics, for instance-level insertion in . Intuitively, such a semantics aims at disregarding knowledge that is entailed neither by the original KB, nor by the set of newly asserted facts. Although such principle is interesting, we believe that the careful semantics is too drastic, as it tends to eliminate too many information from the original KB as shown in the following example.

Example 3

Consider the KB of the Example 1, and suppose that we is now a member of a formula one team, which means changing with the insertion of . Notice that such a new fact does not contradict any information in . Therefore, in our approach, the result of the insertion is , , , , . Conversely, one can verify that the result under the careful semantics is , , , thus loosing both the information that is a test driver, and the information that is a team member.     

Finally, we point out that, to our knowledge, the evolution operator presented in this work is the first tractable evolution operator based on the WIDTIO principle.

4 Deletion in

We study deletion under the assumption that the DL language is . Thus, we refer to a -KB , and we address the problem of changing with the deletion of a finite set of ABox assertions. We assume that both and are satisfiable.

The following theorem specifies when a -KB accomplishes the deletion of from minimally.

Theorem 4.1

accomplishes the deletion of from minimally if and only if is a maximal -closed subset of such that .

We now consider the case where the set is constituted by just one assertion . By exploiting Theorem 4.1, it is easy to conclude that there is exactly one KB accomplishing the deletion of from a given KB.

Theorem 4.2

Let be an ABox assertion. Up to logical equivalence, there is exactly one KB of the form that accomplishes the deletion of from minimally, and such KB can be computed in polynomial time with respect to and .

Proof (sketch).  The proof is based on the fact that is the unique maximal -closed subset of such that .  

Let us now consider the case of arbitrary . Suppose that, for every , accomplishes the deletion of from minimally. One might wonder whether the set of all KBs accomplishing the deletion of from minimally coincides (modulo logical equivalence) with . The next theorem tells us that one direction is indeed valid: for each KB there exists a KB such that .

Theorem 4.3

If accomplishes the deletion of from minimally, then there exists such that accomplishes the deletion of from minimally.

However, the following example shows that the other direction does not hold: there may exist a that is not logically equivalent to any .

Example 4

Let be , let be , and let be . It is easy to see that the deletion of from is accomplished minimally by , while the deletion of from is accomplished minimally by . Therefore, in this case . Also, one can verify that is the only (up to logical equivalence) KB accomplishing the deletion of minimally, i.e., . Thus, there is a KB in , namely , that is not logically equivalent to any KB in .     

Note that the above example also shows that deleting is not equivalent to iteratively deleting all atoms in .

The next theorem characterizes when a given accomplishes the deletion of minimally.

Theorem 4.4

Let , and, for every , let accomplish the deletion of from minimally. Then, , where , accomplishes the deletion of from minimally if and only if there is no such that , and .

Proof (sketch).  We first show that , where , accomplishes the deletion of from minimally if and only if there is no such that , and then show that if and only if , and .  

By exploiting Theorems 4.2, 4.3, and 4.4, we can directly prove that can be computed by the algorithm below. It is easy to see that the time complexity of the algorithm is .

Input: a satisfiable KB , a finite set of ABox assertions such that is satisfiable
Output: a KB.
begin
       ;
       foreach  and such that  do
            if  then 
            ;
            
      return ;
      
Algorithm 1 Algorithm
Theorem 4.5

terminates, and computes in polynomial time with respect to , and .

5 Insertion in

We refer to a -KB , and we address the problem of changing with the insertion of a finite set of ABox assertions. As in the previous section, we assume that both and are satisfiable. The main problem to be faced with insertion is described by the following observation.

Suppose that contains identification assertions with at least two atoms that become simoultaneously violated with the insertion of a single ABox assertion into , and such that every choice of retracting one of such atoms yields a maximal subset of that is -consistent with . Obviously, there are at least such maximal subsets. What the above example shows is that, given , there can be an exponential number of maximal subsets of such that is satisfiable. Note that this cannot happen in those DLs of the DL-Lite family which do not admit the use of identification assertions (such as the DL studied in [6]). Indeed, in such logic, there is always one maximal subset of that is consistent with a set of ABox assertions.

It follows from the above observation that building all maximal subsets of which are -consistent with , and then computing their intersection is computationally costly. Fortunately, we show in the following that we can compute without computing all maximal consistent subsets of with .

To describe our method, we need some preliminary notions. A set of facts is called a -violation set for if is unsatisfiable, while for every proper subset of , is satisfiable. Any set of facts that is a -violation set for a is simply called a -violation set.

Theorem 5.1

Let be a satisfiable -KB, and let be an ABox assertion such that is satisfiable. If is unsatisfiable, then there is a -violation set in such that contains , and .

Proof (sketch).  We first show that, if is unsatisfiable, then there is a TBox assertion in such that , where is the boolean query corresponding to the negation of . This implies that there is a query in the -expansion of that evaluates true on , i.e., that forms a -violation set for in . Now suppose that, for every , and for every -violation set in , does not contain . This means that either there is no -violation set in , or all -violation sets in do not contain . Btoh cases lead to a contradiction, and, therefore, we conclude that there is a -violation set in such that contains . Finally, since is satisfiable, it is immediate to verify that .  

The next theorem is the key to our solution.

Theorem 5.2

Let be an atom such that . There exists a maximal subset of such that is satisfiable and does not contain if and only if there is a -violation set in such that , and is satisfiable.

Proof (sketch).  Suppose that there is a -violation set in such that and is satisfiable. Since is satisfiable, the set of maximal subsets of such that is satisfiable is non-empty. Consider any in such a set, i.e., assume that is a maximal subset of such that is satisfiable. It can be shown that (1) does not contain , and (2) is a maximal subset of such that is satisfiable.

Suppose that there is no -violation set in such that and is satisfiable. We show that every maximal subset of such that is satisfiable contains , by showing that, if is a subset of such that is satisfiable, then is also satisfiable. Indeed, assume by way of contradiction that is unsatisfiable. Note that , and, since is satisfiable, is also satisfiable. We can therefore apply theorem 5.1, and conclude that there is a -violation set in such that (1) contains , (2) . Now, since , and is satisfiable, it follows that is satisfiable. This implies that there is a -violation set in such that and is satisfiable, which is a contradiction.  

Theorems 5.1 and 5.2 allow us to prove that can be computed by the algorithm below.

Input: a satisfiable KB , a finite set of ABox assertions such that is satisfiable
Output: a KB.
begin
       ;
       foreach  do
             if  a -violation set in s.t. and is satisfiable then
                  
                  
            
      return ;
      
Algorithm 2 Algorithm

Algorithm requires to compute all -violation sets in . It can be shown that this can be done by computing the results of suitable conjunctive queries posed to . Such queries are built out of the negative inclusion assertions and the identification assertions in , and essentially look for tuples that satisfy the negation of such assertions. From this observation, one can derive the following theorem.

Theorem 5.3

terminates, and computes in polynomial time with respect to , , and , and in NP with respect to .

It can also be shown that the problem of checking for the existence of -violation sets in a set of ABox assertions is NP-complete with respect to .

6 Conclusions

We have illustrated a WIDTIO approach to instance-level evolution in DL, and we have presented algorithms for the case of . We plan to continue our work along several directions. First, we will extend the algorithms to the case where the KB contains denial constraints, which are constraints that can be added to without changing the complexity of all reasoning tasks. The extension is based on the fact that denial constraints behave similarly to identification assertions with respect to KB evolution. Also, we aim at extending our approach to the problem of evolution of the whole KB, as opposed to the ABox only. Finally, we will add the notion of protected part to our approach, to model situations where one wants to prevent changes on specific parts of the KB when applying insertions or deletions.

References

  • [1] Marcelo Arenas, Leopoldo E. Bertossi, and Jan Chomicki. Consistent query answers in inconsistent databases. In Proc. of PODS’99, pages 68–79, 1999.
  • [2] Alessandro Artale, Diego Calvanese, Roman Kontchakov, and Michael Zakharyaschev. The DL-Lite family and relations.

    J. of Artificial Intelligence Research

    , 36:1–69, 2009.
  • [3] Franz Baader, Diego Calvanese, Deborah McGuinness, Daniele Nardi, and Peter F. Patel-Schneider, editors. The Description Logic Handbook: Theory, Implementation and Applications. Cambridge University Press, 2003.
  • [4] Diego Calvanese, Giuseppe De Giacomo, Domenico Lembo, Maurizio Lenzerini, and Riccardo Rosati. Tractable reasoning and efficient query answering in description logics: The DL-Lite family.

    J. of Automated Reasoning

    , 39(3):385–429, 2007.
  • [5] Diego Calvanese, Giuseppe De Giacomo, Domenico Lembo, Maurizio Lenzerini, and Riccardo Rosati. Path-based identification constraints in description logics. In Proc. of KR 2008, pages 231–241, 2008.
  • [6] Diego Calvanese, Evgeny Kharlamov, Werner Nutt, and Dmitriy Zheleznyakov. Evolution of DL-Lite knowledge bases. In Proc. of ISWC 2010, 2010.
  • [7] Giuseppe De Giacomo, Maurizio Lenzerini, Antonella Poggi, and Riccardo Rosati. On instance-level update and erasure in description logic ontologies. J. of Logic and Computation, Special Issue on Ontology Dynamics, 19(5):745–770, 2009.
  • [8] Ronald Fagin, Jeffrey D. Ullman, and Moshe Y. Vardi. On the semantics of updates in databases. In Proc. of PODS’83, pages 352–365, 1983.
  • [9] Giorgos Flouris, Dimitris Manakanatas, Haridimos Kondylakis, Dimitris Plexousakis, and Grigoris Antoniou. Ontology change: Classification and survey. Knowledge Engineering Review, 23(2):117–152, 2008.
  • [10] Matthew L. Ginsberg and David E. Smith. Reasoning about action I: A possible worlds approach. Technical Report KSL-86-65, Knowledge Systems, AI Laboratory, 1987.
  • [11] Hirofumi Katsuno and Alberto Mendelzon. On the difference between updating a knowledge base and revising it. In Proc. of KR’91, pages 387–394, 1991.
  • [12] Nicola Leone, Thomas Eiter, Wolfgang Faber, Michael Fink, Georg Gottlob, Gianluigi Greco, Edyta Kalka, Giovambattista Ianni, Domenico Lembo, Maurizio Lenzerini, Vincenzino Lio, Bartosz Nowicki, Riccardo Rosati, Marco Ruzzi, Witold Staniszkis, and Giorgio Terracina. The INFOMIX system for advanced integration of incomplete and inconsistent data. In Proc. of ACM SIGMOD, pages 915–917, 2005.
  • [13] Hector J. Levesque. Foundations of a functional approach to knowledge representation. Artificial Intelligence, 23:155–212, 1984.
  • [14] H. Liu, C. Lutz, M. Milicic, and F. Wolter. Updating description logic ABoxes. In Proc. of KR 2006, pages 46–56, 2006.
  • [15] Zhe Wang, Kewen Wang, and Rodney W. Topor. A new approach to knowledge base revision in DL-Lite. In Proc. of AAAI 2010. AAAI Press, 2010.
  • [16] Marianne Winslett. Updating Logical Databases. Cambridge University Press, 1990.