Paper deep dive
Syntactic Simplification of OWL Class Expressions
Alkid Baci, N'Dah Jean Kouagou, Caglar Demir, Axel-Cyrille Ngonga Ngomo
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 8/20/2026, 5:16:50 AM
Summary
The paper introduces Class Expression Simplifier (CES), a novel algorithm for the syntactic simplification of OWL class expressions within Description Logics. CES applies a set of theoretically grounded rewriting rules (such as absorption, idempotence, and factorization) to reduce the complexity and verbosity of class expressions generated by Class Expression Learning (CEL) systems like TDL, while preserving formal semantics. Evaluation on the Mutagenesis and Carcinogenesis datasets demonstrates significant reductions in expression length and instance retrieval runtime, improving reasoning efficiency and human readability.
Entities (11)
Relation Signals (10)
CES → implementedin → OWLAPY
confidence 98% · CES is implemented within the open-source Python framework OWLAPY 3 and is publicly available.
CES → evaluatedon → Carcinogenesis
confidence 95% · We evaluate the effectiveness of CES on class expressions learned from two medium-sized ontologies... Mutagenesis and Carcinogenesis
CES → evaluatedon → Mutagenesis
confidence 95% · We evaluate the effectiveness of CES on class expressions learned from two medium-sized ontologies... Mutagenesis and Carcinogenesis
CES → implements → Syntactic Simplification
confidence 95% · CES aims to preserve formal semantics while reducing representational complexity. It systematically applies rewriting rules to eliminate redundancies...
CES → reduces → Expression Length
confidence 93% · We recorded the highest length reduction to be 86% less than the original expression
CES → reduces → Reasoning Runtime
confidence 93% · demonstrating measurable improvements in reasoning efficiency and reductions in verbosity.
CES → usesrule → Idempotence
confidence 92% · Nested n-ary expressions are first flattened... and then the Law of Idempotence is applied to remove repeated operands.
CES → usesrule →
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Class expression learning often produces complex OWL class expressions that are difficult to interpret and reason over. However, by following theoretically grounded simplification principles, this complexity can be reduced. In this paper, we propose Class Expression Simplifier (CES), a novel algorithm for the syntactic simplification of class expressions in Description Logics (DL). CES aims to preserve formal semantics while reducing representational complexity. It systematically applies rewriting rules to eliminate redundancies and identify simpler yet equivalent expressions, thereby producing more compact and human-readable representations without altering logical entailments. We evaluate the effectiveness of CES on class expressions learned from two medium-sized ontologies, demonstrating measurable improvements in reasoning efficiency and reductions in verbosity. This work contributes to the broader goal of making ontology-driven applications more accessible, maintainable, and scalable, with direct implications for knowledge graph construction, semantic search, and Web-scale reasoning. CES is implemented within the open-source Python framework OWLAPY and is publicly available.
Tags
Links
- Source: https://arxiv.org/abs/2608.18899v1
- Canonical: https://arxiv.org/abs/2608.18899v1
Trouble viewing inline? Open PDF directly →
Full Text
26,036 characters extracted from source content.
Expand or collapse full text
KG knowledge graph KGE Knowledge Graph Embedding LLM Pretrained Large Language Model RAG Retrieval-augmented Generation OWL Web Ontology Language DLs Description Logics CEL Class Expression Learning Syntactic Simplification of OWL Class Expressions Alkid Baci N’Dah Jean Kouagou Caglar Demir Axel-Cyrille Ngonga Ngomo Affiliation: Department of Computer Science Affiliation: Paderborn University Affiliation: Warburger Str. 100, 33098 Paderborn, Germany Affiliation: alkid.baci, ndah.jean.kouagou, caglar.demir, axel.ngonga@upb.de Abstract CEL (CEL) often produces complex OWL class expressions that are difficult to interpret and reason over. However, by following theoretically grounded simplification principles, this complexity can be reduced. In this paper, we propose Class Expression Simplifier (CES), a novel algorithm for the syntactic simplification of class expressions in DLs (DLs). CES aims to preserve formal semantics while reducing representational complexity. It systematically applies rewriting rules to eliminate redundancies and identify simpler yet equivalent expressions, thereby producing more compact and human-readable representations without altering logical entailments. We evaluate the effectiveness of CES on class expressions learned from two medium-sized ontologies, demonstrating measurable improvements in reasoning efficiency and reductions in verbosity. This work contributes to the broader goal of making ontology-driven applications more accessible, maintainable, and scalable, with direct implications for knowledge graph construction, semantic search, and Web-scale reasoning. CES is implemented within the open-source Python framework OWLAPY 3 and is publicly available. Keywords Syntactic simplification, OWL class expressions, Description Logics, Rule-based rewriting, Semantic Web 1 Introduction Ontologies expressed in the OWL (OWL) 2 have become a cornerstone for representing structured knowledge on the Semantic Web 4, powering applications ranging from biomedical data integration to knowledge graph construction and Web-scale reasoning 10; 6. At the heart of OWL are class expressions, which allow the specification of rich and precise concepts by combining logical operators and role restrictions. While this expressiveness (e.g. ℛℐ()SROIQ^(D)) is essential for capturing domain semantics, it often leads to complex and verbose expressions 14. Such expressions are not only difficult for ontology engineers to interpret and maintain, but can also introduce inefficiencies in automated reasoning and query answering tasks 14; 8; 12. The problem of complex class expressions manifests in several ways. From a usability perspective, verbose or redundant expressions reduce the readability of ontologies 5, making collaborative development, reuse and verbalization (e.g. via LLMs) challenging. From a computational perspective, the presence of unnecessary syntactic constructs can increase the size of reasoning tasks, negatively affecting the performance of DLs reasoners 8; 9. Simplifying class expressions without altering their semantics is therefore a desirable step to improve both the human- and machine-oriented aspects of ontology use. In Web-scale applications, where ontologies are combined with massive knowledge graphs, even small inefficiencies in reasoning can become prohibitive 18. Existing work has primarily focused on semantic reasoning 1, optimization techniques 1; 13, or ontology modularization 11; 15. By contrast, systematic methods for the syntactic simplification of OWL class expressions remain largely underexplored. While FaCT++ 16 provides basic simplification like for example, transforming expressions into a simplified normal form (SNF), it represents the closest-yet still limited-point of comparison to our approach. Contributions. In this paper, we address the challenge of simplifying OWL class expressions by introducing a syntactic rewriting approach rooted in ℐ()SOIQ^(D) (restricted to transitive roles and excluding all other RBox axioms), as we adhere strictly to syntactic simplification. Specifically, we: (C1) Define a set of DLs-based rewriting rules for syntactic simplification over concepts in ℐ()SOIQ^(D) with restriction to transitive roles. (C2) Propose CES, a rewriting-based algorithm for syntactic simplification of class expressions, following a recursive approach that guarantees termination. (C3) Display the effectiveness of CES in reduction of length and reasoning runtime on 200 class expressions generated for two medium-sized datasets. 2 Background OWL ontologies are grounded in DLs, where complex class expressions are constructed using boolean connectives, quantifiers, and role restrictions. Throughout this paper we use the terms ‘concept’ and ‘class expression’ interchangeably because DLs concepts can be represented in OWL class expressions and vice-versa. In this section, we define the simplification problem and present the simplification principles. 2.1 Description Logics DLs provide the formal foundation of OWL and define concepts using constructors such as conjunction (⊓ ), disjunction (⊔ ), negation (¬ ), existential (∃r.C∃ r.C), and universal (∀r.C∀ r.C) restrictions over roles r. These constructs enable the definition of complex concepts that describe sets of individuals satisfying specific conditions. Formally, each DL expression is interpreted under a model ℐ=(Δℐ,⋅ℐ)I=( ^I,·^I), where Δℐ ^I is the domain and ⋅ℐ·^I an interpretation function mapping concepts and roles to subsets of Δℐ ^I and binary relations, respectively. 2.2 Principles of Syntactic Simplification Towards the goal of syntactic simplification we propose the following principles: • Redundancy Elimination: remove duplicates of subexpressions or order/flatten conjuncts and disjuncts. • Equivalence Preservation: apply algebraic laws/rules to produce shorter but semantically identical expressions. These principles guide the design of our rewriting algorithm, ensuring termination and semantic soundness. Below, we describe some of the most profound rules applied to simplify class expressions under the equivalence preservation principle. Our function processes expressions according to the unique name assumption (UNA). Absorption The absorption law eliminates redundant disjunctive or conjunctive constructs by exploiting logical inclusion. Formally, for any class expressions C and D, the following equivalences hold: C⊔(C⊓D)≡CandC⊓(C⊔D)≡C.C (C D)≡ C C (C D)≡ C. Idempotence The idempotence law ensures that repeated occurrences of the same class expression within a conjunction or disjunction do not increase its meaning: C⊓C≡CandC⊔C≡C.C C≡ C C C≡ C. Identity and Domination The identity and domination laws describe the interaction of class expressions with the universal concept ⊤ and the empty concept ⊥ . The identity law captures neutral behavior while the domination law expresses overriding behavior: C⊓⊤≡C,C⊔⊥≡C,C⊔⊤≡⊤,C⊓⊥≡⊥.C ≡ C, C ≡ C, C ≡ , C ≡ . Law of the Excluded Middle and Law of Non-Contradiction The law of the excluded middle expresses that, for any class expression C, either C or its negation must hold universally whereas the law of non-contradiction states that a class expression and its negation cannot be simultaneously satisfied. Respectively: C⊔¬C≡⊤andC⊓¬C≡⊥.C C≡ C C≡ . Quantifier Distribution Quantifier distribution combines multiple universal or existential restrictions over the same role (r) into a single restriction with a merged filler expression: ∀r.C⊓∀r.D≡∀r.(C⊓D)and∀ r.C ∀ r.D≡∀ r.(C D) ∃r.C⊔∃r.D≡∃r.(C⊔D).∃ r.C ∃ r.D≡∃ r.(C D). Cardinality Restriction Subsumption When multiple cardinality restrictions share the same role and filler, redundant constraints can be eliminated by selecting the less or more restrictive bound, depending on the connective. Formally, for a role r, a class expression C, and integers m,nm,n with m<nm<n: (≥mr.C)⊔(≥nr.C)≡(≥mr.C)and(≥ m\,r.C) (≥ n\,r.C)≡(≥ m\,r.C) (≥mr.C)⊓(≥nr.C)≡(≥nr.C).(≥ m\,r.C) (≥ n\,r.C)≡(≥ n\,r.C). Analogous equivalences are used for upper-bound restrictions (≤) as well as for datatype restrictions. Factorization Factorization exploits distributivity to extract common subexpressions from disjunctions or conjunctions, reducing repetition and structural complexity: (C⊓D)⊔(C⊓E)≡C⊓(D⊔E)and(C D) (C E)≡ C (D E) (C⊔D)⊓(C⊔E)≡C⊔(D⊓E).(C D) (C E)≡ C (D E). Factorization is also applied to negated concepts to factor out the negation in order to reduce the amount of negation constructs used to represent the complex concept. 3 Methodology We define syntactic simplification as a transformation function f on the class expression C such that f(C)f(C) is syntactically simpler than C in terms of length–i.e. OWL constructs required to represent the expression 12, and semantically equivalent, i.e., Cℐ=f(C)ℐC^I=f(C)^I for all interpretations ℐI. When handling complex class expressions, we often encounter combinations of n-ary boolean connectives (i.e., conjunctions and disjunctions of concepts). For brevity, we refer to these simply as n-ary expressions and to the concepts in such expressions as operands. Our simplification algorithm is particularly effective in this setting, since a larger number of simplification rules can typically be applied. In contrast, when expressions lack such connectives, the simplification process is naturally less extensive. The objective of the algorithm is to apply as many rules within a single simplification pass as possible (i.e., one execution of the algorithm on a given class expression). To this end, we implemented a recursive function simplify(c,p) simplify(c,p), where c denotes the current class expression and p denotes its parent n-ary expression. The second parameter is essential for rules that require knowledge of the surrounding context, i.e., the class expression that is one level higher in the recursion. The simplify function is implemented as a single-dispatch function, with different specializations for each type of class expression, which makes recursive traversal both natural and efficient. 3.1 Simplification of N-ary Boolean Expressions For n-ary expressions, simplification proceeds both at the operand level and at the connective level. In Algorithm 1, we show how the simplify function is implemented for ObjectUnionOf. Nested n-ary expressions are first flattened (e.g., (C⊓(D⊓E))→(C⊓D⊓E)(C (D E))→(C D E)) to facilitate rule application, and then the Law of Idempotence is applied to remove repeated operands. During recursion, Absorption Law is applied when common elements exist between an expression and its parent, and duplicates are removed using set-based storage. In case the ⊤ or ⊥ concepts occur in the set of operands we apply the Law of Domination/Identity. The algorithm also applies the Law of the Excluded Middle, removing operands that appear alongside their negations, and handles subsumption checks for cardinality restrictions. Finally, factorization is applied via apply_factorization to reduce structural length. The simplify function for intersection (ObjectIntersectionOf) follows a similar procedure, with slight differences corresponding to the specific rules applicable to conjunctions. Some minor implementation details have been omitted in Algorithm 1 for clarity, but the overall structure ensures a systematic, recursive application of all relevant simplification rules in a single pass. Algorithm 1 Recursive function (c,p) simplify(c,p) for ObjectUnionOf 1: c′←__(c)c ← combine\_nary\_expressions(c) ⊳ Flatten nested unions & apply Idempotence law 2: if c′≠c ≠ c then 3: return (c′,p) simplify(c ,p) 4: Oc←(c)O_c← operands(c) 5: if p≠Nullp then 6: Apply Absorption law: remove common operands with parent p (if any) 7: S←(,Oc,(c))S← map( simplify,O_c, repeat(c)) ⊳ Recursive simplification of operands 8: if |S|=1|S|=1 then 9: return (S) pop(S) 10: if ⊤∈S ∈ S then 11: return ⊤ ⊳ Domination law 12: if ⊥∈S ∈ S then 13: S←S∖⊥S← S \ \ ⊳ Identity law 14: for e∈(S)e∈ copy(S) do 15: if (e,ObjectComplementOf) isinstance(e,ObjectComplementOf) and operand oe∈So_e∈ S then 16: Remove e,oe\e,o_e\ ⊳ Law of the excluded middle 17: if S=∅S= then 18: return ⊤ 19: if |S|=1|S|=1 then 20: return (S) pop(S) 21: c←new ObjectUnionOf(S)c ObjectUnionOf(S) 22: for o∈(c)o∈ operands(c) if o is a cardinality restriction do 23: Merge cardinality restrictions on the same role and filler 24: Update c←new ObjectUnionOf(S)c ObjectUnionOf(S) 25: break 26: if p=Nullp=Null then ⊳ Root expression 27: c←_(c,True)c← apply\_factorization(c,True) 28: return c 3.2 Factorization Factorization is important when it comes to reducing length of the expressions. Throughout the simplification process, intermediate class expressions may remain structurally verbose, even after the application of local rewriting rules and can further benefit from factorization which we apply at the root level of recursive union or intersection simplifications, following the simplification of all operands. We consider this an important step since factorization can substantially reduce the number of OWL constructs required to represent a concept. The high-level pseudocode of the factorization procedure is presented in Algorithm 2. Factorization is implemented recursively via the recursive function apply_factorization(c,first_iteration) apply\_factorization(c,first\_iteration). On the first call from the simplify function, the class expression c is converted into its top-level disjunctive normal form (DNF). This ensures that all disjunctions are explicitly represented at the outermost level, facilitating the identification of redundant or common subexpressions and reducing repeated traversal of nested structures. Furthermore, in DNF, redundant disjuncts are easier to identify because they appear as explicit top-level components rather than being hidden inside nested structures. To handle both unions and intersections uniformly, two dynamic variables, type_a and type_b are assignd the types ObjectUnionOf and ObjectIntersectionOf where type_a is equal to the type of the class expression c and type_b is the remaining one. Operands of c are partitioned into those of type_b Oc,type_bO_c,type\_b, and the rest Oc,type_b¯O_c, type\_b. The Absorption Law is applied when both sets are non-empty. For multiple operands of type type_b, common components are identified pairwise, and local factorization is performed, which is then merged with the remaining operands. Depending on the sizes of the operand sets, the function returns either the locally factorized expression or the combination of factorized and remaining operands. Single operands of type type_b are recursively factorized before being combined with the rest. This recursive design ensures that factorization proceeds from general to specific cases, repeatedly applying simplification until no further factorization is possible. The final result is a structurally compact class expression that preserves the semantics of the original expression. Algorithm 2 Function _(c,first_iteration) apply\_factorization(c,first\_iteration) for n-ary expressions 1: if first_iteration then 2: c←___(c)c← get\_top\_level\_dnf(c) 3: Determine type_a and type_b based on c 4: Oc←(c)O_c← operands(c) 5: Oc,type_b←o∈Oc∣(o,type_b)O_c,type\_b←\o∈ O_c isinstance(o,type\_b)\ 6: Oc,type_b¯←Oc∖Oc,type_bO_c, type\_b← O_c O_c,type\_b 7: if Oc,type_b≠∅O_c,type\_b≠ and Oc,type_b¯≠∅O_c, type\_b≠ then 8: Apply Absorption between sets 9: if |Oc,type_b|≥2|O_c,type\_b|≥ 2 then 10: for each pair in Oc,type_bO_c,type\_b do 11: Identify common operands and perform local factorization 12: Merge factorized results with remaining operands 13: else if |Oc,type_b|=1|O_c,type\_b|=1 then 14: Recursively factorize the single operand and combine with Oc,type_b¯O_c, type\_b 15: return c 4 Evaluation 002020404060608080100100005005001,5001,5002,5002,5003,5003,5004,5004,500Length (construction units)MutagenesisOriginalCES002020404060608080100100CarcinogenesisOriginalCES002020404060608080100100002020404060608080100100CE indexInstance retrieval runtime (s)OriginalCES002020404060608080100100CE indexOriginalCES Figure 1: Length comparison in terms of construct units (top) and instance retrieval runtime comparison in seconds (bottom), between original and simplified class expressions using CES, generated in Mutagenesis (left) and Carcinogenesis (right). Results are sorted in ascending order from left to right over the original measurement. To assess the impact of our syntactic simplification procedure in terms of length reduction and reasoning efficiency, we generated 200 class expressions given random learning problems over two medium-sized datasets, Carcinogenesis and Mutagenesis, from the SML-bench suite 17. Complex and lengthy class expressions are generated with the Tree-based OWL Class Expression Learner (TDL) 7 from the Ontolearn framework 6, which is known to produce significantly more verbose hypotheses compared to other concept learning algorithms on the framework. We refer to the length of a given class expression as the number of the OWL constructs required to represent it. For reasoning efficiency we measure the runtime of instance retrieval using StructuralReasoner - the native reasoner of OWLAPY 3. While each individual rewrite rule used by the algorithm is semantics-preserving, proving correctness for their arbitrary composition would require a global confluence and termination proof, which is outside the scope of this work. Consequently, we evaluate correctness empirically via reasoning-based validation by comparing the sets of instances retrieved for the original and the simplified class expressions and confirming their equivalence. The results of the experiments are shown in Figure 1. We recorded the highest length reduction to be 86% less than the original expression and the highest runtime reduction to be 90% less than the original. For the conducted experiments the average runtime of simplification is 0.11s on Mutagenesis and 0.16s on Carcinogensis with the longest expression of length 4284 taking 1.34 seconds to simplify. Our experiments deliberately focused on the TDL, which is known to produce lengthy and complex class expressions. In this setting, the value of our simplifier is particularly evident. For other learners that may generate more compact hypotheses, the gain in simplification may be less pronounced. Nevertheless, the algorithm consistently provides a non-intrusive “bonus” improvement in complexity reduction and reasoning efficiency, since it does not affect the semantics of the resulting expressions. 5 Discussion and Conclusion In this work, we introduced CES, a syntactic simplification algorithm for OWL class expressions, and showed its effectiveness in reducing verbosity and improving reasoning efficiency. We highlight the fact that the method can be seamlessly integrated into class expression learning systems (e.g. with TDL), serving as a default post-processing step before presenting the final hypothesis. Since the simplifications are purely syntactic and semantics-preserving, the procedure introduces no risk of information loss, while consistently offering potential benefits with minimal time overhead. The simplification time cost becomes even less significant when considering the fact that class expressions can be reused. We also acknowledge certain limitations. First, all tested hypotheses were generated by TDL. Consequently, the reported reduction rates may not be representative of concepts produced by other concept learning systems, particularly those that generate shorter or structurally different expressions. Another limitation of CES is the order of applying specific processes (e.g., factorization, merging of cardinality restrictions). Since the simplification process proceeds in a single pass, the ordering can influence the outcome. Determining an optimal application strategy remains an open question, and exploring multi-pass or rule-prioritization schemes may yield further improvements. Despite these limitations, our results demonstrate that substantial reductions in class expression complexity can be achieved, improving reasoning efficiency and reducing verbosity. As such, CES provides a practical step towards more interpretable and maintainable ontology-based systems. At present, CES operates exclusively at the syntactic level. This design choice avoids the need to rely on a reasoner, making the method broadly applicable and independent of the presence of a background ontology. Looking ahead, an exciting direction for future work is the incorporation of semantic simplifications, which could further reduce complexity and uncover additional equivalences beyond purely syntactic transformations. References [1] S. Abburu (2012) A survey on ontology reasoners and comparison. International Journal of Computer Applications 57 (17), p. 33–39. Cited by: §1. [2] G. Antoniou and F. v. Harmelen (2009) Web ontology language: owl. In Handbook on ontologies, p. 91–110. Cited by: §1. [3] A. Baci, L. Friedrichs, C. Demir, and A. N. Ngomo (2025) OWLAPY: a pythonic framework for owl ontology engineering. External Links: 2511.08232, Link Cited by: §4, Abstract. [4] T. Berners-Lee, J. Hendler, and O. Lassila (2001) The semantic web. Scientific American 284 (5), p. 34–43. Cited by: §1. [5] A. Blumer, A. Ehrenfeucht, D. Haussler, and M. K. Warmuth (1987) Occam’s razor. Information processing letters 24 (6), p. 377–380. Cited by: §1. [6] C. Demir, A. Baci, N. J. Kouagou, L. N. Sieger, S. Heindorf, S. Bin, L. Blübaum, A. Bigerl, and A. N. Ngomo (2025) Ontolearn—a framework for large-scale owl class expression learning in python. Journal of Machine Learning Research 26 (63), p. 1–6. Cited by: §1, §4. [7] C. Demir, M. Yekini, M. Röder, Y. Mahmood, and A. Ngonga Ngomo (2026) Tree-based owl class expression learner over large graphs. In Machine Learning and Knowledge Discovery in Databases. Research Track, Cham, p. 495–511. External Links: ISBN 978-3-032-06066-2 Cited by: §4. [8] Y. Kang, Y. Li, and S. Krishnaswamy (2012) A rigorous characterization of classification performance-a tale of four reasoners. ORE. p. . Cited by: §1, §1. [9] Y. Kang, Y. Li, and S. Krishnaswamy (2012) Predicting reasoning performance using ontology metrics. In International Semantic Web Conference, p. 198–214. Cited by: §1. [10] J. Lamy (2017) Owlready: ontology-oriented programming in python with automatic classification and high level constructs for biomedical ontologies. Artificial intelligence in medicine 80, p. 11–28. Cited by: §1. [11] A. LeClair, A. Marinache, H. El Ghalayini, W. MacCaull, and R. Khedri (2022) A review on ontology modularization techniques-a multi-dimensional perspective. IEEE Transactions on Knowledge and Data Engineering 35 (5), p. 4376–4394. Cited by: §1. [12] J. Lehmann, S. Auer, L. Bühmann, and S. Tramp (2011) Class expression learning for ontology engineering. Journal of Web Semantics 9 (1), p. 71–81. Cited by: §1, §3. [13] A. Letelier, J. Pérez, R. Pichler, and S. Skritek (2013) Static analysis and optimization of semantic web queries. ACM Transactions on Database Systems (TODS) 38 (4), p. 1–45. Cited by: §1. [14] S. F. Pileggi, F. C. Peña, M. D. P. Villamil, and G. Beydoun (2019) Analysing the trade-off between computational performance and representation richness in ontology-based systems. In International Conference on Computational Science, p. 237–250. Cited by: §1. [15] A. L. Rector (2003) Modularisation of domain ontologies implemented in description logics and related formalisms including owl. In Proceedings of the 2nd international conference on Knowledge capture, p. 121–128. Cited by: §1. [16] D. Tsarkov and I. Horrocks (2006) FaCT++ description logic reasoner: system description. In International joint conference on automated reasoning, p. 292–297. Cited by: §1. [17] P. Westphal, L. Bühmann, S. Bin, H. Jabeen, and J. Lehmann (2019) SML-bench–a benchmarking framework for structured machine learning. Semantic Web 10 (2), p. 231–245. Cited by: §4. [18] S. Zghal and M. Kachroudi (2026) The co-evolution of ontologies and extensive knowledge graphs on a web scale. The Journal of Supercomputing 82 (5), p. 264. Cited by: §1.