Ontology and Information Systems

1. Introduction

In information and computer science the study of ontology is about how to define or describe the things that are (including imagined or possible things) for the purpose of some process of computation on a computer. In philosophy, the field of ontology is often described as “the study of what there is” (see the entries on social ontology, logic ontology and natural language ontology). A philosophical ontology will thus purport to identify the fundamental constituents of reality, the categories they fall into, and the relations they stand in to one another. Ontology in computer and information science shares with philosophy that it includes a study of categories (see the entry on categories) but with a practical focus on recording an inventory of categories in a formal syntax and often with some formal semantics. Some individual information science ontologies are also concerned with a formal specification of the definitions of those categories. Ontology as a field in computer and information science is also reasonably characterized as the study of what there is, but not necessarily of what ultimately exists, rather of what is assumed to exist in some relevant domain for some computational purpose. A computer scientist is less concerned about the metaphysical status of categories – such as whether they actually exist or are just human constructs – than with their practical use in computation. In computer and information science, an ontology may also catalogue individuals and relationships, in addition to categories.

One popular description of an ontology in computer science is “a specification of a conceptualization” (Gruber 1993). But this requires an explanation of of what a specification is and what a conceptualization is. A conceptualization is a way to understand the structure of a particular concept by considering both its relationship to other concepts and the principles that may govern it. So a conceptualization includes a way to understand how a concept differentiates the objects falling under it (whether abstract or concrete), from other things. Historically, a way of understanding a concept would be expressible in a human language as an entry in a dictionary or encyclopedia. Concepts are often labeled using single words or phrases and since they are the meanings of those words and phrases, they are not part of the syntax. Different human languages use different symbols but can express the same concepts, although whether one can have truly exact translations is a subject of some debate (Levine & Lateef-Jan 2017). Words are one method of reference (see the entry on reference). We hope that when we use a proper noun like “Mount Kilimanjaro” that the listener will have enough common information associated with the words that the desired information is communicated. But with more abstract concepts such as “object” or “beauty” this is more problematic. Once a concept is expressed in some way for communication then we can examine what it means to be a specification. If we do not rely on human intuition about the intended meaning of a word or words, or even on the process of human clarification dialogues, then we must have some other way of recording ideas or thoughts.

Since its adoption in the computer science community, the word ‘ontology’ has become broader in usage. Collections of words with natural language definitions have been labeled as an ontology, even though we could call them glossaries and not have to resort to adopting this new word for something that already has an older label. Other approaches to specifying an ontology include use of taxonomy languages (Dallwitz 1980) or Unified Modeling Language (UML: Rumbaugh, Jacobson, & Booch 2004). Others have treated a graph of concept names and binary relationships to be sufficient for a specification, such as what is found in semantic networks (Woods 1975) or knowledge graphs (which might be stated in Resource Description Framework (RDF: see the link to RDF in Other Internet Resources below), or a graph database (Kaliyar 2015)). Description logics (Baader, Calvanese, McGuinness, Nardi, & Patel-Schneider 2007) are a popular choice for specification of an ontology. At its most formal, a specification can be a set of formulas in an expressive mathematical logic such as first-order logic (Enderton 1972), modal logic or higher-order logic (see the entries on modal logic and higher-order logic).

Two of the most important motivations for constructing an ontology are that (i) it can help to prevent concept drift and (ii) it supports the interoperability of systems. Regarding the first of these, a common issue in software development is that the use of strings of symbols in computer code by different programmers can change over time, causing unintended performance in a system. An ontology standardizes and reuses concepts, thereby preventing a concept expressed by a string within a given body of code at one time from drifting into use as another, different concept at a later time. Regarding interoperability, note first that the kind of ontology one creates will, at least in part, be driven by its intended uses. Broadly, there are three categories of use, ultimately leading to a computational implementation, which may all be present in some application: (1) communication among people, (2) communication among machines or between people and machines, and (3) computation.

In (1) the ontology is used to align the terminology and understanding of that terminology among developers of a computational system. There may be no exact transfer of the set of labels or definitions into any formal computational system. An ontology that exists to facilitate understanding among humans may rely on intuitions about concepts based on their names, as well as natural language definitions. Grounding the meaning of specialized terms in a glossary can help to eliminate some interpretations, for example, misunderstandings based on word polysemy.

