Impact Propagation and Inconsistency Resolution in a Large Ontology

1. Introduction

An ontology is defined as a formal and specific representation of a shared conceptualization. Ontologies allow for the analysis of knowledge about a domain, making explicit what is implicit and enabling the reuse and sharing of knowledge among individuals or applications. However, it is worth noting that ontologies evolve for several reasons. An ontology may change due to a change in perspective on the domain, evolving knowledge about certain subjects, or changes to the domain itself [2]. According to Klein and Fensel in [3], an ontology evolves due to changes in the domain, the shared conceptualization, or the specification. Such changes can affect the data that conform to the modified ontology, as well as the ontologies and applications that use it. As stated in [4], a simple ontology (defined as one that does not incorporate other ontologies in its definition) maintains consistency and respects its model only if it preserves the constraints defined for its fundamental model. Stojanovic, also in [4], defines the ontology model as an autonomous unit of structured information that can be reused. These constraints include model invariants, which are soft constraints that can be temporarily invalidated, as well as user-defined constraints. Therefore, managing ontology evolution is a research area in which controlling these constraints is paramount. Ontology evolution, as defined in [5], is the adaptation to changes over time and the consistent propagation of these changes to dependent artifacts. It is a response to a modification in the domain’s conceptualization or definition. This response must, as mentioned in [6], (1) explain the changes made to the ontology and ensure that the ontology and all dependent objects are consistent, (2) be supervised, which allows users to more easily process changes, and (3) offer users guidance for continuously improving the ontology.

However, managing changes to an ontology is by no means straightforward. Modifying a single entity can impact other entities and create inconsistencies. This phenomenon becomes even more complex when the ontology contains tens of millions of entities. In this article, we propose an approach to monitor change impact propagation and resolve inconsistencies resulting from changes in large ontologies using a Markov decision process (MDP). This approach first involves partitioning the ontology into communities and then tracking the propagation of change impacts throughout the ontology. For each entity, we determine its vulnerability to a given change. Finally, we use the MDP to resolve the inconsistencies. This process involves determining the gain generated by replacing a deleted node with one of its neighbors.

The rest of the article is organized as follows: Section 2 provides a review of the state-of-the-art approaches to ontology partitioning and inconsistency resolution. In Section 3, our large ontology partitioning algorithm is presented. The next step, which involves calculating the vulnerability rate of the change impacts, is explained in Section 4. In Section 5, we detail the methodology for resolving inconsistencies based on the MDP and finally, in Section 6, we offer a summary and discuss future directions.

2. Related Works

Inconsistency resolution is an area of research that remains largely to be explored. In the literature, this topic is not sufficiently addressed, particularly when it comes to resolving inconsistencies within a large-scale ontology. However, the study in [7] presents a method for detecting and resolving inconsistencies using a specific strategy. Resolution occurs in two steps: first, changes are detected, and then additional changes are generated to guarantee consistency. To resolve logical inconsistencies, the authors determine which axioms to remove to achieve logical consistency with minimal impact. This semi-automatic approach focuses on the OWL Lite language. This approach has limitations, such as the arbitrary definition of consistency conditions. The proposal in [8] introduces an algorithm for resolving inconsistencies in a stratified knowledge base using description logic. It defines a revision operator for both syntax and semantics to mitigate imbalances in the database. Silva and Chiniti propose two approaches in [9]: a syntactic approach (Model-Detect-Repair) and a semantic approach. The semantic approach is based on a formal description of production rules and an inconsistency programming rule that resolves the impacts of ontological changes. Bell, in [10], studies inconsistency resolution approaches and analyzes their usability. The author points out that logical inconsistencies are detected by the DL reasoners RACER and FaCT, but only by providing lists of unsatisfiable classes. In [12], belief revision is employed to address inconsistencies. When a new belief is added, an inconsistency arises between either the new belief or its logical consequences and the original set of beliefs. According to Plessers and De Troyer in [13], an axiom selection algorithm for an inconsistent ontology, along with a set of rules, can enable an ontology engineer to resolve detected inconsistencies. The approach in [14] manages to handle inconsistencies including data redundancy, isolated nodes arising from derived changes, orphaned individuals, and contradictory axioms. Despite these different approaches, inconsistency resolution remains only partially addressed; complex changes are not handled in the same manner as inconsistencies in large ontologies.

