S-MODULES – AN APPROACH TO CAPTURE SEMANTICS
OF MODULARIZED DL KNOWLEDGE BASES
Krzysztof Goczyła, Aleksander Waloszek and Wojciech Waloszek
Faculty of Electronics, Telecommunications and Informatics, Gdańsk University of Technology
Narutowicza Str. 11/12, Gdańsk, Poland
Keywords: Description Logics and Ontologies, Knowledge Engineering, Knowledge-based Systems.
Abstract: Modularity of ontologies has been recently recognized as a key requirement for collaborative ontology
engineering and distributed ontology reuse. Partitioning of an ontology into modules naturally gives rise to
development of module processing methods. In this paper we describe an algebra of ontology modules
developed during our work on a Knowledge Base Management System called RKaSeA. The idea differs
from other algebras in the fact that we treat a module semantically, i.e. we focus on the set of a module‟s
models rather that on the set of axioms and assertions included in its representation The algebra has revealed
its potential also in the process of reasoning.
1 INTRODUCTION
Subsequent years bring more and more attention into
the area of modularization of Description Logics
(DL) knowledge bases. The main motivation is the
hope to reach the maturity of the collaborative
ontology development and reuse process comparable
to the one achieved by software engineering
methods in the case of software modules. In
consequence, many methods and techniques of
ontology decomposition and merging have been
devised.
During the course of work on a Description
Logic-based Knowledge Base Management System
(KBMS) called RKaSeA we faced the issue of
choosing the proper formalism for modularization.
Naturally we strived for allowing the user to create
and process a modularized knowledge base, but we
wanted also to enable her to extract a fragment of a
selected module, combine it with a fragment from
other module, etc. Moreover, our aim was also to
explore possibilities of automated (i.e. unseen by the
user) ontology decomposition in order to obtain
shorter time of executing reasoning tasks.
As a result we developed a formalism for
describing operations on modules. The formalism is
simple, yet robust enough to describe various
complicated operations useful for expressing module
decomposition and merge. Because we focused
strongly on the semantic aspect of modules, we
called the formalism s-module algebra (pronounced
semodules, as „s’ stands here for “semantics”).
In the following we introduce basic notions of
s-module algebra and present examples of its use.
Then we discuss issues connected with decidability
and compare our work with related published
methods. A short discussion of further directions of
development of the algebra concludes the paper.
2 PRELIMINARIES
In the following we assume that we use an arbitrary
chosen description logic .
Let a signature, denoted S = C  R  I for any
, is a disjoint union of concept names (C), role
names (R), and individual names (I). C(S), R(S),
and I(S), respectively, refer to corresponding part of
S. We assume that there exist a set of acceptable
names, denoted as  (C, R, I  ).
The chosen description logics  determines the
set of (possibly complex) concepts, roles and
individuals one can build using the operators in 
and names from a signature S. We denote these sets
with 
C
(S), 
R
(S), 
I
(S), respectively. For instance,
if  is , then 
C
(S) ::= A | C | C  D | C  D |
R.C | R.C |  | , where A  C(S), C, D  
C
(S),
R  
R
(S).
An S-interpretation  is a pair (

, 

), where 

is a set called the domain of the interpretation and 

117
Goczyła K., Waloszek A. and Waloszek W. (2009).
S-MODULES – AN APPROACH TO CAPTURE SEMANTICS OF MODULARIZED DL KNOWLEDGE BASES.
In Proceedings of the International Conference on Knowledge Engineering and Ontology Development, pages 117-122
Copyright
c
 SciTePress

is an interpretation function assigning each
A  C(S) a set A

 

, each R  R(S) a binary
relation R

 

 

, and each a  I(S) an element
a

of the domain 

. Moreover each description
logic  establishes its own rules for extending the
interpretation to complex concepts, e.g. in 
(C  D)

= C

 D

.
Each description logic allows for formulating
axioms and assertions (sentences), and define the
conditions under which a specific interpretation 
satisfies a particular sentence. We denote the set of
all axioms and assertions that can be built from a
given signature S as (S). The fact that the
interpretation  satisfies a given sentence   (S)
(is its model) is denoted as    .
3 S-MODULES ALGEBRA
3.1 Basic Definitions
An assumption we take is that a user is interested in
conclusions that can be drawn from an ontology
rather than in particular axioms and assertions. So,
we define an ontology module strictly semantically,
focusing only on its interpretations.
Definition 1 (S-module). An s-module M = (S,
W) is a pair of a signature S (called a signature of
the s-module) and a class W of S-interpretations
(called models of the s-module). The two parts of M
are denoted as S(M) and W(M), respectively. Each
S-interpretation from W we call a model of M. 
According to this definition, each module simply
consists of all its models. We say that s-module
satisfies a particular sentence , denoted M  , iff
  W(M):   .
