Closed World Reasoning for OWL2 with NBox?
REN Yuan, Jeff Z Pan?? , ZHAO Yuting
Department of Computing Science, University of Aberdeen, Aberdeen, UK
{y.ren, jeff.z.pan, yuting.zhao}@abdn.ac.uk
Abstract. In this paper, the authors investigate the problem of doing Description
Logic (DL) reasoning with partially closed world. They address this issue by
extending the syntax of DL SROIQ with an NBox, which specifies the predicates
to close, extending the semantics with the idea of Negation As Failure, reducing
the closed world reasoning to incremental reasoning on classical DL ontologies
and applying the syntactic approximation technology to improve the reasoning
performance. Compared with the existing DBox approach, which corresponds to
the relation database, the NBox approach supports deduction on closed concepts
and roles. Also, the approximate reasoning can reduce reasoning complexity from
N2EXPTIME-Complete to PTIME-Complete while preserve the correctness of
reasoning for ontologies with certain properties.
Keywords: ontology; closed world; reasoning; approximation
1
Introduction
With the fast development of the Semantic Web, ontology has become one of the major knowledge formalisms in knowledge intensive systems. Today’s de facto standard
ontology language, the Web Ontology Language (OWL) and its various profiles [1] are
based on a family of Description Logics (DLs) [2]. With its DL foundations, one of
the major feature of ontology is that it imposes the Open World Assumption (OWA) in
reasoning, which means a proposition is inferred to be true iff it is true in all possible
models of the ontology.
In contrast, many other knowledge formalisms impose the Closed World Assumption (CWA), which means a proposition is inferred to be false iff it is not inferred to
be true. In other words, unknown knowledge is regarded as false. This CWA is widely
adopted by serious knowledge representations such as Logic Program and Relational
Database. And it is also imposed by many real world applications in which people believe they have complete knowledge about the domain. For example, in Generation of
Referring Expressions [3], if a certain relation is not entailed between two objects, then
people believe these two objects have no such a relation at all. Also, CWA is important
for the checking of integrity constraints [4].
?
??
Received: 2010-09-21. Supported by the European Project Marrying Ontologies and Software
Technologies (MOST, EU ICT 2008-216691).
To whom correspondence should be addressed. Tel: +44(0)1224 274 449; E-mail:
[email protected]
In order to inter-operate knowledge bases and systems with both OWA and CWA,
it is necessary to study doing ontology with the CWA. In [5] the notion of DBox is
proposed. Briefly speaking, a DBox is a set of individual assertion axioms to which the
interpretation of predicates appear in are restricted to. In other words, expect the explicitly asserted ones in the DBox, no further instances can be entailed for these predicates.
This feature can be inconvenient or inefficient in practice because the ontology engineer
has to explicitly assert all the possible instances for these predicates.
In this paper we overcome this difficulty, allowing inferences on closed predicates
by extending the syntax of ontology with a Negation As Failure (NAF) Box (NBox for
short). An NBox is a set of predicates that the engineer wants to close. The semantics
of the NBox-closed ontology is also presented. Different from the “pre-closed” DBox
approach, when doing reasoning with NBox, one should first retrieve the instances of
the NBox predicates and then use these instances to close NBox predicates and proceed
for further reasoning.
In order to improve the efficiency of this two-phase reasoning by reusing results
of the first phase in the second phase, we apply the the syntactic approximation [6] to
reduce the closed world reasoning in SROIQ to closed world reasoning in EL++ , in
which tractable incremental reasoning algorithm is available [7].
2
Syntactic Approximation of Description Logics
Approximations are techniques used to improve the performance of reasoning. They can
be done in a semantic way (pre-computing the reasoning results off-line and retrieval
them efficiently on-line) or in a syntactic way (reducing the ontologies from very expressive languages to less expressive languages). In this section we present the syntactic
approximation. In later section, we will use it to support closed world reasoning.
Different OWL languages are underpinned by different DLs. For example, the underpinning of the OWL2-DL is DL SROIQ. The underpinning of the OWL2-EL is
DL EL++ . For the sake of conciseness, we highlight the parts of syntax and semantics
that are of interest in our paper. Complete specifications of these two languages can be
found in [8] and [9, 10], respectively.
Let NC , NR and NI = {a1 , a2 , . . . , an } be disjoint sets of concept, role and individual names, respectively. The set of SROIQ roles is NR and, if R is a role, then
R− is also a role. The set of SROIQ concepts is the smallest set that includes the
named concepts NC ∪ {>}, and if C, D are concepts and R is a role, a ∈ NI , and i is
a non-negative integer, then ¬C, C u D, ∃R.C, {a}, ≥ iR.C, ∃R.Self are concepts.
As usual, ⊥, C ∪ D, ∀R.C, {a1 , . . . , am } and ≥ iR.C are short for ¬>, ¬(¬C ∪ ¬D),
¬∃R.¬C, ¬(¬{a1 } u . . . u ¬{am }) and ¬ ≤ i − 1R.C.
Similarly, the set of EL++ roles is NR , while the EL++ concepts can only be >,
⊥, A ∈ NC , {a}, C u D or ∃R.C.
Without loss of generality, in what follows, we assume all the concepts in their
unique negated normal forms (NNF. An SROIQ concept is in NNF iff negation is
applied only to named concepts, nominals or Self-restriction. NNF of a given concept
can be computed in linear time [11].) and use ~C to denote the NNF of ¬C. We assume
all the roles in their unique inverse normal form (INF. A role is in INF iff inverse applies
only to role name.) by applying the transformation (R− )− → R and use Inv(R) to
denote the INF of R− . We also call >, ⊥, A, {a} basic concepts because they are not
composed by other concepts or roles. Given a knowledge base Σ (an ontology or a
TBox, or an ABox), we use CNΣ (RNΣ ) to denote the set of basic concepts (named
roles) in Σ. We use INΣ to denote the set of individuals in Σ.
For any DL, an ontology O is a pair (T , A). T is a terminology box (TBox), A is
an assertion box (ABox). A TBox is a set of concept and role axioms. Both SROIQ
and EL++ support concept inclusion axioms (CIs, e.g. C v D) and role inclusion
axioms (RIs, e.g. r v s, r1 ◦ . . . ◦ rn v s). If C v D (R v S) and D v C (S v R),
we write C ≡ D (R ≡ S). If C is complex, C v D is a general concept inclusion
axiom (GCI). An ABox is a set of assertion axioms. Both SROIQ and EL++ support
the concept assertion axioms, e.g. a : C, role assertion axioms, e.g. (a, b) : R, individual
.
.
equality, e.g. a = b and inequality, e.g. a =
6 b. Furthermore, in SROIQ, negative role
assertion axioms, e.g. (a, b) : ¬R is allowed.
An interpretation I is a pair h∆I , I i where ∆I is a non-empty set and I is a
function that maps named concept A to AI ⊆ ∆I , named role r to rI ⊆ ∆I × ∆I and
individual a to aI ∈ ∆I . The interpretation of complex concepts and some important
forms of axioms are presented in Table 1.
Table 1. DL Semantics (# means the size of a set)
Syntax
R−
>
⊥
¬C
C uD
C tD
∃R.C
∀R.C
{a1 , . . . , am }
≥ iR.C
≤ iR.C
∃R.Self
CvD
RvS
a:C
(a, b) : R
(a, b) : ¬R
.
a=b
.
a=
6 b
Semantics
{(x, y)|(xI , y I ) ∈ RI }
∆
∅
∆ \ CI
C I ∩ DI
C I ∪ DI
{x|∃y ∈ C I , (xI , y) ∈ RI }
{x|∀y, (xI , y) ∈ RI → y ∈ C I }
{aI1 , . . . , aIm }
{x|#{y|y ∈ C I , (xI , y) ∈ RI } ≥ i}
{x|#{y|y ∈ C I , (xI , y) ∈ RI } ≤ i}
{x|(xI , xI ) ∈ RI }
C I ⊆ DI
RI ⊆ S I
aI ∈ C I
(aI , bI ) ∈ RI
(aI , bI ) 6∈ RI
aI = bI
aI 6= bI
I is a model of an axiom α, denoted by I |= α iff it satisfies the semantics of the
axiom. Similarly, I is a model of O, written I |= O, iff I is a model of all axioms in
O.
Some standard reasoning services include:
1. Axiom Entailment Checking: An axiom α is entailed by O, denoted by O |= α
iff ∀I, if I |= O then I |= α. Otherwise, α is not entailed, written O 6|= α.
2. Instance Retrieval: An individual a is a instance of a concept C, iff O |= a : C.
Similarly, two individual a, b have an r relation, iff O |= (a, b) : r.
Due to the different levels of expressive power, the complexity of the above reasoning services in SROIQ and EL++ are different. In SROIQ, the complexity is
N2E XP T IME-Complete. In EL++ , the complexity is PT IME-Complete.
Because we are going to extend the syntax and semantics of ontology in later sections of this paper, we refer to the above definitions and notions as the classical cases.
For example, classical ontology, classical semantics, etc.
Syntactic approximation [12, 6] is an approximate reasoning technique that reduces
DL reasoning in SROIQ to EL++ . The reasoning complexity is thus reduced from
2NEXPTIME-Complete to PTIME-Complete while the results are guaranteed correct.
In this subsection, we briefly recall the syntactic approximation technique and its features. For more details about proofs, readers are referred to [12, 6]. In later sections, we
will extend the current approach to support required closed world reasoning services.
The idea of syntactic approximation from SROIQ and EL++ is to first encode
non-EL++ expressions with fresh names, then maintain their semantics with additional
axioms and separate data structures. For example, complement relations between an
named concept A and the new name, e.g. nA, assigned to its complement ¬A are maintained in the Complement Table (CT). In reasoning phase, additional completion rules
will be used to partially recover the semantics.
In approximation, we only consider concepts corresponding to the particular TBox
in question. We use the notion term to refer to these “interesting” concept expressions.
More precisely, a term is: (i) a concept expression in any axiom, or (ii) a singleton of
any individual, or (iii) the complement of a term, or (iv) the syntactic sub-expression
of a term. In order to represent all these terms and role expressions that will be used in
EL++ reasoning, we first assign names to them.
Definition 1. (Name Assignment) Given S a set of concept expressions, E a set of
(negative) role expressions, a name assignment f n is a function as for each C ∈
S (R ∈ E), f n(C) = C (f n(R) = R) if C is a basic concept (R is named), otherwise f n(C) (f n(R)) is a fresh name.
Now we can transform ontologies into EL++ with additional data structures by the
following definition.
Definition 2. (EL++
CQ Transformation) Given an Ontology O and a name assignment
++
f n, its ELCQ transformation
Af n,EL++ (O) is a triple (T , CT, QT ) constructed as follows:
CQ
1. T , CT and QT are all initialized to ∅.
2. for each C v D (C ≡ D) in O, T = T ∪{f n(C) v f n(D)} (T = T ∪{f n(C) ≡
f n(D)}).
3. for each EL++ role axiom β ∈ O, add β[R/f n(R)] into T .
4. for each a : C ∈ O, T = T ∪ {{a} v f n(C)}.
for each (a, b) : R ∈ O, T = T ∪{{a} v ∃f n(R).{b}, {b} v ∃f n(Inv(R)).{a}}.
.
for each a = b ∈ O, T = T ∪ {{a} ≡ {b}}.
.
for each a 6= b ∈ O, T = T ∪ {{a} v ¬{b}}
for each term C in TO , CT = CT ∪ {(f n(C), f n(~C))}, and
(a) if C is the form C1 u. . .uCn , then T = T ∪{f n(C) ≡ f n(C1 )u. . .uf n(Cn )},
(b) if C is the form ∃r.D, then T = T ∪ {f n(C) ≡ ∃r.f n(D)},
(c) if C is the form ∃R.Self , then T = T ∪ {f n(C) ≡ ∃f n(R).Self }
(d) if C is the form ≥ nR.D, then
i. if n = 0, T = T ∪ {> v f n(C)}
ii. if n = 1, T = T ∪ {f n(C) ≡ ∃f n(R).f n(D)}
iii. otherwise, T = T ∪ {f n(C) ≡ f n(D)f n(R),n }, and QT = QT ∪
{(f n(C), f n(R), n)}.
(e) otherwise T = T ∪ {f n(C) v >}.
9. for each pair of names A and r, if there exist (A, r, i1 ), (A, r, i2 ), . . ., (A, r, in ) ∈
QT with i1 < i2 < . . . < in , T = T ∪ {Ar,in v Ar,in−1 , . . ., Ar,i2 v Ar,i1 ,
Ar,i1 v ∃r.A}
5.
6.
7.
8.
Step 2 rewrites all the concept axioms; Step 3 preserves all the EL++ role axioms;
Step 4 to 7 rewrite all the ABox axioms and internalize them into the approximated
TBox; Step 8 defines terms and constructs the complement table CT and cardinality
table QT ; Particularly, in step 8.(d), f n(D)f n(R),n is a fresh name. For example, Ar,3
for ≥ 3r.A. Obviously, this is unique for a given tuple of D, R and n. We call them
cardinality names. Similarly, ≤ nR.D will be approximated via the approximation of
its complement ≥ (n + 1)R.D. In step 9, for each pair of name assignment A, r in T ,
a subsumption chain is added into T because ≥ in r.A v . . . v≥ i2 r.A v≥ i1 r.A v
∃r.A.
++
We call this procedure an EL++
CQ approximation.The ELCQ approximation approx++
imates a TBox into an EL
ontology with a table maintaining the complementary
relations and another table maintaining the cardinality relations. This approximation
can be computed in linear time:
Proposition 1. (EL++
CQ Approximation) For an ontology O, let Af n,EL++ (O) = (T , CT, QT ),
then T is an EL++ TBox.
CQ
Proposition 2. For any ontology O and (T , CT, QT ) its EL++
CQ transformation, if O
contains nO terms, then CNT , T , CT, QT are all of linear size of |O| + nO .
Given an EL++
CQ transformation (T , CT, QT ), we normalize axioms of form C v
D1 u . . . u Dn into C v D1 , . . . , C v Dn , and recursively normalize role chain
r1 ◦ . . . ◦ rn v s with n > 2 into r1 ◦ . . . ◦ rn−1 v u and u ◦ rn v s. Because C,
Di are basic concepts, this procedure can be done in linear time. In the following, we
assume T to be always normalized. For convenience, we use a complement function
f c : CNT 7→ CNT as: for each A ∈ CNT , f c(A) = B if (A, B) ∈ CT . Note that
if A is a cardinality name, then it does not have a complement. In what follows, when
applying f c(A) we always assume that A is not a cardinality name but a assigned name.
With the normalized approximation, the reasoning can be realized by extending
EL++ completion rules with support for the CT and QT . Given an ontology EL++
CQ
transformation (T , CT, QT ), the completion rules will compute, for each basic concept
A, a subsumer set S(A) ⊆ CNT such that if B ∈ S(A) then A v B, and for each
named role r, a relation set R(r) ⊆ CNT × CNT . For each basic concept A, S(A) is
initialized to {A, >} and for each named role r, R(r) is initialized to ∅. Then, the rules
in Table 2 are repeatedly applied until no new results can be derived.
Table 2. EL++
CQ completion rules
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13
R14
R15
R16
If A ∈ S(X), A v B ∈ T and B ∈
/ S(X)
then S(X) := S(X) ∪ {B}
If A1 , . . . , An ∈ S(X), A1 u . . . u An v B ∈ T and B ∈
/ S(X)
then S(X) := S(X) ∪ {B}
If A ∈ S(X), A v ∃r.B ∈ T and (X, B) ∈
/ R(r)
then R(r) := R(r) ∪ {(X, B)}
If (X, A) ∈ R(r), A0 ∈ S(A), ∃r.A0 v B ∈ T and B ∈
/ S(X)
then S(X) := S(X) ∪ {B}
If (X, A) ∈ R(r), ⊥ ∈ S(A) and ⊥ ∈
/ S(X)
then S(X) := S(X) ∪ {⊥}
If {a} ∈ S(X) ∩ S(A), X R A, S(A) 6⊆ S(X)
then S(X) := S(X) ∪ S(A)
If (X, A) ∈ R(r), r v s ∈ T and (X, A) 6∈ R(s)
then R(s) := R(s) ∪ {(X, A)}
If (X, A) ∈ R(r1 ), (A, B) ∈ R(r2 ), r1 ◦ r2 ∈ T , and (X, B) 6∈ R(r3 )
then R(r3 ) := R(r3 ) ∪ {(X, B)}
If A, B ∈ S(X), A = f c(B) and ⊥ ∈
/ S(X)
then S(X) := S(X) ∪ {⊥}
If A ∈ S(B) and f c(B) ∈
/ S(f c(A))
then S(f c(A)) := S(f c(A)) ∪ {f c(B)}
If A1 u . . . u An v ⊥, A1 , . . . , Ai−1 , Ai+1 , . . . , An ∈ S(X) and f c(Ai ) ∈
/ S(X)
then S(X) := S(X) ∪ {f c(Ai )}
If B ∈ S(A), (A, r, i), (B, s, j) ∈ QT , r v∗ s, i ≥ j and B j 6∈ S(Ai )
then S(Ar,i ) := S(Ar,i ) ∪ {B s,j }
If Ar,i ∈ S(X), A0 ∈ S(A), ∃r.A0 v B ∈ T and B ∈
/ S(X)
then S(X) := S(X) ∪ {B}
If Ar1 ,i ∈ S(X), (A, B) ∈ R(r2 ), r1 ◦ r2 ∈ T , and (X, B) 6∈ R(r3 )
then R(r3 ) := R(r3 ) ∪ {(X, B)}
If (X, A) ∈ R(r1 ), B r2 ,i ∈ S(A), r1 ◦ r2 ∈ T , and (X, B) 6∈ R(r3 )
then R(r3 ) := R(r3 ) ∪ {(X, B)}
If Ar1 ,i ∈ S(X), B r2 ,j ∈ S(A), r1 ◦ r2 ∈ T , and (X, B) 6∈ R(r3 )
then R(r3 ) := R(r3 ) ∪ {(X, B)}
In Table 2, the rules R1-8 are the original EL++ completion rules [9]. Especially,
in R6 X
R A iff there exists C1 , . . . , Ck ∈ CNT s.t. C1 = X or C1 = {b},
(Cj , Cj+1 ) ∈ R(rj ) for some rj ∈ RNT (1 ≤ j ≤ k) and Ck = A. This *reachability* can be computed in polynomial time. Rules R9-R16 are devised to make use of
information maintained in CT and QT . For example, R9 realizes axiom Au~A v ⊥.
R10 asserts the reverse subsumption between concepts to supplement the absence of
negation, i.e. A v B →~A v~B. R11 builds up the relations between conjuncts of
a conjunction, e.g. A u B v ⊥ implies A v~B. R12, in which r v∗ s if r = s or
r v s ∈ T , realizes inference A v B, R v S, i ≥ j →≥ iR.A v≥ jS.B. R13 is
the extension of R4 and R14-16 are extensions of R8. Reasoning with rules R1-16 is
tractable and sound:
Theorem 1. (Complexity) For any EL++
CQ transformation
(T , CT, QT ) (T normalized), TBox reasoning by completion rules R1-R16 will terminate in polynomial time w.r.t. |CNT |+|RNT |.
Theorem 2. (Concept Subsumption Checking) Given an ontology O, its vocabulary
VO and Af n,EL++ (O) = (T , CT, QT ), for any two concepts C and D constructed
CQ
from VO , if
Af n,EL++ ({C v >, D v >}) = (T 0 , CT 0 , QT 0 ), then O |= C v D if f n(D) ∈
CQ
S(f n(C)) can be computed by rules R1-R16 on (T ∪ T 0 , CT ∪ CT 0 , QT ∪ QT 0 ).
As in classical reasoning, unsatisfiability checking of a concept C can be reduced
to entailment checking of C v ⊥; ontology inconsistency checking can be reduced to
entailment checking of > v ⊥ or {a} v ⊥.
3
Technical Motivation
In this section, we introduce the notion of Open World Assumption and Closed World
Assumption and motivate our work by discussion of existing works.
3.1
Open World Assumption & Closed World Assumption
Classical DL reasoning imposes the Open World Assumption (OWA), which means
the truth-value of a statement is unknown if its value varies in different interpretations of the ontology. According to the definition of entailment in DL, the truth-value
of an entailment is true iff the entailment holds in all interpretations of the ontology. It is false iff the entailment does not hold in any interpretation. Otherwise, it
is unknown. For example, in ontology {a : A, b : B} whether a : B is unknown,
so is b : A. DL reasoning can be done with OWA. For example, in the classic example {Oedipus : P atricide, T hersandros : ¬P atricide, (Iokaste, Oedipus) :
hasChild, (Iokaste, P olyneikes) : hasChild, (Oedipus, P olyneikes) : hasChild,
(P olyneikes, T hersandros) : hasChild}, we can inferred that Iokaste : ∃hasChild.(P atricideu
∃hasChild.¬P atricide) is true in all interpretations, no matter P olyneikes : P atricide
or not.
However, in certain applications, as we mentioned in the Sec.1, it is required to
partially or completely close the world or domain. In this case, the truth-value of a
statement that is not known to be true, is false. Thus in the above example {a : A, b :
B}, if A, B are closed, then a : ¬B and b : ¬A can be entailed. The CWA has been
widely applied in relational database and logic programming.
3.2
Closing the Domain with DBox Approach
CWA can be realized in different ways. [5] presented the DBox approach. In addition
to the TBox T and ABox A, a DBox D is specified to close the domain. D is syntactically similar to A, except that in D only named concepts and named roles are allowed.
Furthermore, the interpretations of predicates appearing in D is fixed by D. That is to
say, in any model of the ontology I, if A ∈ CND , then AI = {aI |a : A ∈ D}. If
r ∈ RND , then rI = {(aI , bI )|(a, b) : r ∈ D}. For predicates not appearing in D,
their interpretations are the same as we introduced in Sec.2, especially in Table 1.
The DBox approach strongly corresponds to relational database. Actually, the data
tables in a relation database can be regarded as a DBox. This resemblance makes it
easy to reduce query answering with ontologies over DBox to relational database query
answering [5].
The use of DBox is based on the assumption that a user has complete knowledge
about the predicates he or she wants to close. In this case, a user can confidently
encode such knowledge with the DBox. However, the DBox actually prohibits inferences on predicates appearing in it. In certain cases this can be inconvenient and unscalable. For example, Given an ontology T = {P hDStudent v Student}, A =
.
{Emily : Student, David : P hDStudent, Emily =
6 David} one should infer
David : Student. This kind of inferences are also witnessed by deductive database
and DataLog. However, if we close Student by putting only Emily : Student into D,
this ontology becomes inconsistent, because David, which is inferred to be a Student,
is different from the only instance of Student.
From this example, we can see that the DBox approach does not only require a user
to have complete knowledge about certain domain, but also requires him or her to explicitly assert this knowledge. This will introduce a lot of redundancies and undermines
DL’s advantages of reasoning.
It is nature to ask, is that possible to close certain predicates but still allow inferences
of implicit knowledge about them? To answer this question, we present a realization of
CWA with Negation As Failure.
4
Introducing Negation As Failure Box (NBox)
In this section, we present our realization of CWA. We start from the notion of Negation
As Failure (NAF). Then we present the syntax and semantics of an ontology with a
Negation As Failure Box (NBox).
4.1
Negation As Failure
As we mentioned earlier, the idea of CWA is that the truth-value of a statement that
is not known to be true, is false. However, the meaning of “known” here is unclear.
In knowledge representation, people tend to distinguish the Explicit Knowledge and
Implicit Knowledge. Formally speaking, given a knowledge base Σ, a proposition P
is explicit knowledge iff P ∈ Σ. A proposition P is implicit knowledge iff P 6∈ Σ and
Σ |= P .
Obviously, the DBox approach closes the domain w.r.t. the explicit knowledge encoded in D, leaving no space for implicit knowledge of predicates in the DBox. If we
want to close the domain w.r.t. both the explicit and implicit knowledge, it should be
done by the following non-monotonic inference rule:
Definition 3. (Negation As Failure (NAF)) For a knowledge base Σ and a proposition
P , Σ |= P̄ iff Σ 6|= P , where Σ |= P̄ means Σ entails that P is not true.
Particularly, when P = a : C, Σ |= P̄ iff Σ |= a : ¬C. When P = (a, b) : r,
Σ |= P̄ iff Σ |= (a, b) : ¬r.
In ontology reasoning, not all the predicates need to be closed. Therefore, NAF
should be applied on a pre-specified set of predicates. We call this set of predicates the
Negation As Failure Box (NBox).
4.2
NBox-closed Ontology
The syntax of NBox and NBox-closed Ontology is defined as follows:
Definition 4. (NBox-closed Ontology) An NBox-closed Ontology (N-Ontology for short)
O is a triple (T , A, N ), in which T is a TBox, A is an ABox and N is a subset of the
set containing T , all the named concepts and named roles in T and A.
In order to distinguish the classical ontology and N-Ontology, in what follows, we
use O to denote a classical ontology and ON to denote an N-Ontology.
The semantics of an N-Ontology can be extended by the NBox as follows:
Definition 5. (N-Ontology Semantics) Given an N-Ontology ON = (T , A, N ), let
O = (T , A), an interpretation I of ON is a pair h∆I , I i following the classical
notion of interpretation except that:
1. If a concept A ∈ N , then AI = {aI |O |= a : A}.
2. If a role r ∈ N , then rI = {(aI , bI )|O |= (a, b) : A}
In other words, the interpretation of a predicate in N is restricted to the maximal
common subset of its interpretations over O.
With the above semantics, we have the similar definition for entailment checking as
in classical ontology: an axiom α is entailed by an N-Ontology ON iff it is entailed by
all interpretations of ON , denoted by ON |= α.
We show that the NBox predicates satisfy the NAF inference in Def.3.
Theorem 3. (NBox for NAF) For any N-Ontology ON = (T , A, N ), the following
holds:
1. If concept A ∈ N , then ON |= a : ¬A iff (T , A) 6|= a : A.
2. If role r ∈ N , then ON |= (a, b) : ¬r iff (T , A) 6|= (a, b) : r.
Proof. 1. By definition of N-Ontology entailment, ON |= a : ¬A iff ∀I of ON ,
I |= a : ¬A, i.e. aI 6∈ AI .
According to Def.5, because A ∈ N , AI = {aI |(T , A) |= a : A}. Therefore, due
to the definition of classical entailment checking, aI 6∈ AI iff there exists some
interpretation of (T , A) that does not satisfies a : A, which means (T , A) 6|= a : A.
Together we have ON |= a : ¬A iff (T , A) 6|= a : A.
2. The proof of role entailment is similar.
By definition of N-Ontology entailment, ON |= (a, b) : ¬r iff ∀I of ON , I |=
(a, b) : ¬r, i.e. (aI , bI ) 6∈ rI .
According to Def.5, because r ∈ N , rI = {(aI , bI )|(T , A) |= (a, b) : r}. Therefore, due to the definition of classical entailment checking, (aI , bI ) 6∈ rI iff there
exists some interpretation of (T , A) that does not satisfies (a, b) : r, which means
(T , A) 6|= (a, b) : r.
Together we have ON |= (a, b) : ¬r iff (T , A) 6|= (a, b) : r.
t
u
5
Closed World Reasoning with N-Ontology
In this section, we discuss how to do closed world reasoning with NBox.
5.1
Reasoning Reduction
We first show that N-Ontology reasoning can be reduced to classical ontology reasoning.
Definition 6. (NBox Internalization) Given an N-Ontology ON = (T , A, N ), its
NBox Internalization N I(ON ) is an ontology O = (T 0 , A0 ) constructed as follows:
1.
2.
3.
4.
5.
6.
A0
T0
T0
T0
T0
T0
= A, T 0 = T .
= T 0 ∪ {A ≡ {a|(T , A) |= a : A}|A ∈ N }.
= T 0 ∪ {∃r.> v {a|∃b, (T , A) |= (a, b) : r}|r ∈ N }.
= T 0 ∪ {∃r− .> v {b|∃a, (T , A) |= (a, b) : r}|r ∈ N }.
= T 0 ∪ {{a} v ∀r.{b|(T , A) |= (a, b) : r}|r ∈ N }.
= T 0 ∪ {{b} v ∀r− .{a|(T , A) |= (a, b) : r}|r ∈ N }.
The above Step-2 closes the concepts in N . Step-3 and 4 close the global domains
and ranges of roles in N . Step-5 and 6 close the local domains and ranges of roles in
N.
The following theorem shows that N-Ontology reasoning can be reduced to its
NBox internalization reasoning:
Theorem 4. (Reasoning Reduction) For any N-Ontology ON = (T , A, N ) and its
NBox internalization N I(ON ) = O = (T 0 , A0 ), let α an axiom, then we have ON |=
α iff O |= α.
Proof. According to the definition of N-Ontology entailment and Def.5, it is sufficient
to prove that for any interpretation I of O0 , the following holds
1. If concept A ∈ N , AI = {aI |(T , A) |= a : A}
2. If role r ∈ N , rI = {(aI , bI )|(T , A) |= (a, b) : r}
We show that these two propositions are both true:
1. If concept A ∈ N , according to Step-2 of Def.6, O0 |= A ≡ {a|(T , A) |= a : A}.
Due to the definition of entailment we have AI = {aI |(T , A) |= a : A}.
2. If role r ∈ N , according to Step-3 and 4 of Def.6, we have rI ⊆ {aI |∃b, (T , A) |=
(a, b) : r} × {bI |∃a, (T , A) |= (a, b) : r}.
Together with Step-5 and 6 of Def.6, we have rI = {(aI , bI )|(T , A) |= (a, b) : r}.
All together, the theorem can be proved.
t
u
According to Def.6, the NBox reasoning by NBox internalization requires the following steps:
1. Retrieving the instances of the NBox predicates.
2. Internalizing the NBox with the materialization from Step-1.
3. Reasoning over the NBox internalization from Step-2.
This procedure actually forms an incremental reasoning over the TBox and ABox
in the original N-Ontology with two phases. This is usually difficult in expressive DLs
such as SROIQ because the results in the first phase, i.e. the above Step-1 can not
be reused in the second phase, i.e. the above Step-3. Alternatively, we can approximate
this to EL++ , which has tractable incremental reasoning service [7].
5.2
Closed World Reasoning by Approximation
The first step of closed world reasoning with N-Ontologies is instance retrieval of the
NBox predicates. As we mentioned earlier, the EL++
CQ approximation completion rules
++
R1-16, extended from the EL
completion rules, are devised to compute the subsumption relations between concepts. Therefore, the instance retrieval of named concepts A can be reduced to computing all the singleton subconcepts of A. This can be
done simultaneously in one go for all the named concepts.
The instance retrieval of named roles r is trickier. It requires, for each pair of individuals a, b, checking whether {a} v ∃r.{b} can be entailed. This can not be trivially
done by checking whether ({a}, {b}) ∈ R(r) because the original EL++ completion
rules omitted many such relations. For example, from {A v ∃r.B, B v C} the system
can infer (A, B) ∈ R(r) but not (A, C) ∈ R(r). Therefore it is necessary to extend the
EL++
CQ completion rules to efficiently compute all these entailments instead of checking
entailements one by one. This can be realized by the following additional completion
rule (Table 3).
Table 3. EL++
CQ additional role completion rule
R17
If ({a}, A) ∈ R(r), {b} ∈ S(A) and ({a}, {b}) ∈
/ R(r)
then R(r) := R(r) ∪ {({a}, {b})}
Obviously, this additional rule has no impact on the computation of S sets:
Proposition 3. For any EL++
CQ transformation (T , CT, QT ), A ∈ S(X) can be entailed by rules R1-16 iff A ∈ S(X) can be entailed by rules R1-17.
Proof. This proposition follows from the facts that: (i) The additional R17 only extends
the results of R sets. (ii) Only R4 and R13 use results of R sets to derive results of S
sets. (iii) No matter with R17 or not, the application results of R4 is the same. So does
R13.
t
u
Which means this rule will not affect the concept instance retrieval. We show that
this rule will “complete” the role instance retrieval:
Theorem 5. For any EL++
CQ transformation (T , CT, QT ), {a}
v ∃r.{b} can be entailed by rules R1-16 as in Theorem 2 iff ({a}, {b}) ∈ R(r) can be
entailed by rules R1-17.
Proof. According to Theorem 2, to check {a} v r.{b} with rules R1-16, we first approximate Af n,EL++ ({{a} v >, ∃r.{b} v >}) = {T 0 , CT 0 , QT 0 }. Then we do reaCQ
soning with R1-R16 on (T ∪ T 0 , CT ∪ CT 0 , QT ∪ QT 0 ). Suppose f n(∃r.{b}) = X,
obviously we have T 0 = {{a} v >, X v >, X v ∃r.{b}, ∃r.{b} v X}. And
{a} v r.{b} iff X ∈ S({a}) is derived.
When doing reasoning with R1-16, rules R1,2,4,6,10,13 can be applied to derive
X ∈ S({a}). We show that, no matter which rule is used to derived X ∈ S({a}) in
T ∪ T 0 , R1-17 can be used to derive ({a}, {b}) ∈ R(r) in T . For convenience, we use
∈T ∪T 0 and ∈T to distinguish the results derived by R1-16 on T ∪ T 0 and those derived
by R1-17 on T :
1. R1: This rule requires some Y ∈T ∪T 0 S({a}) s.t. Y v X ∈ T ∪ T 0 . Obviously,
there’s no such axiom in T 0 , thus there exists Y ∈ ST ∪T 0 ({a}) s.t. Y v X ∈ T .
According to Proposition 3 we can see that Y ∈ ST ∪T 0 ({a}) iff Y ∈T S({a}).
Thus with R1 we can derive X ∈T S({a}). According to Def. 2 there should also
exists X v ∃r.{b} ∈ T . With R3 we can derive ({a}, {b}) ∈T R(r).
2. R2: Similar as R1:, if R2 is applied to derive X ∈T ∪T 0 ({a}), we will have X ∈T
S({a}). And further with R3 we have ({a}, {b}) ∈T R(r).
3. R10: Also similar as R1:, f c({a}) ∈T ∪T 0 S(f c(X)) iff f c({a}) ∈T S(f c(X)).
So does X ∈ S({a}). And then we have ({a}, {b}) ∈T R(r).
4. R6: This rule requires some {b} ∈T ∪T 0 S({a}) ∩ S(X) and {a} R,T ∪T 0 X.
Obviously {b} ∈T ∪T 0 S({a}) ∩ S(X) iff {b} ∈T S({a}) ∩ S(X). It is sufficient
to prove {a} R,T ∪T 0 X iff {a} R,T X:
– The → direction is obvious.
– Regarding the ← direction, according to the meaning of R , {a} R,T X iff
there exist C1 , . . ., Ck ∈ CNT s.t. C1 = {a} or C1 = {y}, (Cj , Cj+1 ) ∈T
R(rj ) for some rj ∈ RNT (1 ≤ j ≤ k) and Ck = X. Comparing R1-16 and
R1-17 we know that for each two Cj , Cj+1 , either (Cj , Cj+1 ) ∈T ∪T 0 R(rj ) or
(Cj , Y ) ∈T ∪T 0 R(rj ), Cj+1 = {y} ∈T ∪T 0 S(Y ). In the former case, we have
{a} R,T ∪T 0 X. In the later case, there exist some {y}, Cj+2 , . . ., Ck−1 , X,
which also makes {a} R,T ∪T 0 X.
Thus, with R6, we also have X ∈T ∪T 0 S({a}) iff X ∈T S({a}). Similarly, we
can derive ({a}, {b}) ∈T R(r).
5. R4: This rule requires ({a}, A) ∈T ∪T 0 R(r), B ∈T ∪T 0 S(A), ∃r.B v X ∈
T ∪ T 0 . Obviously, ({a}, A) ∈T ∪T 0 R(r) iff ({a}, A) ∈T R(r) because T 0 does
not introduce any new relation regarding {a}; B ∈T ∪T 0 S(A) iff B ∈T S(A)
because T 0 does not introduce any new concept subsumption:
– If ∃r.B v X ∈ T , then applying R4 on T we will also get X ∈T ({a}).
Similarly applying R3 yields ({a}, {b}) ∈T R(r).
– If ∃r.B v X ∈ T 0 , then obviously B = {b}. Now we have ({a}, A) ∈T
(R, r), {b} ∈T S(A). Applying R17 yields ({a}, {b}) ∈T R(r).
6. R13: This rule can be proved similar as R4.
Altogether, this theorem can be proved.
t
u
It’s worth mentioning that this theorem is not claiming the reasoning to be complete.
It shows that, instead of checking relations between one by one pairs of individuals, the
relations between individuals can be computed simultaneously, just like the concept
instances.
With the extended rule sets, we can compute the instances for all the named concepts and named roles in one go of the reasoning. Given an EL++
CQ transformation
(T , CT, QT ), if A ∈ S({a}) can be derived by R1-17, we say that a : A can be
entailed, denoted by (T , CT, QT ) |= a : A. If ({a}, {b}) ∈ R(r) can be derived by
R1-17, we say that (a, b) : r can be entailed, denoted by (T , CT, QT ) |= (a, b) : r.
We approximate the N-Ontology reasoning with the approximation of the NBox
Internalization.
Definition 7. (Approximate NBox Internalization) Given an N-Ontology ON = (T N , AN , N ),
let Af n,EL++ ((T N , AN )) = (T , CT, QT ), its Approximate NBox Internalization AN I(ON )
CQ
0
0
0
is an EL++
CQ transformation (T , CT , QT ) constructed as follows:
1.
2.
3.
4.
5.
6.
7.
8.
Let T T = ∅.
T T = T T ∪ {A ≡ {a|(T , CT, QT ) |= a : A}|A ∈ N }.
T T = T T ∪ {∃f.> v {a|∃b, (T , CT, QT ) |= (a, b) : r}|r ∈ N }.
T T = T T ∪ {∃r− .> v {b|∃a, (T , CT, QT ) |= (a, b) : r}|r ∈ N }.
T T = T T ∪ {{a} v ∀r.{b|(T , CT, QT ) |= (a, b) : r}|r ∈ N }.
T T = T T ∪ {{b} v ∀r− .{a|(T , CT, QT ) |= (a, b) : r}|r ∈ N }.
Let Af n,EL++ (T T ) = (T 00 , CT 00 , QT 00 )
CQ
T 0 = T ∪ T 00 , CT 0 = CT ∪ CT 00 , QT 0 = QT ∪ QT 00 .
From Def. 7 the incremental pattern is quite obvious: the (T , CT, QT ) is the perma++
00
00
00
nent EL++
CQ transformation, while the (T , CT , QT ) is the temporary ELCQ transformation.
The following theorem describes the quality of approximate closed world reasoning
with approximate NBox Internalization.
Theorem 6. (Soundness) For any N-Ontology ON = (T , A, N ), if for any concept
A ∈ N and any individual a,
Af n,EL++ ((T , A)) |= a : A iff (T , A) |= a : A and for any role r ∈ N and any
CQ
two individual a, b, Af n,EL++ ((T , A)) |= (a, b) : r, then we have, for any two basic
CQ
concepts A and B, ON |= A v B if AN I(ON ) |= A v B.
Proof. According to Theorem 4, ON |= A v B iff N I(ON ) |= A v B. According to Theorem 2, N I(ON ) |= A v B if Af n,EL++ (N I(ON )) |= A v B. Then
CQ
it is sufficient to prove that when the condition of the theorem holds, AN I(ON ) =
Af n,EL++ (N I(ON )).
CQ
We construct a TBox T T as follows:
1.
2.
3.
4.
5.
6.
TT
TT
TT
TT
TT
TT
is initialized to ∅.
= T T ∪ {A ≡ {a|(T , A) |= a : A}|A ∈ N }.
= T T ∪ {∃r.> v {a|∃b, (T , A) |= (a, b) : r}|r ∈ N }.
= T T ∪ {∃r− .> v {b|∃a, (T , A) |= (a, b) : r}|r ∈ N }.
= T T ∪ {{a} v ∀r.{b|(T , A) |= (a, b) : r}|r ∈ N }.
= T T ∪ {{b} v ∀r− .{a|(T , A) |= (a, b) : r}|r ∈ N }.
According to Def.6, we have N I(ON ) = (T ∪ T T , A).
Suppose Af n,EL++ ((T , A)) = (T1 , CT1 , QT1 ) and
CQ
Af n,EL++ (T T ) = (T2 , CT2 , QT2 ). From Def.2 it is easy to see that Af n,EL++ (N I(ON )) =
CQ
CQ
Af n,EL++ ((T ∪ T T , A)) = (T1 ∪ T2 , CT1 ∪ CT2 , QT1 ∪ QT2 ).
CQ
If for any concept A ∈ N and any individual a,
Af n,EL++ ((T , A)) |= a : A iff (T , A) |= a : A and for any role r ∈ N and any
CQ
two individual a, b, Af n,EL++ ((T , A)) |= (a, b) : r, according to Def. 7 we have
CQ
AN I(ON ) = (T1 ∪ T2 , CT1 ∪ CT2 , QT1 ∪ QT2 ) as well.
Altogether, we have AN I(ON ) = Af n,EL++ (N I(ON )). Thus the theorem can be
CQ
proved.
t
u
This theorem indicates that, when the instance retrieval of NBox predicates is complete and sound, the approximate closed world reasoning is always soundness-guaranteed.
When we know that the approximate reasoning is sound and complete for such instance retrieval we can use approximate reasoning to infer them. This is useful in many
applications where the checking of complete and soundness of NBox predicates instance retrieval is much easier than closed world reasoning on them. For example, when
the NBox predicates only appear as the left-hand-side of some axioms, their instances
are solely determinted by the ABox. Thus approximate reasoning is always sound and
complete for them. Also, this is useful in applications where the closed world reasoning
is more frequent and dynamic than the reasoning on the original ontology. In this case,
one can verify the soundness and completeness on the NBox predicates in offline time
and provide closed world reasoning online.
Thanks for the efficient incremental reasoning provided by EL++ [7], subsequent
reasoning on AN I(ON ) can benefit from the reusing of existing results on Af n,EL++ (ON ).
CQ
Also, the overall approximate reasoning is still tractable.
When we don’t know whether the approximate reasoning is complete (it is always
sound), we can use a complete and sound reasoner such as Pellet or HermiT, to compute
N I(ON ), then doing approximate reasoning on Af n,EL++ (N I(ON )).
CQ
6
Conclusion
In this paper we tried to address the issue of doing ontology reasoning with CWA. Different from the existing DBox approach, our solution follows from the idea of Negation
As Failure and extends the syntax and semantics of classical ontology with a Negation
As Failure Box (NBox). We showed that closed world reasoning over NBox-closed ontology can be reduced to reasoning over a classical ontology. In order to speed up this
two-phase reduction-reasoning paradigm, we extended the existing syntactic approximation to support approximate closed world reasoning.
In the future, we will work on implementation and evaluation of our approach, as
well as extending the existing completion rules to support more reasoning patterns.
References
1. Motik, B., Grau, B.C., Horrocks, I., Wu, Z., Fokoue, A., Lutz, C.: OWL 2 Web Ontology
Language: Profiles. W3c working draft, W3C (October 2008)
2. Baader, F., Calvanese, D., McGuinness, D.L., Nardi, D., Patel-Schneider, P.F., eds.: The
Description Logic Handbook: Theory, Implementation, and Applications. Cambridge University Press (2003)
3. Ren, Y., van Deemter, K., jeff Z. Pan: Charting the Potential of Description Logic for the
Generation of Referring Expressions. In: Proc. of 6th Internaltional Conference on Natural
Langauge Generation(INLG-2010). (2010)
4. Tao, J., Sirin, E., Bao, J., McGuinness, D.: Integrity constraints in owl. In: AAAI2010:
Proceedings of the AAAI Conference on Artificial Intelligence. (2010)
5. Seylan, I., Franconi, E., De Bruijn, J.: Effective query rewriting with ontologies over dboxes.
In: IJCAI’09: Proceedings of the 21st international joint conference on Artifical intelligence,
San Francisco, CA, USA, Morgan Kaufmann Publishers Inc. (2009) 923–929
6. Ren, Y., Pan, J.Z., Zhao, Y.: Towards Soundness Preserving Approximation for ABox Reasoning of OWL2. In: the Proc. of the International Description Logic Workshop (DL2010).
(2010)
7. Suntisrivaraporn, B.: Module Extraction and Incremental Classification: A Pragmatic Approach for EL+ Ontologies. In Bechhofer, S., Hauswirth, M., Hoffmann, J., Koubarakis, M.,
eds.: Proceedings of the 5th European Semantic Web Conference (ESWC’08). Volume 5021
of Lecture Notes in Computer Science., Springer-Verlag (2008) 230–244
8. Horrocks, I., Kutz, O., Sattler, U.: The Even More Irresistible SROIQ. In: KR 2006. (2006)
9. Baader, F., Brandt, S., Lutz, C.: Pushing the EL Envelope. In: Proceedings IJCAI-05. (2005)
10. Baader, F., Brandt, S., Lutz, C.: Pushing the EL Envelope Further. In Clark, K., PatelSchneider, P.F., eds.: In OWLED-2008. (2008)
11. Hollunder, B., Nutt, W., Schmidt-Schauß, M.: Subsumption Algorithms for Concept Description Languages. In: ECAI-90, Pitman Publishing (1990) 348–353
12. Ren, Y., Pan, J.Z., Zhao, Y.: Soundness Preserving Approximation for TBox Reasoning. In:
the Proc. of the 25th AAAI Conference Conference (AAAI2010). (2010)