We deal with repairing inconsistent partially ordered lightweight ontologies in the possibilistic setting. More specifically, we consider the closure-based C -repair method, which yields a more productive partially ordered possibilistic repair and is tractable in DL-Liteℛ. In this work, we refine the characterization of the C -repair method and propose an equivalent algorithm that is more eficient. We illustrate our findings with an experimental analysis. In particular, we highlight the main situations in which the C -repair method achieves the best performance both in terms of productivity and computational cost.
Reasoning with inconsistent lightweight ontologies commonly consists in evaluating queries over the
repairs of the ABox, defined as maximal subsets of the ABox that are consistent with respect to the
TBox. Inconsistency-tolerant semantics are strategies for selecting which repairs to query in order
to derive valid conclusions from an inconsistent ontology. Some of the most prominent semantics
have been implemented in reasoning systems. For example, the CQAPri system (Consistent Query
Answering with Priorities) [
The issue of inconsistency management in DL-Liteℛ has been investigated for both totally ordered
ontologies [
Besides, inconsistency has been considered within the framework of possibility theory. One can cite the method for computing a totally ordered possibilistic repair [9], which infers all the assertions that are strictly more certain than some inconsistency degree of the ABox. The possibilistic repair is tractable in DL-Liteℛ, because its computation can be reduced to checking the consistency of a subset of the ABox. This makes it more eficient than the other repairs that apply to totally ordered ABoxes [ 9].
Furthermore, in the case of partially ordered ontologies, there is the method for computing the partially ordered possibilistic repair ( -repair) [10], and its closure-based counterpart (C -repair) [11], which is more productive. In both methods, the partial order over the ABox is interpreted as a family of total orders which define the compatible totally ordered ABoxes extending the partial order. The -repair is obtained from the intersection of the totally ordered possibilistic repairs of the compatible ABoxes, whereas the C -repair intersects their closure. Note that the -repair is included in the C -repair.
Equivalent characterizations have been proposed for the -repair and the C -repair methods, without exhibiting the all compatible ABoxes, and have been shown to be tractable in DL-Liteℛ. The -repair method is characterized by the notion of -accepted assertion [12], which boils down to checking the consistency of the said assertion together with the subset of all the assertions that are at least equally certain or are incomparable to it. The C -repair method is characterized using the notions of support and dominance [11] against the conflicts of the ABox, which are minimal subsets of the ABox that are inconsistent with respect to the TBox. Basically, a valid conclusion is an assertion that can be derived from consistent minimal subsets of the ABox, called supports, that dominate (i.e., are strictly more certain than) all the conflicts.
In this work, we first implement a naive algorithm for the C -repair method, using the tractable characterization based on the notions of support and dominance. We then provide an improved equivalent algorithm by exploiting the fact that C -repair is composed of the -repair and a complement set. We revise the notion of dominance by exploiting the partial order relation in order to reduce the number of conflicts and supports that need to be processed by the algorithm. Thus, computing C -repair amounts to computing the -repair with the tractable characterization of -accepted assertions, and computing the rest by applying the revised notion of dominance to the remaining assertions. We perform an experimental analysis and confirm that computing the C -repair with the new algorithm benefits from the eficiency of computing the -repair. We highlight the main situations in which the C -repair method achieves the best performance both in terms of productivity and computational cost.
This paper is structured as follows. Section 2 recalls some preliminaries then describes a naive algorithm for the C -repair method. Section 3 studies properties of C -repair which serve to introduce an improved algorithm. Section 4 provides an experimental evaluation of these algorithms. A brief discussion concludes the paper.
DL-Liteℛ Syntax A DL-Liteℛ ontology [13] is a finite knowledge base (KB) = ⟨ , ⟩, built by recursively applying the following grammar:
:= | − := | ¬ := | ∃ := | ¬ where is a concept name, is a role name and − is its inverse. The symbol ¬ designates a complement set and ∃ denotes existential restriction on roles.
The TBox contains axioms of the form ⊑ and ⊑ . The ABox contains assertions of the form () and (, ), where and are individuals. The axioms in may be positive inclusions of the form 1 ⊑ 2 or 1 ⊑ 2 which allow to derive new assertions from . The axioms in may also be negative inclusions of the form 1 ⊑ ¬ 2 or 1 ⊑ ¬ 2 which serve to exhibit the conflicts in . A conflict is a minimal subset of that is inconsistent with respect to , with a size of (at most) two assertions in DL-Liteℛ [14]. Inconsistency refers to the absence of a model for the KB. We omit the semantics of DL-Liteℛ for space considerations.
Partially preordered KB A partial preorder ⊵ over an ABox is a reflexive and transitive binary relation. Let ▷ be the associated strict order. Let ◁▷ denote incomparability, i.e., for and two assertions, ◁▷ means that neither ⊵ nor ⊵ applies. The partially preordered ABox is denoted by ⊵. In the rest of this paper, we deal with an inconsistent partially preordered KB and denote it by = ⟨ , ⊵⟩.
Next, we provide an algorithmic definition for each of the core notions of the C -repair method, namely the deductive closure, the conflict set and the support of an assertion.
The deductive closure of the ABox contains all the assertions that may be inferred from the KB using the positive axioms of the TBox. The individuals included in the closure are limited to those present in the ABox, which makes the closure finite. Algorithm 1 computes the deductive closure of ⊵ by running a set of First Order SQL queries. For each concept or role name in an axiom of the TBox, it creates a conjunctive query (CQ) →(− ) to retrieve the individuals in the corresponding assertion (in line 3). Then, the algorithm reformulates the query into a union of conjunctive queries (UCQ), under classical semantics, to get all the individuals present in any subsume or subrole of the initial concept or role name. Any CQ-rewriting procedure may be used. Here, we use the PerfectRef algorithm [13]. The results of the reformulation are then executed on the ABox (in line 6). This corresponds to computing the set of the answers for each query over ℐ⊵ , which is the interpretation that satisfies exactly the assertions of ⊵.
Input: = ⟨, ⊵⟩: a KB
Output: (⊵) : the deductive closure of ⊵. 1 (⊵) ← ∅ 2 foreach N : a concept name or role name in do 3 →(− ) ← (N) 4 PR ← PerfectRef(, ) 5 foreach →(− ) in PR do 6 foreach→− ∈ ans(,ℐ⊵ ) do 7 (⊵) ← (⊵) ∪ { (N→,− )} 8 return ((⊵)) • : a translation function mapping a concept name with a variable , and a role name with the variables 1, 2 (adapted from [13]). • ans(,ℐ⊵ ): the result of running the query on the interpretation ℐ⊵ . • : a translation function mapping the concept name or the role name with each of the answer→s− (adapted from [13]).
In an inconsistent DL-Liteℛ KB, a conflict is a minimal subset of (at most) two assertions that are contradictory in terms of the axioms [14]. In the following, we assume that a conflict contains exactly two assertions, and denote the conflict set of the ABox ⊵ by Cf(⊵). Algorithm 2 uses query generation and reformulation (similar to the algorithm in [15]) to compute the conflict set. The algorithm creates a conjunctive query (→(− )) for each negative axiom in . Then it performs CQ-rewriting under classical semantics, to get queries for the negative axioms that are not explicitly stated in the TBox. The size of each query at this step is 2. After that, the obtained queries are evaluated over the ABox to get the individuals→(− ) that are present in both assertions of any conflicting concept names or role names.→− are substituted for the variable→s− , and the set of atoms in →(− ) are added to the conflict set.
Input: = ⟨, ⊵⟩: a KB
Output: Cf(⊵) : the conflict set of ⊵ 1 Cf(⊵) ← ∅ 2 ← ∅ 3 foreach : a negative axiom in do 4 ← ∪ {→(− ) ← ( )} 5 PR ← ⋃︀∈ PerfectRef(, ) 6 foreach →(− ) in PR do 7 foreach→− ∈ ans(,ℐ⊵ ) do 8 Cf(⊵) ← Cf(⊵) ∪ {{atoms(→(− ))}} 9 return (Cf(⊵)) • : a translation function from a negative axiom in to a conjunctive query (defined in [13]). • ans(,ℐ⊵ ): the result of running the query on the interpretation ℐ⊵ . • atoms(→(− )): the set of atoms in the query →(− ).
The support of an assertion in an ABox is a minimal consistent subset of the ABox that allows to derive it. In DL-Liteℛ, a support consists of at most a single assertion of the ABox. Algorithm 3 computes the union of boolean queries that represent the instance checking queries of the supports for a given assertion. This is achieved via the reformulation of the instance checking query of the assertion under classical semantics (using the PerfectRef algorithm). The verified instances are added to the set of supports of the assertion.
Input: = ⟨, ⊵⟩: a KB, (), resp. (1, 2): an assertion in (⊵) Output: : the supports of (), resp. (1, 2), in ⊵ 1 ← ∅ 2 →(− ) ← () 3 PR ← PerfectRef(, ) 4 foreach →(− ) in PR do 5 if ans(,ℐ⊵ ) is then 6 ← ∪ {{ atoms(→(− )}} 7 return () /* resp. (1, 2) */
Given the notions of deductive closure, conflict set and support introduced in Algorithms 1 to 3, the C -repair method also relies on the notion of dominance. This notion is a way for extending the partial preorder defined over an ABox into a partial preorder defined over subsets of the ABox ⊵. The dominance is defined as follows.
Definition 1 (Dominance). Let two subsets ℬ1 and ℬ2 of ⊵. We say that ℬ1 dominates ℬ2 if ∀ ∈ ℬ1, ∃ ∈ ℬ2 such that ▷ .
The C -repair method is characterized as the dominance of the supports of an assertion over the conflicts of the ABox. The characterization solely applies when the KB is inconsistent. Otherwise, The C -repair amounts to the deductive closure of the ABox.
Definition 2 (C -repair). A given assertion is in (⊵) if ∀ ∈ Cf(⊵), ∃ℬ ⊆ ⊵ such that ℬ supports (as per Algorithm 3), and ℬ dominates (as per Definition 1).
Note that in DL-Liteℛ, a support (a singleton) dominates a conflict (a pair) means that there is an assertion in the ABox that is strictly more certain than at least one element of the conflict.
Algorithm 4 (given in the next page) is a naive implementation of the C -repair method which applies the characterization given in Definition 2 to each assertion of the closed ABox returned by Algorithm 1. Lemma 1. The algorithm ComputeC -repair (Algorithm 4) runs in polynomial time and space in |⊵| (in data complexity).
The proofs of all propositions and lemmas are provided in the appendix.
In this section, we aim at computing C -repair more eficiently. Thus, we propose to improve Algorithm 4 by exploring two ideas. First, we exhibit additional properties of the dominance relation, in order to reduce the number of the processed conflicts and supports. We do so by focusing on subsets of conflicts and of supports called dominant conflicts and dominant supports. Second, since the C -repair contains the -repair, we start by computing the -repair using its tractable characterization. We then complete the C -repair by applying the revised characterization to the assertions that cannot be inferred from the -repair.
/* exit when a support is found or there are no supports */ /* exit after parsing all the conflicts or there is no support */ /* is supported against each conflict */ Definition 3 (Dominant conflicts) . The set of dominant conflicts, denoted Cf(⊵), is the maximal subset Cf(⊵) ⊆ Cf(⊵) such that ∀ ∈ Cf(⊵), if ∃ ∈ Cf(⊵) such that dominates , then ̸∈ Cf(⊵).
The following proposition states that it is suficient to consider only the dominant conflicts within the conflict set to compute the C -repair. This stems from the fact that the dominance relation is transitive, which follows from the transitivity of the partial preorder relation ⊵.
Proposition 1. A given assertion is in (⊵) if and only if ∀ ∈ Cf(⊵), ∃ℬ ⊆ ⊵ such that ℬ supports and ℬ dominates .
Definition 4 (Dominant supports). Let ( ) be the set of supports of an assertion in ⊵. The set of dominant supports of , denoted ( ), is the maximal subset ( ) ⊆ ( ) such that ∀ℬ ∈ ( ), if ∃ℬ ∈ ( ) such that ℬ dominates ℬ, then ℬ ̸∈ ( ).
The following proposition states that it is suficient to consider only the set of dominant supports of any given assertion in order to check its membership in C -repair. This result also follows from the transitivity of the partial preorder relation ⊵.
Proposition 2. Let be an assertion and let ( ) be its set of supports in ⊵. is in (⊵) if and only if ∀ ∈ Cf(⊵), ∃ℬ ∈ ( ) such that ℬ dominates .
Proposition 2 entails that Algorithm 4 can actually consider (strict) subsets of the conflicts and the supports. This has the potential for considerably reducing the number of elements over which the algorithm iterates to check membership of an assertion in the C -repair.
We exploit two key properties of the C -repair [11] to improve Algorithm 4. First, the C -repair (strictly) contains all the assertions of the -repair [12], which is characterized as follows. Definition 5 ( -repair). Let ∈ ⊵ and Δ( ) = ⊵ ∖ { | ∈ ⊵ such that ▷ } be the set of assertions that are at least equally certain or incomparable to . Then ∈ (⊵) if ⟨ , { } ∪ Δ( )⟩ is consistent.
We conclude that Algorithm 4 does not need to consider all the assertions of the deductively closed ABox in order to compute the C -repair. Instead, an improved version of the algorithm first computes the -repair 1, before iterating over the remaining assertions of the closed ABox.
Moreover, we explore a second property of the C -repair in order to reduce the number of remaining assertions that need to be checked by the algorithm. This relates to the set diference between the C -repair and the deductive closure of the -repair. In essence, if an assertion is neither accepted in the -repair nor its closure, it must have strictly more than one support to be in the C -repair. This is formalized in the following lemma.
Lemma 2. Let be an assertion in (⊵). Let ( ) be the set of supports of . If |( )| = 1, then ∈ ( (⊵)).
The converse of Lemma 2 does not hold, a non-accepted assertion may have multiple supports.
Algorithm 5 (given in the next page) constitutes an improved version of Algorithm 4. It begins by computing the closed ABox followed by the set of dominant conflicts. If the KB is consistent, the closed ABox is returned. Otherwise, the algorithm computes the assertions of the -repair and inserts them in the C -repair. Next, it iterates over the assertions of the closed ABox minus the -repair, and for each such assertion, it computes its set of dominant supports. If one of the supports is in the -repair, the assertion is added to the C -repair. This step retrieves the assertions that are in the closure of the -repair. Otherwise, the algorithm checks whether the assertion has more than one support. If it does, then for each conflict, the algorithm checks whether the assertion has a support dominating the conflict (like in Algorithm 4).
Lemma 3. The algorithm ComputeC -repair (Algorithm 5) runs in polynomial time and space in |⊵| (in data complexity).
We implemented all the algorithms of this paper in Python. Our system relies on the RDFLib library [16] to read the ontology, a SQLite3 relational DBMS [17] to store the ABox, and the Rapid query rewriting engine [18] to reformulate queries. Our system is publicly available at: https://github.com/ahmedlaouar/ py_reasoner. We performed the experiments on an Intel 3.60GHz CPU with 32 GB RAM under Ubuntu, and provided instructions for reproducing them. Let us first discuss how to elicit partial orders to obtain a partially ordered KB.
One way for implementing a partially ordered KB is to assign partially ordered priority degrees to the assertions of the ABox [10]. These degrees can be represented graphically using Hasse diagrams or directed acyclic graphs (DAGs). We opt for transitive DAGs [19], which explicitly represent arcs within the graph. In a transitive DAG, nodes represent the degrees of a partially ordered set (POS), an arc indicates the strict preference of a degree over the other, and the absence of an arc expresses incompatibility of two degrees. A set of random DAGs was generated using the R package bnlearn [20], based on diferent numbers of nodes ( {50, 100, 500, 1000, 2500}) and diferent probabilities for the 1A suggested algorithm for computing the -repair is given in the appendix. presence of arcs (0.1, . . . , 0.9). A probability indicates the density of the DAG, hence a less dense DAG has more occurrences of incomparability.
We used an OWL ontology as the TBox. We opted for the DL-Liteℛ version of the modified LUBM benchmark (LUBM2∃0) [21] (available at https://home.uni-leipzig.de/clu/). Since this version does not contain negative axioms, we added a set of negative axioms to the TBox in order to create conflicts. Next, we used the Extended University Data Generator (EUDG) [21] to generate three ABoxes of diferent sizes, and transformed each ABox into a SQLite database. Then, we introduced inconsistency by adding contradictory assertions in each ABox as follows. For each negative axiom inferred from the TBox, we contradict the presence of an individual in a concept assertion (resp. role assertion) with probability (resp. 2 ). We used diferent values of in order to create five diferent situations within each ABox in terms of inconsistency, which is measured with by the number of conflicts. For each execution of the algorithms, degrees from a previously generated DAG are randomly assigned to the assertions of each ABox. We refer to the -repair (Definition 5) and Algorithms 4 and 5 by , and ++, respectively. We consider three diferent cases for the evaluation: Case 1: We analyse both the performance of the algorithms as a function of the size of the ABox and the impact of the number of conflicts on the size of the repairs and the running time (for computing the repairs). The results are presented in Table 1 and Figure 1.
Case 2: We consider diferent configurations for the associated DAG (POS). We analyze the impact of changing the size and density of the DAG. This allows us to measure the diference (⊵) ∖ ( (⊵)). We point out the main situations where the C -repair is more productive than the -repair. The results are depicted in Figure 2 [left].
Case 3: We use ABox u.5 to compare the proportion of time spent in each step of Algorithms 4 and 5.
For each ABox by number of conflicts, we computed the median time from diferent executions.
The results are presented in Figure 2 [middle] and [right].
Impact of the number of conflicts (Case 1) First, we compare the running time of Algorithms 4 and 5 ( and ++) to compute the C -repair, and can see that the improved method largely outruns the naive method. Mainly, in situations of weakly conflicting ABoxes, which correspond to ABoxes with (111, 387) conflicts for u.5, (753, 3049) conflicts for u1 and (4505, 8327) for u5. For these ABoxes, the improved method reduces the running time to a mere 25% of the naive method’s. This can be observed in Figure 1 [left], with (753, 3049) conflicts. This also holds for large sized ABoxes, as ABox u5 in Table 1. Moreover, for highly conflicting ABoxes, the improved method takes at most half of the time taken by the naive one. In these ABoxes, the -repair becomes smaller and more assertions must be checked using the C -repair characterization. We can observe in Figure 1 [left] that the -repair is computed in a stable time. This is because it runs a constant time verification step for each ABox assertion.
Regarding the size of the obtained repairs, we observe that a large subset of assertions is discarded
when the number of conflicts exceeds 10% of the size of the ABox (1268 for ABox u.5, 10388 for
ABox u1 and 57054 for ABox u5). This is confirmed by Figure 1 [right]. This outcome is expected.
Moreover, it is true even for the IAR semantics, which is considered by nature to be more productive
than possibilistic repairs (for more details on IAR, see [
Impact of the used partial order (Case 2) In order to point out the main situations where the C -repair is more productive than the -repair, we illustrate the size of the -repair ( ), the closure of the -repair (( )) and the additional assertions that are only in the C -repair (only ), as a function of the density of the used POS. Figure 2 [left] depicts the results of these executions. Note that in this case, we used ABox u1 with 753, 3049 and 10388 conflicts. The evaluation of the density shows that lower probabilities, which indicate a higher presence of incomparabilities, lead to a more productive C -repair. When the probability of having a strict preference between two degrees in the POS is lower than 0.5, the C -repair is larger than the -repair. Conversely, POSs with higher probabilities corresponds to a decreased likelihood of C -repair being more productive than the -repair, such partial orders approximate a total order. This result illustrates Lemma 2, with more incomparabilities, there is a higher chance for an assertion to have diferent supports dominating diferent conflicts. This is the case for the assertions that are only in the C -repair.
We can also observe that, for POSs with many incomparabilities, the C -repair returns more answers when the -repair is empty. This can be observed in Figure 2 [left], with the densities 0.1 and 0.3. Furthermore, we concluded, trough multiple executions with diferent POS densities, that the C -repair returns an important number of assertions in 80% of the cases where the -repair contains less than 10% of the ABox assertions. In addition, for weakly conflicting ABoxes, the C -repair provided additional assertions in 10% of the times. This percentage falls under 5% for the highly conflicting ABoxes. Proportion of time spent by Algorithms 4 and 5 (Case 3) Figure 2 ([middle] and [right]) illustrates the running time taken by each step of Algorithms 4 and 5. For both algorithms, the computation of the ABox closure is achieved in constant time. The time taken to compute the set of conflicts increases slightly as their number increases. This also results in an increase in total time, as there are more conflicts to go through. In the improved method (Figure 2 [right]), computing the -repair is run in constant time with respect to the changing number of conflicts, whereas computing its closure is more time-consuming in weakly conflicting ABoxes. Computing the supports involves processing each assertion in the ABox closure through multiple SQL queries to retrieve them. Although significantly faster in the improved algorithm, as shown in the results of Table 1, supports computation is the most time-intensive step of the process.
In this paper, we conducted an experimental study of data repair methods for partially ordered possibilistic knowledge bases, including three principal phases. Initially, it involved developing suitable algorithms for the computation of repairs. Subsequently, we delved into examining the inherent properties of the repair strategies and the algorithms’ to enhance their eficiency. Finally, we tested the algorithms across various scenarios to evaluate their performance. We provided an algorithmic investigation, complemented by experimental analysis of the closure-based partially ordered possibilistic repair. Starting with the repair’s characterization, we showed that leveraging certain properties allows for a more eficient repair process. Our experiments, conducted across diverse ABoxes, featuring a varying number of conflicts and configuration of partial orders, led to the insight that the C -repair is particularly beneficial in cases where the partial order defined over the ABox incorporates numerous incomparabilities and its subset, the -repair, includes fewer assertions. Furthermore, the algorithms we developed are capable of batch processing, enabling an incremental computation of repairs for larger ABoxes. Future work involves checking whether polynomial time complexity holds also in combined complexity.
Acknowledgments: This research was supported by the European Union’s Horizon research and innovation program under the MSCA-SE (Marie Skłodowska-Curie Actions Staf Exchange) [grant agreement 101086252]; Call: HORIZON-MSCA-2021-SE-01; Project title: STARWARS (STormwAteR and WastewAteR networkS heterogeneous data AI-driven management).
Ahmed Laouar’s PhD is supported by the French national project ANR (Agence Nationale de la Recherche) Vivah (Vers une intelligence artificielle à visage humain) [grant number ANR-20-THIA-0004]. This research has also received support from the two French national ANR (Agence Nationale de la Recherche) projects EXPIDA (EXplainable and parsimonious Preference models to get the most out of Inconsistent DAtabases) [grant number ANR-22-CE23-0017] and AGGREEY (Une plate-forme basée sur l’argumentation pour la démocratie participative) [ANR-22-CE23-0005].
The authors would like to thank the reviewers for their useful comments. [7] S. Staworko, J. Chomicki, J. Marcinkowski, Prioritized repairing and consistent query answering in relational databases, AMAI 64 (2012) 209–246. [8] M. Bienvenu, C. Bourgaux, Querying and repairing inconsistent prioritized knowledge bases: Complexity analysis and links with abstract argumentation, in: Principles of Knowledge Representation and Reasoning (KR), Virtual Event, 2020, pp. 141–151. [9] A. Telli, S. Benferhat, M. Bourahla, Z. Bouraoui, K. Tabia, Polynomial algorithms for computing a single preferred assertional-based repair, KI-Künstliche Intelligenz 31 (2017) 15–30. [10] S. Belabbes, S. Benferhat, Computing a possibility theory repair for partially preordered inconsistent ontologies, IEEE Transactions on Fuzzy Systems (2021) 1–10. [11] A. Laouar, S. Belabbes, S. Benferhat, Tractable closure-based possibilistic repair for partially ordered dl-lite ontologies, in: European Conference on Logics in Artificial Intelligence, Springer, 2023, pp. 353–368. [12] S. Belabbes, S. Benferhat, Characterizing the possibilistic repair for inconsistent partially ordered assertions, in: Information Processing and Management of Uncertainty in Knowledge-Based Systems - 19th International Conference, IPMU 2022, Milan, Italy, Proceedings, Part II, volume 1602, 2022, pp. 652–666. [13] D. Calvanese, G. De Giacomo, D. Lembo, M. Lenzerini, R. Rosati, Tractable reasoning and eficient query answering in description logics: The DL-Lite family, Journal of Automated Reasoning 39 (2007) 385–429. [14] D. Calvanese, E. Kharlamov, W. Nutt, D. Zheleznyakov, Evolution of DL-Lite knowledge bases, in:
International Semantic Web Conference (1), Shanghai, China, 2010, pp. 112–128. [15] M. Bienvenu, C. Bourgaux, F. Goasdoué, Computing and explaining query answers over inconsistent dl-lite knowledge bases, Journal of Artificial Intelligence Research 64 (2019) 563–644. [16] D. Krech, G. A. Grimnes, G. Higgins, J. Hees, I. Aucamp, N. Lindström, N. Arndt, A. Sommer, E. Chuc, I. Herman, A. Nelson, J. McCusker, T. Gillespie, T. Kluyver, F. Ludwig, P.-A. Champin, M. Watts, U. Holzer, E. Summers, W. Morriss, D. Winston, D. Perttula, F. Kovacevic, R. Chateauneu, H. Solbrig, B. Cogrel, V. Stuart, Rdflib, 2023. URL: https://zenodo.org/record/6845245. [17] R. D. Hipp, SQLite, 2020. URL: https://www.sqlite.org/index.html. [18] A. Chortaras, D. Trivela, G. Stamou, Optimized query rewriting for owl 2 ql, in: Automated Deduction–CADE-23: 23rd International Conference on Automated Deduction, Wrocław, Poland, July 31-August 5, 2011. Proceedings 23, Springer, 2011, pp. 192–206. [19] G. Gutin, Acyclic digraphs, Classes of Directed Graphs (2018) 125–172. [20] M. Scutari, Learning bayesian networks with the bnlearn r package, arXiv preprint arXiv:0908.3817 (2009). [21] C. Lutz, I. Seylan, D. Toman, F. Wolter, The combined approach to OBDA: taming role hierarchies using filters, in: The Semantic Web - ISWC 2013 - 12th International Semantic Web Conference, Sydney, Australia, 2013, pp. 314–330.