Introduction

Ontologies [17] play an important role in the Semantic Web [2]. The advent of the connectivity and the Web makes an increasing number of ontologies widely available for reuse. As more and more applications use ontology to represent semantic information, how to support ontology reuse [18] is becoming more and more important. In this paper, we assume that ontologies are all written in a standard ontology language, such as the W3C recommendation OWL Web Ontology Language [12], and do not consider the translation of ontological axioms from one ontology language to another.

The basic primitive for in the OWL Web ontology language to support reuse is owl:imports [12], which allows one to "copy-and-paste" an ontology into another one. We call this operation syntactic import, to stress the fact the operation is defined on the set of axioms of an ontology, rather than the knowledge encoded in the ontology itself. The "copy-and-paste" approach provides only limited support for partial ontology reuse, which means importing only a (small) part of the knowledge encoded in an ontology, while ignoring the rest. We illustrate this issue with the following example.

( * ) Thanks to Prof. Fausto Giunchiglia for the discussions on this topic, he has participated to write previous versions of this paper. This work is supported by the FP6 Network of Excellence EU project Knowledge Web (IST-2004-507842).

Example 1. Suppose that we want to build our own ontology for people transportation, let us say W ppl , by reusing other ontology present on the Web, e.g. SUMO [9]. In our ontology, one can use cars and horses as transportation devices; therefore, we would like to impose the following axioms:

sumo:Horse sumo:TransportationDevice (1) sumo:Car sumo:TransportationDevice

Furthermore, we would like to reuse some knowledge which is explicitly stated in or entailed by SUMO:

sumo:Car ∃sumo:capability.(sumo:Transportation)

There are three approaches to reaching the partial ontology reuse through syntactic imports: (i) simply import the whole SUMO ontology into W ppl , and only use some of the axioms, ignoring the others; (ii) only "copy-and-paste" a subset of the SUMO axioms into W ppl ; (iii) divide the SUMO ontology into different modules, based on some criteria, and import only the interesting module. All these approaches present some problems, as discussed below.

For (i), when importing the whole ontology and only using some of its axioms the following drawback can raise. Firstly, inconsistency can easily be reached by importing those conflicting axioms from the source ontology. Secondly, there exist partial disagreements in certain axioms; e.g., we might agree that Horses are quadrupeds and mammals, but we do not agree that they are not transportation devices. Thirdly, scalability could become a problem. This means that intention of reusing only a few objects and/or classes in a source ontology would end up importing the whole ontology.

For (ii), in order to import a subset of the axioms, users have to be carefully identify which set of axioms encodes the knowledge he wants to import; otherwise, it will cause information lost. Sometimes, the structure of the ontology is such that this is not possible. For example, given an ontology containing the axioms A B and B C, a user wants to import only A C without committing on B.

Approach (iii) actually is most promising. The main difficulty of (iii) is that the modularisation of an ontology is far from easily customisable and generalisable to any ontology. A recent approach in this line is the work by Cuenca-Grau et al. [5], which provides the theory and an algorithm for the modularisation of a wide class of ontologies, called safe ontologies.

The main contributions of this paper are as follows. Firstly, it proposes semantic imports, a new mechanism of partial ontology reuse. One distinguished feature of this new partial reuse mechanism is to allow users to semantically reuse vocabulary (classes, properties or individuals), while current approaches allow to reuse axioms. Moreover, semantic imports provide a flexible way to partially reuse ontologies, by allowing users (in their target ontologies) to agree or disagree with some subsumption relationships in a distant ontology. More specifically, in our mechanism all subsumption relations among the semantically imported named classes in the distant ontology are transferred to the target ontology. Secondly, the paper address some logical properties and algorithm of a reasoning problem for a special case in our framework, i.e., semantic imports in simple ontology spaces, where an ontology semantically imports vocabulary from another ontology. Based on the notion of local/non-local classes first proposed by Cuenca-Grau et al. [5] (we call them positive/negative classes), several categories of subsumption relations among class descriptions over the semantically imported vocabulary can be transferred from a distant ontology to a target ontology in simple ontology spaces. Furthermore, it presents a distributed tableaux algorithm to compute class satisfiability in simple ontology spaces, in the presence of semantic import of ALC ontologies.

Ontologies with Imports

