RE: Cutting the Patrician datatype knot

> In the above union "data type", the literal "7" maps to
> two members of the value space. Therefore, it is not a
> valid data type.

If you define a union type then such anomalies can arise.
XML Schema specifies how to resolve them.  If a literal can be 
interpreted as a valid literal for more than one of the datatypes
included in a union, it is assumed to have the datatype of the first
datatype specified in the union for which it is a legal literal.

You may not think this is an elegant solution but it solves the 

All the best, Ashok 
Ashok Malhotra              <mailto:> 
Microsoft Corporation

-----Original Message-----
From: [] 
Sent: Thursday, November 29, 2001 4:09 AM
Subject: RE: Cutting the Patrician datatype knot

> For example, if you allow union XML Schema datatypes there is 
> a model of 
> 	<rdfs:range foo xsd:[integer union string]>
> 	<John foo 7>

As I think I've said earlier, I don't consider 
[integer union string] to be a "valid" data type.

The definition of a data type that I subscribe to is
that a data type defines a value space and (optionally)
a lexical space, and a member of the lexical space maps
to one and only one member of the value space.

In the above union "data type", the literal "7" maps to
two members of the value space. Therefore, it is not a
valid data type.

What you seem to be defining is just a union of lexical 
space. I.e., the union of the lexical space of integers with 
the lexical space of strings; which, however possible to do,
is not particularly useful if you want to deal with the
values themselves.

XML Schema is not concerned with values the same way that
an application would be. XML Schema only has to ensure
the integrity of the lexical and structural space. Thus,
a union such as above is reasonable, as XML Schema does
not itself worry about the ambiguity that arises in the
lexical to value mapping.  

You do, though, raise an important question -- whether it
is possible to define XML Schema simple data types which
do not have a N:1 mapping from lexical space to value space.
If we can have 1:N or N:N mappings, then we are going to
have problems, and that might mean that perhaps XML Schema
may need to be more constrained with regards to some
simple type derivations.

I'm presuming, of course, that RDF is only concerned with
simple data types, not all XML Schema definable types in

> For example, what is the theory of rdf:type on datatype classes?

Good question. I'm not the best person to offer an answer,
insofar as the formal MT is concerned, but I would expect
that the theory of rdf:type is the same for all classes, datatype
or otherwise, and it is the knowledge about a particular class
that tells us it is a data type class, and data type classes
have distinct characteristics, such as defining a value space
and (optionally) lexical space. If we declare that literals
may only be bound to data type classes, then we know that a
given class is a data type class if it is bound to a literal,
and thus know how to interpret the pairing of literal (lexical
form) to data type.



Patrick Stickler              Phone: +358 50 483 9453
Senior Research Scientist     Fax:   +358 7180 35409
Nokia Research Center         Email:

Received on Thursday, 29 November 2001 08:25:58 UTC