Introduction

It is generally understood that complementing the factual (assertional) knowledge represented in Knowledge Graphs with ontological (terminological) information greatly advances the usefulness of the ensuing knowledge base in terms of querying and many other downstream tasks. This is because combining assertional information with terminological background knowledge allows for the derivation of a vast amount of implicit knowledge, which is not explicitly stated in the knowledge base but follows logically from it and thus can be taken into account for all kinds of knowledge management activities, including query answering.

The by far most widespread type of ontological information added to knowledge graphs is taxonomic in nature, that is, it is related to (i) putting the individual objects of interest into categories, usually referred to as classes, based on shared characteristics and (ii) establishing set-theoretic relationships between these classes. Among the diverse possible such taxonomic relationships, the subclass/superclass relationships -tightly connected to the linguistic hyponymy/hypernymy relationships of the corresponding class names -are the ones predominantly found across numerous ontologies today, typically forming sizeable conceptual hierarchies. As an example, the subclass/superclass relationship between the classes Mammal and Vertebrate implies that any object that belongs to (or, in more technical terms: is an instance of) the class Mammal also must belong to the class Vertebrate.

Another well-known basic type of taxonomic relationship between two classes is that of disjointness. Two classes are said to be disjoint if it is impossible that they have common instances, which, intuitively, means that the two classes cannot overlap, and membership in these two classes is mutually exclusive. For example, disjointness of the classes Mammal and Fish implies that any instance of Mammal must not be an instance of Fish. Given the symmetric nature of disjointness, this is logically equivalent to saying that any instance of Fish must not be an instance of Mammal. As opposed to subclass statements, which allow for inferring positive facts from other positive facts, disjointness statements enable the inference of negated facts. For example, given the fact that Flipper is an instance of Mammal, the above subclass relationship gives rise to the information that Flipper is an instance of Vertebrate, whereas the disjointness statement allows us to infer the information that Flipper must not be an instance of Fish. This fact makes disjointness information particularly valuable in the context of machine-learning approaches that rely on the presence of negative examples, such as Knowledge Graph Embedding.

When specifying taxonomic relationships between classes in the course of the ontology design process, it should be kept in mind that they are not meant to reflect spurious relationships in the data currently available, but rather they are supposed to represent immutable background knowledge that continues to hold in different situations or at different points in time. For instance, although historically, no woman has served as US President, a woman may be elected as the US President in the future. Therefore, the corresponding classes Woman and USPresident are not (ontologically) disjoint. 1 To reflect this situation more formally, one can employ the idea of possible or conceivable worlds (referred to as interpretations in model-theoretic terms), which e.g., include potential future or just hypothetical circumstances. Then, a certain taxonomic relationship (such as subclass or disjointness) between two classes holds if the corresponding set relation (such as subset or intersection-emptiness) holds between the sets of class instances in every conceivable world (under every conceivable interpretation). Based on this, we will employ a very lightweight logical framework to give our arguments a formal underpinning: Stipulating a set I of conceivable worlds, we define taxonomic relationships for this set. The goal of ontological knowledge modeling is to capture I using a knowledge base 𝒦 whose statements rule out the inconceivable worlds so that only the conceivable ones remain as models of 𝒦. Let I be a set of interpretations, representing the conceivable worlds. Then, for an individual name i ∈ I and for concept names C, D ∈ C we call

• i an instance of C (written i : C) if every interpretation ℐ ∈ I satisfies i ℐ ∈ C ℐ , • C a subclass of D (written C ⊑ D) if every interpretation ℐ ∈ I satisfies C ℐ ⊆ D ℐ , • C disjoint with D if every interpretation ℐ ∈ I satisfies C ℐ ∩ D ℐ = ∅. • C incoherent if every interpretation ℐ ∈ I satisfies C ℐ = ∅.

