Get my pizza right: Repairing missing is-a relations in ALC ontologies (extended version)

10/26/2012 ∙ by Patrick Lambrix, et al. ∙ 0

With the increased use of ontologies in semantically-enabled applications, the issue of debugging defects in ontologies has become increasingly important. These defects can lead to wrong or incomplete results for the applications. Debugging consists of the phases of detection and repairing. In this paper we focus on the repairing phase of a particular kind of defects, i.e. the missing relations in the is-a hierarchy. Previous work has dealt with the case of taxonomies. In this work we extend the scope to deal with ALC ontologies that can be represented using acyclic terminologies. We present algorithms and discuss a system.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

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

Developing ontologies is not an easy task, and often the resulting ontologies are not consistent or complete. Such ontologies, although often useful, also lead to problems when used in semantically-enabled applications. Wrong conclusions may be derived or valid conclusions may be missed. Defects in ontologies can take different forms (e.g. [16]). Syntactic defects are usually easy to find and to resolve. Defects regarding style include such things as unintended redundancy. More interesting and severe defects are the modeling defects which require domain knowledge to detect and resolve, and semantic defects such as unsatisfiable concepts and inconsistent ontologies. Most work up to date has focused on debugging (i.e. detecting and repairing) the semantic defects in an ontology (e.g. [16, 15, 29, 5]). Modeling defects have mainly been discussed in [2, 20, 19] for taxonomies, i.e. from a knowledge representation point of view, a simple kind of ontologies. The focus has been on defects regarding the is-a structure of the taxonomies. In this paper we tackle the problem of repairing the is-a structure of ontologies that can be represented using acyclic terminologies.

In addition to its importance for the correct modeling of a domain, the structural information in ontologies is also important in semantically-enabled applications. For instance, the is-a structure is used in ontology-based search and annotation. In ontology-based search, queries are refined and expanded by moving up and down the hierarchy of concepts. Incomplete structure in ontologies influences the quality of the search results. As an example, suppose we want to find articles in the MeSH (Medical Subject Headings [25], controlled vocabulary of the National Library of Medicine, US) Database of PubMed [27] using the term Scleral Diseases in MeSH. By default the query will follow the hierarchy of MeSH and include more specific terms for searching, such as Scleritis. If the relation between Scleral Diseases and Scleritis is missing in MeSH, we will miss 738 articles in the search result, which is about 55% of the original result. The structural information is also important information in ontology engineering research. For instance, most current ontology alignment systems use structure-based strategies to find mappings between the terms in different ontologies (e.g. overview in [21]) and the modeling defects in the structure of the ontologies have an important influence on the quality of the ontology alignment results.

Debugging modeling defects in ontologies consists of two phases, detection and repair. There are different ways to detect missing is-a relations. One way is by inspection of the ontologies by domain experts. Another way is to use external knowledge sources. For instance, there is much work on finding relationships between terms in the ontology learning area [3]. In this setting, new ontology elements are derived from text using knowledge acquisition techniques. Regarding the detection of is-a relations, one paradigm is based on linguistics using lexico-syntactic patterns. The pioneering research conducted in this line is in [11]

, which defines a set of patterns indicating is-a relationships between words in the text. Another paradigm is based on machine learning and statistical methods. Further, guidelines based on logical patterns can be used

[5]. When the ontology is part of a network of ontologies connected by mappings between the ontologies, knowledge inherent in the ontology network can be used to detect missing is-a relations using logical derivation [2, 20, 19]. However, although there are many approaches to detect missing is-a relations, these approaches, in general, do not detect all missing is-a relations. For instance, although the precision for the linguistics-based approaches is high, their recall is usually very low.

In this paper we assume that the detection phase has been performed. We assume that we have obtained a set of missing is-a relations for a given ontology and focus on the repairing phase. In the case where our set of missing is-a relations contains all missing is-a relations, the repairing phase is easy. We just add all missing is-a relations to the ontology and a reasoner can compute all logical consequences. However, when the set of missing is-a relations does not contain all missing is-a relations - and this is the common case - there are different ways to repair the ontology. The easiest way is still to just add the missing is-a relations to the ontology. For instance, Figure 1 shows a small part of a pizza ontology based on [26], that is relevant for our discussions. Assume that we have detected that MyPizza FishyMeatyPizza and MyFruttiDiMare NonVegetarianPizza are missing is-a relations. Obviously, adding MyPizza FishyMeatyPizza and MyFruttiDiMare NonVegetarianPizza to the ontology will repair the missing is-a structure. However, there are other more interesting possibilities. For instance, adding AnchoviesTopping FishTopping and ParmaHamTopping MeatTopping will also repair the missing is-a structure. Another more informative way111This is more informative in the sense that the former is derivable from the latter. Adding ParmaHamTopping HamTopping, also allows to derive ParmaHamTopping MeatTopping as the ontology already includes HamTopping MeatTopping. to repair the missing is-a structure is to add AnchoviesTopping FishTopping and ParmaHamTopping HamTopping. Essentially, these other possibilities to repair the ontology include missing is-a relations (e.g. AnchoviesTopping FishTopping) that were not originally detected by the detection algorithm.222Therefore, the approach discussed in this paper can also be seen as a detection method that takes already found missing is-a relations as input. We also note that from a logical point of view, adding AnchoviesTopping MeatTopping and ParmaHamTopping FishTopping also repairs the missing is-a structure. However, from the point of view of the domain, this solution is not correct. Therefore, as it is the case for all approaches for debugging modeling defects, a domain expert needs to validate the logical solutions.

The contributions of this paper are threefold. First, we show that the problem of finding possible ways to repair the missing is-a structure in an ontology in general can be formalized as a generalized version of the TBox abduction problem (Section 3). Second, we propose an algorithm to generate different ways to repair the missing is-a structure in ontologies that can be represented using acyclic terminologies (Section 4). Third, we discuss a system that allows a domain expert to repair the missing is-a structure in Section 5. We discuss the functionality and user interface of the repairing system and show an example run. Further, we discuss related work in Section 6 and conclude in Section 7. We continue, however, with some necessary preliminaries in Section 2.


Pizza
PizzaTopping
hasTopping

AnchoviesTopping PizzaTopping

MeatTopping PizzaTopping

HamTopping MeatTopping

ParmaHamTopping PizzaTopping

FishTopping PizzaTopping MeatTopping

TomatoTopping PizzaTopping MeatTopping FishTopping

GarlicTopping PizzaTopping MeatTopping FishTopping

MyPizza Pizza hasTopping.AnchoviesTopping hasTopping.ParmaHamTopping

FishyMeatyPizza Pizza hasTopping.FishTopping hasTopping.MeatTopping

