RDFL - An Ontology for Describing Lexical Datatypes

Patrick Stickler <patrick.stickler@nokia.com>

This document outlines an ontology for defining and relating lexical datatypes, which serves as a convenient mechanism for validation and/or interpretation of literals. It can also be used solely for defining the relations between datatypes leaving the definition of and interpretation by their lexical spaces to other applications.

The goals of the RDFL ontology are to enable one to:

The RDFL ontology borrows the basic datatyping vocabulary and semantics from XML Schema but differs from XML Schema such that:

Regular expression values must conform to the Extended Regular Expression Syntax (ERE) as defined by Posix.2 standard (ISO/IEC 994502: 1993 (ANSI/IEEE Std 1003.2 - 1992)), section 2.8) which is a functional subset of the regular expression syntax of XML Schema, Perl5, and is supported for most programming languages.

The complete machine readable version of the RDFL schema is available here.

See below for an RDFL Definition of the relations between the pre-defined XML Schema simple datatypes.

Datatype Definition

Lexical Spaces


<rdfs:Class rdf:about="&rdfl;Datatype"/>

<rdfs:Property rdf:about="&rdfl;pattern">
   <rdfs:domain rdf:resource="&rdfl;Datatype"/>
   <rdfs:range  rdf:resource="&rdfl;RegularExpression"/>
</rdfs:Property>

<rdfs:Property rdf:about="&rdfl;patternExclusion">
   <rdfs:domain rdf:resource="&rdfl;Datatype"/>
   <rdfs:range  rdf:resource="&rdfl;RegularExpression"/>
</rdfs:Property>

<rdfs:Property rdf:about="&rdfl;patternDependencyOn">
   <rdfs:domain        rdf:resource="&rdfl;Datatype"/>
   <rdfs:range         rdf:resource="&rdfl;Datatype"/>
</rdfs:Property>

An rdfl:Datatype has both value space and lexical space.

Lexical space is defined lexically, by a set of inclusive and exclusive regular expressions, and in the context of all other rdfl:Datatypes related by rdfl:patternDependencyOn.

Lexical and value spaces have no explicit URI identity. Only the datatype itself.

rdfs:subClassOf relates to all members of the Datatype class, which includes the members of both the value and lexical spaces.

For any rdfl:Datatype X which is an rdfs:subClassOf some rdfl:Datatype Y, all members of the lexical space of X are also members of the lexical space of Y and all members of the value space of X are also members of the value space of Y and the mappings from lexical to value space for X is a subset of the mappings from lexical to value space of Y.

The patterns defined for an rdfl:Datatype may be dependent on patterns defined for another type, as indicated by the value of the rdfl:patternDependencyOn property. Prior to matching the local patterns for a datatype, all types that it is dependent on must first successfully match. This constraint is enforced by the validation algorithm specified below.

Subordinate rdfl:Datatypes related by rdfs:subClassOf may only restrict, not extend, the lexical spaces of superordinate rdfl:Datatypes. This constraint is enforced by the lexical subset validation algorithm defined below, in that a lexical form that fails to match the lexical definition of all superordinate rdfl:Datatypes will fail to match the local rdfl:Datatype.

Canonical Lexical Spaces


<rdfs:Property rdf:about="&rdfl;canonicalPattern">
   <rdfs:domain rdf:resource="&rdfl;Datatype"/>
   <rdfs:range  rdf:resource="&rdfl;RegularExpression"/>
</rdfs:Property>

<rdfs:Property rdf:about="&rdfl;canonicalPatternExclusion">
   <rdfs:domain rdf:resource="&rdfl;Datatype"/>
   <rdfs:range  rdf:resource="&rdfl;RegularExpression"/>
</rdfs:Property>

A datatype may have, in addition to a lexical space, a canonical lexical space. The lexical space and canonical lexical space may be identical.

Canonical lexical space is defined lexically, by a set of inclusive and exclusive regular expressions, similarly to the definition of the lexical space.

Note that if a lexical form is a canonical lexical form for a given datatype, that does not garuntee that it is also a canonical lexical form for any of its superordinate datatypes. Consider xsd:integer and xsd:decimal, where the canonical lexical space of xsd:integer is not a subset of the canonical lexical space of xsd:decimal even though the lexical space of xsd:integer is a subset of the lexical space of xsd:decimal (e.g. "5" is a member of the canonical lexical space of xsd:integer but is not a member of the canonical lexical space of xsd:decimal, only of the lexical space of xsd:decimal).

