=Paper=
{{Paper
|id=Vol-1193/paper_9
|storemode=property
|title=DeaLing with Ontologies using CODs
|pdfUrl=https://ceur-ws.org/Vol-1193/paper_9.pdf
|volume=Vol-1193
|dblpUrl=https://dblp.org/rec/conf/dlog/VescovoP14
}}
==DeaLing with Ontologies using CODs==
https://ceur-ws.org/Vol-1193/paper_9.pdf
DeaLing with Ontologies using CODs
Chiara Del Vescovo1? and Rafael Peñaloza2??
1
School of Computer Science, The University of Manchester, UK
delvescc@cs.man.ac.uk
2
Theoretical Computer Science, TU Dresden, Germany
Center for Advancing Electronics Dresden
penaloza@tcs.inf.tu-dresden.de
Abstract. A major challenge in knowledge representation is to manage
the access to knowledge: users should not be presented with knowledge
that is irrelevant to their topic of interest, or have no right to access.
Two general strategies exist for providing access restrictions: (1) the
ontology engineers describe the conditions that allow access to specific
fragments of the ontology, or (2) fragments are automatically identified
through their logical properties. The former is prone to miss logical con-
nections between axioms, while the latter can fail to capture relevant
knowledge that has no logical connection with the topic of interest.
We define the Context-Oriented Decomposition (COD) of an ontology
as a technique that combines the benefits of both approaches: it allows
authors to identify relevant fragments, while guaranteeing the strong
semantic properties of the logic-based Atomic Decomposition.
1 Introduction
Description Logics (DLs) [1] have been successfully used to represent the knowl-
edge of an application domain in a structured and usable manner. This knowl-
edge is encoded through an ontology: a finite set of axioms that restrict the
possible interpretations of the terms that are relevant for the domain. Differ-
ent reasoning tasks can then be applied to extract knowledge that is implicitly
encoded in this ontology.
In general, ontologies can be very large and contain a high level of detail of
different topics within the same general domain. For example, the large-scale
ontology Snomed CT [16] describes knowledge about anatomy, disorders, and
processes, among many others. A user that is interested in only one topic or
a general view might be overwhelmed by the additional information, irrelevant
to her, available. It would thus be helpful to provide this user with just the
knowledge that is relevant with her, without obscuring any relevant knowledge.
A related, dual problem in using ontologies consists of restricting the access to
sensitive knowledge: users have reasoning capabilities, thus removing an explicit
axiom that describes sensitive knowledge is not sufficient to preserve secrecy, as
it might be the case that the same knowledge can be inferred from the rest of
?
Funded by the EPS Strategic Fund 2014 provided by the University of Manchester
??
Partially supported by the DFG within the Cluster of Excellence ‘cfAED’
the ontology. These two problems offer the same kind of challenge: to provide
different users with the view to this knowledge that best suits their needs.
One strategy for tacking these issues is to decompose the ontology into mean-
ingful fragments that can be provided to or hidden from users, depending on their
interests and access rights. Current approaches for decomposing an ontology
can be divided in two main categories: manual author-defined decompositions
like [3,2], where the strong human component makes the fragments obtained
liable to miss key information, or to include irrelevant one; and automated logic-
based approaches, where the decomposition obtained satisfies logical properties,
but it is likely to be very different from the one that authors have in mind.
The main drawbacks of these two approaches are clear. The manual approach
requires an expert to explicitly describe the full decomposition in detail, which
is infeasible, specially for large or complex ontologies. The automated approach,
on the other hand, must rely on semantic properties of the ontology without the
intervention of an expert. Such an automated procedure cannot, e.g., combine
two axioms with two disparate signatures into one common topic.
In this paper we present a new approach to ontology partitioning, called
context-oriented (atomic) decomposition (COD), that combines the benefits of
both kinds of approaches, while minimizing their drawbacks: it allows authors
to identify fragments of an ontology that may be provided to users under some
conditions; and it is based on a well-defined ontology partitioning, namely the
atomic decomposition, that can be efficiently computed and guarantees the frag-
ments obtained to satisfy strong logical properties.
2 Preliminaries
We assume familiarity with Description Logics (DLs) [1], and discuss the central
notions of locality-based modularity [4] and Atomic Decompositions (ADs) [6].
For the rest of this paper, L denotes an arbitrary but fixed DL language, e.g.
ALC, and O, M, or R, stand for an L-ontology, i.e., a finite set of L-axioms.
For an axiom α or ontology O, we denote as α e and O e the signature of α and O,
respectively; i.e., O
e is the set of concept-, role-, and individual-names that appear
in O, and similarly for α e. A seed signature is any user-selected or application-
driven set Σ of terms occurring in O. e A logical module M for a seed signature
Σ in O is a subset of O such that, for all axioms α with α e ⊆ Σ, M |= α iff
O |= α; i.e., M preserves all the entailments of O over the seed signature Σ.
This property is usually known as coverage.
In general, we call module any subset M of an ontology O such that there
exists a signature Σ ⊆ O e for which M is a logical module in O. This notion
of module is based upon the well-known notion in logics of deductive Conser-
vative Extensions (dCEs), first discussed for DLs in [7]. Unfortunately, deciding
whether a set of axioms is a module is, in general, hard or even impossible for
expressive DLs [12]. In particular, it is hard to identify minimal such modules:
due to the monotonicity of DLs, once a module M for Σ in O is found, then
all its supersets in O are also modules for Σ in O. Clearly, all the axioms in a
minimal module play some role in preserving the entailments over Σ.
Some (not necessarily minimal) modules satisfy two additional properties:
(1) a module M is depleting if O \ M entails only tautologies over the signature
Σ; and (2) M is self-contained if it is a module in O for the signature Σ ∪ M. f
Intuitively, depleting modules encapsulate the knowledge of O about Σ, and
no information about Σ is disclosed if the remainder O \ M is published; and
self-containment guarantees that all the terms in M f have the same status w.r.t.
entailments, so that all the terms in M are as much constrained in M as they are
f
in O. Modules satisfying these two properties also satisfy uniqueness: for each
ontology O, a depleting and self-contained module for a signature Σ is uniquely
determined, under some mild conditions on the language used that are always
satisfied by DL ontologies [13]. These properties, originally introduced in [13]
are important for knowledge reuse, as discussed in [15].
The hardness results for minimal modules transfer to the computation of
minimal self-contained and depleting modules. To identify feasible module ex-
traction algorithms, one line of research in module extraction has been to restrict
the expressivity of the DL to regain decidability; this approach has led to the
identification of a polynomial algorithm to extract modules from DL-Lite on-
tologies using QBF solvers [13], and to the MEX system that allows for the
extraction of modules from terminological ELI ontologies [11].
A different approach, aiming to allow module extraction from ontologies as
expressive as SROIQ, consists of identifying conditions under which computing
a module is cheap, and the resulting modules are “not too large”; i.e., do not
contain too many superfluous axioms. A prominent approach in this direction
exploits the notion of syntactic locality [4], or locality for short. Locality-based
modules (LBMs) come in many flavours, but for the sake of this paper we will
focus on the three main notions named ⊥, >, and >⊥∗ .
Let ∈ {>, ⊥}, and let α0 denote the formula obtained by replacing with the
concept all the terms in α that are not in Σ. A syntactic check for -locality
can be performed by testing whether α0 matches one of the syntactical patterns
that guarantee that α is a tautology, that can be found in [4]. In contrast to
determining whether a formula is a tautology, which is as hard as reasoning,
the syntactic approximation provided by the patterns table makes the locality
check purely syntactic, and hence the check can be performed in linear time. As
an example, consider the axiom α = C v D. Then, α is ⊥-local w.r.t. Σ1 = {D}
since α0 = ⊥ v D is clearly a tautology for any (possibly complex) concept D.
Similarly, α is >-local w.r.t. Σ2 = {C} since α0 = C v > is a tautology for any
concept C. The following proposition lays down the foundation for using locality
to identify modules in ontologies.
Proposition 1 ([4]). If M ⊆ O is such that all the axioms in O \M are -local
w.r.t. Σ ∪ M,
f then M is a depleting module for Σ in O.
The extraction of a module can be thus performed as follows: (1) define M as the
set consisting of all the axioms in O that are non -local w.r.t. Σ; (2) enlarge Σ
with M;
f (3) repeat steps (1) and (2) until a fixpoint is reached. By Proposition 1,
the set M obtained is a depleting module. Moreover, the enlargement of Σ by
Mf guarantees that M is also self-contained. The resulting module is called the
-module of Σ in O, and is denoted by -mod(Σ, O).
Due to the coverage property, the extraction of the ⊥-module for a signature
Σ from the >-module for Σ in O is still a module for Σ in O. The converse is also
true; that is, the >-module for Σ in the ⊥-module for Σ in O is still a module
for Σ in O. Hence, by iteratively nesting ⊥- and >-extraction until a fixpoint
is reached one can get rid of more axioms that are not needed to preserve the
entailments of O over Σ. It can be shown that the fixpoint does not depend on
which notion is applied first. This uniquely determined new notion of module is
called the >⊥∗ -module of Σ in O, and is denoted by >⊥∗ -mod(Σ, O).
Roughly speaking, a >-module for Σ in O gives a view “from above” to
the knowledge about Σ: it contains all the named sub-concepts of any concept
name in Σ; dually, a ⊥-module for Σ in O gives a view “from below” since it
contains all the named super-concepts of any concept name in Σ; a >⊥∗ -module,
instead, is a subset of both the corresponding >- and ⊥-modules, containing all
the axioms needed to entail that two concepts in Σ are one a sub-concept of
the other, but not necessarily all their sub- or super-concepts. The results in
this paper can be easily extended to all notions of self-contained and depleting
modules, but for simplicity we restrict our attention to LBMs. For a deeper
discussion on LBMs, see [4].
OWL [10] and its successor OWL 2 are syntactic variants of DLs. For OWL
ontologies, module extraction systems have been implemented and are available,
both as part of the ontology editor Protégé,3 and online.4
The Atomic Decomposition of an Ontology. For the purposes of this paper,
it is relevant to investigate on the logical relationships between modules. This
task, though, cannot be performed by pairwise comparisons of modules, as there
are, in principle and in practice, exponentially many modules in the number of
axioms of an ontology O [14].
We can restrict our attention to the building blocks of modules, as defined
in [6]: a -atom is a maximal set of axioms a ⊆ O such that, for each -module
M, either a ⊆ M, or a∩M = ∅ (for ∈ {⊥, >, >⊥∗ }). Atoms are thus fragments
of an ontology that show a tight logical interrelation as they never split across
two or more modules. Notably, atoms are disjoint, and cover the whole ontology.
As a consequence, the set A of all the atoms of an ontology O is a partition of
O, thus there are at most as many atoms as axioms in O.
For each atom a, there is a unique smallest module Ga that contains a. Such
a module is called genuine. Notably, the set G of the genuine modules of O forms
a base of the set F of all the modules of O. In particular, every module of O can
be decomposed in a unique way as the union of one or more genuine modules.
Moreover, G induces a partial order relation over the set A which is defined
as follows: we say that an atom a depends on another, distinct atom b, and
write a b, iff for every genuine module G ∈ G such that a ⊆ G, we have that
b ⊆ G. The partially ordered set (A, ) is called the Atomic Decomposition (AD)
3
http://www.co-ode.org/downloads/protege-x
4
http://owlapi.sourceforge.net/
36 41 35 10 21 9
19 7 50 45 29 44 12 13 16 6 28 33 48
11 14 34 3 37 31 30 2 23 8 17 22 46 24 39 26
15 32 1 42 40 25 27 43 18 47 49 4
20 5
38
Fig. 1. The ⊥-AD of the CARO ontology
of O, and its well-foundedness derives from the depletion and self-containment
properties of modules. ADs are usually represented by their Hasse diagrams as
the one shown in Figure 1. Each genuine module Ga can be found by identifying
the corresponding atom a and by taking the union of atoms obtained by chasing
the dependence relation .
Example 2. The Common Anatomy Reference Ontology (CARO) is a simple
ontology, available in the ontology repository BioPortal,5 that, in the words of
its developers, aims at “facilitating interoperability between existing ontologies
for different species, and at providing a template for building new anatomy
ontologies” [9]. CARO consists of 54 axioms written in EL with transitive roles.
Figure 1 depicts the ⊥-AD of CARO, which reflects the hierarchical structure
of the ontology. As it can be seen, CARO decomposes into 50 different ⊥-atoms.
46 of these atoms contain only one axiom, and the remaining atoms (a3 , a7 , a19 ,
and a37 in the figure) contain 2 axioms each. Looking at the graph, we can iden-
tify the different genuine modules. For instance, a20 defines the genuine module
G20 = a20 ∪ a38 . The atom a39 contains only epithelium v portion of tissue.
Three atoms depend on a39 :
a12 = {atypical epithelium v epithelium},
a13 = {multilaminar epithelium v epithelium}, and
a16 = {unilateral epithelium v epithelium}.
Although a31 contains the axiom epithelial cell v cell, no logical dependence
among a31 and a39 is shown since the ontology does not describe any logical
relationship between an epithelial cell and the epithelium.
3 Contexts and Rhemes
Modules are widely used for ontology reuse as they provide a powerful tool to
identify a part of an ontology preserving the meaning of a signature of interest.
For other tasks, though, the user must understand how the module M relates
to the rest of the ontology. In the following, we describe two such tasks, and
discuss the limitations of using purely logical modules for them.
5
http://bioportal.bioontology.org/
Knowledge Completion (KC). An ontology is an explicit, formal represen-
tation that accounts for the ontological commitment of a particular conceptual-
ization of the knowledge about a domain [8]. As such, it can only approximate
the intended models; moreover, even if the difference between the intensional
and extensional models could be eliminated, for many purposes this would mean
superfluous work, as a partial representation may suffice for a given applica-
tion. In other words, some relations between the objects of the domain can be
underspecified in the logical formalisation, as it occurs in the CARO ontology
(see Example 2). However, the users may still want their fragments to preserve
not only the logical aspects, but also the ontological commitment of their sub-
domain of interest, which purely logical modules are not designed to preserve.
In this case, domain knowledge is required to include the relevant terms for the
sub-domain of interest in the seed signature of the module.
Access Control (AC). As discussed in Section 2, the signature of a module M
is usually larger than the seed signature Σ, as the reasons for an entailment over
Σ to hold can arise from axioms where no term in Σ is mentioned. Since users are
capable of reasoning, they can then derive logical consequences over the signature
M.
f Thus, the knowledge engineer must ensure that users can only access those
modules that do not implicitly encode any sensitive information, whose access
should be denied. This task is in general infeasible given the exponential number
of possible modules. Restricting the inspection only to genuine modules can still
be impractical since their number is usually close to the number of axioms of
the ontology [5]. Most importantly, even distinct genuine modules can be dealing
with related topics as shown in Example 2, and users are likely to have the right
to access a combination of them.
Technically, both KC and AC can be carried out with the help of contexts,
and more precisely, modules that preserve the knowledge from a context.
Definition 3. Let O be an ontology, L a finite set of labels and lab : O → 2L
a function that maps every axiom to a set of labels. A context is a finite subset
C = {C1 , . . . , Cκ } ⊆ L. Every context C defines the subontology
RC := {α ∈ O | lab(α) ∩ C 6= ∅}.
C
This set R is called the rheme of the context C.6
Intuitively, the set C expresses the conditions under which the ontology RC is
accessible to a user. Every user will be associated also to a set of labels from L.
If she has at least one label from C, then she can access the whole rheme RC .
If there is no ambiguity regarding the context C, or specifying it is irrelevant
in the discussion, we will usually drop the symbol C and write R. In some cases,
we may deal with sets of contexts C 1 , . . . , C κ ; to ease the notation, we will then
write Ri to denote the rheme of the context C i , for i ∈ {1, . . . , κ}.
Definition 4. Let O be an ontology, a notion of module, and C a context. The
contextual -module for C in O is the set -mod(C, O) = -mod(R fC , O) ∪ RC .
C
The signature of this set, Σ , is called the contextual signature of C.
6
The term rheme is borrowed from linguistics; it refers to “what is said about a
theme”, in contrast to the theme itself, which may be seen as the title for the rheme.
Algorithm 1 Computation of the contextual -module for C in O
Input: An ontology O; a notion of module; a context C.
Output: The contextual -module MC = -mod(C, O) for C.
1: MC ← ∅
2: repeat
3: Σprev ← R fC ∪ M
gC
4: for each α ∈ O do
5: if (the -locality check of α against R gC is negative) or (α ∈ RC ) then
fC ∪ M
6: MC ← MC ∪ {α}
fC ∪ M
7: until R gC = Σprev
C
8: return M
If the ontology O is clear, we will use the notation MC . If, instead, we have a set
of contexts C1 , . . . , Cκ , then we denote the corresponding contextual signatures
by Σ 1 , . . . , Σ κ . As the name suggests, a contextual module is also a module.
Proposition 5. The contextual -module for a context C in an ontology O is a
fC .
self-contained and depleting logical module in O for the signature R
Proof. By definition, -mod(R fC , O) is a module for RfC . Then, the result fol-
lows by monotonicity of DLs since the contextual module MC is a superset of
-mod(R fC , O), and hence since RfC is contained in the signature of the module,
it is also a module for RC with the same properties as -mod(R
f fC , O). t
u
Notice that in general MC 6= -mod(R fC , O): in principle the rheme RC could
contain tautologies, like OWL declarations, which have no logical influence on
the represented knowledge, but can be helpful for simplifying the work of the
reasoners. Since tautologies are logically unnecessary for preserving entailments
fC , minimal modules over this signature will not include any of them.7 Tau-
over R
tologies, though, can be of interest for users, for example if they are annotated
with useful information. For this reason, it is crucial to leave at the discretion
of the ontology engineer the choice of including them in rhemes or not.
Contextual modules can be computed by making use of Algorithm 1, which
we prove to compute in finite time the contextual module MC for a context C.
Proposition 6. Let O be an ontology, a notion of module, and C a context.
Algorithm 1 computes the contextual -module for the context C.
Proof. Termination follows from the finiteness of the ontology: the repeat loop
on lines 2-7 terminates when no more axioms can be added to the set MC , and
this eventually happens since there is a finite number of axioms in O. Lines 5
and 6 ensure that the output MC of the algorithm contains -mod(R fC , O) ∪ RC .
We need only to prove that the converse inclusion holds.
Suppose that there is some axiom α ∈ MC \ (-mod(R fC , O) ∪ RC ). W.l.o.g.,
assume α to be -local against the signature of -mod(R fC , O), but not -local
7
In syntactic approximations of modules, like e.g., syntactic locality, some tautologies
can still appear since syntactic checks may fail to identify them as irrelevant.
against the signature of -mod(R fC , O) ∪ RC . Notice that the signature of the
C
second term R equals (thus, it is contained in) the seed signature of the first
term -mod(R fC , O). Thus, the set of all the axioms that are non -local against
the signature of -mod(RfC , O) ∪ RC is already in -mod(R fC , O). t
u
Computing a contextual module requires a polynomial number of locality checks
in the number n of axiom of an ontology O. Since we focus only on the syntactic
notions which can be performed in polynomial time on n, it is clear that the
whole extraction is overall polynomial in n.
We now take a closer look at the notion of context and its properties. From
Definition 3, an axiom can belong to as many contexts as the number ` of
possible labels, which could, in principle, be arbitrarily large. On the other hand,
ontologies are always finite by definition. Let n be the cardinality of the ontology.
If ` > 2n , then some contexts have the same content; that is, there exists two
different contexts C 1 = {C11 , . . . , Cr1 } and C 2 = {C12 , . . . , Cs2 } such that R1 = R2 .
In other words, we have two syntactically different contexts sharing the same
rheme. Since we cannot differentiate among them, we can equivalently define a
new context C := C 1 ∪ C 2 . It is a simple consequence of Definition 3 and the
equivalence of R1 and R2 that the rheme for C is R = R1 = R2 .
From what we just discussed, it is clear that the number of contexts can be
bounded by 2n . Such method leads to a potentially exponential number of dif-
ferent contexts, and hence of contextual modules. In this case, it is hard to check
that all of them keep the promise of either completing knowledge or restricting
the access to sensitive knowledge. However, ontology engineers can focus their
attention to a much smaller sample of contextual modules; there is a base, linear
in n, of contextual modules, called genuine, such that every contextual module is
the union of a suitable selection of genuine contextual modules. Attentive read-
ers may have noticed that we are reusing the term “genuine” as in the context
of ADs. This choice is not due to chance; it is rather a way to emphasize the
similarities between the two notions. We formalize and analyse this next.
Definition 7. Let O be an ontology, and C the set of all the contexts over O.
For each axiom α ∈ O, define the rheme of α as RCα = {β ∈ O | lab(α) ⊆ lab(β)}
if lab(α) is non-empty, or {α} otherwise. A genuine contextual module is a
contextual module GαC := mod(RfC , O) for some α ∈ O.
α
For each two axioms α, β, the condition lab(α) ⊆ lab(β) means that whoever can
access α can also access β. In particular, GαC is the smallest contextual module
containing α.
Theorem 8 Let O be an ontology. The set of the genuine contextual modules
GC = {GαC | α ∈ O} is a base for the set of all the contextual modules in O.
Proof. We prove that every contextual module MC coincides S with the union
of all the modules GαC for α ∈ MC . The inclusion MC ⊆ α∈MC GαC is trivial
since every RCα contains at least α. The converse inclusion also holds since MC
contains, for each α ∈ MC , the rheme RCα by construction. t
u
Since there are at most as many genuine contextual modules as axioms, we have
that GC is a linear (in |O|) base of the set of all contextual modules of O. As for
ADs, the genuine contextual modules are those contextual modules that never
split as the union of two or more contextual modules, which are incomparable
by ⊆. We want to find the building blocks of contextual modules.
Definition 9. A contextual atom is a maximal subset of axioms aC ⊆ O such
that, for each genuine contextual module G C ∈ GC , either aC ⊆ G C , or aC ∩G C = ∅.
Contextual atoms are pairwise disjoint by construction; as for modules, con-
textual modules are then a finite union of contextual atoms. Since contextual
modules are also modules, atoms cannot split across two contextual modules.
Similarly, contextual atoms do not split across two contextual modules by con-
struction. Thus, the set AC of all the contextual atoms of O is a coarsening of
the set A of all the atoms of O. Moreover, the preservation of logical interrela-
tions between the terms of a contextual atom requires that this atom is always
provided to users as a whole. Thus, rhemes can be, ultimately, redefined to co-
incide with contextual atoms. Rhemes then contain axioms that are logically
or contextually interrelated; that is, RC includes axioms that belong to a same
topic according to the knowledge engineer.
Definition 10. Let O be an ontology, C = {C1 , . . . , Cκ } a set of contexts with
rhemes RC1 , . . . , RCκ , and AC the set of all the corresponding contextual atoms.
A partial order relation is induced as follows: for each pair of distinct contex-
tual atoms aC , bC , we say that aC bC iff, if a contextual module G C contains
aC , then G C contains also bC . The pair (AC , ) is called the Context-Oriented
Decomposition (COD) of O.
The COD of an ontology can be represented by a dependency graph of contextual
atoms. From this graph, ontology engineers may want to identify the fragments
of the ontology that are of interest for the needs of its users, and provide them
with suitable contexts to access the corresponding subontology. Thus, the issue
of identifying the right subontology for each user can be reduced to the definition
of contexts in such a way that the corresponding COD reflects the knowledge
engineer modelling of the domain.
We discuss a feasible methodology to generate a suitable set of contexts C and
the corresponding fragments of the ontology O from which users are assigned the
right to access to the relevant part of O. Rather than defining all the modules
directly, the knowledge engineer may proceed in the following way. First, she can
identify relevant but small rhemes RCi . Second, the COD (AC , ) is computed,
and rhemes are redefined to coincide with contextual atoms. Finally, she defines
suitable labels for each contextual atoms that will form the set of contexts.
4 Applications of CODs
In this section, we discuss the two applications, Knowledge Completion and Ac-
cess Control, introduced before, and show how COD can be of help for practical
use of ontologies.
R2 R4 30 37 R5 R6 R1
47 27 R3 4 40 42 18 1 R7 43 R8
5
38
Fig. 2. ⊥-COD of the CARO ontology
COD for KC. An analysis of the ⊥-AD of the CARO ontology reveals how
hard it can be to identify which fragment captures everything that an ontology
says about a certain topic. The most emblematic example in CARO can be ob-
served already in Example 2: even by chasing sub- and super-concepts, incoming
or outgoing role-links to the concept epithelium, a user not familiar with CARO
cannot find the portion of the ontology dealing with epithelial cells. To reveal
that these terms are related in the ontological commitment of the CARO ontol-
ogy, we have grouped the 8 atoms a39 , a12 , a13 , a16 , a35 , a10 and a21 in rheme R4,
and named the context C4 as Epithelium.
In general, two axioms dealing with the same topic may still belong to differ-
ent atoms even when the ontology is supposedly well-modelled. Ideally, we might
want that two contextual atoms are distinct only when they deal with different
topics. To obtain this situation, we can adopt the strategy just described, and
merge into a broader contextual atoms all those atoms that deal with the same
topic according to the domain experts’ knowledge.
In Figure 2 we show the ⊥-COD of CARO where the atoms are grouped
according to the principle just discussed. In specific: rheme R1, that deals with
Immaterial anatomical entity, consists of the atom a26 plus all the atoms that
depend on it; R2, dealing with Sexual traits, contains the atoms a8 , a17 , a22 plus
all those that depend on any of these; R3= a25 ∪ a2 , and deals with Acellular
anatomical objects; R5= a23 ∪ a7 ∪ a19 , and deals with Neuron projection; R6,
dealing with Compound organ, consists of the atom a32 plus all those that depend
on it; R7= a49 ∪ a24 ∪ a46 , and deals with Anatomic group; finally, R8=a20 ∪ a15
deals with Portion of substance.
From the ⊥-COD of CARO, the knowledge engineer will provide the axioms
in R4, a4 , a40 , a5 and a38 to those interested in getting the fragment of CARO
that deals with Epithelium.
COD for AC. To exploit the use of COD for AC, the main idea is that users
are assigned a set of genuine contextual signatures, which specify the logical
symbols over which the user can query the ontology. The coverage properties of
logical modules guarantees that reasoning over these modules yields the exact
same answers as reasoning over the whole ontology, provided that they refer only
to symbols in the genuine contextual signature. Thus, the knowledge engineer
can verify that the user cannot derive a consequence, simply by comparing the
signature of the consequence with the contextual signatures assigned to the user:
if the former is contained in any of the latter, then (and only then) the user can
derive the consequence.
Notice that, by definition, users are not assigned one module, but a set of
them. This means that each user can derive the consequences of the union of
all the contexts that she can access. For each of these contexts, it is guaranteed
that all the consequences of the ontology that refer to its signature are obtained.
However, we might want to restrict the access a specific piece of knowledge, but
not to completely obstruct access to its signature. In this case, we can exploit
the fact that the union of two modules is not, in general, a module. For example,
suppose that we are trying to hide a consequence C v D from a user. To achieve
this, it is not necessary to completely prevent the user from accessing none of
the concept names C or D. In fact, she can be assigned two signatures Σ1 and Σ2
such that C ∈ Σ1 and D ∈ Σ2 , as long as {C, D} is not contained in any of them.
In this way, the user can still derive meaningful consequences concerning each
of the concepts C and D, while the subsumption C v D remains hidden.
To fully specify an AC scenario, the knowledge engineer needs only to identify
which genuine contextual modules do not cover the signature of the piece of
knowledge that some users cannot access. Users are then assigned only contextual
signatures that do not contain the signature of any consequence that they are
not allowed to see, or which are irrelevant for their intended use.
5 Conclusions
We have proposed a new approach for decomposing ontologies, capable of deal-
ing with contexts defined by a user or knowledge engineer. This context-oriented
decomposition is based on the notions of atomic decompositions, and preserves
several of its important properties. Most notably, the COD can be efficiently
computed and provides a compact representation of all genuine modules that
preserve the given contexts. Intuitively, one can think of contexts as a manner
of combining axioms that do not necessarily share logical properties into a sin-
gle entity. This combination can be motivated by the presence of axioms with
disparate signatures, but referring to a common theme.
As working examples, we showed how COD can be used to complete knowl-
edge and to restrict access to some consequences of the ontology in a structured
manner. Using COD, a knowledge engineer can easily define contexts that can be
assigned to different users, guaranteeing access to all relevant knowledge, while
hiding all unauthorized consequences from them.
Although we have focused our discussion on locality-based modules, and
in particular on the three notions of >-, ⊥-, and >⊥∗ -modules, it should be
noted that our approach is general and can be applied to any desired notion
of module. Obviously, the choice of a different notion of module can affect the
efficiency of the method; in particular, if modules are hard to compute, then the
decomposition will necessarily be also hard to find.
As future work we plan to further study the logical and computational proper-
ties of COD and its applicability to other context-dependent reasoning problems.
We are also in the process of developing a tool for computing these decomposi-
tions. This tool will allow us to evaluate the practical feasibility of our approach
for solving different reasoning tasks.
References
1. Baader, F., Calvanese, D., McGuinness, D., Nardi, D., Patel-Schneider, P.F. (eds.):
The Description Logic Handbook: Theory, Implementation, and Applications.
Cambridge University Press (2003)
2. Baader, F., Knechtel, M., Peñaloza, R.: Context-dependent views to axioms and
consequences of semantic web ontologies. J. of Web Sem. 12–13, 22–40 (2012)
3. Baader, F., Knechtel, M., Peñaloza, R.: A generic approach for large-scale onto-
logical reasoning in the presence of access restrictions to the ontology’s axioms. In:
et al., A.B. (ed.) Proc. of ISWC-09. LNCS, vol. 5823, pp. 49–64 (2009)
4. Cuenca Grau, B., Horrocks, I., Kazakov, Y., Sattler, U.: Modular reuse of ontolo-
gies: Theory and practice. J. of Artif. Intell. Research 31(1), 273–318 (2008)
5. Del Vescovo, C., Gessler, D., Klinov, P., Parsia, B., Sattler, U., Schneider, T.,
Winget, A.: Decomposition and modular structure of BioPortal ontologies. In:
Proc. of ISWC-11. LNCS, vol. 7031, pp. 130–145 (2011)
6. Del Vescovo, C., Parsia, B., Sattler, U., Schneider, T.: The modular structure of
an ontology: Atomic decomposition. In: Proc. of IJCAI-11. pp. 2232–2237 (2011)
7. Ghilardi, S., Lutz, C., Wolter, F.: Did I damage my ontology? A case for conser-
vative extensions in Description Logics. In: Proc. of KR-06. pp. 187–197. AAAI
Press/The MIT Press (2006)
8. Guarino, N.: Formal ontology in information systems. In: Proc. of FOIS-98. pp.
3–15. IOS Press (1998)
9. Haendel, M.A., Neuhaus, F., Osumi-Sutherland, D., Mabee, P.M., Mejino, J.L.V.J.,
Mungall, C.J., Smith, B.: CARO - The Common Anatomy Reference Ontology. In:
Anatomy Ontologies for Bioinformatics: Principles and Practice, pp. 327–350. No. 6
in Computational Biology, Springer-Verlag (2008)
10. Horrocks, I., Patel-Schneider, P.F., van Harmelen, F.: From SHIQ and RDF to
OWL: The making of a web ontology language. J. of Web Sem. 1(1), 7–26 (2003)
11. Konev, B., Lutz, C., Walther, D., Wolter, F.: Semantic modularity and module
extraction in description logics. In: Proc. of ECAI-08. pp. 55–59 (2008)
12. Konev, B., Lutz, C., Walther, D., Wolter, F.: Formal properties of modularization.
In: Stuckenschmidt, H., Parent, C., Spaccapietra, S. (eds.) Modular Ontologies:
Concepts, Theories and Techniques for Knowledge Modularization, LNCS, vol.
5445, pp. 25–66. Springer-Verlag (2009)
13. Kontchakov, R., Pulina, L., Sattler, U., Schneider, T., Selmer, P., Wolter, F., Za-
kharyaschev, M.: Minimal module extraction from DL-Lite ontologies using QBF
solvers. In: Proc. of IJCAI-09. pp. 836–841 (2009)
14. Parsia, B., Schneider, T.: The modular structure of an ontology: an empirical study.
In: Proc. of KR-10. pp. 584–586. AAAI Press/The MIT Press (2010)
15. Sattler, U., Schneider, T., Zakharyaschev, M.: Which kind of module should I
extract? In: Proc. of DL 2009. ceur-ws.org, vol. 477 (2009)
16. Spackman, K.: Managing clinical terminology hierarchies using algorithmic calcu-
lation of subsumption: Experience with SNOMED-RT. Journal of the American
Medical Informatics Association (2000), fall Symposium Special Issue.