MyFruttiDiMare Pizza hasTopping.AnchoviesTopping
                    hasTopping.GarlicTopping hasTopping.TomatoTopping
                    hasTopping.(AnchoviesTopping GarlicTopping TomatoTopping)

VegetarianPizza Pizza hasTopping.FishTopping hasTopping.MeatTopping

NonVegetarianPizza Pizza VegetarianPizza

Figure 1: A pizza ontology.

AnchoviesTopping PizzaTopping

MeatTopping PizzaTopping

HamTopping MeatTopping

ParmaHamTopping PizzaTopping

FishTopping PizzaTopping MeatTopping

TomatoTopping PizzaTopping MeatTopping FishTopping

GarlicTopping PizzaTopping MeatTopping FishTopping


MyPizza Pizza hasTopping.AnchoviesTopping hasTopping.ParmaHamTopping

FishyMeatyPizza Pizza hasTopping.FishTopping hasTopping.MeatTopping

MyFruttiDiMare Pizza hasTopping.AnchoviesTopping
                    hasTopping.GarlicTopping hasTopping.TomatoTopping
                    hasTopping.(AnchoviesTopping GarlicTopping TomatoTopping)

VegetarianPizza Pizza hasTopping.FishTopping hasTopping.MeatTopping

NonVegetarianPizza Pizza VegetarianPizza

Figure 2: A pizza ontology - Acyclic terminology.

2 Preliminaries

In this paper we deal with ontologies represented in the description logic with acyclic terminologies (e.g. [1]). Concept descriptions are defined using constructors as well as concept and role names. As constructors allows concept conjunction (C D), disjunction (C D), negation ( C), universal quantification ( r.C) and existential quantification ( r.C).333C and D represent concepts, and r represents a role. In this paper we consider ontologies that can be represented by a TBox that is an acyclic terminology. An acyclic terminology is a finite set of concept definitions (i.e. terminological axioms of the form where is a concept name) that neither contains multiple definitions nor cyclic definitions.444We observe that the TBox in Figure 1 is not an acyclic terminology as there are statements of the form . However, it is possible to create an equivalent TBox that is a acyclic terminology by replacing the statements of the form with where is new atomic concept. See Figure 2. An ABox contains assertional knowledge, i.e. statements about the membership of individuals (interpreted as elements in the domain) to concepts (C(i)) as well as relations between individuals (r(i,j)).555i and j represent individuals. In the completion graph in Section 4 statements of the form C(i) are written as , and statements of the form r(i,j) are written as . A knowledge base contains a TBox and an ABox. A model of the TBox/ABox/knowledge base satisfies all axioms of the TBox/ABox/knowledge base. A knowledge base is consistent if it does not contain contradictions.

An important reasoning service is the checking of (un)satisfilibility of concepts (a concept is unsatisfiable if it is necessarily interpreted as the empty set in all models of the TBox/ABox/knowledge base, satisfiable otherwise). A TBox is incoherent if it contains an unsatisfiable concept.

Checking satisfiability of concepts in can be done using a tableau-based algorithm (e.g. [1]). To test whether a concept C is satisfiable such an algorithm starts with an ABox containing the statement C(x) where x is a new individual and it is usually assumed that C is normalized to negation normal form. It then applies consistency-preserving transformation rules to the ABox (Figure 3). The -, - and -rules extend the ABox while the -rule creates multiple ABoxes. The algorithm continues applying these transformation rules to the ABoxes until no more rules apply. This process is called completion and if one of the final ABoxes does not contain a contradiction (we say that it is open), then satisfiability is proven, otherwise unsatisfiability is proven. One way of implementing this approach is through completion graphs which are directed graphs in which every node represents an ABox. Application of the -rule produces new nodes with one statement each, while the other rules add statements to the node on which the rule is applied. The ABox for a node contains all the statements of the node as well as the statements of the nodes on the path to the root. Satisfiability is proven if at least one of the ABoxes connected to a leaf node does not contain a contradiction, otherwise unsatisfiability is proven.

In this paper we assume that an ontology O is represented by a knowledge base containing a TBox that is an acyclic terminology and an empty ABox. In this case reasoning can be reduced to reasoning without the TBox by unfolding the definitions. However, for efficiency reasons, instead of running the previously described satisfiability checking algorithm on an unfolded concept description, the unfolding is usually performed on demand within the satisifiability checking algorithm. It has been proven that satisfiability checking w.r.t. acyclic terminologies is PSPACE-complete in [23].

-rule: if the ABox contains (C C)(x), but it does not contain both C(x) and C(x),
              then these are added to the ABox.
-rule: if the ABox contains (C C)(x), but it contains neither C(x) nor C(x),
              then two ABoxes are created representing the two choices of adding C(x) or adding C(x).
-rule: if the ABox contains ( r.C)(x) and r(x,y), but it does not contain C(y),
              then this is added to the ABox.
-rule: if the ABox contains ( r.C)(x) but there is no individual z such that r(x,z) and C(z) are in the ABox,
              then r(x,y) and C(y) with y an individual name not occurring in the ABox, are added.
Figure 3: Transformation rules (e.g. [1]).

3 An abduction problem

In our setting, a missing is-a relation in an ontology O represented by a knowledge base KB, is an is-a relation between named concepts that is not derivable from the KB, but that is correct according to the intended domain. We assume that we have a set M of missing is-a relations (but not necessarily all) for O. Then, the is-a structure of O can be repaired by adding is-a relations (or axioms of the form C D) between named concepts to O such that the missing is-a relations can be derived from the repaired ontology. This repair problem can be formulated as a generalized version of the TBox abduction problem.

Definition 1

Let KB be a knowledge base in , and for 1 i m: C, D are concepts that are satisfiable w.r.t. KB, such that KB { C D 1 i m} is coherent. A solution to the generalized TBox abduction problem for (KB, {(C, D) 1 i m}) is any finite set S = {G H j n} of TBox assertions in such that i: KB S C D. The set of all such solutions is denoted by S(KB, {(C, D ) 1 i m}).

In our setting the language is and only allows named concepts. We say that any solution in S(KB, {(C, D)}) is a repairing action. A repairing action is thus a set of is-a relations. When m = 1, this definition of the generalized TBox abduction problem coincides with the TBox abduction problem as formulated in [8], which therefore deals with repairing one missing is-a relation. Further, we have that S(KB, {(C, D)}) = S(KB, {(C, D)}).666A solution for all missing is-a relations is also a solution for each missing is-a relation and therefore, in the intersection of the solutions concerning one missing is-a relation at the time. Further, a solution in the intersection of the sets of solutions for each of the missing is-a relations, allows, when added to the knowledge base, to derive all missing is-a relations, and is therefore, a solution for the generalized TBox abduction problem as well.
This shows that solving a generalized TBox abduction problem can be done by solving m TBox abduction problems and then taking the intersection of the solutions. In practice, however, this leads to a number of difficulties. First, it would mean that a domain expert will need to choose between large sets of repairing actions for all the missing is-a relations at once, and this may be a very hard task. Further, due to the size of the solution space, even generating all solutions for one TBox abduction problem is, in general, infeasible. Also, many of the solutions will not be interesting for a domain expert (e.g. [20]). For instance, there may be solutions containing is-a relations that do not contribute to the actual repairing. Some solutions may introduce unintended equivalence relations.