In (2) the set of labels used in a computational system forms a standard that people and software systems adhere to. The people who develop the computational system agree on the set of symbols to be used and agree on some set of definitions which are at least partly given in natural language and require human intelligence to interpret.

In (3) there is a fully computational representation of a set of concepts, in which the intended meaning of a set of symbols is fully specified in a computational form, such as a computationally implemented mathematical logic. People may still have intuitions about concepts which are not fully captured in the logical language, but that would be considered a bug or omission to be rectified.

This classification of an ontology with respect to these three categories is a framework for understanding the usage of an ontology rather than a mutually exclusive and rigid set. One might for example have an ontology strictly implemented in a computational mathematical logic as a way for people to adjudicate disagreements about terminology, rather than to govern the behavior of a software system.

2. History

The conception of ontology adopted in information science has its roots in the history of philosophy and may be traced all the way back to the “Tree of Porphyry” (with reference to the 3rd-century Greek neoplatonist philosopher Porphyry of Tyre: Franklin 1986). The abstraction of a tree was used to show the relationships between concepts.

This abstraction would become a dominant way to depict ontological distinctions from the biological taxonomy of Linnaeus (1758) to the present day. Much writing about categories throughout the Middle Ages consists of commentary (see the entry on medieval categories) on Aristotle’s work. After the Middle Ages, efforts to catalog categories were more independent of Aristotle, and the advent of the scientific method led to interest in defining categories in the natural sciences, including in Linnaeus’ writings.

A less-well known effort of particular note, which predates Linnaeus, is John Wilkins’ monumental “An Essay Towards a Real Character and a Philosophical Language” of 1685 (Subbiondo 1992). It contains hundreds of pages of a single tree structure of concepts, each with a natural language definition. While much of the content, such as the categories for organisms, is only of historical interest, some innovations, such as a concept of ‘glove’ being viewed as a function that denotes clothing for a body part, point to modern uses of logical functions in ontological definitions. His work also is notable in that he presents the concepts not only in a taxonomy but also with a written and spoken language that uses the categories in a grammar in order to form a more perfect language (Eco 1995), free from ambiguity.

Before Frege and Peirce (see the entries on Frege and Peirce’s deductive logic) laid the foundations for modern mathematical logic, the concepts in an ontology were defined informally in natural language. Hence, until the development of modern computers, only humans were capable of working with an ontology.

Before the word ‘ontology’ was adopted in computer science there was a long history in Artificial Intelligence (AI) of using formal logic and logic-inspired systems such as Prolog (Clocksin & Mellish 2003) to define concepts. Collections of logical theories (Farquhar, Fikes, & Rice 1997) showed how many logical definitions of general concepts could be documented, but at that point the concepts were not integrated so that they could be combined and used together in a single consistent theory.

Another knowledge representation method used in some information science ontologies is that of Semantic Networks (Woods 1975; Lehmann 1992; see also the section “Representationalist Approaches” in the entry on computational linguistics). They are also called Knowledge Graphs and often implemented in graph databases (Robinson, Webber, & Eifrem 2015). They consist of a set of labeled nodes and arcs, arranged as a graph, that state relationships between entities. This approach was popular in AI in the 1970s and has again become popular in the 2020s.

Expert systems, prevalent in the 1970s and 1980s, were arguably the earliest systems that used a computational ontology, although they were not known by that label at that time. But if we consider a computational product that consists of a collection of symbols and some symbolic language that defines the concepts, such systems did include ontologies. Mycin (Buchanan & Shortliffe 1985), Prospector (Duda, Gaschnig, & Hart 1979) and many other expert systems were developed through the 1970s and 1980s.

