The metatheory of ontology reuse

Abstract

The reuse of ontologies is critical to their value as a means of knowledge representation. Unfortunately, reuse also still poses a considerable challenge for the ontological community. One reason for this is the lack of a formal definition of reuse. How can we attempt to perform or even assist this sort of ontology design, if we have no clear understanding of what constitutes reuse, and what does not? In this work we aim to remedy this situation by providing a formal definition of the concepts of reuse and reusability: a metatheory of ontology reuse. Beyond providing a clear understanding of these concepts, part of the resulting definition is a characterization of the operations of reuse that can be leveraged to determine how a given ontology(s) may be reused to satisfy some specified requirements. This serves not only to provide direction for the task of reuse, but also to assess the implications of reusing an ontology(s). Collectively, the solutions presented in this paper provide an important foundation for ontology reuse.

Keywords

Ontology design development reuse

1. Introduction

There exist many approaches to reuse, formalized to various degrees, and yet there is no clear definition of what it means to develop an ontology via reuse, and precisely what this entails. This hinders the support we can provide, and the development of the field as a whole. How can we talk about or develop tools/techniques for reuse if we don’t necessarily share the same understanding? There are a variety of alternative approaches to knowledge representation, and part of what sets ontologies apart is that they provide a knowledge representation that is not only unambiguous but adaptable, shareable, and reusable. However, if ontologies are not reused with care, these benefits may be (intentionally or not) discounted. Worse still, if the benefits are mistakenly assumed, they may give rise to inconsistencies or unintended semantics. While there are certainly other aspects of reuse to consider, such as the search for and selection of an ontology to reuse, this work focuses solely on the task of reusing a particular ontology(s) after it has been chosen.

1.1. Motivation

The term ontology reuse can be used to describe the repeated implementation of a single ontology, e.g. with different software applications. It also describes the use of existing axioms as input for an ontology engineering activity; while examples of ontologies being imported or otherwise referenced in the design of other ontologies are readily found throughout the community, the meaning of reuse in this sense is not clear. There are those who might view reuse as being restricted to cases where the entire ontology is reused (i.e. imported) in the engineering process. Others might relax this requirement and allow for a less complete import, so long as all of the relevant semantics are included. Beyond this, we also find cases wherein an ontology is reused, but then modified in some way because it is “not quite right” for the requirements.

Consider for example, the reuse of a very large and well-known ontology such as the Semantic Sensor Network Ontology (SSN),1

¹
https://www.w3.org/TR/vocab-ssn/

the Ontology of Units of Measure (OM),2

http://www.wurvoc.org/vocabularies/om-1.6/

or the Process Specification Language (PSL) described by Grüninger (2009) (upper ontologies might make good examples here, too). Apart from their sheer size, these ontologies have other things in common: they are often owned or published by large organizations and they have widespread use within the ontology community. These qualities make the ontologies attractive for reuse. However, the very same qualities also present barriers, should the ontology engineer (the “reuser”) require changes to the ontology. Certainly, the ontology owners are within their rights to refuse a change – in particular one that disagrees with the intended and/or specified semantics. However, even in cases where an error may be recognized in the ontology, lobbying for and successfully implementing the change may prove difficult (or simply not worthwhile for the ontology engineer who has deadlines to consider). In a case of a disagreement of semantics, a natural response might be: “If you don’t agree with the semantics of the ontology, then it is not the one for you”. But what about the rest of the semantics that are agreed upon? Shouldn’t ontology designers be able to take advantage of this? Some shareability between the theories may still be possible – shouldn’t this be identified? If they were to duplicate those axioms that were agreed upon from the original theory, shouldn’t the creators of that ontology be credited? It is our view that a variety of approaches to reuse may be appropriate in different scenarios, and thus it is important not to overly restrict our view, in order to fully exploit its benefits.

1.2. Definitions for reuse: A key issue

It is clear that the open view of reuse we have advocated allows for the introduction of serious issues in the absence of a formal definition. Specifically, there may be instances where an ontology is said to be reused, but its semantics are in some way changed.

In cases where only part of an ontology is reused, and perhaps even modified, the relationship between the original ontology and the ontology resulting from this is unclear. This lack of clarity is an important, though perhaps sometimes subtle complication for any future use of the resulting ontology. To illustrate this, let us consider the following simple example: Alice is designing an OWL ontology to represent aspects of her local transit system. The W3C time ontology (OWL-Time)3

³
https://www.w3.org/TR/owl-time/

is a strong candidate for reuse in her design project. Unfortunately for Alice, OWL-Time allows for zero-duration intervals. Alice does not want to allow for any zero-duration intervals in her representation, however the rest of the ontology suits her needs perfectly. Another factor in play is that the OWL-Time ontology is widely used by many communities; Alice doesn’t want to miss out on the potential linked data and integration opportunities that this might lend itself to in the future. In the end, Alice reuses OWL-Time , but adds an axiom to require the Interval class to have a non-zero duration. Setting aside any questions of other approaches that Alice could have taken in her design (such criticisms pertain to the definition of reuse itself, and this will be discussed later), the result is that we now have (a) the original OWL-Time ontology, and (b) Alice’s ontology, which reuses OWL-Time with modified semantics.

How can some future user of Alice’s ontology know that an Interval cannot have a non-zero duration, and avoid any possible issues that might arise due to this? Only by careful inspection. A user with previous experience with OWL-Time would, understandably but incorrectly, assume an understanding of the semantics of time in Alice’s ontology without a detailed review of the axioms. This goes beyond impacting users’ understanding of the ontology but may also impact future efforts to integrate and align ontologies. This is a simple example for demonstration purposes, however it should be clear that similar, more complex scenarios could arise in practice. In such cases the changes made and the implications for the semantics may not be readily apparent. A well-defined metatheory provides the language to precisely specify any changes in order to avoid confusions and complications that might otherwise arise. It may be tempting to argue that such scenarios should simply not be documented as reuse. However, the original ontology and its manifestation in the new ontology will still share some semantics; to conceal reuse would have the undesirable effect of sacrificing all information regarding this shared semantics. Important information regarding the provenance of the axioms, and credit to the original sources would also be lost.

As alluded to in the previous example, a formal account of ontology reuse also plays a key role in characterizing the shareability of ontologies among systems. If two people claim that their own ontologies reuse the same ontology, there is some expectation that they will agree on the intended semantics of the terminology as axiomatized by the reused ontology. However, this is not the case when the ontology is being reused in different ways. Consider the example of reusing the DOLCE Ontology (Gangemi et al., 2002) – is the entire ontology being reused, or only some module? The latter case allows each person to use different axioms for concepts and relations that are outside of the modules being reused. Even if the two people are reusing the same modules, they may extend DOLCE in different ways – for example, one person may simply add new subclasses of existing classes in DOLCE while the other may provide additional axioms constraining the constitution relation. Without a formal characterization of reuse, we cannot make the distinctions that are required in this example.

Situations such as these raise a key question: What does it mean if one ontology is said to have reused another? What can we infer from this? To remedy this, we propose a metatheory of reuse; we characterize the ways in which it can occur and their implications. This provides a clear and precise understanding of reuse, and serves as a tool with which we can speak precisely about different instances of reuse.

1.3. Approach

We address these issues with several contributions. In Section 3 we derive a well-founded, formal definition for reuse from the notion of intended models. Through this definition, we define detailed reuse operations that completely characterize all possible cases of reuse. The properties of these operations are explored in Section 4. In Section 5 we discuss the implications of the metatheory; in particular, we describe how it may be applied to determine what operations were performed on any ontology that was reused. The definition provides a concrete understanding of what it means to reuse an ontology (or ontologies), as well as the necessary concepts to describe reuse at an effective level of detail. This serves to improve both our understanding of reuse and our ability to support it. This paper extends previous work by Katsumi and Grüninger (2016) with detailed results and an improved presentation of definitions. The reader is advised that a glossary of some relevant logical terms is provided for reference at the end of this paper.

2. Related work

Currently, we find no formal definition of ontology reuse accepted or even proposed within the community. Nearly all work pertaining to the task of reuse assumes some implicit definition of the reuse of an ontology; no effort is made, formal or otherwise, to provide further clarification of precisely what this entails. An exception to this is found in the sort of definition presented by Bontas et al. (2005), where the authors describe reuse as:

…the process in which available (ontological) knowledge is used as input to generate new ontologies.

This is a very broad definition, and its lack of specificity not only limits its usefulness but, we will argue later, is also inaccurate in its generality.

A similar, implicit definition may be found when reviewing the guidelines for reuse presented by Fernández-López et al. (2012), where the authors’ customizing activity (Activity 2) accounts for a wide range of loosely defined operations (pruning, enriching, translating, and adapting the selected ontology). Without any justification or precise definition of what these operations entail, it appears as though the authors also consider reuse to include any scenario in which an available ontology is used as an input in the development of a new one. Attempting to extract an implicit definition from other existing guidelines only reinforces that this vague definition is generally accepted by the community.

At best, we find that some more specific, related, and sometimes overlapping subtypes of reuse have been defined, such as merging and alignment (Noy and Musen, 1999), integration (Pinto and Martins, 2001; Gangemi et al., 1998), modular or ‘safe’ reuse (Grau et al., 2008), and the application of ontology patterns (Falbo et al., 2013). Even with the provision of examples and guidelines, these implicit definitions remain either vague or isolated to a specific type of reuse. No existing work has provided a concrete understanding of precisely what is, and what is not ontology reuse.