A common way to limit the number of possible solutions is to introduce constraints, e.g. minimality. Our proposed algorithm generates solutions to a TBox abduction problem that are minimal in the sense that repairing actions only contain necessary information for repairing the missing is-a relations. Further, we check the generated solutions for the introduction of incoherence.

4 Algorithm for generating repairing actions

Input: The ontology O represented by knowledge base KB and a set of missing is-a relations M.
Output: Set of repairing actions .
Algorithm
1. For every missing is-a relation in M:
      1.1 completion graph after running a tableaux algorithm with as input on KB;
      1.2 Leaf-ABoxes = get ABoxes of the leaves from the completion graph ;
      1.3 For every open ABox Leaf-ABoxes:
          1.3.1 ;
          1.3.2 For every individual in ;
              1.3.2.1 is a named concept};
              1.3.2.2 is a named concept};
              1.3.2.3 = ;
      1.4 ;
      1.5 As long as there are different choices:
          1.5.1 Create a repairing action by choosing one element from each set ;
          1.5.2 = { };
          1.5.3 Remove reduncancy in ;
          1.5.4 Remove incoherent solutions from ;
2. = { M };
3. As long as there are different choices:
      3.1 Create a repairing action by choosing one element from each
           and taking the union of these elements;
      3.2 = { rp };
4. Remove reduncancy in ;
5. Remove incoherent solutions from ;
Figure 4: Basic algorithm for generating repairing actions using completion graph.

4.1 Basic algorithm

The basic algorithm for generating repairing actions for a set of given missing is-a relations for an ontology is shown in Figure 4. In this first study we assume that the existing structure in the ontology is correct. Also, as stated in the definition in Section 3, adding the missing is-a relations to the ontology does not lead to incoherence.

In step 1 a set of repairing actions is generated for each missing is-a relation (thereby solving a TBox abduction problem for each missing is-a relation). In step 1.1 we run the satisfiability checking algorithm with unfolding on demand as described in Section 2, on KB with input , and we collect the ABoxes of the leaves in step 1.2. As is a missing is-a relation, it cannot be derived from KB and thus the completion graph will have open leaf ABoxes. We then generate different ways to close these ABoxes in step 1.3. For each individual in an open leaf ABox we collect the concepts in the statements of the form : in and the concepts in the statements of the form : in where and are named concepts. The ABox can be closed if is added to the ontology for any and . Indeed, with this extra information : could be unfolded and : would be added to the ABox, and this gives a contradiction with : which was already in the ABox. A repairing action for the missing is-a relation is then a set of that closes each open leaf ABox. In step 1.5 we generate such sets by selecting one such axiom per open leaf ABox and remove redundancy based on the sub-set relation. If a repairing action is a super-set of another repairing action, it is removed. Further, we remove solutions that introduce incoherence.

In step 2 the repairing actions set for all missing is-a relations is initialized with the set of missing is-a relations. Therefore, there will always be at least one repairing action. In step 3 additional repairing actions are generated by combining repairing actions for the individual missing is-a relations. As repairing actions are sets, there are no duplicates in a repairing action. In step 4 we remove redundancy based on the sub-set relation. In step 5 we remove solutions that introduce incoherence. We note that there always will be at least one solution that does not introduce incoherence (i.e. M or a sub-set of M).

As an example, consider the acyclic terminology in Figure 2 equivalent to the ontology in Figure 1 and M = {MyPizza FishyMeatyPizza, MyFruttiDiMare NonVegetarianPizza}. For the missing is-a relation MyPizza FishyMeatyPizza the completion graph obtained after running the satisfiability check on is shown in Figure 13. The completion graph contains 17 nodes of which 11 are leaf nodes. Of these leaf nodes 6 are closed and the repairing actions will be based on the 5 open leaf nodes. The computation of the , and for the leaf ABoxes is given in Figure 14. Closing all open leaf ABoxes will lead to 11 non-redundant repairing actions (see Figure 5) of which 8 lead to incoherence (marked by * in Figure 5). The remaining repairing actions are {MyPizza FishyMeatyPizza}, {AnchoviesTopping FishTopping, ParmaHamTopping MeatTopping } and {ParmaHamTopping FishTopping, AnchoviesTopping MeatTopping}. Observe that in this example we removed the repairing actions containing a concept of the form . This is because whenever : occurs in an ABox, then also : is in that ABox, as : only can appear by unfolding in :. Therefore, whenever is a choice for repairing, then also is a choice for repairing, and we can ignore the choice, which does not relate to a concept in the original ontology.

{MyPizza FishyMeatyPizza}
{Pizza FishyMeatyPizza}
{AnchoviesTopping FishTopping, AnchoviesTopping MeatTopping}
{PizzaTopping FishTopping, AnchoviesTopping MeatTopping}
{ParmaHamTopping FishTopping, AnchoviesTopping MeatTopping}
{AnchoviesTopping FishTopping, PizzaTopping MeatTopping}
{PizzaTopping FishTopping, PizzaTopping MeatTopping}
{ParmaHamTopping FishTopping, PizzaTopping MeatTopping}
{AnchoviesTopping FishTopping, ParmaHamTopping MeatTopping}
{PizzaTopping FishTopping, ParmaHamTopping MeatTopping}
{ParmaHamTopping FishTopping, ParmaHamTopping MeatTopping}
Figure 5: Non-redundant repairing actions for MyPizza FishyMeatyPizza.

In a similar way, for missing is-a relation MyFruttiDiMare NonVegetarianPizza, we find the following non-redundant coherence-preserving repairing actions: {MyFruttiDiMare NonVegetarianPizza}, {AnchoviesTopping FishTopping} and {AnchoviesTopping MeatTopping}. After combining the repairing actions for the individual missing is-a relations, and removing redundancy and incoherence-introducing repairing actions, we obtain the following 5 solutions for the repairing of the missing is-a structure: {MyPizza FishyMeatyPizza, MyFruttiDiMare NonVegetarianPizza}, {AnchoviesTopping FishTopping, ParmaHamTopping MeatTopping}, {ParmaHamTopping FishTopping, AnchoviesTopping MeatTopping}, {MyPizza FishyMeatyPizza, AnchoviesTopping FishTopping}, and {MyPizza FishyMeatyPizza, AnchoviesTopping MeatTopping}.

