There is a diversity of ontology languages in use, among them OWL, RDF, OBO, Common Logic, and F-logic. Related languages such as UML class diagrams, entity-relationship diagrams and object role modelling provide bridges from ontology modelling to applications, e.g. in software engineering and databases. Another diversity appears at the level of ontology modularity and relations among ontologies. There is ontology matching and alignment, module extraction, interpolation, ontologies linked by bridges, interpretation and refinement, and combination of ontologies. The Distributed Ontology, Modelling and Specification Language (DOL) aims at providing a unified meta language for handling this diversity. In particular, DOL provides constructs for (1) “as-is” use of ontologies formulated in a specific ontology language, (2) ontologies formalised in heterogeneous logics, (3) modular ontologies, and (4) links between ontologies. This paper sketches the design of the DOL language. DOL will be submitted as a proposal within the OntoIOp (Ontology Integration and Interoperability) standardisation activity of the Object Management Group (OMG).
OWL is a popular language for ontologies.5 Yet, the restriction to a decidable description logic often hinders ontology designers from expressing knowledge that cannot (or can only in quite complicated ways) be expressed in a description logic. A practice to deal with this problem is to intersperse OWL ontologies with first-order axioms, e.g. in the case of bio-ontologies where mereological relations such as parthood are of great importance, though only partly definable in OWL. However, these remain informal annotations to inform the human designer, rather than first-class citizens of the ontology with formal semantics and impact on reasoning. One goal of the Distributed Ontology, Modelling and Specification Language (DOL), discussed in detail in this paper, is therefore to equip such heterogeneous ontologies with a precise semantics and proof theory. 5 We adopt the completely formal position that an ontology is a formal theory in a given ontology language, and that an ontology language is any logical language that some community considers suitable for ontology design.
A variety of languages is used for formalising ontologies. Some of these, such as RDF (mostly used for linked data), OBO and certain6 UML class diagrams, can be seen more or less as fragments and notational variants of OWL, while others, such as F-logic and Common Logic (CL), clearly go beyond the expressiveness of OWL.
We face this diversity not by proposing yet another ontology language that
would subsume all the others, but by accepting this pluralism in ontology
languages and by formulating means (on a sound and formal semantic basis) to
compare and integrate ontologies written in different formalisms. This view is
a bit different from that of unifying languages such as OWL and CL, which are
meant to be “universal” formalisms (for a certain domain/application field), into
which everything else can be mapped and represented. While such “universal”
formalisms are clearly important and helpful for reducing the diversity of
formalisms, it is still a matter of fact that no single formalism will be the Esperanto
that is used by everybody [
DOL enjoys the following distinctive features:
– modular and distributed ontologies are specially supported,
– ontologies can not only be aligned (as in BioPortal [37] and NeON [
The paper is organised as follows: we first discuss the theoretical foundations of DOL in Section 2, followed by a sketch of the DOL language itself in Section 3. Section 4 briefly discusses the DOL-enabled, web-based ontology repository engine Ontohub, and Section 5 concludes. 2
The Distributed Ontology, Modelling and Specification Language (DOL)7 aims
at providing a unified framework for (1) “as-is” use of ontologies formulated in
6 Those avoiding qualified associations (amounting to identification constraints), n-ary
relations (for n > 2) and stereotyping.
7 DOL has formerly been standardised within ISO/TC 37/SC 3. The OntoIOp
(Ontology Integration and Interoperability) activity is now being continued at OMG,
see the project page at http://ontoiop.org.
a specific ontology language, (2) ontologies formalised in heterogeneous logics,
(3) modular ontologies, and (4) links between ontologies. Historically, the design
of DOL has inherited many ideas and features (1) discussed in the Workshop on
Modular Ontologies series [
A distributed ontology in DOL consists of modules formalised in basic
ontology languages, such as OWL (based on description logic) or Common Logic
(based on first-order logic with some second-order features). These modules
are serialised in the existing syntaxes of these languages in order to facilitate
reuse of existing ontologies. DOL adds a meta-level on top, which allows for
expressing heterogeneous ontologies and links between ontologies.9 Such links
include (heterogeneous) imports and alignments, conservative extensions
(important for studying ontology modules), and theory interpretations (important
for reusing proofs). Thus, DOL gives ontology interoperability a formal
grounding and makes heterogeneous ontologies and services based on them amenable
to automated verification. The basic syntax and semantics of DOL has been
introduced in [35, 34], and the general theory of heterogeneous specifications
for ontologies in [
The large variety of logical languages in use can be captured at an abstract
level using the concept of institutions [
Institutions also provide a model theory, which introduces semantics for the language and gives a satisfaction relation between the models and the sentences of a signature. The only restriction imposed is the satisfaction condition, which captures the idea that truth is invariant under change of notation (and enlargement of context) along signature morphisms. This relies on two further components of institutions: the translation of sentences along signature morphisms, and 8 See http://ifipwg13.informatik.uni-bremen.de 9 The languages that we call “basic” ontology languages here are usually limited to one logic and do not provide meta-theoretical constructs. the reduction of models against signature morphisms (generalising the notion of model reduct known from logic).
It is also possible to complement an institution with a proof theory,
introducing a derivability relation between sentences, formalised as an entailment system
[
Example 1. OWL signatures consist of sets of atomic classes, individuals and properties. OWL signature morphisms map classes to classes, individuals to individuals, and properties to properties. For an OWL signature Σ, sentences are subsumption relations between classes or properties, membership assertions of individuals in classes and pairs of individuals in properties, complex role inclusions, and some more. Sentence translation along a signature morphism simply replaces non-logical symbols with their image along the morphism. The kinds of symbols are class, individual, object property and data property, respectively, and the set of symbols of a signature is the union of its sets of classes, individuals and properties. Models are (unsorted) first-order structures that interpret concepts as unary and properties as binary predicates, and individuals as elements of the universe of the structure, and satisfaction is the standard satisfaction of description logics. This gives us an institution for OWL.
In this framework, a basic ontology O over an institution I is a pair (Σ, E) where Σ is a signature and E is a set of Σ-sentences. Given a basic ontology O, we denote by Sig(O) the signature of the ontology. An ontology morphism σ : (Σ1, E1) → (Σ2, E2) is a signature morphism σ : Σ1 → Σ2 such that σ(E1) is a logical consequence of E2.
Several notions of translations between institutions can be introduced. The
most frequently used variant are institution comorphisms [
Figure 1 shows a conceptual hierarchy of mappings.10 Mappings are split
along the following dichotomies:
– translation versus projection: a translation embeds or encodes a logic into
another one, while a projection is a forgetful operation (e.g. the
projection from first-order logic to propositional logic forgets predicates with arity
greater than zero). Technically, the distinction is that between institution
comorphisms and morphisms.
– plain mapping versus simple theoroidal mapping [
Mappings can also be classified according to their accuracy; see [33] for
details. Sublogics are the most accurate mappings: they are syntactic subsets.
Embeddings come close to sublogics, like injective functions come close to subsets. A
mapping can be faithful in the sense that logical consequence (or logical
deduction) is preserved and reflected, that is, inference systems and reasoning engines
for the target logic can be reused for the source logic (along the mapping).
(Weak) exactness is a technical property that guarantees this faithfulness even
in the presences of ontology structuring operations [
Figure 2 is a revised and extended version of the graph of logics and translations introduced in [33]. New nodes include UML class diagrams, OWL-Full (i.e. OWL with an RDF semantics instead of description logic semantics), and Common Logic without second-order features (CL−). We have defined the translations between most of these logics in earlier publications [35, 33]. The definitions of the DOL conformance of some central standard ontology languages and translations among them will be given as annexes to the standard and published in an open registry, which is also the place where the remaining definitions will be maintained (cf. Section 2.3). 2.3
Beyond those shown so far, it will be possible to use any (future) language or mapping (in the sense of Section 2.1) with DOL. We host a registry to which EL++ (OWL 2 EL)
DL-LiteR (OWL 2 QL)
DL-RL (OWL 2 RL)
Prop UML-CD Schema.org
DDLOWL ECoOWL
EER
SROIQ (OWL 2 DL) ECoFOL
OWL-Ful
OBOOWL OBO 1.4 F-logic
RDF
RDFS
FOL=
FOLms=
CASL
HOL
subinstitute
theoroidal subinstitute
simultaneously exact and
model-expansive comorphisms
model-expansive comorphisms
grey: no fixed expressivity
green: decidable ontology languages
yellow: semi-decidable
orange: some second-order constructs
red: ful second-order logic
the community can contribute descriptions of any languages and mappings11,
as well as logics and serialisations (i.e. concrete syntaxes of languages).12 The
LoLa (“logics and languages”) ontology formalises these notions [
Figure 3 shows the top-level classes of LoLa’s OWL module, axiomatising
logics, languages, and mappings. Object-level classes (that is, classes providing
the vocabulary for expressing distributed ontologies) comprise ontologies, their
constituents (namely symbols and sentences), as well as links between
ontologies. Mappings are modelled as shown in Figure 1: by a hierarchy of properties
corresponding to the different types of edges in Figure 2. The full LoLa ontology
is available at http://purl.net/dol/1.0/rdf#.
11 As distributed ontologies refer to languages and mappings by IRIs, third parties may
also set up their own, decentral registry extensions.
12 The OWL 2 DL language is, e.g., exactly as expressive as the logic SROIQ(D) [
Many (domain) ontologies are written in DLs such as SROIQ and its profiles. These logics are characterised by having a rather fine-tuned expressiveness, exhibiting (still) decidable satisfiability problems, whilst being amenable to highly optimised implementations.
However, expressiveness beyond standard DLs is required for many foundational ontologies (as well as bio-medical ontologies), for instance Dolce13, BFO14, or GFO15. Moreover, for practical purposes, these foundational ontologies also come in different versions ranging in expressiveness, typically between OWL (e.g. Dolce Light, BFO-OWL) and first-order (Dolce, GFO) or even second-order logic (BFO-Isabelle).
The relation between such different versions, OWL and first-order, may be
recorded in various ways. In some cases it is primarily discussed in the research
literature, see Keet’s mereo-topological ontology [
Consider the BFO-OWL object property temporalPartOf. The OWL axiomatisation states this to be a transitive subproperty of occurrentPartOf, and the inverse of hasTemporalPart.16 This property is, however, annotated in a rich way, containing example usages, a richer first-order axiomatisation of this property with pointers to the corresponding axioms in the first-order version, as well as natural language renderings of these axioms. The logical part of this annotation may be captured in DOL as follows: an OWL ontology first lists the entire OWL axiomatisation of BFO. In a second step, we import this OWL ontology along a translation to Common Logic, and subsequently extend the resulting firstorder version of BFO-OWL with the first-order axioms previously only listed as comments. We obtain a two-level specification of BFO: the original OWL part (supported by OWL reasoners) and the full first-order part in Common Logic (amenable to first-order theorem proving and non-conservatively extending the OWL consequences). 3.2
The DOL language is not “yet another ontology language”, but a meta language for expressing relations between ontologies. Therefore, any ontology written in any conforming ontology language also is a DOL ontology. This has the clear 13 See http://www.loa.istc.cnr.it/DOLCE.html 14 See http://www.ifomis.org/bfo/ 15 See http://www.onto-med.de/ontologies/gfo/ 16 Parthood, typically understood as an anti-symmetric relation in mereology, is the canonical example of a relation that cannot be adequately formalised in OWL; a corresponding comment can be found in many bio-medical ontologies. advantage that users can leave their ontologies as they are when working with DOL.
DOL provides two main abstract syntax categories: 1. Modular and heterogeneous ontologies. Such an ontology is written in a modular way, with the help of structuring operations. The semantics of ontologies is given by a signature and a class of models. In some cases, we can additionally provide a theory-level semantics of ontologies, as a signature and a class of sentences that, if it exists, agrees with the model-level semantics (that is, the model class is equal to the class of models satisfying the theory). We call an ontology flattenable if it has a theory-level semantics and elusive if it only admits a model-level semantics. This can be decided according to the outermost structuring operation on ontologies, as follows: Flattenable ontologies: basic ontologies, extension, union, translation, interpolate/forget, extract, reference, qualification, combination, bridge. Among these operations, interpolate/forget and extract can only be applied to flattenable ontologies.
Elusive ontologies: reduction, minimisation and maximisation.
For detailed definitions of these types of ontologies, see Section 3.3. 2. Distributed ontologies. These consist of of a list of declarations involving (possibly modular and/or heterogeneous) ontologies. These declarations can be ontology definitions (assigning a name to an ontology), interpretations (specifying a logical consequence relationship between ontologies), equivalences of ontologies (specifying that their model classes are in bijective correspondence), module relations (between ontologies and their modules), ontology alignments, and qualifications of the language, logic and/or serialisation. This will be detailed in Section 3.4. 3.3
A (possibly modular and/or heterogeneous) ontology can be one of the following: (a) a basic ontology O written inline, in a conforming ontology language and serialisation. The semantics is inherited from the ontology language. O can also be an ontology fragment, which means that some of the symbols or axioms may refer to symbols declared outside O (i.e. in an imported ontology). This is mainly used for extensions and equivalences. Here are two sample ontologies in OWL (using Manchester syntax) and Common Logic (using CLIF): Class: Woman EquivalentTo: Person and Female ObjectProperty: hasParent (cl-module PreOrder (forall (x) (le x x)) (forall (x y z) (if (and (le x y) (le y z)) (le x z)))) (b) an ontology qualified with the ontology language that is used to express it (written language l : O, where l identifies a language). Similarly, qualifications can also be by logic (written logic l : O), and/or serialisation (written syntax s : O).17 (c) an IRI reference to an ontology existing on the Web18, possibly abbreviated using prefixes.19 For example: %prefix(
co-ode: <http://owl.cs.manchester.ac.uk/co-ode-files/ontologies/> )% http://owl.cs.manchester.ac.uk/co-ode-files/ontologies/pizza.owl co-ode:pizza.owl (d) an extension of an ontology by new symbols and axioms, written O1 then O2, where O2 is an ontology (fragment) in a conforming ontology language. The resulting signature is that of O1, augmented with the symbols in O2. A model of an extension ontology is a model of this signature, that satisfies the axioms on O2 and is (when appropriately reduced) a model of O1. An extension can optionally be marked as conservative (%mcons or %ccons after the “then”). The semantics is that each O1-model must have at least one expansion to the whole extension O1 then O2 (for %mcons) resp. that each logical consequence of O1 then O2 is already one of O1 if it is over the signature of O1 (for %ccons). In case that O2 does not introduce any new symbols, the keyword %implied can be used instead of %ccons or %mcons; the extension then merely states intended logical consequences. The keyword %def stands for definitional extensions. This is similar to %mcons, but the model expansion must always exist uniquely. The following OWL ontology is an example for the latter:
Class Person
Class Female then %def
Class: Woman EquivalentTo: Person and Female (e) a union of two self-contained ontologies (not fragments), written O1 and O2.
Models of this union are those models that are (perhaps after appropriate reduction) models of both O1 and O2. For example, the class of commutative monoids can be expressed as algebra:Monoid and algebra:Commutative Forming a union of ontologies is a particularly common operation in the RDF logic, where it is known as merging graphs [15, section 0.3]; however, the RDF language provides no explicit syntax for this operation. When multiple RDF ontologies (“graphs”) contain statements about the same symbol (“resource”), i.e., syntactically, triples having the same subject, the effect 17 Some of the following listings omit obvious qualifications for readability. 18 Note that not all ontologies can be downloaded by dereferencing their IRIs. Implementing a catalogue mechanism in DOL-aware applications might remedy this problem. 19 Some of the following listings abbreviate IRIs using prefixes but omit the prefix bindings for readability.
is that in the merged graph the resource will have all properties that have previously been stated about it separately. Different kinds of properties, e.g. multilingual labels, geodata, or outgoing links to external graphs, are often maintained in different RDF graphs, which are then merged; consider the following excerpt: { :UniBremen rdfs:label "Université de Brême"@fr . } and { :UniBremen geo:lat "53.108612"^^xsd:float . } and { :UniBremen owl:sameAs20
<http://dbpedia.org/page/University_of_Bremen> . } (f) a translation of an ontology to a different signature (written O with σ, where σ is a signature morphism) or into some ontology language (written O with translation ρ, where ρ is an institution comorphism). For example, we can combine an OWL ontology with a first-order axiom (formulated in Common Logic) as follows: ObjectProperty: isProperPartOf
Characteristics: Asymmetric
SubPropertyOf: isPartOf with translation trans:SROIQtoCL then
(if (and (isProperPartOf x y) (isProperPartOf y z)) (isProperPartOf x z)) Note that OWL can express transitivity, but not together with asymmetry. (g) a reduction of an ontology to a smaller signature Σ is written O reveal Σ.
Alternatively, it can be written O hide Σ, where Σ is the set of symbols to be hidden (i.e. this is equivalent to O reveal Sig(O) \ Σ). The effect is an existential quantification over all hidden symbols. For example, when specifying a group in sorted first-order logic, using the CASL language, sort Elem ops 0: Elem; __+__: Elem * Elem -> Elem; inv: Elem -> Elem forall x,y,z . 0 + x = x . x + (y + z) = (x + y) + z . x + inv(x) = 0 reveal Elem, 0, __+__ revealing everything except the inverse operation inv results in a specification of the class of all monoids that can be extended with an inverse operation, i.e. the class of all groups with inverse left implicit.
Here is an example of hiding:
ontology Pizza = %% a simplified remake of the Pizza ontology [
EquivalentTo: { TomatoTopping, MozzarellaTopping, ... } 20 While owl:sameAs is borrowed from the vocabulary of OWL, it is commonly used in the RDF logic to link to resources in external graphs, which should be treated as if their IRI were the same as the subject’s IRI.
Class: VegetarianPizza SubClassOf: some hasTopping VegetarianTopping ... end ontology Pizza_hide_VegetarianTopping =
Pizza hide VegetarianTopping end A reduction to a less expressive logic is written O hide along μ, where μ is an institution morphism. This is a common operation in TBox/ABox settings, where an ontology in an expressive language provides the terminology (TBox) used in assertions (ABox) stated in a logic that is less expressive but scales to larger data sets; OWL DL (whose logic is SROIQ) vs. RDF is a typical language combination: ontology TBoxABox =
Pizza hide along trans:SROIQtoRDF then language lang:RDF syntax ser:RDF/Turtle : { :myPizza :hasTopping
[ a :TomatoTopping ], [ a :MozzarellaTopping ] .
}
(h) an interpolation of an ontology, either in a subsignature or a sublogic,
optionally with respect to a logic L (written O keep in Σ with L, where
Σ is a signature or a logic and L is a logic)21. The effect is that sentences
not expressible in Σ are weakened or removed, but the resulting theory still
has the same L-consequences. The “with L” is optional, it defaults to the
logic of O. Technically, this is a uniform interpolant [
Pizza forget VegetarianTopping This has a theory-level semantics, i.e. yields a theory in the reduced signature (without VegetarianTopping). By contrast Pizza hide VegetarianTopping has a model-level semantics. (i) a module extracted from an ontology, written O extract c Σ with m. Here, Σ is a restriction signature (which needs to be a subsignature of Sig(O)), c is one of %mcons and %ccons, and m identifies a module extraction method. The extracted module is a subontology of O with signature larger than (or equal to) Σ, such that O is a conservative extension of the extracted module. 21 It is also possible to specify a signature and a logic simultaneously: O keep in Σ, L1 with L2 22 Interpolants need not always exist, and even if they do, tools might only be able to approximate them.
Dually, O remove c Σ with m extracts w.r.t. the signature Sig(O) \ Σ.23 For example, using the syntactic locality-* extraction method [38]: Pizza remove %mcons
VegetarianTopping with <http://example.org/onto/module/syntactic-locality-*> which captures the theory of Pizza hide VegetarianTopping. Note that there is a subtle difference between (model-theoretic) hiding and (consequencetheoretic) forgetting: a model satisfying the theory of O hide Σ might itself not be a model of O hide Σ. In examples involving “with L”, the uniform interpolant can be weaker than the hiding, because it is only required to have the same logical consequences in some language L, and a formula like (*) might not be a formula of L. Finally, an extracted module does not contain (*), because it only selects a subontology, and Pizza does not contain (*). Note that while forget/keep and hide/reveal both work w.r.t. smaller signatures and sublogics, remove/extract does not work for sublogics. This is because remove/extract must always respect the conservative extension property, which may not be possible when projecting to a sublogic. And if conservativity cannot be guaranteed, then forget/keep can be used in any case. (j) a combination of ontologies, written combine O1, . . . , On L1, . . . , Lm. Here the Lj are links between ontologies, see below. For disambiguating the symbols in the combined ontology, the individual ontologies can be prefixed with labels, like n : O, which are scoped to the current distributed ontology. The simplest example of a combination is a disjoint union (we here translate OWL ontologies into many-sorted OWL in order to be able to distinguish between different universes of individuals): ontology Publications1 =
Class: Publication Class: Article SubClassOf: Publication
Class: InBook SubClassOf: Publication
23 Note that the resulting module can still contain symbols from Σ, because the
resulting signature may be enlarged.
hide/reveal
semantic background
relation to original
approach
type of ontology
signature of result
change of logic
conservative
extension
subtheory
theory level
flattenable
≥ Σ
not possible
interpretable interpretable
uniform
interpolation
theory level
flattenable
= Σ
possible
model reduct
model level
elusive
= Σ
possible
(This example will be continued using bridges below.) If links or alignments
are present, the semantics of a combination is a quotient of a disjoint union
(aligned symbols are identified). Technically, this is a colimit, see [
Class: Block Individual: B1 Types: Block
Individual: B2 Types: Block DifferentFrom: B1 then minimize {
Class: Abnormal
Individual: B1 Types: Abnormal } then
Class: OnTable Class: BlockNotAbnormal EquivalentTo:
Block and not Abnormal SubClassOf: OnTable then %implied
Individual: B2 Types: OnTable
Dually to minimisations, there are also maximisations.
(l) an ontology bridge, written O1 bridge with translation t O2, where t is
a logic translation. The semantics is that of O1 with translation t then
O2. Typically, t will translate a language like OWL to some language for
distributed description logic or E -connections [
v 1:Publication −→ 2:Publication
v 1:PhdThesis −→ 2:Thesis
v 1:InBook −→ 2:BookArticle
v 1:Article −→ 2:Article
w 1:Article −→ 2:Article end 3.4
Distributed ontologies. These have an optional identifier, declared with distributed ontology Id, and consist of (a) ontology definitions, written ontology Id = O. For example, ontology co-code:Pizza =
Class: VegetarianPizza Class: VegetableTopping ObjectProperty: hasTopping ...
end
(b) theory interpretations, written interpretation Id : O1 to O2 = σ,
expressing that the σ-reduct of each model of O2 is a model of O1. Instead of σ,
an institution comorphism can be referred to. For example, we can express
that the natural numbers are a total order as follows:
interpretation i : TotalOrder to Nat = Elem 7→ Nat
Here is a more complex example in Common Logic from the COLORE
repository [
and int:mappings/owltime_interval_reduction }
= int:ProperInterval 7→ int:Interval end
(c) ontology equivalences, written equivalence Id : O1 ↔ O2 = O3 along
ρ1, ρ2, expressing that O1 and O2 have model classes that are in bijective
correspondence. This is done by providing a (fragment) ontology O3 such
that ρi(Oi) then O3 is a definitional extension [
end
(d) module relations, written module Id c : O1 of O2 for Σ. This expresses
that O1 is a module of O2 with restriction signature Σ and conservativity
c. If c is %mcons, this means that every Σ-reduct of an O1-model can be
expanded to an O2-model. If c is %ccons, this means that every Σ-sentence
ϕ following from O2 already follows from O1. This relation shall hold for any
module O1 extracted from O2 using the extract construct.
(e) alignment definitions, written alignment Id card1 card2 : O1 to O2 =
c1, . . . , cn, where card1 resp. card2 specify constraints on the alignment
relation concerning the source resp. target. Each cardi is one of 1, ?, +, *
(‘1’ for injective and total, ‘+’ for total, ‘?’ for injective and ‘*’ for none).
The cj are correspondences of form sym1 rel conf sym2. Here, symi is a
symbol from Oi, rel is one of the built-in relations >, <, =, %, 3, ∈, 7→,
or an identifier of a relation specified externally, and conf is an (optional)
confidence value between 0 and 1. This syntax of alignments follows the
Alignment API [
<http://www.example.org/alignment#> 24 Note that BioPortal’s [37] mappings are correspondences in the sense of the Alignment API and hence of DOL. BioPortal only allows users to collect correspondences, but not to group them into alignments. In a sense, for each pair of ontologies, all BioPortal users contribute to a big alignment between these.
lang: <http://purl.net/dol/languages/> ser: <http://purl.net/dol/serializations/> trans: <http://purl.net/dol/translations/> )% distributed ontology Alignments language lang:OWL2/DL syntax ser:OWL2/Manchester alignment Alignment1 : { Class: Woman } to { Class: Person } =
Woman < Person end ontology AlignedOntology1 =
combine Alignment1 end ontology Onto1 =
Class: Person Class: Woman SubClassOf: Person
Class: Bank end ontology Onto2 =
Class: HumanBeing Class: Woman SubClassOf: HumanBeing
Class: Bank end alignment VAlignment : Onto1 to Onto2 =
Person = HumanBeing,
Woman = Woman end ontology VAlignedOntology = combine 1 : Onto1, 2 : Onto2, VAlignment %% 1:Person is identified with 2:HumanBeing %% 1:Woman is identified with 2:Woman %% 1:Bank and 2:Bank are kept distinct end ontology VAlignedOntologyRenamed =
VAlignedOntology with 1:Bank 7→ RiverBank, 2:Bank 7→ FinancialBank,
Person_HumanBeing 7→ Person end (f) qualifications choosing the ontology language, logic, and/or serialisation.
This is written language Id, logic Id and/or syntax Id, referring to entries of a registry as explained in Section 2.3, and affects the subsequent definitions in the distributed ontology.
This completes our overview of DOL. The full syntax and semantics of DOL will be available at wiki.ontohub.org and later submitted to OMG for standardisation.
Note that we have not covered the role of annotations in DOL so far. For structured annotation of ontologies and their parts, e.g. with metadata, or possibly with ontological relations not built into DOL’s syntax, DOL does not provide its own syntax, but relies on the existing RDF standard. DOL allows for giving identifiers to all entities of distributed ontologies and basic ontologies25 and thus enables their annotation. Annotations can be maintained in an RDF ontology that is a part of the distributed ontology. 4
25 When a basic ontology language has no mechanism for annotating or assigning identifiers to some ontology entities (as with imports in OWL or sentences in Common Logic), DOL provides a special comment syntax for injecting identifiers into basic ontologies written inline. Where identifiers in a basic ontology language are not IRIs, DOL allows for making them accessible as IRIs. 26 Ontohub’s sources are freely available at https://github.com/ontohub/ontohub. as described in this paper.27 The structural information extracted from DOL ontologies by Hets is stored in the Ontohub database and exposed to human users via a web interface and to machine clients as linked data.28 5
The Distributed Ontology, Modelling and Specification Language (DOL)
integrates different lines of research that have been reflected in the WoMO
community (see [
FOL).
DOL provides a unified meta language for these (and more) concepts, with a clean formal semantics. Tool support is provided by the Heterogeneous Tool Set (Hets) and by ontohub.org. The latter will also be used for the FOIS 2014 ontology competition. Since ontologies used in FOIS papers often need expressiveness beyond OWL, the multi-logic nature of DOL and Ontohub is essential. A number of open problems and challenges remain: – What is a suitable abstract meta framework for non-monotonic logics and rule languages such as RIF and RuleML? Are institutions suitable here? Are the modularity questions for these languages different from those for OWL? – What is a useful abstract notion of ontology query (language)? How to handle answer substitutions in a logic-agnostic way? – Can the notions of class hierarchy and of satisfiability of a class be generalised from OWL to other languages? – Can logical frameworks be used for the specification of ontology languages and translations?
The development of DOL is supported by the German Research Foundation
(DFG), Project I1-[OntoSpace] of the SFB/TR 8 “Spatial Cognition”. Mihai
Codescu was supported by the DFG, project SCHR1118-7-1. Christoph Lange
was supported by EPSRC grant EP/J007498/1. The authors would like to
27 Some (but only few) of DOL’s features are still being implemented at the time of
the writing of this paper.
28 “Linked data” is a set of best practises for publishing structured data on the Web
in a machine-friendly way [
In TACAS 2007. Ed. by O. Grumberg and M. Huth. Vol. 4424. Lecture Notes in Computer Science. Springer-Verlag Heidelberg, 2007, pp. 519–522. 37. Noy, N. F., Shah, N. H., Patricia L. Whetzel, ., Dai, B., Dorf, M., Griffith, N., Jonquet, C., Rubin, D. L., Storey, M.-A., Chute, C. G., and Musen, M. A. BioPortal: ontologies and integrated data resources at the click of a mouse. In Nucleic Acids Research 37 (2009). http://bioportal.bioontology.org, W170–W173. 38. Sattler, U., Schneider, T., and Zakharyaschev, M. Which Kind of Module Should I Extract? In Proceedings 22nd Int. Workshop on Description Logics (DL).
Vol. 477. CEUR Workshop Proceedings. CEUR-WS.org, 2009. 39. Sattler, U. and Tamilin, A., eds. Workshop on Ontologies: Reasoning and Modularity (WORM-08). Vol. Vol-348. (ESWC) Tenerife, Spain: CEUR Workshop Proceedings, 2008. http://ftp.informatik.rwth- aachen.de/Publications/CEURWS/Vol-348/. 40. Schneider, T. and Walther, D., eds. Proc. of the 6h Int. Workshop on Modular
Ontologies. Vol. 875. CEUR-WS, 2012. 41. Wang, Z., Wang, K., Topor, R. W., and Pan, J. Z. Forgetting for knowledge bases in DL-Lite. In Ann. Math. Artif. Intell. 58 , 1–2 (2010), pp. 117–151. 42. Zimmermann, A., Krötzsch, M., Euzenat, J., and Hitzler, P. Formalizing Ontology Alignment and its Operations with Category Theory. In Proc. of FOIS06. 2006, pp. 277–288.