3. Defining reuse

In ontology design, we are attempting to create a set of axioms that captures some intended semantics of a set of concepts. Reuse is often conceptualized as a special case of design; intuitively, it refers to the task of taking some existing ontology(s) and manipulating it in some way in order to satisfy the design requirements. This observation is supported by existing, informal definitions of reuse.

In addition, there is an implicit condition which is often not stated as it is perhaps assumed as common sense – reuse can only be performed on a reusable ontology. To illustrate this with an example, consider the development of a finance ontology. It would be possible to take some existing anatomy ontology, and through some series of operations create the required finance ontology. However, if no remnants of the anatomy ontology are preserved in the finance ontology then we would not really want to consider such behaviour to be reuse. In fact, in such a case we may as well have developed the finance ontology from scratch. While manipulating an existing ontology is certainly a necessary part of reuse, it is not sufficient to define reuse. In order to define reuse, we first consider the notion of reusability in more detail and produce a formal definition. Following this, we define the different possible reuse operations, by which an ontology may be manipulated. The combination of the classification of operations and the condition of reusability will form the definition of reuse that we present here.

It is important to note that the work that follows is restricted in that it does not consider any signature translations of the ontology to be reused; in other words, we assume that the theories to be reused are axiomatized in the required signature, where applicable. This assumption is made in order to simplify the presentation of the definition, and while this may seem to be an oversimplification it is in fact quite reasonable. If an ontology has been selected for reuse, then the developer must at least implicitly observe some mappings between its signature and those of the requirements. It is then simple enough to satisfy the assumption of a shared signature through the application of these mappings between the signatures of the candidate and required theories. A straightforward process to accomplish this has in fact been suggested in previous work by Katsumi and Grüninger (2017). The definition presented here also assumes that no language translations are required; in other words the reused ontology(s) are in the same logical language as the ontology being developed. While not ideal, this is the norm in the current state and therefore a reasonable assumption to make.

Although we discuss the addition or removal of axioms, we view a theory as a set of sentences closed under logical implication. This is important to keep in mind while reviewing the material in the sections that follow.

A note on intended models. The foundation of our understanding of reusability is based on what we refer to as intended models. Before proceeding with our definition in the following section, it is important that we clarify some misconceptions and common questions about this concept.

This approach is unrealistic because you can’t possibly know all of the intended models; and if you have the intended models, then why are you developing the ontology? The role of intended models is to illustrate the concept of the explicit and implicit requirements that reside in the mind of the developer. We do not claim to have a complete characterization of the intended models, but these models exist in within the developer’s mind nonetheless. Some intended models may be partially characterized by rough axioms or competency questions: requirements that the developer is able to formalize to aid in his or her design. Others may only be revealed upon the developer’s recognition of some error: a model that the axioms allow that he recognizes as something undesirable, or conversely a model that he expects to be true in his theory but finds is precluded by the axioms.

What if you can’t axiomatize them? From a practical standpoint, we are focused on ontologies in first-order logic and OWL, therefore for our purposes we consider only elementary classes of models. In general, the intended models dictate the required logical language; while there certainly are classes of models that cannot be axiomatized in, say first-order logic, if these are in fact the required (intended) models, this simply signifies that FOL is not the appropriate language.

3.1. Reusability

A perspective on the goal of ontology design is that its aim is to develop a set of axioms that captures the intended models. It follows that to satisfy the requirements with existing theories, we should be reusing theories that in some way characterize one or more of the different domains of conceptual coverage. As discussed, a key distinction between reuse and traditional development is that with the concept of reuse there is an implicit constraint on the acceptable (re-) design of the axioms. Simply put, if we claim that some ontology(s) has been reused, we expect and in fact should require that some remnants of the original ontology remain in the resulting ontology. For any ontology T that is reused to satisfy a developer’s intended models (we denote these $M^{intended}$ ), the models of T must characterize at least some of the models of some part of $M^{intended}$ . We can restate this condition as saying at least some model(s) in $M^{intended}$ must map to a model(s) of T, or model(s) of a subtheory4

⁴
Note that we consider an ontology to be equivalent the logical closure of its set of axioms, i.e. a theory. We therefore use the term subtheory in the usual way in reference to an ontology (a theory), to refer to some weaker ontology, i.e. a ‘sub-ontology’.

of T. Depending on the nature of the ontology to be reused,

M^{intended}

may only map to some of the models of T as shown in Fig. 1 (i.e. if T is weaker than the required ontology). Note that we denote the models of an ontology T as

Mod (T)

Fig. 1.

If the ontology is weaker than required, the intended models (the dark shaded area) will only map to some of the models of its axiomatization. This and subsequent figures are adaptations of the depiction of intended models, originally from Guarino et al. (2009).

On the other hand, $M^{intended}$ may map to models outside of $Mod (T)$ , i.e. models of some subtheory of T; this may occur if T is either stronger or incomparable to the required ontology, as shown in Fig. 2 and Fig. 3, respectively.

Fig. 2.

If the ontology is stronger than required, the intended models (the dark shaded area) will map to models of a subtheory its axiomatization.

Fig. 3.

If the ontology is incomparable to the required ontology, the intended models (the dark shaded area) will only map to some of the models of a subtheory of its axiomatization.

Fig. 4.

Intuitively, if an ontology is reusable for some required ontology, we expect to find some part of it in the resulting ontology.

An additional factor to account for is that the class of intended models may characterize one or many different domains. For example, consider the design of an enterprise ontology: $M^{intended}$ will likely cover concepts of organizations, actors, dates, and so on. However, we do not necessarily expect to be able to reuse a single ontology that completely covers these enterprise-related concepts. More likely, we hope to find useful theories that contribute to the various required domains; we may reuse some ontology of time, another ontology of dates, and perhaps another ontology of organizations. In such cases, it is not all of $M^{intended}$ that maps in some way to T, but a reduct of $M^{intended}$ where the models are restricted so some sub-signature (e.g. only the time-related concepts). Similarly, there are cases where T may have a larger signature than that of the intended models. For example, in the design of our enterprise ontology we may reuse an ontology of time that is in fact part of a larger ontology for scheduling. In this case, the reduct of $M^{intended}$ maps to a reduct of the models of T. Therefore the diagrams that we have been considering do not necessarily capture mappings between the intended models and the models of the reused ontology, but the reducts of these models as shown more precisely in Fig. 4. To account for mismatches in the scope of the required and reused ontology’s concepts, we consider mappings between the reducts of the models. Thus $L_{1}$ may in fact be a sub-language (sub-signature) of the signature of the intended models, which we denote $σ (M^{intended})$ , and similarly $L_{2}$ may be a sub-language (sub-signature) of the candidate’s signature, which we denote $σ (T)$ .

Here, we extend the usual meaning of a reduct (denoted by $M |_{σ}$ ) of a single model, $M$ , to some sub-signature, σ, of its original signature to apply to an entire class of models. Formally, we denote this $Red (M, σ)$ , and define it as follows:

Definition 1.

The reduct of a class of models $M$ to some signature σ is defined as the class of structures consisting of the reducts of each model $M$ in $M$ to the signature σ: $\begin{matrix} Red (M, σ) = {N : N ≅ M |_{σ}, M \in M} \end{matrix}$