Voluminous ontologies have emerged in the fields of medicine and agronomy, including AGROVOC, YAGO, and the Gene Ontology. YAGO (Yet Another Great Ontology), developed at the Max Planck Institute for Informatics in Saarbrücken, is an enormous knowledge base describing more than two million entities, including people, organizations, and cities, and containing more than 20 million facts about these entities. Its data come from Wikipedia and are structured using WordNet. The Gene Ontology project aims to provide a controlled vocabulary applicable to all organisms, creating a knowledge base of genes and protein roles in cells [15]. Initially, the objective was to enable researchers to query related databases and identify associated proteins and genetic products. The ontology contains tens of thousands of concepts. However, maintaining such large ontologies is difficult. If an update occurs on an entity within the ontology, tracking its impact on the entire ontology requires complex techniques. One such technique is to decompose the ontology into communities using partitioning methodologies. Ontology partitioning is the process of grouping ontology entities (concepts, instances, and types) into clusters or communities, where entities within a community share more properties than they do with entities outside it. Originally used for ontology alignment [16], it is now also used in fields such as social networks, biological networks, information networks, and linguistic networks, leading to the development of various tools and methods. The TaxoPart tool thus developed uses a hierarchical classification algorithm [17] that iteratively groups similar concepts into the same block, based on a similarity measure that relies solely on the relative position of the concepts within the ontology. The tool decomposes the first, more structured ontology and forces the second to follow this decomposition. Our context makes this methodology inappropriate because we have only one ontology that needs to be divided. The work in [18] presents two decomposition approaches based on graph partitioning algorithms. The first approach involves finding a minimal dividing line in the graph to create two disjoint subsets. The second approach is inspired by image segmentation methodology, which is a process that involves dividing an image into smaller parts based on color, shape, or texture. In [19], a partitioning method based on the hierarchy of concepts is proposed. The process involves creating a weighted dependency graph from the ontology structure and then identifying the modules using the "Island Line" algorithm [20].

Note that there are different ontology partitioning methods, including graph partitioning and image segmentation:

• Spectral Bisection Method [21]: This method calculates the eigenvector corresponding to the smallest non-zero eigenvalue of the graph’s Laplacian matrix. The graph is split into two parts based on the sign of their components according to this eigenvector.
• Kernighan-Lin Method [22]: This is a bisection algorithm that aims to find the graph cut that minimizes the number of edges falling between the two groups.
• Hierarchical Clustering Methods [23]: Initially, each vertex represents a small community. The process iterates, calculating the distances between communities and merging the two closest communities into a new community.
• G-decomposition [11]: This decomposition is represented by an intersection graph where each vertex constitutes a subgraph and the edges represent the connections of each pair of vertices. The decomposition only considers the axioms of the TBox.
• Minimum Separator Lines [18]: This method finds a connection pair in the graph by calculating the minimum separator, then decomposes the graph along this separator.
• Partitioning Method for Ontology Alignment [16]: This approach is guided by the existence of two ontologies to be aligned.
• Image Segmentation-Inspired Method [24]: This method uses normalized cuts that measure both similarity within a group and dissimilarity between groups.

However, most of these methods produce incomplete partitions (particularly graph theory-based methods), exhibit poor scalability, and entail very high complexity.

3. Ontology Partitioning Methodology

Community detection, also known as partitioning, involves decomposing a set E into subsets E₁, E₂, ..., E_n, where the elements of each subset E_i share more properties within E_i than outside of it. In this section, we detail the methodology for partitioning a large ontology into communities. This approach is inspired by the methodology proposed in [19]. First, a weighted dependency graph [29] is created from the ontology’s structure. Then, the "Island Line" algorithm is used to determine the communities.

3.1. Partitioning Algorithm

The ontology partitioning algorithm starts by dividing the ontological graph into subsets called "islands". Each island is defined by its port, which is the point closest to the island. This step creates a set of islands grouped under a new sub-island name. The second step involves selecting those islands whose number of elements (vertices) falls between the initial minimum and maximum as candidates for partitioning. Islands with fewer vertices than the minimum are removed, and islands with more than the maximum are subdivided into smaller islands and integrated into the set. The third and final step involves taking all candidates as inputs to determine the partitions. The algorithm are outlined in Table 1.

This partitioning makes it easier to track the impact of changes on the ontology. In the following section, we demonstrate how this impact is tracked.

4. Impacts Propagation

In software engineering, the propagation of change impacts describes how a change in one module necessitates a change in other modules. In ontology engineering, this concept describes how changes to an entity or group of entities affect other elements within that ontology. Rajlich [26] models this process as a sequence of snapshots, with each snapshot representing a specific point in time. In this section, we first identify the entities affected by a change and then calculate a change vulnerability rate for each entity in the ontology.