As discussed above, ontologically dictated taxonomic relationships can be leveraged for sophisticated reasoning and consistency-checking tasks when reasoning over a knowledge graph. Yet, despite their usefulness, disjointness relationships are rarely explicitly recorded within an ontology. Research on 1,275 ontologies showed that only 97 of them include disjointness assertions [1]. Arguably, this can be explained by the fact that disjointness information is so self-evident from a human common-sense point of view, that human experts are often not aware that it is not logically "built-in" but needs to be explicitly specified. For this reason, semi-automated labeling of disjoint classes could be advantageous. Recent approaches [2,3,4] propose supervised and unsupervised models using various features in disjointness axioms. However, the generalizability of these methods is limited to their specific datasets and cannot be implemented on a large scale. Additionally, the sophisticated feature engineering required hinders their practical application. Therefore, a method that functions independently of feature design and dataset restrictions is highly desirable.

Given that (i) ontological class descriptions are often recorded as (or associated with) terms in natural language and (ii) LLMs have been found to possess wide linguistic and semantic working knowledge, we aim to assess the potential of LLMs to decide on the question which classes ought to be disjoint while assessing the impact of prompt engineering on classification validity. We hypothesize that through the use of prompt engineering, LLMs are to classify ontologically disjoint classes with high validity in both positive (two classes are ontologically disjoint), and negative (two classes are not ontologically disjoint), cases. We test our hypothesis on the DBpedia ontology2 using LLMs. We propose a method that intertwines the LLMbased disjointness classification with basic logical inferencing to increase efficiency, maintain consistency, and minimize the number of calls to the LLM.

Thus, this paper is dedicated to answering the following main research questions:

RQ1: Can LLMs help enrich ontologies with class disjointness axioms? RQ2: Which LLM prompts work better for disjointness discovery? RQ3: How can we exploit taxonomic relationships to reduce interaction with the LLM?

Related Work

Disjointness Learning Models for disjointness learning can be categorized into supervised and unsupervised approaches. In the unsupervised category, Schlobach [5] follows the strong disjointness assumption [6], which posits that children of a common parent in the subsumption hierarchy should be considered disjoint. They introduced a pinpointing algorithm to identify minimal sets of axioms that need revision to make an ontology coherent, thereby enriching appropriate disjointness statements. However, this approach neglects background knowledge, which could be beneficial in identifying disjoint classes. Rizzo et al. [4] proposes an unsupervised approach based on concept learning and inductive classification. This method employs a hierarchical conceptual clustering technique capable of providing intensional cluster descriptions and utilizes a novel form of semi-distances over individuals in an ontological knowledge base, incorporating available background knowledge. In the supervised category, Völker et al. [2,3] gather syntactic and semantic evidence, such as positive and negative association rules as well as correlation coefficients, from various sources to establish a strong foundation for learning disjointness. However, their work exploits background knowledge and reasoning only to a limited extent. Subsequent work, the DL-Learner by Lehmann [7], uses Inductive Logic Programming (ILP) for learning class descriptions, including disjointness. Despite these advancements, disjointness learning with LLMs remains much underexplored.

Large Language Models

In recent years, Large Language Models (LLMs) have become state-of-the-art for Natural Language Processing and have also significantly impacted other fields such as knowledge engineering [8,9,10,11]. LLMs rely on pre-training Transformer models [12] over large-scale unlabeled corpora. Pre-trained context-aware word representations achieve state-of-the-art performance on various downstream tasks and set the "pre-training and fine-tuning" learning paradigm. Early LLMs, such as BERT [13], utilized relatively small training corpora and required fine-tuning for specific downstream tasks. However, subsequent research demonstrated that scaling up both model size and dataset volume significantly enhances performance. GPT-3 [14], for instance, achieves competitive results through few-shot learning and in-context learning without parameter updates. GPT-3.5 further improves capabilities by incorporating reinforcement learning from human feedback (RLHF). The introduction of GPT-4 [15] marked a milestone by extending beyond text input to include multimodal signals. Meta AI introduced the collection of LLaMA models [16,17] with four different sizes. Other notable LLMs, such as Claude, Gemini [18], and Mixtral [19], have also garnered significant attention.

Prompt Engineering Designing effective prompts for LLMs is essential for maximizing their potential. Key strategies in prompt engineering include zero-shot [20], few-shot [14], and chainof-thought [21] prompting. Zero-shot [20] involves providing task descriptions to LLMs without any input-output examples, relying on the models' pre-existing knowledge to generate responses. Few-shot [14] includes input-output examples, guiding the models' generation process. Chainof-Thought (CoT) [22] promotes coherent and step-by-step reasoning by decomposing a complex question into a series of simpler logical reasoning questions, mimicking human problem-solving processes. This method has been shown to significantly improve performance on reasoning tasks [22]. However, the need for multiple prompts makes this approach difficult to use at large scales. With this in mind, Kojima et al. [23] proposed Zero-shot-CoT prompting. They found that by appending the phrase "Let's think step by step. " to the end of a question, LLMs can generate a chain of thought that leads to more accurate answers w.r.t the vanilla zero-shot approach.