A repairing action is a set of statements of the form with and named concepts. We note that for acyclic terminologies, after adding such a statement, the resulting TBox is not an acyclic terminology anymore. If this is needed, then instead of adding the following should be done. If there is no definition for yet in the TBox, then add with a new atomic concept. If there is already a definition for in the TBox, say then change this definition to . For instance, to add the repairing action {AnchoviesTopping FishTopping, ParmaHamTopping MeatTopping} to the acyclic terminology in Figure 2, we have to change two definitions. AnchoviesTopping PizzaTopping becomes AnchoviesTopping PizzaTopping FishTopping, and ParmaHamTopping PizzaTopping becomes ParmaHamTopping PizzaTopping MeatTopping.

4.2 Solution properties

We prove that the algorithm is correct. In the following and are named concepts.

Lemma 1

If an ABox in the algorithm in Figure 4 contains x: and x: for some individual x, then adding to the ontology will close this ABox.

Proof

Adding to an acyclic terminology can be done in the following way. If there is no definition for yet in the TBox, then add with a new atomic concept. If there is already a definition for in the TBox, say then change this definition to . In both cases it will allow an unfolding step in the ABox for x: such that x: or x: is added to the ABox. A further application of the -rule will then also add x: to the ABox. This leads to a contradiction with x: and closes the ABox.

Lemma 2

Let G be the completion graph after running the tableaux algorithm with as input on KB. Let G be the completion graph when running the tableaux algorithm with as input on KB, the knowledge base for the extended ontology where (i) a statement is added, or (ii) a statement is changed to . Then for every open leaf ABox in G, there is a corresponding open leaf ABox in G such that .

Proof

We observe that the statements that are valid in the original ontology are still valid in the extended ontology. Also, all transformation rules that could be applied in the tableaux algorithm on the original ontology can also be applied on the extended ontology. Further, additionally, for the extended ontology, there may be an unfolding based on the extension (i.e. when x: appears in an ABox, then by unfolding x: (and in case (i) also x:) should be added), as well as additional applications of transformation rules based on x: and its consequences. Therefore, assume that is an open leaf ABox in G. Then will contain statements that are a result of transformations that could have been peformed in the original ontology as well as statements that can only be derived based on x:.

In order to identify which statements in belong to which of these two categories, we built a dependency graph DG = (V, E) where the vertices represent statements from , and there is an edge from node related to statement to node related to statement if could be a direct result of applying some transformation rule or unfolding on . We label the edges with , , (from a node related to x:r.D to a node related to xry), (from a node related to x:r.D to a node related to y:D), (from a node related to xry to a node related to y:C), (from a node related to x:r.C to a node related to y:C) and depending on which transformation rule was applied.

Further, we tag the nodes in the dependency graph using and . When the tagging is finished, the statements related to the nodes tagged with are a result of transformations that could have been performed in the original ontology. The algorithm for tagging nodes is given in Figure 7. Initially, the node related to x: is tagged with . Further, for case (i) all nodes related to z: and z:B for some individual z are tagged with and this tag can never be changed777 does not occur in the original ontology and thus these statements are not included in any ABox related to the original ontology.; All other nodes are initially tagged with and collected in the set -nodes. We then traverse the dependency graph and change tags into tags according to a number of rules. Essentially, the tagging simulates the construction of a completion graph (step 4) by first using , , and unfolding rules until no more such rules are applicable (essentially an ABox in the completion graph). This is achieved in step 4.1. by applying the tagging rules 1-5 in Figure 6. For case (ii) we need to deal with a special case when unfolding x:A (step 4.1.2). When no more such rules can be applied, but a -rule could be applied, a choice is made and the procedure is repeated (essentially a child ABox in the completion graph is created and then if needed, further descendant ABoxes). This is achieved by using tagging rules 6 and 7 in Figure 6 in step 4.4. Step 4 finishes when all nodes have tags or no more tagging rules can be applied to nodes with tags.

A node tagged with changes its tag to if:
1. node has an incoming edge from a -tagged node
2. node has an incoming edge from a -tagged node
3. node has an incoming edge from a -tagged node
4. node has an incoming edge from a -tagged node
5. node has an incoming edge from a -tagged node
        and an incoming edge from a -tagged node
6. node has an incoming edge from a -tagged node
        and all other nodes with an incoming edge from are tagged with
7. node has an incoming edge from a -tagged node
        and there are no other nodes with an incoming edge from
