RE: question: datatype reasoning?

  with due respect, I'm still not sure from your answer what the 
answer to my question is

At 9:34 +0100 1/24/03, Jeremy Carroll wrote:
>My understanding is as follows:
>There are many difficult cases
><p> range xsd:negativeInteger
><p> range xsd:byte
>owl:Thing owl:sameClassAs
>   restriction(p, maxCardinality=128 )

maybe it's just me, but it seems like expecting the above to be in 
any complete OWL reasoner is pretty tough - there are DL reasoners 
that do some datatype reasoning, but they don't seem to discuss 
anything near this level of complexity.

>There are worse cases when we are considering potential compatible types
>that do not have the same primitive base type (e.g. try xsd:float instead of
>xsd:byte). Such cases are in need of clarification from XML Schema WG.
>Nasty questions that can be asked in OWL DL assuming floats and decimals
>share the same underlying real values is how many floats are unsignedLongs
>(algorithm is keep increasing the maxCardinality in an entailment like that
>above until the entailment does not hold).
>I am not sure that there can be an effective OWL DL reasoner that cannot
>reason about the cardinalities of sets of individuals, and hence it may also
>need the ability to reason about the cardinalities of sets of datatypes (as
>in the above example).

not clear to me this is the same as what I was asking.  I'd agree 
that reasoning about the cardinality should be there (and is 
expected), but consider a simple case where

class A is restricted to have a property called foo of type URI.
class B is restricted to have a property called foo of the string.

everything else is the same.  I might expect a classifer to determine 
that A is a subclass of B because all A's are necessarily Bs (since 
URIs are strings) - and that doesn't seem totally unreasonable.  On 
the other hand, if I have an example like the one above - expecting 
the "only if" version of your rule above

owl:Thing owl:sameClassAs
     restriction(p, maxCardinality=128 )
would require that I make this a subclass of something with restrictions of

<p> range xsd:negativeInteger
<p> range xsd:byte

seems a lot higher bar to expect.  (and I don't know how 
implementable it is) - in fact, is there even an axiomization of all 
the datatype rules the reasoner would need to know with respect to 
all the xsd: datatypes (i.e. what strings are dates? what lengths are 
allowed on various types, etc.)

>OWL Lite is largely rescued from this by restriciting cardinalities to 0 and
>1. A complete OWL Lite reasoner would I suspect need to simply know the
>intersection lattice of the XML Schema builtin datatypes and which
>intersections are empty and singleton.
><p> range xsd:nonNegativeInteger
><p> range xsd:nonPositiveInteger
>owl:Thing rdfs:subClassOf
>   restriction(p, maxCardinality=1 )
><p> range xsd:unsignedByte
><p> range xsd:nonPositiveInteger
><i> rdf:type restriction( p, minCardinality=1 )
><i> <p> "0"^xsd:int
>OWL with user defined datatypes (that we want) is worse.
>OWL Full (with or without user defined datatypes) is much worse.
>I was planning on adding such tests under the datatypes issue.
>for long discussion of these issues (RDF not OWL)

I think the WG has to address the issue of what is expected in terms 
of reasoning about datatypes.  If we really want to insist on 
completeness of reasonign with respect to these, I'd think we need to 
produce a list of all the "axioms" of XML Schema datatypes (which I'd 
want to rule out of scope :->) or we need to come up with a 
reasonable way of expressing our expectations (my preferred solution) 
for a less than complete requirement with respect to the full set.

Professor James Hendler
Director, Semantic Web and Agent Technologies	  301-405-2696
Maryland Information and Network Dynamics Lab.	  301-405-6707 (Fax)
Univ of Maryland, College Park, MD 20742	  240-731-3822 (Cell)

Received on Friday, 24 January 2003 07:53:08 UTC