Resources

To effectively assess the ability of LLMs to support the assertion of disjointness axioms, we ideally require a reference ontology that includes a sized set of classes, to ensure diversity during the experiments and some disjoint classes in its description, preferably specified through a specific disjoint class property such as owl:disjointWith. These criteria maximize the generalizability of the approach and encourage its use for future studies. Several ontologies can be identified for this task, from foundational ontologies, such as DOLCE 3 or UFO 4 , to domain-specific ontologies, such as FoodOn 5 . Disjointness axioms from these ontologies, however, are not intuitive and require extensive common-sense reasoning and domain knowledge. For instance, DOLCE defines an Event to be disjoint from an Object while UFO does not. Both axioms are correct, as they deeply depend on their philosophical commitment to these abstract concepts. Similarly, the FoodOn ontology asserts that the Arabia coffee plant 6 , the plant used to produce black coffee, is disjoint with Camellia sinensis 7 , the plant used to produce black tea. In this case, deciding whether the two plants should be considered disjoint highly depends on the domain of the ontology. To avoid feeding the LLM with classes whose disjointness highly depends on the context or domain, we choose to avoid foundational and domain-specific ontologies for our initial experiments. Moreover, as our interaction with the LLM is based on natural language, we only consider ontologies that provide natural language labels for classes via labeling properties, such as skos:prefLabel or rdfs:label.

We ultimately decided to use the DBpedia ontology8 because of its general popularity and conformity with dataset minimal requirements. Since the DBpedia ontology is created through a crowdsourcing approach [24], the availability of disjointness axioms cannot be expected to be equally accurate across all classes, as it depends on the annotators' expertise and diligence. This issue has been actively discussed within the DBpedia community 9 . The main drawback is the lack of a systematic approach in the creation of the taxonomy, which greatly impacts the consistency of the ontology when disjointness axioms are asserted. In particular, we found 23 explicit disjointness axioms in the DBpedia ontology. In Section 4 we show how exploiting automated reasoning techniques allows the creation of a larger pool of disjoint classes. In Table 1 a selection of disjointness axioms within the ontology is shown. Indeed, most of the disjointness axioms are universally known common-sense relations, such as disjointness between dbo:Fish and dbo:Mammal or dbo:Agent and dbo:Place.

Table 1

Examples of pairs of classes explicitly specified as ontologically disjoint in the DBpedia ontology.

Proposed approach

We now describe our approach which, given a Knowledge Base, clarifies for every pair of named classes of that ontology if disjointness should hold between the two classes or not. At the core of the approach is prompting an LLM to exploit the semantic and linguistic "world knowledge" it has obtained from training on vast amounts of textual data. The two major underlying objectives of our approach are:

1. Ensuring that the resulting disjointness-enriched ontology is satisfiable (i.e., contradictionfree) for usability reasons since otherwise it would be unusable for any reasoning tasks, including ontology-supported querying. 2. Minimizing the number of interactions with the LLM for efficiency reasons and costawareness.

We propose to address both objectives using automated reasoning. More specifically, we continuously materialize all the (non-)disjointness information that follows logically from the original knowledge base plus the already acquired disjointness information. Thus, the LLM is only queried about the disjointness status of pairs of classes, when neither of the outcomes would result in an inconsistency. In this way, the derived information remains contradiction-free "by design" and, at the same time, the number of queries to the LLM is significantly reduced.

Our approach relies on several logical correspondences, discussed in the following.

Proposition 1.

Let 𝒦 be a knowledge base and let C 1 , C 2 , D 1 , D 2 be classes of 𝒦 such that the following statements follow from 𝒦:

(i) C 1 and C 2 are disjoint, (ii) D 1 is a subclass of C 1 , (iii) D 2 is a subclass of C 2 .