Semantic networks and first-order logic were two of the earliest knowledge representation paradigms in Artificial Intelligence and also exemplars of the “neat” vs. “scruffy” debate (Crevier 1993; Poirier 2024; Gonçalves & Cozman 2021) about whether knowledge representation required a formal mathematics. Some practitioners (“neats”) would advocate that a solid theoretical basis for reasoning is needed. Others (“scruffies”) argue that having a system that “just works” is enough, and that a system that accomplishes a task need not have a theoretical underpinning. This echoes a broader debate about the validity of empiricism (see the entry on logical empiricism). In the mid-1990s the value of a collection of named concepts as a resource, somewhat independent of its use, began to be recognized in computer science.

Another response to the difficulties in knowledge engineering for expert systems, which predated the use of “ontology” as a term in computer science, is the Cyc project (Lenat & Guha 1989). Cyc is a commercial endeavor conceived of as a repository of common-sense knowledge to support Artificial Intelligence applications. It is the largest effort to date to collect concepts and definitions in an expressive logic in a computational system. There was a recognition that an important area of study for ontology was the “upper ontology” (see section 3) – a set of concepts that are likely to be needed and held in common among many domains. Some of the first upper ontologies conceived with that description were the Suggested Upper Merged Ontology (SUMO: Niles & Pease 2001; Pease 2011), the Descriptive Ontology for Linguistic and Cognitive Engineering (DOLCE: Gangemi, Guarino, Masolo, Oltramari, & Schneider 2002) and Basic Formal Ontology (BFO: Arp, Smith, & Spear 2015; Smith, Grenon, & Goldberg 2004). Many others followed (see the link to Upper Ontology in the Other Internet Resources section below). Ontology languages evolved in parallel with creation of new ontologies. Expert systems were implemented in Prolog (Clocksin & Mellish 2003) or expert system “shells” such as Clips (Riley, Culbert, Savely, & Lopez 1987) and OPS5 (Brownston, Farrell, Kant, & Martin 1985). Some ontologies are defined in languages that can be used in computation to answer questions or check their consistency. Theorem-proving languages for particular mathematical logics were developed with increasing expressiveness from first-order logic (Sutcliffe & Suttner 1998) to typed first-order logic (Sutcliffe, Schulz, Claessen, & Baumgartner 2012), modal (Raths & Otten 2012) and higher-order logic (Benzmüller, Rabe, & Sutcliffe 2008), and implemented in automated theorem-proving systems (Sutcliffe 2010). Languages including Knowledge Interchange Format (KIF: Genesereth & Fikes 1992) and Description Logics such as the Ontology Web Language (OWL) family of languages (Bechhofer et al. 2004) were developed explicitly to support ontologies.

3. Domain Ontology and Upper Ontology

An upper ontology is a collection of concepts that are not specific to any application domain. The determination of whether a concept belongs in an upper ontology or not is not an objective decision, except relative to other terms in the same ontology. Some upper ontologies aim to be minimal, containing only a small number of the most general concepts, and others include larger collections from the most general to the more specific. Many domain ontologies are created as extensions of upper ontologies. An upper ontology starts with a category of all things and then elaborates, adding categories (and sometimes, definitions) for physical and abstract things, relations and functions etc. But the boundary of where upper ontology becomes domain ontology is arbitrary. A domain ontology would not have a decomposition of categories starting from the class of all things, but many domain ontologies that do not extend an upper ontology still will require a few very general categories, such as the notion of a physical object or a process.

What counts as a domain is an issue of perspective, and is relative to the practitioner’s objectives. A particular application for preventing negative drug interactions (Zhao, Yin, Zhang, Zhang, & Chen 2023) might have few concepts relating to drug chemistry, while an application to support drug synthesis might have no concept of a drug interaction. However, a more general ontology about drugs might have both those concepts and more, but possibly a less extensive catalog of drugs.

There are vastly more domain ontologies in existence than upper ontologies (see the links to ontologies in the Other Internet Resources section below).

4. Ontological Commitment

What should an ontology commit to and what should it leave unspecified? If ontological commitment (see the entry on ontological commitment) is something to be minimized, then one might only commit to categories of Entity and Relation, with no other terms in the ontology. With such a minimal ontology of only two concepts there are virtually no commitments, but then also little utility is derived from such a theory in describing the world and assisting in creating a set of concepts and definitions that can be held in common by different entities. There is a clear tension between not wanting to make commitments that would limit the application of an ontology to only some narrow contexts, and with wanting to have as large a set of commitments as possible in order to facilitate common understandings.

