Re: possible changes to abstract syntax and direct semantics to support annotations and fix problem with imports

Hi Peter,

Thank you for this proposal, it is very definitely a step forward.

It is certainly better to do the annotation semantics inside the direct 
semantics than not; however I remain perplexed as to why not use treat 
annotations just like normal properties using the facilities of the direct 
semantics to allow "a URI reference [that] can be the identifier of a class 
or datatype as well as the identifier of a property as well as the identifier 
of an individual in this abstract syntax," As long as the annotation 
properties are sufficiently restricted then any unwelcome complexities or 
surprising consequences can be avoided. e.g. to avoid any implicit typing of 
classes, the annotation properties must not have declared domains, or 
inverses (also their superproperties), but superproperties etc could be 
permitted. In particular permitting subproperty hierarchies over annotations 
looks genuinely useful - and while not worth the effort if you really need to 
duplicate the work already done for ordinary subproperties, but I am not at 
all convinced that that is necessary.

Aspects that still concern me ....
The intent seems that 

<a> rdf:type owl:Thing .
<a> <p> "foo" .

is intended to be really quite different from

<a> rdf:type owl:Thing .
<a> <p> "foo" .
<p> rdf:type owl:DatatypeProperty .

The difference between this two, I believe is overly subtle and will confuse 
users. e.g. your doc allows:

<a> rdf:type owl:Thing .
<a> <p> "foo" .
<a> <p> <b> .

but not

<a> rdf:type owl:Thing .
<a> <p> "foo" .
<p> rdf:type owl:DatatypeProperty .
<a> <p> <b> .

The abstract syntax form makes this sharp distinction between annotations and 
property values. In the concrete syntax it is not nearly as sharp.


So looking at your example:

        Class(Person partial)
        Individual(john annotation(ex a) type(Person))
        Individual(jack type(Person))
        SameIndividual(john jack)

should entail

        Class(Person partial)
        Individual(john type(Person))
        Individual(jack annotation(ex a) type(Person))
        SameIndividual(john jack)

I think this is much clearer if we just make these normal value pairs i.e.

        Class(Person partial)
        Individual(john value(ex a) type(Person))
        Individual(jack type(Person))
        SameIndividual(john jack)

should entail

        Class(Person partial)
        Individual(john type(Person))
        Individual(jack value(ex a) type(Person))
        SameIndividual(john jack)

then we are led to ask, if we also wish to permit such a value/pair as a 
(genuine) annotation on a class or property what constraints must we put on 
it to not contravene the separations needed by the abstract syntax and 
semantics.


Jeremy

Received on Sunday, 9 February 2003 15:33:43 UTC