W3C home > Mailing lists > Public > public-owl-wg@w3.org > October 2008

RE: A proposal for resolving the punning issue (ISSUE-114) + a related proposal for a tweak to the annotation system

From: Boris Motik <boris.motik@comlab.ox.ac.uk>
Date: Wed, 15 Oct 2008 18:44:07 +0100
To: "'Alan Ruttenberg'" <alanruttenberg@gmail.com>
Cc: <public-owl-wg@w3.org>
Message-ID: <093CFFAB5EB2479385CC8477AED45250@wolf>

Hello,

[snip]

> The only remaining pun I am concerned about is the one between
> ontology and individual. We have this undesirable situation (in my
> opinion) where if we write
> Imports(a:foo a:foov1)
> then a:foo and a:foov1 are not part of the domain. But if we then
> write elsewhere
> Annotation(owl:backwardCompatibleWith a:foov2) then a:foov2 is part of
> the domain.
> It seems to me that either ontologies should all be or not all be part
> of the domain.
> Moreover, if a:foov2 *is* an individual here, and if a:foov2 is in the
> imports closure, then the owl:backwardCompatibleWith is not referring
> to the a:foov2 ontology but to some unrelated punned entity.
> No problem perhaps with owl:backwardCompatibleWith, but it is a
> problem for owl:incompatibleWith
> 
> Moreover maintaining these two entities distinct in OWL RL would seem
> to be problematic.
> 

I'm not 100% sure that I understand this. What do you mean by "an individual being in the domain"? I get an impression that you
might be asking whether the ontology (1) logically contains an individual with the URI http://my.bla.com/inner.

(1) Ontology( <http://my.bla.com/outer> Imports( <http://my.bla.com/inner> ) )

If this is the question, then I believe the answer is no: http://my.bla.com/inner is not used as an individual at this point so the
ontology doesn't contain this individual. Please read my example below for more clarification.

Note, however, that punning between ontology and individuals could be useful: it would allow you to assert logical about an
ontology.

[snip]

> So far so good. Some questions:
> 
> What sort of thing is a:Eagle and how is it (formally - say in the
> metamodel) related to entities in OWL? Can I have an annotations where
> a:Eagle is not the same URI as some entity in the ontology? Should a
> tool display annotations stated in such an axiom with any entity in
> the ontology that has the same URI?
> 

a:Eagle is just a URI, and its purpose is to identify one thing in your domain model. It has, however, several views: instance view,
class view, object property view, ontology view, etc. The URI is represented in the structural spec using the URI class, and the
views are represented by classes that use the URI class. This is the current situation and this would also be the case if we were to
change the annotation subsystem as I proposed. The views are needed in order for users to attach logical information to the URIs. In
a way, the views can be seen as go-betweens between first-order logic and the URI.

If we were to change the annotation subsystem as I suggested, then annotations would be attached to URIs, and not to views. Thus,
you would be able to place an annotation on the URI a:Eagle even if the ontology does not contain any view of a:Eagle (i.e., even if
the ontology doesn't mention a class or an individual with the URI a:Eagle).

I imagine an OWL 2 tool to work as follows. Assume you have the following ontology O.

Ontology( <http://bla.com/onto>

SubClassOf( a:Eagle a:Species )
OntologyProperty( a:eats )
PropertyAssertion( a:eats a:Eagle a:Mouse )

AnnotationProperty( a:latinName )
EntityAnnotation( a:Eagle Annotation( a:latinName a:Aquilla ) Label("EAGLE") )

)

(Forget for the moment that a:latinName would in reality not be an annotation property: I needed to invent something here.)

So here is the answer to some of the questions you raised:

Q: What is the set of classes occurring in O?
A: { a:Eagle, a:species }

Q: What is the set of individuals occurring in O?
A: { a:Eagle, a:Mouse }

Q: What is the set of URIs occurring in O?
A: { <http://bla.com/onto>, a:Eagle, a:Species, a:eats, a:Mouse, a:latinName, a:Aquilla }

Q: What is the label of the class a:Eagle?
Q: What is the label of the individual a:Eagle?
Q: What is the label of the URI a:Eagle?
A: "Eagle"

Q: What is the value of the annotation property a:latinName for the class/individual/URI a:Eagle?
A: The URI a:Aquilla

Thanks Alan for this question: it helped me to actually clarify this issue in my head. We should definitely explain this in the
spec. 


> How do annotations on Axioms work?
> 

I don't see any change here, with the difference that the values of annotations are URIs rather than entities.

> What about the RHS of an annotation? If i have (annotation by entity)
> 

These should be URIs rather than entities as well (see example above).

> Annotation( a:Eagle a:image(i:eaglePicture))
> ObjectProperty(i:eaglePicture)
> NamedIndividual(i:eaglePicture)
> What does the annotation refer to? Does it matter? What is our advice
> to tool writers on how to present this?
>

I'm not sure I understand this question (the syntax seems to be a bit garbled). I hope, however, that the above example already
answers your question. If not, I'll be happy to provide you with more detai.
 
> >
> > The impact on the documents would be minimal. There is no impact on OWL Full, and there would be
> rather trivial changes to the
> > Syntax and the RDF Mapping documents. The RDF Mapping document would actually become much simpler.
> 
> Much?
> 

Yes. Currently, there is a problem with the reverse mapping of annotations with entities: the RDF mapping cannot always correctly
detect the type of entity used in the annotation. Currently, the annotations (2)--(6) get mapped to (7)--(9). At this point, it is
not clear that a:B in (9) should refer to both an individual and a class, so the backwards mapping produces only (10).

(2) Declaration( Class( a:A ) )
(4) Declaration( Class( a:B ) )
(5) EntityAnnotation( Class( a:A ) Annotation( a:ap Class( a:B ) ) )
(6) EntityAnnotation( Class( a:A ) Annotation( a:ap NamedIndividual( a:B ) ) )

(7) ( a:A rdf:type owl:Class )
(8) ( a:B rdf:type owl:Class )
(9) ( a:A a:ap a:B )

(10) EntityAnnotation( Class( a:A ) Annotation( a:ap Class( a:B ) ) )

Without typed entities in annotations, things get much simpler.

Regards,

	Boris

> 
> > Please let me know how you feel about this.
> >
> >
> > Regards,
> >
> >        Boris
Received on Wednesday, 15 October 2008 17:44:47 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Wednesday, 15 October 2008 17:44:48 GMT