But does creating and defining a concept in an ontology necessarily create a commitment? It depends on how such a definition is made. Let’s examine two cases consisting of a strong commitment and a weak commitment. If one states \(\exists x \: \text{unicorn}(x)\) this has created what is likely a strong and unwise commitment. However if one states \(\forall x \: (\text{unicorn}(x) \implies \exists y \: (\text{horn}(y) \land \text{part}(y,x)))\) a different, weak sort of commitment has been made that is likely not problematic. The latter formula only commits to the fact that if there were a unicorn in existence, it would have a horn. A commitment about how to define the characteristics of an imaginary entity, which isn’t necessarily presumed to exist, is quite a weak commitment. The practical issue of ontological commitment in the context of a computational ontology (as well as in philosophy more generally) hinges on whether a theory is not false – that is, not incompatible with modeling the world in useful software applications. One need not have an ontology that is capable of modeling all knowledge in the world for it to be practically useful. The question at hand then becomes the degree to which useful models of the world are excluded by a particular ontology, and the degree to which the ontology supports definition of various models. One could be concerned only with commitments that may rule out other reasonable commitments. An ontology that makes obviously poor modeling choices, such as requiring the Earth to be flat, makes an error of commission that excludes many of its possible uses. An ontology that has very few concepts or categories, or few definitions, has limited utility for modeling. It is an error of omission to avoid making commitments to concepts that are needed in modeling the world, such as omitting spatial or temporal relationships, or a way to model time or action. One can avoid being wrong by saying nothing at all. The challenge is to say as many things about the world as possible while not saying things that are false.

An illustration of choices in commitment (see the entry on identity over time) is that of Endurantism vs. Perdurantism: do objects have temporal parts and how are those parts related (Haslanger & Kurtz 2006)? But must one choose between alternatives for how we define a single notion of parthood or identity (see the entry relative identity)? One can have properties of an object that change while identity is maintained. A formal ontology creates not only a computationally useful product but also a laboratory for exploring how we see the world. One might suppose a conflict in views or theories, but absent a formal proof in the logic employed by a particular ontology, worries about a particular conflict in modeling choices are at best just unverified hypotheses. On the other hand if there is a proof of a logical contradiction, then there is a mathematical basis for asserting that a conflict in modeling choices actually exists, and working towards a harmonization of those choices. One might informally assume, for example, that identity must assume identicality (see the entry on identity of indiscernibles) (\(\forall F(Fx \leftrightarrow Fy \implies x=y)\) for all properties \(F\)), but unless that ontological commitment is made axiomatically, in code that an automated theorem-prover or other inference system can execute, it is only a potential bad choice that has been avoided in practice.

An ontology that commits to every entity having a place in space and time has excluded timeless entities such as numbers. An ontology that commits to a notion of physical things (which have a place in space and time) and abstract things (which do not have a position in space or time) has merely created modeling facilities that may be employed, rather than a commitment that excludes an important aspect or view of the world.

A goal to minimize ontological commitments is related to a similar desire for an ontology that contains only a minimal set of primitives. How many concepts does one need? Is there a limit to the number of concepts that exist? If one takes human language as a guide, it would seem not: new words that express new concepts are created continually. The words “smartphone” and “selfie” were coined to express concepts that did not previously exist. While one could use existing words to express a similar thought, such as in “I took my – small computer that has a touchscreen and also functions as a phone – out of my pocket”, this would be a very inefficient form of discourse, which would still leave out the many connotations of the modern word of “smartphone”. One could conceivably define every concept during the course of communication, and avoid committing a priori to many words with associated definitions. Similarly, one might be able to build up a set of terms in an ontology from a small set of primitives, but it would be more efficient to archive each new term and definition as it appears to be needed.

