RE: Literals (Re: model theory for RDF/S)

> > ... <... xml:lang="en">pan</...> is
> > a statement about the particular occurrence of the literal and
> > not about the byte sequence "pan" in general. 
> 
> You're perfectly right.
> So I guess that assigning the xml:lang property to the 
> *triple* would be
> better.
> 
>  <rdf:Description about="myuri">
>    <rdfs:label xml:lang="fr">Quelle bonne idée</rdfs:label>
>  </rdf:Description>
> 
> would hence result in
> 
> [[ myuri rdfs:Label "Quelle bonne idée" ] xml:lang "fr" ]

Well, you'd have to change the processing model of the
RDF parser to derive that -- and I would guess that it wouldn't
be considered quite kosher insofar as the XML spec is concerned
since the xml:lang property really does qualify the content
of the element, and not some interpretation of its parent. I.e.
it really doesn't define a property of the reified statement,
only of the literal value.

The way I currently do qualified values is to employ an explicit
'qualified value' class x:QValue for which the following
constraints/characteristics are defined:

   1. An x:QValue may occur as the value of any RDF property,
      regardless of property value type (i.e. whether it is a
      literal string value or a resource value).

   2. An x:QValue node must have one and only one value defined
      for the rdf:value property, specifying the actual value of
      the predicate in the statement in which it is the object.

   3. An x:QValue node must have one or more properties defined
      which serve to qualify the occurrence of the RDF property 
      value. The values of such qualifying properties may themselves have
      x:QValue node values, allowing recursive qualification of
      property values.

   4. Additional constraints/requirements governing the specific
      set of properties defined for a x:QValue node may be
      defined for a particular system or process.

This is essentially a refinement/restriction of the "poor man's
composite structure" approach defined for encoding Dublin Core 
in RDF. Having the explicitly typed anonymous node allows more
constraint governing the constructions, which results in more
consistent representations of such knowledge.

E.g. (forgive the bogus ad-hoc URIs ;-)

   <dc:title>
      <x:QValue>
         <rdf:value>User's Guide</rdf:value>
         <dc:language rdf:resource="urn:ietf:rfc:1766#en"/>
      </x:QValue>
      <x:QValue>
         <rdf:value>Käyttäjänopas</rdf:value>
         <dc:language rdf:resource="urn:ietf:rfc:1766#fi"/>
      </x:QValue>
   </dc:title>

or

   <foo:location>
      <x:QValue>
         <rdf:value
rdf:resource="http://www.abc.com/local/path/to/document"/>
         <dc:coverage rdf:resource="urn:worldzones:global"/>
      </x:QValue>
      <x:QValue>
         <rdf:value
rdf:resource="http://usa.abc.com/local/path/to/document"/>
         <dc:coverage rdf:resource="urn:worldzones:north_america"/>
      </x:QValue>
      <x:QValue>
         <rdf:value
rdf:resource="http://europe.abc.com/local/path/to/document"/>
         <dc:coverage rdf:resource="urn:worldzones:europe"/>
      </x:QValue>
   </foo:location>

etc.

> > I would myself love to see a data type URI approach by which 
> > otherwise "literal" values could be defined as instances of a 
> > given data type URI. E.g.
> > 
> >    dt:integer:5
> >    dt:token:en
> >    dt:date:2001-09-27
> >    dt:time:2000-11-01T17:32:20Z
> >    dt:float:38829.11883292
> >    ...
> 
> So would I...

Anyone else think this would be a good idea to pursue?

Cheers,

Patrick

--
Patrick Stickler                      Phone:  +358 3 356 0209
Senior Research Scientist             Mobile: +358 50 483 9453
Nokia Research Center                 Fax:    +358 7180 35409
Visiokatu 1, 33720 Tampere, Finland   Email:  patrick.stickler@nokia.com

Received on Thursday, 27 September 2001 08:15:27 UTC