4.1. Marking of Impacted Entities

An ontology is a set of entities consisting of concepts and types that are linked by subsumption, associative, and attribute relations. In terms of computational capacity, an ontology can be either computationally intensive (containing axioms and constraints for inferences) or lightweight (without this capacity). In this article, we consider a lightweight ontology represented by an O structure, defined as follows:

$$O=\{C,R,A,T,CA{R}_R,H^C,H^R,{\sigma }_R,{\sigma }_{CARR},{\sigma }_A\}$$

(1)

with :

• C represents the set of concepts in the ontology;
• A, the set of attributes;
• T, the set of attribute types;
• R ⊆ (C x C) defines the set of associative relations between concepts;
• H^C⊆ (C x C), defining the subsumption relation between two concepts;
• H^R⊆ (R x R) defines the subsumption between two associative relations;
• CAR_R, representing the characteristic of the associative relation R, which can take the value symmetric, transitive, or reflexive;
• $\sigma$_R : R → C x C defines the signature of the associative relation R;
• $\sigma$_CARR : R → CAR_R, the signature of the relation specifying the characteristic of the relation R;
• $\sigma$_A : A → C x T, the signature of the attribute relation between a concept and an attribute.

For each type of relation between two entities E_i and E_j, there is an impact propagation from the changes.

• If C_i and C_j are two concepts linked by a subsumption relation H^C such as H^C(C_i, C_j), then a change in C_j impacts C_i.
• If E_i and E_j are two entities linked by an associative relation $\sigma$_R such as $\sigma$_R(E_i, R_k, E_j), then a change in E_j impacts E_i.
• If E_i is an entity and T_j is a type linked by an attribute relation $\sigma$_A such as $\sigma$_A(E_i, A_k, T_j), then a change in type T_j impacts entity E_i.

Defining the direction of impact flow is crucial for tracking the ripple effects of a change on the ontology. The propagation process involves marking all elements affected by a modification. To this end, we propose an algorithm that marks impacted entities within an ontology partition. This procedure identifies all entities affected by a change operation performed within an ontology community. Our algorithm builds upon existing work addressing change impact propagation in software [26, 27] and ontological change propagation in [28].

4.1.1. Algorithmic Marking Principle

The algorithm for marking entities affected by a modification to the ontology first retrieves the invariant of the operation—which is defined below—if it’s not empty. Then, any unverified assertions of the invariant are marked. Marking an assertion results in marked entities and potentially new assertions that will be added to the invariant. Marking an assertion involves identifying and marking all entities and relations affected by the modification. Marking an entity E_i involves marking E_i and all relations Relation_i belonging to {$\sigma$_R, H^C, $\sigma$_CARR, $\sigma$_A} with E_i as their source. Marking a relation Relation_i involves marking the target entities of that relation, provided they are not already marked.

An operation to modify an ontological entity, also called an ontological change operation, is modeled by a triplet:

$$\Delta =(Operation,Arguments,Assertions)$$

(2)

where:

• Operation represents the modification operation;
• Arguments denotes the arguments of the operation;
• Assertion = (preconditions, invariant, post-conditions) represents the assertions of the operation, which are the preconditions, invariant, and post-conditions, as defined in Table 2 for elementary changes.

4.1.2. Illustration

As shown in Figure 1, removing the Activity concept (in red) from the ontology triggers a process of marking the affected entities. Orange entities represent those affected by the change, and gray entities represent those unaffected.

4.2. Vulnerability Rate

In this section, we propose a method for calculating the propagation rate of changes from one ontological entity to another within the same community. The vulnerability rate represents the risk that an entity (E_i) in each partition will be impacted by a change to an entity (E_j) in the same partition. This rate enables us to identify the entities most susceptible to changes in the ontology. This rate is determined based on the path between the entities. The following Table 3 provides the algorithm that calculates the distance between two entities in an ontology.

The vulnerability rate of changes affecting ontology elements is inversely proportional to the length of the propagation path. In other words, the farther an entity is from the modified entity, the less affected it is by the change. This impact rate defines the distribution of inconsistencies resulting from changes from one node to another within the same community. Thus, it allows us to define the vulnerability of an ontological entity to changes. Let E_i be an entity belonging to community C in ontological graph G = (E, G). The vulnerability rate of E_i in community C, v(E_i), is defined as follows:

$$v\left(E_i\right)=k{\Phi }_i\left(E_i\right){\Sigma }_{Ej\in C}t(E_j,E_i)$$