Then 𝒦 also entails that D 1 and D 2 are disjoint.

Proof. Consider an arbitrary model ℐ of 𝒦. According to the assumptions and in view of Definition 1, we know that (i)

C ℐ 1 ∩ C ℐ 2 = ∅, (ii) D ℐ 1 ⊆ C ℐ 1 , and (iii) D ℐ 2 ⊆ C ℐ 2 .

We equivalently express (ii) and (iii) by (ii')

D ℐ 1 = C ℐ 1 ∩ D ℐ 1 , and (iii') D ℐ 2 = C ℐ 2 ∩ D ℐ 2 .

This allows us to infer

D ℐ 1 ∩ D ℐ 2 = (C ℐ 1 ∩ D ℐ 1 ) ∩ (C ℐ 2 ∩ D ℐ 2 ) = (C ℐ 1 ∩ C ℐ 2 ) ∩ (D ℐ 1 ∩ D ℐ 2 ) = ∅ ∩ (D ℐ 1 ∩ D ℐ 2 ) = ∅.

We exploit this property to use subclass relationships from 𝒦 to deduce class disjointness statements from existing class disjointness statements. This way we avoid posing redundant disjointness queries to the underlying LLM. Proposition 2. Let 𝒦 be a knowledge base and let C 1 , C 2 , C be classes of 𝒦 such that the following statements follow from 𝒦:

(i) C 1 and C 2 are disjoint, (ii) C is a subclass of C 1 , (iii) C is a subclass of C 2 . Then 𝒦 also entails that C is incoherent.

Proof. Consider an arbitrary model ℐ of 𝒦. According to the assumptions and in view of Definition 1, we know that (i)

C ℐ 1 ∩ C ℐ 2 = ∅, (ii) C ℐ ⊆ C ℐ 1 , and (iii) C ℐ ⊆ C ℐ 2 .

We equivalently express (ii) and (iii) by (ii')

C ℐ = C ℐ 1 ∩ C ℐ , and (iii') C ℐ = C ℐ 2 ∩ C ℐ . This allows us to infer C ℐ = C ℐ ∩ C ℐ = (C ℐ 1 ∩ C ℐ ) ∩ (C ℐ 2 ∩ C ℐ ) = (C ℐ 1 ∩ C ℐ 2 ) ∩ C ℐ = ∅ ∩ C ℐ = ∅.

We exploited this property indirectly under the assumption that any named class 𝐶 in the considered ontology is supposed to have instances -which seems to be a reasonable assumption since, otherwise, the definition of the class appears to be meaningless. In that case, any two classes that have a common subclass must be not disjoint.

Proposition 3.

Let 𝐾 be a knowledge base, let C 1 , C 2 be classes and let 𝑒 be an individual of 𝒦 that such that the following statements follow from 𝒦:

(i) C 1 and C 2 are disjoint, (ii) 𝑒 is an instance of C 1 , (iii) e is an instance of C 2 .

Then 𝒦 is unsatisfiable.

Proof. Suppose ℐ is a model of 𝒦. According to the assumptions and in view of Definition 1, we know that (i)

C ℐ 1 ∩ C ℐ 2 = ∅, (ii) e ℐ ∈ C ℐ 1 , and (iii) e ℐ ∈ C ℐ 2 .

Then, combining (ii) and (iii) we obtain e ℐ ∈ C ℐ 1 ∩ C ℐ 2 and applying (i) yields e ℐ ∈ ∅ which is a contradictory statement. Thus 𝒦 cannot have any models, which means it is unsatisfiable.

Again, this property can be exploited by noting that any two classes having common instances must not be disjoint. These considerations lead to the proposed methodology, detailed in Algorithm 1, which achieves the above-mentioned objective of producing an enriched knowledge base that is guaranteed to be contradiction-free, provided that the original knowledge base is.

Algorithm 2 achieves the objective of reducing the number of interactions with the LLM and maintaining satisfiability as new disjointness information is added through the LLM. The aim of producing an output that accurately reflects taxonomic relationships crucially depends on the quality and accuracy of the LLM's responses. This, in turn, is influenced by both the LLM itself and the chosen prompting strategy. We focus on these issues in Section 5.

The last steps of Algorithm 2 (lines 14 and 15) are optional, but highly recommended, as they remove logically redundant statements from the disjointness-enriched knowledge base 𝒦 ∪ 𝒟. This yields a knowledge base that is logically equivalent but typically much smaller in size and hence both easier to process algorithmically and to scrutinize and maintain manually. Also, this "pruning step" is not computationally expensive, as it only requires |𝒟 * | calls to a reasoner.

Experiments

In this section, we experiment with the approach proposed in Section 4 on the classes extracted from the DBpedia ontology. In particular, by relying on Algorithm 1, we obtain the list ℒ related to the DBpedia ontology. We have that |ℒ| = 1148, with 370 pairs labeled as disjoint and 778 pairs labeled as not unknown. In Table 2, we provide some examples of classes in ℒ.

Note that the list ℒ assumes that the ontology designers carefully produced a taxonomy that is intended to also reflect disjointness between classes. As shown in Section 3, however, this is not the case. The design of the taxonomy of DBpedia is structured such that disjoint axioms might result in unwanted inconsistencies. For this reason, we employ multiple metrics to evaluate the LLMs' performances, each measuring a different behavior of the model. For

Algorithm 1 Determine the pair of disjoint classes derivable from 𝒦

Input A knowledge base 𝒦 containing a class hierarchy. The knowledge base might or might not contain defined disjointness axioms and/or more complex axiomatizations.

Output A list ℒ of pair of classes such that disjointness statements logically following from 𝒦 are explicitly asserted.

for all (C 1 , C 2 ) ∈ ℒ do 5: if (C 1 ⊑ D 1 ∧ C 2 ⊑ D 2 ) or (C 1 ⊑ D 2 ∧ C 2 ⊑ D 1 ) then 6: (C 1 , C 2 ) ← "disjoint" 7: end if 8:

end for 9: end for 10: for all

(C 1 , C 2 ) ∈ ℒ | (C 1 , C 2 ) = "unknown" do 11:

if C 1 and C 2 have joint subclasses then 12:

(C 1 , C 2 ) ← "not disjoint" 13: end if 14: end for 15: for all (C 1 , C 2 ) ∈ ℒ | (C 1 , C 2 ) = "unknown" do 16:

Query 𝐾 for joint instances of C 1 and C 2 . 17:

if ∃e ∈ I | e : C 1 ∧ e : C 2 then 18: (C 1 , C 2 ) ← "not disjoint" 19:

end if 20: end for all metrics, a higher score indicates better performances, with 1 being the maximum score. In particular, disjoint recall (DR) measures how much the LLM aligns with humans by measuring the amount of true disjointness axioms that have been identified by the LLM. This measure provides an evaluation of the reliability of the prompt. Non-disjoint F1 (NDF1) measures the F1 score between the non-disjoint couples in 𝐿 and the ones identified by the LLM. This provides a measure of how conservative the LLM is on its answers -i.e. how much the LLM acknowledges the open-world assumption. The F1 metrics measure the end-to-end performances of the model. The symmetric consistency metric (SC) measures how much the answers provided by the LLM Algorithm 2 Determine the set of disjointness statements 𝒟 consistent with 𝒦 Input A list ℒ containing pairs of classes labeled as "unknown", "disjoint" or "not disjoint"; a prompt 𝑃 for disjointness classification, with 𝐿𝐿𝑀 𝑃 : C × C → {"disjoint","not disjoint"} the function that queries an LLM for disjointness of two classes using prompt 𝑃 Output A set 𝒟 of class disjointness axioms, such that all valid disjointness statements logically follow from 𝒦 ∪ 𝒟 and no invalid disjointness statements follow from it.

1: while ∃(D 1 , D 2 ) ∈ ℒ | (D 1 , D 2 ) = "unknown" do 2: Select (D 1 , D 2 ) ∈ ℒ | (D 1 , D 2 ) = "unknown" 3: 𝑑 ← 𝐿𝐿𝑀 𝑃 (D 1 , D 2 ) 4: if 𝑑 = "disjoint" then 5: for all (C 1 , C 2 ) ∈ ℒ | (C 1 ⊑ D 1 ∧ C 2 ⊑ D 2 ) ∨ (C 2 ⊑ D 1 ∧ C 1 ⊑ D 2 ) do 6: (C 1 , C 2 ) ← "disjoint" 7:

end for 8:

else 9: for all (C 1 , C 2 ) ∈ ℒ | (D 1 ⊑ C 1 ∧ D 2 ⊑ C 2 ) ∨ (D 2 ⊑ C 1 ∧ D 1 ⊑ C 2 ) do 10: (C 1 , C 2 ) ← "not disjoint" 11:

end for 12:

end if 13: end while 14:

𝒟 * ← {DisjointClasses(C 1 , C 2 ) | (C 1 , C 2 ) ∈ ℒ ∧ (C 1 , C 2 ) = "disjoint"} 15:

Determine the minimal subset 𝒟 of 𝒟 * such that 𝒦 ∪ 𝒟 entails 𝒟 * respect the symmetric property of the disjointness axiom -i.e. if 𝐴 is disjoint from 𝐵 then 𝐵 is disjoint from 𝐴. Finally, we measure the overall accuracy of each model.

Prompting

We adopt different prompting strategies: a naive approach, where the LLM has to autonomously understand the task, a task description approach, where the disjointedness task is described and a few-shot approach that extends the task description by also providing some positive and negative examples. For each prompt, we frame the problem as a questionanswering (QA) task, where the LLM has to answer positively or negatively to classify two classes as disjoint. To identify the best QA approach, we identify two prompts: (i) the LLM has to answer positively to classify two classes as disjoint and (ii) the LLM has to answer negatively. Table 3 describes the prompt templates we used. When possible, we rely on the instruction format of each LLM and use the Prompting Strategy template to instruct the LLM while we use the QA Strategy as a query to the instructed LLM.

Experimental setup

We perform our experiments on publicly available LLMs, to ensure full reproducibility of the experiments. For each LLM, we set the sampling temperature to 0, to reduce the randomness of the result. Moreover, we only rely on small LLMs -i.e. LLMs with approximately 8 billion of parameters. Through the use of proper optimization techniques, it is possible to run these models on consumer-level devices without the need for specialized hardware. We perform Table 3 Prompting strategy templates. 𝐴 and 𝐵 are natural language labels of classes from the ontology.

Prompting Strategy Template

Naive Answer only "yes" or "no".

Zero-shot Task Description This is a question about ontological disjointness, answer only with "yes" or "no"

Few-shot Task Description This is a question about ontological disjointness, answer only with "yes" or "no". Examples of disjoint are: "person" and "file system", "tower" and "person", "place" and "agent", "continent" and "sea", "baseball league" and "bowling league", "planet" and "star".

Examples of not disjoint are: "basketball player" and "baseball player", "means of transportation" and "reptile", "garden" and "historic place", "president" and "beauty queen", "castle" and "prison".

QA Strategy Template

Positive Is the class 𝐴 disjoint from 𝐵?

Negative Can a 𝐴 be a 𝐵?

our experiments on a selection of the current state-of-the-art models, including Mistral 0.3 7B [25], Gemma 2 9B [26], LLama 3 8B10 , and Qwen 2 7B [27] 11 . All experiments are run on 8-bit quantized models on an RTX3090 with 24GB of RAM. We experiment with each combination of the prompts of Table 3.

Results

The overall results are shown in Table 4. In general, LLMs achieve promising results in disjointness detection. Notably, the best prompting technique is not providing few-shot examples, but rather providing the LLM with little to no description of the task. Indeed, it has been observed how few-shot prompting is more effective when in-context learning is required, while zero-shot prompting is more effective when the implicit knowledge of the LLM should be exploited [28].

Nonetheless, further research on few-shot prompting for disjointness classification should be performed, as lower performances can also be attributed to the amount and nature of the examples we provide in the prompt. We manually select examples that are likely to provide meaningful disjointness instances. However, a more complex approach could be employed, such as exploiting Retrieval Augmented Generation (RAG) techniques to provide examples that are more likely to be relevant for the classes used as input. Different heuristics can be used to measure the relevance of other classes, such as word embeddings or knowledge graph embeddings. Interestingly, framing the problem as a negative QA task -i.e. asking whether an individual of a class can also be an instance of another class -consistently outperforms the positive QA prompt. This could be attributed to the fact that using the negative approach is more consistent with natural language questions. LLMs can actively exploit their pre-training phase, which generally includes a fine-tuning phase to solve QA tasks akin to our negative prompt. On average, Gemma 2 performs better than the other LLMs. However, depending on the requirements, other LLMs might be better suited. For instance, Mistral 0.3 is better aligned with human judgment, since it has a higher recall on disjointness axioms.

Disjointness on DBpedia

Given the results of Table 4, we consider Gemma 2 with task description prompt and a negative QA strategy as the most effective way of producing disjointness axioms among the methods tested. We execute Algorithm 2 on the whole DBpedia ontology. We rely on a straightforward random selection for the pair (D 1 , D 2 ) (line 3). In total, the algorithm takes 21589.75𝑠 ≈ 6ℎ to execute. Note that given the random selection, we are not able to exploit parallelism and query the LLM with single prompts. However, a selection strategy that enables parallel selection would greatly enhance the performance of the algorithm. In total, we find 510, 600 disjointness axioms, which results in ≈ 98% of the classes participating in at least one disjointness axiom. The number of axioms can be greatly reduced by relying on the "pruning" operation of Algorithm 2 (line 15). In the case of the DBpedia ontology, the number of resulting axioms is 170, 122 -a reduction of ≈ 66%. For illustration and discussion purposes, Table 5 shows a non-representative selection of particularly discussion-worthy positive and negative disjointness statements retrieved via Algorithm 2. We observe that for some class relationships, including both common-sense and domain-specific classes, our approach resulted in the "conservative" misclassification of classes as non-disjoint, meaning the LLM classified the classes as non-disjoint despite the classes actually being disjoint. Examples include dbo:VideogamesLeague and dbo:Website, dbo:GeneLocation and dbo:HumanGene, and dbo:Identifier and dbo:District. Conversely, we also observed "aggressive" misclassification where our approach classified classes as disjoint despite them being really non-disjoint. Straightforward examples include dbo:PlayboyPlaymate and dbo:Camera or dbo:WikimediaTemplate and dbo:WomensTennisAssociationTournament, with a more complicated example being dbo:Mosque and dbo:Museum. The latter being disproven by a counter-example, the famous Mosque Hagia Sophia in Turkey12 . To address these misclassification instances, we suspect that providing more contextual information in the prompt may improve classification accuracy, especially for domain-specific scenarios. Also, future work could be done to assess how, through prompt design, the approach could encourage more "aggressive" or "conservative" disjointness classifications in scenarios where relationships are more uncertain.

Conclusion and Future Work

This work shows that LLMs can roughly identify and assert disjointness axioms in ontologies, with a different degree of reliability depending on the model. By harnessing their inherent background knowledge and employing strategic prompt engineering, we showed that these models can classify ontological disjointness with minimal human intervention. This capability simplifies ontology management and supports more robust reasoning in knowledge graphs. Our findings underscore the potential of LLMs as valuable tools for the automated enrichment of ontologies, which encourages future exploration and innovation in this domain.

Future works include testing the approach proposed in Section 4 on other ontologies, to assess its effectiveness on different types of ontologies, including domain-specific ontologies. Additionally, comprehensive validation by human domain experts would be required to obtain conclusive insights into the degree of reliability of the axioms asserted by the LLM.

Moreover, using different LLMs with different numbers of parameters and improving and expanding our strategies for testing disjointness constitutes interesting future work.

It could be worthwhile to look into heuristics for -given a large list of disjointness candidate pairs -picking those entries that are particularly "promising". One option would be to follow the strong disjointness assumption [6] and pick "sibling classes", that is, classes 𝐴 and 𝐵 that have a common direct superclass 𝐶. Furthermore, it could be interesting to test class pairs with just one or two examples of non-disjointness, as these instances may be errors to remove from the KG. On another note, one could develop strategies for gauging the reliability of an LLM response by rephrasing the question asked. This involves adding a description of classes in prompts to see if it improves the answers, relying on proper ontology serialization techniques [29]. Finally, using advanced prompting techniques, such as chain-of-thought, may improve the results alongside RAG techniques to pick the few-shot examples. Similarly, a richer prompt, including more qualifying phrases such as "at the same time" to check the temporality of the disjointness or "theoretically" to force abstraction might instruct the model toward a more effective framing of the problem.