We think that creators of an ontology is not able
to foresee all its future uses. By necessity, the
creators have to focus on a small set of chosen
contexts of use of particular modules, and the
contexts of their choice may not be adequate for a
particular application of a knowledge base with this
ontology. So, the s-modules algebra puts stress on
various methods of manipulation for s-modules; that
in general allow for changing and combining
signature and models.
3.2 Operators
In this section we introduce operators of s-module
algebra. Some of the operators are non-primitive and
can be derived from others.
We assume that description logic  and domain
set  are chosen and fixed (both assumptions can be
alleviated, see Section 3.3). We denote a set of all
modules as M, a set of all signatures as  , and a set
of all S-interpretations as  (S). We also use the
notion of a projection ΄ = |S΄ of an S-
interpretation  to a signature S΄ (S΄  S). ΄ is an
S΄-interpretation for which the following holds: 
΄
= 

and X
΄
= X

for every X  S΄.
In the subsequent descriptions: for unary
operators, their operand is denoted as M, for binary
operators the operands are denoted as M
1
and M
2
. M΄
always represents a result.
Extend

S
: M  M, S   ;

S
(M) = (S(M)  S, {   (S(M)  S): |S(M)
 W(M)}). 
Extension extends a signature of a given module
M by names from a given signature S. The allowed
set of interpretations of each original name is
preserved, and so are the relationships between
original concepts, roles, and individuals (e.g. if
M  ,   (S(M)), then also 
S
(M)  ).
Project

S
: M  M, S   , S  S(M);

S
(M) = (S, {|S:   W(M)}). 
Projection reduces a signature of a given
module. However, relationships between original
concepts, roles, and individuals whose names remain
in the signature are preserved (e.g. if M  ,
  (S), then also 
S
(M)  ).
Rename


: M  M,  is a signature mapping;


(M) = ((S), (W)). 
Renaming uses the notion of a signature
mapping. Signature mapping  is a triple: (
C
, 
R
, 
I
),
each of them being a bijection from  to . By (S)
we mean 
C
(C(S))  
R
(R(S))  
I
(I(S)), and by
(), where  is an S-interpretation, we mean an
(S)-interpretation ΄ such that 
΄
= 

and (X)
΄
=
X

for every X  S. Rename preserves relationships
between concepts, roles, and individuals, however
with respect to their name changes (e.g. if M  ,
  (S(M)), then 

(M)  (), where () is 
transformed in such a way that all names in  have
been systematically changed according to ).
Select


: M  M,   (S(M));


(M) = (S, {  W(M):   }). 
KEOD 2009 - International Conference on Knowledge Engineering and Ontology Development
118

Selection leaves only these interpretations that
are models of a sentence . Obviously 

(M)  .
Union
: M  M  M, S(M
1
) = S(M
2
);
M
1
 M
2
= (S(M
1
), W(M
1
)  W(M
2
)). 
Union performs a set-theoretic union of sets of
models of s-modules. The condition that S(M
1
) =
S(M
2
) is not very restrictive because we can easily
upgrade this operation to a generalized union 
g
: M
1

g
M
2
= 
S(M
2
)
(M
1
)  
S(M
1
)
(M
2
).
Intersection
: M  M  M, S(M
1
) = S(M
2
);
M
1
 M
2
= (S(M
1
), W(M
1
)  W(M
2
)). 
Difference
–: M  M  M, S(M
1
) = S(M
2
);
M
1
– M
2
= (S(M
1
), W(M
1
) – W(M
2
)). 
Intersection and difference are analogous to the
union, and can be generalized in the similar way to
the case when signatures of the operands differ.
Union and difference are non-linguistic (strictly
semantic), i.e. their use may lead to generation of a
s-module M for which there does not exist any
corresponding set of sentences S in . This issue
will be elaborated on later in the paper.
I-Join (Intersecting Join)
: M  M  M;
M
1
 M
