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: Alan Ruttenberg <alanruttenberg@gmail.com>
Date: Wed, 15 Oct 2008 18:02:16 -0400
Message-ID: <29af5e2d0810151502p66c134dbj6b70b76cb21d1732@mail.gmail.com>
To: "Boris Motik" <boris.motik@comlab.ox.ac.uk>
Cc: public-owl-wg@w3.org

On Wed, Oct 15, 2008 at 1:44 PM, Boris Motik
<boris.motik@comlab.ox.ac.uk> wrote:
> 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.

This is my understanding as well.

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

My point was that with annotations as they were, you would have to
create an individual in the ontology because the target of the
annotation needed to be an entity. However if the target is a URI then
this problem does not arise.

Just for curiosity, why not have ontologies individuals in all cases?

> 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 )

I assume you mean ObjectProperty here?

> 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

Still a bit more. What if a:Aquilla is an individual in 0. What if it
is also punned as a Class in O?
Would URI be an "object" in the sort of object model that you envision
the metamodel specifying?
Should a tool display the raw URI as the value of the annotation? Or
all views of the URI?

> 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.

There's still an issue with anonymous individuals as subject and
object of annotations.
For subject, don't change anything?
But what about if an anonymous individual is the object of an annotation?

-Alan

>
>> 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).

>> > 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 22:02:51 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 21:42:07 UTC