Figure 6: Tagging rules.
Input: The initial dependency graph .
Output: Tagged dependency graph.
Algorithm
1. Tag the node related to x: with .
1(i). Only for case (i): Tag all nodes related to z: and z:B for some indivdual z with ;
2. Tag all remaining nodes with and add them to the set -nodes;
3. := ;
4. While -nodes and -nodes , do:
      4.1 While -nodes and -nodes , do:
           4.1.1 Select a node -nodes and add to ;
           4.1.2 If is related to x:BC for some x
                and rule 1 is applicable for unfolding a -tagged node related to x:A (only case (ii)
                then
                4.1.2.1 If there is no node related to x:C
                     then
                     4.1.2.1.1 Add a new node related to x:C and connect it with outgoing -edges to
                     all nodes that are connected with incoming -edges to the node related to x:BC,
                     except the node x:B;
                4.1.2.2 Tag the node related to x:C with ;
                else
                4.1.2.1’ If any of the tagging rules 1-5 in Figure 7 is applicable,
                    then
                     4.1.2.1’.1 Change the tag of to ;
                     4.1.2.1’.2 Remove from -nodes;
                     4.1.2.1’.3 := ;


      4.2 := ;
      4.3 -- := true;
      4.4 While -nodes and -nodes and -- = true, do:
           4.4.1 Select a node -nodes and add to ;
           4.4.2 If tagging rule 6 or 7 in Figure 7 is applicable,
                then
                4.4.2.1 Change the tag of to ;
                4.4.2.2 Remove from -nodes;
                4.4.2.3 := ;
                4.4.2.3 -- := false;

5. Return the tagged graph;

Figure 7: Algorithm for tagging the dependency graph.

We now show that the set of statements related to -tagged nodes is an open leaf ABox in G (with possible renaming of individuals). It is clear that . Further, contains statements that can be derived by running the tableaux algorithm on the original ontology with as input. (Without loss of generality, individuals may be renamed.) The dependency graph shows which transformation rules and unfoldings can be performed. is also a leaf ABox in the completion graph obtained by running the tableaux algorithm on the original ontology with as input. If were not a leaf ABox in that completion graph, then there would be other statements that could be added through the application of the transformation rules or unfolding. However, in that case, these transformation rules or unfoldings could also be applied to and these statements could be added to , which would contradict the fact that is a leaf ABox. Finally, as and as does not contain a contradiction (as it is an open leaf ABox in G), also does not contain a contradiction.

Consider the example ontology in Figure 8(a) and assume we run the tableaux algorithm with input x:A F. The completion graph is given in Figure 9(a). Figure 9(b) shows a completion graph for running the tableaux algorithm with input A F on the ontology that extends the original ontology with the axiom A B (Figure 8(b)). The completion graph G contains two open leaf ABoxes, ABox 1.2.1 and ABox 1.2.2. We observe that ABox 1.2.1 in Figure 9(b) contains all literals from ABox 1.1 in Figure 9(a) and ABox 1.2.2 in Figure 9(b) contains all literals from ABox 1.2 in Figure 9(a).

Figure 10(a) shows an initial dependency graph for ABox 1.2.1. In this example all but x:A F can be the direct result of the application of a transformation rule or unfolding of only one other statement. In general this is not case, though. Initially, the node related to (1) is tagged as . All other nodes are tagged with , and the tag of the nodes related to (3) and (5) cannot be changed. In the first iteration the tags of the nodes related to (2), (9) and (10) will be changed to using the tagging rules 1 and 2. Further, the tag for the node related to (14) is changed to using tagging rule 7. Then, there will be no more changes in the tagging and the statements related to the nodes with tags in Figure 10(b) constitute the statements in ABox 1.1. in Figure 9(a).

B C (D E)
D F
F G H
(a) Original ontology.
B C (D E)
D F
F G H
A B
(b) Extended ontology.
Figure 8: Ontology - original and extended.
(a) Completion graph after running the tableaux algorithm with input A F on the original ontology in Figure 8(a).
(b) Completion graph after running the tableaux algorithm with input A F on the extended ontology in Figure 8(b).
Figure 9: Completion graphs
(a) Initial dependency graph for ABox 1.2.1. in Figure 9(b).
(b) Tagged dependency graph for ABox 1.2.1. in Figure 9(b).
Figure 10: Dependency graphs.

The previous lemma also holds when adding sets of axioms of the form (i) or changing a sets of axioms (ii) of the form to axioms of the form .

Lemma 3

Let G be the completion graph after running the tableaux algorithm with as input on KB. Let G be the completion graph when running the tableaux algorithm with as input on KB, the knowledge base for the extended ontology where (i) statements of the form are added, or (ii) statements of the form are changed to . Then for every open leaf ABox in G, there is a corresponding open leaf ABox in G such that .

Proof

Let = {, ,} be the changes to the original ontology, i.e. represents either an addition of an axiom of the form or a change of an axiom of the form to an axiom of the form .

For any possible order , , of the elements in , let = {, ,} be the set of the first k changes according to the chosen order. Let KB be the knowledge base for the ontology that is constructed by applying the changes in to the original ontology. We note that for k = n there is only one possible set of changes, i.e. = and KB = KB.

According to the previous lemma, we then know that for any open leaf ABox in the completion graph obtained by running the tableaux algorithm with as input on KB with k n, there is an open leaf ABox in the completion graph obtained by running the tableaux algorithm with as input on KB, such that the latter is contained in the former.

Therefore, for every open leaf ABox in G, there is a chain of open leaf ABoxes , , , , such that is an open leaf ABox in the completion graph obtained by running the tableaux algorithm with as input on KB, is an open leaf ABox in G, and , , .

Lemma 4

Any element of repairs the missing is-a relation .

Proof

Let { , , } . Let KB be the knowledge base of the original ontology. Then, we want to prove that can be derived from the knowledge base of the ontology extended with { , , }.

Adding { , , } to an ontology means adding statements of the form with a new atomic concept or changing statements of the form to . Assume G and G are the completion graphs obtained by running the tableaux algorithm with as input on the knowledge bases of the original (with added missing is-a relations except ) and the extended ontology respectively.

We now prove that every leaf ABox in G is closed. Let us assume that there exists an open ABox in G. According to the previous lemma, we know then that for there is a corresponding leaf ABox in G such that . Further, there is at least one individual and named concepts and such that : and : are statements in the ABox 888If the ABox is open then there must be at least one such situation. For instance, we know that : and : are in the ABox .. collects all possible is-a relations between such pairs and . In the algorithm one such pair is chosen to be added to the ontology. Therefore, there is an individual and named concepts and such that : and : are statements in , and such that was added to the ontology. By lemma 1 is then closed which contradicts with our assumption. This shows that all leaf ABoxes are closed and thus can be derived from the knowledge base of the ontology extended with { , , }.

Theorem 1

Any element of repairs the missing is-a relations in .

Proof

The previous lemma guarantees that adding any element from to KB allows us to derive . Therefore, adding one element from each to KB guarantees that each missing is-a relation is derivable.

The proposed algorithm returns minimal solutions for every missing is-relation. In our setting a solution is minimal if it contains only necessary information for repairing a missing is-a relation.

Definition 2

Let KB be a knowledge base representing ontology O and a missing is-a relation. A repairing action is said to be minimal if it holds that and there is no such that .

Theorem 2

The basic algorithm for generating repairing actions for missing is-a relations in Figure 4 produces minimal repairing actions according to the Definition 2 for each missing is-a relation in the set M.

Proof

Trivial. This kind of redundancy is removed in step 1.5.3 and step 4.

4.3 Optimization

The basic algorithm may produce many redundant solutions already in step 1. For instance, if the root node in the completion graph contains : and : with and named concepts, then appears in every open leaf ABox as a possible way of closing that ABox. To deal with this issue we modify the algorithm such that at each node with an open ABox it generates and . However, and only contain the concepts that are not already in a and related to an ancestor node. For instance, if is related to the root node, then will not appear in any related to another node. For each ABox we then generate a set = { P N } where P for the current node or any ancestor node, N for the current node or any ancestor node, and at least one of P and N occurs in the current node. This allows us to reduce the redundancy in step 1. An open leaf ABox can now be closed by using an element from from the leaf node or from any ancestor node. When generating repairing actions in step 1.5 we then make sure that when an element related to a non-leaf node is chosen, that no additional element from any descendant of that node is selected. For instance, if any element from the root’s is chosen, then no other elements should be chosen.

As an example, let us reconsider the computation of the repairing actions related to MyPizza FishyMeatyPizza for the acyclic terminology in Figure 2. In the optimized version of the algorithm, we compute , and for every open ABox (see Figure 15). The root ABox (ABox 1 in Figure 13) has statements of the forms : and : and we thus create Pos = {MyPizza, Pizza}, Neg = {FishyMeatyPizza}, Pos = {AnchoviesTopping, , PizzaTopping}, Neg = , Pos = {ParmaHamTopping, , PizzaTopping}, Neg = . This leads to = {MyPizza FishyMeatyPizza, Pizza FishyMeatyPizza} for ABox 1. We also know now that any element of the will close all leaf nodes. For Abox 1.2 the new statements of the form : and : (i.e. not occurring in an ancestor) are :FishTopping and :FishTopping. Therefore, we create Pos = , Neg = , Pos = , Neg = {FishTopping}, Pos = , Neg = {FishTopping} for Abox 1.2. for Abox 1.2 contains the new ways to close this ABox (i.e. ways not occurring in ancestor nodes) and contains AnchoviesTopping FishTopping, PizzaTopping FishTopping, and ParmaHamTopping FishTopping. We now know that any of these will close all leaf ABoxes of Abox 1.2. After all are computed for all open ABoxes, a leaf node can be closed using an element from its or any related to an ancestor node. For instance, ABox 1.2.2.2 can be closed using any element from , , and . When creating repairing actions we then make sure that when an element related to a non-leaf node is chosen, that no additional element from any descendant of that node is selected to close any leaf ABoxes that are descendants of that non-leaf node. For instance, if AnchoviesTopping FishTopping related to ABox 1.2 is chosen, then no additional element is chosen to close any leaf ABoxes that are descendants of Abox 1.2.

4.4 Extension

The algorithm can be extended to generate additional repairing actions for every individual missing is-a relation. In step 1.5 if is used as one of the is-a relations in a repairing action then also where is a super-concept of and is a sub-concept of could be used. Therefore, the extended algorithm generates two sets of concepts for every is-a relation in a repairing action, Source set containing named super-concepts of and Target set containing named sub-concepts of . Further, to not introduce non-validated equivalence relations where in the original ontology there are only is-a relations, we remove the super-concepts of from Source, and the sub-concepts of from Target.

Alternative repairing actions for a repairing action { , , } are then repairing actions { , , } such that . This extension allows the algorithm to produce more informative repairing actions.

Next, we prove the correctness of the proposed extension.

Theorem 3

If a missing is-a relation is repaired by a repairing action then will also be repaired by .

Proof

Let KB be the knowledge base of the original ontology. As , is a repairing action for , we know that KB , .

To prove that is repaired by , we need to show that can be derived from the knowledge base of the extended ontoloy KB .

As , we know that KB . Further as , we know that KB . Therefore, KB , and therefore, KB .

This shows that KB entails all statements that KB , entails and thus also .

As an example, consider the repairing action {AnchoviesTopping FishTopping, ParmaHamTopping MeatTopping} for the missing is-a relations M = {MyPizza FishyMeatyPizza, MyFruttiDiMare NonVegetarianPizza} for the ontology in Figure 2, as computed using the basic algorithm. The Source set for AnchoviesTopping FishTopping contains all named super-concepts of AnchoviesTopping that are not super-concepts of FishTopping, i.e. {AnchoviesTopping, PizzaTopping} {FishTopping, PizzaTopping} = {AnchoviesTopping}. The Target set for AnchoviesTopping FishTopping contains all named sub-concepts of FishTopping that are not sub-concepts of AnchoviesTopping, i.e. {FishTopping} {AnchoviesTopping} = {FishTopping}. For ParmaHamTopping MeatTopping the Source set is {ParmaHamTopping, PizzaTopping} {MeatTopping, PizzaTopping} = {ParmaHamTopping}, and the Target set is {MeatTopping, HamTopping} {ParmaHamTopping} = {MeatTopping, HamTopping}. In this small example, using Source and Target sets, we would obtain one additional repairing action {AnchoviesTopping FishTopping, ParmaHamTopping HamTopping}.

5 Implementation

Figure 11: Screenshot - Validating is-a relations in a repairing action.
Figure 12: Screenshot - Repairing using Source and Target sets.

We have implemented a system that supports the user to repair missing is-a relations. In our system the user loads the ontology and the missing is-a relations from the ’File’ menu. The missing is-a relations are then shown in a drop-down list (e.g. MyPizza FishyMeatyPizza999In the system C D is shown as C D. in the second drop-down list in Figure 11). The user then chooses a missing is-a relation to repair.101010As we repair one is-a relation at a time, there may be some redundancy in the solutions. At any time the user can switch between different missing is-a relations. Once a missing is-a relation is chosen for repairing the user generates repairing actions for it by clicking the ’Generate Repairing Actions’ button. This covers step 1 in Figure 4 and was implemented in Java using Pellet (version 2.3.0) [31]. The satisfiability checker in Pellet was modified in order to extract full completion graphs. Furthermore, to increase performance and account for higher level of non-determinism, ontologies are first passed through Pellint [22] before running the algorithm. The computed repairing actions are shown in the drop-down list under the button. Each repairing action consists of one or more is-a relations. In Figure 11 the user has chosen to repair MyPizza FishyMeatyPizza and the system has generated three repairing actions that do not introduce incoherence ({MyPizza FishyMeatyPizza}, {AnchoviesTopping FishTopping, ParmaHamTopping MeatTopping}, and {AnchoviesTopping MeatTopping, ParmaHamTopping FishTopping}). To repair this missing is-a relation the user has to succesfully deal with at least one of the repairing actions, i.e. add all is-a relations (or more informative is-a relations from Source and Target) in at least one of the repairing actions to the ontology. In Figure 11 the user has chosen the second repairing action. When repairing actions are added to the ontology, they will make the missing is-a relation derivable. However, it is not guaranteed that all the is-a relations in the repairing actions are also valid with respect to the domain. Therefore, a domain expert needs to validate the is-a relations in the repairing actions. When the user clicks the ’Validate is-a Relations in Repairing Action’ button, a pop-up window (Figure 11) appears where the user can mark all the is-a relations that are correct with respect to the domain model. The repairing actions for all missing is-a relations and the ontology are updated according to the results of the validation. If an is-a relation is validated as incorrect according to the domain, all repairing actions that contain this incorrect is-a relation, for this and for all other missing is-a relations, are removed from the lists of the repairing actions. When an is-a relation is validated as correct it is added to the ontology and it is marked as correct in all repairing actions for all missing is-a relations. When all is-a relations in the current repairing action are validated as correct, they are shown in the last drop-down list (Figure 12). Now the user can repair them one by one.

For each is-a relation within the repairing action the Source and Target sets are generated and displayed on the left and the right hand sides, respectively, within the panel under the drop-down lists (Figure 12). Both panels have zoom control and can be opened in a separate window. The concepts in the is-a relation under consideration are highlighted in red, existing asserted and inferred is-a relations are shown in grey, not yet repaired missing is-a relations in blue and is-a relations that were previously added for repairing missing is-a relations in black. In order to repair the is-a relation the user has to choose one concept from each of the sets and click the ’Repair’ button. In Figure 12 the user has chosen to repair ParmaHamTopping MeatTopping with ParmaHamTopping HamTopping. Upon repair the ontology is updated, i.e. the chosen is-a relation (ParmaHamTopping HamTopping) is added to the ontology. A red label next to the drop-down list shows the status (Repaired or Not Repaired) of the selected is-a relation. When all is-a relations within a repairing action are repaired the missing is-a relation is marked as repaired (’This relation is already repaired’ label in Figure 12). The other repairing actions are still available for review by the user. These may give information about other possible missing is-a relations. The user can also revoke repairing actions (through the ’Revoke Repairing Actions’ button). If the user revokes the repairing action, the missing is-a relation may become not repaired again and the is-a relations within the repairing action are marked as not repaired. All changes in the ontology are revoked and the user can start repairing this missing is-a relation again in the way just described.

5.0.1 Example run

As an example run, consider the ontology in Figure 1 and missing is-a relations MyPizza FishyMeatyPizza and MyFruttiDiMare NonVegetarianPizza. After loading the ontology and the missing is-a relations, we can choose a missing is-a relation to repair. Assume we choose MyFruttiDiMare NonVegetarianPizza and click the ’Generate Repairing Actions’ button. The system will show three repairing actions in the drop-down list: {MyFruttiDiMare NonVegetarianPizza}, {AnchoviesTopping FishTopping}, and {AnchoviesTopping MeatTopping}. We can choose to deal with AnchoviesTopping MeatTopping and validate this to be incorrect with respect to the domain. In this case all repairing actions containing this is-a relation will be removed. We could then choose AnchoviesTopping FishTopping and validate it to be correct. All is-a relations in this repairing action (i.e. AnchoviesTopping FishTopping) are validated to be correct and thus we can continue with the repair of AnchoviesTopping FishTopping. In this small example the Source set only contains AnchoviesTopping and the Target set only contains FishTopping. Therefore, we click on these concepts and the ’Repair’ button. AnchoviesTopping FishTopping will be marked as repaired and also the missing is-a relation MyFruttiDiMare NonVegetarianPizza will be marked as repaired.

We can then start repairing MyPizza FishyMeatyPizza. The system would have generated as repairing actions that do not introduce incoherence {MyPizza FishyMeatyPizza}, {AnchoviesTopping FishTopping, ParmaHamTopping MeatTopping} and {AnchoviesTopping MeatTopping, ParmaHamTopping FishTopping}. However, as we earlier already validated AnchoviesTopping MeatTopping to be incorrect with respect to the domain, the third repairing action has already been removed. When we choose the second repairing action, AnchoviesTopping FishTopping is already marked as correct (because of earlier validation) and only ParmaHamTopping MeatTopping needs to be validated. We validate this as correct and then choose to repair it. The Source set in this small example contains ParmaHamTopping and the Target set contains HamTopping and MeatTopping. Although we can add ParmaHamTopping MeatTopping, it is more informative (and correct with respect to the domain) to add ParmaHamTopping HamTopping. We therefore choose the latter. All is-a relations in this repairing action are then repaired and thus also MyPizza FishyMeatyPizza.

6 Related work

6.0.1 Debugging ontologies

Detecting missing is-a relations can be done in a number of ways (see Section 1). There is, however, not much work on the repairing of missing is-a structure. In [20] we addressed this in the setting of taxonomies.

There is more work on the debugging of semantic defects. Most of it aims at identifying and removing logical contradictions from an ontology. Standard reasoners are used to identify the existence of a contradiction, and provide support for resolving and eliminating it [9]. In [29] minimal sets of axioms are identified which need to be removed to render an ontology coherent. In [16, 15] strategies are described for repairing unsatisfiable concepts detected by reasoners, explanation of errors, ranking erroneous axioms, and generating repair plans. In [10] the focus is on maintaining the consistency as the ontology evolves through a formalization of the semantics of change for ontologies. In [24] and [13] the setting is extended to repairing ontologies connected by mappings. In this case, semantic defects may be introduced by integrating ontologies. Both works assume that ontologies are more reliable than the mappings and try to remove some of the mappings to restore consistency. The solutions are often based on the computation of minimal unsatisfiability-preserving sets or minimal conflict sets. The work in [28] further characterizes the problem as mapping revision. Using belief revision theory, the authors give an analysis for the logical properties of the revision algorithms. Another approach for debugging mappings is proposed in [32] where the authors focus on the detection of certain kinds of defects and redundancy. The approach in [14] deals with the inconsistencies introduced by the integration of ontologies, and unintended entailments validated by the user.

Work that deals with both modeling and semantic defects includes [5] where the authors propose an approach for detecting modeling and semantic defects within an ontology based on patterns and antipatterns. Some suggestions for repairing are also given. In [19] we provided a method to detect and repair wrong and missing is-a structure in taxonomies connected by mappings.

A different setting is the area of modular ontologies where the ontologies are connected by directional mappings and where knowledge propagation only occurs in one direction. Regarding the detection of semantic defects, within a framework based on distributed description logics, it is possible to restrict the propagation of local inconsistency to the whole set of ontologies (e.g. [30]).

6.0.2 Abductive reasoning in description logics

In [8] four different abductive reasoning tasks are defined - (conditionalized) concept abduction, ABox abduction, TBox abduction and knowledge base abduction. Concept abduction deals with finding sub-concepts. Abox abduction deals with retrieving abductively instances of concepts or roles that, when added to the knowledge base, allow the entailment of a desired ABox assertion. Knowledge base abduction includes both ABox and TBox abduction.

Most existing approaches for DL abduction focus on ABox and concept abduction and are mostly based on existing proof techniques such as semantic tableaux and resolution. Since the number of possible solutions is very large, the approaches introduce constraints. The work in [17]

proposes a goal-oriented approach where only actions which contribute to the solution are chosen in the proof procedures. The method is both complete and sound for consistent and semantically minimal solutions. Since the set of solutions can contain some inconsistent and non-minimal solutions additional checks are required. A practical approach for ABox abduction, based on abductive logic programming, was proposed in

[7]. In order to use existing abductive logic programming systems it is necessary to do a transformation to a plain Datalog program. The solutions are consistent and minimal given a set of abduciles. However, the approach does not guarantee completeness since the translation to a Datalog program is approximate and in some cases a solution would not be found. An approach for conditionalised concept abduction that uses a variation of the semantic tableaux and two labeling functions was proposed in [4]. The two labeling functions and represent true and false formulas in a tableaux where the solutions are formed from concepts which have at least one constraint in F() of every open branch. This choice is non-deterministic and can be used to select solutions based on some criteria. The algorithm also contains a consistency check which implies that produced solutions are always consistent.

There has not been much work related to TBox abduction, which is the most relevant abduction problem for this paper. The work in [12] proposes an automata-based approach to TBox abduction using abduciles representing axioms that can appear in solutions. It is based on a reduction to the axiom pinpointing problem which is then solved with automata-based methods. A PTIME algorithm is proposed for the language .

All of the presented approaches to description logic abduction work with relatively inexpressive ontologies, such as and . However, some recent work [6] describes a type of conditionalised concept abduction called structural abduction which is applicable to .

7 Conclusion

This paper formalized repairing the is-a structure in acyclic terminologies as a generalized TBox abduction problem, provided a solution based on semantic tableaux, and discussed a system.

There are a number of interesting aspects for future work. First, we intend to extend the algorithm to deal with more expressive ontologies. Further, it may be useful to consider also solutions introducing incoherence as they may lead to the detection of other kinds of modeling defects such as wrong is-a relations. In this case we do not assume anymore that the existing structure is correct. As a domain expert may need to deal with many possible solutions, other useful extensions are mechanisms for ranking the generated repairing actions and among those recommending repairing actions, e.g. based on domain knowledge.

References

  • [1] F Baader and U Sattler. An overview of tableau algorithms for description logics. Studia Logica, 69:5–40, 2001.
  • [2] M Bada and L Hunter. Identification of OBO nonalignments and its implication for OBO enrichment. Bioinformatics, 24(12):1448–1455, 2008.
  • [3] Ph Cimiano, P Buitelaar, and B Magnini. Ontology Learning from Text: Methods, Evaluation and Applications. IOS Press, 2005.
  • [4] S Colucci, T Di Noia, E Di Sciascio, F Donini, and M Mongiello. A uniform tableaux-based approach to concept abduction and contraction in ALN. In International Workshop on Description Logics, pages 158–167, 2004.
  • [5] O Corcho, C Roussey, L M Vilches, and I Pérez. Pattern-based owl ontology debugging guidelines. In Workshop on Ontology Patterns, pages 68–82, 2009.
  • [6] F Donini, S Colucci, T Di Noia, and E Di Sciasco. A tableaux-based method for computing least common subsumers for expressive description logics. In

    21st International Joint Conference on Artificial Intelligence

    , pages 739–745, 2009.
  • [7] J Du, G Qiand Y-D Shen, and J Pan. Towards practical abox abduction in large owl dl ontologies. In 25th AAAI Conference on Artificial Intelligence, pages 1160–1165, 2011.
  • [8] C Elsenbroich, O Kutz, and U Sattler. A case for abductive reasoning over ontologies. In OWL: Experiences and Directions, 2006.
  • [9] G Flouris, D Manakanatas, H Kondylakis, D Plexousakis, and G Antoniou. Ontology Change: Classification and Survey. Knowledge Engineering Review, 23(2):117–152, 2008.
  • [10] P Haase and L Stojanovic. Consistent Evolution of OWL Ontologies. In 2nd European Semantic Web Conference, volume 3532 of LNCS, pages 182–197. 2005.
  • [11] M Hearst. Automatic acquisition of hyponyms from large text corpora. In 14th International Conference on Computational Linguistics, pages 539–545, 1992.
  • [12] T Hubauer, S Lamparter, and M Pirker. Automata-based abduction for tractable diagnosis. In International Workshop on Description Logics, pages 360–371, 2010.
  • [13] Q Ji, P Haase, G Qi, P Hitzler, and S Stadtmuller. RaDON - repair and diagnosis in ontology networks. In 6th European Semantic Web Conference, volume 5554 of LNCS, pages 863–867, 2009.
  • [14] E Jimenez-Ruiz, B Cuenca Grau, I Horrocks, and R Berlanga. Ontology Integration Using Mappings: Towards Getting the Right Logical Consequences. In 6th European Semantic Web Conference, volume 5554 of LNCS, pages 173–187, 2009.
  • [15] A Kalyanpur, B Parsia, E Sirin, and B Cuenca-Gray. Repairing Unsatisfiable Concepts in OWL Ontologies. In 3rd European Semantic Web Conference, volume 4011 of LNCS, pages 170–184, 2006.
  • [16] A Kalyanpur, B Parsia, E Sirin, and J Hendler. Debugging Unsatisfiable Classes in OWL Ontologies. Journal of Web Semantics, 3(4):268–293, 2006.
  • [17] S Klarman, U Endriss, and S Schlobach. Abox abduction in the description logic ALC.

    Journal of Automated Reasoning

    , 46:43–80, 2011.
  • [18] P Lambrix, Z Dragisic, and V Ivanova. Get my pizza right: Repairing missing is-a relations in ALC ontologies. In 2nd Joint International Semantic Technology Conference, 2012.
  • [19] P Lambrix and Q Liu. Debugging is-a structure in networked taxonomies. In 4th International Workshop on Semantic Web Applications and Tools for Life Sciences, pages 58–65, 2011.
  • [20] P Lambrix, Q Liu, and H Tan. Repairing the Missing is-a Structure of Ontologies. In 4th Asian Semantic Web Conference, volume 5926 of LNCS, pages 76–90, 2009.
  • [21] P Lambrix, L Strömbäck, and H Tan. Information Integration in Bioinformatics with Ontologies and Standards. In Bry and Maluszynski, editors, Semantic Techniques for the Web: The REWERSE perspective, chapter 8, pages 343–376. Springer, 2009.
  • [22] H Lin and E Sirin. Pellint - a performance lint tool for pellet. In OWL: Experiences and Directions, 2008.
  • [23] C Lutz. Complexity of terminiological reasoning revisited. In 16th International Conference on Logic for Programming and Automated Reasoning, pages 181–200, 1999.
  • [24] C Meilicke, H Stuckenschmidt, and A Tamilin. Repairing Ontology Mappings. In 22th Conference on Artificial Intelligence, pages 1408–1413, 2007.
  • [25] MeSH. Medical subject headings. http://www.nlm.nih.gov/mesh/.
  • [26] Pizza Ontology v1.5. http://www.co-ode.org/ontologies/pizza/2007/02/12/.
  • [27] PubMed. http://www.ncbi.nlm.nih.gov/pubmed/.
  • [28] G Qi, Q Ji, and P Haase. A Conflict-Based Operator for Mapping Revision. In 8th International Semantic Web Conference, volume 5823 of LNCS, pages 521–536, 2009.
  • [29] S Schlobach. Debugging and Semantic Clarification by Pinpointing. In 2nd European Semantic Web Conference, volume 3532 of LNCS, pages 226–240, 2005.
  • [30] L Serafini, A Borgida, and A Tamilin. Aspects of distributed and modular ontology reasoning. In 19th International Joint Conference on Artificial Intelligence, pages 570–575, 2005.
  • [31] E Sirin, B Parsia, B Cuenca Grau, A Kalyanpur, and Y Katz. Pellet: A practical owl-dl reasoner. Journal of Web Semantics, 5(2):151–53, 2007.
  • [32] P Wang and B Xu. Debugging ontology mappings: a static approach. Computing and Informatics, 27:21–36, 2008.