As with rdfl:Datatype, the canonical lexical patterns defined for an rdfl:Datatype may be dependent on patterns defined for another type, as indicated by the value of the rdfl:patternDependencyOn property. Prior to matching the local patterns for a datatype, all types that it is dependent on must first successfully match. This constraint is enforced by the validation algorithm specified below.

Union Datatypes


<rdfs:Class rdf:about="&rdfl;UnionDatatype"/>

<rdfs:Property rdf:about="&rdfl;memberType">
   <rdfs:domain rdf:resource="&rdfl;UnionDatatype"/>
   <rdfs:range  rdf:resource="&rdfl;Datatype"/>
</rdfs:Property>

An rdfl:UnionDatatype represents the definition of a superordinate datatype shared by all of the union member datatypes. The rdfl:memberType relation is the inverse of the rdfs:subClassOf relation, such that it syndicates of the definitions of the subordinate datatypes, rather than constraining the definition of a superordinate datatype.

An rdfl:UnionDatatype may only syndicate, but neither extend nor constrain, the value spaces or lexical spaces of its members. This is enforced by the validation algorithm below in that a lexical form that fails to match the lexical definition of at least one member datatype is not a valid lexical form for the union datatype.

List Datatypes


<rdfs:Class rdf:about="&rdfl;ListDatatype"/>

<rdfs:Property rdf:about="&rdfl;itemType">
   <rdfs:domain rdf:resource="&rdfl;ListDatatype"/>
   <rdfs:range  rdf:resource="&rdfl;Datatype"/>
</rdfs:Property>

<rdfs:Property rdf:about="&rdfl;length">
   <rdfs:domain rdf:resource="&rdfl;ListDatatype"/>
</rdfs:Property>

<rdfs:Property rdf:about="&rdfl;maxLength">
   <rdfs:domain rdf:resource="&rdfl;ListDatatype"/>
</rdfs:Property>

<rdfs:Property rdf:about="&rdfl;minLength">
   <rdfs:domain rdf:resource="&rdfl;ListDatatype"/>
</rdfs:Property>

... discussion TBD ...

Validation of Lexical Forms

Algorithm for the Validation of lexical forms:

(this is *very* informal psuedocode... will refine it into something more formal before done...)

If any MATCH operation fails, the entire test fails. 


IF (rdfl:Datatype)
{
   MATCH every rdfl:patternDependencyOn type
   IF (any rdfl:pattern defined)
   {
      MATCH any rdfl:pattern
   }
   MATCH no rdfl:patternExclusion
   IF (canonical membership test)
   {
      IF (any rdfl:canonicalPattern defined)
      {
         MATCH any rdfl:canonicalPattern
      }
      MATCH no rdfl:canonicalPatternExclusion
   }
}
ELSE IF (rdfl:UnionDatatype)
{
   MATCH any rdfl:memberType component type
}
ELSE IF (rdfl:ListDatatype)
{
   IF (rdfl:length is defined AND list length not equal to rdfl:length value)
   {
      FAIL
   }
   IF (rdfl:minLength is defined AND list length less than rdfl:minLength value)
   {
      FAIL
   }
   IF (rdfl:maxLength is defined AND list length greater than rdfl:maxLength value)
   {
      FAIL
   }
   FOREACH (whitespace delimited lexical form)
   {
      MATCH any rdfl:itemType component type
   }
}
ELSE
{
   FAIL
}

Lexical Subset Validation of Lexical Forms

Algorithm for the Validation of lexical forms based on subclass relations in addition to pattern dependency relations, ensuring lexical subset conformance for that lexical form for all superordinate lexical datatypes:

(this is *very* informal psuedocode... will refine it into something more formal before done...)

If any MATCH operation fails, the entire test fails. 


IF (rdf:type is rdfl:Datatype)
{
   MATCH every rdfs:subClassOf superordinate type that is rdfl:Datatype
   MATCH every rdfl:patternDependencyOn type
   IF (any rdfl:pattern defined)
   {
      MATCH any rdfl:pattern
   }
   MATCH no rdfl:patternExclusion
   IF (canonical membership test)
   {
      IF (any rdfl:canonicalPattern defined)
      {
         MATCH any rdfl:canonicalPattern
      }
      MATCH no rdfl:canonicalPatternExclusion
   }
}
ELSE IF (rdf:type is rdfl:UnionDatatype)
{
   MATCH any rdfl:memberType component type
}
ELSE IF (rdf:type is rdfl:ListDatatype)
{
   IF (rdfl:length is defined AND list length not equal to rdfl:length value)
   {
      FAIL
   }
   IF (rdfl:minLength is defined AND list length less than rdfl:minLength value)
   {
      FAIL
   }
   IF (rdfl:maxLength is defined AND list length greater than rdfl:maxLength value)
   {
      FAIL
   }
   FOREACH (whitespace delimited lexical form)
   {
      MATCH any rdfl:itemType component type
   }
}
ELSE
{
   FAIL
}

