W3C home > Mailing lists > Public > public-owl-wg@w3.org > December 2007

Declarations in OWL 1.1

From: Boris Motik <boris.motik@comlab.ox.ac.uk>
Date: Sat, 15 Dec 2007 20:02:41 -0000
To: "'Web Ontology Language \(\(OWL\)\) Working Group WG'" <public-owl-wg@w3.org>
Message-ID: <000d01c83f55$72f68df0$2711a8c0@wolf>


At the F2F meeting, I was asked to provide some information about OWL declarations, so here it is.

Why declarations?

An ontology in OWL 1.1 contains only axioms. Entities such as classes and properties do not occur in an ontology as first-level
citizens; rather, an ontology contains some entity if and only if it contains an axiom (directly, not through the import closure)
mentioning the entity.

This is sometimes seen as a drawback. A possible solution is to allow for *entity declarations* -- statements saying "this entity
exists in this ontology". I'll now list some of the problems and explain how declarations might be of help.

1. You should be able to put an entity into an ontology

Imagine that you want to implement "Create New Class" in Protégé; what do you do? Sometimes tools are hacking their way around this
problem and are asserting a class to be a subclass of owl:Thing. There is no such hack, however, for properties.

Declarations solve this problem in an obvious way: you can put an entity into an ontology by declaring it. OWL 1.1 currently
provides such a mechanism. 

2. You should prevent "spelling errors"

You wouldn't believe how many errors I've seen that arise due to the fact that some axiom is referring to an entity that has not
been "defined" anywhere. This sometimes occurs due to typos. However, it happens even more often due to imports: some tools used to
serialize RDF files incorrectly, so the URIs for imported entities would get resolved incorrectly. In OWL 1.0 there is no way to
detect such errors.

If we have a notion of declarations, then we could perform structural checks: for each entity used in an axiom, we could check
whether the entity has been declared somewhere in the imports closure; if not, we raise an error.

3. Typing

Declarations are linked with the typing problem in that they naturally provide types for URIs: if you say "a class x exists", then
you clearly know that x is of type owl:Class.

Declarations and typing

The problem of declarations is somewhat related to the problem of entity typing that I described in my previous e-mail. If you have
a declaration for an entity, then you know the entity's type. Hence, triples of the form 

(1)  <e rdf:type owl:ObjectProperty>

have often been interpreted as declarations. This, however, holds only if we adopt the variant T1 or T3 from my previous e-mail.
I'll explain in more detail.

Assume that you have an ontology O which imports an ontology O'. Assume now that O' "defines" some entity e, but that this entity is
reused in O as well. Clearly, we can put the triple (1) into O' and thus "declare" the entity e. Whether this is a declaration,
however, depends on what our approach to typing is.

If we adopt the typing policy T2 (that is, if we put the typing triples in each ontology), then the fact that e is used in O
requires us to put (1) in O as well. But then, (1) cannot be used as a declaration of e: it then necessarily occurs in each RDF
graph that mentions e. Therefore, in the case of T2 we need additional ways to do declarations. This is why OWL 1.1 currently has

If we adopt T1 (without T2 for backwards compatibility), then we don't need the typing triples, so we can use them for declarations.
In this case, an entity may, but need not be explicitly declared.

If we adopt T3, then we *must* use typing triples for declarations. In fact, since we need to know explicitly the type of each
entity, each entity must be declared (at least in OWL 1.1 DL).


D0. No declarations

I don't think this would be good, but I mention it for completeness. Without declarations, we don't have ways of adding entities to
an ontology.

D1. Use owl11:declaredAs

We encode declarations using a special triple, and not use rdf:type for declarations. This is *required* in the case of T2 solution
for typing. In the case of T3, this is redundany.

D2. Use rdf:type

We take rdf:type as declarations. This is *possible* only with T1 and T3 solution for typing. In the case of T3, this requires each
entity to be declared; for T1 declarations can be made optional. 


Received on Saturday, 15 December 2007 20:03:28 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 16:41:41 UTC