Ontology design patterns are normally instantiated by replicating and adapting the pattern concepts and roles. The relation between pattern definitions and their instantiations is documented in natural language. The use of parametric ontologies or pattern-reuse modifications to OWL-DL has been suggested before, but so far only practical aspects have been analysed, leaving the formal semantics of these extensions as future work. In this work we present formal definitions for ontology pattern and pattern instantiations, together with the semantics of instantiation. We propose the use of semantic annotations to describe and generate OWL pattern instantiations, without the need for explicit ontology replication, and provide tools to support this process.
Pattern instantiation is normally done in two different ways: (1) importing the pattern axioms and establishing mappings (equivalences) with existing elements in our ontology, or (2) replicating the pattern by changing the names of its elements. The former leads to representation and reasoning problems in case we use the pattern twice in the same ontology, as described in section 2. The latter is error prone and loses the relation between the instantiations and the pattern, which is in some cases only described with comments in natural language.
this purpose. However, we propose using the ontology language expressiveness, by means of semantic annotations, to support this pattern instantiation process.
The work of IMDEA Software on this paper has been partially funded by the Spanish Ministry of Industry, Tourism and Trade under the grant FIT-340503-2007-2, as part of the Morfeo EzWeb strategic singular project. we define formally the concepts of pattern and pattern instance. In section 4 we describe our tools for supporting pattern reuse. Finally, section 5 presents conclusions, related work and further research topics in this area.
properties or roles, and individual for individuals. The notation used for DL
formulas, unless stated otherwise, follows the one presented in [
provinces, which we will use as an ontological pattern. We use the concepts
City
the above axiom to relate them. With the following axioms, we can use the relation isPartOf also for German cities and provinces:
GermanCity GermanProvince
City Province
City and Province, for instance, FrenchCity and FrenchProvince:
FrenchCity FrenchProvince
City Province
GermanCity ≡ ∀isPartOf.GermanProvince FrenchCity ≡ ∀isPartOf.FrenchProvince
an ad-hoc solution to a simple problem of multiple instantiation of one pattern.
3 We use this adhoc “pattern” to simplify our explanation, since we have not found any
well-known ontology pattern that contained these axioms and could be used instead.
Potential candidate patterns like Componency [
Two key elements are needed in ontologies to support patterns: a means to define the patterns and a way to use them. Before going into details, we introduce a few elementary definitions that will be used along the paper. We use C for a set of concept names, R for a set of role names, and I for individual names. We consider a DL, with a set of symbols S, as a language over the union of all four sets C, R, I and S. DL sentences are formulas, and an ontology is a finite set of formulas of a particular DL. We consider C+, R+, I+ and S+ pairwise disjoint4. Finally, given a set W , a list of symbols w1, . . . , wn ∈ W all different, and a second list of symbols w1, . . . , wn ∈ W , we define the substitution function from w1, . . . , wn ∈ W to w1, . . . , wn respectively, as the function f ⊆ W × W such that: f (x) = wi x if there is an i ∈ {1, . . . , n} such that wi = x otherwise
[w1 → w1, . . . , wn → wn] or [f ]. Given a substitution function f , and given a string w of elements in W of length n (that is, w : [n] → W )5, we define the substitution of w under the total substitution function f : W → W , and we represent it as w[f ], as the string w : [n] → W such that ∀i ∈ [n] w (i) = f (w(i)). 3.1
Pattern definitions
4 We use the notation X+ for the Kleene plus, that is, the Kleene closure of the set
X without the empty string. More details can be found in [
interface to the pattern, that is, a definition of which parts are instantiable. This allows us to establish if an element in a pattern is not meant to be substituted or instantiated. This can happen because a name is just presented to simplify the axioms, or if the element in question represents more general knowledge.
City
This model and the interface {City, Province, isPartOf} is a pattern definition.
Given an ontology O, and given the sets C ⊆ C, R ⊆ R and I ⊆ I. The tuple O, C , R , I is an ontological knowledge pattern.
tern definitions or simply patterns. If O, C , R , I is a pattern, we will refer to
3.2
Pattern instantiations
the model has exactly the same axioms as the pattern, where the parameters have been substituted with their corresponding values. Note that the values must be of the same kind, that is, we can substitute or instantiate a concept with a concept, a role with a role and an individual with an individual.
FrenchCity to City and FrenchProvince to Province, having as a result the following model:
FrenchCity ∀isPartOf−1.FrenchCity ∀isPartOf.FrenchProvince = 1 isPartOf.
Let O, C , R , I be a pattern, where O is an ontology over some description logic D. Let c1, . . . , cm ∈ C , k1, . . . , km ∈ C be concepts, r1, . . . , rn ∈ R , s1, . . . , sn ∈ R be roles, and i1, . . . , ip ∈ I , j1, . . . , jp ∈ I be individuals.
We say that O is an instance of the pattern O, C , R , I with the mappings c1 → k1, . . . , cm → km, r1 → s1, . . . , rn → sn, i1 → i1, . . . , ip → jp if O = {o[c1 → k1, . . . , cm → km, r1 → s1, . . . , rn → sn, i1 → i1, . . . , ip → jp] | o ∈ O} and O is also an ontology over D. 3.3
Rebasing ontologies to avoid name clashing We now address a practical issue commonly found when partially instantiating the same pattern twice as part of the same ontology. Imagine that we instantiate the city pattern for French and German cities, and do not want to name isPartOf differently in each case. The following axioms would be part of the result: ∀isPartOf−1.GermanCity ∀isPartOf−1.FrenchCity which implies that either isPartOf is empty or GermanCity and FrenchCity are related (one is a subclass of the other).
occur in non-instantiable elements. The pattern designer may document or avoid these issues, but it is the responsibility of the pattern user to make sure that no inconsistencies are introduced with multiple instantiations of a pattern.
entities at once, thus avoiding all name clashes of non-instanced local names.
of namespaces, such that C = M × Cu, R = M × Ru, and I = M × Iu. Like before, Cu, Ru and Iu are pairwise disjoint.
Let O be an ontology, and m, m ∈ M two namespaces. We define the rebasing of O from m to m , and we represent it as Om→m , as the ontology {o[f ] | o ∈ O} where f is the substitution function defined by the relation {(x, y) ∈ C ∪ R ∪ I × C ∪ R ∪ I | ∃z ∈ (Cu ∪ Ru ∪ Iu) x = m, z ∧ y = m , z }.
We say that an ontology O is an instantiation of the pattern P with the namespace change from m to m and the mappings [e1 → d1, . . . , en → dn] if O = O m→m and O is an instantiation of the pattern P with the mappings [e1 → d1, . . . , en → dn].
For example, assume we use http://foo/Cities as the base URI of the cities pattern and http://foo/Cities#isPartOf as the qualified name of isPartOf. If we set http://foo/FCities and http://foo/GCities as the base URIs of the instances for French and German cities respectively, applying the new pattern instance definition with the same mappings as before would give us the following axioms instead, where no name clashes occur: ∀http://foo/GCities#isPartOf−1.http://foo/GCities#GermanCity ∀http://foo/FCities#isPartOf−1.http://foo/FCities#FrenchCity 4
Pattern definition. Patterns are defined as ontologies with an interface, hence
to define patterns we simply need to support interface declaration. For this
purpose, we have developed:
– An ontology [
the pattern to be used, establishing a parameter/value map and a URI rebasing.
– An ontology [
– An ontology [
The new Prot´eg´e plugin is accessible under the menu Tools, as an import wizard. The process is divided in three steps. First, the location of a pattern definition (an ontology) is provided. Second, the plugin shows all the elements in that pattern that are exportable. The user can then introduce the main information about the instantiation, that is, the new names for each entity that will be instantiated, and the URI rebase. Third, the plugin allows the user to select a location where the instantiation will be saved. This will create an ontology with all the information of this particular instantiation (the entity mappings and the
rebase and entity mapping, and adds all the axioms into the currently active ontology. It also annotates the ontology with the property isPatternInstance, using the base URI of the pattern instance definition as value. 5
interface (as if they were parametric ontologies), and how pattern instantiations can be formalised as a substitution of the parameters in a pattern ontology, providing formal definitions for both concepts. We have also analysed some of the problems derived from multiple pattern instantiation, and suggested ontology rebasing as a way to avoid name clashes.
presented as part of an ontology modification language (OPPL), not focusing on pattern reuse specifically. There are also some relationships with Package-Based
The current OWL syntax and tool support is built completely around annotation properties. Prot´eg´e plugins are based on the OWLAPI library, and they are currently in an early beta-testing state of development. In future versions of the syntax, we plan to keep annotation properties to indicate if an element is instantiable in a pattern, and add support for pattern imports to the modules mechanism in OWL. This could be done by extending owl:imports with a nested tag owl:patterninstance, which in turn would have from uri and to uri attributes for the rebasing. Also, nested owl:mapping elements with attributes from name and to name could be used for the element/value assignations. The meaning of these attributes, their domain and range, would be according to what was established in the Pattern Instance definition ontology, in section 4.
allows roles, concepts and individuals to be treated as parameters. This may be sufficient in most cases, but it might be interesting to have other parametrisable parts of an ontology. For instance, numbers in cardinality restrictions could also be parameters. Note that the introduction of parametricity at this level would likely make the pattern definition no longer be an ontology.