An RDFL Definition of XML Schema Simple Datatypes

The following is an RDF Schema definition of the pre-defined XML Schema simple datatypes according to the RDFL ontology defined above.

This schema is still under development, but when completed, will be suitable for validation of typed data literals based on the validation algoritm defined for RDFL to determine the integrity of datatyping knowledge relating to XML Schema simple datatypes, according to either canonical or non-canonical lexical spaces, independent of a complete XML Schema validator. A machine readable version of the schema is available here. 



<?xml version="1.0"?>

<!--
An RDFL Definition of XML Schema Simple Datatypes

Author: Patrick Stickler <patrick.stickler@nokia.com>

$Date: 2002/03/07 14:21:34 $
-->

<!DOCTYPE uridef [
  <!ENTITY rdf  "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
  <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#">
  <!ENTITY xsd  "http://www.w3.org/2001/XMLSchema#">
  <!ENTITY rdfl "voc://nokia.com/RDFL-1.0/">
]>

<rdf:RDF
   xmlns:rdf   ="&rdf;"
   xmlns:rdfs  ="&rdfs;"
   xmlns:xsd   ="&xsd;"
   xmlns:rdfl  ="&rdfl;"
>

<rdfl:Datatype rdf:about="&xsd;anySimpleType"/>

<rdfl:Datatype rdf:about="&xsd;string">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;boolean">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>[01]</rdfl:pattern>
   <rdfl:pattern>true</rdfl:pattern>
   <rdfl:pattern>false</rdfl:pattern>
   <rdfl:canonicalPatternExclusion>.</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;decimal">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>[-\+]?[0-9]+(\.[0-9]+)?</rdfl:pattern>
   <rdfl:canonicalPatternExclusion>\+.*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>00+\..*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>.*\.00+</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>[^\.]*</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;float">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>[-\+]?[0-9]+(\.[0-9]+)?[eE][-\+][0-9]+</rdfl:pattern>
   <rdfl:pattern>INF</rdfl:pattern>
   <rdfl:canonicalPatternExclusion>\+.*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>.*e.*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>.*E\+.*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>00+\..*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>.*\.00+E.*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>.*E00+</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>[^\.]*</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;double">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <!-- need to account for magnitude limits -->
   <rdfl:pattern>[-\+]?[0-9]+(\.[0-9]+)?[eE][-\+][0-9]+</rdfl:pattern>
   <rdfl:pattern>INF</rdfl:pattern>
   <rdfl:pattern>-INF</rdfl:pattern>
   <rdfl:pattern>NaN</rdfl:pattern>
   <rdfl:canonicalPatternExclusion>\+.*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>.*e.*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>.*E\+.*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>00+\..*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>.*\.00+E.*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>.*E00+</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>[^\.]*</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;duration">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <!-- need to constrain digits? -->
   <rdfl:pattern>-?P([0-9]+Y)?([0-9]+M)?([0-9]+D)?(T[0-9]+H)?([0-9]+M)?([0-9]+S)?</rdfl:pattern>
   <rdfl:patternExclusion>-?P</rdfl:patternExclusion>
</rdfl:Datatype>

<!-- Add rdfl:patternExclusion's to trap bogus date elements? -->

