Question:
In Example 3, list the number of axioms that are contained in the resulting set of wanted inclusion assertions or the set of unwanted inclusion assertions (note that a complete revision state separates a TBox into a set of wanted inclusion assertions and a set of unwanted inclusion assertions)?
A. 2
B. 4
C. 3
D. 1

Answer: BD

Example 3. Let T 1 = { A ⊑ ∃ S, ∃ S ⊑ E} , T 2 = {∃ R ⊑ X, A ⊑ ¬ X, S ⊑ R } .
T = T 1 ∪ T 2 . It is easy to check that concept A is an unsatisﬁable
concept in T , and we get a complete revision state of T given as follows.
1. T ⊨= {∃ S ⊑ E, ∃ R ⊑ X, A ⊑ ¬ X, S ⊑ R } .
2. T ⊭ = { A ⊑ ∃ S} .

Knowledge-Based Systems 100 (2016) 1–12
Contents lists available at ScienceDirect
Knowle dge-Base d Systems
journal homepage: www.elsevier.com/locate/knosys
Graph-based approaches to debugging and revision of terminologies
in DL-Lite
Xuefeng Fu , Guilin Qi ∗, Yong Zhang , Zhangquan Zhou
School of Computer Science and Engineering, Southeast University, Nanjing, China
a r t i c l e
i n f o
Article history:
Received 8 July 2015
Revised 28 January 2016
Accepted 29 January 2016
Available online 4 March 2016
Keywords:
DL-Lite
Ontology debugging
Ontology revision
Scoring function
Hitting set tree
a b s t r a c t
In this paper, we deal with the problem of debugging and revision of incoherent terminologies. Ontology
debugging aims to provide the explanation of the causes of incoherence and ontology revision aims to
eliminate the incoherence. For this purpose, we propose the graph-based approaches to deal with the
debugging and revision of terminologies for a family of lightweight ontology languages, DL-Lite. First
of all, we transform DL-Lite ontologies to graphs. To deal with the problem of ontology debugging, we
calculate the minimal incoherence-preserving subsets (MIPS) of an ontology by computing the minimal
incoherence-preserving path-pairs (MIPP) based on the transformed graph. To deal with the problem of
ontology revision, we propose the notion of revision state which separates the terminology of an ontol-
ogy into two disjoint sets: the set of wanted axioms and the set of unwanted axioms. We further deﬁne a
revision operator based on the revision state. Afterward, two revision algorithms are proposed to instan-
tiate the revision operator: one is based on a scoring function, and the other one is based on a hitting
set tree. We implement these algorithms and conduct experiments of ontology debugging and ontology
revision on several adapted real ontologies. The experimental results of ontology debugging show that
our approach of calculating MIPS based on graph is eﬃcient and outperforms the state of the art. The
experimental results of ontology revision show that the algorithm based on a scoring function is more
eﬃcient than the algorithm based on a hitting set tree.
© 2016 Elsevier B.V. All rights reserved.
1. Introduction
Ontologies play an important roles in semantic web and it
is also important in recommender systems and social network
[1] . However, the development and maintenance of ontologies are
complex and error-prone. Thus, logical inconsistencies can easily
occur in real ontologies [2] . Ontology debugging [3] , which aims to
pinpoint the causes of inconsistencies, and ontology revision [4] ,
which aims to eliminate the inconsistencies, have become the key
issues in ontology engineering.
Up to now, many approaches of ontology debugging are pro-
posed to compute minimal unsatisﬁability preserving subsets
(MUPS) of an ontology [3,5,6] or to compute minimal incoherence
preserving subsets (MIPS) of an ontology [5,7] . MUPS is useful for
relating a set of axioms to an unsatisﬁable concept and MIPS is
the minimal sub-TBox of T which is incoherent. It is argued that
MIPS is more useful than MUPS when repairing an ontology, since
∗Corresponding author. Tel.: +86 13376069256; fax: +86 2552090910.
E-mail addresses: fxf@seu.edu.cn (X. Fu), gqi@seu.edu.cn , fxfcn@126.com (G. Qi),
zhangyong@seu.edu.cn (Y. Zhang), quanzz@seu.edu.cn (Z. Zhou).
every MIPS is a MUPS and removing one axiom from each MIPS
can resolve the incoherence of an ontology.
Similarly, there also exist many approaches for ontology revi-
sion. Most works, such as those reported in [8,9] , on ontology re-
vision are based on the AGM theory [10] . An important principle
of these works is minimal change, i.e., a revision approach should
delete information from the original ontology as little as possible.
In [8] , a kernel revision operator is proposed based on an incision
function that is used to select axioms from each MIPS. In [9] , the
authors propose a revision operator based on a trust-based inci-
sion function which aims to ﬁnd minimal set of axioms that need
to be removed to render a terminology logically correct. Neverthe-
less, the delete operation may lead to the loss of valuable informa-
tion in an ontology.
Recently, there is an increasing interest in inconsistency han-
dling in DL-Lite, which is a family of tractable description log-
ics. In this paper, we provide graph-based approaches to debug
and to revise DL-Lite ontologies. At ﬁrst, we encode an ontology
into a graph, and derive subsumption relations between two con-
cepts (or roles) by reachability of two nodes. Then, all MIPSs can
be calculated by backtracking pairs of nodes in the graph. Thus
this approach helps to avoid the computation of all MUPSs of the
http://dx.doi.org/10.1016/j.knosys.2016.01.039
0950-7051/© 2016 Elsevier B.V. All rights reserved.
2
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
ontology w.r.t. all unsatisﬁable concepts. Based on MIPS, we pro-
pose the notion of revision state, which separates the terminol-
ogy of an ontology into two disjoint sets: the set of wanted ax-
ioms and the set of unwanted axioms. We further deﬁne a reﬁne-
ment revision operator based on the revision state. This operator
aims to retrieve useful information from the set of unwanted ax-
ioms. Afterward, we propose two revision algorithms to instanti-
ate the revision operator: one is based on a scoring function, and
the other one is based on a hitting set tree. We then evaluate
the performance of these algorithms by conducting experiments on
some (adapted) real ontologies. The experimental results of ontol-
ogy debugging show that our approach of calculating MIPS based
on graph is eﬃcient and outperforms the state of the art. The ex-
perimental results of ontology revision show that the algorithm
based on a scoring function is more eﬃcient than the algorithm
based on a hitting set tree.
The rest of the paper is organized as follows: We ﬁrst intro-
duce the theoretical basis of DL-Lite and a method of graph con-
struction in Section 2 . We then present our graph-based debug-
ging and revision approaches in Section 3 . In Section 4 , we present
our algorithms to instantiate the revision operator. In Section 5 , we
evaluate our algorithms using some adapted ontologies. We dis-
cuss related works in Section 6 . Finally, we conclude this paper in
Section 7 .
2. Preliminaries
2.1. DL-Lite family
In this subsection, we introduce DL-Lite FR , which is an impor-
tant language in DL-Lite that stands out for its tractable reasoning
and eﬃcient query answering [11,12] . We start with the introduc-
tion of DL-Lite core , which is the core language for the DL-Lite family
[13] . The complex concepts and roles of DL-Lite core are deﬁned as
follows:
(1) B → A |∃ R , (2) R → P | P −, (3) C → B | ¬B , (4) E → R | ¬R , where
A denotes an atomic concept, P an atomic role, B a basic concept,
and C a general concept. A basic concept can be either an atomic
concept or a concept of the form ∃ R , where R denotes a basic role
which can be either an atomic role or the inverse of an atomic
role.
In DL-Lite core , an ontology O = ⟨T , A⟩ consists of a TBox T and
an ABox A , where T is a ﬁnite set of concept inclusion assertions
of the form: B ⊑ C ; and A is a ﬁnite set of membership asser-
tions of the form: A ( a ), P ( a, b ). In this paper, ABoxes will not be
considered. DL-Lite FR extends DL-Lite core with inclusion assertions
between roles which are the form R ⊑ E and functionality on roles
(or on their inverses) which are the form ( funct R ) or ( funct R −) .
To keep the logic tractable, whenever a role inclusion R 1 ⊑ R 2 ap-
pears in T , neither ( funct R 2 ) nor ( funct R −
2 ) can appear in it.
The semantics of DL-Lite is deﬁned by an interpretation I =
(△ I , ·I ) which consists of a non-empty domain set △ I and an
interpretation function ·I , which maps individuals, concepts and
roles to elements of the domain, subsets of the domain and binary
relations on the domain, respectively. The interpretation function
can be extended to arbitrary concept (or role) descriptions and in-
clusion (or membership) assertions in a standard way [11] . Given
an interpretation I and an assertion φ, I |	 φ denotes that I sat-
isﬁes φ. An interpretation is called a model of an ontology O, iff
it satisﬁes each assertion in O. An ontology O logically implies an
assertion φ, written O |	 φ, if all models of O satisfy φ.
In DL-Lite, the assertions of the form B 1 ⊑ B 2 or R 1 ⊑ R 2 are
called positive inclusions (PIs) and the assertions of the form B 1 ⊑
¬B 2 or R 1 ⊑ ¬R 2 are called negative inclusions (NIs). In order to take
into account the interaction of inclusions, we introduce the deﬁni-
tion of NI-closure [11] .
Deﬁnition 1. Let T be a DL-Lite FR TBox. We deﬁne the NI-closure
of T , denoted by cln (T ) , inductively as follows:
1. All negative inclusion assertions (NIs) in T are also in
cln (T ) .
2. All functionality assertions in T are also in cln (T ) .
3. If B 1 ⊑ B 2 is in T and B 2 ⊑ ¬B 3 or B 3 ⊑ ¬B 2 is in cln (T ) , then
also B 1 ⊑ ¬B 3 is in cln (T ) .
4. If R 1 ⊑ R 2 is in T and ∃ R 2 ⊑ ¬B or B ⊑ ¬∃ R 2 is in cln (T ) , then
also ∃ R 1 ⊑ ¬B is in cln (T ) .
5. If R 1 ⊑ R 2 is in T and ∃ R −
2 ⊑ ¬ B or B ⊑ ¬∃ R −
2 is in cln (T ) ,
then also ∃ R −
1 ⊑ ¬ B is in cln (T ) .
6. If R 1 ⊑ R 2 is in T and R 2 ⊑ ¬R 3 or R 3 ⊑ ¬R 2 is in cln (T ) , then
also R 1 ⊑ ¬R 3 is in cln (T ) .
7. If one of the assertions ∃ R ⊑ ¬∃ R , ∃ R −⊑ ¬∃ R −and R ⊑ ¬R is
in cln (T ) , then all three such assertions are in cln (T ) .
Deﬁnition 2. Let T be a DL-Lite FR TBox. We deﬁne the PI-closure
of T , denoted by clp(T ) , inductively as follows:
1. All positive inclusion assertions (PIs) in T are also in clp( T ) .
2. If B 1 ⊑ B 2 is in clp(T ) and B 2 ⊑ B 3 is in clp(T ) , then also
B 1 ⊑ B 3 is in clp(T ) .
3. If R 1 ⊑ R 2 is in clp(T ) and R 2 ⊑ R 3 is in clp(T ) , then also
R 1 ⊑ R 3 is in clp(T ) .
4. If R 1 ⊑ R −
2 is in clp(T ) and R 2 ⊑ R −
3 is in clp(T ) , then also
R 1 ⊑ R 3 is in clp(T ) .
5. If R 1 ⊑ R 2 is in clp(T ) and ∃ R 2 ⊑ B is in clp(T ) , then also
∃ R 1 ⊑ B is in clp(T ) .
6. If R 1 ⊑ R 2 is in clp(T ) and ∃ R −
2 ⊑ B is in clp(T ) , then also
∃ R −
1 ⊑ B is in clp(T ) .
Finally, let cl(T ) = clp(T ) ∪ cl n (T ) , where cl (T ) is the closure
of T . We call a TBox T is closed if T = cl(T ) .
2.2. Logical conﬂict in TBox
We now introduce several important notations closely related
to ontology revision given in [14] . These notations will be used in
the sequel.
Deﬁnition 3. Let T be a DL-Lite FR TBox. A concept C (resp. role
R ) in T is unsatisﬁable if and only if for each model I of T , C I = ∅
(resp. R I = ∅ ).
A TBox T is incoherent if and only if there exist at least one
unsatisﬁable concepts or roles in T .
Deﬁnition 4. Let T be an incoherent TBox. A TBox T ′ ⊆T is a
minimal incoherence-preserving sub-TBox (MIPS) of T if and only
if T ′ is incoherent and every sub-TBox T ′′ ⊂T ′ is coherent.
Example 1. Given a TBox T , where T = { A ⊑ B, B ⊑ C, B ⊑ D, D ⊑
¬ C, A ⊑ ¬ B } . According to Deﬁnition 3 , A and B are unsatisﬁable
concepts. According to Deﬁnition 4 , there are two MIPSs in T , one
is { A ⊑ B, A ⊑ ¬B }, and the other is { B ⊑ C, B ⊑ D, D ⊑ ¬C }.
Deﬁnition 5. Let T be a coherent DL-Lite FR TBox. A TBox is logical
closure of T , denoted by cn (T ) , if φ ∈ cn (T ) for any T |	 φ.
In the following, we give the relationship between cl(T ) and
cn (T ) .
Theorem 1. Let T be a DL-Lite FR TBox, cl(T ) = cn (T ) if T is
coherent.
Proof. According to the deﬁnition of cn (T ) , it includes all ax-
ioms entailed by T . Since for inductive rules in Deﬁnition 2 and
Deﬁnition 1 , all positive inclusion assertions, negative inclusion as-
sertions and functionality assertions that can be entailed by T , are
included in cl(T ) . Therefore, cl(T ) ⊆cn (T ) .
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
3
Each axiom φ in a TBox of a DL-Lite ontology can have three
forms: positive inclusion, negative inclusion and functionality as-
sertions. To arbitrary axiom φ ∈ cn (T ) , we discuss the relationship
between cn (T ) and cl(T ) by considering these three forms respec-
tively.
Let φ be a positive inclusion assertion of the form A ⊑ B . As-
suming that I is a model of T , I satisﬁes axiom A ⊑ B , that is A I ⊆
B I . Since T is coherent and φ ∈ cn (T ) implies that T ⊨A ⊑ B, there
exist concepts, without loss of generality, B 1 , . . . , B n , such that
A I ⊆B I
1 ⊆· · · ⊆B I
n ⊆B I . Then we can get that T |	 A ⊑ B 1 , T |
B 1 ⊑ B 2 , . . . , T |	 B n −1 ⊑ B n , T |	 B n ⊑ B . According to the rules of
deﬁnition of clp(T ) which entail A ⊑ B . Therefore, φ ∈ cl(T ) .
Let φ be a negative inclusion assertion or a functionality as-
sertion. φ ∈ cn (T ) implies T ⊨φ. According to the Corollary 13 of
[11] , if T ⊨φ then φ ∈ cln ( T ). Hence we can infer that φ ∈ cl(T )
because cl(T ) = clp(T ) ∪ cln (T ) .
Finally, we conclude that cl(T ) = cn (T ) . □
The coherence of TBox T is the prerequisite for cl(T ) = cn (T ) .
If TBox T is incoherent, T include at least one unsatisﬁable con-
cepts or roles. An unsatisﬁable concept or role can infer an ar-
bitrary consequence, so that the reasoning would turn out to be
trivial. It can be shown in Example 2 .
Example 2. Given a TBox T , where T = { A ⊑ B, A ⊑ ¬ B, C ⊑ D } . It
is easy to check that A is an unsatisﬁable concept and T is inco-
herent. According to Deﬁnition 5 , we can get cn (T ) = { A ⊑ B, A ⊑
¬ B, C ⊑ D, A ⊑ ¬ A, A ⊑ C, A ⊑ D } .
According to the deﬁnition of cl(T ) , we can get cl(T ) = { A ⊑
B, A ⊑ ¬ B, C ⊑ D, A ⊑ ¬ A } .
2.3. Graph construction
Inspired by the work given in [15,16] and [17] , we transform a
DL-Lite ontology into a graph. Based on the constructed graph, we
can propose our debugging and revision approaches, which will be
discussed in the next section.
Let T be a DL-Lite TBox over a signature T , containing sym-
bols for atomic elements, i.e., atomic concept and atomic roles. The
digraph G T = ⟨ N, E⟩ constructed from T over the signature T is
given as follows:
1. For each concept B in T , N contains the node B .
2. For each role P in T , N contains the nodes P, P −, ∃ P, ∃ P −.
3. For each concept inclusion B 1 ⊑ B 2 ∈ T , E contains the
arc( B 1 , B 2 ).
4. For each concept inclusion B 1 ⊑ ¬ B 2 ∈ T , E contains the
arc( B 1 , ¬B 2 ) and N contains the node ¬B 2 .
5. For each role inclusion R 1 ⊑ R 2 ∈ T , E contains the arc( R 1 ,
R 2 ), arc (R −
1 , R −
2 ) , arc( ∃ R 1 , ∃ R 2 ), arc (∃ R −
1 , ∃ R −
2 ) .
6. For each role inclusion R 1 ⊑ ¬ R 2 ∈ T , E contains the arc( R 1 ,
¬R 2 ), arc (R −
1 , ¬ R −
2 ) , arc( ∃ R 1 , ¬∃ R 2 ), arc (∃ R −
1 , ¬∃ R −
2 ) and N
contains nodes ¬R 2 , ¬ R −
2 , ¬∃ R 2 , ¬∃ R −
2 .
Based on (1)–(6), we construct a graph from a TBox T . It has
been shown in [16] that the problem of TBox classiﬁcation in a DL-
Lite ontology O can be done by computing the transitive closure of
graph G T . For simplicity, we call these rules Construction Rules ,
and we use C ( R ) to denote the node w.r.t. concept C (role R ).
In a graph built by Construction Rules, each node represents a
basic concept or a basic role, while each arc represents an inclu-
sion assertion, i.e. the start and end nodes are corresponding re-
spectively to the left-hand and right-hand parts of an inclusion as-
sertion. In order to ensure that the information represented in the
TBox is preserved by the graph, we add nodes R , R −, ∃ R , ∃ R −for
each role R , arc( R 1 , R 2 ), arc (R −
1 , R −
2 ) , arc( ∃ R 1 , ∃ R 2 ), arc (∃ R −
1 , ∃ R −
2 )
for each role inclusion assertion R 1 ⊑ R 2 .
3. Graph-based debugging and revision
In this section, we introduce our graph-based approaches for
TBox debugging and revision. At ﬁrst, we give theorems that serve
as the theoretical basis for our approach.
3.1. Theoretical basis
To explain the equivalence of a DL-Lite TBox and its correspond-
ing graph, we ﬁrstly introduce the theorem given in [16] .
Theorem 2. Let T be a DL-Lite FR TBox that contains only positive
inclusions and let S 1 and S 2 be two atomic concepts, or two atomic
roles. S 1 ⊑ S 2 is entailed by T if and only if at least one of the fol-
lowing conditions holds:
1. a set P of positive inclusions exists in T , such that P |	 S 1 ⊑ S 2
2. T |	 S 1 ⊑ ¬ S 1 .
We can extend Theorem 2 to general concepts or roles, i.e., the
subsumption relation may be a negative inclusion.
Theorem 3. Let T be a DL-Lite FR TBox and let S 1 and S 2 be two
atomic concepts, or two atomic roles. S 1 ⊑ ¬S 2 is entailed by T if and
only if at least one of the following conditions holds:
1. a set P of positive inclusions and a negative inclusion n ∈ T
exist in T , such that P ∪ { n } |	 S 1 ⊑ ¬ S 2
2. T |	 S 1 ⊑ ¬ S 1 .
Proof. ( ⇐ ) This can be easily proved.
( ⇒ ) Assume T |	 S 1 ⊑ ¬ S 2 . Without loss of generality, we sup-
pose that there exists a minimal axiom set T ′ = { φ1 , φ2 , . . . , φn } in
T and T ′ |	 S 1 ⊑ ¬ S 2 . According to Deﬁnition 1 and Deﬁnition 2 ,
negative inclusions do not concur in the entailment of a set of pos-
itive inclusions. Therefore, there exists at least one negative inclu-
sions in T ′ . Let φi be the ﬁrst negative inclusion that occurs in
the T ′ and is of the form B 1 ⊑ ¬B 2 , then the following cases are
considered:
1. φi is the ﬁrst negative inclusion of T ′ , then φ1 , φ2 , . . . , φi −1
are positive inclusions. If there has no negative inclusions in
the φi +1 , φi +2 , . . . , φn , we can conclude that T ′ only contains
one negative inclusion φi .
2. Suppose that there have more than one negative inclusions
in φi +1 , φi +2 , . . . , φn , we select one negative inclusion and
assume that it is of the form B
′
1 ⊑ ¬ B
′
2 . According to the syn-
tax of DL-Lite [11] , the general concept (role) only occurs on
the right-hand side of inclusion assertions. Due to this con-
straint, inference cannot be carried out between φi (we as-
sume the form of φi is B 1 ⊑ ¬B 2 ) and B
′
1 ⊑ ¬ B
′
2 , so T ′ is not
a minimal set that entails S 1 ⊑ ¬S 2 . Then we get a contradic-
tion.
□
Let T be a DL-Lite FR TBox and let G T = ⟨ N, E⟩ be the digraph
constructed from T according to the Construction Rules. We de-
note the transitive closure of G T by G ∗
T = ⟨ N, E ∗⟩ . According to
Theorem 2 and Theorem 3 , we can see that the entailment prob-
lem can be reduced to the graph reachability problem between
concepts and roles. Consider for example, T = { B 1 ⊑ B 2 , B 2 ⊑ B 3 } ,
whose corresponding graph G contains two edges arc( B 1 , B 2 ) and
arc( B 2 , B 3 ), it is obvious that B 1 ⊑ B 3 ∈ cl(T ) and arc( B 1 , B 3 ) be-
longs to the transitive closure of G .
In order to prove the equivalence of an ontology and the graph
constructed from it w.r.t. classiﬁcation, we cite a theorem given in
[16] .
Theorem 4. Let T be a DL-Lite FR TBox that contains only positive
inclusions and let G T = ⟨ N, E⟩ be its digraph representation. Let S 1 , S 2
4
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
be two basic concepts (roles). S 1 ⊑ S 2 ∈ cl(T ) if and only if arc ( S 1 , S 2 )
∈ E ∗.
Then we extend Theorem 4 as follows.
Theorem 5. Let T be a DL-Lite FR TBox and let G T = ⟨ N, E⟩ be the
digraph constructed from T according to the Construction Rules. Let
m be a basic concept (role) and n be a general concept (role). m ⊑
n ∈ cl(T ) if and only if arc ( m, n ) ∈ E ∗.
Proof. ( ⇐ ) If arc( m, n ) ∈ E ∗, according to the deﬁnition of transi-
tive closure of graph, there exists at least one paths starting from
the node m to the node n in G T . Moreover, according to Construc-
tion Rules, for each edge in G T , it corresponds to at least one in-
clusion assertions in T or cl(T ) . We assume S is the set of these
assertions. Obviously that S |	 m ⊑ n . Therefore, m ⊑ n ∈ cl(T ) .
( ⇒ ) If m ⊑ n ∈ cl(T ) , we consider the following two cases:
1. If m ⊑ n ∈ clp(T ) , we can infer arc( m, n ) ∈ E ∗based on
Theorem 4 .
2. If m ⊑ n ∈ cln (T ) , then m ⊑ n is in the form of B 1 ⊑ ¬B 2 . Ac-
cording to Theorem 3 , there exist a set of PIs and a NI n such
that P ∪ { n } B 1 ⊑ ¬B 2 . Without loss of generality, we assume
n = { B
′ ⊑ ¬ B 2 } and P |	 B 1 ⊑ B
′ . According to Theorem 2 , we
can infer that arc (B 1 , B
′ ) ∈ E ∗. Therefore, arc( B 1 , ¬B 2 ) ∈ E ∗.
□
3.2. TBox debugging
In order to revise an incoherent TBox, we propose an approach
for TBox debugging which provides the explanation of the incoher-
ence of an TBox. In this subsection we present our graph-based ap-
proach for TBox debugging. At ﬁrst, we deﬁne the notion of MIPP
which corresponds to MIPS of an incoherent TBox.
Deﬁnition 6. Let T be a DL-Lite FR TBox and G T = ⟨ N, E⟩ be the
digraph constructed from T according to the Construction Rules.
Then for arbitrary node C ∈ N , if there exist two paths that start
from node C to node D and from node C to node ¬D respectively
in G T and there does not exist joint edge between path C → D and
path C → ¬D , we call these two paths as minimal incoherence-
preserving path-pair (MIPP).
We use mipp(G T ) to denote the set of all MIPPs in G T .
In the following, we show that the problem of computing MIPS
of T , denoted by mips (T ) , can be reduced to that of ﬁnding MIPP
in graph G T . Based on the correspondence between the syntax of
DL-lite and the graph representation, the following theorem holds.
Theorem 6. Let T be a DL-Lite FR TBox, T is incoherent if and only
if there exist at least one MIPP in G T .
Proof. ( ⇐ ) If there exists a MIPP in G T , according to Deﬁnition 6 ,
we assume that there exist two paths, one is C → D , and the other
is C → ¬D . In this case, we can infer both C ⊑ D and C ⊑ ¬D from
T by Theorem 5 . Therefore, T contains at least one unsatisﬁable
concepts or roles.
( ⇒ ) T is incoherent so that there will be at least one unsatis-
ﬁable concepts or roles in T . Without loss of generality, suppose C
is an unsatisﬁable concept and C ⊑ D ∈ cl(T ) , C ⊑ ¬ D ∈ cl(T ) . Ac-
cording to Theorem 5 , we have arc (C, D ) ∈ G T and arc (C, ¬ D ) ∈ G T .
It is easy to see that there exist two paths without joint edge in
the digraph G ∗
T , that is a MIPP by Deﬁnition 6 . □
We use M to denote the set of inclusion assertions in a path P
on the graph. It is obvious M ⊆cl(T ) . According to Theorem 3 and
Theorem 5 , there will be a minimal subset S ⊆T such that S |	 M
and for every S
′ ⊂S, S
′ ⊭ M . We call S as the minimal set in T
corresponding to a path P , denoted by S T → P . Based on the notion,
we discuss the relationship between MIPP and MIPS.
Theorem 7. Let T be a DL- Lite FR TBox and S T → MIPP be the minimal
set in T corresponding to a MIPP in G T . Then S T → MIPP is a MIPS in
T .
Proof. By Theorem 6 , it is easy to see that T is incoherent. Let M
be the set of inclusion assertions corresponding to the MIPP. For
any S ′ ⊂S T → MIPP , S ′ ⊭ M because S T → MIPP is the minimal subset
of T that satisﬁes S T → MIPP |	 M . According to Construction Rules,
there does not exist a MIPP in G S ′ . Then S T → MIPP is incoherent
and S ′ is coherent. According to Deﬁnition 4 , S T → MIPP is a MIPS
in T . □
Theorem 8. Let T be a DL- Lite FR TBox. The set of all S T → MIPP in G T
corresponds to the set of all MIPS in T .
Proof. For any MIPP in mipp(G T ) , by Theorem 7 , S T → MIPP ∈
mips (T ) . For any MIPS M in mips (T ) , M is incoherent and for
any M ′ ⊂M , M ′ is coherent. Therefore, there exists a MIPP in G M
and it does not exist in G M ′ . It is easy to see that M corresponds
to the MIPP in G T and M is contained in the set of all S T → MIPP
corresponding to MIPP in T .
The case of role R can be proved analogously. □
3.3. TBox revision
TBox debugging only provides the cause of incoherence in a
TBox. We now consider TBox revision which helps to further elim-
inate the conﬂicts based on the result of debugging.
In our work, we restrict to the case that T 1 and T 2 are coherent
and T 1 ∪ T 2 is incoherent. We consider extending the deﬁnition of
MIPS given in [8] .
Deﬁnition 7. Let T 1 and T 2 be two coherent DL-Lite FR TBoxes and
T 1 ∪ T 2 is incoherent. A minimal incoherence-preserving sub-TBox
of T 1 w.r.t. T 2 , denoted by MIPS T 2 (T 1 ) , is a sub-TBox of T 1 which
satisﬁes both of the following conditions:
1. MIPS T 2 (T 1 ) ∪ T 2 is incoherent.
2. ∀ T ′
1 ⊂MIPS T 2 (T 1 ) , T ′
1 ∪ T 2 is coherent.
We denote the set of all MIPS of T 1 w.r.t T 2 by mips T 2 (T 1 )
Deﬁnition 7 can be applied to a single TBox. In this case, an in-
coherent TBox can be divided into a static part and a rebuttal part.
The rebuttal part consists of the axioms in MIPS. In the following,
we present a modiﬁed notation of revision state which was pro-
posed in [18] .
Deﬁnition 8. Let T 1 and T 2 be two DL-Lite FR TBoxes and T = T 1 ∪
T 2 . The revision state of T is a tuple (T , T ⊨, T ⊭ ) that satisﬁes the
following conditions:
1. T ⊨⊆T , T ⊭ ⊆T 1 .
2. T ⊨∩ T ⊭ = ∅ .
A revision state is complete, if T = T ⊨∪ T ⊭ , and incomplete oth-
erwise. A revision state is coherent if there is no φ ∈ T ⊭ such that
T ⊨⊨φ.
A revision state actually separates a TBox into two parts: T ⊨,
which includes wanted inclusion assertions, and T ⊭ , which con-
tains unwanted inclusion assertions. In a complete revision state,
we can remove axioms in unwanted set T ⊭ from T to accomplish
the purpose of revision. The following example illustrates the idea.
Example 3. Let T 1 = { A ⊑ ∃ S, ∃ S ⊑ E} , T 2 = {∃ R ⊑ X, A ⊑ ¬ X, S ⊑ R } .
T = T 1 ∪ T 2 . It is easy to check that concept A is an unsatisﬁable
concept in T , and we get a complete revision state of T given as
follows.
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
5
1. T ⊨= {∃ S ⊑ E, ∃ R ⊑ X, A ⊑ ¬ X, S ⊑ R } .
2. T ⊭ = { A ⊑ ∃ S} .
We can simply revise the merged TBox by removing T ⊭ . How-
ever, the naive revision method may lose too much information in
the original TBox. In Example 3 , we can see that A ⊑ E ∈ cl(T ) and
A ⊑ E /
∈ cl(T ⊨) . Nevertheless, { A ⊑ E} ∪ T ⊨is coherent, which means
the inclusion assertion { A ⊑ E } can be preserved. In order to avoid
the loss of information, we deﬁne the reﬁnement of revision state.
Deﬁnition 9. Let T 1 and T 2 be two DL-Lite FR TBoxes, T = T 1 ∪
T 2 .A coherent reﬁnement of revision state (T , T ⊨, T ⊭ ) is (T , T ⊨∪
T r
⊨, T ⊭ ) , where T r
⊨= { ψ ∈ cl T (φ) |T ⊨∪ { ψ} is coherent, φ ∈ T ⊭ } .
In the above deﬁnition, cl T (φ) denotes the closure of inclusion
assertion φ w.r.t T . Referring to the previous rules in Deﬁnition 2
and Deﬁnition 1 , we give inductive rules for calculating cl T (φ) . At
ﬁrst, inclusion assertions φ is in cl T (φ) . If B 1 ⊑ B 2 is in cl T (φ) and
B 2 ⊑ B 3 is in T , then B 1 ⊑ B 3 is in cl T (φ) . Analogously, other rules
can be deﬁned.
When incorporating a new TBox into an old one, reﬁnement
of revision state can retain original information as much as pos-
sible by adding some axioms into T ⊨. According to Deﬁnition 9 , in
Example 3 , we can obtain T r
⊨= { A ⊑ E} .
In general, there could be more than one revision states. A
problem is that which axioms are unwanted. Therefore, we pro-
pose some principles to address this problem.
In the revision process, a natural requirement is that the oper-
ator should follows the principle of minimal of changes [4] , which
says that a revision should result in a minimal modiﬁcation. In-
spired by the work in [19] , we give the deﬁnition of fewer change
to formalize the above principle.
Deﬁnition 10. Let T 1 and T 2 be two DL-Lite FR TBoxes, T = T 1 ∪ T 2
and RS = (T , T ⊨, T ⊭ ) and RS ′ = (T , T ′
⊨, T ′
⊭ ) be two reﬁnement of re-
vision states w.r.t T . RS ′ has fewer changes than RS if
1. |T ′
⊭ | < |T ⊭ | , or
2. |T ′
⊭ | = |T ⊭ | , and |T ′
⊨| < |T ⊨| .
In the above deﬁnition, , RS ′ has fewer changes than RS means
RS ′ has fewer unwanted axioms than RS , or if the number of ax-
ioms of RS ′ has the same as RS , then the number of axioms of RS ′
should be less than that of RS .
This deﬁnition gives the conditions of selecting axioms when
calculating reﬁnement of revision state. In order to satisfy the con-
dition of fewer changes, we give a revision function which is ac-
tually a composite of two parts. The ﬁrst part calculates the un-
wanted axioms of TBox, and the second part reﬁnes valuable in-
formation from the results of the ﬁrst part. The ﬁrst part of our
revision function can be implemented by an incision function [8] .
Deﬁnition 11. Let T 1 and T 2 be two DL-Lite FR TBoxes and T =
T 1 ∪ T 2 . An incision function for T , denoted by σ , is a function( σ :
2 2 T → 2 T ) such that
1. σ (mips T 2 (T 1 )) ⊆
T i ∈ mips T 2 (T 1 ) T i .
2. if T ′ ∈ mips T 2 (T 1 ) , then T ′ ∩ σ (mips T 2 (T 1 )) ̸ = ∅ .
An incision function selects at least one axioms from each non-
empty MIPS T 2 (T 1 ) . To meet the conditions of fewer changes, the
results should be minimal, that is, no other incision function σ ′
satisﬁes σ ′ (mips T 2 (T 1 )) ⊂σ (mips T 2 (T 1 )) .
In the second part of the revision function, we propose a re-
ﬁnement function which expands the results of incision function
σ . We deﬁne the reﬁnement function in the following way:
Deﬁnition 12. Let T 1 and T 2 be two DL-Lite FR TBoxes and T =
T 1 ∪ T 2 . A reﬁnement function for T , denoted by ξ, is a function( ξ :
2 2 T → 2 T ) based on incision function σ such that,
1. ξ(mips T 2 (T 1 )) ⊆cl T (φ) , φ ∈ σ (mips T 2 (T 1 )) ,
2. ξ(mips T 2 (T 1 )) ∪ T 2 is coherent.
According to Deﬁnitions 11 and 12 , we obtain a revision func-
tion by composing an incision function and a reﬁnement function,
denoted by F r = σ ⊕ξ.
In the composite function F r = σ ⊕ξ, incision function σ se-
lects unwanted axioms from MIPS and reﬁnement function ξ re-
ﬁnes result of σ . However, among different types of revision func-
tions, some of them cannot satisfy the conditions of fewer change.
To avoid the above case, we give the following deﬁnition.
Deﬁnition 13. Let T 1 and T 2 be two DL-Lite FR TBoxes and T =
T 1 ∪ T 2 . A revision function F r = σ ⊕ξ for T is optimal with re-
spect to a lexicographic order if there is no other revision function
F ′
r = σ ′ ⊕ξ′ that satisﬁes the following conditions:
1. | σ ′ (mips T 2 (T 1 ))) | < | σ (mips T 2 (T 1 )) |
2. if | σ ′ (mips T 2 (T 1 ))) | = | σ (mips T 2 (T 1 )) | , then | ξ′ (mips T 2
(T 1 )) | < | ξ(mips T 2 (T 1 )) |
Let (T , T ⊨∪ T r
⊨, T ⊭ ) be a reﬁnement revision state of T = T 1 ∪
T 2 . We obtain that T ⊭ = σ (mips T 2 (T 1 )) , T r
⊨= ξ(mips T 2 (T 1 )) and
T ⊨= (T \ T ⊭ ) .
Based on the above discussion, we give the deﬁnition of an op-
erator for revising a TBox T 1 with a newly received TBox T 2 . The
idea is that we obtain the revision state of the merged TBox by
calculating mips T 2 (T 1 ) .
Deﬁnition 14. Let T 1 and T 2 be two TBoxes and T = T 1 ∪ T 2 . Let
(T , T ⊨, T ⊭ ) be a revision state of T and (T , T ⊨∪ T r
⊨, T r
⊭ ) be the re-
ﬁnement revision state of T . The reﬁnement revision operator ◦
is deﬁned as follows: T 1 ◦⊨T 2 = (T 1 \ T r
⊭ ) ∪ T r
⊨∪ T 2 .
In the following, we discuss the properties of the reﬁnement
revision operator.
Proposition 1. Let T 1 and T 2 be two TBoxes. The operator ◦ satisﬁes
the following properties:
R1. T 2 ⊆T 1 ◦⊨T 2 .
R2. if T 1 ∪ T 2 is coherent, then T 1 ◦⊨T 2 = T 1 ∪ T 2 .
R3. if T 2 is coherent, then T 1 ◦⊨T 2 is coherent.
R4. if T 2 ≡T ′
2 , then T 1 ◦⊨T 2 ≡T 1 ◦⊨T ′
2 .
R5. if φ ∈ T 1 and φ /
∈ T 1 ◦⊨T 2 , then there exists S 1 ⊆T 1 such that
S 1 ∪ T 2 is coherent, but S 1 ∪ T 2 ∪ { φ} is not.
Proof. According to Deﬁnition 14 , T 2 ⊆(T 1 \ T r
⊭ ) ∪ T r
⊨∪ T 2 = T 1 ◦⊨
T 2 . It implies that (R1) holds. If T 1 ∪ T 2 is coherent, we can get
mips T 2 (T 1 ) = ∅ , which indicates that T ⊨and T ⊭ in a reﬁnement
revision state are empty set. It implies that (R2) holds. Accord-
ing to Deﬁnition 14 , it is clear that (R3) holds. If T 2 ≡T ′
2 , we
can get mips T 2 (T 1 ) = mips T ′
2 (T 1 ) according to Deﬁnition 7 . Thus,
σ (mips T 2 (T 1 )) = σ (mips T ′
2 (T 1 )) . It implies that (R4) holds. Accord-
ing to Deﬁnition 14 , the prerequisite of (R5) indicates that φ ∈
T 1 \ (T 1 ◦⊨T 2 ) ⊆T ⊭ . In the previous discussion, we know that T ⊭ is
the set of axioms selected by the incision function. Therefore, ax-
iom φ satisﬁed the prerequisite of (R5) must be in a subset of T 1
which is in conﬂict with T 2 . It is implies that (R5) holds. □
4. Graph-based algorithms for TBox debugging and revision
In this section, we present our graph-based algorithms for TBox
debugging and revision. In the process of debugging, all MIPPs,
which can be transformed to MIPSs of ontology, can be calculated
based on G T . In the process of revision, the incoherence of ontol-
ogy can be eliminated based on the MIPPs calculated in the pro-
cess of debugging.
6
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
Algorithm 1: Graph-based debugging.
Input : an incoherent TBox T
Output : set of MIPS in G T
1 Construct G T = ⟨ N, E⟩ ;
2 mipps ← CalculateMIPP (G T ) ;
3 for each MIPP in mipps do
4
mipses ← mipses ∪ TransToAxioms ( MIPP ) ;
5 return mipses ;
Algorithm 2: CalculateMIPP.
Input : G T
Output : set of MIPP in G T
1 mipps ← ∅ ;
2 for each ¬ S ∈ N do
3
for each n 1 ∈ Descendants( ¬ S, G T ) do
4
for each n 2 ∈ Descendants( S, G T ) ∪{ S} do
5
if n 1 = n 2 then
6
pathpairs =
GetDisjointPathpairs (path (n 1 , ¬ S) , path (n 2 , S)) ;
7
for each {⟨ n 1 → ¬ S, n 2 → S⟩} in pathpairs do
8
mipps ← mipps ∪ {⟨ n 1 → ¬ S, n 2 → S⟩} ;
9 return mipps ;
Algorithm 3: TransToAxioms.
Input : a MIPP in G T
Output : a MIPS in T
1 MIPS ← ∅ , axiomset ← ∅ ;
2 for each ⟨ P 1 , P 2 ⟩ ∈ MIPP do
3
for i = 1 : 2 do
4
for each arc⟨ B 1 , B 2 ⟩ ∈ P i do
5
if B 1 = ∃ R 1 and B 2 = ∃ R 2 and arc⟨ R 1 , R 2 ⟩ ∈ G T then
6
axiomset ← axiomset ∪ { R 1 ⊑ R 2 } ;
7
else
8
axiomset ← axiomset ∪ { B 1 ⊑ B 2 } ;
9 MIPS ← axiomset;
10 return MIPS ;
4.1. Graph-based algorithm for TBox debugging
We propose Algorithm 1 for calculating all MIPSs of a TBox. We
then give an example in the following to illustrate the procedure
of this algorithm.
Let S be a concept or a role expression. At the beginning of
Algorithm 1 , the TBox will be transformed into a graph in line
1, and then Algorithm 2 will be invoked to calculate MIPPs. In
lines 2–6 of Algorithm 2 , descendant nodes of S and ¬S can be
obtained. If there is a node (called S
′ ) between descendant nodes
of node S (specially, it includes S itself for the case S ⊑ ¬S ) and
those of node ¬S . This also means that there exists a path-pair
⟨ S
′ → S, S
′ → ¬ S⟩ on G T . Since S
′ → S and S
′ → ¬ S have no joint
edge, ⟨ S
′ → S, S
′ → ¬ S⟩ is a MIPP.
The function GetDisjointPathpairs is applied to calculate path-
pairs between two disjoint nodes, and there is no intersection edge
between these path-pairs. Algorithm 3 is applied to transform a
MIPP into a MIPS.
In the following, we ﬁrst discuss the complexity of
Algorithm 1 –3 . According to the construction rules of graph,
Fig. 1. Directed graph in Example 4 .
Fig. 2. Directed graph in Example 5 .
line 1 of Algorithm 1 can be executed in polynomial time. In line
2 of Algorithm 1, Algorithm 2 ( CalculateMIPP ) is invoked. Thus, we
turn to discuss the complexity of Algorithm 2 .
In line 2 of Algorithm 2 , all the negative nodes of G T can be
accessed in the ﬁrst loop. In lines 3–4 of Algorithm 2 , the descen-
dant nodes of each negative node ¬A and its disjoint node A can be
calculated. At the end of Algorithm 2 , all of MIPP can be obtained
in lines 7–8 which is nested in the third loop. From above analysis,
Algorithm 2 is actually executed in a quadruple loop, but the com-
plexity of function GetDisjointPathPairs which is invoked in line 6
of Algorithm 2 is in NP-hard. GetDisjointPathPairs aims to calculate
all pairs of paths between the nodes ¬A and A . Calculating a pair
of paths is a traversal of the graph G T to visit all nodes and edges
in the graph, thus its complexity is O(| v | 2 ) in the worst case. Since
there exists exponential number of pairs of paths in the worst case,
there may be exponentially MIPP in the G T . It can be shown in the
following example which is modiﬁed from Example 1 of [20] .
Example 4. Given a TBox T , where T = { B 0 ⊑ ¬ B n , B i −1 ⊑
P i , B i −1 ⊑ Q i , P i ⊑ B i , Q i ⊑ B i | 1 ≤i ≤n } .
The TBox T can be transformed into a graph as shown in Fig. 1 .
In Fig. 1 , we can obtain that the number of pairs of paths from
B 0 → ¬B n and B 0 → B n is 2 n . Therefore, the complexity of
Algorithm 2 is in exponential time.
We continue to discuss Algorithm 1 . Lines 3–4 of Algorithm 1
contain a single loop which can be executed in time O( n ) ( n is the
size of mipps). From what we have discussed above, the complex-
ity of Algorithm 1 is also in exponential time.
In Algorithm 3 , a MIPP can be transformed into a MIPS. Lines
2–8 of Algorithm 3 contain a triplet loop which can be executed in
cubic time. Therefore, the complexity of Algorithm 3 is O( n 3 ).
Example 5. Given a TBox T , where T = { A ⊑ B, B ⊑ C, C ⊑ D, B ⊑
¬ C, R 1 ⊑ R 2 , B ⊑ ∃ R 1 , ∃ R 2 ⊑ ¬ D } .
According to the Construction Rules, we construct a directed
graph as shown in Fig. 2 . In lines 2–6 of Algorithm 2 , two MIPPs
are identiﬁed in Fig. 2 , { B → ¬C, B → C } and { B → D, B → ¬D }.
In Algorithm 3 , the path pair of MIPP will be transformed to ax-
ioms. For ∃ R 1 ⊑ ∃ R 2 /
∈ T and R 1 ⊑ R 2 ∃ R 1 ⊑∃ R 2 , arc ( ∃ R 1 , ∃ R 2 ) cor-
responds to R 1 ⊑ R 2 in T . Finally, two MIPSs { B ⊑ C, B ⊑ ¬C } and
{ B ⊑ C, C ⊑ D, R 1 ⊑ R 2 , B ⊑∃ R 1 , ∃ R 2 ⊑ ¬D } are generated.
Theorem 9. Given an incoherent TBox T , the output of Algorithm 1
is the set of all MIPSs of T .
Proof. According to Theorem 5 , n ∈ d escend ants (S, G T ) means n ⊑
S . Thus, in lines 2–6 of Algorithm 2 , n 1 = n 2 means that there
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
7
exists a path pair from the node n 1 ( or n 2 ) to disjointness pair ( S ,
¬S ). By Deﬁnition 6 , these two paths are in a MIPP. Further, Algo-
rithm 3 is applied to transform a MIPP to a MIPS.
For any MIPS in T , there exists a concept (or role) that is
subsumed by two disjointness concepts (or roles). Thus, from
Theorem 5 , we can get two intersectional paths derived from two
disjointness nodes in G T . Obviously, the intersectional point is the
descendant of the two disjointness node. Namely, each MIPS can
be calculated as shown in lines 1–4 of Algorithm 1 . Therefore, the
result of Algorithm 1 is mips( T ). □
4.2. Graph-based algorithms for TBox revision
In this subsection, we give speciﬁc algorithms to instantiate the
reﬁnement revision operator deﬁned in Section 3 . Inspired by the
works reported in [7,8] and [21] , we propose two algorithms, one
is based on a scoring function, the other is based on a hitting set
tree (HS-Tree).
4.2.1. Revision algorithm based on scoring function
In [22] , a scoring function is used to measure the inconsistency
of an ontology. In [8] , this scoring function is reformulated for on-
tology revision in which axioms with the highest frequency of oc-
currence in mips T 2 (T 1 ) are picked. In the following, we introduce
the deﬁnition of a scoring function.
Deﬁnition 15. Let T 1 and T 2 be two DL-Lite FR TBoxes and T =
T 1 ∪ T 2 . The scoring function for axiom α w.r.t T , is a function
S T : mips T 2 (T 1 ) → N such that for all φ ∈
mips
S T (φ) = | T i ∈ mips T 2 (T 1 ) : φ ∩ T i ̸ = ∅ | .
Then, in order to deﬁne a speciﬁc reﬁnement function, we mod-
ify the notion of axiom impact in [18] , which evaluates the impact
of an axiom when removing it from TBox.
Deﬁnition 16. Let T 1 and T 2 be two DL-Lite FR TBoxes and T = T 1 ∪
T 2 . The impact of an axiom φ, denoted by impact( φ), is deﬁned as
follows:
impact(φ) =
⎧
⎨
⎩
0 , φ /
∈
mips ,
|{ φ′ ∈ cl T (φ) |
mips φ \{ φ} ∪ { φ′ } is coherent. }| ,
φ ∈
mips .
In Deﬁnition 16 ,
mips =
T i ∈ mips T 2 (T 1 ) T i , mips φ denotes the
set of MIPS that contains the inclusion assertion φ and
mips φ =

