Dublin Core in OWL 2

This site provides OWL 2 DL ontologies for terms of the Dublin Core Metadata Intitiative. It is meant for applications and other ontologies which need OWL DL versions for reasoning or import rather than the existing RDFS schemas provided by the Dublin Core Metadata Intitiative itself.
Various ontologies define the Dublin Core terms they use themselves rather than import something and they mostly define the properties as annotation properties. Others have provided OWL versions that also only use annotation properties which is problematic in some cases.
Various new features of OWL 2 now allow alternative ways of modelling and this project tries to deliver coherent and consistent mappings of Dublin Core terms to OWL making use of those features.

Ontology URIs and files

Use the PURL URIs below as ontology URIs when you want to import the ontologies.

Annotation versus object/datatype

In modelling DC as OWL ontologies others have so far chosen to declare all properties as annotation properties. This is because Dublin Core doesn't always make clear statements if the values of the properties should be literals or non-literals (and for example for dcterms:title it explicitly states that both literals and non-literals are allowed). And annotation properties allow for both because they have no semantic relevance for reasoning.
Because of this in OWL 1 DL you can't declare any domains, ranges and sub-properties for annotation properties. So if you want to use them as an integral part of your data model it doesn't work. Link an individual to another resource with dcterms:creator and you can't infer that it is a dcterms:Agent like Dublin Core states it is. Also you can't build on those properties, declaring your own refined properties as sub-properties of them.
In OWL 2 DL this is possible: you can declare domains, ranges and sub-properties for annotation properties. But quoting the spec: These special axioms have no semantic meaning in the OWL 2 Direct Semantics, but carry the standard RDF semantics in the RDF-based Semantics (via their mapping to RDF vocabulary). And, using this approach means that all properties you declare as sub-properties of annotation properties are annotation properties themselves.
Also new in OWL 2 DL is punning. You can use one and the same URI for entities of different kinds, thus treating for example a resource as both a class and an individual. The reasoning engine will just treat them as two different entities. This, although not explicitly mentioned, also works for ontology URIs. You can thus declare dcterms:creator as an object property and use it on ontologies, classes, properties and individuals alike and still get the full reasoning capabilities. You can even make regular sub-properties of it.

With punning there is still a restriction that one URI doesn't denote both a datatype property and an object property so for each property you have to decide which it should be. This is a bit difficult in some cases. Therefore two different ontologies are offered here for the Dublin Core Metadata Terms model (namespace http://purl.org/dc/terms/).

One uses annotation properties only. It imports the Element Set (namespace http://purl.org/dc/elements/1.1/) terms which are defined as annotation properties anyway and declares Metadata Terms properties as sub-properties of those as declared in the specification. Using this ontology you have full flexibility in how you want to use the terms with the downsides of annotation properties as described above. This for example means that you can use DCSV for representing complex values as literals – or you can choose to model this with resources instead. While the DCMI itself recommends to do the latter (but doesn't restrict you to it), using this you will get better interoperability with legacy data.

Annotation properties seem a bit like cheating though. They do the trick of allowing both literal and non-literal values but they're not meant for that purpose. The second ontology offered therefore is not based on the Element Set ontology anymore but uses object and datatype properties mainly. This means a decision for one or the other had to be made sometimes (because the Metadata Terms specification is not always consistent in its definitions). Datatype properties were used for all date-related properties, for dcterms:identifier and for its sub-property dcterms:bibliographicCitation. Annotation properties were still used for the properties dcterms:description, dcterms:title and their sub-properties dcterms:abstract, dcterms:tableOfContents and dcterms:alternative because here the specification clearly states that both literals and non-literals make sense and because their character is annotation-like enough. All other properties are defined as object properties. The range of the property dcterms:type couldn't be defined as a class like in the annotation property version because this apparently is not valid for object properties in OWL 2 DL. It is recommended to use rdf:type in place of that property anyway.
Using this ontology you get the full reasoning capabilities and can use the properties as proper members of your data model, however you are restricted to one interpretation of the character of the properties and may get into interoperability issues.

Since the DCMI is recommending to use non-literal values in many cases (which is more in the gist of the modern Semantic Web) hopefully they will offer their own interpretation of the situation to make OWL reasoning more consistent in the future. Until then the ontologies offered here may be of help for you.


This page as well as all of the ontology files (but not the Dublin Core models themselves) are licenced under a Creative Commons licence.

Last change: 2009-09-07 by Simon Reinhardt