<rdfl:Datatype rdf:about="&xsd;dateTime">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>-?[0-9]{4,}-[0-9]{2}-[0-9]{2}T(([01][0-9])|(2[0-3])):[0-5][0-9]:[0-5][0-9](Z|([-\+](([01][0-9])|(2[0-3])):[0-5][0-9]))?</rdfl:pattern>
   <rdfl:patternExclusion>0000-.*</rdfl:patternExclusion>
   <rdfl:canonicalPatternExclusion>.*[-\+]..:..</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;time">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>(([01][0-9])|(2[0-3])):[0-5][0-9]:[0-5][0-9](Z|([-\+](([01][0-9])|(2[0-3])):[0-5][0-9]))?</rdfl:pattern>
   <rdfl:canonicalPatternExclusion>.*[-\+]..:..</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>24:00:00.*</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;date">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>-?[0-9]{4,}-[0-9]{2}-[0-9]{2}</rdfl:pattern>
   <rdfl:patternExclusion>0000-.*</rdfl:patternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;gYearMonth">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>-?[0-9]{4,}-[0-9]{2}</rdfl:pattern>
   <rdfl:patternExclusion>0000-.*</rdfl:patternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;gYear">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>-?[0-9]{4,}</rdfl:pattern>
   <rdfl:patternExclusion>0000</rdfl:patternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;gMonthDay">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>--[0-9]{2}[0-9]{2}</rdfl:pattern>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;gDay">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>---[0-9]{2}</rdfl:pattern>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;gMonth">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>--[0-9]{2}--</rdfl:pattern>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;hexBinary">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>([0-9A-Fa-f]{2})+</rdfl:pattern>
   <rdfl:canonicalPatternExclusion>.*[a-f].*</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;base64Binary">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <rdfl:pattern>[\+/=0-9A-Za-z]+</rdfl:pattern>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;anyURI">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <!-- rdfl:pattern TBD -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;QName">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <!-- rdfl:pattern TBD -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;NOTATION">
   <rdfs:subClassOf rdf:resource="&xsd;anySimpleType"/>
   <!-- rdfl:pattern TBD -->
</rdfl:Datatype>

<!-- Derived Data Types -->