T i ∈ mips φ T i .
Based on the value of the scoring function, the incision function
can select a candidate axiom φ. In detail, an axiom will be selected
if its score is maximum, otherwise, the impact value of these ax-
ioms will be calculated. Then, the axiom with minimum value of
impact will be selected because the smaller the value of impact,
the less number of axioms will be added.
By using the scoring function and the axiom impact, we present
algorithm GReviByScoring (see Algorithm 4 )
for TBox revision,
which consists of three steps.
Step 1 initialization . In lines 1-2, the set E 1 (resp. E 2 ) is initially
assigned by the set of edges of G T 1 (resp. G T 2 ). CalculateMIPP is in-
voked to obtain the set of MIPP and the returned result is assigned
to mipp (line 3), and then the edges of mipp , which belong to G T 1 ,
are selected to initialize the set candidates (lines 4–7). At the end
of the step, the function SortingOnScore sorts candidates according
to the frequency of the edges in mipp .
Step 2 calculating the unwanted set. In lines 9-15, the edge with
maximum score is selected. The function GetTopEqEdges (line 13)
groups the edges with the same maximum score in eqEdges . The
function GetImpact is called to rank the impact values of the edges
in eqEdge (line 14). The edge with minimum impact value is then
Algorithm 4: GReviByScoring.
Input : G T = G T 1 ∪ G T 2
Output : G T 1 ◦⊨G T 2
1 E ⊨← ∅ , E ⊭ ← ∅ , E r
⊨← ∅ ;
2 E 1 ← GetEdges (G T 1 ) , E 2 ← GetEdges (G T 2 ) ;
3 mipp = CalculateMIPP (G T );
4 for each MIPP ∈ mipp do
5
for each edge ∈ MIPP do
6
if edge ∈ G T 1 then
7
candidates ← candidates ∪ { edge } ;
8 scoredEdges ← SortingOnScore(candidates) ;
9 while mipp ̸ = ∅ do
10
if ExistMaxScore(scoredEdges) then
11
edge ← GetMaxScoreEdge(scored) ;
12
else
13
eqEdges ← GetTopEqEdges(scoredEdges) ;
14
ranked Ed ges ← GetImpact (eqEdges, G T ) ;
15
edge ← GetMaxRankEdge(rankedEdges) ;
16
E ⊭ ← E ⊭ ∪ { edge } ;
17
rCandidates ← rCandidates ∪ Closure (edge, G T ) ;
18
UpdateState(edge, scoredEdges, mipp) ;
19 E ⊨= (E 1 \ E ⊭ ) ∪ E 2 ;
20 for each edge ∈ rCandidates do
21
if not HasMIPP( E ⊨∪ edge ) then
22
E r
⊨← E r
⊨∪ { edge } ;
23 return E ⊨∪ E r
⊨;
selected and put in the unwanted set T ⊭ (line 15). In line 17, the
function Closure is called to compute the closure of G T , and the
output is rCandidates . Finally, the function UpdateState removes the
MIPPs that contain the selected edges.
Step 3 calculating the reﬁnement set. The set E  is ﬁrst as-
signed with ( E 1 \ E ) ∪ E 2 ) (line 19). rCandidates is then scanned and
checked to see whether a union of an edge in rCandidates with E ⊭
leads to a new MIPP. All the edges that would not lead to new
MIPPs are added in the reﬁnement set E ⊨(lines 20–22).
In the following, we discuss the complexity of Algorithm 4 . The
exponential algorithm CalculateMIPP will be invoked in line 3 for
calculating all the MIPP of G T . In lines 4–7, there exists a double
loop. The times of the outer loop is the number of MIPPs and the
times of the inner loop is the number of edges in corresponding
MIPP. In line 8, a sorting algorithm will be invoked and its com-
plexity is O( n 2 ) in the worst case. The function of line 9–18 is to
calculate the unwanted set, which can be executed in polynomial
time. Therefore, except for the calculation of MIPP, the complexity
of Algorithm 4 is in PTIME.
Example 6. Let T 1 and T 2 be two TBoxes. T 1 = { A ⊑ B, B ⊑ C, D ⊑
E, D ⊑ F , F ⊑ G } , T 2 = { A ⊑ ¬ C, A ⊑ ¬ B, C ⊑ E, F ⊑ ¬ E} . We consider
using algorithm GReviByScoring to revise T .
We ﬁrstly encode T 1 and T 2 into the graph as shown in the left
part of Fig. 3 .
According to Deﬁnition 6 , we can obtain three MIPPs as follows:
{ A → ¬B, A → B }, { A → B, B → C, A → ¬C }, { D → E, D → F, F
→ ¬E }. Based on lines 4–7 , we obtain cand id ates = { A → B, B →
C, D → E, D → F } , whose edges are from G T 1 .
In line 8, the edges of candidates are sorted by the
scoring function (see scored Ed ges = { (A → B, 2) , (B → C, 1) , (D →
E, 1) , (D → F , 1) } ).
8
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
Fig. 3. The process of revision in Example 6 .
At the ﬁrst iteration of lines 9–15, the edge ( A → B ) is se-
lected in lines 10–11, which has the maximum value of scoring
function. Then, edge ( A → B ) is appended in the set E  and the
closure of ( A → B ), which is { A → C, A → E }, is appended into
the set nCandidates .Then, the variables in the algorithm are up-
dated. During the updating, the edge ( A → B ) is removed from
candidates . The MIPPs including the edge ( A → B ) are removed
from mipp and the scoredEdges is updated into {( D → E , 1), ( D →
F , 1)}. At the second iteration, there are two edges in candidates
with the same value of scoring function. Therefore, the algorithm
switches to “else case”, where the impact values are calculated for
the edges, ( D → E ) and ( D → F ), based on lines 13–15. For the ex-
ample, we have obtained that Closure ( D → E, G T ) = ∅ and Closure
( D → F , G T ) = { D → G, D → ¬ E} . Further, the edge ( D → F ) is se-
lected based on the function GetMaxRankEdge . Finally, when mipp
turns into an empty set, the whole iteration ﬁnishes.
The above operation just gets unwanted set of edges from G T ,
there still has some available information in set nCandidates . Thus,
in lines 20-22, we retrieve the set nCandidates and collect the
edges in nCandidates that will not lead to new MIPP. For the ex-
ample, edge ( A → C ) is collected. The ﬁnal result of the revision of
Example 6 is shown in the right part of Fig. 3 .
4.2.2. Revision algorithm based on hitting set tree
The incision function can be also implemented by a HS-Tree.
HS-Tree is proposed in [23] where Reiter propose an approach that
constructs a labeled tree based on a conﬂict set and reformulated
in [7] for ontology debugging. During the process of ontology de-
bugging, mips T 2 (T 1 ) can be regarded as a set of conﬂict sets. In a
HS-Tree, nodes can be labeled with MIPS ∈ mips T 2 (T 1 ) and edges
can be labeled with axioms α ∈
T ∈ mips T 2 (T 1 ) T .
In the following, we propose the revision algorithm, GReviByHST
(see Algorithm 5 ).
The algorithm also has three steps which are analogous to
GReviByScoring . The main difference is in Step 2. In Step 2 of
GReviByHST , the whole unwanted set E  is obtained based on the
method of hitting set tree. and the candidate set of unwanted ax-
ioms are calculated once by invoking the function HS-Tree (line 8)
and GetMinHS .
Next, we discuss the complexity of Algorithm 5 . Algorithm 5
aims to perform the revision of ontologies by using a global op-
timal solution, which ﬁrstly calculates all the MIPP of G T resem-
bling to Algorithm 4 . In line 3, the exponential algorithm Calcu-
lateMIPP will be invoked. Lines 4–7 contain a double loop which
can be executed in square time. In line 8 , a function based on hit-
ting set tree will be invoked. There exists exponential number of
hitting sets [24] which can be executed in exponential time. There
is no loop statement in lines 9–16 which can be executed in poly-
nomial time. Lines 17–19 contain a single loop which can be done
in O( n )( n is the size of rCandidates ). Therefore, except for the calcu-
lating of MIPP, the complexity of Algorithm 5 is also in exponential
time.
Algorithm 5: GReviByHST.
Input : G T = G T 1 ∪ G T 2
Output : G T 1 ◦⊨G T 2
1 E 1 ← GetEdges (G T 1 ) , E 2 ← GetEdges (G T 2 ) ;
2 E ⊨← ∅ , E ⊭ ← ∅ , E r
⊨← ∅ ;
3 mipp = CalculateMIPP (G T );
4 for each MIPP ∈ mipp do
5
for each edge ∈ MIPP do
6
if edge ∈ G T 2 then
7
MIPP ← MIPP \{ edge } ;
8 hittingSets ← HS-Tree ( mipp ) ;
9 if ExistMinHS(hittingSets) then
10
E ⊭ ← GetMinHS ( hittingSets ) ;
11 else
12
eqHSs ← GetTopEqHSs(hittingSets) ;
13
rankedHSs ← GetImpacts ( eqHSs , G T ) ;
14
E ⊭ ← GetMaxRankHS ( rankedHSs ) ;
15 rCandidates ← Closure (E ⊭ , G T ) ;
16 E ⊨= (E 1 \ E ⊭ ) ∪ E 2 ;
17 for each edge ∈ rCandidates do
18
if not HasMIPP( E ⊨∪ edge ) then
19
E r
⊨← E r
⊨∪ { edge } ;
20 return E ⊨∪ E r
⊨
Fig. 4. Hitting set tree of Example 7 .
Example 7. We consider using the TBoxes in Example 6 here. We
perform the revision based on GRevisByHST.
GReviByHST ﬁrstly initializes the variables. According to lines 3–
7, we get three MIPS T 2 (T 1 ) : { A → B }, { A → B, B → C }, { D → E ,
D → F }. According to the algorithm for calculating diagnoses using
hitting set [7] , we can build a hitting set tree, as shown in Fig. 4 .
From Fig. 4 , we obtain two minimum hitting sets: { A → B, D →
E } and { A → B, D → F }. According to lines 9-14, function GetImpacts
is called to calculate the impact value of these two sets. For { A →
B, D → F }, the reﬁnement set is { A → C, A → E, D → ¬E }. For
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
9
Table 1
Partitioned ontologies.
Ontology
Axioms
NIs
Concepts
Roles
AEO
Part 1
1043
1
225
7
Part 2
1038
4
223
6
CL
Part 1
12373
19
2841
26
Part 2
12365
20
2843
22
DOLCE
Part 1
294
5
34
66
Part 2
335
13
33
70
Economy
Part 1
1726
34
285
41
Part 2
1719
37
296
38
Fly-Anatomy
Part 1
16766
31
7091
27
Part 2
16703
30
7093
31
FMA
Part 1
274501
2
70339
15
Part 2
272731
1
69968
14
GO
Part 1
50774
1
17209
1
Part 2
51091
2
17302
1
Plant
Part 1
10984
24
1464
10
Part 2
11029
2
1457
9
Terrorism
Part 1
1038
1
93
120
Part 2
984
1
77
111
Transportation
Part 1
1415
158
387
79
Part 2
1420
159
383
76
Table 2
Conﬂict information in ontologies.
AEO
CL
DOL.
Eco.
F.A.
FMA
GO
Pla.
Terr.
Tra.
UC
49
59
33
51
71
304
97
45
14
62
MIPS
17
25
5
47
53
3
18
12
5
36
{ A → B, D → E }, the reﬁnement set is { A → C, A → E }. In order to
guarantee minimal change, we choose the set { A → B, D → E } as
the unwanted set. Based on lines 17-19, the edges in rCandidates
are added.
5. Implementation and evaluation
We have implemented the debugging and revision algorithms
presented in the previous section. The system is built on several
open source software packages. We parse the structure of an on-
tology by OWLAPI, 1 which is a tool for managing OWL ontologies
[25] . We transform an ontology into a graph and store it in the
Neo4j graph database [26] . Neo4j 2 is an open-source and high-
performance graph database supported by Neo Technology [27] .
The main ingredients of Neo4j are nodes and relationships. The
nodes of Neo4j are used to record data in nodes which have user-
deﬁned properties and organized by relationships which also have
user-deﬁned properties. Furthermore, Neo4j provides a powerful
declarative graph query language, cypher, which can be leveraged
to querying and updating a graph database.
The ontologies used in our experiments have different sizes
and structures. An ontology will be approximated [16] , if it cannot
be expressed in DL-Lite. As we mentioned above, the incoherence
appears in the merging process of two ontologies. To obtain the
test ontologies, we partition an ontology into two different parts
and modify them by inserting some “incoherent-generating” ax-
ioms randomly, such as negative inclusions. For example, if T =
{ A ⊑ B, B ⊑ C, B ⊑ D } , it is obvious that T is coherent. To make it
incoherent, we may insert C ⊑ ¬D into T .
In our work, we assume that the single ontology is consis-
tent and the incoherence appears when ontologies are combined.
In the preprocessing, we store the two ontologies into the Neo4j
database, and use cypher query of neo4j to guarantee the precon-
1 http://owlapi.sourceforge.net .
2 http://www.neo4j.org/learn/cypher .
Table 3
Time ( in milliseconds ) required to calculate all MIPS.
Ontology
Pellet
Hermit
FaCT++
JFaCT
onGraph
AEO
1385
1986
814
1602
397
CL
1536
2423
1187
2342
652
DOL.
784
1121
515
867
362
Eco.
1354
1429
677
1976
652
F.A.
2129
3386
1926
4993
642
FMA
47975
49867
45760
92017
3718
GO
3805
5442
3893
9465
906
Pla.
1654
2180
1102
1978
596
Terr.
415
496
405
521
193
Tra.
1892
2861
1457
4926
725
Table 4
Debugging time ( in milliseconds ) for incremental unsatisﬁable concepts.
UC in GO
Pellet
Hermit
FaCT++
JFact
onGraph
100
4381
6090
3991
8882
827
110
4641
6280
4342
10864
912
120
4982
7155
4 94 8
12636
933
130
6609
9771
6425
17174
1016
140
8077
10132
7305
66663
1127
150
9449
12082
8714
overﬂow
1209
160
10210
13065
9630
overﬂow
1263
200
12889
16573
12503
overﬂow
1769
Table 5
Time (in seconds) required to ontology revision.
AEO
CL
DOL.
Eco.
F.A.
GReviByScoring
14.076
16.649
2.358
20.198
20.452
GReviByHST
21.972
timeout
4.776
timeout
timeout
FMA
GO
Pla.
Terr.
Tra.
GReviByScoring
4.524
14.448
4.879
2.644
18.393
GReviByHST
6.47
250.552
8.53
5.179
timeout
dition of our algorithms when adding a disjoint axiom to an ontol-
ogy. The statistics of the used ontologies is given in Table 1 .
All experiments are performed on a desktop computer with In-
tel Core i5-2400 3.1 GHz CPU and 8GB of RAM, running Microsoft
window 7 operating system, and Java 1.7 with 6GB of heap space.
5.1. Experiment of computing MIPSs based on graph
In this paper, our approach of debugging aims to calculate MIPS.
Many ontology reasoners can calculate MIPS. In this section, we
performed comparative experiments with several popular reason-
ers, such as Pellet, 3 Hermit, 4 FaCT++, 5 JFaCT 6 .
We conducted the experiment from two aspects: one is to com-
pare eﬃciency and the other is to compare performance on an on-
tology with different number of unsatisﬁable concepts or roles.
The conﬂicting information is shown in Table 2 (we abbrevi-
ate the name of ontologies in Table 1 and UC is the abbreviation
of unsatisﬁable concepts). The experimental results are shown in
Table 3 . From Table 3 (Graph-based Debugging approach is abbre-
viated as onGraph), our approach outperforms others. Especially,
for some complex ontologies, such as FMA, our approach is sig-
niﬁcantly faster than others. Table 4 gives the result of scalability
over the adapted GO ontology, with different number of unsatisﬁ-
able concepts or roles added. In the table, overﬂow means that the
experimental program exhausts available memory.
3 https://github.com/complexible/pellet .
4 http://hermit-reasoner.com .
5 https://code.google.com/p/factplusplus .
6 http://jfact.sourceforge.net .
10
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
Table 6
The change of ontologies in GReviByScoring .
AEO
CL
DOL.
Eco.
F.A.
FMA
GO
Pla.
Terr.
Tra.
Deleted
6
12
3
27
3
1
7
3
5
14
Added
6
22
6
144
35
1
13
3
5
66
Table 7
The change of ontologies in GReviByHST .
AEO
CL
DOL.
Eco.
F.A.
FMA
GO
Pla.
Terr.
Tra.
Deleted
5
–
3
–
–
1
7
3
5
–
Added
5
–
6
–
–
1
13
3
5
–
Fig. 5. Time required to calculate MIPSs on GO.
We ﬁrst identiﬁed all the disjoint concepts in GO ontology, and
then increased the number of unsatisﬁable concepts by adding
common subsumed concept to the disjoint concepts randomly (we
began with 100 unsatisﬁable concepts for clearer comparison). The
same treatment is also applied to roles. To have a better view, we
transformed Table 4 into chart shown in Fig. 5 . From Fig. 5 , we
can see that, with the growing number of unsatisﬁable concepts
and roles, the execution time of the state of the art approaches in-
creases sharply. In comparison, the execution time of our approach
grows moderately. The comparison result shows that our approach
performs more steadily than other approaches in computing MIPS.
5.2. Experiment of revising terminologies based on graph
We conducted the experiment of revision to compare
GReviByScoring and GReviByHST .
In this part, we set 30 min as the cut-off time. The experimen-
tal result of TBox revision is shown in Table 5 . From Table 5 , we
can see that scoring-based algorithm outperformed HST-based al-
gorithm. We can further see that, with the number of MIPP in-
creasing, the execution time is also increasing and GReiviByHST
runs slower than GReviByScoring .
The difference between the two algorithms is caused by the
speciﬁc incision function. GReviByHST is based on the method
of hitting set tree to implement the incision function that can
obtain the globally optimal solution. However, the complexity
of ﬁnding minimal hitting sets is known to be NP-hard [24] .
Thus, GReviByHST leads to a non-linear growth of running time.
GReviByScoring employs a scoring function to deﬁne the inci-
sion function. Though it only achieves locally optimal solution,
the complexity of calculating cardinality-minimal set is in PTime.
Hence, the execution time of GReviByScoring is more than that of
GReviByScoring .
The changes of the number of axioms in ontologies are col-
lected in Tables 6 and 7 . As shown in Tables 6 and 7 , only on
the ontology AEO, GReviByHST leads to fewer changes than that of
GReviByScoring .
6. Related work
In the process of building and maintaining ontologies, new in-
formation may be inconsistent with ontologies when added it to
the ontologies. Reasoning with inconsistent ontologies can obtain
arbitrary conclusions. Therefore, inconsistency of ontology is an ur-
gent problem that has to be resolved. This problem can be tackled
by ontology debugging and revision which have been widely dis-
cussed in the literature.
First, we introduce the related work of ontology debugging. In
general, the approaches for ontology debugging can be divided into
two categories: glass-box approach and black-box approach. Glass-
box approaches are based on reasoning algorithms and most of the
glass-box approaches are obtained as extension of tableau-based
algorithms for checking satisﬁability of a DL-based ontology. The
ﬁrst tableau-based algorithm for ontology debugging is proposed
in [14] , but the algorithm is restricted to unfoldable ALC TBoxes.
In [5] , the tableau-based algorithm is extended to a more expres-
sive DL, OWL DL. As pointed out in [21] , one problem for the
tableau-based algorithms is that some blocking techniques cannot
be used. To avoid this problem, an automata-based approach is
given in [28] . This approach has some nice theoretical advantage
over tableau-based approaches. In order to compute MUPS, a de-
bugging algorithm for DL-Lite ontologies is proposed based on the
cln (T ) which can be calculated off-line [29] . Our graph-based de-
bugging algorithm belongs to the glass-box approach and specif-
ically designed for DL-Lite ontologies. Furthermore, our algorithm
can directly compute MIPS, while previous debugging algorithms
are mostly applied to compute MUPS.
Different from the glass-box approaches, the black-box ap-
proaches do not need to modify the DL reasoner. However, in the
worst case, the black-box approach may call the reasoner an ex-
ponential number of times. In [30] , a general DL-based debug-
ging approach is given. The approach is based on Reiter’s algorithm
and employs a simpliﬁed variant of QUICKXPLAIN [31] to generate
the hitting set tree. According to [20] , computing MUPS is a hard
task for tractable DLs like EL . Therefore, it may be not possible
to compute all MUPS for some large ontologies. In [32] , the au-
thors present an extensive evaluation of existing ontology debug-
ging systems. However, they mainly evaluate systems for comput-
ing MUPS, but do not consider the computation of MIPS.
Next, we discuss the related work of ontology revision.
Ontology revision deals with the incoherent problem when in-
corporating newly received information. In a nutshell, approaches
to ontology revision can roughly be divided into two categories:
syntax-based one and model-based one.
Most of practical revision operators are syntax dependent, i.e.,
if two logically dependent ontologies are revised by another on-
tology, the results of revision may not be logically equivalent. One
type of syntax-based approaches is based on incision function. The
incision function is used to select axioms, which are to be removed
from the original ontology. The authors in [8] proposes a kernel
revision operator and give two algorithms to deﬁne speciﬁc ker-
nel revision operators. The authors in [9] develop a revision op-
erator based on a trust-based incision function. The other type of
formula-based approaches is to ﬁnd maximally satisﬁable termi-
nologies. An algorithm is proposed in [33] to ﬁnd maximally sat-
isﬁable terminologies for the description logic ALC . A ﬁne-grained
approach is proposed in [34] in which notion of ﬁne-grained repair
is ﬁrstly introduced. In the approach, one axiom may be weakened
to more axioms instead of being deleted.
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
11
Most of the works on model-based revision in DLs are devoted
to proving the inexpressibility of model-based revision operators
(see [35] and [36] for example). However, very few of them dis-
cuss the approximation of model-based revision. One exception is
the work in [37] , where a revision operator is deﬁned by a new
semantics called features. However, feature-based revision also suf-
fers from the inexpressibility problem and the algorithm is ineﬃ-
cient to deal with large ABoxes. Recently, there are some works
on TBox revision based on a new semantics, called type semantics
(see [38] and [39] ). In [40] , the authors propose an approach for
approximating model-based revision operator by using a syntax-
based revision operator. However, this work focuses on ABox revi-
sion instead of TBox revision.
7. Conclusion
In this paper, we proposed graph-based approaches for debug-
ging and revising incoherent DL-Lite ontologies.
In order to debug incoherent ontologies, we ﬁrstly encoded a
DL-Lite ontology into a directed graph according to the given con-
struction rules. Then, we gave a deﬁnition of MIPP on the graph
and proposed the debugging approach based on MIPP. Finally, we
conducted experiments over some adapted ontologies. Without the
help of the DL reasoner, all the MIPS of an ontology can be cal-
culated by backtracking some pairs of nodes in the graph. Our
graph-based approach improves the ontology debugging both in ef-
ﬁciency and scalability.
In order to revise incoherent ontology, we propose the re-
ﬁnement revision operation based on a reﬁnement revision space
which can be obtained by a revision function. According to the
principle of minimal change, the reﬁnement revision operation can
reserve more valid information. Finally, we gave two algorithms
for ontology revision. one is based on incision function and the
other is based on a HS-Tree. The experimental results shown that
scoring-based algorithm leads to a better performance than HST-
based algorithm, especially for the ontologies that contain numer-
ous MIPSs.
In the paper, we focused on the family of DL-Lite. One of future
works, we plan to extend our algorithms to more expressive de-
scription languages. As to DL-Lite, one of the remarkable character-
istics is that it is suitable for query answering. The data complexity
of answering unions of conjunctive queries in DL-Lite is polynomial
in the size of the whole ontology and in LOGSPACE with respect to
the size of ABox only [11] . As another of future work, we plan to
study consistent query answering approaches based on graph.
Acknowledgments
We would like to thank the anonymous referees for their com-
ments. Research presented in this paper was partially supported by
National Science Foundation of China (no. 61272378 ), by the funds
from JiangXi Educational Committee (no. GJJ12643), by the Na-
tional High Technology Research Program of China (863 Program)
(no. 2015AA015406).
References
[1] K. Amailef , J. Lu , Ontology-supported case-based reasoning approach for intel-
ligent m-government emergency response services, Decis. Support Syst. 55 (1)
(2013) 79–97 .
[2] Y. Ma , B. Jin , Y. Feng , Dynamic evolutions based on ontologies, Knowl. Based
Syst. 20 (1) (2007) 98–109 .
[3] B. Parsia , E. Sirin , A. Kalyanpur , Debugging OWL ontologies, in: Proceedings
of the 14th International Conference on World Wide Web (WWW), 2005,
pp. 633–640 .
[4] G. Qi , F. Yang , A survey of revision approaches in description logics, in: Pro-
ceedings of Second International Conference on Web Reasoning and Rule Sys-
tems (RR), 2008, pp. 74–88 .
[5] A. Kalyanpur , B. Parsia , E. Sirin , J. Hendler , Debugging unsatisﬁable classes in
OWL ontologies, J. Web Sem. 3 (4) (2005) 268–293 .
[6] Q. Ji , Z. Gao , Z. Huang , M. Zhu , An eﬃcient approach to debugging ontologies
based on patterns, in: Proceedings of Joint International Semantic Technology
Conference (JIST), 2011, pp. 425–433 .
[7] S. Schlobach , Z. Huang , R. Cornet , F. Van Harmelen , Debugging incoherent ter-
minologies, J. Autom. Reasoning 39 (3) (2007) 317–349 .
[8] G. Qi , P. Haase , Z. Huang , J.Z. Pan , A kernel revision operator for terminologies,
in: Proceedings of the 21st International Workshop on Description Logics (DL),
2008, pp. 419–434 .
[9] J. Golbeck , C. Halaschek-Wiener , Trust-based revision for expressive web syn-
dication, J. Log. Comput. 19 (5) (2009) 771–790 .
[10] C.E. Alchourrón , P. Gärdenfors , D. Makinson , On the logic of theory change:
partial meet contraction and revision functions, J. Symb. Log. 50 (2) (1985)
510–530 .
[11] D. Calvanese , G.D. Giacomo , D. Lembo , M. Lenzerini , R. Rosati , Tractable rea-
soning and eﬃcient query answering in description logics: The DL-Lite family,
J. Autom. Reasoning 39 (3) (2007) 385–429 .
[12] T. Venetis , G. Stoilos , G.B. Stamou , Query rewriting under query reﬁnements,
Knowl. Based Syst. 56 (2014) 36–48 .
[13] A. Artale , D. Calvanese , R. Kontchakov , M. Zakharyaschev , The DL-Lite family
and relations, J. Artif. Intell. Res. 36 (1) (2009) 1–69 .
[14] S. Schlobach , R. Cornet , Non-standard reasoning services for the debugging of
description logic terminologies, in: Proceedings of the 13th International Joint
Conference on Artiﬁcial Intelligence (IJCAI), 2003, pp. 355–362 .
[15] S. Gao , G. Qi , H. Wang , A new operator for ABox revision in DL-Lite, in: Pro-
ceedingsof the 26th National Conference on Artiﬁcial Intelligence (AAAI), 2012,
pp. 2423–2426 .
[16] D. Lembo , V. Santarelli , D.F. Savo , Graph-based ontology classiﬁcation in OWL
2 QL, in: Proceeding of 10th International Conference on the Semantic Web:
Semantics and Big Data(ESWC), 2013, pp. 320–334 .
[17] M. Akram , Bipolar fuzzy graphs with applications, Knowl. Based Syst. 39 (2013)
1–8 .
[18] N. Nikitina , S. Rudolph , B. Glimm , Interactive ontology revision, J. Web Sem. 12
(1) (2012) 118–130 .
[19] M. Lenzerini , D.F. Savo , Updating inconsistent description logic knowledge
bases, in: Proceeding of 20th European Conference on Artiﬁcial Intelligence
(ECAI), 2012, pp. 516–521 .
[20] F. Baader , R. Peñaloza , B. Suntisrivaraporn , Pinpointing in the description logic
EL + , in: Proceeding of Advances in Artiﬁcial Intelligence (KI), 2007, pp. 52–
67 .
[21] A. Kalyanpur , B. Parsia , M. Horridge , E. Sirin , Finding all justiﬁcations of OWL
DL entailments, in: Proceedings of Sixth International Semantic Web Con-
ference (ISWC) and Second Asian Semantic Web Conference (ASWC), 2007,
pp. 267–280 .
[22] G. Qi , A. Hunter , Measuring incoherence in description logic-based ontologies,
in: Proceedings of Sixth International Semantic Web Conference (ISWC) and
Second Asian Semantic Web Conference (ASWC), 2007, pp. 381–394 .
[23] R. Reiter , A theory of diagnosis from ﬁrst principles, Artif. Intell. 32 (1) (1987)
57–95 .
[24] S. Schlobach , Diagnosing terminologies, in: Proceedings of the 20th National
Conference on Artiﬁcial Intelligence (AAAI), 2005, pp. 670–675 .
[25] M.A. Casteleiro , J.J.D. Diz , Clinical practice guidelines: a case study of combin-
ing OWL-S, OWL, and SWRL, Knowl. Based Syst. 21 (3) (2008) 247–255 .
[26] I. Robinson, J. Webber, E. Eifrem, Graph Databases, O’Reilly Media, Inc., pp. 25–
63.
[27] J. Webber , A programmatic introduction to Neo4j, in: Proceedings of Con-
ference on Systems, Programming, and Applications: Software for Humanity
(SPLASH), 2012, pp. 217–218 .
[28] F. Baader , R. Peñaloza , Automata-based axiom pinpointing, in: Proceeding of
Fourth International Joint Conference on Automated Reasoning (IJCAR), 2008,
pp. 226–241 .
[29] L. Zhou , H. Huang , G. Qi , Y. Qu , Q. Ji , An algorithm for calculating minimal
unsatisﬁability-preserving subsets of ontology in DL-Lite, J. Comput. Res. Dev.
48 (3) (2011) 2334–2342 .
[30] G. Friedrich , K.M. Shchekotykhin , A general diagnosis method for ontologies,
in: Proceeding of Fourth International Semantic Web Conference (ISWC), 2005,
pp. 232–246 .
[31] U. Junker , QuickXplain: preferred explanations and relaxations for over-con-
strained problems, in: Proceedings of the 18th National Conference on Artiﬁ-
cial Intelligence (AAAI), 2004, pp. 167–172 .
[32] Q. Ji , Z. Gao , Z. Huang , M. Zhu , Measuring effectiveness of ontology debugging
systems, Knowl. Based Syst. 71 (2014) 169–186 .
[33] T.A. Meyer , K. Lee , R. Booth , J.Z. Pan , Finding maximally satisﬁable terminolo-
gies for the description logic ALC , in: Proceedings of the 21st National Confer-
ence on Artiﬁcial Intelligence (AAAI), 2006, pp. 269–274 .
[34] J. Du , G. Qi , X. Fu , A practical ﬁne-grained approach to resolving incoherent
OWL 2 DL terminologies, in: Proceedings of the 23rd International Conference
on Information and Knowledge Management (CIKM), 2014, pp. 919–928 .
[35] G. Qi , J. Du , Model-based revision operators for terminologies in description
logics., in: Proceedings of the 21st International Joint Conference on Artiﬁcial
Intelligence (IJCAI), 2009, pp. 891–897 .
[36] B.C. Grau , E.J. Ruiz , E. Kharlamov , D. Zhelenyakov , Ontology evolution under
semantic constraints, in: Proceeding of 13th International Conference on Prin-
ciples of Knowledge Representation and Reasoning (KR), 2012, pp. 137–147 .
12
X. Fu et al. / Knowledge-Based Systems 100 (2016) 1–12
[37] Z. Wang , K. Wang , R.W. Topor , A new approach to knowledge base revision
in DL-Lite, in: Proceeding of the 24th National Conference on Artiﬁcial Intelli-
gence (AAAI), 2010, pp. 369–374 .
[38] Z. Zhuang , Z. Wang , K. Wang , G. Qi , Contraction and revision over DL-Lite
TBoxes, in: Proceedings of the 28th National Conference on Artiﬁcial Intelli-
gence (AAAI), 2014, pp. 1149–1156 .
[39] Z. Wang , K. Wang , Z. Zhuang , G. Qi , Instance-driven ontology evolution in
DL-Lite, in: Proceedings of the 29th National Conference on Artiﬁcial Intelli-
gence (AAAI), 2015, pp. 1656–1662 .
[40] G. Qi , Z. Wang , K. Wang , X. Fu , Z. Zhuang , Approximating model-based ABox
revision in DL-Lite: Theory and practice, in: Proceedings of the 29th National
Conference on Artiﬁcial Intelligence (AAAI), 2015, pp. 254–260 .