2
= (S΄, W΄);
S΄ = 
1
(S(M
1
))  
2
(S(M
2
));
W΄ = {   (S΄): |
1
(S(M
1
))  
1
(W(M
1
)) 
|
2
(S(M
2
))  
2
(W(M
2
))}. 
I-Join is an operation on two s-modules. It uses
two signature mappings 
1
, 
2
, each of them
preceding every terminological name in a signature
with a unique prefix. Thus, I-Join helps to solve
potential naming conflict between s-modules. I-Join
preserves relationships between original concepts
and roles in both modules (if M
1
 ,   (S(M
1
)),
then M΄  
1
(), analogically for M
2
).
I-Join is a non-primitive operation, as M
1
 M
2
can be expressed as 

1
(M
1
) 
g


2
(M
2
). This
derivation justifies the name “intersecting join” as
we may perceive this join as a “safe” way of
intersecting modules.
U-Join (union join)
: M  M  M;
M
1
 M
2
= (S΄, W΄);
S΄ = 
1
(S(M
1
))  
2
(S(M
2
));
W΄ = {   (S΄): |
1
(S(M
1
))  
1
(W(M
1
)) 
|
2
(S(M
2
))  
2
(W(M
2
))}. 
U-Join is a counterpart of I-Join. 
1
, 
2
have the
same meaning as above. U-Join offers the “safe”
way of performing union. Naturally, M
1
 M
2
=


1
(M
1
) 
g


2
(M
2
).
Put-Under

C
: M  M  M, C  
C
(S(M
2
));
M
1

C
M
2
= (S΄, W΄);
S΄ = S(M
1
)  S(M
2
);
W΄ = {   (S΄): |S(M
2
)  W(M
2
) 
(|S(M
1
)  C

)  W(M
1
)}. 
Put-Under correlates the domains of two
s-modules. We use here a restriction of an S-
interpretation : by   ΄ we mean an
interpretation ΄ = (΄,
΄
) such that X
΄
= X

 ΄
for every X  S. As each s-module induces a set of
laws that enforce certain relationships between
concepts, roles, and individuals, then Put-Under can
be perceived as a restriction of the scope of these
laws to a fragment of a larger domain.
3.3 Remarks on S-module Algebra
First we distinguish between primitive and non-
primitive operators. Such a partition is to some
extent arbitrary (e.g. we could treat I-Join rather than
Extend a primitive operation). As far as Rename is
concerned: if we need to change elements of a
signature S of a s-module M into elements of a new
signature S΄, we might think of the following
scenario. Instead of using  operation, we extend the
signature of M by S΄ (with use of ). Then we assure
the extensional equality between terms from S and
S΄ by formulating appropriate axioms (like A  B,
we assume that A  S and B  S΄). Finally, we
remove the unwanted terms by using . However,
this may not always be possible as not every
description logic allows for formulating such axioms
(e.g. in  we cannot express equality of roles).
This is why we consider Rename primitive.
Earlier we mentioned possibility of alleviation of
the two assumptions: that a single description logic
 is used in all the s-modules, and that a particular
domain set  is chosen and fixed. The latter is
simple to be lifted, the consequence is that sets of
interpretations in s-modules become classes. The
former assumption relates to the issue of multi-
Description Logics modules and its alleviation is a
more complicated. In general, the exploited
description Logic  is not used explicitly in the
definition of a s-module. Yet, it is indirectly
contained in the set of interpretations, because each
interpretation of a s-module follows the rules of
S-MODULES - AN APPROACH TO CAPTURE SEMANTICS OF MODULARIZED DL KNOWLEDGE BASES
119

expanding base-term interpretation into the
interpretation of complex roles and concepts.
Therefore, in order to translate a s-module M
1
“expressed” in 
1
into a s-module “expressed” in 
2
we just need to “contract” each interpretation
  W(M
1
) to its base interpretation and then
“expand” it in according to the rules of expansion
appropriate for the logic 
2
. This, however, may
lead to over-expressiveness of some s-modules.
Example 1 (Over-expressiveness). Let us take any
s-module M and assume that it contains 
interpretations. We extend the signature of the
module by a new role R and select only these
interpretations that satisfy the axiom Trans(R), i.e.
we build M΄ = 
Trans
(R)
(
{R}
(M)). Then we change the
logic of M΄ to . Interpretations contained in
W(M΄) no longer map concepts like  3R., but the
role R remains transitive in all interpretations in
W(M΄), although there is no possibility of
expressing this fact in . 
The effect described in the above example seems
to reveal a crucial obstacle in using multi-logic
modules. However, as it is shown below over-
expressiveness is not specific only to multi-logic.
To elaborate on this we introduce a notion of a
linguistic s-module. To ease the task we return to the
assumptions of chosen and fixed  and .
Definition 2 (Linguistic S-module). We call a
s-module M = (S, W) linguistic iff there exists a set
of sentences S  (S) such that W = {   (S):
  S:   }. 