One argument for a small set of ontological primitives is that it is easier to learn a smaller set than a larger one. One might look to modern software development for lessons learned in this case. While reusable software libraries were non-existent at the dawn of computing, now large libraries form an essential part of the modern software development process. It is inefficient to reinvent common abstractions. There are enough common abstractions that modern programming languages have tens of thousands of functions available for reuse. No programmer need learn all of them, and the ones that are unused in any given project cause no harm since unused library functions are not included by a compiler into a runnable program. Reusable components speed up development and increase compatibility among systems. An additional analogy is that an English dictionary that fits on a single page has vastly less utility for standardizing the meaning of words than a comprehensive collection such as Webster’s (Merriam-Webster 2003) or the OED (Oxford English Dictionary 2020).

5. Ontology by Theory Elements

Ontologies that concern themselves with top-level or general categories (which are often called “upper ontologies”), as opposed to concepts specific to a domain (see section 3), have broadly similar inventories. One needs to have physical entities and abstract ones, substances and objects, processes, attributes, numbers of different sorts, and define these notions to organize the conceptual space and provide as much opportunity for abstraction as possible. The Tree of Porphyry (see section 2) also sets an example of providing differentia – an explanation of how each concept differs from the others. An undifferentiated concept is just a synonym of some others in an ontology. The first challenge for any ontologist is to learn how to create these descriptions, and reject any proposed concept for which no set of precise differentia can be given.

All the prominent upper ontologies have at least some version of the following concepts:

Thing/Entity – The class of all things.
Physical – The class of all things that have a position in space and time.
Process/Action/Event – The class of things that happen.
Object/PhysicalThing – The class of things that are. Tangible entities.
Stuff/Mass – The class of things that may be subdivided and retain their identity (see the entry on mass expressions).
PhysicalObject/CorpuscularObject – The class of things that may not be subdivided and retain their identity.
Abstract/NonTangibleThing – The class of things that do not have a position in space and time.
Relation – The class of relationships among entities.
Property/Attribute.
Function – The class of functional relationships: for every one element or unique combination of elements of the relation there is a unique other element.

Less common are catalogues of relationships. A few types of relationships such as the class of transitive relations are built into the Ontology Web Language (OWL) used in the semantic web community, rather than being defined in the ontology language, since the OWL language is not sufficient to express that property. Other common classes of relations are symmetric, reflexive, anti-symmetric etc.

Relationships found in common in some ontologies are:

physical part/‘has a’ — one physical entity has another as a physical part, such as a door having a doorknob or a car having a wheel (see the entry on mereology).
temporal part — an event or process has another event or process that is a part of the parent process (see the entry on temporal parts).
physical location — something is located at a region or other object (see the entry on location and mereology)
subclass/‘is a’ — one class of things is more specific than another class of things
instance — an individual entity is a member of a class
case roles (Fillmore 1968; Gisborne & Donaldson 2019) such as agent, patient, instrument etc.
temporal relationships among events (as in Allen 1984): including before, meets, during, starts etc.

6. Ontology by Logical Language

While most things called ontologies are stated in some formal language, some ontologies do not employ a language with a formal (mathematical) semantics. A ontology that is essentially a glossary may collect words and natural language definitions. Humans must read such a product, resolve ambiguities in the language and reason about how they may apply to a specific problem. While a spelling or grammar checker can help with construction of such a document, machine or mathematical processes cannot be used to determine whether definitions are in conflict with one another. These shortcomings of natural language ontologies motivated the use of formal languages in the construction of ontologies.

The simplest formal languages used in ontologies are taxonomies and graphical languages. In a taxonomy, the only error that can be identified with automation is the presence of a cycle, where \(A\) is a parent (possibly transitively) of \(B\) and vice versa. The formal semantics for a taxonomy is that child nodes denote more specific concepts than their parent \(\forall x : \text{child-class}(x) \implies \text{parent-class}(x)\).

The simplest graph language is one comprised of named nodes and arcs. Graphs do not have any inherent formal semantics other than that some relations hold. It may be as simple as that a graph G consists of vertices and edges \(G = (V,E)\), although typically there will be some reusable set of edge labels (relations) \(R\) and there should be no “orphan” nodes with no relationships – \(G = (V,E,R)\) and:

\[\forall x \in V : \exists r,y: x r y \land r \in R \land y \in V.\]

