Ontology Design Patterns (ODP) are often described as reusable solutions to recurrent modelling problems. Yet, there is no wellestablished formalism or framework for facilitating the reuse of ODPs in practise. This motivates a comparison of existing approaches and proposals for capturing modelling solutions recommended by ODPs. To gain a first understanding, we identify and characterise repetitive structures, e.g. axioms or logical expressions, as an important aspect of many ODPs. We ifnd that existing frameworks provide features to support simple repetitive structures that commonly occur in modelling solutions of ODPs.
We assume the reader to be familiar with description logics (DL) [
Commons License Attribution 4.0 International (CC BY 4.0). otherwise. We will refer to the set of non-logical symbols (class, property, and individual names) of an ontology as its signature. Any element of an ontology’s signature will be referred to as an entity. 3
ODPs have been proposed for a wide range of ontology engineering tasks. As a
result, a variety of different kinds of ODPs exist [
In the following, we give examples for the reuse of both CODPs and LODPs (cf. Section 3.1) and how these ways of reusing ODPs involve repetitive structures (cf. Section 3.2). Finally, we characterise these structures and identify publicly available ODPs exhibiting aspects of repetitive structures as part of their design (cf. Section 3.3). 3.1
Examples of ODP Reuse
The descriptions of both CODPs and LODPs often suggest a notion of ODP
reuse in terms of some implied metamodel. For example, in case of LODPs
there is generally an assumed notion of variables that are to be instantiated.
However, neither variables nor a valid ways for instantiating them are explicitly
defined or qualified. Such vagueness in the documentation of ODPs gives room for
interpretation with respect to an ODP’s reuse in practise. We will discuss issues
related to this lack of formal rigour in Section 3.2 and Section 5. For the purpose
of this section, we present example ODPs that are documented in a well-known,
publicly available library of ODPs [
For a concrete use case, consider an academic conference, e.g. ISWC, and its participants in terms of authors, reviewers, and organisers. Suppose that authors 1, 2, 3 participated in the 2019 edition of ISWC with a jointly written paper that has been reviewed by reviewers 1, 2, 3. Then, the following adaptation of the NaryParticipation pattern captures this situation.
First, the specified classes of NaryParticipation are specialised by creating domain specific subclasses and subproperties (see Figure 2).
Publication ⊑ NaryParticipation
Conference ⊑ ∀hasParticipant.(Author ⊔ Organiser ⊔ Reviewer) includesAuthor ⊑ participationIncludes includesPaper ⊑ participationIncludes includesReviewer ⊑ participationIncludes includesOrganiser ⊑ participationIncludes includesTimeInterval ⊑ participationIncludes
includesVenue ⊑ participationIncludes
Next, the newly created subclasses are populated as needed, i.e, Author(), Reviewer(ri),
etc., and finally all individual parts are interrelated via a shared instance of the
Publication class that is subsumed by NaryParticipation (see Figure 3).
includesConference(1, )
includesAuthor(1, 1)
includesAuthor(1, 2)
includesAuthor(1, 3)
includesReviewer(1, 1)
includesReviewer(1, 2)
includesReviewer(1, 3)
includesPaper(1, )
includesTimeInterval(1, 1)
Example 2 (LODP). The LODP NaryRelation [
In this diagram, the NaryRelationClass constitutes the reified class for the -ary relationship. This class is used to establish a connection between all components of the original relationship each of which will be represented by a distinct instantiation of the class NaryRelationProjection.
As a concrete use case, consider information about a university level exam. Here, a relation between a student, a course, a grade, and a semester time has to be modelled. This can be achieved by using the NaryRelation pattern as follows. First, we reify a class ExamEntry to represent the relationship. Next, we introduce distinct classes and properties for each component of the original relationship:
Comparing this set of axioms to the axioms for modelling publications in the previous example, it becomes clear that the CODP NaryParticipation is based on the LODP NaryRelation. Note that the use of existential restrictions in the CODP NaryParticipation and in the example for exams is not part of the design proposed by the LODP NaryRelation. As Figure 4 indicates, only the domains and ranges of object properties are required to be specified. Our use of existential restrictions is merely for ease of presentation and not a substitute for domain and range axioms. However, there exist variants of the NaryRelation pattern that define the use of existential restrictions as mandatory. See for example the following diagram published in the Manchester “ontology design patterns public catalogue”.1 The examples in the previous section demonstrate ways of reusing both CODPs and LODPs. For a given CODPs, its classes and properties are extended by subclasses and subproperties, whereas for a given LODP, variable entities are instantiated (e.g. by atomic entities, or compound expressions). For both notions of reuse, extending entities by subsumption on the one hand, and instantiating variables on the other hand, the respective operations may be repeatedly performed to give rise to structurally similar axioms.
For example, the different participants of a conference publication are all modelled in the same manner in Example 1 (CODP). Namely, ⊑ Object ⊑ participationIncludes
where we abstracted over names of domain specific participation objects, e.g. Author or Reviewer, by introducing the variables (a class variable) and (a property variable). Similarly, in Example 2 (LODP), all components of an -ary relationship are modelled by instantiating structurally identical variable components, e.g. existential restrictions or domain and range axioms, repeatedly.
Repetitive structures in ODP driven modelling are not necessarily incidental
to ways of reusing patterns in specific use cases. In fact, many ODPs describe
repetitive structures as part of their design explicitly. Most CODPs published
in [
We identify ODPs exhibiting repetitive structures in their design according to the following five criteria: (a) presence of an indefinite cardinality constraint, (b) presence of an indefinite enumeration, (c) presence of a cyclic design component, (d) presence of an example suggesting indefinite enumeration, (e) presence of an example suggesting a cyclic component.
Using these criteria, we determine the prevalence of ODPs involving repetitive
structures in the following publicly available catalogues:
1. D2.5.1: A Library of Ontology Design Patterns (NeOn Catalogue) [
Table 1 reports the number of ODPs identified by criteria (a)–(e) above without double-counting ODPs by (d) or (e) if already identified by (a)–(c). 3 http://ontologydesignpatterns.org/wiki/Submissions:Situation 4 http://ontologydesignpatterns.org 5 http://odps.sourceforge.net/odp/html/index.html 6 https://dase.cs.wright.edu/content/modl-modular-ontology-design-library The prevalence of repetitive structures in modelling solutions proposed by ODPs raises the question whether these structures are based on common design principles that suggest similar ways of reuse in practise. Consider the axioms used in Example 1 based on the NaryParticipation pattern. Here, different types of participants 1, . . . , at a conference are modelled by using a structure with indefinite arity of the following form:
Conference ⊑ ∀hasParticipant. ⎝ ⎛
⎞ In this structure, the variable number of participants 1, . . . , are used both within a single logical expression (namely a union of class names), as well as a set of axioms (namely a set of subsumptions ⊑ Object). This observation motivates a threefold distinction of repetitive structures: 1. structures involving some repetition of axioms, 2. structures involving some repetition within logical expressions, 3. structures involving a combination of repetitive structures.
Despite its simplicity, this threefold distinction allows us to gain a first understanding about the nature of repetitive structures that are, by design, part of modelling solutions proposed by ODPs. In Table 2, we list how many ODPs involving repetitive structures (c.f. Section 3.2 categories (a)–(e) and Table 1) involve repetitive axioms, repetitive logical expressions, or some combination of both. It appears that most repetitive structures in ODPs are due to repeated axioms rather than logical expressions of indefinite arity.
Note that these numbers only report on ODPs that suggest repetitive structures
explicitly in the documentation of their proposed modelling solution (see Figure 5
for an example). The table does not report on ODPs that give rise to repetitive
structures solely by virtue of specific notions of ODPs reuse.
Infrastructure for supporting ontology engineering with ODPs is scarce and often
not well-maintained [
There currently exist two publicly available frameworks for handling repetitive
ontology design tasks, namely the Ontology Pre-Processing Language7 (OPPL) [
In addition to basic support of ODP reuse via simple variable instantiation of a fixed set of axioms, both frameworks provide means for generating a set of axioms based on repeated instantiation of a given set of axioms. For example, given the axiom ? ⊑ ∃hasAttribute.? where ?, and ? are variables, both OPPL and OTTR allow for the generation of the set of axioms, that corresponds to the cross product of variables instantiations of the respective input sets. So, continuing the example with 1 and 2 as input sets of class names for ? and ? , then the resulting set of axioms is
{? ⊑ ∃hasAttribute.? |? ∈ 1, ? ∈ 2}.
Replicating syntactically similar axioms seems to be a needed feature for the reuse of some LODPs as well as CODPs as most of the repetitive structures
explicitly occurring in ODPs appear to exhibit such repeated axioms (cf. Table 2 in Section 3.3).
Example 3 (Instantiation by Cross Product). Consider the NaryParticipation pattern from Example 1 in Section 3.1. Here, all participation objects of an -ary participation are specialisations of (i.e. are subsumed by) the Object class. Without introducing separate object properties for all objects, the (partial) reuse of the NaryParticipation pattern could be formalised by the following set of axioms: ? ⊑ Object ? ⊑ NaryParticipation ? ⊑ ∃participationIncludes.?.
Given 1 = {Author, Organiser, Reviewer, Paper} and 2 = {Publication} as sets of class names, the cross product of instantiations ? over 1 and ? over 2 would allow for the generation of repetitive modelling of participation objects.
In addition to repeated axioms, some ODPs exhibit logical expressions, e.g. class unions, with an indefinite number of components (cf. Table 2 for Catalogue 3). Such variable logical expressions can be captured in both OTTR and OPPL to some degree.
Example 4 (Logical Expressions with indefinite arity). As before, consider the NaryParticipation pattern from Example 1 in Section 3.1. Here, the axiom
contains a class union of three classes. However, a pattern’s design might generalise over the number of different participant types via an axiom of the form Conference ⊑ ∀hasParticipant. ⎝ ⎛
⎞ ⨆︁ ⎠ , 1≤ ≤ where we introduced variables for the classes participating in the union that is the filler of the universal quantification. In both OTTR and OPPL, this more general rendering can be expressed if are assumed to be class names.
While both OPPL and OTTR provide some support for capturing logical expressions of indefinite arity, there are limitations in terms of nesting and composing expressions of indefinite arity as the following example shows. Example 5 (Compound Logical Expressions with indefinite arity). Both OTTR and OPPL provide support for formulating logical expressions such as an intersection of classes 1 ⊓ . . . ⊓ , where the number of classes is not fixed. Furthermore, it is possible to create compound logical expressions of arbitrary arity, as long as they are not nested. For example, it is possible to formulate an expression that is the union of say three intersections of indefinite arity, i.e., (1 ⊓ . . . ⊓ ) ⊔ (1 ⊓ . . . ⊓ ) ⊔ (1 ⊓ . . . ⊓ ) . ⏟ifrst interse⏞ction ⏟second inte⏞rsection ⏟third inter⏞section However, it is not possible to generalise this case from a union of three indefinite intersections to an indefinite union of indefinite intersections.9
Lastly, there exist ODPs that propose modelling solutions involving combinations of distinct repetitive structures (cf. Table 2 for the Manchester Catalogue). Such combinations may be structurally interrelated or not. A repetitive structure that involves two structurally independent components may be supported by both OPPL or OTTR if each of the components is supported separately. Example 6 (Combination of Independent Repetitive Structures). As before, consider the NaryParticipation pattern from Example 1 in Section 3.1. Here, the structure
Conference ⊑ ∀hasParticipant. ⎝ ⎛
⎞ with 1 = Author, 2 = Organiser, 3 = Reviewer occurs. Since both OPPL and OTTR provide means for generating the repeated axioms ⊑ Object as well as the axiom containing a union over an indefinite number of class names, the combination of both structures can be captured as well.
However, not all complex repetitive structures are combinations of structurally independent components as the following example shows.
Example 7 (Interrelated Repetitive Structures). As before, consider the NaryParticipation pattern from Example 1 in Section 3.1. Here, the NaryParticipation pattern is (partially) reused by extension according to the following general structure: 1 ⊑ Object . .
. ⊑ Object 1 ⊑ participationIncludes . .
. ⊑ participationIncludes
Publication ⊑ ∃1.1 . .
.
Publication ⊑ ∃. 9 OPPL only allows for a fixed number of ’input variables’ that range over entities of an ontology. Hence, only a fixed number of indefinite intersections can be captured.
For OTTR, a similar argument can be made.
For each participation object, e.g. Author, a separate object property is introduced, e.g. includesAuthor that is used to establish the relationship to the NaryParticipationObject, here Publication. Therefore, each participation object is related to exactly one object property . This dependency, where each has to be coupled with a corresponding to generate the axioms Publication ⊑ ∃., constitutes a structure that can be captured in OTTR via a list expansion mode called “zip”. However, OPPL does not appear to provide support for such interrelations of repetitive structures. 5 5.1
Choice of Examples
We have guided the comparison of OTTR and OPPL by characteristics of repetitive
structures occurring in ODPs and potential ways of their reuse in practise. The
choice of our examples was based on two frequently discussed operations for ODP
reuse. First, the instantiation of variables in a given set of axioms [
However, it needs to be pointed out that there are other ways of ODP reuse
and that the very notion of ODP reuse is still an open research question [
Complex Repetitive Structures The repetitive structures occurring in most ODPs are of rather simple nature. Axioms are repeated in a very systematic manner and logical expressions with an indefinite number of components are mostly restricted to operators over a set of entity names, e.g. a union of an arbitrary number of class names. However, there are also examples of more complex repetitive structures that exhibit interdependencies between its constituent components.
While a complete coverage of characteristics for more complex patterns is beyond the scope of this work, we give a concrete example Entity-Property-Quality pattern (see Figure 7). Reusing this pattern may give rise to three interrelated repetitive structures. First, an entity category is defined in terms of a number of entities 1, . . . , . Second, each entity may have multiple qualities10 1, . . . , . And third, each of these qualities is modelled by a union of (pairwise disjoint) quality values 1, . . . , ( denotes the th quality value for quality ). So overall, an entity may have a number of quality values , . . . , , . . . , . . . , over a number of different qualities , . . . , . The interrelationship of these three structures may or may not result in a systematically repetitive ontological model. 10 Although the diagram for the pattern does not show an enumeration for diferent qualities, the documentation states the enumeration for qualities verbally: “To model qualities of independent entities (e.g. position, colour, ...).”
It is currently unknown whether (and how) such complex repetitive structures
are used in practise and whether they could be captured in OTTR or OPPL.
Research on ODPs faces a number of difficult open questions and challenges [
Existing user studies reveal inconsistent perceptions of the benefits supposedly
provided by ODPs. While some studies report that participants perceive ODPs
generally as useful [
These inconclusive results motivate what is often referred to a
“bottomup” approach that tries to gather information for ODP research from existing
ontologies. However, empirical studies on the prevalence of publicly accessible
ODP repositories indicate limited evidence for ODP reuse in practise [
Besides user studies, empirical detection and discovery studies for ODPs, there
is little research on formal requirements of mechanisms to effectively reuse ODPs
in practise. One step in this direction is done by [
Despite a large number of proposals of different notions for pattern reuse, little is known what kind of features a mechanism for facilitating ODP reuse needs to 11 http://odps.sourceforge.net/odp/html/Entity_Property_Quality.html provide. The work in this paper on tool support for capturing repetitive structures contained in modelling solutions of ODPs is a tentative step in this direction. Understanding and qualifying important aspects of ODPs may inform the design of suitable mechanisms for ODP reuse.
In this paper, we have considered repetitive structures of axioms and logical expressions in the context of ODP reuse. It seems that many ODPs exhibit such structures already in their proposed modelling solution or suggest the generation of such structures due to repeated operations of reuse. We found that two existing frameworks seem to provide suitable support for most ODPs with respect to identified repetitive structures. There are examples of complex interrelated structures (cf. Section 5.2) that cannot be appropriately captured by either OPPL nor OTTR but is unclear whether such structures have practical relevance.
Overall, it seems that, in principle, providing sufficient technical support for ODP reuse in practise is possible. The identification of important features occurring in many modelling solutions of ODPs can inform notions of ODP reuse and how they might be supported by tools. While the scope of this work is limited to just two frameworks and their support of repetitive structures in ODPs, there are many more directions for future work. A direct extension of this work might consider aspects of ODPs other than repetitive structures. A more comprehensive comparison between OPPL and OTTR (or other frameworks) to determine how they differ in terms of expressive capabilities would also provide useful information for knowledge engineers in search for a tool of their needs.
Besides such technical aspects of how to provide tool support for ODP reuse,
one also has to consider practical aspects in terms of usability. It has already
been speculated that OPPL is not widely adopted as a tool for ODP reuse
because it may not be easy to use [