In other words, linguistic s-modules are modules
whose models are all models of a particular set of
sentences. We denote a linguistic s-module as M(S,
S), where S is the set of sentences, or simply as M(S)
if module signature can be inferred from the context,
e.g. M({A  B, A(a)}) with signature S = {A, B, a}.
In general, when using specific operations we
have no guarantee that the outcome is linguistic even
if all operands are. These operations are called non-
linguistic and they are: Union (), Difference (–),
Projection (), and U-Join (). They may result in
obtaining a s-module M which does not correspond
directly to any set of sentences from (S(M)).
Example 2 (Non-linguistic S-module). Consider a
union M΄ of two linguistic s-modules
M΄= M({A  B})  M({B  A}). Neither M΄ A  B
nor M΄ A  B is true. But after an intersection:
M΄΄= M΄ 
g
M({A  B(a), A  B(b)}), we obtain
a s-module with no models: W(M΄΄) = . 
4 EXAMPLES
There is similarity between the s-module algebra and
the relational algebra. Both algebras aim at
delivering operators on defined units of data (or
knowledge) that allow a user to combine the units in
order to obtain a new unit, presumably better suited
for a specific purpose. Like the relational algebra,
the s-module algebra may be a base for development
of a language for the end-user, and such a language
would have a desired property of closeness.
The following example shows how to merge
information from two s-modules in order to obtain
desired piece of knowledge.
Example 3 (Intersecting S-modules). Consider two
s-modules: M
1
describes human resources and M
2
the structure of a hospital.
M
1
= M({isManagerIn.HTBusinessUnit  Expert,
Expert  Employee})
M
2
= M({leadsDepartment(johnSmith,
neurosurgery), Department(neurosurgery)}).
To merge the information from the two
s-modules in order to infer that johnSmith is an
expert, we first create an intersection of the
s-modules: M´= M
1

g
M
2
, and then restrict the set
of models by introducing additional “bridge”
axioms: M´´= M´ 
g
M({leadsDepartment 
isManagerIn, Department  HTBusinessUnit}). The
last step can also be done by double selection. 
In the example we did not encounter any name
conflict between s-modules being merged. In
general, such a conflict may occur and I-Join
operator should be used. Below we show how to
align two s-modules in which the same set of terms
is used to express different meanings.
Example 4 (Joining S-modules). Consider two
s-modules: M
1
and M
2
. They contain assessment of
several rooms for rent, and use the same
categorization and signature S = {HSRoom,
ASRoom, LSRoom}, where the concepts denote high,
average and low standard rooms. But in M
1
and M
2
different criteria were used for categorization, as in
the first case we were looking for a room to spend
just one day and in the second case to stay for a
longer period of time. We “import” the assessment
from M
1
to M
2
performing necessary translation of
classification between the s-modules.
1. In the first step we simply I-Join the modules. As
a result we obtain a module M΄= M
1
 M
2
. The
concepts have been renamed, so S(M) =
{1:HSRoom, 2:HSRoom, 1:ASRoom, …}.
2. Next, we make the criteria of assessment explicit.
In this example we use only one criterion: a
KEOD 2009 - International Conference on Knowledge Engineering and Ontology Development
120