Some meta-language may then be used to express a formal semantics for particular node and arc symbols, such as that a “PhysicalPart” arc is transitive. But many knowledge graphs and semantic networks do not have a formal specification, just an implementation in a software system. Note that an implementation in a software program is not a formal semantics. A semantics is a mathematical construct that exists outside any implementation. A program may enforce restrictions that are entailed by a mathematics, and several different programs might use different procedures to implement a single given body of semantics.

Description logic is a subset of first-order logic. It was created in order to provide a logical language with decidable inference, as in propositional logic, but with greater expressivity. First-order logic is only semi-decidable – while contradictions can be found in finite time, there is no guarantee that a theorem-prover will determine that no contradiction exists in finite time. The notion of finding contradictions is of critical importance since the most computationally efficient automated theorem-proving systems work by employing proof by refutation.

However, some variants of OWL go beyond description logic while also losing strict decidability but also not supporting all of standard first-order logic (Baader et al. 2007). Considerable progress has also been made in first-order automated theorem-proving to avoid the worst case of undecidability (Geoff Sutcliffe & Desharnais 2024). Practitioners therefore differ in opinions about the choice of a particular logic to solve classes of problems.

Description logics such as the OWL family (Baader, Horrocks, & Sattler 2005) employ as part of the logic keywords that have definitions in a meta-language, since description logic is insufficient to describe their semantics. The OWL language must employ first-order logic in its language definition to state the semantics of some keywords that are part of the OWL language. In addition, OWL has the associated SWRL language (Horrocks, Patel-Schneider, Bechhofer, & Tsarkov 2005), in order to augment the description logic with a language capable of expressing rules. One implementation that preserves the semantics of SWRL uses a first-order-logic theorem-prover (Tsarkov, Riazanov, Bechhofer, & Horrocks 2004). Other implementations use the Drools rule engine (see the section Other Internet Resources) which is a production system rather than a logic (Shapiro 2001) and therefore loses some of the semantics of SWRL.

Relatively few ontologies are defined in more expressive languages such as first-order logic or beyond (notable exceptions are SUMO (Niles & Pease 2001; Pease 2011) and Cyc (Lenat 1995)). The more expressive the logic used, the more things that can be said about concepts, and therefore the more machine reasoning can be applied to answer questions with the ontology, or verify its consistency. For example, in a propositional logic one might have the propositional terms \(S =\) “Socrates is a man” and \(M =\) “Socrates is mortal” and state \(S \implies M\). One would have to state that implication for all humans (and better yet, all organisms). In predicate calculus, one can state a more general rule just once:

\[\forall x \: \text{Organism}(x) \implies \text{Mortal}(x)\]

along with

\[\forall x \: \text{Man}(x) \implies \text{Organism}(x).\]

Going beyond first-order logic one might want to state the axiom of transitivity just once and have it hold for all instances of the type “TransitiveRelation”, rather than repeating that axiom for every such relation. The more expressive the logical language, the more efficient it is at encoding knowledge and creating generalizations, so any metrics about the size of an ontology must also take into account the logical expressiveness of the formulas counted.

Another issue in ontology languages and the reasoners that can process them is whether numbers and arithmetic are supported in the logical language. Measures and metric times are part of the world and yet very few ontologies employ a logic that can be paired with a reasoning system capable of reasoning with numbers. SNARK (Waldinger et al. 2004) is one such reasoner, which has its own language. TPTP Typed First-Order Form with Arithmetic (TFA: Sutcliffe, Schulz, Claessen, & Baumgartner 2012) is another language, implemented by a few theorem-provers including iProver (Korovin 2008) and Vampire (Kovács & Voronkov 2013).

Ontologies that are implemented in less expressive logical languages will leave more of their definitions to the intuitions and interpretations of humans. Such ontologies may be used for standardization of terminology among humans. Humans are then responsible for realization of those concepts in software. People must ensure that programs use those concepts correctly and embody their intended meaning. If the author of the ontology is also the author of the software, the realization is likely to be as intended. But there is a risk that others attempting to use the ontology to govern the behavior of their software may have a different understanding. This issue may become more prominent if the size of the system grows or if its use continues over a long period. Maintaining the same intuitions about the meaning of concepts will be more challenging without automation to ensure that interpretations remain consistent.

