W3C home > Mailing lists > Public > w3c-rdfcore-wg@w3.org > September 2002

Re: in line literal semantics

From: Patrick Stickler <patrick.stickler@nokia.com>
Date: Mon, 9 Sep 2002 10:42:23 +0300
Message-ID: <000f01c257d4$6fa78cd0$294516ac@NOE.Nokia.com>
To: "ext Jeremy Carroll" <jjc@hpl.hp.com>, <w3c-rdfcore-wg@w3.org>

Bravo Jeremy. 

While I would myself prefer to also have untidy semantics for
inline literals, Jeremy's proposed middle ground of adopting
untidy syntax with unspecified semantics has the significant
benefits of (a) letting us postpone the decision about tidy
vs. untidy semantics, while still (b) providing an abstract
syntax that supports either interpretation.

I wholeheartedly support this proposal, whether or not we
also still decide to consider the semantics of inline literals.

(specific comments below)

[Patrick Stickler, Nokia/Finland, (+358 50) 483 9453, patrick.stickler@nokia.com]
----- Original Message ----- 
From: "ext Jeremy Carroll" <jjc@hpl.hp.com>
To: <w3c-rdfcore-wg@w3.org>
Sent: 08 September, 2002 23:29
Subject: in line literal semantics

> In one camp, that has been quite quiet of late, we have those who argue that 
> inline literals should be self denoting.
> In another, there are those, (some of whom believe the argument has been won), 
> who argue that inline literals denote something else, which might be made 
> clear elsewhere.
> Then there also a few voices, myself and Graham, at the last telecon, arguing 
> for minimalism.
> We have seen the tidiness vs untidiness debate as one without a middle ground.
> The point of this message is to propose it. (or rather to remind the group of 
> its existence).
> Middle ground:
> ============
> >From datatyping part 1:
>   Explicit data values in the graph are self denoting.
> >From Valentines day MT (VMT)
> http://www.w3.org/TR/2002/WD-rdf-mt-20020214/
>   Other literals are syntactically untidy.
>   Literal semantics depends on a function XL mapping lteral nodes to literal 
> values.
>   Nothing is said about whether XL induces a function or not on the literal 
> labels. i.e. this does not rule out tidy semantics.
> Moreover, consider the crucial tidiness entailments.
> <a> <foo> "literal" .
> <b> <bar> "literal".

Which I presume would actually be written

   <a> <foo> _:x"literal" .
   <b> <bar> _:y"literal" .


> this does not entail
> <a> <foo> _:b .
> <b> <bar> _:b .
> (in the VMT)


> However, this is not because of untidy semantics, but merely because the first 
> triple by itself is not entailed.
> i.e.
> <a> <foo> "literal" .
> does not VMT-entail
> <a> <foo> _:b 
> (bnodes don't match literals in the Valentines day MT).

The nice thing here is that we can choose either tidy or untidy
semantics merely by adding closure rules to the MT, without
any change to the concrete or abstract syntax. Sweet.

Thus, if we want tidy semantics, then we simply assert that
each non-explicitly-typed literal denotes the
unicode string portion of its label. If the graph contains
the node (_:x, "LLL"), then I((_:x, "LLL")) = I("LLL").

And if we want untidy semantics, then we assert that the
systemID portion of a non-expliticly typed literal denotes
some datatype, typically disambiguated by a rdfs:range
assertion, e.g. if the graph contains the triples

   ddd rdf:type rdfs:Datatype .
   aaa bbb (_:x, "LLL") .
   bbb rdfs:range ddd .

then I((_:x, "LLL")) = I((ddd, "LLL"))


Very nice indeed. And we could even pre-specify the extensions to the MT
for the tidy versus untidy interpretations, so that application developers can
have a solid basis to choose one or the other, and a place to point to that
is official, even if non-normative.

> Thus, if we choose the Valentines day MT, we are not ruling out RDF2 choosing 
> tidy semantics.
> We, are old and tired, we already have agreed enough to meet our charter. We 
> should postpone work on the semantics of inline literals for a new and fresh 
> working group.
> ========
> Obviously, I have been an advocate of untidiness for a while; if the grouo has 
> consensus to go with untidiness, then I clearly would be in favour.
> However, I would also be very surprised.
> If any of the group cannot live with Part 2, but could accept some sort of 
> compromise of the sort outlined above, then they would get my support.

If we cannot agree on the semantics of inline literals, then 
I think that Part 1 with the above addition of untidy syntax for inline
literals, and pre-defined MT extensions for tidy versus untidy semantics
would be a far more complete and reasonable solution than Part
1 alone, as presently defined. 

Though I think we should still give strong consideration to untidy

> Another way to go would be for us to collectively downgrade the tidiness 
> issue. My take, is that with the values in the graph, the decision for tidy 
> or untidy is much less pointed. Although I would value the debate, I believe 
> my position has changed from "cannot live with tidy" to simply a preference 
> for untidy.
> If we all can downgrade our previously strong opinions then a debate and 
> asimple majority decision would suffice.

If Part 1 were extended with untidy syntax, and the semantics of
inline literals was left agnostic (allowing applications to assert either
tidy or untidy without running foul of the MT) then I would be 
satisfied with that.

I am not, however, prepared to downgrade my position from "cannot
live with tidy semantics" as I feel that tidy semantics of inline (non-typed)
literals is fundamentally wrong.


Received on Monday, 9 September 2002 03:42:27 UTC

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