Processing math: 100%
Research article Special Issues

Effective method for detecting error causes from incoherent biological ontologies


  • Computing the minimal axiom sets (MinAs) for an unsatisfiable class is an important task in incoherent ontology debugging. Ddebugging ontologies based on patterns (DOBP) is a pattern-based debugging method that uses a set of heuristic strategies based on four patterns. Each pattern is represented as a directed graph and the depth-first search strategy is used to find the axiom paths relevant to the MinAs of the unsatisfiable class. However, DOBP is inefficient when a debugging large incoherent ontology with a lot of unsatisfiable classes. To solve the problem, we first extract a module responsible for the erroneous classes and then compute the MinAs based on the extracted module. The basic idea of module extraction is that rather than computing MinAs based on the original ontology O, they are computed based on a module M extracted from O. M provides a smaller search space than O because M is considerably smaller than O. The experimental results on biological ontologies show that the module extracted using the Module-DOBP method is smaller than the original ontology. Lastly, our proposed approach optimized with the module extraction algorithm is more efficient than the DOBP method both for large-scale ontologies and numerous unsatisfiable classes.

    Citation: Yu Zhang, Haitao Wu, Jinfeng Gao, Yongtao Zhang, Ruxian Yao, Yuxiang Zhu. Effective method for detecting error causes from incoherent biological ontologies[J]. Mathematical Biosciences and Engineering, 2022, 19(7): 7388-7409. doi: 10.3934/mbe.2022349

    Related Papers:

    [1] Peng Wang, Shiyi Zou, Jiajun Liu, Wenjun Ke . Matching biomedical ontologies with GCN-based feature propagation. Mathematical Biosciences and Engineering, 2022, 19(8): 8479-8504. doi: 10.3934/mbe.2022394
    [2] Shirin Ramezan Ghanbari, Behrouz Afshar-Nadjafi, Majid Sabzehparvar . Robust optimization of train scheduling with consideration of response actions to primary and secondary risks. Mathematical Biosciences and Engineering, 2023, 20(7): 13015-13035. doi: 10.3934/mbe.2023580
    [3] Wei-Min Zheng, Qing-Wei Chai, Jie Zhang, Xingsi Xue . Ternary compound ontology matching for cognitive green computing. Mathematical Biosciences and Engineering, 2021, 18(4): 4860-4870. doi: 10.3934/mbe.2021247
    [4] Li Hou, Meng Wu, Hongyu Kang, Si Zheng, Liu Shen, Qing Qian, Jiao Li . PMO: A knowledge representation model towards precision medicine. Mathematical Biosciences and Engineering, 2020, 17(4): 4098-4114. doi: 10.3934/mbe.2020227
    [5] Karpaga Priyaa Kartheeswaran, Arockia Xavier Annie Rayan, Geetha Thekkumpurath Varrieth . Enhanced disease-disease association with information enriched disease representation. Mathematical Biosciences and Engineering, 2023, 20(5): 8892-8932. doi: 10.3934/mbe.2023391
    [6] Hangle Hu, Chunlei Cheng, Qing Ye, Lin Peng, Youzhi Shen . Enhancing traditional Chinese medicine diagnostics: Integrating ontological knowledge for multi-label symptom entity classification. Mathematical Biosciences and Engineering, 2024, 21(1): 369-391. doi: 10.3934/mbe.2024017
    [7] Wenjun Xu, Zihao Zhao, Hongwei Zhang, Minglei Hu, Ning Yang, Hui Wang, Chao Wang, Jun Jiao, Lichuan Gu . Deep neural learning based protein function prediction. Mathematical Biosciences and Engineering, 2022, 19(3): 2471-2488. doi: 10.3934/mbe.2022114
    [8] Wen-Lung Tsai . A process-tailoring method for digital manufacturing projects. Mathematical Biosciences and Engineering, 2021, 18(5): 5664-5679. doi: 10.3934/mbe.2021286
    [9] Yu Jin, Zhe Ren, Wenjie Wang, Yulei Zhang, Liang Zhou, Xufeng Yao, Tao Wu . Classification of Alzheimer's disease using robust TabNet neural networks on genetic data. Mathematical Biosciences and Engineering, 2023, 20(5): 8358-8374. doi: 10.3934/mbe.2023366
    [10] Yutong Man, Guangming Liu, Kuo Yang, Xuezhong Zhou . SNFM: A semi-supervised NMF algorithm for detecting biological functional modules. Mathematical Biosciences and Engineering, 2019, 16(4): 1933-1948. doi: 10.3934/mbe.2019094
  • Computing the minimal axiom sets (MinAs) for an unsatisfiable class is an important task in incoherent ontology debugging. Ddebugging ontologies based on patterns (DOBP) is a pattern-based debugging method that uses a set of heuristic strategies based on four patterns. Each pattern is represented as a directed graph and the depth-first search strategy is used to find the axiom paths relevant to the MinAs of the unsatisfiable class. However, DOBP is inefficient when a debugging large incoherent ontology with a lot of unsatisfiable classes. To solve the problem, we first extract a module responsible for the erroneous classes and then compute the MinAs based on the extracted module. The basic idea of module extraction is that rather than computing MinAs based on the original ontology O, they are computed based on a module M extracted from O. M provides a smaller search space than O because M is considerably smaller than O. The experimental results on biological ontologies show that the module extracted using the Module-DOBP method is smaller than the original ontology. Lastly, our proposed approach optimized with the module extraction algorithm is more efficient than the DOBP method both for large-scale ontologies and numerous unsatisfiable classes.



    Description logics (DLs) [1] are a family of logic-based knowledge representation formalisms that can be used to develop ontologies using the web ontology language (OWL) [2]. DL ontology typically consists of TBox axioms and ABox axioms. TBox axioms represent relationships between classes or between properties. For example, the axiom "mitochondrioncytoplasm" states that the class mitochondrion is the subclass of cytoplasm, while the axiom "hasChildhasSibling" states that the property hasChild is a sub-property of hasSibling. ABox axioms represent relationships between classes and individuals, and between properties and individuals. For example, LocatedIn(mitochondria, cytoplasm) states that mitochondria are located in the cytoplasm. This study focuses on the TBox part of ontologies. Given that the TBox reasoning is not influenced by ABox reasoning [3], we assume that an ontology consists of only a TBox in the rest of the study. In the opening environment, errors often occur in a biological ontology when the same ontology is simultaneously edited by more than one participators, and the majority of them are unaware of the existences of one another [4]. Errors mean that the definitions of some of the classes yield logical conflicts. We call the classes as unsatisfiable classes and the ontology as incoherent ontology.

    The following is a example of an incoherent gene ontology O1.

    α1: mitochondrionorganelle (mitochondrion is an organell)

    α2: mitochondrioncytoplasm (mitochondrion is a part of cytoplasm)

    α3: cytoplasmcell (cytoplasm is a part of a cell)

    α4: mitochondrion¬cell (mitochondrion is not a part of a cell)

    Biological proteins play an important role in most cellular processes, such as gene regulation, recombination, repair, replication, and DNA modification [5]. Research on biological proteins has effectively contributed to interventions and cancer therapies [6,7]. Given the increasing number of biological ontologies developed on the semantic web, manually finding the cause of errors has becomes a significantly difficult task. Ontology debugging services can find the reason why a certain error occurs by computing the minimal axiom sets (MinAs) related to the error. This helps developers and users of biological ontology to understand the reason why an error follows from the ontology. Therefore, debugging an incoherent ontology is performed to determine the reasons why the classes in the ontology are unsatisfiable. Given the previously mentioned ontology O1, we can deduce that mitochondrioncell (i.e., mitochondrion is a part of a cell) according to α2 and α3. However, mitochondrion is known to not be a part of a cell according to α4. At this point, we can conclude that the definition of mitochondrion yields a logical conflict, as shown in Figure 1. Therefore, mitochondrion is an unsatisfiable class and O1 is an incoherent ontology. The aim of ontology debugging is to find which axioms cause the unsatisfiability of mitochondrion. The result is MinAs(O1, mitochondrion) = {α2,α3,α4}.

    Figure 1.  Illustration show how thedefinition of mitochondrion yields a logical conflict.

    MinAs is a common debugging technique, also known as justifications and minimal unsatisfiability-preserving sub-TBoxes (MUPS). Justification is a minimal set of axioms of an incoherent ontology that can explain an unsatisfiable class. The MUPS refers to the smallest subsets of axioms of an incoherent ontology preserving unsatisfiability of an unsatisfiable class[8]. Two types of methods for computing MinAs (or Justifications and MUPS) are the greasoner-independent-based glass-box methods and the reasoner-dependent black-box methods. The former modifies the internal tableau-based algorithm of the reasoner, thereby making these methods dependent but with a limited portability[9]. By contrast, the latter adopts an "expand-contract" strategy to check which subset of an ontology is a MinAs without modifying the reasoner.

    A significant number of studies have been devoted to the graph-based debugging methods. Reference [10] presents a consequence-based reasoning algorithm based on the notion of a decomposition, i.e., a graph-like structure that can capture the essential features. In Reference [11], the authors construct an explanation dependency graph from the classification result of a reasoner and then compute all justifications thereafter based on the graph. In addition, Reference [12] presents a graph-based method for debugging and revising incoherent DL-Lite ontologies. The authors first encoded DL-Lite ontology into a directed graph and then calculated the minimal incoherence-preserving path-pairs based on the directed graph.

    In recent years, there have been significant research efforts devoted to studying ontology modularization. Modularization is particularly beneficial for ontology reuse [13,14]. It is also used for the subsumption reasoning tasks and incremental classification [15]. A selection function algorithm is given in Reference [16] to compute all justifications. It was further optimized in [17] using the module extraction. The authors of Reference [18] focused on the EL+ ontologies by extracting the reachability-based module. A goal-directed extraction method is given in Reference [19]; it was developed by backward traversing a set of axioms responsible for the given entailment. A decomposition-based extraction algorithm is proposed in Reference [20]. With their algorithm, the computation of {MIS (Minimal incoherent sub-ontology)} can be separately performed in each extracted modules. Moreover, a new strategy based on a local search technique is proposed in Reference[21]; it allows the user to compute the approximating core before extracting the precise minimally unsatisfiable subformulas.

    The authors of Reference [9] constructed unsatisfiable dependent paths to avoid unnecessary non-deterministic expansion. The advantage is that all irrelevant axioms are not in the dependent paths and these axioms are not selected to participate in the computation of MUPS. However, such a method is only fit for an ALC ontology. Thereafter, the method was extended to the work in Reference [22]. The authors first extracted a clash module from the ontology and then identified the root unsatisfiable concepts from the clash module. Thereafter, MUPS of each root unsatisfiable concept can be calculated on the basis of the clash module. However, the real-world ontologies are often dynamic and modified frequently. Thus, logical errors inevitably occur in the dynamic environments. To solve this problem, a heuristic strategy was developed to reuse the previous debugging results for subsequent debugging to avoid recomputing the MUPS [23].

    Seven criteria are proposed in Reference [24] to systematically compare the existing ontology debugging methods; additionally, a set of beneficial suggestions are provided for users to choose an appropriate debugging approach according to their needs. Thereafter, the research was expanded in Reference [25]. The authors evaluated the existing ontology debugging systems based on numerous ontologies with various sizes and expressivities, providing several suggestions thereafter for users or developers to choose an effective debugging algorithm or design an appropriate debugging system. In Reference [26], Ye et al. first created a recursive expansion procedure and then explored the critical axioms one by one. Furthermore, the authors proposed an incremental reasoning procedure to substitute for a series of standard reasoning tests with respect to satisfiability. The authors of Reference [27] computed all MUPSes based on the duality between the MUPS and minimal correctness-preserving subset (MCPS) by applying parallel strategies. The MCPS represents the minimal diagnosis of a concept required to debug unsatisfiable concepts in the ontology debugging domain.

    Other researchers have focused on using the fine-grained approach to resolve unsatisfiable classes. The authors of Reference [3] revised the tableaux algorithm to rewrite logical erroneous axioms and determine the parts of the axioms responsible for errors. A fine-grained method was also developed by modifying one axiom to zero or more axioms [28].

    This section elaborates the syntax and semantics of OWL DL ontologies and presents the formal definitions of debugging incoherent ontologies.

    DL provides a set of so-called constructors, which are used to form complex classes and properties. Table 1 lists the logic constructors and their corresponding syntax and semantics.

    Table 1.  Syntax and semantics of OWL DL ontologies.
    Constructors Syntax Semantics
    top class ΔI
    bottom class
    class name A AI
    negation ¬B ΔIBI
    conjunction CD CIDI
    disjunction CD CIDI
    existential restriction R.C {aΔI|b.(a,b)rIbCI}
    universal restriction R.C {aΔI|b.(a,b)rIbCI}
    at-least restriction nS.C {xΔI|{y:(x,y)SIyCIn}
    at-most restriction nS.C {xΔI|{y:(x,y)SIyCIn}
    property name R RIΔI×ΔI
    inverse property R {(x,y)ΔI×ΔI|(y,x)RI}
    transitivity Trans(R) (x,y),(y,z)RI(x,z)RI
    property inclusion RS RISI
    class inclusion CD CIDI
    class equivalence C D CI=DI

     | Show Table
    DownLoad: CSV

    In Table 1, A and B are atom classes that correspond in first-order logic to unary predicates; C and D are (possibly complex) class expressions that can be recursively constructed based on the atom classes A and B using Boolean operators (,,¬), value restrictions (R.C,R.C) and number restrictions (nS.C,nS.C) for n a non-negative integer.

    Ontology comprises finite axioms with the form of the property transitivity Trans(r), the class inclusion CD, and the property inclusion RS. The equivalent axiom CD is transformed into CD and DC.

    Logic constructors in an ontology determine the expressivity of the ontology. Expressivity ALC consists of the constructors ¬A (negation), CD (conjunction), CD (disjunction), r.C (existential restriction), and r.c (value restriction). Expressivity S consists of ALC and transitivity. Other expressivities are the combinations of ALC, S, and the following expressivity symbols: H (role hierarchies), I (inverse roles), O (nominals), F (functional roles) and D (data type). The DL language considered in our spans ALCH through to SHOIF(D).

    Baader et al. defined an interpretation I in [1] to represent the semantics of OWL DL ontologies. I consists of a non-empty set ΔI (the domain of the interpretation) and an interpretation function, which assigns to every class A a set AIΔI and to every property R a binary relation RIΔI×ΔI. For example, we say that C is subsumed by D, and write CD, if CIDI for all interpretations I.

    The unsatisfiability of a class C indicates that the definition of C in the ontology O is incorrect. By asking a reasoner to check whether or not C is unsatisfiable with regards to O (i.e., it can be expressed as OC), we can determine whether C is unsatisfiable [29].

    Definition 1. (Unsatisfiable class) [30] A class C in an ontology O is unsatisfiable if and only if for each interpretation I of O, CI=.

    Definition 2. (Incoherent ontology) [30] An ontology O is incoherent if and only if there exists at least one unsatisfiable class in O.

    Definition 3. (Inconsistent ontology) [30] An ontology O is inconsistent if and only if it has no interpretation.

    The incoherence can be considered as a kind of the inconsistency in the TBox, i.e., the terminology part of an ontology. An incoherent ontology has an incoherent TBox. However, an ontology being inconsistent does not necessarily imply that it is coherent[30].

    Figure 2 shows four examples of incoherence and inconsistency. The detailed explanations are as follows.

    Figure 2.  Examples of incoherence-and-inconsistency in [30].

    Figure 2(A) shows a coherent but inconsistent ontology because the two disjoint classes C1 and C2 share an individual a.

    Figure 2(B) shows an incoherent but consistent ontology because the two disjoint classes C1 and C2 share a subclass C3.

    Figure 2(C) shows an incoherent and inconsistent ontology because the two disjoint classes C1 and C2 share a subclass C3, which has an individual a.

    Figure 2(D) shows a coherent but inconsistent TBox because the two disjoint classes C1 and C2 share a subclass that is a nominal {a}.

    Given that the TBox reasoning is not influenced by ABox reasoning [3], we assume that an ontology consists of only a TBox in the rest of the study.

    The unsatisfiability of a class can be determined using a DL reasoner, such as Pellet[31], HermiT[32], or FaCT++[33].

    Consider the following inclusion axioms that hold in our example ontology O1:

    α1:B1A1¬A1 (B1 is a part of the conjunction of A1 and the negation of A1)

    α2:B2¬A1 (B2 is a part of the negation of A1)

    α3:CB1B2A1 (C is a part of the conjunction of B1, B2 and A1)

    α4:DCEF (the conjunction of D and C is a part of the disjunction of E and F)

    α5:EA1A2 (E is a part of the conjunction of A1 and A2)

    α6:DCE (D is a part of the disjunction of C and E)

    Definition 4. (MinA) Let O be an incoherent ontology, and C an unsatisfiable class [34]. The set ΣO is a minimal axiom set (MinA) for OC if, and only if, for every ΣΣ, ΣC.

    The three axioms labelled with α1 to α3 entail B1 and C. We can find one MinA for B1: {α1}, and two MinAs for C: {α1,α3} and {α2,α3}. That is, MinAs(O1,B1) = {{α1}} and MinAs(O1,C) = {{α1,α3},{α2,α3}}.

    Table Algorithm 1.  Calculating MinA.
        Input: O, unsatisfiable class C
        Output: MinA(O,C)
        1 Σ:=O
        2 for each axiom αO do
        3  if ΣαC then
        4    Σ:=Σα
        5 return Σ

     | Show Table
    DownLoad: CSV

    Algorithm 1 was introduced in [34] to calculate one MinA of the unsatisfiable C. First, we make a copy of an ontology O as Σ (line 1). Second, for each axiom αO, if the given unsatisfiable class C is unsatisfiable with regards to Σα, then we can conclude that α is not responsible for the unsatisfiability of C. Thus, we remove α from Σ (lines 2–4). After all axioms in O are tested, we can obtain an MinA of C. That is, MinA(O,C) = Σ.

    However, Algorithm 1 can only calculate one MinA. Accordingly, we need to use the classic hitting set tree (HST) method if we want to calculate all MinAs. This process is shown in Figure 3.

    Figure 3.  Process for calculating all MinAs(O1,C) using HST method.

    In Figure 3, the first MinA is computed by Algorithm 1. That is, MinA1 = {B1A1¬A1,CB1B2A1}. Taking the root node, which is labelled with MinA1, the HST was extended to the left hand side by removing B1A1¬A1 from O and computing the second MinA for O{B1A1¬A1}. In this case, MinA2 = {B2¬A1,CB1B2A1} was found. The left hand side successor node of the root node was therefore labelled with MinA2 and its connecting edge labelled with B1A1¬A1. Similarly, the HST was extended to the left hand side by removing B1A1¬A1 and B2¬A1 from O and computing the third MinA for O{B1A1¬A1,B2¬A1}. However, MinA3=.

    The algorithm repeats this process by again removing an axiom, adding a node and executing Algorithm 1 to compute a new MinA. When no more successor nodes can be generated, the HST is complete. At this point, all MinAs occur as labels of nodes in the tree. That is, MinAs(O1,C) = { MinA1, MinA2} = {{B2¬A1,CB1B2A1},{B2¬A1,CB1B2A1}}.

    In general, a module M of an ontology O comprises meaningful fragments of O that have some desirable properties [17]. For example, an incoherent module M for an incoherent ontology O and an unsatisfiable class C is a subset of O that is guaranteed to preserve the unsatisfiability of O.

    Let a signature S of a DL be the union of a set of atomic classes (A,B,...) representing sets of elements and a set of properties (R,S,...) representing binary relations between elements. And let Rol(S) be the set of properties (R,S,...) for a signature S. For the computation of MinAs, we modify the definition of module given in [14] as follows.

    Definition 5. (Incoherent module) Let C be an unsatisfiable class in an ontology O. An incoherent module M for O and C is a subset of O such that MCOC.

    Definition 6. (Syntactic locality) Let S be a signature, R a role, and C a class. Let AS be an atomic class and let RRol(S) be a role. Two sets of classes, namely, CS and CS, are recursively defined by the following rules:

    CS::=(¬C)|(C1C2),

    CS::=A|(¬C)|(CC)|(R.C)|(R.C)|(nR.C)|(nR.C),

    where CCS, C(i)CS,i=1,2.

    An axiom is syntactically local with respect to S if it is of one of the following forms:

    (1) RR, (2) Trans(R), (3) CC, (4) CC.

    An OWL DL ontology O is syntactically local with respect to S if all axioms in O are syntactically local with respect to S.

    Classes in CS become equivalent to the bottom class if A or R not in S is replaced with or . Similarly, Classes in CS become equivalent to the top class under the conditions of this replacement. After these replacements, syntactically local axioms become tautologies.

    Proposition 1 (Testing locality)[35] Let S be a signature, C a class and α an axiom; then the localities of C and α for S can be defined recursively as follows:

    τ(C,S)::= τ(,S) = (a)
    τ(A,S) = if AS and otherwise = A (b)
    τ({a},S) =a (c)
    τ(C1C2,S) =τ(C1,S)τ(C2,S) (d)
    τ(¬C1,S) =¬τ(C1,S) (e)
    τ(R.C1,S) = if Sig(R)S and otherwise = R.τ(C1,S) (f)
    τ(nR.C1,S) = if Sig(R)S and otherwise = nR.τ(C1,S) (g)
    τ(α,S)::= τ(C1C2,S) =(τ(C1,S)τ(C2,S)) (h)
    τ(R1R2,S) = if Sig(R1)S, otherwise
    = R1. if Sig(R2)S, otherwise = (R1R2) (i)
    τ(a:C,S) =a:τ(C,S) (j)
    τ(R(a,b),S) if RS and otherwise =R(a,b) (k)
    τ(Trans(R),S) = if RS and otherwise =Trans(R) (l)
    τ(Funct(R),S) = if Sig(R)S and otherwise =Funct(R) (m)
    τ(O,S)::= αOτ(α,S) (n)

    The following example shown in Figure 4 from [35] will suffice to illustrate the point.

    Figure 4.  Sketch of testing localities for given signatures.

    In Figure 4(1), let O={Genetic_FibrosisFibrosishas_Origin.Genetic_Origin} and S1={Fibrosis,Genetic_Origin}. Firstly, τ(Genetic_Fibrosis,S1)= because Genetic_FibrosisS1 according to the case (b) from Proposition 1. Therefore, the left hand side of the axiom Genetic_FibrosisFibrosishas_Origin.Genetic_Origin is replaced by . That is, Fibrosishas_Origin.Genetic_Origin. Secondly, τ(has_Origin,S1)= because Sig(has_Origin)S1 according to the case (f) from Proposition 1. Therefore, the part has_Origin.Genetic_Origin on the right-hand side of the axiom is replaced by . That is, Fibrosis. We know that Fibrosis is a tautology. Hence O is local with respect to S1.

    In Figure 4(2), let O={Genetic_FibrosisFibrosishas_Origin.Genetic_Origin} and S2={Genetic_Fibrosis,has_Origin}. τ(Fibrosis,S2)= because FibrosisS2 according to the case (b) from Proposition 1. Therefore, the part Fibrosis on the right hand side of the axiom is replaced by . Moreover, τ(Genetic_Origin,S2)= because Genetic_OriginS2 according to the case (b) from Proposition 1. Therefore, the part Genetic_Origin is also replaced by . That is, Genetic_Fibrosishas_Origin.Genetic_Fibrosis. We know that Genetic_Fibrosis is not a tautology. Hence O is not local with respect to S2.

    We modify the algorithm presented in [14] to extract a module related to a signature, and implement the following Algorithm 2 for extracting the module for an unsatisfiable class.

    Table Algorithm 2.  ExtractModule(O, C).
    Input: O:an ontology;
        C:an unsatisfiable class
    Output: MC: C-module of O
    1 MC,OO
    2 while O!= do
    3  α SelectAxiom(O)
    4  if LocalityTest(α, {C}Sig(MC)) then
    5    OO{α}     # α is processed
    6  else
    7    MCMC{α}   # move α into MC
    8    OOMC     # reset O to the complement of MC
    9  end if
    10 end while
    11 return MC

     | Show Table
    DownLoad: CSV

    Given an ontology O and an unsatisfiable class C, Algorithm 2 retrieves a fragment MCO as follows. First, MC is initialized to , and the ontology O is copied to O (line 1). Second, an axiom α is randomly selected from O (line 3). If α is locality with respect to the union of C and the signature of MC, then α is removed from O (lines 4–5). Otherwise, α is added to MC (line 7). Lastly, MC is removed from O and the remaining subset is copied thereafter to O (line 8). These steps are repeated until O=.

    For example, considering the following ontology O2 presented in Reference [14].

    α1 Cystic-Fibrosis Fibrosis located-In.Pancreas has-Origin.Genetic-Origin
    α2 Genetic-Fibrosis Fibrosis has-Origin.Genetic-Origin
    α3 Fibrosis located-In.Pancreas Genetic-Fibrosis
    α4 Genetic-Fibrosis Genetic-Disorder
    α5 DEFBI-Gene Immuno-Protein-Gene associated-With.Cystic-Fibrosis

    The trace of Algorithm 2 for O2={α1,α2,α3,α4,α5} and S = {CysticFibrosis,GeneticDisorder} is described in Table 2.

    Table 2.  Trace of Algorithm 2 for O2 and S.
    MC O2 New elements in S Sig(MC) α loc.?
    1 α1α5 Cystic-Fibrosis, Genetic-Disorder α1 No
    2 α1 α2α5 Fibrosis, located-In, Pancreas, has-Origin, Genetic-Origin α2 No
    3 α1,α2 α3α5 Genetic-Fibrosis α3 No
    4 α1α3 α4,α5 α4 No
    5 α1α4 α5 α5 Yes
    6 α1α4

     | Show Table
    DownLoad: CSV

    Theorem 1 guarantees the correctness of Algorithm 2.

    Theorem 1 (Correctness of Algorithm 2). For any unsatisfiable class C in an ontology O, Algorithm 2 returns a C-module of O.

    Proof. (1) Algorithm 2 terminates {for any input C in O}.

    In every iteration of the while loop, either the size of MC increases, or the size of MC remains the same as the size of O decreases. This means that Algorithm 2 terminates in quadratic time in the number of axioms in O, assuming a constant time locality test.

    (2) The output MC of Algorithm 2 is a locality-based C-module in O.

    Given that α can appear in line 3 of the algorithm, α is local with respect to {C}Sig(MC) if α is neither in MC nor in O'. Moreover, α remains in O(MCO) if {C}Sig(MC) does not change.

    In Reference [36], the authors proposed three heuristic strategies for the unsatisfiability of classes.

    (1) Local unsatisfiability. The combination of direct restrictions and superclasses is unsatisfiable.

    (2) Propagated unsatisfiability. The combination of direct restrictions and superclasses are unsatisfiable except that some classes used in them are unsatisfiable.

    (3) Global unsatisfiability. The domain/range constraints, which along with other information can be used to infer that the class is unsatisfiable.

    On the basis of the above three strategies, Ji proposed a novel debugging algorithm in Reference [37] presenting four types of incoherent patterns as follows.

    (1) Isa-Disjoint pattern: XY,XZ,Y¬Z

    The pattern indicates that the superclasses Y and Z of X are disjointed.

    (2) Exist-Bottom pattern: Xr.Y,Y

    The pattern indicates that the filler Y of existential restriction is a bottom class, that is, the semantic of Y is empty.

    (3) Exist-All pattern: Xr.Y,Xr.Z,Y¬Z

    (4) Exist-Domain pattern: Xr.Y,X¬Z, domain(r.Y=Z)

    Figure 5 shows the incoherent patterns proposed in Reference [37]. Each incoherent pattern can be represented as a directed graph, where the vertex indicates class and the arc from the vertex A to the vertex B indicates a relation, corresponding to a logical axiom, between A and B. For example, <X,r.Y> denotes the arc from X to r.Y and it corresponds to the axiom Xr.Y.

    Figure 5.  Four types of incoherent patterns.

    Patterns provide beneficial information to explain unsatisfiability according to the structure of an ontology. Various patterns are also presented in Reference [38], which lists the following antipatterns.

    (1) AntiPattern AndIsOr (AIO): C1R.(C2C3),Disj(C2,C3).

    (2) AntiPattern OnlynessIsLoneliness (OIL): C1R.C2,C1R.C3,Disj(C2,C3)

    (3) AntiPatterns UniversalExistence (UE): C1R.C2,C1R.C3,Disj(C2,C3)

    (4) AntiPattern UniversalExistenceWithInverseProperty (UEWIP): C2R.C1,C1R.C3,Disj(C2,C3).

    (5) AntiPattern EquivalenceIsDifference (EID) C1C2,Disj(C1,C2).

    Table Algorithm 3.  DOBP(O, C).
      Input: O:ontology; C:an unsatisfiable class
       Output: MinAs of C
      1 CS=
       2 if CCS then
       3  return null
       4 CSCS{C}
       5 MinAs DOBP_IsaDisjoint(O,C)
       6 MinAs MinAs DOBP_ExistBot(O,C)
       7 MinAs MinAs DOBP_ExistAll(O,C)
       8 MinAs MinAs DOBP_ExistDomain(O,C)
       9 return MinAs

     | Show Table
    DownLoad: CSV

    For each pattern, Algorithm 3 first finds the disjoint relations and searches a set of paths thereafter in connection with the relations. For example, finding disjoint relations between A and B involves iterating the ancestors of A and those of B. If one ancestor of A is disjoint with the other ancestor of B, then A is also disjoint with B [37].

    For example, considering the following O3:

    C1R1.(C2R2.C3),

    C3R3.C4R3.C5,

    C5C6,

    C4¬C6.

    In O3, C1 and C3 are unsatisfiable. Now, O3 is normalized as follows:

    C1R1.X,

    XR2.C3,

    XC2,

    C3R3.C4,

    C3R3.C5,

    C5C6,

    C4¬C6.

    Here, X is a new added concept. Then, X is also unsatisfiable because XR2.C3 and C3 is unsatisfiable

    For C1 in O3, the Exist-Bottom pattern shown in Figure 5(b) is detected as C1R1.X. To explain why X is unsatisfiable, DOBP needs to be invoked again. Then the Exist-Bottom pattern is detected again for X because XR2.C3.

    For C3, the Exist-All pattern shown in Figure 5(c) is detected because R3.C4 and R3.C5 share R3 and C4,¬C6 is a disjoint relation. For this relation, we have {C4,C4,C5,C6,C3,C3}. After expanding the pairs, we obtain {{C5,C6}}. Then we have {C3R3.C4R3.C5,C5C6,C4¬C6} that is the MinAs of C3.

    The performance of the DOBP algorithm is significantly affected if the size of the ontology and the number of unsatisfiable classes are large. However, the modularization method can extract a subontology as needed. From this perspective, we combine the modularization method with the DOBP algorithm and propose the Module-DOBP algorithm (see Algorithm 4).

    In lines 3 to 4, the algorithm extracts the module of the unsatisfiable class C by calling the ExtractModule sub-routing (Algorithm 2), and adds the module to the results set M. For each unsatisfiable class C in CS, the algorithm computes the MinAs related to the four patterns based on the extracted module M and C in lines 7 to 10.

    Table Algorithm 4.  Module-DOBP(O).
      Input: O:ontology
       Output: MinAs
      1 CSO,M=
       2 for C in CS
       3  MCExtractModule(O,C)
       4  M=MMC
       5 end for
       6 for C in CS
       7  MinAs DOBP_IsaDisjoint(M,C)
       8  MinAs MinAs DOBP_ExistBot(M,C)
       9  MinAs MinAs DOBP_ExistAll(M,C)
       10  MinAs MinAs DOBP_ExistDomain(M,C)
       11 end for
       12 return MinAs

     | Show Table
    DownLoad: CSV

    Theorem 2. Let M be the incoherent module of an incoherent ontology O. For any unsatisfiable class C, let MinA(O,C) be MinA of O. Thereafter, MinA(M,C) exists such that MinA(M,C) = MinA(O,C), where MinA(M,C) is the MinA of M.

    Proof. We prove on the basis of the expansion-contraction process of Algorithm 1.

    Let O=MN, and MN=. According to Definition 4, we have MCOC.

    1) Expansion process of Algorithm 1.

    Let SO= and SM= be the expansion set of O and M. We obtain SO={α1} after the first axiom α1 is added to SO. We consider two cases:

    (1) α1N. Considering MN=, we have α1M. Then, SM=.

    (2) α1M. Incorporating α1 into M we have SM={α1}. After incorporating k axioms into O we have SO={α1,...,αk}C. Meanwhile, the set of axioms {α1,...,αk} are also incorporated into M, and we have SM={α1,...,αk}. The expansion process ends and we have MCOC, SMSO.

    2) Contraction process of Algorithm 1.

    Given SMSO, we let SO=SMSN, SMSN=. Given SOCSMC we have SNC. Let SO be the set after removing the axiom αx from SO. Two cases exist as follows.

    (1) αxSM. Let SM be the axiom set after removing αx from SM. We consider the following two cases.

    (a) SOC. It indicates that ax is not responsible for the unsatisfiability of C. Thus, SMC.

    (b) SOC. It indicates that ax is responsible for the unsatisfiability of C. Thus, the unsatisfiable C becomes satisfiable. In this case, we must reinsert ax into SO and SM; thereafter, we have SO=SO{ax} and SM=SM{ax}.

    (2) axSN. Given that SMSN=, we have axSM. In such a case, SMC. Considering SPC, we have SMC.

    After all axioms in O are tested by following the preceding steps, we have SO=SM.

    On the basis of the preceding two processes, we have MinA(O,C) = SO and MinA(M,C) = SM. Therefore, MinA(O,C) = MinA(M,C).

    Theorem 2 indicates that for any unsatisfiable class C, we can obtain the incoherent module MC responsible for the unsatisfiability of C such that MinA(O,C) = MinA(M,C).

    Theorem 3 (correctness of Algorithm 4). Let M be the incoherent module of an incoherent ontology O. For any unsatisfiable class C, we have MinAs(M,C) = MinAs(O,C).

    Proof. Let MinAs(O,C) = m1MinA(O,C)i, where m is the number of MinA(O,C). For any MinA(O,C)i MinAs(O,C), according to Theorem 2, MinA(M,C)i exists such that MinA(O,C)i = MinA(M,C)i. Therefore, we have MinAs(M,C) = m1MinA(M,C)i = m1 MinA(O,C)i = MinAs(O,C).

    Experimental evaluations were performed on a laptop with a 1.60 GHz Intel Core i5 CPU and 16 GB of main memory. We conducted all experiments using Pellet 2.3.1* as a reasoner for satisfiability tests and OWL API 3.4.3 for ontology loading and manipulation. The experimental corpus, source codes and experimental results are available at http://www.zhyweb.cn/mradon/index.html.

    *Pellet is available at https://github.com/stardog-union/pellet

    https://sourceforge.net/projects/owlapi/

    The benchmark ontologies used in our experiments were taken from the Open Biological Ontology library (see http://krr-nas.cs.ox.ac.uk/ontologies/lib/OBO/). These ontologies are well-known in the life sciences because they are often used in real-world applications. We collected 15 biological ontologies (see Table 2) as benchmarks for our experimental evaluations. The test ontologies are complex because they use numerous OWL DL constructors and some of them include a large number of axioms. To obtain the incoherent ontologies, we adopted the "incoherent-generating" method given in Reference [12]. For example, if O={AB,AC}, then O is evidently coherent. We applied four classes A,B,CandD. Then we created a pair of complementary classes by randomly selecting two classes. For example, A¬B, A¬C, AC, BC, BD or CD. There were a total of six possibilities. More details can be found in Table 3.

    Table 3.  Characteristics of test ontologies used in experiments.
    ID. Name Exp. C P onto. u.c.
    O1 NIF_Dysfunction SHOIF(D) 2749 60 3511 25
    O2 amphibian_anatomy SH 700 2 708 14
    O3 cell ALCH 814 32 645 13
    O4 cellular_component ALCH 1111 32 761 34
    O5 brenda ALCH 3138 3 3957 11
    O6 Cellular09 SH 2370 4 4552 20
    O7 Cellular12 SR 3121 7 5818 12
    O8 cereal ALCH 869 2 1433 12
    O9 cereal_anatomy SR 1271 4 2281 16
    O10 envo SH 1226 3 1445 18
    O11 envo_xp SH 1779 8 2218 30
    O12 event SH 3829 4 7380 31
    O13 fix ALCH 1163 2 1784 19
    O14 fly SHI 6322 3 11014 12
    O15 fly_anatomy SRI 7798 21 19574 15

     | Show Table
    DownLoad: CSV

    In Table 3, the first two columns indicate the IDs and names of the 15 ontologies. The third column represents the expressivity. The expressivities of the test ontologies ranges from ALCH through to SHOIF(D). The next four columns refer to number of classes (C), number of properties (R), the number of axioms (onto.) and the number of unsatisfiable classes (u.c.), respectively.

    For every incoherent ontology, and for each unsatisfiable class in the signature, we extracted the corresponding incoherent modules using Algorithm 2.

    Table 4 presents the maximum, minimum and average sizes of the modules and the standard deviation. Among the 15 ontologies, O15 had the largest maximum, minimum and average module sizes because O15 had an extremely complex ontology structure with 7798 classes and 19574 axioms. {However, MAX in O3 only contained 6 axioms} because it has a markedly simple with 814 classes and 645 axioms.

    Table 4.  Maximum/minimum/average of modules for unsatisfiable classes.
    ID. O1 O2 O3 O4 O5 O6 O7 O8 O9 O10 O11 O12 O13 O14 O15
    MAX 282 18 6 15 26 151 21 53 60 48 90 42 93 142 585
    MIN 135 14 2 6 24 28 11 30 22 12 21 19 25 138 342
    AVG 271.6 17.6 5.7 11.4 25.8 86.1 16.6 45.2 45.5 29.1 53.2 33.3 53.4 141.2 467.9
    STDEV 28.0 1.1 1.1 1.6 0.6 34.4 3.0 7.2 10.4 9.6 18.6 3.8 22.3 1.3 116.0

     | Show Table
    DownLoad: CSV

    Figure 6 shows the sizes of the modules for each unsatisfiable class in 15 ontologies; the Y-axis represents the unsatisfiable class and the X-axis represents the size of the corresponding module.

    Figure 6.  Sizes of modules for the unsatisfiable classes in the 15 ontologies.

    Apart from PATO_0000930, all module sizes for the 24 unsatisfiable classes were found to be equally likely in O1. The average size was close to the maximum. In O2, the modules were the same size (18), except the two classes AAO_0000679 and AAO_0000199. All but one of the modules had the same size, which also occurred in O3 and O5. In O4, the unsatisfiable class GO-0043623 had the largest module, GO-0065003 had the smallest module and the size for 76% the modules was 12. A total of 10 out of 11 unsatisfiable classes in O5 had the same sized module. The sizes of modules for all unsatisfiable classes in O14 were relatively close to each other.

    The percentages of extracted incoherent modules vs. non-incoherent modules for 15 ontologies are summarized in Figure 7.

    Figure 7.  Percentages of incoherent modules vs. non-incoherent modules for the 15 ontologies.

    For all incoherent ontologies, we obtained extremely small modules. The largest module obtained for O13 was only 15.7%. This result indicates that the dependencies between the different classes are extremely strong, and that structures of the ontology are more complex than other ontologies.

    The following observations were obtained on the basis of the above-mentioned 15 charts:

    (1) The size of the module is smaller than that of the non-module. For example, the percentage of the module in O7 was found to be 0.6%. This means that only 34 axioms out of the 5818 axioms are responsible for the incoherence.

    (2) The percentage of the module in O13 was found to be the highest among all ontologies, although it was below 16%.

    (3) The modules extracted using our Module-DOBP algorithm were found to be significantly smaller than the sizes of the original ontologies. For example, the module M6 obtained was 6/1000 of the size of O6.

    Table 5 shows the comparison results for Module-DOBP and DOBP. M represents the size of the extracted module (i.e., the number of axioms in the module). TM denotes the time required to extract the module. TDOBP displays the time to compute MinAs based on the extracted modules. The Module-DOBP column shows the total time to extract the module and compute the MinAs (i.e., TM + TDOBP). The DOBP column show the time to compute the MinAs based on the original ontology.

    Table 5.  Comparison results for Module-DOBP and DOBP.
    ID. onto. u.c. M TM TDOBP Module-DOBP DOBP MinAs
    O1 3511 25 327 3.995 2.151 6.146 20.579 25
    O2 708 14 40 1.766 0.79 2.556 4.475 14
    O3 645 13 45 2.302 0.607 2.909 1.595 13
    O4 761 34 105 2.486 1.441 3.927 9.042 34
    O5 3957 11 44 3.006 0.505 3.511 2.728 11
    O6 4552 20 210 4.41 7.329 11.739 612.6 119
    O7 5818 12 34 3.112 0.72 3.832 61.969 13
    O8 1433 12 108 2.263 1.182 3.445 9.129 12
    O9 2281 16 150 2.954 2.278 5.232 39.772 22
    O10 1445 18 80 2.186 1.501 3.687 8.656 25
    O11 2218 30 188 2.647 8.11 10.757 239.882 134
    O12 7380 31 163 4.513 2.824 7.337 887.284 62
    O13 1784 19 280 2.6 1.265 3.865 2.768 19
    O14 11014 12 160 5.322 1.306 6.628 67.826 12
    O15 19574 15 660 9.224 3.595 12.819 1803.287 15
    1 onto. denotes the number of axioms in an ontology.
    2 uc. denotes the number of unsatisfiable classes in an ontology.

     | Show Table
    DownLoad: CSV

    For the majority of the ontologies (13/15) in Table 4, the time required to extract modules was below 5 seconds and all 15 ontologies required less than 10 seconds. O15 required the most time to extract the modules because it had the axioms (19574).

    We found that Module-DOBP performed better than DOBP for the majority of cases. Module-DOBP is considerably efficient because it was designed to extract incoherent modules and compute MinAs based on the module. Based on the results for O7,O12,O14 and O15, it turns out that module-extracting optimization is necessary to make our Module-DOBP perform well on large ontologies. For example, the size of O15 was 19574. The runtime of Module-DOBP was 12.819. However, the runtime of DOBP was 140 times longer than that for Module-DOBP. DOBP performed inefficiently because it worked on the entire ontology. Take O15 as an example. Module-DOBP took 12.819 seconds to complete the computation. However, DOBP could not complete the task within 30 minutes. Module-DOBP performed worse for O13 than DOBP. The reason is that in such a case, the additional time to extract the module is relatively large compared with the total time.

    The runtime performance of Module-DOBP was strongly affected by the time consumed by extracting modules. When more time was needed, performance was substantially degraded.

    In this paper, we proposed an optimization method for MinAs computation using the DOBP algorithm. Unlike the DOBP algorithm, our proposed Module-DOBP method first extracts an incoherent-module relevant to the unsatisfiability of the classes, and then implements the DOBP algorithm based on the extracted module. An incoherent-module M for an incoherent ontology O and an unsatisfiable class C is a subset of O that is guaranteed to preserve the unsatisfiability of O. The experimental evaluation showed that the Module-DOBP optimization approach performs better than the DOBP method in most cases. {Regarding future work, we will attempt to present other debugging algorithms using the module-based approach}.

    We would like to thank the anonymous referees for their comments. The research presented in this paper was partially supported by the Key Science and Technology Research of Henan Province, China (Grant No. 222102210232, Grant No. 222102210279, Grant No. 212102210516)

    We declare that we have no financial or personal relationships with other people or organizations that could have inappropriately influenced our work; there is no professional or other personal interest of any nature or kind in any product, service or company that could be construed as having influenced the position presented in, or the review of, the manuscript entitled, "Effective method for detecting error causes from incoherent biological ontologies".



    [1] F. Baader, D. Calvanese, D. McGuinness, D. Nardi, P. F. Patel-Schneider, The Description Logic Handbook: Theory, Implementation, and Applications, Cambridge University Press, 2003.
    [2] I. Horrocks, P. F. Patel-Schneider, F. van Harmelen, From SHIQ and RDF to OWL: The making of a web ontology language, J. Web Semantics, 1 (2003), 7–26. https://doi.org/10.1016/j.websem.2003.07.001 doi: 10.1016/j.websem.2003.07.001
    [3] J. S. C. Lam, D. Sleeman, J. Z. Pan, W. Vasconcelos, A fine-grained approach to resolving unsatisfiable ontologies, J. Data Semantics X, 10 (2008), 62–95. https://doi.org/10.1007/978-3-540-77688-8_3 doi: 10.1007/978-3-540-77688-8_3
    [4] L. Qiu, Y. Liu, Y. Song, B. Zhang, A conflict diagnosis approach of changing sequences in gene ontology evolution, Int. J. Control Autom., 7 (2014), 269–284.
    [5] X. W. Zhao, X. T. Li, Z. Q. Ma, M. H. Yin, Identify DNA-binding proteins with optimal Chou's amino acid composition, Proteins Pept. Lett., 19 (2012), 398–405. https://doi.org/10.2174/092986612799789404 doi: 10.2174/092986612799789404
    [6] J. Zhang, Y. Zhang, Z. Ma, In silico prediction of human secretory proteins in plasma based on discrete firefly optimization and application to Cancer biomarkers identification, Front. Genet., 10 (2019), 542. https://doi.org/10.3389/fgene.2019.00542 doi: 10.3389/fgene.2019.00542
    [7] J. Zhang, H. Chai, G. Yang, Z. Ma, Prediction of bioluminescent proteins by using sequence-derived features and lineage-specific scheme, BMC Bioinf., 18 (2017), 1–13. https://doi.org/10.1186/s12859-017-1709-6 doi: 10.1186/s12859-017-1709-6
    [8] S. Schlobach, Z. Huang, R. Cornet, F. Harmelen, Debugging incoherent terminologies, J. Autom. Reasoning, 39 (2007), 317–349. https://doi.org/10.1007/s10817-007-9076-z doi: 10.1007/s10817-007-9076-z
    [9] Y. Zhang, D. Ouyang, Y. Ye, Glass-box debugging algorithm based on unsatisfiable dependent paths, IEEE Access, 5 (2017), 18725–18736. https://doi.org/10.1109/ACCESS.2017.2753381 doi: 10.1109/ACCESS.2017.2753381
    [10] F. Simančík, B. Motik, I. Horrocks, Consequence-based and fixed-parameter tractable reasoning in description logics, Artif. Intell., 209 (2014), 29–77. https://doi.org/10.1016/j.artint.2014.01.002 doi: 10.1016/j.artint.2014.01.002
    [11] Z. Zhou, G. Qi, B. Suntisrivaraporn, A new method of finding all justifications in OWL 2 EL, in 2013 IEEE/WIC/ACM International Conferences on Web Intelligence, (2013), 213–220. https://doi.org/10.1109/WI-IAT.2013.31
    [12] X. Fu, G. Qi, Y. Zhang, Z. Zhou, Graph-based approaches to debugging and revision of terminologies in DL-Lite, Knowl. Based Syst., 100 (2016), 1–12. https://doi.org/10.1016/j.knosys.2016.01.039 doi: 10.1016/j.knosys.2016.01.039
    [13] B. C. Grau, I. Horrocks, Y. Kazakov, U. Sattler, A logical framework for modularity of ontologies, in Proceedings of the 20th International Joint Conference on Artificial Intelligence, (2007), 298–303.
    [14] B. Grau, I. Horrocks, Y. Kazakov, U. Sattler, Just the right amount: extracting modules from ontologies, in Proceedings of the 16th international conference on World Wide Web, (2007), 717–726. https://doi.org/10.1145/1242572.1242669
    [15] B. Cuenca Grau, C. Halaschek-Wiener, Y. Kazakov, History matters: incremental ontology reasoning using modules, in Proceedings of the 6th International Semantic Web Conference, 2nd Asian Semantic Web Conference, (2007), 183–196. https://doi.org/10.1007/978-3-540-76298-0_14
    [16] A. Kalyanpur, B. Parsia, M. Horridge, E. Sirin, Finding all justifications of OWL DL entailments, in Proceedings of 6th International Semantic Web Conference, ISWC 2007 and 2nd Asian Semantic Web Conference, (2007), 267–280. https://doi.org/10.1007/978-3-540-76298-0_20
    [17] M. Horridge, Justification Based Explanation in Ontologies, Ph.D thesis, University of Manchester in Manchester, 2011.
    [18] B. Suntisrivaraporn, Module Extraction and Incremental Classification: A pragmatic approach for EL+ ontologies, in Proceedings of the 5th European Semantic Web Conference, (2008), 230–244. https://doi.org/10.1007/978-3-540-68234-9_19
    [19] J. Du, G. Qi, Q. Ji, Goal-directed module extraction for explaining OWL DL entailments, in Proceedings of the 8th International Semantic Web Conference, (2009), 163–179. https://doi.org/10.1007/978-3-642-04930-9_11
    [20] J. Du, G. Qi, Decomposition-Based Optimization for Debugging of Inconsistent OWL DL Ontologies, in Proceedings of the 4th International Conference on the Knowledge Science, Engineering and Management, (2010), 88–100. https://doi.org/10.1007/978-3-642-15280-1_11
    [21] M. Gao, Y. Ye, D. Ouyang, B. Wang, Finding justifications by approximating core for large-scale ontologies, in Proceedings of the 28th International Joint Conference on Artificial Intelligence (IJCAI2019), (2019), 6432–6433.
    [22] Y. Zhang, R. Yao, D. Ouyang, J. Gao, F. Liu, Debugging incoherent ontology by extracting a clash module and identifying root unsatisfiable concepts, Knowl. -Based Syst., 223 (2021), 107043. https://doi.org/10.1016/j.knosys.2021.107043 doi: 10.1016/j.knosys.2021.107043
    [23] Y. Zhang, D. Ouyang, Y. Ye, An optimization strategy for debugging incoherent terminologies in dynamic environments, IEEE Access, 5 (2017), 24284–24300. https://doi.org/10.1109/ACCESS.2017.2758521 doi: 10.1109/ACCESS.2017.2758521
    [24] Q. Ji, Z. Gao, Z. Huang, Study of ontology debugging approaches based on the criterion set BLUEI2CI, in Proceedings of the 6th Chinese Semantic Web Symposium and 1st Chinese Web Science Conference, (2013), 251–264. https://doi.org/10.1007/978-1-4614-6880-6_22
    [25] Q. Ji, Z. Gao, Z. Huang, M. Zhu, Measuring effectiveness of ontology debugging systems, Knowl. -Based Syst., 71 (2014), 169–186. https://doi.org/10.1016/j.knosys.2014.07.023 doi: 10.1016/j.knosys.2014.07.023
    [26] Y. Ye, X. Cui, D. Ouyang, Extracting a justification for OWL ontologies by critical axioms, Front. Comput. Sci., 14 (2020), 55–64. https://doi.org/10.1007/s11704-019-7267-5 doi: 10.1007/s11704-019-7267-5
    [27] J. Gao, D. Ouyang, Y. Ye, Exploring duality on ontology debugging, Appl. Intell., 50 (2020), 620–633. https://doi.org/10.1007/s10489-019-01528-y doi: 10.1007/s10489-019-01528-y
    [28] J. Du, G. Qi, X. Fu, A practical fine-grained approach to resolving incoherent OWL 2 DL terminologies, in Proceedings of the 23rd ACM International Conference on Conference on Information and Knowledge Management, (2014), 919–928. https://doi.org/10.1145/2661829.2662046
    [29] D. Fleischhacker, C. Meilicke, J. Völker, M. Niepert, Computing incoherence explanations for learned ontologies, in Proceedings of the 7th International Conference on the Web Reasoning and Rule Systems, (2013), 80–94. https://doi.org/10.1007/978-3-642-39666-3_7
    [30] G. Flouris, Z. Huang, J. Z. Pan, D. Plexousakis, H. Wache, Inconsistencies, negations and changes in ontologies, in Proceedings of the Twenty-First National Conference on Artificial Intelligence and the Eighteenth Innovative Applications of Artificial Intelligence Conference, (2006), 1295–1300.
    [31] E. Sirin, B. Parsia, B. C. Grau, A. Kalyanpur, Y. Katz, Pellet: a practical owl-dl reasoner, J. Web Semantics, 5 (2007), 51–53. https://doi.org/10.1016/j.websem.2007.03.004 doi: 10.1016/j.websem.2007.03.004
    [32] R. Shearer, B. Motik, I. Horrocks, HermiT: a highly-efficient OWL reasoner, in Proceedings of the Fifth OWLED Workshop on OWL: Experiences and Directions, collocated with the 7th International Semantic Web Conference (ISWC-2008), (2008), 1–10.
    [33] D. Tsarkov, I. Horrocks, FaCT++ description logic reasoner: system description, in International joint conference on automated reasoning, (2006), 292–297. https://doi.org/10.1007/11814771_26
    [34] F. Baader, B. Suntisrivaraporn, Debugging SNOMED CT using axiom pinpointing in the description logic EL, in Proceedings of the 3rd International Conference on Knowledge Representation in Medicine, 410 (2008), 1–7.
    [35] B. C. Grau, I. Horrocks, Y. Kazakov, U. Sattler, Modular reuse of ontologies: theory and practice, J. Artif. Intell. Res., 31 (2008), 273–318. https://doi.org/10.1613/jair.2375 doi: 10.1613/jair.2375
    [36] H. Wang, M. Horridge, A. Rector, N. Drummond, J. Seidenberg, Debugging OWL-DL ontologies: a heuristic approach, in Proceedings of the 4th International Semantic Web Conference, (2005), 745–757. https://doi.org/10.1007/11574620_53
    [37] Q. Ji, Z. Gao, Z. Huang, M. Zhu, An efficient approach to debugging ontologies based on patterns, in Proceedings of the Semantic Web-Joint International Semantic Technology Conference, (2011), 425–433. https://doi.org/10.1007/978-3-642-29923-0_33
    [38] Ó. Corcho, C. Roussey, L. M. Vilches-Blázquez, I. Perez, Pattern-based OWL ontology debugging guidelines, in Proceedings of the Workshop on Ontology Patterns (WOP 2009), (2009), 1–15.
  • Reader Comments
  • © 2022 the Author(s), licensee AIMS Press. This is an open access article distributed under the terms of the Creative Commons Attribution License (http://creativecommons.org/licenses/by/4.0)
通讯作者: 陈斌, bchen63@163.com
  • 1. 

    沈阳化工大学材料科学与工程学院 沈阳 110142

  1. 本站搜索
  2. 百度学术搜索
  3. 万方数据库搜索
  4. CNKI搜索

Metrics

Article views(1702) PDF downloads(42) Cited by(0)

Figures and Tables

Figures(7)  /  Tables(9)

/

DownLoad:  Full-Size Img  PowerPoint
Return
Return

Catalog