The Distributed Ontology Language (DOL), currently being standardised within the OntoIOp (Ontology Integration and Interoperability) activity of ISO/TC 37/SC 3, aims at providing a unified framework for (1) ontologies formalised in heterogeneous logics, (2) modular ontologies, (3) links between ontologies, and (4) annotation of ontologies. This paper focuses on the LoLa ontology, which formally describes DOL's vocabulary for logics, ontology languages (and their serialisations), as well as logic translations. Interestingly, to adequately formalise the logical relationships between these notions, LoLa itself needs to be axiomatised heterogeneously-a task for which we choose DOL. Namely, we use the logic RDF for ABox assertions, OWL for basic axiomatisations of various modules concerning logics, languages, and translations, FOL for capturing certain closure rules that are not expressible in OWL4, and circumscription for minimising the extension of concepts describing default translations.
a large number of communities in ontological research and application, such as different (1) ontology languages and logics (e.g. Common Logic and OWL), (2) conceptual and theoretical foundations (e.g. model theory, proof theory), (3) technical foundations (e.g. ontology engineering methodologies and linked open data), and (4) application areas (e.g. manufacturing, bio-medicine, etc.). For details and earlier publications, see the project page at http://ontoiop.org.
The OntoIOp/DOL standard is currently in its final working draft stage and
will be submitted as a committee draft (the first formal standardisation stage)
in September 2012.7 The final international standard ISO 17347 is scheduled for
2015. The standard specifies syntax, semantics, and conformance criteria:
Syntax: abstract syntax of distributed ontologies and their parts; three concrete
syntaxes: a text-oriented one for humans, XML and RDF for exchange among
tools and services, where RDF particularly addresses exchange on the Web.
Here, we will use the DOL text syntax in listings but also explain the RDF
vocabulary; for further details on the DOL syntaxes, see [
Semantics: (1) a direct set-theoretical semantics for the core of the language,
extended by an institutional and category-theoretic semantics for advanced
features such as ontology combinations (technically co-limits), where basic
ontologies keep their original semantics; (2) a translational semantics,
employing the semantics of the expressive Common Logic ontology language for
all basic ontologies, taking advantage of the fact that for all basic ontology
languages known so far translations to Common Logic have been specified
or are known to exist8; (3) finally, there is the option of providing a collapsed
semantics, where the semantics of the meta-theoretical language level
provided by DOL (logically heterogeneous ontologies and links between them)
is not just specified in semiformal mathematical textbook style, but once
more formalised in Common Logic, thus in principle allowing for machine
verification of meta properties. For details about the semantics, see [
UML-CD EL++ (OWL 2 EL) DL-LiteR (OWL 2 QL) DL-RL (OWL 2 RL) DDLOWL ECoOWL SROIQ (OWL 2 DL) OWL-Ful Rel-S ECoFOL F-logic OBOOWL OBO 1.4 bRDF
The OntoIOp standard is not limited to a fixed set of ontology languages. It will be possible to use any (future) ontology language, logic, serialisation, or mapping (translation or projection) with DOL, once its conformance with the criteria specified in the standard has been established. This led to the idea of setting up a registry to which the community can contribute descriptions of any such languages, logics, serialisations, or mappings. In the current, early phase of the standardisation process, we are maintaining this registry manually. With the release of the final international standard, everyone will be able to make contributions, which an editorial board will review and approve or reject. Fig. 2
shows a subset of the OntoIOp registry: a subgraph of Fig. 1 in the “logic” column, as well as related ontology languages and serialisations. Note that the relation between ontology languages and logics generally is not bijective: e.g. first-order logic is supported by various languages such as Common Logic, TPTP and CASL.
Any entry of the registry shall be identified by an IRI, so that DOL ontologies
can refer to it. At these IRIs, when treated as URLs, there shall be a
machinereadable description of the resource according to the linked data principles (cf.
[
Starting with a plain RDFS vocabulary, we soon realised that we could deliver added value to tools supporting DOL by encoding additional information about the semantics of, e.g., translations into the vocabulary using some OWL constructs, and eventually arrived at a richer formalisation that goes beyond 9 RDF only allows for describing, not for fully formally defining logics and translations.
To that end, we are planning to alternatively offer full formalisations in the richer OMDoc language from the same IRIs.
OWL: the LoLa ontology. To realise the benefit of a machine-comprehensible representation of this semantics in a rich ontology language, consider DOL’s understanding of an ontology language translation: Unless a direct translation on the language level has been specified (e.g. from Common Logic to CASL), one can translate an ontology from a language La to La0 if the expressivity of these languages is exactly captured by two logics Lo and Lo0, and Lo can (possibly transitively) be translated to Lo0. In a plain RDF graph, this would require multiple lookups. 4
LoLa, the ontology of logics and languages, is implemented as a heterogeneous
ontology in DOL, consisting of the following modules:
– An OWL core provides classes and properties for the basic concepts,
including a basic axiomatisation.
– We use additional FOL axioms for closure rules not expressible in OWL,
such as non-expressible role compositions.
– We use circumscription [
The OntoIOp registry, is implemented as an RDF dataset, acting as the ABox of the LoLa ontology. The OntoIOp registry is available through a collection of linked data IRIs in the paths http://purl.net/dol/{logics,languages, serializations,translations}, e.g. http://purl.net/dol/logics/SROIQ for the logic SROIQ. We made it originally available in RDF/XML, the most widely supported linked data format, but other syntaxes can be provided as well. It can be browsed with frontends like uriburner; try, e.g., http://linkeddata. uriburner.com/about/html/http/purl.net/dol/logics/SROIQ.
The OWL core of the LoLa ontology comprises classes for ontology languages, logics, mappings (translations or projections) between ontology languages and between logics, as well as serialisations. The LoLa properties relate all of the former classes to each other, as shown in Fig. 2, e.g. an ontology language to the serialisations that it supports, or to the logic that exactly formalises its expressivity, or an ontology language mapping to the logic mapping it has been derived from.
Fig. 3 shows the top-level classes of LoLa’s OWL module, axiomatising logics, languages, and mappings to the extent possible in OWL. Concerning meta-level classes (that is, classes for describing the graph of languages and logics), Fig. 2 already has illustrated the interplay of ontology languages, logics and serialisations.
Object-level classes (that is, classes providing the vocabulary for expressing distributed ontologies) comprise ontologies, their constituents (namely entities, such as classes and object properties, and sentences, such as class subsumptions), as well as links between ontologies.
Mappings are modelled by a hierarchy of properties corresponding to the different types of edges in Fig. 1. For example, object properties such as translatableTo model the existence of a translation between two languages. mappableToLanguage models the fact that a language can be mapped to another one.
However, this only allows for covering the default translations between logics. E.g., we can express that the default translation from SROIQ to F-logic is a model-expansive comorphism. Besides further alternative translations that the community may contribute, there is, however, also another translation, which can be obtained from our graph, by composing the SROIQ →FOL= and FOL=→Flogic translations, resulting in a subinstitution. For expressing such alternatives, LoLa additionally reifies mappings into classes, whose hierarchy corresponds to that of the mapping properties.
Fig. 4 shows the inferred class hierarchy below the class Mapping, as computed
within protégé. Notice that our ontology produces several cases of multiple
inheritance. Mappings are split along the following dichotomies:
– logic mapping versus ontology language mapping, cf. Fig. 2.
– translation versus projection: a translation embeds or encodes an ontology
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 [
Other classes concern the accuracy of the mapping, see [
The full OWL ontology is available at http://purl.net/dol/1.0/rdf#; it serves, as said above, simultaneously as an RDF vocabulary for the linked dataset that constitutes the OntoIOp registry, and for serialising DOL ontologies in RDF—therefore the “rdf” name. DOL allows us to put together the pieces collected so far. First, we specify that the RDF registry conforms with the OWL ontology. This is achieved by projecting the registry from RDF to OWL10, and stating an interpretation of theories of this into the OWL ontology.
We use circumscription [
Furthermore, we use first-order logic to formulate logical axioms that exceed
the expressiveness of OWL. We here use the Common Logic Interchange
Format (CLIF) [
ABox and TBox minimize DefaultMapping %% circumscription-like minimisation end %% first-order rules for infering new facts in the registry logic log:CommonLogic syntax ser:CommonLogic/CLIF ontology LoLaRules = (forall (subLa superLa lo) (if (and (dol:translatableTo subLa superLa) (dol:mappableToLanguage subLa superLa) (dol:supportsLogic subLa lo)) (dol:supportsLogic superLa lo))) ... end
DOL-conforming applications can explore and query the OntoIOp registry to find out useful information about the logics and languages of concrete given ontologies, or about logics and languages in general.
The following query in the SPARQL RDF query language, e.g., returns all languages a given ontology is translatable to: PREFIX dol: <http://purl.net/dol/1.0/rdf#> SELECT DISTINCT ?target-language WHERE { # first determine, by querying the ontology itself, its language <http://ontohub.org/ontologies/my-ontology>
dol:language ?theLanguageOfTheGivenOntology . # find out everything the language is translatable to ?theLanguageOfTheGivenOntology dol:translatableTo ?targetLanguage ; # just to be sure: We are only interested in mappings to languages. dol:mappableToLanguage ?targetLanguage .
# (The use of two properties is owed to the orthogonal design of LoLa.) }
This query assumes that both the information about the ontology and about
the OntoIOp registry are available in RDF and ready to be queried as SPARQL.
At the moment this cannot be taken for granted; however, we are working on
Ontohub, an ontology repository engine, which we will, at the same time, also
use to host the OntoIOp registry instead of the current static file deployment
[
Aiming at wide tool support, the linked data graph that we deploy has all inferences of the LoLa ontology applied; this means in particular that, from a translation between two logics, it is inferred that the corresponding ontology languages are translatable into each other, and that the transitive closure of the translation graph has been computed. Therefore, the query shown above operates on a plain RDF graph, and the query engine does not have to have further inferencing support built in.
The following query focuses exclusively on the OntoIOp registry. It answers a frequent question in knowledge engineering: Which logic is the right one for formalising my conceptual model? For the sake of this example, we focus on knowledge representability and thus assume that a logic is suitable if it has translations from and to many other logics. This ignores questions of availability of reasoners for the respective logics, of tools performing the translations, and of their performance. Such information is not yet available in the OntoIOp registry itself, but could be compiled in a separate linked dataset that the registry would link to.
PREFIX dol: <http://purl.net/dol/1.0/rdf#> SELECT ?logic, COUNT(?targetLogic) AS ?t, COUNT(?sourceLogic) AS ?s WHERE { ?logic a dol:Logic ; dol:translatableTo ?targetLogic ; dol:translatableFrom ?sourceLogic . } ORDER BY ?t, ?s We have presented LoLa, an ontology of logics, languages, and mappings between them. This ontology formalises the semantics not only of these aspects of the Distributed Ontology Language DOL, but also of the vocabulary employed in the OntoIOp registry for extending the DOL framework with further logics, languages and mappings. LoLa is a heterogeneous ontology consisting of a core OWL module, which declares the vocabulary and provides a basic formalisation, a Common Logic module providing additional first-order rules; furthermore we employ DOL’s logic-independent circumscription facility to minimise the extension of default translations. Along with our plans to publish not only machinecomprehensible descriptions of logics and mappings, but full formalisations, we will also expand LoLa to formalise further features of the DOL language, such as the vocabulary that describes the accuracy of a mapping (cf. Sec. 4).
The development of DOL is supported by the German Research Foundation (DFG), Project I1-[OntoSpace] of the SFB/TR 8 “Spatial Cognition”; the first author is additionally supported by EPSRC grant EP/J007498/1. The authors would like to thank the OntoIOp working group within ISO/TC 37/SC 3 for their input, particularly Michael Grüninger for his advice regarding the hierarchy of types of ontology translations.