RE: OWL use cases

Jeremy,

 >  as far as I could understand your use cases were intended as use
 >  cases for punning.

Wasn't the intention, but certainly fine if that were the case.

 >  I would like to understand:

 >  a) why OWL 1.0 Full does not address these use cases to 
 >  your satisfaction

It does currently, to the extent that DL reasoning works in Full, as in
Racer/Protege and JENA.  See examples at
http://www.w3.org/2007/OWL/wiki/index.php?title=OWLMetamodeling.  Just
wanted to check that it would continue under OWL 1.1.

 >  b) why the (lack of) semantics for punning offered in OWL 1.1 may be
 >  helpful in these cases

 >  i.e. it is clear that sometimes we do want to blur the distinctions
 >  between classes properties and individuals. But when we do, it is
 >  not simply to do with allowing the same name to be used to refer to
 >  a class, a property and an individual which have no relationship
 >  between them (other than the spelling of their name); the use cases
 >  for using the same name are to do with underlying semantic
 >  relationships between the class, the property and the individual.

Didn't entirely follow, but agreed it might be more than just happening
to use the same name for a property and class.  The instances of the
class in our application are all and only the statements that have the
property as a predicate.  See example [2] at
http://www.w3.org/2007/OWL/wiki/index.php?title=OWLMetamodeling.  This
is analogous to pairs as the interpretation of a relation, but RDF has
statements instead of pairs, so we use those instead.   Others might
interpret these "property classes" differently, so an alternative would
be to have a subclass of owl:class with a property identifying another
property, which the instances of the class have as prdicate.

 >  Since the OWL 1.1 member submission does not include a design for
 >  these relationships, it would be helpful if you could clarify
 >  whether you believe your use cases are:

Will do, but first I need to understand if the current tooling support
is somehow out of bounds or not.  They seem to perform DL reasoning in
the above examples, which are not technically DL.  It makes sense (to
me) that they do, because they probably just treat instances of
subclasses of owl:class (in Full) as instances of owl:class (in DL) and
perform normal reasoning procedures on them.

Perhaps one thing I should clarify is that this isn't DL reasoning about
classes of classes, it's just about classes of individuals, as normal.
The only uses of classes of classes are typical querying, not DL
reasoning.  Eg, it's not part of the use case to deduce that two
subclasses of owl:class are disjoint.

Conrad

Received on Tuesday, 23 October 2007 22:43:00 UTC