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

Re: Literal subjects can be tidy (was: Re: Use case for tidy literal subjects (ignore if not interested))

From: Patrick Stickler <patrick.stickler@nokia.com>
Date: Tue, 19 Feb 2002 08:58:21 +0200
To: Pat Hayes <phayes@ai.uwf.edu>, Brian McBride <bwm@hplb.hpl.hp.com>
CC: RDF Core <w3c-rdfcore-wg@w3.org>
Message-ID: <B897C42D.EEB3%patrick.stickler@nokia.com>
On 2002-02-19 4:22, "ext Pat Hayes" <phayes@ai.uwf.edu> wrote:

>> During the datatyping followup after Friday's telecon, I made
>> the statement that if literals were subjects which took datatyping
>> properties, they must be untidy -- and I was told this was incorrect.
> Then we were at cross purposes.
> There are two issues here: whether literals can be subjects, and
> whether a literal node can have a datatype-sensitive meaning.

I never said that literal subjects could not be tidy. I said literal
subjects that were tidy could not bear meaningful datatyping

I fully understood both issues, and was simply trying to make a point
about the second case, where literal subjects would bear datatyping
qualification. I think it *was* unclear for some of the other participants
that I was talking about the second issue, though I tried to stress that,
which is why I posted my examples and explanation.

I consider the first case, in the context of tidy literals, to be so
trivial as to not be worth bothering any time discussing. I can't imagine
anyone caring to go to any trouble to get such uninteresting, anemic,
useless tidy literal subjects. Who cares if tidy literals are subjects?

*BUT*, since all of the debate previously about allowing literals as
subjects would have presumed *untidy* and interesting literal subjects,
I simply wanted it to be clear that the tidy/untidy distinction was
"can't have your cake and eat it too" with regards to literals as
subjects, that's all.

> But this arises even if we
> do not allow literals as subjects, as in the old P idiom (updated
> here to use drange):
> aaa age "10" .
> age rdfs:drange decimalInt .

No. In the above example, tidy vs. untidy is irrelevant. The literal
node does not itself denote the value or the lexical form. It is
just a literal. For inline idioms, the data value
has no explicit denotation in the graph. It is implied. Only the
bNode idioms provide explicit denotation of values in the graph, and
that is the primary (possibly only) difference between the inline
idiom and the value triple idiom, when applying a union interpretation
to rdfs:drange.


> So, to repeat, the two issues are separate; and when separated, it is
> the latter, not the former, that requires untidy literals. I thought
> that we had decided the latter issue some time ago in favor of
> tidiness.

We did. And I had no problem with the first issue, but was concerned
about folks who may read too much into the 'literal as subject' and
think they might get interesting, useful literal subjects in the
future. They won't. Tidy literals kills that possibility.

> I suggest that we stick with the decision to have literals always
> denoting themselves, under all circumstances, as a rock-solid
> principle. 

I never suggested that would change. The union treatment of rdfs:drange
does not change that. Only the bNode idioms provide explicit denotation
of values in the graph. Literals are just literals. Period.

> Literals are *never* contextual in their meaning; all the
> datatyping cleverness applies to the bnode at the other end of the
> triple. 

Well, literals themselves, in isolation bear no meaning, but as
a component of a TDL pairing, they denote a lexical form, but it
is not the literal *in the graph* that denotes the lexical form
but the literal in the context of a TDL pairing that is treated
as a lexical form. It's a fine distinction, but I think a clear
> Then we can allow literals to be subjects with equinamity,
> and still retain tidy literal nodes in the syntax. Your example then
> has a datatyping clash in the merged graph, in just the same way as
> if you had used bnodes rather than literals.

No. You're missing the very critical point that rdfs:drange is
taken as constraining the property value to the *union* of the
lexical space and value space of the datatype. Thus, there is no
type clash.

> However, the first graph
> is nonsensical on its face, since the triple
> "30" rdf:dtype decimalInt .
> says that the string '30' is in the *value* space of decimalInt,
> which is presumably false, and would be immediately rejected by a
> datatype checker.

True, but...

You're mixing datatyping solutions, Pat. If we had untidy, literal
subjects, we would do things very differently than we are doing
them now. You can't impose consistency of the present solution,
which never considered untidy literal subjects, to the above
examples. That's not fair.

But it's also not relevant, so let's just drop it.

I think we are (and have been) in agreement.


Patrick Stickler              Phone: +358 50 483 9453
Senior Research Scientist     Fax:   +358 7180 35409
Nokia Research Center         Email: patrick.stickler@nokia.com
Received on Tuesday, 19 February 2002 01:56:51 UTC

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