Collecting all of these observations, we can refine our intuitions to say more specifically that if an ontology T is reusable to satisfy $M^{intended}$ , then there must be a mapping from the reducts of $M^{intended}$ to reducts of models of $T^{'}$ , a subtheory of T with the same signature. Formally,

Definition 2.

T is reusable for $M^{intended}$ iff:

There is a mapping $π : Red (M^{intended}, σ_{1}) \to Red (Mod (T^{'}), σ_{2})$ such that:

$T^{'} \subseteq T$ ,

$σ (T^{'}) = σ (T)$ ,

$σ_{1} \subseteq σ (M^{intended})$ ,

$σ_{2} \subseteq σ (T^{'})$ ,

$M ≅ π (M)$ .

As an example, suppose each of the structures in $M^{intended}$ is the amalgamation of a linear ordering of timepoints and a mereology on physical objects. We can use the definition to show that the PSL-Core Ontology (Menzel and Grüninger, 2001) is reusable for $M^{intended}$ . If $M$ is a model of PSL-Core, the reduct of $M$ to the signature timepoint is a linear ordering with endpoints at infinity. There exists a module $T_{psl_time}$ 5

⁵

colore.oor.net/psl_time/psl_time.clif

of PSL-Core that axiomatizes this class of structures, and a subtheory

T^{'}

of PSL-Core contains a module that axiomatizes the class of linear orderings. We can see that for each reduct of a structure in

M^{intended}

to the signature timepoint, there exists a model

N

T^{'}

such that

M ≅ N

It is straightforward to extend this definition to apply to a collection of ontologies; the same intuition applies:

Definition 3.

For a set of ontologies, $T_{1}, \dots, T_{n}$ , we say that the set $T_{1}, \dots, T_{n}$ is reusable for $M^{intended}$ iff each $T_{i}$ is reusable for $M^{intended}$ .

The notion of reusability can be captured similarly, from the perspective of the theories’ axiomatizations. Note that owing to our definition of an ontology being the logical closure of a set of axioms, the ⊆ symbol denotes a subtheory as opposed to simply a subset of axioms. We use $Th (M)$ to denote the axiomatization of a class of models $M$ .

Theorem 1.

A set of ontologies $T_{1}, \dots, T_{n}$ is reusable for $M^{intended}$ iff $Th (M^{intended})$ contains non-trivial subtheories of $T_{1}, \dots, T_{n}$ .

Proof.

⇒

By Definition 3, if the set of ontologies $T_{1}, \dots, T_{n}$ is reusable for $M^{intended}$ , then for each $T_{i}$ , $i = 1, \dots, n$ , we must have:

some $R_{i} \in Red (M^{intended}, σ_{1})$ where $σ_{1} \subseteq σ (M^{intended})$ , and

some $N_{i} \in Red (Mod (T_{i}^{'}), σ_{2})$ where $T_{i}^{'} ⩽ T_{i}$ and $σ_{2} \subseteq σ (T_{i})$ , and

$π_{i} (R_{i}) ≅ N_{i}$

Since we are assuming that the mapping does not alter the signature of the models (in this simplified presentation we assume that no logic- or signature-translations are required), observe that we must have: $\begin{array}{l} Th (R_{i}) ⊧ Th (N_{i}) so that \\ \to Th (N_{i}) \subseteq Th (R_{i}) \end{array}$ By definition of a reduct, the axiomatization of a reduct of some class of models $Th (Red (M, σ))$ must be a subtheory of the axiomatization of that class of models $Th (M)$ , therefore: $\begin{array}{l} Th (N_{i}) \subseteq T_{i}^{'} \subseteq T_{i} and \\ Th (R_{i}) \subseteq Th (M^{intended}) \end{array}$ Therefore, for each $T_{i}$ , $i = 1, \dots, n$ we have some $Th (N_{i})$ that is a subtheory of both $T_{i}$ and $Th (M^{intended})$ .

⇐

For each $T_{i}, i = 1, \dots, n$ we have some $T_{i}^{'}$ s.t. $\begin{matrix} T_{i}^{'} \subseteq T_{i} and T_{i}^{'} \subseteq Th (M^{intended}) \end{matrix}$ It follows that: $\begin{matrix} M^{intended} \subseteq Mod (T_{i}^{'}) . \end{matrix}$ And trivially, for any reduct of $M^{intended}$ : $\begin{matrix} Red (M^{intended}, σ_{1}) \subseteq M^{intended} \subseteq Mod (T_{i}^{'}), for some σ_{1} \subseteq σ (M^{intended}) \end{matrix}$ Thus there is a mapping $\begin{matrix} π : Red (M^{intended}, σ_{1}) \to Mod (T_{i}^{'}) \end{matrix}$ And thus to some reduct of $T_{i} : Red (Mod (T_{i}), σ_{2})$ where $σ_{2} = σ (T_{i}^{'})$ : $\begin{matrix} π : Red (M^{intended}, σ_{1}) \to Red (Mod (T_{i}^{'}), σ_{2}) . \end{matrix}$ □

3.2. Classification of reuse operations

While it is tempting to interpret Theorem 1 as a definition of reuse, it would be inaccurate to do so. Certainly, for any ontology that has been reused, we expect that it must have been reusable and thus we expect the results of reuse are captured by Theorem 1. In fact, the theorem captures the basic intuition of reuse that motivated the definition of reusability: in order for design to qualify as reuse, we expect some remnants of the original ontology(s) to remain. However, reusability is a necessary but not sufficient condition for reuse. There is an extralogical condition that must be accounted for in order to completely capture what it means to reuse an ontology. Unlike reusability, reuse is not a static property between theories; reuse refers to an act that is performed with some existing theories, in the design of an ontology. Simply because an ontology is reusable for some intended models does not mean it will or has been reused to axiomatize those models.

Informally, reuse is the act of applying some operations to a given, reusable ontology(s), such that the final result axiomatizes the intended models. To formally define reuse, these operations must be completely identified and defined. While various approaches to reuse, such as ontology fusion, merging, and extension, have been identified in varying degrees of detail in the current state, none of these approaches have been defined with respect to a complete definition of reuse; in some cases they have not been defined formally at all. Here, we provide a precise definition for a set of operations that completely covers the possible approaches to reuse. The terms used here should be interpreted independently of those that have been identified in the literature. No relationships should be inferred or assumed due to a similarity of terms or descriptions.

There are 4 distinct reuse operations by which an ontology may be manipulated for reuse: as_is, extraction, extension, and combination. These operations are natural and fairly obvious approaches to manipulating an ontology; the focus here is on the way in which we define them, and the subsequent analysis they are capable of supporting.

The first two operations address the sort of do-nothing operation, and the operation to remove axioms from an ontology. Extension and combination are operations to add axioms to an ontology; the way that this occurs depends on the source of the axioms – they could be new axioms, created during design by the ontology developer, or they could be existing axioms, reused from some other ontology. It is important to make this distinction because these differences affect the way in which reuse is carried out. If the axioms were reused from another ontology, the design work is minimal, however if they are new axioms then the developer must have invested some time to design them from-scratch. This distinction between these two types of axiom addition also has potential implications for the shareability of the resulting theory. If the additional axioms were reused from some other ontology it may indicate that shareability will also be supported with this ontology; at the very least it indicates that shareability is something that should be considered and addressed in the metadata. We formalize this distinction by considering whether the additional axioms may be found in some repository. If axioms are added to one ontology (by reuse of axioms) from another ontology, then a combination has occurred. Otherwise, the addition is simply an extension of the ontology with additional axioms. We make reference to a single repository for simplicity, however it is straightforward to see that the definition and subsequent results also apply for any number of repositories or other sources of ontologies.

Fig. 5.

Intuition behind the specialized extraction operations. $T^{-}$ (depicted with dotted lines) represents the part of the theory T being removed, with the remainder being reused. The individual circles represent modules of T.

Fig. 6.

Intuition behind the specialized extension operations, where $T^{+}$ (depicted with dotted lines) represents the theory being added and the individual circles represent modules of T. Combination is similar.

For each of these general operations (with the exception of as_is), we identify three specialized operations based on a more precise identification of the changes that result, relative to the original ontology. Diagrams shown in Figs 5 and 6 illustrate the intuition behind the specialized operations for extraction and extension, respectively. These specialized operations have been defined in a strategic way so as to be able to describe any case of reuse, in a way that clearly identifies the implications of any changes that were made.

For the definitions that follow, let $T$ be the set of all consistent, first-order theories, and let $S$ be an ontology repository, which we consider to be some set of ontologies. Note that this notion of an ontology repository is weaker than the definition given by Grüninger et al. (2012). This is due to the fact that the results given here do not depend on the use of hierarchies and their organization, we simply require that a repository exists and contains at least one ontology.

3.2.1. as_is

$as_is$ refers to a null operation. This corresponds to the reuse of an ontology directly, with no modifications of any sort. In this sense, it is analogous to an identity function and we consider it to be a trivial operation.

Definition 4.
The $as_is$ operation is a mapping $\begin{matrix} as_is : T \to T \end{matrix}$ such that for any $T \in T$ , $\begin{matrix} as_is (T) = T \end{matrix}$

3.2.2. Extraction

Extraction refers to the reuse of an ontology via a removal of some of the original axioms, where the removed theory is denoted by $T^{-}$ . Intuitively, the reused theory is then the “difference” between T and $T^{-}$ . In order to preclude the extraction of axioms that do not exist in a particular theory (e.g. the extraction of $T^{-}$ from T where $T \subset T^{-}$ ), this operation is a partial mapping between two arbitrary theories.

Definition 5.
The $extraction$ operation is a partial mapping $\begin{matrix} extraction : T \times T \to T \end{matrix}$ such that $extraction (T, T^{-})$ is the theory that is the closure of $A x (T) ∖ A x (T^{'})$ under logical consequence, where $A x (T)$ is an axiomatization of T and $A x (T^{-})$ is an axiomatization of $T^{-}$ such that $A x (T^{-}) \subseteq A x (T)$ .

We identify the following three specializations of the extraction operation:

Domain Extraction: an entire domain (set of concepts) is completely extracted from the original ontology.
Definition 6.
The $domain_extraction$ operation is a partial mapping $\begin{matrix} domain_extraction : T \times T \to T \end{matrix}$ such that $\begin{matrix} domain_extraction (T, T^{-}) = extraction (T, T^{-}) \end{matrix}$ where $σ (T^{-}) \cap σ (extraction (T, T^{-})) = \emptyset$ .

Note that T conservatively extends $domain_extraction (T, T^{-})$ .

Examples of domain extraction are quite common, and are closely related to the idea of extracting and reusing a maximal module $T^{-}$ of a given ontology T (Doran et al., 2007; Konev et al., 2009; Grau et al., 2008). Specifically, $domain_extraction (T, T^{-})$ is the result of removing the module $T^{-}$ from T. Figure 5(b) depicts an example of domain extraction, where module $T_{i}$ is extracted and the rest of the ontology is reused.

Weakening Extraction: the semantics of the original ontology are weakened by the operation while its scope remains the same.
Definition 7.
The $weakening_extraction$ operation is a partial mapping $\begin{matrix} weakening_extraction : T \times T \to T \end{matrix}$ such that $\begin{matrix} weakening_extraction (T, T^{-}) = extraction (T, T^{-}) \end{matrix}$ where $σ (extraction (T, T^{-})) = σ (T)$ .

Note that T non-conservatively extends $weakening_extraction (T, T^{-})$ . Examples of this kind of reuse can be found among the timepoint ontologies by Van Benthem (1983) and Hayes (1996); in particular, we can consider the timepoint ontology $T_{lp_ordering}$ 6
⁶
colore.oor.net/timepoints/lp_ordering.clif

to be the weakening extraction of the axioms for the linear ordering over timepoints from the timepoint ontology $T_{lp_discrete}$ .7
⁷
colore.oor.net/timepoints/lp_discrete.clif

Figure 5(c) depicts an example of weakening extraction where the dotted line represents $T^{-}$ : the part of the ontology that is removed before it is reused. Notice that here it is not an isolated module, but a subtheory such that the resulting concepts will have a weaker semantics.

Residue Extraction: the residue of the theory is extracted. The term residue is used in the formal, logical sense as defined in the Glossary.
Definition 8.
The $residue_extraction$ operation is a partial mapping $\begin{matrix} residue_extraction : T \times T \to T \end{matrix}$ such that $\begin{matrix} residue_extraction (T, T^{-}) = extraction (T, T^{-}) \end{matrix}$ where $T^{-}$ is the residue of T.

Note that T conservatively extends $residue_extraction (T, T^{-})$ .

Examples of residue extraction arise from reuse with weakly reducible ontologies, which have nonempty residues. The time interval ontologies discussed by Gruninger and Ong (2011) are the axiomatization of different ontological commitments for time intervals proposed by Van Benthem (1983). Applying the residue_extraction operation to these ontologies returns the module that axiomatizes the semilinear ordering of the precedence relation and the module that axiomatizes the mereology of the inclusion relation. Figure 5(d) depicts an example of residue extraction. Notice that in this case, the part of the theory being removed before reuse (outlined in dotted lines) is the part of the theory that is i contained in any of its individual modules. Therefore, what is reused after residue extraction is only the modules $T_{i}, \dots, T_{n}$ .

Observe the specialized operations are completely distinct in that no one specialized operation may be defined in terms of either of the other specialized operations. $weakening_extraction$ and $domain_extraction$ are clearly disjoint as a result of the constraint on their signatures. Further, no part of any $residue_extraction$ may be defined by a $weakening_extraction$ or a $domain_extraction$ . This follows from the definition of a residue (see Glossary), since both $weakening_extraction$ or a $domain_extraction$ refer to the extraction of a subtheory of some module of T.
3.2.3. Extension

Extension refers to the reuse of an ontology via the creation and introduction of new axioms, denoted by $T^{+}$ . It is a mapping between an arbitrary theory and one not in a repository

Definition 9.
Let $S$ be an ontology repository.

The $extension$ operation is a mapping $\begin{matrix} extension : T \times (T ∖ S) \to T \end{matrix}$ such that $\begin{matrix} extension (T, T^{+}) = T \cup T^{+} \end{matrix}$

Thus $extension (T, T^{+})$ is the extension of the theory T with the theory $T^{+}$ .

We identify the following three specializations of the extension operation:

Domain Extension: the original ontology is extended via a new set of axioms $T^{+}$ created by the developer, in a completely new (distinct) domain.
Definition 10.
Let $S$ be an ontology repository.

The $domain_extension$ operation is a mapping $\begin{matrix} domain_extension : T \times (T ∖ S) \to T \end{matrix}$ such that $\begin{matrix} domain_extension (T, T^{+}) = extension (T, T^{+}) \end{matrix}$ where $σ (T) \cap σ (T^{+}) = \emptyset$ .

Note that $domain_extension (T, T^{+})$ conservatively extends T.

One can consider the PSL-Core Ontology8
⁸
colore.oor.net/pslcore.clif

to be a domain extension of the timepoint ontology $T_{lp_infinite_end}$ , in which the additional axioms are in the domain of activities and activity occurrences. Domain extension is depicted in Fig. 6(b), where $T_{k}$ is added and is an independent module from the original theory.

Strengthening Extension: the original ontology is extended via a new set of axioms $T^{+}$ created by the developer, such that its semantics are strengthened while maintaining its scope.
Definition 11.
Let $S$ be an ontology repository.

The $strengthening_extension$ operation is a mapping $\begin{matrix} strengthening_extension : T \times (T ∖ S) \to T \end{matrix}$ such that $\begin{matrix} strengthening_extension (T, T^{+}) = extension (T, T^{+}) \end{matrix}$ where $σ (T^{+}) \subseteq σ (T)$ .

Note that $strengthening_extension (T, T^{+})$ non-conservatively extends a module of T.

Strengthening extension is often found when reuse of one theory leads to unintended models. For example, the central result of work by Muñoz and Grüninger (2016) is the verification of a nonconservative extension of SUMO-Time; that is, SUMO-Time was extended to a new ontology $T_{sumo_ordered_timepoints} \cup T_{sumo_timeintervals}$ that is logically synonymous with the mathematical ontologies: $\begin{matrix} T_{bounded_linear_ordering}^{9} \cup T_{strict_graphical}^{10} \end{matrix}$
⁹
http://colore.oor.net/orderings/bounded_linear_ordering.clif

¹⁰
http://colore.oor.net/bipartite_incidence/strict_graphical.clif

Without the additional axioms, this aforementioned Theorem cannot be proven, and this is equivalent to saying that there are unintended models of SUMO-Time. In this way, the verification of SUMO-Time by Muñoz and Grüninger (2016) led to the identification of three classes of unintended models – models with a unique timepoint, models with partially ordered sets of timepoints (rather than linearly ordered sets), and models in which time intervals are temporal parts of timepoints. Three new axioms were proposed to eliminate these unintended models, and then the extended theory $T_{sumo_ordered_timepoints} \cup T_{sumo_timeintervals}$ was verified. Strengthening extension is depicted in Fig. 6(c), where $T^{+}$ strengthens the semantics of $T_{i}$ , within its original scope.

Residue Extension: the original ontology is extended via a new set of axioms $T^{+}$ created by the developer, where $T^{+}$ is the residue of $T \cup T^{+}$ .
Definition 12.
Let $S$ be an ontology repository.

The $residue_extension$ operation is a mapping $\begin{matrix} residue_extension : T \times (T ∖ S) \to T \end{matrix}$ such that $\begin{matrix} residue_extension (T, T^{+}) = extension (T, T^{+}) \end{matrix}$ where $T^{+}$ is the residue of $T \cup T^{+}$ .

Note that $residue_extension (T, T^{+})$ non-conservatively extends T.

Examples of residue extension can be seen in the Periods Hierarchy11
¹¹
colore.oor.net/periods

of COLORE, particularly between the two ontologies $T_{periods_root}$ and $T_{periods}$ ; the latter extends the former with the axiom $\begin{matrix} (\forall x, y, z) precedence (x, y) \land inclusion (z, y) \supset precedence (x, z) \end{matrix}$ which is in the signature of the residues of the two ontologies.

Observe that the specialized operations are completely distinct in that no one specialized operation may be defined in terms of either of the other specialized operations. $domain_extension$ and $strengthening_extension$ are clearly disjoint as a result of the constraint on their signatures. Further, no part of any $residue_extension$ may be defined by a $strengthening_extension$ or a $domain_extension$ . This follows from the definition of a residue, since both $strengthening_extension$ or a $domain_extension$ refer to the extension of some module of $T \cup T^{+}$ , and the residue cannot be contained in any module. Residue extension is depicted in 6(d) where the theory $T^{+}$ that is added is not part of any proper module of the resulting theory (i.e. $T_{i}, \dots, T_{n}$ remain the only proper modules).
3.2.4. Combination

Combination is the reuse of an ontology $T_{1}$ via the addition of another reused ontology(s), denoted $T_{2}$ . Combination is a mapping between an arbitrary theory and a theory in a repository.

Definition 13.
Let $S$ be an ontology repository.

The $combination$ operation is a mapping $\begin{matrix} combination : T \times S \to T \end{matrix}$ such that $\begin{matrix} combination (T_{1}, T_{2}) = T_{1} \cup T_{2} \end{matrix}$

We identify the following three specializations of the combination operation:

Domain Combination: The original ontology T is combined with another ontology $T_{2}$ that defines a completely distinct domain.
Definition 14.
Let $S$ be an ontology repository.

The $domain_combination$ operation is a mapping $\begin{matrix} domain_combination : T \times S \to T \end{matrix}$ such that $\begin{matrix} domain_combination (T, T_{2}) = combination (T, T_{2}) \end{matrix}$ where $σ (T) \cap σ (T_{2}) = \emptyset$ .

Note that $domain_combination (T, T_{2})$ conservatively extends T and $T_{2}$ .

Domain combination arises most prominently with reducible theories and the design of upper ontologies using the sideways approach (Grüninger et al., 2014, 2017), in which generic ontologies in domains such as time, process, mereotopology, and physical objects are combined.

Strengthening Combination: The original ontology T is combined with another ontology $T_{2}$ that defines the same domain, such that their semantics are strengthened while maintaining the original scope.
Definition 15.
Let $S$ be an ontology repository.

The $strengthening_combination$ operation is a mapping $\begin{matrix} strengthening_combination : T \times S \to T \end{matrix}$ such that $\begin{matrix} strengthening_combination (T, T_{2}) = combination (T, T_{2}) \end{matrix}$ where $σ (T_{2}) \subseteq σ (T)$ .

Note that $strengthening_combination (T, T_{2})$ non-conservatively extends T and $T_{2}$ .

Residue Combination: The original ontology T is combined with another ontology $T_{2}$ , where $T_{2}$ is the residue of $T \cup T_{2}$ .
Definition 16.
Let $S$ be an ontology repository.

The $residue_combination (T, T_{2})$ operation is a mapping $\begin{matrix} residue_combination : T \times S \to T \end{matrix}$ such that $\begin{matrix} residue_combination (T, T_{2}) = combination (T, T_{2}) \end{matrix}$ where $T_{2}$ is the residue of $T \cup T_{2}$

Note that $residue_combination (T, T_{2})$ non-conservatively extends T and $T_{2}$ . Also observe the specialized operations are completely distinct in that no one specialized operation may be defined in terms of either of the other specialized operations. $domain_combination$ and $strengthening_combination$ are clearly disjoint as a result of the constraint on their signatures. Further, no part of any $residue_combination$ may be defined by a $strengthening_combination$ or a $domain_combination$ . This follows from the definition of a residue, since both $strengthening_combination$ or a $domain_combination$ refer to the extension of some module of $T \cup T_{2}$ , and the residue cannot be contained in any module.

Again, consider the definition of reuse – this time based on the reuse operations that have just been defined. Such a definition appeals to our intuition: reuse is the application of some set of reuse operations; however the act of reuse cannot be defined via these operations alone. It is not the case that any set of these operations corresponds to an act of reuse. For example, consider a scenario in which we extract a subtheory from some existing ontology, extend it with some new axioms, and then perhaps extract a subtheory again, such that no remnants of the original theory remain. This violates a key condition for reuse that is captured in the definition for reusability. We cannot have such possibilities included within the definition of reuse. To completely define what we mean by reuse, we must incorporate both the logical conditions identified previously and the extralogical conditions of the operations performed. Reuse is defined as the act of performing some set of operations on some existing ontology(s) $T_{1}, \dots, T_{n}$ 12
¹²
Note that we use the term ontology in a broad sense – this work includes the possibility that $T_{1}, \dots, T_{n}$ are some combination not only of whole ontologies being reused, but perhaps modules of ontologies, an upper ontology(s), or even ontology patterns.

that is reusable for some $M^{intended}$ , in order to transform $T_{1}, \dots, T_{n}$ to $Th (M^{intended})$ . Formally,
Definition 17.
$T_{1}, \dots, T_{n}$ are reused for $M^{intended}$ iff
$T_{1}, \dots, T_{n}$ are reusable for $M^{intended}$ , and

some set of reuse operations applied to $T_{1}, \dots, T_{n}$ axiomatizes $M^{intended}$ .

The sections that follow explore the ramifications of this definition and the transparency it provides for the task of reuse.
4. Properties of reuse operations

The metatheory of reuse defines specialized operations with a precision such that their effect on the preservation of semantics of the original theory is clear. It also provides a foundation upon which we may identify and prove useful properties about the operations; several such properties are presented in the following sections.

4.1. Commutativity

While it is intuitive to consider reuse as the application of a sequence of these operations, so long as an ontology or set of ontologies $T_{1}, \dots, T_{n}$ is reusable for $Th (M^{intended})$ the order in which reuse operations are applied does not effect the final result. The order may be of some importance in maintaining consistency throughout the series of operations, however this is not a requirement of design.

Theorem 2.
The operations for reuse are commutative.
Proof.
To illustrate this, we consider each pairing of reuse operations and show that either order of application produces the same results. It is clear that like-operations will achieve the same result in any order, therefore we consider only pairings of different operations. It is straightforward to see that this then extends to any series of operation applications. as_is and extraction
Consider the application of as_is to some T, followed by extraction of some $T^{-}$ .

By definition, $as_is (T) = T$ , thus this can be expressed simply as: $extraction (T, T^{-})$ . Similarly, the application of some extraction followed by as_is reuse can be expressed as: $extraction (T, T^{-})$ . From the definition of as_is, commutativity is trivial.
as_is and extension
Similar to above, from the definition of as_is the result is trivial.
as_is and combination
Similar to above, from the definition of as_is the result is trivial.
extraction and extension
Consider the application of extraction of some $T^{-}$ to some T, followed by extension with some $T^{+}$ . This can be expressed as: $extraction (T, T^{-}) \cup T^{+}$ . Similarly, some $extension$ of T followed by an extraction can be expressed as: $extraction ((T \cup T^{+}), T^{-})$ . Therefore, to prove that extraction and extension are commutative operations we must show that $extraction (T, T^{-}) \cup T^{+} = extraction ((T \cup T^{+}), T^{-})$ .

Consider $extraction (T, T^{-})$ .

It is straightforward to see that the removal of any subtheory of T (i.e. an extraction) results in a subtheory of T: $extraction (T, T^{-}) \subset T$ .

Now, say we add some theory to the extraction of T and to T. It is straightforward to see that the extraction, with some addition, will also be a subtheory of T, with the same addition, so that $extraction (T, T^{-}) \cup T^{+} \subset T \cup T^{+}$ .

Likewise, any subtheory that we remove from both sides cannot affect this relationship; at most we can reduce $T \cup T^{+}$ such that it is equivalent to $T ∖ T^{-} \cup T^{+}$ , we cannot possibly to reverse the subsumption relationship through extraction. Therefore, if we perform an extraction of $T^{-}$ again on both sides we obtain: $extraction (T, T^{-}) \cup T^{+} \subseteq extraction ((T \cup T^{+}), T^{-})$ .

Now, consider $T \cup T^{+}$ .

It is straightforward to see that any extension of T subsumes T itself: $T \cup T^{+} \supset T$ .

This subsumption relationship will be maintained, with the possibility of equivalence, should any subtheory be removed from both sides: $extraction ((T \cup T^{+}), T^{-}) \supseteq extraction (T, T^{-})$ .

Again, any subtheory added to both sides will maintain the subsumption relationship will be maintained. Adding $T^{+}$ yields: $extraction ((T \cup T^{+}), T^{-}) \supseteq extraction (T, T^{-}) \cup T^{+}$ .

Since we have shown: $extraction ((T \cup T^{+}), T^{-}) \supseteq extraction (T, T^{-}) \cup T^{+}$ and $extraction (T, T^{-}) \cup T^{+} \subseteq extraction ((T \cup T^{+}), T^{-})$ then we must have: $extraction (T, T^{-}) \cup T^{+} = extraction ((T \cup T^{+}), T^{-})$ .
extraction and combination
The result is the same as above, except instead of $T^{+}$ , we have $T_{2}$ representing any possible theory that will be combined with T.
extension and combination
It is trivial to see that: $(T \cup T^{+}) \cup T_{2} = (T \cup T_{2}) \cup T^{+}$ .
□

4.2. Necessary operations

Observe that there are not only different possible sequences but in fact many different sets of operations that achieve the same result. Such sets may be differentiated through redundant or unnecessary operations. For example, consider repeated applications of extension and extraction operations that add and remove the same axioms. This may seem bizarre, but consider a design scenario where one approach is attempted, only to find it does not have the desired effect and it is therefore undone or modified in a subsequent step. In some instances, it may be useful to distinguish those operations that are necessary to achieve the reuse of a particular theory(s) for some $M^{intended}$ , and those that are simply allowed by the definition of reuse.

A necessary operation for reuse is defined with respect to a particular set of operations applied to $T_{1}, \dots, T_{n}$ to axiomatize $M^{intended}$ .

Definition 18.
Let $X$ be a set of reuse operations applied to some ontology(s) $T_{1}, \dots, T_{n}$ to axiomatize $M^{intended}$ . A non-trivial reuse operation x is a necessary operation for the reuse of ontology(s) $T_{1}, \dots, T_{n}$ to axiomatize $M^{intended}$ iff any subset $X^{'}$ of the set of operations $X$ applied to $T_{1}, \dots, T_{n}$ to axiomatize $M^{intended}$ contains x.

$x \in X^{'}$ for all $X^{'} \subset X$ , where $X^{'}$ applied to $T_{1}, \dots, T_{n}$ axiomatizes $M^{intended}$ .

4.3. Completeness of specialized operations

Each reuse operation may be completely defined by its specialized operations. In other words, there exists no instance of reuse that cannot be described by some combination of specialized reuse operations. The proofs for each general reuse operation follow.

Lemma 1.
Domain extraction, weakening extraction, and weakening domain extraction are the only ways in which reuse via extraction can occur.
Proof.
Let $S_{1}$ be the maximal subtheory (module) of $T^{-}$ that is definable in $σ (T)$ . Its signature must therefore be contained in the signature of T. $\begin{array}{l} S_{1} \subseteq T^{-} \\ σ (S_{1}) \subseteq σ (T) \end{array}$

By definition, if $S_{1}$ is non-empty then $extraction (T, S_{1}) = weakening_extraction (T, S_{1})$ .

Let $S_{2}$ be the maximal subtheory (module) of $T^{-}$ that is definable outside of $σ (T)$ . In other words, its signature must be disjoint with that of T. $\begin{array}{l} S_{2} \subseteq T^{-} \\ σ (S_{2}) = σ (T \cup T^{-}) ∖ σ (T) \\ σ (S_{2}) \cap σ (T) = \emptyset \end{array}$ By definition, if $S_{2}$ is non-empty then $\begin{matrix} extraction (extraction (T, S_{1}), S_{2}) = domain_extraction (extraction (T, S_{1}), S_{2}) \end{matrix}$

Let $S_{3}$ be the leftover of $T^{-}$ , in other words, the subtheory not in $S_{1}$ or $S_{2}$ . $\begin{matrix} S_{3} = extraction (T^{-}, (S_{1} \cup S_{2})) . \end{matrix}$ By definition, since $extraction (T, S_{1})$ is the maximal extraction of the module of T in the signature $σ (T)$ , and $extraction (T, S_{2})$ is the maximal extraction of the module of T in the signature $σ (T \cup T^{+}) ∖ σ (T)$ , $S_{3}$ must be the residue of T since there can be no subtheory of $S_{3}$ in either of the maximal modules of T.

By definition, if $S_{3}$ is non-empty then $\begin{array}{l} extraction (extraction (extraction (T, S_{1}), S_{2}), S_{3}) \\ = residue_extraction (extraction (T, extraction (S_{1}, S_{2}), S_{3})) . \end{array}$ Therefore, we have: $\begin{array}{l} extraction (extraction (extraction (T, S_{1}), S_{2}), S_{3}) \\ = residue_extraction (domain_extraction (weakening_extraction (T, S_{1}), S_{2}), S_{3}) \end{array}$ □
Lemma 2.
For any T, $T^{+}$ the reuse operation $extension (T, T^{+})$ is definable by some set of its specialized operations: $strengthening_extension$ , $domain_extension$ , and/or $residue_extension$ .
Proof.
For any T, $T^{+}$ the reuse operation $extension (T, T^{+}) = T \cup T^{+}$ .

Let $S_{1}$ be the maximal subtheory (module) of $T^{+}$ that is definable in $σ (T)$ . Its signature must therefore be contained in the signature of T. $\begin{array}{l} S_{1} \subseteq T^{+} \\ σ (S_{1}) \subseteq σ (T) \end{array}$ By definition, if $S_{1}$ is non-empty then $extension (T, S_{1}) = strengthening_extension (T, S_{1})$ .

Let $S_{2}$ be the maximal subtheory (module) of $T^{+}$ that is definable outside of $σ (T)$ . In other words, its signature must be disjoint with that of T. $\begin{array}{l} S_{2} \subseteq T^{+} \\ σ (S_{2}) = σ (T \cup T^{+}) ∖ σ (T) \\ σ (S_{2}) \cap σ (T) = \emptyset \end{array}$ By definition, if $S_{2}$ is non-empty then $extension (T \cup S_{1}, S_{2}) = domain_extension (T \cup S_{1}, S_{2})$ .

Let $S_{3}$ be the leftover of $T^{+}$ , in other words, the subtheory not in $S_{1}$ or $S_{2}$ . $\begin{matrix} S_{3} = extraction (T^{+}, (S_{1} \cup S_{2})) \end{matrix}$ By definition, since $S_{1} \cup T$ is the maximal module of $T \cup T^{+}$ in the signature $σ (T)$ , and $S_{2}$ is the maximal module of $T \cup T^{+}$ in the signature $σ (T \cup T^{+}) ∖ σ (T)$ , $S_{3}$ must be the residue of $T \cup T^{+}$ since there can be no subtheory of $S_{3}$ in either of the maximal modules of $T \cup T^{+}$ .

By definition, if $S_{3}$ is non-empty then $extension (T \cup S_{1} \cup S_{2}, S_{3}) = residue_extension (T \cup S_{1} \cup S_{2}, S_{3})$ .

Therefore, we have: $\begin{array}{l} extension (T, T^{+}) \\ = S_{1} \cup S_{2} \cup S_{3} \\ = extension (extension (extension (T, S_{1}), S_{2}), S_{3}) \\ = residue_extension (domain_extension (strengthening_extension (T, S_{1}), S_{2}), S_{3}) \end{array}$ □
Lemma 3.
Domain combination, strengthening combination, and strengthening domain combination are the only ways in which reuse via combination can occur.
Proof.
The proof for this lemma follows precisely the same form as the proof for Lemma 2 with the minor distinction that rather than $T^{+}$ we are considering some $T_{2}$ from some repository $S$ . □

4.4. Validation of reuse operations

The reuse operations defined not only help to identify the sorts of manipulations that may be performed, they provide a complete characterization of the possible ways in which an ontology(s) may be reused; through this they provide concrete examples of what is, and what is not reuse.

Theorem 3.
Let $S$ be some ontology repository, and let $T_{1}, \dots, T_{n}$ be some ontologies in $S$ . If $T_{1}, \dots, T_{n}$ are reusable for $M^{intended}$ , then there exists some set of reuse operations that can be applied to $T_{1}, \dots, T_{n}$ to axiomatize $M^{intended}$ .
Proof.
Assume the theorem is false. Then we must have some $T_{1}, \dots, T_{n}$ reused for $M^{intended}$ that cannot be axiomatized with some sequence of the reuse operations.

There are 2 possible cases: reuse of a single theory or reuse of multiple theories.

Case 1: reuse of a single theory $n = 1$ i.e. a single theory T is reused for $Th (M^{intended})$ .

By definition, if T is reused for $Th (M^{intended})$ then T is reusable for $M^{intended}$ and by Theorem 1:

There exists a $T^{'}$ s.t. $T^{'} \subseteq T$ and $T^{'} \subseteq Th (M^{intended})$ .

It is straightforward to see that in this case one of the following 4 situations must be true:
$T^{'} \subset T$ and $T^{'} \subset Th (M^{intended})$ .

There exists a $T^{-}$ such that $extraction (T, T^{-}) = T^{'}$ .

T reused for $T^{'}$ via extraction of some $T^{-}$ .

$\to T^{'} \subset Th (M^{intended})$ .

There exists a $T^{+}$ such that $extension (T^{'}, T^{+}) = Th (M^{intended})$ .

$T^{'}$ reused for $Th (M^{intended})$ via extension with some $T^{+}$ .

$extension (extraction (T, T^{-}), T^{+}) = Th (M^{intended})$ .

Therefore the assumption cannot hold in this situation as it corresponds to reuse of T via extraction of some $T^{-}$ and extension with some $T^{+}$ to axiomatize $Th (M^{intended})$ . It is clear from the definitions of the reuse operations that extraction and extension are the only possible operations to axiomatize $Th (M^{intended})$ .

$T^{'} \subset T$ and $T^{'} = Th (M^{intended})$ .

There exists a $T^{-}$ such that $extraction (T^{'}, T^{-}) = Th (M^{intended})$ .

The assumption cannot hold in this situation as it corresponds to reuse of T via extraction of some $T^{-}$ . It is clear from the definitions of the reuse operations that extraction is the only possible operation to axiomatize $Th (M^{intended})$ .

$T^{'} = T$ and $T^{'} \subset Th (M^{intended})$ .

There exists a $T^{+}$ such that $extension (T^{'}, T^{+}) = Th (M^{intended})$ .

This cannot hold as it corresponds to reuse of T via extension with some $T^{+}$ . It is clear from the definitions of the reuse operations that extension is the only possible operation to axiomatize $Th (M^{intended})$ .

$T^{'} = T$ and $T^{'} = Th (M^{intended})$ .

$as_is (T) = Th (M^{intended})$ .

This cannot hold as it corresponds to as_is reuse of T for $Th (M^{intended})$ . It is clear from the definitions of the reuse operations that as_is is the only possible operation to axiomatize $Th (M^{intended})$ .
Therefore when $n = 1$ the assumption cannot hold so we can conclude that any reuse of a single theory can be defined by some sequence of reuse types.

Case 2: reuse of multiple theories $n > 1$ .

In order to reuse multiple theories, the combination operation must be applied at some point, to collect all of the theories $T_{1}, \dots, T_{n}$ together (i.e. $n - 1$ times). We consider this necessary operation first (recall that the operations are commutative) and then show how the result reduces to Case 1, for which we have shown the assumption cannot hold.

Again, by Theorem 1:

There exists a $T_{1}^{'}, \dots, T_{n}^{'}$ s.t. $T_{1}^{'} \subseteq T_{1}, \dots, T_{n}^{'} \subseteq T_{n}$ and $T_{1}^{'} \cup \dots \cup T_{n}^{'} \subseteq Th (M^{intended})$ .

Consider all n theories collectively, let $\begin{matrix} T_{new} = T_{1} \cup \dots \cup T_{n} = combination (T_{1}, combination (\dots, combination (T_{n - 1}, T_{n})) \end{matrix}$ i.e. by definition, $T_{1}, \dots, T_{n}$ are reused for $T_{new}$ via combination.

Let $T_{new}^{'} = T_{1}^{'} \cup \dots \cup T_{n}^{'}$ $\begin{array}{l} \to T_{new}^{'} \subseteq T_{new} \\ \to T_{new}^{'} \subseteq Th (M^{intended}) \end{array}$ By definition, $T_{new}$ is reused for $Th (M^{intended})$ and we now have $n = 1$ for which we’ve shown (Case 1) the assumption is impossible (i.e. a subsequent sequence of operations exists for any scenario). Therefore we can conclude that any reuse of a set of n theories where $n > 1$ can also be defined by some sequence of reuse types. □
Theorem 4.
Let $S$ be some ontology repository, and let $T_{1}, \dots, T_{n}$ be some ontologies in $S$ . If an ontology or set of ontologies $T_{1}, \dots, T_{n}$ is reusable for $M^{intended}$ there exists a set of specialized reuse operations on $T_{1}, \dots, T_{n}$ to axiomatize $M^{intended}$ .
Proof.
By Theorem 3, for any ontology or set of ontologies $T_{1}, \dots, T_{n}$ that is reusable for $M^{intended}$ there exists a set of general reuse operations on $T_{1}, \dots, T_{n}$ to axiomatize $M^{intended}$ .
By Lemma 1 any extraction operation may be defined by some set of domain_extraction, weakening_extraction, residue_extraction operations.

By Lemma 2 any extension operation may be defined by some set of domain_extension, strengthening_extension, residue_extension operations.

By Lemma 3 any combination operation may be defined by some set of domain_combination, strengthening_combination, residue_combination operations.
Therefore, for any ontology or set of ontologies $T_{1}, \dots, T_{n}$ that is reusable for $M^{intended}$ there exists a set of specialized reuse operations on $T_{1}, \dots, T_{n}$ to axiomatize $M^{intended}$ . □

Theorem 4 confirms that our definition of reuse operations has in fact covered all cases of reuse.
5. Discussion

The metatheory presented in this paper provides a formal foundation for the task of ontology reuse. In order for ontology development to move toward becoming an engineering discipline, concepts like reuse and its operations must be clearly understood and defined. Here, we consider the implications of this work; in particular, the improved understanding and the opportunities for reuse support that it provides for reuse.

5.1. Documenting ontology reuse

For any ontology, either during or post-reuse, it is important that the developer understand – and be able to communicate – precisely what reuse operations must be or were applied. This is valuable both in providing guidance for reuse, and also in assessing precisely how a particular ontology was reused. The metatheory of ontology reuse provides a language with which a developer may communicate the operations that were performed during reuse, and as a result, specify the relationship between the new and the reused ontology(s). Extraction, extension and combination may be performed in several distinct ways, each of which has a different intuition and impact on the resulting ontology. The specializations of the reuse operations are based on a more precise identification of these changes to the original ontology. Not only does this provide more detailed guidance with respect to the required operations, it allows for a more detailed analysis of the implications of any given reuse scenario. The identification of these operations facilitates recognition of the relationships between concepts in the original ontology(s) and the resulting ontology being developed via reuse. Most notably, this supports the identification of shareability that is attained or lost for concepts in the new ontology. If applied to consider the operations required to axiomatize some approximation of the required theory (a set of competency questions, for example), the identification of necessary specialized operations may also be used as a sort of look-ahead. In the same way that the operations provide valuable documentation post-reuse, a priori their approximation serves to inform developers of the implications that a reuse operation on some ontology will have on its semantics, and consequently the resulting shareability that can be expected. The result serves to provide information about the shareability between the resulting ontology and the reused theories. In effect, it enables us to give a useful answer the question: What does it mean if one ontology is said to have reused another?

It is our hope that the reuse operations be applied and annotated by ontology developers as a means of documenting reuse. Failing this, the metatheory of reuse also provides a means of explicitly identifying or specifying how a given ontology(s) was reused. Not only does there exist some set of operations to axiomatize the intended models, we can in fact leverage the definitions to determine precisely what operations were required. This result comes about by way of the proof for Theorem 3. The proof illustrates the straightforward identification of the required, general operations to axiomatize some $Th (M^{intended})$ from a reusable ontology T. For each general operation, the results of Lemmas 1, 2, and 3 illustrate how the specialized operations may be determined through an examination of the ontologies’ modular structures. Therefore, if it is known that T was reused to create $Th (M^{intended})$ , it is possible to identify the necessary specialized operations based on the relationship between the signatures, and the axioms of $Th (M^{intended})$ and T. While it may not be a completely accurate reflection of the reuse operations that took place in the design of $Th (M^{intended})$ , it represents those operations that were necessary, and thus still contains valuable information regarding the relationship between the new theory and the reused one.

5.2. Beyond semantic requirements

The analysis of necessary operations described above only considers required changes to the models of the ontology being reused. In practice, it may be the case that axioms that are added or removed during the course of reuse are logical consequences of the theory and have no impact on its underlying models. Such cases are included in the definitions of the appropriate reuse operations, however they cannot be identified by considering the intended models. This is because these cases are motivated by extra-logical requirements. The addition or removal of such axioms may be motivated by usability considerations; for example, a developer may add several axioms which are intended simply to make the theory more easily understandable. Alternatively, axioms are sometimes added or removed to achieve improvements in automated reasoner performance. While these cases were not explicitly addressed in the definition of reuse, they are included in the definition of the operations. It is worth noting however, that with only knowledge of the intended models, we cannot recognize when such operations have been or will be required.

5.3. Other operations on ontologies

The reader may note that the notion of ontology operations itself is not novel. Work on ontology algebras, belief revision, and the Distributed Ontology Language (DOL) standard have particular resonance. We review each of these areas here and discuss the relationship to this work. It is critical to note that the novelty of the current work is not in the identification of the operations themselves, rather, the contribution we make is the way in which we interpret these operations, in the context of a metatheory of ontology reuse. The perspective we take in defining these operations is such that they serve to both prescribe how an ontology can be reused to satisfy a given set of requirements, and to assess what the implications of this reuse will be on the resulting ontology.

5.3.1. Ontology algebras

The ontology algebra presented by Mitra and Wiederhold (2004), Wiederhold (1994) are designed to support ontology integration, thus the resulting operations focus on composing ontologies when global consistency is not feasible. We observe that similarities are evident between the operators defined in this work and the reuse operations we identify here. In particular, the combination and extraction operations may be captured by operators defined for ontology algebras. A major distinction here is that the role of the algebra operators is to support the integration ontologies, thus their attention is on the combinations of ontologies. The intersection and difference operators defined for the ontology algebra do not correspond to any of the reuse operations we define here, as these distinctions are not relevant for our purposes; nor do the algebras define any sorts of extension operations, as their focus is on the combination of existing theories, not the addition of new axioms.

5.3.2. Belief revision and the AGM framework

The reader may also have noticed similarities between the identified operations and the well-known AGM Framework for belief revision by Alchourrón et al. (1985), Gärdenfors (2003). It defines operations, or ways in which beliefs can change. The notion of revising a set of beliefs to resolve inconsistencies is thus one of particular importance. In the context of ontologies, the AGM Framework may be considered as a tool to approach ontology evolution (Flouris et al., 2006).

Conceptually, the extraction, extension, and combination operations could all be described in the AGM Framework, albeit without the sorts of distinctions that are made between the specializations. On the other hand, there are belief revision operations such as revision and consolidation that do not correspond to any of the reuse operations defined here. Again, a major distinction is that the purpose of these operations is to update the belief set and arrive at a consistent set of beliefs, whereas the reuse operations are manipulating existing ontology(s) in order to arrive at a specific end result.

5.3.3. DOL

The Distributed Ontology Language (DOL) (Mossakowski et al., 2012), has been designed in response to the OntoIOP request for proposal (Neuhaus, 2013) to address the challenge of interoperability for heterogeneous formal representations. The DOL project considers not only ontologies, but ‘specifications and MDE [Model-Driven Engineering] models’ in a variety of languages, and is focused not on reuse but on integration and interoperability. While the scope of this project is much broader and not quite aligned with the work presented here, we find that the ‘structuring language for OMS’ provided by DOL corresponds in a way to the concept of reuse operations. A key distinction is that the language in DOL defines constructs, which are meant to describe the structure of theories and how they relate to one another, as opposed to the definition of operations here which represents a manipulation performed on a given ontology.

Each of the reuse operations defined here may be expressed by some DOL construct. However certain distinctions such as the difference between the original and resulting signature that are made when considering operations in the context of reuse, are not captured by these constructs as they are simply not relevant when defining metalogical relationships between theories. As mentioned, the DOL constructs provide a means of describing the structure of an ontology such that we can understand its relationship to other ontologies. The concept of an ‘original’ (reused) ontology, or even the source of axioms (another ontology, or created by the developer) make little sense from this perspective.

5.4. Extending the definition of reuse

The definition of reuse presented in this paper is subject to two major assumptions that are made to simplify its presentation: we assume that no translations of an ontology’s signature or language are performed as part of reuse. While justifiable, there exists practical motivation to consider a more general definition of reuse that does not make these assumptions. Different terminology may be more or less appropriate in different domains, so it is possible that some modifications to the signature may sometimes be required, and it would be reasonable to still recognize such behaviour as reuse. Furthermore, Grüninger and Katsumi (2012) present an approach wherein ontologies from the same domain are reused in ontologies for parthood, periods of time, as well as subactivities, by applying translations to the signature. By considering reuse with signature translations, a seemingly unrelated theory may in fact provide precisely the required semantics that are required. This approach greatly expands the pool of potential candidates, thus encouraging reuse and increasing the possibility of finding an appropriate ontology.

Including the possibility of translation between languages is a more challenging task, however it has the potential to be tremendously beneficial for the development of ontologies. Translation of ontologies in different logical languages both expands the candidates for reuse, and allows developers to take advantages of the strengths and weaknesses of different languages and communities. For example, development of a FOL ontology might take advantage of the widespread application and use of OWL ontologies, whereas as in our earlier example OWL ontologies may take advantage of the rigorous definitions that are more typical of FOL ontologies. In forthcoming work, we shall present an extended definition of reuse that builds on the work presented here to capture the possibility of reuse with translations of an ontology’s signature and language.

6. Conclusion

Although ontology reuse is widely recognized as a critical aspect of ontology design and application, the principles and practice of reuse remains underdeveloped because no definition of reuse or complete characterization of operations to achieve reuse has been proposed. The metatheory of reuse presented in this paper is a novel contribution that provides the logical foundations for ontology reuse. While there are certainly other challenges that present barriers for the reuse of ontologies, the work presented in this paper takes steps towards the goal of reuse becoming a more principled and effective means of ontology design by developing definitions for the concepts of reuse and reusability that are not only formal but functional. We have presented a precise set of reuse operations that, in any possible case, can be applied to an ontology in order to satisfy some specified semantic requirements. Not only are the operations capable of providing valuable guidance for reuse, perhaps more crucially they provide a means of assessing and understanding the implications of a given instance of reuse.

This work provides the necessary metatheory to support ontology reuse, but in the absence of tools to support such solutions, their adoption is not guaranteed. The availability of tool support to implement this metatheory would be an invaluable contribution towards simplifying and improving the practice of reuse. We hope that future work will look towards the adoption of the approach to reuse presented here in a more user-friendly medium, perhaps integrated with existing ontology design tools.

Of particular interest for the task of ontology reuse are the relationships identified between the reuse operations and the constructs specified in DOL. The correspondences that we have identified present an opportunity to extend implementation of this work to capture any resulting ontologies in the DOL terminology. For example, it will be straightforward to translate the necessary reuse operations to axiomatize the intended models from some $T_{1}, \dots, T_{n}$ , in order to define the structure of the resulting ontology using the metalogical relationships of DOL. This has the potential to ease adoption of the DOL standard, and also to benefit reuse with the provision of standardized metadata detailing the reuse of ontologies. Should existing ontology development tools adopt the DOL standard, this should serve to motivate the (possibly automated) annotation of reuse operations.

Footnotes

Definitions for relevant logical terminology

Here we include definitions for the logical terms employed in this work for the reader’s reference.

References

Aameri, B., Grüninger, M. & Chui, C. (2016). Anti-modules. In

Kutz ,

de Cesare ,

M.M.

Hedblom ,

T.R.

Besold ,

Veale ,

Gailly ,

Guizzardi ,

Lycett ,

Partridge ,

Pastor ,

Grüninger ,

Neuhaus ,

Mossakowski ,

Borgo ,

Bozzato ,

C.D.

Vescovo ,

Homola ,

Loebe ,

Barton and

Bourguet (Eds.), Proceedings of the Joint Ontology Workshops 2016 Episode 2: The French Summer of Ontology Co-Located with the 9th International Conference on Formal Ontology in Information Systems (FOIS 2016), Annecy, France. CEUR Workshop Proceedings (Vol. 1660). CEUR-WS.org.

Alchourrón, C.E., Gärdenfors, P. & Makinson, D. (1985). On the logic of theory change: Partial meet contraction and revision functions. The Journal of Symbolic Logic, 50(2), 510–530. doi:10.2307/2274239.

Bontas, E.P., Mochol, M. & Tolksdorf, R. (2005). Case studies on ontology reuse. In

Tochtermann (Ed.), Proceedings of the IKNOW05 International Conference on Knowledge Management (Vol. 74).

Doran, P., Tamma, V. & Iannone, L. (2007). Ontology module extraction for ontology reuse: An ontology engineering perspective. In Proceedings of the Sixteenth ACM Conference on Conference on Information and Knowledge Management, CIKM ’07 (pp. 61–70). New York, NY, USA: ACM. doi:10.1145/1321440.1321451.

Falbo, R.A., Guizzardi, G., Gangemi, A. & Presutti, V. (2013). Ontology patterns: Clarifying concepts and terminology. In Proceedings of the 4th International Conference on Ontology and Semantic Web Patterns (Vol. 1188, pp. 14–26).

Fernández-López, M., Suárez-Figueroa, M.C. & Gómez-Pérez, A. (2012). Ontology development by reuse. In Ontology Engineering in a Networked World (pp. 147–170). Springer. doi:10.1007/978-3-642-24794-1_7.

Flouris, G., Plexousakis, D. & Antoniou, G. (2006). Evolving ontology evolution. In SOFSEM 2006: Theory and Practice of Computer Science (pp. 14–29). Springer. doi:10.1007/11611257_2.

Gangemi, A., Guarino, N., Masolo, C., Oltramari, A. & Schneider, L. (2002). Sweetening ontologies with DOLCE. In Proceedings of the 13th International Conference on Knowledge Engineering and Knowledge Management. Ontologies and the Semantic Web, EKAW ’02 (pp. 166–181). London, UK: Springer. doi:10.1007/3-540-45810-7_18.

Gangemi, A., Pisanelli, D. & Steve, G. (1998). Ontology integration: Experiences with medical terminologies. In Formal Ontology in Information Systems (pp. 46–98). Amsterdam, AM: IOS Press.

10.

Gärdenfors, P. (2003). Belief Revision. Cambridge University Press.

11.

Grau, B.C., Horrocks, I., Kazakov, Y. & Sattler, U. (2008). Modular reuse of ontologies: Theory and practice. Journal of Artificial Intelligence Research (JAIR), 31, 273–318.

12.

Grüninger, M. (2009). Using the PSL ontology. In

Staab and

Studer (Eds.), Handbook on Ontologies (pp. 423–443). Springer. doi:10.1007/978-3-540-92673-3_19.

13.

Grüninger, M., Chui, C. & Katsumi, M. (2017). Upper ontologies in COLORE. In

F.N.

Antony Galton (Ed.), Foundational Stance (FOUST), Joint Ontology Workshops 2017.

14.

Grüninger, M., Hahmann, T., Hashemi, A., Ong, D. & Özgövde, A. (2012). Modular first-order ontologies via repositories. Applied Ontology, 7(2), 169–209.

15.

Grüninger, M., Hahmann, T., Katsumi, M. & Chui, C. (2014). A sideways look at upper ontologies. In Formal Ontology in Information Systems – Proceedings of the Eighth International Conference, FOIS, September, 22–25, 2014, Rio de Janeiro, Brazil (pp. 22–25).

16.

Grüninger, M. & Katsumi, M. (2012). Specifying ontology design patterns with an ontology repository. In Proceedings of the 3rd International Conference on Ontology Patterns (Vol. 929, pp. 1–12).

17.

Gruninger, M. & Ong, D. (2011). Verification of time ontologies with points and intervals. In

F.W.

Martin Leucker (Ed.), Temporal Representation and Reasoning (TIME), 2011 Eighteenth International Symposium (pp. 31–38). IEEE. doi:10.1109/TIME.2011.27.

18.

Guarino, N., Oberle, D. & Staab, S. (2009). What Is an Ontology? (2nd ed., pp. 1–17). Berlin: Springer.

19.

Hayes, P. (1996). Catalog of temporal theories. Technical Report Technical Report UIUC-BI-AI-96-01, University of Illinois Urbana-Champagne.

20.

Katsumi, M. & Grüninger, M. (2016). What is ontology reuse? In

Ferrario and

Kuhn (Eds.), Formal Ontology in Information Systems: Proceedings of the 9th International Conference (FOIS 2016) (Vol. 283, pp. 9–22). IOS Press.

21.

Katsumi, M. & Grüninger, M. (2017). Choosing ontologies for reuse. Applied Ontology, 12(3–4), 195–221. doi:10.3233/AO-160171.

22.

Konev, B., Lutz, C., Walther, D. & Wolter, F. (2009). Formal properties of modularisation. In

Stuckenschmidt ,

Parent and

Spaccapietra (Eds.), Modular Ontologies: Concepts, Theories and Techniques for Knowledge Modularization (pp. 159–186).

23.

Menzel, C. & Grüninger, M. (2001). A formal foundation for process modeling. In

Smith and

Welty (Eds.), Formal Ontology in Information Systems: Proceedings of the 2nd International Conference (FOIS 2001) (pp. 256–269). IOS Press.

24.

Mitra, P. & Wiederhold, G. (2004). An ontology-composition algebra. In

Studer and

Staab (Eds.), Handbook on Ontologies (pp. 93–113). Springer. doi:10.1007/978-3-540-24750-0_5.

25.

Mossakowski, T., Codescu, M., Kutz, O., Lange, C. & Gruninger, M. (2013). Proof support for common logic. In

Benzmüller and

Otten (Eds.), Proceedings of the Workshop on Automated Reasoning for Quantified Non-Classical Logic (ARQNL), July (Vol. 33, pp. 42–58).

26.

Mossakowski, T., Lange, C. & Kutz, O. (2012). Three semantics for the core of the distributed ontology language. In FOIS (Vol. 239, pp. 337–352).

27.

Muñoz, L.S. & Grüninger, M. (2016). Mapping and verification of the time ontology in SUMO. In Formal Ontology in Information Systems – Proceedings of the 9th International Conference, FOIS 2016, Annecy, France, July 6–9, 2016 (pp. 109–122).

28.

Neuhaus, D.F. (2013). Ontology, model and specification integration and interoperability (ontoiop) RFP. Technical report, Object Management Group (OMG).

29.

Noy, N.F. & Musen, M.A. (1999). An algorithm for merging and aligning ontologies: Automation and tool support. In

Farquhar and

Stoffel (Eds.), Proceedings of the Workshop on Ontology Management at the Sixteenth National Conference on Artificial Intelligence (AAAI-99) (pp. 17–27).

30.

Pinto, H.S. & Martins, J.P. (2001). A methodology for ontology integration. In

Gil ,

Musen and

Shavlik (Eds.), Proceedings of the 1st International Conference on Knowledge Capture (pp. 131–138). ACM.

31.

Van Benthem, J. (1983). Logic of Time. Springer.

32.

Wiederhold, G. (1994). An algebra for ontology composition. In Proceedings of 1994 Monterey Workshop on Formal Methods (pp. 56–61). Naval Postgraduate School.