bathroom. So, we extend the signature of M΄
appropriately: M΄΄= 
{RoomWithBathroom}
(M΄).
3. Afterwards, we bind the criteria with the
assessment. In M
1
rooms with bathrooms were
automatically considered high standard. According
to the criteria used in M
2
no room with bathroom can
be considered more than low standard.
M΄΄΄= M΄΄ 
g
M({RoomWithBathroom  1:HSRoom,
RoomWithBathroom  2:LSRoom}).
Naturally, the second axiom is valid only if the
domain consists of only rooms (which is assumed).
4. Finally we remove unwanted terms from the
module signature: M = 
{2:HSRoom, 2:ASRoom,
2:LSRoom}
(M΄΄΄).
In these steps all the translations possible to
perform were done. All average or low standard
rooms from M
1
were considered low standard in
accordance with criteria from M
2
. 
We do not claim that the s-module algebra is to
replace the existing methods of modularization, like
DDL, -connections (see e.g. d‟Aquin et al., 2008)
for a brief survey), etc. Each of the methods has its
own goals and offers apparatus for solving certain
problems (e.g. locality is in fact beyond the scope of
the current version of the s-module algebra). Instead
we argue that the s-module algebra is a tool that
might be useful in describing some common aspects
of wide range of actions involving merging and
transformation of knowledge.
The s-module algebra cannot capture some
mappings proposed by other methods. For instance,
it is impossible to map role instances into concept
instances, as proposed in (Ghidini et al., 2007) for a
version of DDL. The reason is that there is no DL
sentence for such a relationship. However, if we
extend the language with Horn rules (see e.g. Motik
et al., 2005), we can obtain somewhat similar result
with use of a rule like C(a)  R(a, b).
Example 5 (Union). Consider the s-module M:
M = M({   1murdered.{victim},
accuses
–
.TrustedWitness  murdered
–
.{victim},
TrustedWitness  presentAt.CrimeScene}).
The s-module contains knowledge that there is
only one murderer of a victim and it is the one who
is accused by a trusted witness (who was present at
the crime scene). Let consider two (mutually
exclusive) versions of facts:
M
1
= M  M({TrustedWitness(johnShady),
accuses(johnShady, tedInnocent)}
M
2
= M  M({TrustedWitness(henryBrillant),
accuses(henryBrillant, markGuilty)}.
We can hold the two version in a single s-module M΄
= M
1
 M
2
. No unambiguous conclusion about the
murder can be drawn from M΄. Fortunately, the
further information collected (John Shady actually
was not present at the crime scene) allows to rule out
one of the versions: M΄΄ = M΄ 
M({presentAt.CrimeScene(johnShady)}); M΄΄
murdered(markGuilty, victim)). 
5 DECIDABILITY ISSUES
Since the use of the s-modules algebra may result in
exceeding the original expressiveness of a chosen
description logic, it is necessary to investigate
whether basic reasoning problems remain decidable.
In our analysis we focus on the concept
satisfiability problem (csat), which for s-modules
can be formulated as follows: Given a module M and
a concept C  
C
(S(M)); check if there exists an
interpretation   W(M) for which C

 .
Factors that influence decidability are: the used
description logic  (for multi-logic modules we
assume the most expressive logic) and the set of
allowed algebra operators. Each problem instance
can be then described as a triple (p, , A), where p
is the problem name,  is the logic used, and A is
the set of primitive operators (A denotes all
operators: {,,,,,,–,}). We also make an
assumption that the only s-module constants we use
correspond to linguistic s-modules. Preliminary
results are described by the following theorems.
Theorem 8. Problem (csat, , A–{–}) is
decidable.
Sketch of proof. We associate each s-module with
one or more sets of sentences (denoted M  {S
1
, S
2
,
…}). Linguistic modules of the form M(S) are
associated with S (M {S}). Each algebraic
operation produces a new module associated with
newly constructed sets: (M {S
1
, S
2
…}) = M΄ 
{S
1
, S
2
, …}, (M  {S
1
, S
2
, …}) = M΄  {S
1
, S
2
, …},


(M  {S
1
, S
2
, …}) = M΄  {(S
1
), (S
2
) , …},
M
1
{S
1-1
, S
1-2
, …}  M
2
 {S
2-1
, S
2-2
, …} = M΄ 
{S
1-1
, S
1-2
, …, S
2-1
, S
2-2
, …}, M
1
{S
1-1
, S
1-2
, …} 
M
2
 {S
2-1
, S
2-2
, …} = M΄  {S
1-1
 S
2-1
, S
1-1
 S
2-2
,
…, S
1-2
 S
2-1
, S
1-2
 S
2-2
, …}, M
1
{S
1-1
, S
1-2
, …} 
C
M
2
 {S
2-1
, S
2-2
, …} = M΄  {
C
(S
1-1
)  S
2-1
, 
C
(S
1-1
)
 S
2-2
, …, 
C
(S
1-2
)  S
2-1
, 
C
(S
1-2
)  S
2-2
, …}. Two
operators needs special attention.  may constrain
the signature in the way that some of the sentences
from S
1
, S
2
, … may fall outside (S(M΄)).
Nevertheless, we keep track of these sentences,
watching if there are no naming conflicts (if
someone tries to reintroduce one or more of the
“dummy” names, they have to be changed). 
C
S-MODULES - AN APPROACH TO CAPTURE SEMANTICS OF MODULARIZED DL KNOWLEDGE BASES
121

needs a special “translation” of the sentences to
constrain their influence only to C

(e.g. D  E to
C  D  C  E). Under these assumption we prove
that checking satisfiability of a concept C in
M  {S
1
, S
2
, …} can be performed by checking its
satisfiability against each set of sentences S
1
, S
2
, …
(with standard  reasoner). 
Theorem 9. Problem (csat, , A) is decidable.
Proof. The same technique as in the previous proof
can be used. Details are omitted for brevity 
A question arises whether the result from
Theorem 9 can be generalized to more expressive
logics. This question is open, although we are
pessimistic in this matter because the line of
argument used in the proof suggests that the
problem is similar to extending such logics with
role negations.
6 RELATED WORK
The s-module algebra is inspired by relational
algebra, especially in its version published in (Hall
et al., 1975). In our work we draw an analogy
between a knowledge base (or ontology) module and
a relation (or a table), and between a model and a
tuple (a record in a table).
Some similarities can also be noticed with the
algebra of software modules proposed in (Herrmann
et al., 2007). Here we should compare a s-module to
software model and an interpretation to
implementation of a system.
Several ontology and module algebra have been
developed so far. One of examples is described in
(Mitra and Wiederhold, 2004). The authors share
with us some motivations (they treat ontologies as
contexts, each context represents some viewpoint).
However their algebra represents ontologies as RDF
graphs. Moreover, explicit mapping between
ontologies have to be defined in some extra-
ontological language.
One of the most recent algebra for modules
(Neon algebra) has been proposed in (d‟Aquin et al.,
2008). It also contains operations on a signature (in
the case of Neon algebra called an interface) and on
module contents. However, the contents of the
module is understood there as purely linguistic
(which also makes some of definitions not intuitive,
e.g. the definition of difference states that (M
1
– M
2
)
  iff M
1
  and M
2
| .). Additionally NeOn
algebra does not define any join operation.
7 SUMMARY
The s-module algebra provides a broad range of
tools for manipulating knowledge. So it constitutes a
framework in which many issues concerning
modularity of knowledge bases can be efficiently
described. It also provides a user with methods of
manipulation of contents of s-modules and enables
her to override the original (source) way of
modularization of an ontology.
Further planned development of the algebra is
connected mainly with its practical application:
implementation of a KBMS allowing for storing
s-modules, creation of knowledge manipulation
language for users, and efficient methods of query
execution and optimization.
ACKNOWLEDGEMENTS
The work has been supported by Polish Ministry of
Research and High Education under grant No.
N N516 4115 33.
REFERENCES
d‟Aquin, M., et al, 2008. NeOn Formalisms for
Modularization: Syntax, Semantics, Algebra. Neon
Project, Deliverable D1.1.3.
Ghidini, C., Serafini, L., and Tessaris, S. 2007. On relating
heterogeneous elements from different ontologies. In
Proceedings of the 20
th
International Workshop of
Description Logics, pp. 283–290.
Herrmann, C., Krahn, H., Rumpe, B., Schindler, M., and
Völkel, S. 2007. An Algebraic View on the Semantics
of Model Composition. In Model Driven Architecture
- Foundations and Applications, Springer-Verlag, pp.
99–113.
Hall, P., Hitchcock, P., and Todd, S. 1975. An algebra of
relations for machine computation. In Proceedings of
the 2nd ACM SIGACT-SIGPLAN symposium on
Principles of programming languages, Palo Alto, pp.
225–232.
Mitra P., Wiederhold, G. 2004. An Ontology-Composition
Algebra. In Handbook on Ontologies, Springer-
Verlag, pp. 171–216.
Motik, B., Sattler, U., and Studer, R. 2005. Query
Answering for OWL-DL with Rules. Journal of Web
Semantics: Science, Services and Agents on the World
Wide Web 3 (1), pp. 41–60.
KEOD 2009 - International Conference on Knowledge Engineering and Ontology Development
122