An OWL [12] ontology, as defined by the W3C standard, consists of a set of axioms, including class axioms, property axioms and individual axioms. 1 The reader is referred to [12] for details of syntax and semantic of OWL. An OWL ontology can import (other) OWL ontologies, with the help of imports annotations similar to the following. Annotation(imports <http://www.car.org/car#>) Annotation(imports <http://www.xyz.it/vehicle#>) These imports annotations include all the axioms in the two source ontologies into the target ontology.

We extend the notion of ontology by allowing the semantic import of classes, properties, and individuals from source ontologies. To simplify the presentation, in this paper we only consider the abstract domain and leave the discussion of the datatype domain [10] as our future work. They state that horses can be used for transportation (4), that those can be used for transportation are transportation devices (5), that Belgian Draft horses are horses (6), and that Ferrari is a type of car (7), which do not hold in SUMO.

Definition 1 (Ontology). An ontology is a tupleW i = i, M i , S i , O i ,

Intuitively the fact that W ppl semantically imports sumo:Car means that W ppl "demands" the semantics of sumo:Car from SUMO. In other words, an object of the domain of W ppl cannot be a sumo:Car if it is not a sumo:Car in the domain of the SUMO ontology.

It is worth noting that, in the formal definition, a semantic import box is described as a set of classes, properties, and/or individuals. While in practice, this box can be specified either by explicitly listing its components, or, in a more intensional way, by, e.g., including all the sub-classes or all the individuals of some given classes. From the theoretical perspective this is clearly irrelevant, while it is very relevant from the usability point of view.

We end this section by clarifying the expected effects of semantic imports, which are all satisfied by the semantics of semantic imports to be provided in the next section (we assume that 1:A, 1:B, 1:R, 1:o, 1:o2

∈ S 2 ): (i) Propagation of class hierarchy: if W 1 entails 1:A 1:B, then W 2 entails 1:A 1:B. (ii) Propagation of disjoint classes: if W 1 entails 1:A ¬ 1:B, then W 2 entails 1:A ¬ 1:B. (iii)

Property Closure: all the 1:R-successors and 1:R-predecessor of 1:o1 are also imported. (iv) Propagation of (in)equality objects: if W 1 entails 1:o1 ≈ 1:o2 (1:o1 = 1:o2), then W 2 entails 1:o1 ≈ 1:o2 (1:o1 = 1:o2).

Ontology Spaces

In order to give a formal semantics to semantic imports, we briefly introduce some basic notions.

Definition 2 (Local language). Given an ontology W i , a local class w.r.t. W i is a class name in O i associated with the identifier i. Local properties and local individuals are defined analogously. The set of local classes, local properties and local individuals ofW i are denoted by C i , R i and I i . The local language of W i , i.e., L i , is the union of them.

For example, the local language of W ppl is L ppl , which contains the two classes ppl:BelgianDraftHorse and ppl:Ferrari. Now we introduce the concept of ontology spaces, in which we consider not only a single ontology but a set of ontologies. As described in the last section, OWL imports annotations do not guarantee the existence of imported ontologies.

Similarly, the occurrence of an URIrefs in an axiom does not impose requirement of the existence of an ontological resource associated with such a URIref. For instance, the existence of the axiom car:Car abc:ExpensiveGood in the ontology W car does not guarantee the existence of the ontology W abc ; furthermore, even if W abc does exist, this axiom does not guarantee that abc:ExpensiveGood is in L abc . When we consider an ontology space, we impose these requirements.

Definition 3 (Ontology space). Let I be a set of ontology identifiers and j ∈ I an ontology identifier. An ontology space on I is a family of ontologies

S = {W i } i∈I such that (i) for each W i = i, M i , S i , O i , M i ⊆ I, (ii) for each j:x occurring in O i , j:x ∈ S i ,

and (iii) for each j:x ∈ S i , j:x appears in O j , where j ∈ I and j = i.

Note that, given an ontology space {W i } i∈I , the above definition requires that: (i) all the imported ontologies of each ontology exist and are in {W i } i∈I , and (ii) non-local classes, properties and individuals of each ontology in {W i } i∈I should be introduced by some ontologies in {W i } i∈I . For example, S = W sumo , W ppl is an ontology space, where W ppl is defined in Example 2 and W sumo = sumo, M sumo , S sumo , O sumo with M sumo = ∅, S sumo = ∅, (no ontology imports and no semantic import) and with O sumo equal to the set of axioms contained in SUMO.

Based on an ontology space, we introduce the concept of import closure and foreign languages. Intuitively speaking, an import closure of an ontology W i is the set of axioms considering its syntactic imports, while the foreign language of W i is the set of names of classes, properties and individuals in an ontology space that are not in its local language. Definition 4 (Import closure). Given an ontology space S = {W i } i∈I , the import closure of an ontology W i w.r.t. S, written as O S i , is a set of class, property, and individual axioms recursively defined as follows:

1. O i ⊆ O S i ; 2. if j ∈ M i then O S j ⊆ O S i ; 3.

nothing else is in O S

i . Definition 5 (Foreign language). Given an ontology space S = {W i } i∈I , the foreign language of W i w.r.t. S, written as F S i , is the set of classes, properties and individuals of the form j:x (j = i) which occur in S i or in O S i . Intuitively, the semantic for an ontology space is a family of interpretations one for each ontology, such that the axioms of the import closure of each ontology are satisfied, and there is an agreement between the interpretations on the semantics of semantically imported symbols, which will be formally defined below. It should be noted that the interpretation domains of the family of interpretations could be disjoint or overlapping with each other. Definition 6 (Interpretation of an ontology space). Let S = {W i } i∈I be an ontology space on I. An interpretation of S is a family I = {I i } i∈I , where each I i , called the local interpretation of W i , is an interpretation (including hole interpretations) of the local and foreign language of W i , such that It is worth noting the following points: (i) In a local interpretation of W ppl , only symbols in local and foreign languages are considered. That is why local interpretations of W ppl , such as I ppl above, do not have to provide an interpretation mapping for symbols (such as sumo:OrganicObject and sumo:Artifact) that are not in the local or foreign languages of W ppl . (ii) Due to the backward closure, d, t is in (sumo:capability) Ippl . Definition 7 (Logical consequence). Let S = {W i } i∈I be an ontology space on I. An OWL DL axiom α is a logical consequence of S in W j , written S |= j α, iff, for every interpretation I = {I j } j∈I of S, I j |= α.

1. I i |= O S i ; 2. if j:C is a class name in S i , then (j:C) Ii = (j:C) Ij ∩ ∆ Ii ; 3. if j:a is an individual name in S i , then (j:a) I i = (j:a) I j ; 4. if j:

Reasoning in Simple Ontology Spaces

Note that the framework proposed in the previous sections is very general; e.g., there can be an arbitrary (finite) number of ontologies in an ontology space and any ontology involved can semantically vocabulary from any other ontologies in the ontology space. As a first step, in the rest of this paper we only consider a special kind of ontology spaces, called simple ontology spaces. Informally speaking, a simple ontology space consists of a pair of ontologies W i and W j , where there is no syntactic imports, and W j semantically imports some vocabulary from W i , and W i does not (semantically) import anything. Definition 8. A simple ontology space is of the form S = W j , W i , where M j = M i = ∅ (no syntactic imports) and S j = ∅.

What is the effect on the logical consequence of semantic import? And how such effect can be computed? In what follows, we will answer these questions by characterizing the effect of class constructors on transferring knowledge (in the form of class subsumptions) from a distant ontology to a target ontology. Let us illustrate our characterization by revisiting our example about W sumo , W ppl .

Example 4. In our example, the subsumption (3) is propagated from W sumo to W ppl . Intuitively this is because W ppl semantically agrees with W sumo on the meanings of all the terms of this subsumption. Instead, the subsumption sumo:Horses ¬sumo:TransportationDevice which holds in W sumo , does not hold in W ppl because W ppl disagrees with W sumo on the meaning of sumo:Transport-ationDevice (see the different interpretations in table 1).

Generalizing the previous example, one might falsely infer that, if the ontology W i semantically imports a set of symbols S i from the ontology W j , then all the class subsumptions in the language of S j that hold in W j are propagated to W i . This is true with an exception, due to the effect of coverage axioms. Let us explain this point with an example.

Example 5 (Closure Axioms are not Propagated). 2 On the base of the intuition given in the example presented at the beginning of Section 4, in the following we will provide a precise class characterization on which subsumptions propagate as a consequence of semantic imports in simple ontology spaces. Formally speaking, we accomplish this by using the notion of local/non-local classes first proposed by Cuenca-Grau et al. [5]. In this paper, we call them positive/negative classes.

Definition 11 (Polarity). The polarity of a semantically imported SHOINclasses is defined as follows (let A and B be classes, a an individual and R an object property): any atomic class is positive, ⊥ is positive, is negative, {a} is positive, A B is positive if either A or B are positive, A B is positive if both A and B are positive, ¬A is positive iff A is negative, ∃R.A is positive, ∀R.A is negative, (≥ 0)R is negative, (≥ n)R with n ≥ 1 is positive, (≤ n)R is negative, every class which is not positive is negative.

Property 1. For every positive concept semantically imported from W j , C Ii = C I j ∩ ∆ I i . For every negative concept semantically imported from W j ,

C I i = (C I j ∩ ∆ I i ) ∪ ∆ I i −I j (where ∆ I i −I j is a shortcut of ∆ I i \ ∆ I j ).

The Property 1 is the same as the property of local/non-local classes presented in the proof of Theorem 1 of [5], in which the authors have proved: (1) for each local (positive) class description C, C I i = C I j , and (2) for each nonlocal (negative) class description C, C Ii = C Ij ∪ ∆ Ii−Ij . Note that the property from [5] is based on a different kind of cross-domain semantics, namely domain expansion 3 , rather than that of semantic imports presented in Definition 6. It should be pointed out that, in order to maintain properties like Property 1, the kind of cross-domain semantics should be carefully selected. For example, if we replace the semantics of semantically imported properties (defined in Definition 6) with R Ii = R Ij ∩ (∆ Ii × ∆ Ii ) (as in C-OWL [3]), the Property 1 no longer holds.

Based on the notion of positive/negative (i.e. local/non-local) classes and the above property, the following Definition 12, Theorem 1 and 2 and can be seen as counterparts (under the semantics of semantic imports) of the Theorem 2 of [5], which identifies safe axioms, i.e. the kind of axioms that are satisfies by any domain expansions of their interpretations. Definition 12. Let S = W j , W i be a simple ontology space. The subsumptions transfer from W j to W i , written as S ji (W j ), is the set of subsumption statements of the form X Y , where X and Y are S i -related class descriptions, W j |= X Y and, either X is positive or Y is negative.

Intuitively, the subsumption transfer from W i to W j is the set of all the possible subsumptions in W i that are semantically propagated in W j . The following theorem shows that the subsumption transfer defined above can be used for a sound and complete characterization of logical consequences in simple ontology spaces.

Theorem 1 (Soundness). Let S = W j , W i be a simple ontology space. If X and Y are S i -related class descriptions, then

W i ∪ S ji (W j ) |= X Y =⇒ S |= i X Y.

Theorem 2 (Completeness). Let S = W j , W i be a simple ontology space. If X and Y are S i -related class descriptions, then

W i ∪ S ji (W j ) |= X Y ⇐= S |= i X Y. Proof. Suppose that O i ∪ S ji (W j ) |= X Y and let us build a model for S such that S |= i X Y . If O i ∪ S ji (W j ) |= X Y then let I i be a model of O i ∪ S ji (W j ) such that X I i ⊆ Y I i . Suppose that O j is unsatisfiable, then for all concept C ∈ S i , O j |= C ⊥; for all nominal {x} ∈ S i i, O j |= {x} ⊥; for all role R ∈ S i , O j |= ∀R.⊥.

In all the cases we have that the corresponding subsumptions belongs to S ji (O j ). The fact that I i |= S ji (O j ), implies that S i does not contains nominals (otherwise I i |= {x} ⊥, which is not possible), and for all C and R in S i , they are interpreted by I i in the empty set. This implies that the interpretation I j , I i with I j being a hole interpretation, satisfies S. Now let us consider the case were O j is consistent. Let ∆ * ⊆ ∆ Ii be the set

       x ∈ ∆ I i

x ∈ B Ii for some B ∈ S i or x = {a} I i for some a ∈ S i or x, y ∈ R Ii for some y and R ∈ S i or y, x ∈ R I i for some y and R ∈ S i

      

If ∆ * = ∅ then, the interpretation I j , I i where I i is the hole interpretation is a model of S which does not satisfy X Y . Suppose, therefore that ∆ * contains at least an element x 0 . Let W * i be obtained by extending the semantic import S i of W i with the set of constants in ∆ * (we can suppose with no loss of generality that ∆ * is disjoint from the language of W i ), and with a new role R 0 . a new nominal {x 0 }. Let I * i be the extension of I i such that x I * i = x for all x ∈ ∆ * and x

I * i 0 be any value in ∆ * . Clearly I * i is an interpretation of W * i that satisfies O * i = O i . Let W *

j be obtained by extending O j of W j , with the following set of axioms. We denote the resulting set with O * j .

1. {x 0 } ∃R 0 {x} for all x ∈ ∆ * 2. {x} ¬ {y} for every

x = y ∈ ∆ * . 3. {x} B, if B ∈ S i and x ∈ B I i ; 4. {x} ∃R. {y}, if R ∈ S i and x, y ∈ R Ii .

Consider the ontology space S * = W * j , W * i , If O * j is consistent, then there is an interpretation I * j for O * j in which x I * j = x. Let I j be the restriction of I * j on the language of W i , then by construction I j , I i is an interpretation for S.

If O * j is inconsistent, then, since O j is consistent, there is a finite subset O 0 j of the axioms 1-4 added to O j that make it inconsistent. Let C * be the concept

X Y ∈O 0 j X ¬Y.

We have that O j ∪ C * ⊥ is inconsistent. This implies that

O j |= {x 0 } ∃R 0 C * .

Notice that both {x 0 } and ∃R 0 C * are positive classes, which implies that {x 0 } ∃R 0 C * belongs to S ij (W i ) which generates a contradiction.

Distributed Tableaux for Simple Ontology Spaces

In this section, we consider ontologies represented as ALC [13] TBoxes (which consists of only class axioms) and describe a distributed tableaux algorithm to compute concept consistency in simple ontology spaces. Tableaux algorithms (first by [14]) are very useful to solve class satisfiability problem. They test the satisfiability of a class E4 by trying to construct an interpretation for E, which is represented by a completion tree T : nodes in T represent individuals in the model; each node y is labeled with L(y) and each edge y, z is labeled with L( y, z ). A tableaux algorithm starts from an labelled initial tree (usually simply a root node), and is expanded by repeatedly applying the completion rules. The algorithm terminates either when T is complete (no further completion rules can be applied) or when an obvious contradiction, or clash, has been revealed.

Formally, a completion tree is a tuple T = x, N, E, L , where x is the root of T , N and E are the sets of nodes and edges, respectively, of T , and L a function that maps each node y (each edge y, z ) in T to its label L(y) (L( y, z ), respectively). Let T be a completion tree, S a semantic import box. We say that a completion tree T is S-related if there exist some S-related class or property descriptions in the labels of all edges and all non-leaf nodes of T . In what follows, we define the main operation on completion trees we need in our algorithm.

Definition 13 (Projection of Completion Tree). Let S be a semantic import box and T an S-related clash-free completion tree with root x 0 . The projection of T w.r.t. S, denoted as π S (T ), is a completion tree which 1. has the same root x 0 , 2. contains the exact set of nodes and edges as T , and 3. for each label L(x ) (L( x , y )) of a node x (an edge x , y , respectively) is the subset of the label L(x) (L( x, y ), respectively) of the corresponding node x (edge x, y , respectively). If all the S-related class descriptions in L(x) is negative, L(x ) = ∅; otherwise, L(x ) contains all the S-related class descriptions in L(x) . L( x , y ) contains all the S-related property descriptions in L( x, y ).

According The algorithm needs some explanation and clarification. T is initialised with a root x 0 with L(x 0 ) = {E}, and is expanded by local completion rules w.r.t. O i (line 1). As T might not be S i -related, maximal S i -related sub-trees then should be projected and expanded by local completion rules w.r.t. O j (lines 6-8). If any of the projected sub-tree has a clash, T needs to be backtracked, expanded and start the checking all over again. In what follows, let us use a simple example to illustrate its main idea of the algorithm. Example 6. Given the following ontology space S = W j , W i , where W j and W i are defined as follows: W j = j, M j = ∅, S j = ∅, O j = {j:A ∀j:R.(j:C), j:C j:B} and W i = i, M i = ∅, S i = {j:A, j:B, j:R}, O i = ∅ . We want to check the satisfiability of the following class j:A ∃j:R.(¬j:B) in W i w.r.t. S.

We use Tab(O i , x 0 , {x 0 }, ∅, {L(x 0 ) = {j:A ∃j:R.(¬j:B)}} ) to build a clash-free completed completion tree T . It is obvious that T is S i -related, so there is only one maximal S i -related sub-tree of T , which is itself. Therefore, T consists of two connected nodes x 0 and x 1 , where x 0 is labelled with L(x 0 ) = {j:A ∃j:R.(¬j:B), j:A, ∃j:R.(¬j:B)}, x 1 is labelled with L(x 1 ) = {¬j:B} and the edge x 0 , x 1 is labelled with L( x 0 , x 1 ) = j:R. Then we expand T with mega-constraints: 5 we first expand L(x 0 ) as {j:A ∃j:R.(¬j:B), j:A, ∃j:R.(¬j:B), ¬j:A ∀1:R.(j:C), ¬j:C j:B}; for the disjunction ¬j:A ∀j:R.(j:C) in L(x 0 ), we have to choose ∀j:R.(j:C) since j:A ∈ L(x 0 ); then we expand L(x 1 ) and add C in it, so L(x 1 ) = {¬j:B, ¬j:A ∀j:R.(j:C), ¬j:C j:B, C}; obviously there is a clash in L(x 1 ) because ¬j:C j:B, j:C and ¬j:B are in L(x 1 ). Hence, T and T are not complete and j:A ∃j:R.(¬j:B) is unsatisfiable in W i w.r.t. S.

To prove the algorithm correct, we need to show that: (1) The algorithm always terminates. (2) The algorithm returns unsatisfiable iff S |= i E. (3) The algorithm returns satisfiable iff S |= i E.

Due to limited space, we only provide a brief discussion. For (1), observe that Algorithm 1 does not change T at all and simply invokes backtrack when there exists an external clash. Algorithm 1 terminates because Tab(O, E) terminates. For (2), observe that S |= i E either because O i |= E (this would be detected by lines 1-3) or there exists some X Y ∈ S ji s.t. ¬X Y is disjoint with a S i -related sub-class of E (this would be detected by lines 7-9). For (3), it can be shown that we can construct an interpretation of E whenever we have a complete T , and vice versa.

Related Work

Ontology reuse has been an important topic [19,18,8]. Uschold et al [18] conclude that reusing an ontology requires significant effort on considering the context and intended usage of both the source and target ontologies as well as the specific task of the target application. This is consistent with our observation that users need to be able to customise their partial reuse of ontologies.

The semantic for ontology import is an evolution of the semantics C-OWL language [3]. The main difference concerns the interpretation of foreign relations. In C-OWL (i:R) I j = (i:R) I i ∩ ∆ I j × ∆ I j while in semantic import we imposed the forward and backtrack closure. This update was necessary to allow the propagation of properties on relations.

Our approach is also related to existing work on reasoning with distributed Description Logics [15] and distributed First Order Logics [6]. In particular it is still an open question if semantic imports can be obtained by suitably mapping a concept (role or individual) on its native ontology with the occurrence of the concept in the importer ontology. The conjecture is that semantically importing i:C into the ontology W j corresponds to adding the mappings i:C ≡ −→ j:C, ¬i:C ≡ −→ ¬j:C. 6 . Ontology modularisation [16,4,11,5,1] is an active topic in the field of ontology reuse. StuckenSchmidt and Klein [16] propose a structure-based approach for partitioning large class hierarchies. Cuenca-Grau et al. [4] present a partitioning algorithm, based on e-connections [7]. The partitioning of an ontology is automatic, although the modularisation is not always possible. Later, Cuenca-Grau et al. [5] propose the notion of safe ontologies, which are ontologies that can be modularised. The idea of safe ontologies is based on the notion of local/non-local classes (which we call positive/negative classes); see Section 4.1 for more details. Besides using different kind of cross-domain semantics, the main differences between our approach and Cuenca-Grau et al.'s approach include: (1) the reusable units in our approach are some vocabulary (such as classes or properties) rather than axioms; (2) our approach allows users to agree or disagree with some subsumption relations in distant ontologies, while modules of ontologies are required to preserve subsumptions among named classes; (3) unlike the modularisation operator, the semantic imports operator can be used between any two ontologies in an ontology space.

Discussion

How to support ontology reuse is becoming more and more important. While the "copy-and-paste" approach suffers a number of problems, this paper proposes a new import primitive, called semantic import, to facilitate partial ontology reuse. In this paper, we have identified four semantic requirements for semantic import: propagation of class hierarchy, disjoint classes, property closure and (in)equality objects. Secondly, we have investigated the logical properties of semantic imports in simple ontology spaces. Based on the notion of positive/negative classes first proposed by Cuenca-Grau et al. [5], several categories of subsumption relations (knowledge) class descriptions over the agreed vocabulary have been shown to be transferrable form distant ontologies to the target ontology. Finally, we have presented a distributed algorithm for TBox reasoning of semantic import of ALC ontologies in simple ontology spaces.

An important "side effect" of introducing semantic import into ontology languages such as OWL DL is to open a door to support the intended usage of URI references, i.e. identifying resources. In OWL DL, the same individual URIref can be interpreted as different objects in different ontologies, where URI references are not really playing a role on identifying resources. In the presence of semantic import, however, the semantic of ontology space guarantees that an semantically imported individual is interpreted as the same object in multiple ontologies. This suggests that semantic import could play a very fundamental role in Web ontologies under the unique identification assumption.