W3C home > Mailing lists > Public > w3c-rdfcore-wg@w3.org > October 2001

Re: Argh!

From: Sergey Melnik <melnik@db.stanford.edu>
Date: Mon, 29 Oct 2001 11:49:17 -0800
Message-ID: <3BDDB2BD.7E6820D6@db.stanford.edu>
To: "Peter F. Patel-Schneider" <pfps@research.bell-labs.com>
CC: phayes@ai.uwf.edu, RDFCore WG <w3c-rdfcore-wg@w3.org>
"Peter F. Patel-Schneider" wrote:
> > You are right, according to the DAML/OIL schema, &quot;2&quot; is supposed to be a
> > nonNegativeInteger. Following Pat's proposal, &quot;2&quot; could denote many
> > different things like numbers, shoe sizes and weights in pounds
> > depending on the context. In my opinion, this ambiguity is
> > counterproductive and is a heavy burden for interoperability.
> Arghhhh!  Pat's proposal does not introduce any extra ambiguity.  Pat's
> proposal is quite compatible to the DAML+OIL way of doing things.  Pat's
> proposal produces a single denotation for literals that are the object of
> DAML+OIL cardinality properties.
> Please, please, please, if you are going to argue against Pat's proposal
> get the facts right!

I'd be glad to and I'm sorry if I don't. Of course, you are right in
that the immediate interpretation (by means of 'I') of each literal
symbol is some uniquely determined entity in DD. Then, in your/Pat's
suggestion,  some other mapping (IDT, if I remember right) assigns each
of these uniquely determined entities a set of other entities. So what's
the difference? Effectively, a literal symbol is mapped to a *set* of
entities in DD by a composition of mappings.

Please prove me wrong - maybe that's just a big misunderstanding. I
brought up several examples in
http://lists.w3.org/Archives/Public/w3c-rdfcore-wg/2001Oct/0530.html and
illustrated graphically my understanding of how they should be
interpreted. I'm still waiting for Pat's output of MT DT section, in
which he will presumably provide an illustration of an alternative
approach. How would the examples I referred to look like?

> > If literals may denote everything you like (and many things at once), I
> > don't see why we need resources/URIs any more. We could do just fine
> > with literals. For example, literal &quot;Peter&quot; could denote a person,
> > sometimes Peter Pan, another time Peter The Great (even in the same
> > graph!). Literal &quot;2&quot; in the above example could well denote Peter The
> > Great, too.
> This is soo wrong that I don't know how any reasonable person could even
> think of it.  Literals are constrained in their interpretation.
> Non-literals are less constrained than literals.  The only differences
> between literals and non-literals is that a literal has a ``print-string''
> that is used to restrict what it can denote and a non-literal can have a
> label, which has no real import in a tidy RDF graph.

So? Literals are constrained by what? By properties defined in some
schemas? So why can't "Peter" denote Peter Pan (or Patel-Schneider,
given the context ;) ?

> If it makes you feel better, you could use a different (but equivalent)
> graph where a literal maps into two nodes.  One node, corresponding to the
> node in Pat's RDF graphs, would be *like* a blank node.  The other node
> would be the ``print-string'' of the first node.  The model theory would
> then constrain the interpretation of the first kind of node by having a
> built-in interpretation of ``print-string''.

The last sentence stops me from feeling better. If you change it to "The
property that connects the blank node and the ``print-string'' node
constrains the interpretation of the blank node", I would totally
subscribe under the above paragraph.

> Why use Pat's RDF graphs instead of these graphs?  Two reasons:
> 1/ Pat's RDF graphs are closer to RDF M&S.

Graphs are graphs, and are as close to graphs, as any other graphs. I
don't buy that Pat's *interpretation* of those graphs is closer to M&S -
I believe the opposite.

> 2/ The ``print-string'' edge would be subject to lots of misunderstandings.

This is where I vehemently disagree. The edge determines the
interpretation of the blank node, it represents a mapping (possibly
partial) between a lexical space and a value space. XML Schema defines
such mappings in a quite precise fashion. IMO, the edge is what makes
datatyping work!

> Peter F. Patel-Schneider
> PS: Feel free to forward this to rdfcore-wg.

Action completed ;)

Received on Monday, 29 October 2001 14:22:54 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 20:24:05 UTC