It is easy to conflate our own knowledge or interpretation with someone else’s. A good example of this is Newton1990, which shows how difficult it is for people to recognize a tune just by its rhythm, and how correspondingly challenging it is for a person providing a rhythm to realize that they haven’t provided enough information. An ontologist may believe that a label or natural language description is enough to constrain the interpretation of a symbol, but without detailed formal specification, it is all too easy for a different person to have a different interpretation. The more detailed and formal the specification, the more likely that different and conflicting interpretations can be avoided.

For those systems that do have an implementation of the ontology based on a taxonomy or graph language, developers may implement constraints on concepts in procedural code, such as the popular Java or Python programming languages, or may choose some auxilliary language that is more declarative, like Prolog, SWRL or Clips.

One advantage to using a less expressive logical language is greater computational efficiency. Description logics are decidable, and so queries are guaranteed to terminate. First-order logic is only semi-decidable and therefore queries may not terminate when there is not a proof showing how to satisfy the query. Higher-order logics have even fewer guarantees of performance. However, considerable progress (Sutcliffe & Desharnais 2023) has been made in avoiding theoretical worst-case scenarios for inference, and improving performance even on large theories (Pease, Sutcliffe, Siegel, & Trac 2010). Additionally, one can easily remove expressive formulas from an ontology for a given application in order to meet specific performance constraints, while retaining expressive formulas as a set of definition of the terms to align human understanding.

7. Assessment of an Ontology

Objective assessments of ontologies performed by disinterested third parties are rare, but Mascardi, Cordi, & Rosso 2007 is one, although it was done for upper ontologies rather than ontologies in general. Some objective measures include:

whether a mathematical logic is used, and if so, which one. The choice of logical language will dictate what aspects of the definition of each concept are formally expressible, and what content has to be provided instead as an informal natural language comment.
whether the logic has been implemented as a computational system, such as with an automated theorem-prover or inference engine. There are many logics with a formal semantics that have not been implemented for computation. If an ontology is defined in an unimplemented logic (and of non-trivial size) it will not be possible to validate that the ontology is free of contradictions, or to pose queries to it without using a human to calculate the result.
which automated reasoner (if any) was used to validate the formulas and what are the limitations of the validation. A description-logic reasoner (such as FaCT++ (Tsarkov & Horrocks 2006) or Pellet (Sirin, Parsia, Grau, Kalyanpur, & Katz 2007)) can guarantee that there are no type conflicts in an OWL ontology. A first-order reasoner can test an ontology in first-order logic in which more things can be stated than a description logic, but cannot guarantee to find all conflicts, due to first-order logic being semi-decidable. A first-order model-finder guarantees consistency if it finds a model, but the limitations of model-finders mean that it is only practical to attempt to analyze relatively small collections of formulas. A higher-order logic theorem-prover can attempt to validate yet more kinds of statements that are not expressible in less expressive logics, but performance of such systems is such that they are even less likely to find all contradictions that may exist.
the number of concepts, which may be broken down further into instances, classes and relationships
the number of formulas, and of which type, whether
- ground or not (the formula does not contain any variables)
- number of implications or disjunctions
- number of formulas containing a relation of a given arity (graphs and description logics are limited to binary relations)
- number of formulas requiring a given level of logical expressiveness, such as:
  - propositional (no variables)
  - description logic (classification/type reasoning)
  - first-order logic (quantification over terms only)
  - modal logic (and which particular modal-logic operators and supporting axioms)
  - higher-order logic (quantification over formulas)
- number of formulas including numbers and/or arithmetic expressions

Some ontologies may have lexical mappings for their terms such as to WordNet (Fellbaum 1998), in one or more human languages, so there could be a measurement of how many lexical mappings exist, and in how many languages.

For each of these measures, all others being equal, we may say that more is better.

Assessments may be also made as to non-technical characteristics, such as measurements of popularity, tool support, standards conformance, or licensing. Claims have often been made of the need to conform to some interpretation of an overarching philosophical principle, such as Realism (see the entry realism), Post-modernism and Relativism (see the entry on relativism), or Positivism (see the entries on logical empiricism and Auguste Comte).

