A Modularization-Based Approach to Finding

All Justications for OWL DL Entailments

Boontawee Suntisrivaraporn
1
, Guilin Qi
2
, Qiu Ji
2
, and Peter Haase
2
1
Theoretical Computer Science, TU Dresden, Germany
[email protected]
2
AIFB Institute, University of Karlsruhe, Germany
|gqi,qiji,[email protected]
Abstract. Finding the justications for an entailment (i.e., minimal sets
of axioms responsible for it) is a prominent reasoning service in ontology
engineering, as justications facilitate important tasks like debugging in-
consistencies or undesired subsumption. Though several algorithms for
nding all justications exist, issues concerning eciency and scalability
remain a challenge due to the sheer size of real-life ontologies. In this
paper, we propose a novel method for nding all justications in OWL
DL ontologies by limiting the search space to smaller modules. To this
end, we show that so-called locality-based modules cover all axioms in
the justications. We present empirical results that demonstrate an im-
provement of several orders of magnitude in eciency and scalability of
nding all justications in OWL DL ontologies.
1 Introduction
Since the Web Ontology Language (OWL) has become a W3C standard, it is
widely believed that ontologies play a prominent role in formal representation
of knowledge on the Semantic Web. The main advantages of employing OWL
in knowledge engineering are twofold. On the one hand, the well-dened seman-
tics of Description Logic (DL), which is the logical underpinning of OWL, helps
guarantee that everyone on the Web understands the described knowledge in a
consistent way. On the other hand, reasoning services can be exploited to derive
implicit knowledge from the one explicitly given. DL systems can, for example,
identify unsatisable concepts and classify a given ontology, i.e., compute all the
subsumption (subconceptsuperconcept) relationships between the concepts de-
ned in the ontology. These standard reasoning services have proved essential
but not sucient in engineering real-world ontologies. This is because building
ontologies is an error-prone endeavor. Although most DL systems can detect an
error (an unsatisable concept or undesired subsumption) in a given ontology,
additional reasoning is needed in order to nd its justications, i.e., minimal
subsets of the ontology that still have the error.
Several techniques for nding all justications have been proposed in the
literature in the past decade which can be categorized into glass-box approaches
and black-box approaches.
J. Domingue and C. Anutariya (Eds.): ASWC 2008, LNCS 5367, pp. 115, 2008.
c Springer-Verlag Berlin Heidelberg 2008
2 B. Suntisrivaraporn et al.
Glass-box approaches require the decision (e.g., tableau) procedure to be mod-
ied, usually by adding labels to keep track of relevant axioms used during the
computation [14,12,11,1,2]. Most of the work in this direction considers specic
Description Logics, e.g., /L(, and a specic type of entailment, e.g., concept un-
satisability. In [14], Schlobach and Cornet proposed an extension to the tableau
algorithm for /L( with unfoldable TBoxes. The extension uses labels to keep
track of axioms used during the computation which directly corresponds to justi-
cations. They also coined the name axiom pinpointing for the task of nding
justications for an entailment. Since glass-box approaches are based on modify-
ing the internals of a DL reasoning algorithm, an extension has to be developed
for each DL. Meyer et al. extended the idea to /L( with general concept in-
clusions (GCIs) [12], and Kalyanpur et al. extended it to the more expressive
DL oH1T(T) [11] and oHO1^(T) [10] which underly the core of OWL. In
[1], a general approach for extending a tableau-based algorithm to a pinpointing
algorithm is proposed which can be used to nd all justications for a given
entailment. Most previous work on glass-box methods considers tableau-based
reasoning algorithm. An exception is the work by Baader et al. [2] which ex-
tends the polytime classication algorithm in order to compute justications for
a subsumption relation in the lightweight DL cL
+
, and also shows that axiom
pinpointing is inherently hard, i.e., determining whether there is a justication
within a given cardinality bound is NP-complete despite tractability of the un-
derlying DL.
The other class of approaches to axiom pinpointing is known as black-box,
where a DL reasoner is merely used to test specic entailment queries, and as
such its internals need not be modied. With a nave pruning algorithm, a jus-
tication can be computed by invoking the DL reasoner linear number of times
[11,2]. The nave algorithm essentially sweeps through all the axioms in the on-
tology and tests if the entailment still holds in absence of each axiom. Since
this approach is independent from reasoning algorithms, it can be easily imple-
mented on top of any existing DL reasoners. The main disadvantage, however,
is that it typically requires several calls to the DL reasoning services that are
already computationally expensive. Therefore, several optimization techniques
have very recently been proposed that help to reduce the number of calls to
the DL reasoner and hence speed up the black-box approach. Examples include
the sliding window technique employed in the fast pruning algorithm [10], the
binary-search idea adapted to obtain a best-case logarithmic pruning algorithm
[3], and the relevance-based selection function that syntactically select relevant
axioms from the ontology [9]. Based on a black-box pruning algorithm for com-
puting a single justication, the hitting set tree (HST) algorithm [13,10,9] can
be used to recursively compute all justications.
Recently, ontology modularity and modularization have been studied exten-
sively, with various applications ranging from ontology re-use and optimization
of classical reasoning such as subsumption, as well as non-classical reasoning
such as incremental classication [5] and axiom pinpointing [3]. Closely related
to [9] is the modularization-based approach to axiom pinpointing where relevant
A Modularization-Based Approach to Finding All Justications 3
Table 1. Syntax and semantics of S1O1Q concepts and axioms
Name Syntax Semantics
top
I
concept name A A
I

I
nominal |a |a
I

negation C
I
\C
I
conjunction C D C
I
D
I
exists restriction r.C |x
I
[ y
I
: (x, y) r
I
y C
I

at-least restriction ns.C |x

I
[ |y : (x, y) s
I
y C
I
n
role name r r
I

I

I
inverse role r

|(x, y)
I

I
[ (y, x) r
I

role hierarchy r s r
I
s
I
transitivity Trans(r) (x, y), (y, z) r
I
implies (x, z) r
I
GCI C D C
I
D
I
axioms are precisely those axioms in the module [3]. In order to exploit modu-
larity in black-box axiom pinpointing, Baader and Suntisrivaraporn showed that
the reachability-based module [16] covers all justications for an entailment of
interest in cL
+
[3].
In the present paper, we combine the relevance-based techniques developed
in [9] and the modularization-based techniques in [3] to eectively enhance the
HST pinpointing algorithm. Since the results in [3] are w.r.t. reachability-based
modules for cL
+
, we need to adopt the locality-based module [6] for oHO1Q.
Our main contributions in the present paper are twofold. In theory, we show that
the minimal locality-based module is a subsumption module (rst dened in [3]),
i.e., it covers all justications. As a consequence, it suces to focus on axioms
in the module when nding all justications and when testing subsumption. In
practice, we have implemented the approach using KAON2 as the black-box rea-
soner and evaluated it on realistic ontologies. Our empirical results demonstrate
an improvement of several orders of magnitude in the eciency and scalability of
nding all justications. The results thus render the black-box approach feasible
for application-scale OWL DL ontologies.
2 Preliminaries
In this section, we give formal denitions for oHO1Q ontologies, justications
and locality-based modules. Then, we introduce selection functions and the HST
pinpointing algorithm.
Description logic and justications
To make the paper self-contained, we rst introduce the Description Logic (DL)
oHO1Q [7] which is the underpinning DL formalism of the Web Ontology Lan-
guage (OWL DL and OWL Lite).
4 B. Suntisrivaraporn et al.
Starting with disjoint sets of concept names CN, role names RN and individuals
Ind, a oHO1Q-role is either a role name r RN or an inverse role r

with
r RN. We denote by Rol the set of all oHO1Q-roles. oHO1Q-concepts can
be built using the constructors shown in the upper part of Table 1, where a
Ind, r, s Rol with s a simple role
1
, n is a positive integer, A CN, and C, D
are oHO1Q-concepts.
2
We use the standard abbreviations: stands for ;
C . D stands for (C D); r.C stands for (r.C); and ns.C stands
for ( (n + 1)s.C). We denote by Con the set of all oHO1Q-concepts.
A oHO1Qontology O is a nite set of role hierarchy axioms r _ s, transitivity
axioms Trans(r), and a general concept inclusion axioms (GCIs) C _ D with
r, s Rol and C, D Con.
3
We write CN(O), RN(O) and Ind(O) to denote,
respectively, the set of concept names, role names and individuals occurring in
the the ontology O, and Sig(O) to denote the signature of O, i.e., CN(O)
RN(O) Ind(O). Similarly, Sig(r), Sig(C) and Sig() are used to denote the
signature of a role, a concept and an axiom, respectively.
The DL semantics is dened by means of interpretations 1 with a non-empty
domain
I
and a function
I
that maps each concept C Con to a subset of
the domain and each role r Rol to a binary relation over the domain. An
interpretation 1 is a model of an ontology O (1 [= O), if the conditions given
in the semantics column of Table 1 are satised. The main types of entailments
are concept satisability: C is satisable w.r.t. O if there exists a model 1 of
O such that C
I
,= ; and concept subsumption: C is subsumed by D w.r.t. O
(written O [= C _ D or C _
O
D) if, for every model 1 of O, C
I
D
I
. Without
loss of generality, we restrict attention to concept subsumption in what follows.
Considering an example ontology depicted in Figure 1, all DL reasoners are able
to detect that the subsumption O
ex
[= = (Endocarditis _ HeartDisease) holds.
Denition 1 (Justication). Let O be a oHO1Q ontology with an entailment
(i.e., O [= ). A subset J O is a justication for in O if J [= and, for
every J

J, J

,[= .
Justications for an entailment need not be unique. Moreover, given an ontology
and an entailment, the number of justications may be exponential in the size
of the ontology. For the small example ontology O
ex
(see Figure 1), it is not
dicult to infer that there are precisely two justications for : one consisting
of axioms marked by , and the other by .
Modularization
We now introduce the notions of syntactic locality and locality-based module,
which have been rst introduced in [6]. Syntactic locality is used to dene the
notion of module for a signature, i.e., a subset of the ontology that preserves the
meaning of names in the signature.
1
A simple role is neither transitive nor a superrole of a transitive role.
2
Concepts and roles in DL correspond to classes and properties in OWL, respectively.
3
A concept denition A C is an abbreviation of two GCIs A C and C A,
while ABox assertions C(a) and r(a, b) can be expressed as the GCIs |a C and
|a r.|b, respectively.
A Modularization-Based Approach to Finding All Justications 5

1
Pericardium Tissue part-of.Heart

2
Endocardium Tissue part-of.HeartValve
part-of.HeartWall

3
HeartValve BodyValve part-of.Heart

4
HeartWall BodyWall part-of.Heart

5
Pericarditis Inammation has-loc.Pericardium

6
Endocarditis Inammation has-loc.Endocardium

7
Inammation Disease acts-on.Tissue

8
Disease has-loc.Heart HeartDisease

9
part-of has-loc

10
Trans(has-loc)
Fig. 1. An example ontology O
ex
; the minimal locality-based module O
loc
Endocarditis
; and
the justications for Endocarditis
O
HeartDisease
Denition 2 (Syntactic locality for oHO1Q). Let S be a signature. The
following grammar recursively denes two sets of concepts Con

(S) and Con

(S)
for a signature S:
Con

(S) ::= A

[ (C

) [ (C C

) [ (r

.C) [ (r.C

)
[ ( n r

.C) [ ( n r.C

)
Con

(S) ::= (C

) [ (C

1
C

2
)
where A

, S is a concept name, C is a oHO1Q-concept, C

Con

(S),
C

i
Con

(S) (for i = 1, 2), and Sig(r

) , S.
An axiom is syntactically local w.r.t. S if it is of one of the following
forms: (i) r

_ r, (ii) Trans(r

), (iii) C

_ C or (iv) C _ C

. The set of all

oHO1Q-axioms that are syntactically local w.r.t. S is denoted by s local(S). A
oHO1Q-ontology O is syntactically local w.r.t. S if O s local(S).
Intuitively, if an axiom is syntactically local w.r.t. S, its interpretation is
directly aected by that of symbols in S, in the sense that is true in every
interpretation 1 in which concept and role names from S are interpreted with
the empty set. Based on this notion, locality-based modules can be dened as
follows: Let O be a oHO1Q ontology, O

O a subset of it, and S a signature.

Then, O

is a locality-based module for S in O if every axiom OO

is
syntactically local w.r.t. S Sig(O

). Given an ontology O and a signature S,

there always exists a unique, minimal locality-based module [4], denoted by O
loc
S
.
In the example ontology, it can be easily veried that the underlined axioms are
precisely those in O
loc
{Endocarditis}
.
The notion of strong subsumption module (rst introduced in [3]) is essential
for our modularization-based approach.
6 B. Suntisrivaraporn et al.
Denition 3 (Strong subsumption module). Let o O be oHO1Q on-
tologies, and A a concept name. Then, o is a subsumption module for A in O
if, for all B CN(O): A _
O
B i A _
S
B.
A subsumption module o for A in O is called strong if, for all B CN(O):
A _
O
B implies that J o, for every justication J for A _ B in O.
Observe that the largest such strong subsumption module is the whole ontology
itself, and the smallest such module is precisely the union of all justications
J for A _ B in O, for all superconcept B of A. For our purpose, the minimal
locality-based module is of interest since it is relative small (though not smallest)
and cheap to compute (i.e., quadratic time).
Selection functions
We introduce the notion of selection function in a single ontology given in [8],
which will be used in our algorithm to extract a subset of an ontology relevant
to a subsumption to some degree. Though applied to arbitrary DL languages,
we here restrict attention to oHO1Q:
Denition 4 (Selection function). Let L be the set of all oHO1Q axioms
over a set of signature. Then, a selection function for L is a mapping s
L
:
T(L) L N T(L) s.t. s
L
(O, , k) O, where T(L) is the power set of L.
Intuitively, a selection function selects a subset of an ontology w.r.t. an axiom
at step k. A specic selection function based on syntactic relevance is employed
in our algorithm. We begin with dening direct relevance between two axioms.
Denition 5 (Direct relevance). Two axioms and are directly relevant
i Sig() Sig() ,= .
The intuition is that two axioms are directly relevant if they share a common
(concept or role) name. Another relevance relation is given in [15]. However, that
relevance relation is tailored for unfoldable DL /L(, and as such the selection
function dened by it cannot be used to nd all justications in our setting, so
we do not consider it here.
Based on the notion of direct relevance, we can dene the notion of relevance
between an axiom and an ontology.
Denition 6. An axiom is relevant to an ontology O i there exists an axiom
in O such that and are directly relevant.
We introduce the relevance-based selection function which can be used to nd
all the axioms in an ontology that are relevant to an axiom to some degree.
Denition 7 (Relevance-based selection function). Let O be an ontology,
be an axiom and k be an integer. The relevance-based selection function,
written s
rel
, is dened inductively as follows:
s
rel
(O, , 0) =
s
rel
(O, , 1) = O : and are directly relevant
s
rel
(O, , k) = O : is directly relevant to s
rel
(O, , k 1), where k > 1.
We call s
rel
(O, , k) the k-relevant subset of O w.r.t. . For convenience, we
dene s
k
(O, ) = s
rel
(O, , k) s
rel
(O, , k 1) for k 1.
A Modularization-Based Approach to Finding All Justications 7
Hitting set tree (HST) algorithm
We briey introduce some notions regarding Reiters Hitting Set Tree algorithm
given in [13] which will be used in our algorithm to nd all justications. We
follow the reformulated notions in Reiters theory in [10]. Given a universal set
U, and a set S = s
1
, ..., s
n
of subsets of U which are conict sets, i.e. subsets of
the system components responsible for the error. A hitting set T for S is a subset
of U such that s
i
T ,= for all 1 i n. A minimal hitting set T for S is a
hitting set such that no T

T is a hitting set for S. A hitting set T is cardinality-

minimal if there is no other hitting set T

such that [T

[ < [T[. Reiters algorithm

is used to calculate minimal hitting sets for a collection S = s
1
, ..., s
n
of sets
by constructing a labeled tree, called a Hitting Set Tree (HST). In a HST, each
node is labeled with a set s
i
S, and each edge is labeled with an element in

s
i
S
s
i
. For each node n in a HST, let H(n) be the set of edge labels on the
path from the root of the HST to n. Then the label for n is any set s S such
that s H(n) = , if such a set exists. Suppose s is the label of a node n, then
for each s, n has a successor n

connected to n by an edge with in its

label. If the label of n is the empty set, then we have that H(n) is a hitting set
of S. In the case of nding justications, the universal set corresponds to the
ontology and a conict set corresponds to a justication [10].
3 Justication Coverage in Locality-Based Modules
This section presents the main technical contribution of the paper that lays the
foundation of our modularization-based algorithm. We show that a locality-based
module for S=A in O is a strong subsumption module for A in O.
Proposition 1. Let S be a signature, and 1 = (
I
,
I
) an interpretation such
that x
I
= for all (concept and role) names x , S. Then, (C

)
I
= for every
concept C

Con

(S), and (C

)
I
=
I
for every concept C

Con

(S).
The proof is an easy induction on the structure of the concepts C

and C

.
Intuitively, every concept in Con

(S) (Con

(S), resp.) behaves as if it were the

top concept (the bottom concept, resp.) in any interpretation 1 with x
I
= for
all x , S. It follows that syntactically local axioms of the form C

_ C and
C _ C

are vacuously satised by such an interpretation 1. This property of

syntactically local axioms is used to prove the following lemma.
Lemma 1. Let O be a oHO1Q ontology, A, B concept names in Sig(O) such
that A _
O
B, O
loc
A
a locality-based module for A in O. If A _
S
B for an
o O such that o , O
loc
A
, then A _
S
B with o

= o O
loc
A
.
Proof. We show the contraposition by assuming that A ,_
S
B and then demon-
strating that A ,_
S
B. Since A ,_
S
B, there must be a model 1

of o

and
an individual w
I

such that w A
I

B
I

. Construct a new interpreta-

tion 1 based on 1

by setting x
I
:= for all symbols (role or concept names)
x Sig(O)Sig(O
loc
A
). Obviously, w A
I
since 1 does not change the interpre-
tation of A Sig(O
loc
A
). There are two possibilities for B: either B
I
= B
I

or
B
I
= . In either case, we have that w , B
I
.
8 B. Suntisrivaraporn et al.
It remains to show that 1 is a model of o, i.e., satises every axiom =
(
L
_
R
) in o. We make a case distinction as follows:
O
loc
A
. It follows that o

, and thus 1

[= . By construction, both 1
and 1

agree on the interpretation of symbols in Sig(O

loc
A
) and thus Sig().
Hence, 1 [= as required.
, O
loc
A
. By denition of locality-based modules, is syntactically local
w.r.t. S = Sig(O
loc
A
) A. Then, there are four possibilities for :
= r

_ r. First, assume that r

is a role name. Then, r

, S and
thus r

Sig(O)Sig(O
loc
A
). By construction of 1, (r

)
I
= . Otherwise,
r

is an inverse role s

. Then, s Sig(r

) , S. It follows that s
Sig(O)Sig(O
loc
A
), and thus (r

)
I
= s
I
= . In both cases, 1 [= as
required.
= Trans(r

). Analogous to the rst case.

= C

_ C. By Proposition 1, (C

)
I
= . Hence, 1 [= .
= C _ C

. By Proposition 1, (C

)
I
=
I
. Hence, 1 [= .
Since 1 is a model of o such that w A
I
B
I
, we have A ,_
S
B, contradicting
the premise of the lemma.
Now, we are ready to establish the required property of the modules:
Theorem 1 (O
loc
A
is a strong subsumption module). Let O be a oHO1Q
ontology and A a concept name. Then O
loc
A
is a strong subsumption module for
A in O.
Proof. The fact that O
loc
A
is a subsumption module has been shown in [4]. It
remains to show that it is strong, i.e., every justication J O for A _
O
B is
contained in O
loc
A
, for every concept name B CN(O).
Assume to the contrary that there is a concept name B and a justication
J for A _
O
B that is not contained in O
loc
A
. By Lemma 1, the strict subset
J

= J O
loc
A
of J is such that A _
J
B. Obviously, J is not minimal and hence
cannot be a justication for A _
O
B, contradicting the initial assumption.
Intuitively, the (minimal) locality-based module for S = A in a oHO1Q-
ontology O contains all the relevant axioms for any subsumption = (A _
O
B),
in the sense that all responsible axioms for are included. In other words, in
order to nd all justications for a certain entailment in an OWL ontology,
it is sucient to consider only axioms in the locality-based module. Since the
minimal locality-based modules are relatively very small (see, e.g., [6,16]), our
modularization-based approach proves promising. The empirical results on real-
life ontologies are described in Section 5.
4 Our Modularization-Based Algorithm
In this section, we propose a new algorithm for nding all justications based
on the relevance-based algorithm and the modularization extraction algorithm.
Before we describe our algorithm, we need to recap the relevance-based algorithm
given in [9].
A Modularization-Based Approach to Finding All Justications 9
Algorithm 1. REL ALL JUSTS(A _ B, O, s)
Data: An ontology O, a subsumption A B and a selection function s.
Result: All justications
begin 1
Globals : ; 2
O

HS HS
local
; k 1; 3
S s(O, A B, k); 4
while S ,= do 5
O

S; 6
if HS
local
,= then 7
for P HS
local
do /* Get global hitting sets */ 8
if O \ P ,[= A B then 9
HS HS |P; 10
HS
local
HS
local
\ HS; 11
if (HS
local
= ) then 12
return /* Early termination */; 13
HS
temp
HS
local
; 14
for P HS
temp
do /* Expand hitting set tree */ 15
(

, HS

local
) EXPAND HST(A B, O

\ P); 16

; 17
HS
local
HS
local
|P P

[P

HS

local
\ |P; 18
else if O

[= A B then 19
(, HS
local
) EXPAND HST(A B, O

); 20
k k + 1; 21
S s
k
(O, A B); 22
return 23
end 24
The relevance-based algorithm (Algorithm 1) receives an ontology O, a sub-
sumption A _ B of O and a selection function s, and outputs the set of all
justications . We sketch the basic idea of the algorithm and refer to [9] for
details of the algorithm. First of all, we nd the rst k such that A _ B is
inferred by the k-relevant subset O

of O, i.e., the if condition in line 19 is

satised. We then call Algorithm 2 to nd a set of justications for A _ B in
O

and a set of local hitting sets, where a local hitting set is a hitting set for all
justications in the selected sub-ontology, i.e., O

in line 20. We then add to the

sub-ontology obtained in the previous iteration those axioms that are directly
relevant this sub-ontology. For those local hitting sets that are not hitting sets of
all justications in the entire ontology O, we call Algorithm 2 to further expand
them, and so on.
To compute a single justication in Algorithm 2, we invoke a sub-procedure
SINGLE JUST(, O) which is a black-box pinpointing algorithm optimized either
by the sliding window technique in [10] or by binary search technique in [3].
The correctness of Algorithm 1 follows from Theorem 1 in [9].
10 B. Suntisrivaraporn et al.
Algorithm 2. EXPAND HST(A _ B, O)
Data: An ontology O and a subsumption A B of O
Result: A set of justications for A B in O and a set of hitting sets
begin 1
HS HS
1
2
J SINGLE JUST(A B, O) 3
|J 4
for J do /* Create all possible branches. */ 5
HS
1
HS
1
|| 6
while true do 7
HS
2
8
for (P HS
1
) do 9
if O \ P ,[= A B then 10
HS HS |P 11
else 12
HS
2
HS
2
|P /* Branches need to be expanded */ 13
if (HS
1
= ) or (HS
2
= ) then 14
return (, HS) 15
HS
1
16
for P HS
2
do 17
J SINGLE JUST(A B, O \ P) 18
|J 19
for J do 20
HS
1
HS
1
|P | 21
end 22
Theorem 2. Given an ontology O, a subsumption A _ B of O and a relevance-
based selection function s
rel
, returned by Algorithm 1 is the set of all justi-
cations for A _ B.
Based on the algorithms introduced above, we propose our novel algorithm for
computing all the justication. The idea of our algorithm is straightforward:
to nd all justications for a subsumption A _ B in O, we rst extract the
locality-based module O
loc
A
for S = A in O and then apply Algorithm 1.
The method is outlined in Algorithm 3, where EXTRACT MODULE implements
the locality-based extraction algorithm in [4], and s
rel
is the relevance-based
selection function. The correctness of the algorithm can be seen by Theorem 1
and Theorem 2. We illustrate the eectiveness of our algorithm by means of an
example:
Example 1. Consider an ontology O that contains the following axioms:

1i
: A
1i
_ P
1i
Q
1i
Z,
2i
: P
1i
_ A
2i
Z,
3i
: Q
1i
_ A
2i
Z

4i
: A
2i
_ P
2i
Q
2i
Z,
5i
: P
2i
_ A
3i
Z,
6i
: Q
2i
_ A
3i
Z,
A Modularization-Based Approach to Finding All Justications 11
Algorithm 3. MODULE ALL JUSTS(A _ B, O)
Data: An ontology O and a subsumption A B
Result: All justications
begin 1
O
loc
A
EXTRACT MODULE(O, A) 2
return REL ALL JUSTS(A B, O
loc
A
, s
rel
) 3
end 4
{
11
,
21
,
41
,
51
}

11

21
{
11
,
31
,
41
,
51
} {
11
,
31
,
41
,
61
}

41

51

31

41

61
{
11
,
21
,
41
,
61
}

11

31

41

51

{
11
,
31
,
41
,
61
}

11
h

11

31

41

61
h h h
h h

11

21

41

61
h h h
h
Fig. 2. Finding all justications by HST algorithm on the locality-based module. Each
rectangle represents a justication, and the bold rectangle indicates a justication
reuse. means early path termination, while

means a hitting set is found.

for 1 i 10000. Obviously, O comprises 60 000 axioms and entails the sub-
sumption = (A
11
_ A
31
). While such an ontology clearly is not a realistic
ontology, it well demonstrates the need and potential of search space reduction.
If algorithm REL ALL JUSTS is applied directly to this ontology, one cannot
expect an acceptable performance when nding all justications. This is be-
cause: (i) SINGLE JUST(, O) has to prune a very large set, and (ii) each sub-
sumption test is w.r.t. the entire ontology O since all the axioms O share a
common concept Z. In our modularization-based approach, however, we rst
extract the locality-based module O
loc
A
11
for S = A
11
in O, and then apply
REL ALL JUSTS to O
loc
A
11
instead of O. Since the module contains only 6 axioms,
i.e., O
loc
A
11
=
11
,
21
,
31
,
41
,
51
,
61
, both points above can be achieved in
much less time.
Figure 2 illustrates the process of nding all justications by means of expand-
ing a hitting set tree (HST). To begin with, a justication
11
,
21
,
41
,
51
is
computed by SINGLE JUST(, O
loc
A
11
), which is taken as the root of the tree. Since
O
loc
A
11
dispensed with
11
does not entail ,
11
is a hitting set. On the other
hand, O

= O
loc
A
11

21
still entails , and thus another justication can be com-
puted by calling SINGLE JUST(, O

). The process continues to expand HST un-

til it nds all other justications for :
11
,
31
,
41
,
51
,
11
,
31
,
41
,
61
,

11
,
21
,
41
,
61
. Observe that the node following the branch
51
is a result
of the optimization justication reuse.
12 B. Suntisrivaraporn et al.
Table 2. Benchmark ontologies and their characteristics
Ontologies Axioms Concepts Roles Module size Extraction time
Average Maximum (sec)
Galen 4 529 2 748 413 75 530 6
Go 28 897 20 465 1 16 125 40
Nci 46 940 27 652 70 29 436 65
5 Empirical Results
Our algorithm has been realized by using KAON2
4
as the black-box reasoner. Of
course, the method (like other black-box approaches) can be applied to any other
reasoner, e.g., RacerPro
5
and FaCT++
6
. To fairly compare with the pinpointing
algorithm in [10], we re-implemented it with KAON2 API (henceforth referred
to as ALL JUSTS algorithm). The experiments have been performed on a Linux
server with an Intel(R) CPU Xeon(TM) 3.2GHz running Suns Java 1.5.0 with
allotted 2GB heap space.
Benchmark ontologies used in our experiments are the Galen Medical Knowl-
edge Base
7
, the Gene Ontology (Go)
8
and the US National Cancer Institute
thesaurus (Nci)
9
. The three biomedical ontologies are well-known to both the
life science and Semantic Web communities since they are employed in real-world
applications and often used as benchmarks for testing DL reasoners. Both Go
and Nci are formulated in the lightweight DL cL, while Galen uses expressiv-
ity of the more complex DL oHT. Some information concerning the size and
characteristics of the benchmark ontologies are given in the left part of Table 2.
Modularization reveals structures and dependencies of concepts in the ontologies
as argued in [4,16]. We extract the (minimal) locality-based module for S = A
in O, for every benchmark ontology O and each concept name A CN(O). The
size of the modules and the time required to extract them are shown in the last
three columns of Table 2. Observe that the modules in Galen are larger than
those in the other two ontologies although the ontology itself is smaller. This
suggests that Galen is more complex in the sense that more axioms in it are
non-local (thus relevant) according to Denition 2.
In the experiments, we consider three concept names in CN(O) for each benchmark
ontology O such that one of them has the largest locality-based module
10
. For the
sake of brevity, we denote by subs(O) the set of all tested subsumptions A _ B
in O, with A one of the three concept names mentioned above and B an inferred
4
http://kaon2.semanticweb.org/
5
http://www.racer-systems.com/
6
http://owl.man.ac.uk/factplusplus/
7
http://www.openclinical.org/prj galen.html
8
http://www.geneontology.org
9
http://www.mindswap.org/2003/CancerOntology/nciOntology.owl
10
The concept name with largest module is hand-picked in order to cover hard cases in
our experiments, while the other two are randomly selected.
A Modularization-Based Approach to Finding All Justications 13
subsumer of A. For each O of our benchmark ontologies, we compute all justica-
tions for in O, where subs(O). In order to compare with the other existing
approaches, we performthe following for each and Oto compute all justications:
1. ALL JUSTS(, O) (i.e., the algorithm in [10]).
2. REL ALL JUSTS(, O, s
rel
);
3. MODULE ALL JUSTS(, O);
The justication results by MODULE ALL JUSTS are shown in Table 3, where
the ontology marked with means that some run does not terminate within the
two hour time-out. Precisely, there are three subsumptions in Go and one in Nci,
for which the computation took more than two hours. The statistics given on
the right hand side of the table does not take into account these subsumptions.
Table 3. Justication results using the modularization-based approach
Ontologies Subsumptions Justications Justication size
[subs(O)[ Average Maximum Average Maximum
Galen 69 1.5 4 9.7 24
Go

53 3.2 11 5.3 9
Nci

23 1.6 8 5.4 9
To visualize the time performances of the three algorithms, we randomly
selected two subsumptions
1
and
2
from subs(O) for each ontology O and
compared their computation time required by the three algorithms. These sub-
sumptions are shown as follows:
Galen:
1
AcuteErosionOfStomach _ GastricPathology
Galen:
2
AppendicularArtery _ PhysicalStructure
Go:
1
GO 0000024 _ GO 0007582
Go:
2
GO 0000027 _ GO 0044238
Nci:
1
CD97 Antigen _ Protein
Nci:
2
APC 8024 _ Drugs and Chemicals
The chart in Figure 3 depicts the overall computation time required for each
algorithm to nd all justications for each tested subsumption. Unlike the time
results reported in [10], which excluded the time for satisability checking, we re-
port here the overall computation time, i.e. the total time of the algorithm includ-
ing the time needed by the black-box reasoner for the standard reasoning tasks.
Observe that both ALL JUSTS and REL ALL JUSTS did not yield results within
the time-out of two hours on three out of six tested subsumptions (marked by
TO on the chart). Comparing these two algorithms (without modularization),
REL ALL JUSTS performs noticeably better than ALL JUSTS in most cases. For
instance, on the subsumptions Galen:
2
and Nci:
2
, REL ALL JUSTS outper-
forms ALL JUSTS by about 10 and 20 minutes, respectively. On the subsumption
Go:
2
, both algorithms show a similar performance, i.e., time dierence is less
than a minute. More explanations on the comparison between these two algo-
rithms can be found in [9].
14 B. Suntisrivaraporn et al.
TO TO TO TO TO TO
Subsumption
Module Size
Number of Justs
Justs Size(Avg)
0.01
0.1
1
10
100
1000
10000
Galen:X1 Galen:X2 GO:X1 GO:X2 NCI:X1 NCI:X2
293 133 25 26 436 9
4 2 10 1 2
19.5 6.5 6.9 6
T
i
m
e

(
s
e
c
)
ALL_JUSTS REL_ALL_JUSTS MODULE_ALL_JUSTS
1 1 2
6 6 6
Fig. 3. The time performance of three algorithms for nding all justications
Interestingly, MODULE ALL JUSTS outperforms all the other algorithms on
all subsumptions, and the improvement is tremendous as can be seen in all
cases in the chart. This empirically conrms our initial conjecture that, given
the strongness property (in the sense of Denition 3) and the small size (see
Table 2 and [6,16]) of locality-based modules, our optimization should be highly
eective. As an example, MODULE ALL JUSTS took only 0.6 seconds to nd
all the justications for Nci:
2
, while REL ALL JUSTS needed 3 242 seconds. In
this case, the locality-based module for APC 8024 in Nci consists of 9 axioms,
whereas the whole ontology has some tens of thousands of axioms. Although
the selection function used in REL ALL JUSTS also prunes the search space by
considering only k-directly relevant axioms (see Denition 7) when HST algo-
rithm is executed, several irrelevant axioms (in the sense of syntactic locality)
are still considered.
6 Conclusion
In this paper, we proposed a novel approach for nding all justications for an
entailment in OWL DL. The approach is based on the computation of minimal
locality-based modules. We rst showed that locality-based modules always cover
all axioms in all justications and exploited this property to limit the search
space when nding all justications. Then, we presented a modularization-based
pinpointing algorithm that is based on relevance-based techniques and a hitting
set tree algorithm. Finally, we reported on several promising empirical results
that demonstrate an improvement of several orders of magnitude in eciency and
scalability of nding all justications in OWL DL ontologies. Our work is based
on locality-based modules. As future work, we shall investigate dierent kinds
of modules and selection functions that hopefully produce even more relevant
axioms for pinpointing.
A Modularization-Based Approach to Finding All Justications 15
Acknowledgements. This work was partially supported by the DFG project
under grant BA1122/11-1 and the EU under the IST project NeOn (IST-2006-
027595) http://www.neon-project.org.
References
1. Baader, F., Pe naloza, R.: Axiom pinpointing in general tableaux. In: Olivetti, N.
(ed.) TABLEAUX 2007. LNCS, vol. 4548, pp. 1127. Springer, Heidelberg (2007)
2. Baader, F., Pe naloza, R., Suntisrivaraporn, B.: Pinpointing in the description logic
c/
+
. In: Hertzberg, J., Beetz, M., Englert, R. (eds.) KI 2007. LNCS, vol. 4667,
pp. 5267. Springer, Heidelberg (2007)
3. Baader, F., Suntisrivaraporn, B.: Debugging SNOMED CT using axiom pinpoint-
ing in the description logic c/
+
. In: Proceedings of KR-MED 2008: Representing
and Sharing Knowledge Using SNOMED (2008)
4. Grau, B.C., Horrocks, I., Kazakov, Y., Sattler, U.: Modular reuse of ontologies: The-
ory and practice. J. of Articial Intelligence Research (JAIR) 31, 273318 (2008)
5. Cuenca Grau, B., Halaschek-Wiener, C., Kazakov, Y.: History matters: Incremen-
tal ontology reasoning using modules. In: Aberer, K., Choi, K.-S., Noy, N., Alle-
mang, D., Lee, K.-I., Nixon, L., Golbeck, J., Mika, P., Maynard, D., Mizoguchi,
R., Schreiber, G., Cudre-Mauroux, P. (eds.) ASWC 2007 and ISWC 2007. LNCS,
vol. 4825, pp. 183196. Springer, Heidelberg (2007)
6. Cuenca Grau, B., Horrocks, I., Kazakov, Y., Sattler, U.: Just the right amount:
Extracting modules from ontologies. In: Proc. of WWW 2007, Ban, Canada, pp.
717726. ACM, New York (2007)
7. Horrocks, I., Sattler, U.: A tableaux decision procedure for S1O1Q. In: Proc. of
IJCAI 2005, pp. 448453 (2005)
8. Huang, Z., van Harmelen, F., ten Teije, A.: Reasoning with inconsistent ontologies.
In: Proc. of IJCAI 2005, pp. 254259 (2005)
9. Ji, Q., Qi, G., Haase, P.: A relevance-based algorithm for nding justications of
DL entailments. In: Technical report, University of Karlsruhe (2008),
http://www.aifb.uni-karlsruhe.de/WBS/gqi/papers/RelAlg.pdf
10. Kalyanpur, A., Parsia, B., Horridge, M., Sirin, E.: Finding all justications of
OWL DL entailments. In: Aberer, K., Choi, K.-S., Noy, N., Allemang, D., Lee,
K.-I., Nixon, L., Golbeck, J., Mika, P., Maynard, D., Mizoguchi, R., Schreiber,
G., Cudre-Mauroux, P. (eds.) ASWC 2007 and ISWC 2007. LNCS, vol. 4825, pp.
267280. Springer, Heidelberg (2007)
11. Kalyanpur, A., Parsia, B., Sirin, E., Hendler, J.: Debugging unsatisable classes in
OWL ontologies. Journal of Web Semantics 3(4), 268293 (2005)
12. Meyer, T., Lee, K., Booth, R.: Knowledge integration for description logics. In:
Proc. of AAAI 2005, pp. 645650. AAAI Press, Menlo Park (2005)
13. Reiter, R.: A theory of diagnosis from rst principles. Articial Intelligence 32(1),
5795 (1987)
14. Schlobach, S., Cornet, R.: Non-standard reasoning services for the debugging of
description logic terminologies. In: Proc. of IJCAI 2003, pp. 355362 (2003)
15. Schlobach, S., Huang, Z., Cornet, R., van Harmelen, F.: Debugging incoherent
terminologies. J. Autom. Reasoning 39(3), 317349 (2007)
16. Suntisrivaraporn, B.: Module extraction and incremental classication: A prag-
matic approach for c/
+
ontologies. In: Bechhofer, S., Hauswirth, M., Homann,
J., Koubarakis, M. (eds.) ESWC 2008. LNCS, vol. 5021, pp. 230244. Springer,
Heidelberg (2008)