(3)

with $\Phi$_i(E_i) a function that denotes the existence of a path between E_j and E_i (it is equal to 1 if this path exists, 0 otherwise) and k a normalization constant and t(E_j, E_i) the impact rate of a change in entity E_j on entity E_i. The normalization constant is necessary because we must have the sum of the rates equal to 1.

Example 1:

For the given ontology in Figure 1, the vulnerability rate of the Destination concept within its community for a deletion operation is as follows:

v(Destination) = k(t(Accommodation, Destination) + t(Activity, Destination))

v(Destination) = k(${\displaystyle \frac{I\left(deleteConcept\right(Accommodation\left)\right)}{l(Accommodation,Destination)}}$ + ${\displaystyle \frac{I\left(deleteConcept\right(Activity\left)\right)}{l(Activity,Destination)}}$)

with I(Op) an inconsistency measure of the operation Op. This operation was established in [29]. This vulnerability will be used in the following section for the inconsistency resolution process.

5. Inconsistencies Resolving

In this section, we are interested in the inconsistencies resulting from an operation to delete an entity in the ontology. The inconsistency resolution methodology consists of first calculating, using Markovian decision processes, the gain generated by replacing the deleted node with one of its neighbors in the ontological graph. The greater this gain, the more likely the entity concerned is to replace the deleted node.

5.1. Gain Determination

The Markov decision process (MDP) is a model of dynamic systems that describes sequential decision problems involving probabilistic uncertainty about future system states [30]. The MDP is used to model the interactions between an agent and an observable Markovian environment. The agent takes an action in each state, after which the system transitions to another state and generates a reward for the agent. Formally, an MDP is defined by the 5-tuple:

$$MDP=(S,A,T,R,\gamma )$$

(4)

with:

• S is the set of states;
• A : S → 2 A is the set of actions allowed in each state where A is the set of all actions;
• T : S × A ×S → [0, 1] defines the transition probabilities of the system;
• R : S × A × R → [0, 1] is the probabilistic reward model;
• $\gamma$∈ [0, 1] is the discount rate used to calculate the long-term return.

In our case, S is the ontology, A is the modification operation, and the transition probability P(E_i, Op, E_j) represents the dependence weight of the entity E_j to the entity E_i under the effect of the modification operation Op, as defined in our work in [29]. Therefore, the gain is determined by taking the inverse of the vulnerability rate of the entity impacted by the modification operation, which was calculated in the previous section. The higher the vulnerability rate, the lower the gain, meaning resolution will require more actions.

5.2. Resolution Process

The resolution process involves applying actions, or additional modification operations, to the ontology according to the scenario that arises, while taking the gain into account. In this case, the modification operation is deleting a node in the ontological graph. There are three scenarios:

1.

The node concerned is not linked to any other node. In this case, the vulnerability rate is zero because no entities depend on the deleted entity. Therefore, there are no inconsistencies to resolve.

2.

The node has a single relation in the ontology. In this case, only one entity is affected by node deletion. The vulnerability rate is therefore maximum, which means that it is zero from the impacted entity towards the deleted entity. Therefore, resolving the inconsistency will consist of replacing the deleted entity with the impacted entity.

3.

The node has several relationships. This is the most complex case. Several entities are affected by the deleted node. Resolving the inconsistencies requires going through all the affected nodes and determining the most impacted node with the highest vulnerability rate each time. Then, we will replace the deleted node and calculate the new gains to bring the other nodes up in the ontological tree.

Thus, we have laid the groundwork for an approach to resolve inconsistencies in a large-scale ontology. The implementation of this approach is currently the subject of an ongoing research project we are supervising, which is showing promising results.

6. Conclusions

In this article, we propose an approach to monitor and resolve inconsistencies caused by a change operation in a large ontology. This approach involves first partitioning the ontology into communities. Then, within each community, the propagation of change impacts is followed. We do this monitoring by marking the impacted entities for which we calculate a vulnerability rate for each modification. We then used the Markovian decision process to model our system and resolve the inconsistencies. The resolution involves applying actions, or additional modification operations, to the ontology according to the scenario that arises, while taking the gain into account. In this case, the modification operation involves deleting a node in the ontological graph. However, although our approach provides strong support for impact monitoring, resolving inconsistencies poses certain difficulties. Additional actions may cause impacts that cannot leave the system in an inconsistent state. In our future work, we will incorporate Shannon entropy into the gain calculation to more accurately determine which actions to execute.