<rdfl:Datatype rdf:about="&xsd;normalizedString">
   <rdfs:subClassOf rdf:resource="&xsd;string"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;string"/>
   <rdfl:patternExclusion>.*#xD.*</rdfl:patternExclusion>
   <rdfl:patternExclusion>.*#x9.*</rdfl:patternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;token">
   <rdfs:subClassOf rdf:resource="&xsd;normalizedString"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;string"/>
   <rdfl:patternExclusion>.*#xD.*</rdfl:patternExclusion>
   <rdfl:patternExclusion>.*#x9.*</rdfl:patternExclusion>
   <rdfl:patternExclusion>#x20.*</rdfl:patternExclusion>
   <rdfl:patternExclusion>.*#x20</rdfl:patternExclusion>
   <rdfl:patternExclusion>.*(#x20){2,}.*</rdfl:patternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;language">
   <rdfs:subClassOf rdf:resource="&xsd;token"/>
   <rdfl:pattern>(aa)|(ab)|(af)|(am)|(ar)|(as)|(ay)|(az)|(ba)</rdfl:pattern>
   <rdfl:pattern>(be)|(bg)|(bh)|(bi)|(bn)|(bo)|(br)|(ca)|(co)</rdfl:pattern>
   <rdfl:pattern>(cs)|(cy)|(da)|(de)|(dz)|(el)|(en)|(eo)|(es)</rdfl:pattern>
   <rdfl:pattern>(et)|(eu)|(fa)|(fi)|(fj)|(fo)|(fr)|(fy)|(ga)</rdfl:pattern>
   <rdfl:pattern>(gd)|(gl)|(gn)|(gu)|(ha)|(hi)|(hr)|(hu)|(hy)</rdfl:pattern>
   <rdfl:pattern>(ia)|(ie)|(ik)|(in)|(is)|(it)|(iw)|(ja)|(ji)</rdfl:pattern>
   <rdfl:pattern>(jw)|(ka)|(kk)|(kl)|(km)|(kn)|(ko)|(ks)|(ku)</rdfl:pattern>
   <rdfl:pattern>(ky)|(la)|(ln)|(lo)|(lt)|(lv)|(mg)|(mi)|(mk)</rdfl:pattern>
   <rdfl:pattern>(ml)|(mn)|(mo)|(mr)|(ms)|(mt)|(my)|(na)|(ne)</rdfl:pattern>
   <rdfl:pattern>(nl)|(no)|(oc)|(om)|(or)|(pa)|(pl)|(ps)|(pt)</rdfl:pattern>
   <rdfl:pattern>(qu)|(rm)|(rn)|(ro)|(ru)|(rw)|(sa)|(sd)|(sg)</rdfl:pattern>
   <rdfl:pattern>(sh)|(si)|(sk)|(sl)|(sm)|(sn)|(so)|(sq)|(sr)</rdfl:pattern>
   <rdfl:pattern>(ss)|(st)|(su)|(sv)|(sw)|(ta)|(te)|(tg)|(th)</rdfl:pattern>
   <rdfl:pattern>(ti)|(tk)|(tl)|(tn)|(to)|(tr)|(ts)|(tt)|(tw)</rdfl:pattern>
   <rdfl:pattern>(uk)|(ur)|(uz)|(vi)|(vo)|(wo)|(xh)|(yo)|(zh)</rdfl:pattern>
   <rdfl:pattern>(zu)</rdfl:pattern>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;NMTOKEN">
   <rdfs:subClassOf rdf:resource="&xsd;token"/>
   <!-- rdfl:pattern TBD -->
</rdfl:Datatype>

<rdfl:ListDatatype rdf:about="&xsd;NMTOKENS">
   <rdfl:itemType rdf:resource="&xsd;NMTOKEN"/>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;Name">
   <rdfs:subClassOf rdf:resource="&xsd;token"/>
   <!-- rdfl:pattern TBD -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;NCName">
   <rdfs:subClassOf rdf:resource="&xsd;name"/>
   <!-- rdfl:pattern TBD -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;ID">
   <rdfs:subClassOf rdf:resource="&xsd;NCName"/>
   <!-- rdfl:pattern TBD -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;IDREF">
   <rdfs:subClassOf rdf:resource="&xsd;NCName"/>
   <!-- rdfl:pattern TBD -->
</rdfl:Datatype>

<rdfl:ListDatatype rdf:about="&xsd;IDREFS">
   <rdfl:itemType rdf:resource="&xsd;IDREF"/>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;ENTITY">
   <rdfs:subClassOf rdf:resource="&xsd;NCName"/>
   <!-- rdfl:pattern TBD -->
</rdfl:Datatype>

<rdfl:ListDatatype rdf:about="&xsd;ENTITIES">
   <rdfl:itemType rdf:resource="&xsd;ENTITY"/>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;integer">
   <rdfs:subClassOf rdf:resource="&xsd;decimal"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;decimal"/>
   <rdfl:patternExclusion>[^\.]*</rdfl:patternExclusion>
   <rdfl:canonicalPatternExclusion>\+.*</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>0.+</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;nonPositiveInteger">
   <rdfs:subClassOf rdf:resource="&xsd;integer"/>
   <rdfl:pattern>0+</rdfl:pattern>
   <rdfl:pattern>-[0-9]+</rdfl:pattern>
   <rdfl:canonicalPatternExclusion>0+</rdfl:canonicalPatternExclusion>
   <rdfl:canonicalPatternExclusion>-0.+</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;negativeInteger">
   <rdfs:subClassOf rdf:resource="&xsd;nonPositiveInteger"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;nonPositiveInteger"/>
   <rdfl:patternExclusion>-?0+</rdfl:patternExclusion>
   <rdfl:canonicalPatternExclusion>-0.+</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;long">
   <rdfs:subClassOf rdf:resource="&xsd;integer"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;integer"/>
   <!-- need to constrain between 9223372036854775807 and -9223372036854775808. -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;int">
   <rdfs:subClassOf rdf:resource="&xsd;long"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;long"/>
   <!-- need to constrain between 2147483647 and -2147483648 -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;short">
   <rdfs:subClassOf rdf:resource="&xsd;int"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;int"/>
   <!-- need to constrain between 32767 and -32768 -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;byte">
   <rdfs:subClassOf rdf:resource="&xsd;short"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;short"/>
   <!-- need to constrain between 127 and -128 -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;nonNegativeInteger">
   <rdfs:subClassOf rdf:resource="&xsd;integer"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;integer"/>
   <rdfl:patternExclusion>-.*</rdfl:canonicalPatternExclusion>
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;unsignedLong">
   <rdfs:subClassOf rdf:resource="&xsd;nonNegativeInteger"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;nonNegativeInteger"/>
   <!-- need to constrain below 18446744073709551615 -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;unsignedInt">
   <rdfs:subClassOf rdf:resource="&xsd;unsignedLong"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;unsignedLong"/>
   <!-- need to constrain below 4294967295 -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;unsignedShort">
   <rdfs:subClassOf rdf:resource="&xsd;unsignedInt"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;unsignedInt"/>
   <!-- need to constrain below 65535 -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;unsignedByte">
   <rdfs:subClassOf rdf:resource="&xsd;unsignedShort"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;unsignedShort"/>
   <!-- need to constrain below 255 -->
</rdfl:Datatype>

<rdfl:Datatype rdf:about="&xsd;positiveInteger">
   <rdfs:subClassOf rdf:resource="&xsd;nonNegativeInteger"/>
   <rdfl:patternDependencyOn rdf:resource="&xsd;nonNegativeInteger"/>
   <rdfl:patternExclusion>\+?0+</rdfl:patternExclusion>
</rdfl:Datatype>

</rdf:RDF>
Last Modified: $Date: 2002/03/07 14:21:34 $