8. Ontology and Large Language Models

Large Language Models (Jurafsky & Martin 2000) are a model of language but not of the world (Bender, Gebru, McMillan-Major, & Shmitchell 2021). When LLMs generate text that is clearly at odds with what humans know about the world it has been called (rather anthropomorphically) “hallucination”. One method that has been proposed to address this issue is to combine LLMs and logical reasoning in a neuro-symbolic approach (Hitzler & Sarker 2021). LLMs may be trained on symbolically-expressed knowledge (Chattopadhyay, Dandekar, & Roy 2025), and symbolic knowledge may be used in prompts (Lewis et al. 2020). LLMs may also be used to align terminological ontologies (Hertling & Paulheim 2023).

Most work in this area has been with ontologies expressed as knowledge graphs. This potentially encourages LLMs to conform to facts such as taxonomic relationships, measures such as the cost or number of something, or expressions of simple relationships such as physical parthood. Using ontologies defined in expressive logics would allow LLMs to conform to the more complex relationships inherent in the world, but it remains to be seen how this can be implemented.

9. Applications of Ontologies

An ontology can be used solely as a tool for ensuring common understanding of concepts, or it can be used for reasoning (or both). Some surveys of ontology use include Qaswar et al. 2022; Poli, Healy, & Kameas 2010; Uschold & Jasper 1999. Many ontologies have been developed as an independent product that forms a standard for vocabulary, rather than as part of a running computational system. Many ontologies are used in application only by their authors, to illustrate their value, rather than being motivated by solving a particular application need.

Some uses of ontologies in applications are for search (Suomela & Kekäläinen 2005), natural language processing (Bateman, Hois, Ross, & Tenbrink 2010; Behr, Völkenrath, & Kockmann 2023), Internet of Things applications (Qaswar et al. 2022) and engineering (Zheng et al. 2021). Biology is one application area that has seen considerable work on ontology development (Stevens & Lord 2009; Kramer & Beißbarth 2017). Implementations of such ontologies are often in the form of databases, and the positioning of such products as ontologies stems from the perspective of its authors rather than features of the product itself.

10. Future Directions

There is wide scope for further work in ontology, especially in developing ever larger and more formal theories for aspects of the world. Research at the most general levels of ontology in Computer Science is already starting to benefit from collaboration with what has been termed computational metaphysics (Kirchner, Benzmüller, & Zalta 2019; Fitelson & Zalta 2007). Research on formally specifying aspects of the physical world, such as Casati & Varzi 1999 and Casati & Varzi 1994, illustrates comprehensive formal axiomatizations that could be implemented computationally.

One example of fundamental work on formalizing ontology of an aspect of the physical world, for which there does not yet appear to be a computational theory, is a theory of substances or substance-like actions that define what properties are true of parts of stuff that are true of the whole, at a given level of decomposition. For example, when does a temporal slice of walking cease to be walking and start being just a stepping or a motion? When does a part of a cake stop being a cake and start to be a sugar molecule? What relationships or concepts would allow for stating these limits of granularity and determine how properties of the whole are held by its parts? To what degree are the granularities of a class true of its subclasses?

The notion of competency questions points to a direction for evaluating the computational capabilities of ontologies (Wiśniewski, Potoniec, Ławrynowicz, & Keet 2019; Bezerra, Freitas, & Santana da Silva 2013). This area of study attempts to collect questions that may be asked of ontologies to evaluate their degree of knowledge. The challenge is to develop a corpus containing a wide range of questions, and determine how such a corpus can be tested without having an ontology simply be written for the test. One large project that took this approach, at least to an extent, was Cohen et al. 1998.

While description logics are the most widely used family of languages for ontologies, future work may increasingly use more expressive logics, and the OWL family of logics has grown to include incrementally more expressive languages. The automated theorem-proving community has been standardizing more expressive logics and implementing them in automated theorem-provers (Sutcliffe 2024). It is possible that increasing numbers of projects in ontology may take advantage of that work.