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

> -----Original Message-----
> From: ext Sean B. Palmer [mailto:sean@mysterylights.com]
> Sent: 05 October, 2001 23:36
> To: Stickler Patrick (NRC/Tampere)
> Cc: www-rdf-logic@w3.org
> Subject: Re: Literals (Re: model theory for RDF/S)
> 
> 
> [...]
> > Well, if "scoping" (a'la XTM, ISO Topic Maps) were added as
> > a primitive feature of the graph, rather than having to resort
> > to typed anonymous nodes, then one could see data typing of
> > literal values as just a scope, like any other qualification.
> 
> Where in any of the RDF specifications does it say that 
> Literals are typed
> anonymous nodes? RDF Core don't seem to have decided what to 
> use rdf:value
> for yet, so it can't be in the specification as "lexical 
> representation
> of".

Never said that typed anon nodes where in any of the RDF specs.
Did I? You may be reading a bit into what I was saying...

I simply said that typed anon nodes seem the most logical method and
in fact have some degree of official definition - a'la RDF application
by DCMI.

> But I agree that people seem to be leaning in that direction, 
> including
> myself.
> 
>    :Sean :name "Sean" .
> 
> becomes:-
> 
>    :Sean :name _:sean .
>    _:sean rdf:value (s:U0063 s:U0065 s:U0061 s:U006E) .
>    _:sean rdf:type :Name .
> 
> and therefore, I guess:-
> 
>    rdf:value rdfs:range str:String .
> 
> but I don't think there's any point in actually implementing 
> it that way.

Why not

  <rdf:Description rdf:about="#sean">
     <rdf:value>Sean</rdf:value>
     <rdf:type rdf:resource="#Name"/>
  </rdf:Description>

I don't get the '(s:U0063 s:U0065 s:U0061 s:U006E)' really.

And really this is basically the same as Wolfram's proposal, which
I really see as just an explicit representation of knowledge which
can be implicitly, but consistently and portably defined in terms
of a URI encoding for those literals.

E.g. 

URI representation:

  "name:Sean"

Semantics of URI scheme:

  <rdf:Description rdf:about="name:">
     <rdf:type rdf:resource="#Name"/>
  </rdf:Description>

Expanded knowledge from URI and URI Scheme:

  <rdf:Description rdf:about="name:Sean">
     <rdf:value>Sean</rdf:value>
     <rdf:type rdf:resource="#Name"/>
  </rdf:Description>

etc...

Also, see my arguments against this kind of expanded construct as a primary
for of knowlege encoding with regards to conciseness and scalability for 
infinite sets.

> People will always just use "Sean" as a literal identifier, without
> expanding it into a bNode, and there's no way to give a label 
> to a bNode in
> XML RDF anyway. 

Sorry...uhhh... "bNode"? Eh? What? En ymmärrä...

(I guess this is N3 speak...  and maybe soon in my busy schedule
I'll get around to learning yet another non-standard serialization,
but... wouldn't it be fair that RDF on the RDF lists be RDF... eh?)

(as in the current standard, I mean... after all, why don't I just
start tossing out RDF examples in my own pet alternate serialization
model and start talking about fooNodes and barNodes and booga
transforms...)

(yeah, yeah, that's a bit anally pedantic... but it's been a long
standing annoyance that I finally thought I'd vent some steam about...)

(the whole point of standards are that they are, uhh, well, you 
know...   *standards*   ... eh?)

(and, yes, I know alot of RDF folks love N3, etc. and think it is
now the defacto official RDF serialization...   I guess I'm just being
a pigheaded, stubborn, idealist...  imagine that! ;-D

So, anyone care to tell me what a bNode is, or do I have to go
look it up on the Web as my homework for tonight?

> So this method is a piece of theoretical 
> pedantry, IMO.
> It's quite accpetable to have a literal refered to only in 
> using it, i.e.
> there is no conceivable situation that I can think of that 
> would merit the
> anon node solution, other than to satisfy some theoretical bug.

Well, what you did above was not using anonymous nodes ;-)

I.e., you didn't create an anonymous node. You created a named
resource that serves as a proxy for a literal. That's not the same 
thing. They are analogous in structure, but not in interpretation.

An anonymous node constitues a qualified *occurrance*. The assignment
of a URI to an anonymous node results in the occurrance-local properties
being made global to all other occurrences which reference that
resource. Now, this may seem like splitting hairs or smoke and
mirrors -- in that one could actually assign a unique URI to each
anonymous node and say that the result was the same -- but true anonymous 
nodes are the only assured mechanism to isolate occurrence-specific
properties, and the assignment of a URI to them removes that assurance
(even if it does not in fact introduce any reuse of that knowledge).

And in fact, as with Wolfram, you simply are providing an explicit
representation of the knowledge embodied implicitly (though regularly)
in a URI encoded literal (though such an explicit representation is
likely "a good thing" at some point in processing -- just not IMO
at the fundamental level of knowledge definition/management).

> > Still, wherever one defines the data type of a literal, it
> > results in the same amount of information: a data type
> > identifier, and a literal value.
> 
> Yep.
> 
> > [...] I think I'd prefer having a centralized authority such as
> > IETF, W3C, IEEE, ISO, etc. defining most of my data types, eh?
> 
> For the base datatypes? Yes, I would. And, lo and behold, they already
> have:-
> 
>    http://www.w3.org/TR/xmlschema-2/

Well, for some types, yes, a general data type model has been defined,
but not a generic, fully web-application portable URI scheme for their 
representation. I.e., various data types have been defined, such as
"http://www.w3.org/2000/10/XMLSchema#nonNegativeInteger" but no official
URI representation for typed values, e.g. "xsd:nonnegint:5".

And I also am not sure I'd pick XML Schema over e.g. IEEE or ISO for
my preferred authority for standardized data types -- no offense to 
the W3C or XML Schema folks. Though, if data type URI schemes existed
based on both XML Schema and e.g. IEEE, one could certainly use RDFS to
define their equivalence relations, so just as with ontologies in
general, there is freedom to use what one feels is optimal (and hope
that the mappings will exist or be even possible to define such that
others will know what you "mean"). 

Yes, you can do this stuff without URI representations, but it's a 
simple matter of efficiency and usability as to which methodology is
preferable.

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 Monday, 8 October 2001 04:12:53 UTC