RE: Dave Reynolds: rdf:text - clarification requested

(The cc's were removed on the original email)


Boris wrote:
> Hello,
>
> Please allow me to explain how we meant rdf:text to be interpreted.
> Consider the following two graphs:
>
> (G1)    eg:a eg:p  "foo"@en .
>
> (G2)    eg:a eg:p  "foo@en"^^rdf:text .
>
>
> Our intention was that (G1) and (G2) are semantically equivalent. This
> is because we indented the rdf:text spec to be interpreted such that,
> whenever you see somewhere "foo"@en, you actually mean
> "foo@en"^^rdf:text. There are no entailment rules in RDF for this, but
> these are not really needed: "foo"@en is *identical* to
> "foo@en"^^rdf:text --that is, the two should be interpreted in the same
> way and one should be treated as a syntactic shortcut for the other.

Semantic equivalence is through entailment so I don't see how there can be no entailment rules in RDF yet (G1) and (G2) are semantically equivalent.

As RDF abstract syntax, they are not equivalent.  This is a simple matter to resolve because we are just talking about how the RDF specifications are currently written.  If I have misread them, please just quote from the RDF specifications to explain why I am wrong.

This is aside from whether they should have been in the first place - it is just stating what the RDF specs currently say and that is that G1 and G2 are different abstract syntax.

> Similarly, "foo" is to be taken as a syntactic shortcut for
> "foo"^^xsd:string; thus, both are actually identical to each other.

Again, you are presenting a new design because this is different to how RDF deals with the matter at the moment.  Aside from which is a better design, we do have in-place specifications so deviating from them should come with justification and an advantage for the change.

>
>
> Now let's consider the impact of this change to SPARQL. In our opinion,
> we thought the following should be the case:
>
> Lang("Padre de familia@es"^^rdf:text) ==> "es"
> Lang("Padre de familia"@es) ==> "es"
> Lang("Padre de familia") ==> ""
> Datatype("Padre de familia@es"^^rdf:text) ==> rdf:text
> Datatype("Padre de familia") ==> xs:string
>
> I believe that all this is unequivocal,

It may be unequivocal as to your intent but I also see comments that the intent is to have no visible change to RDF.  It is different from the SPARQL specification of Jan 2008 as I read the specifications.

> and I see only one possible
> difference. In your e-mail, you said the following:
>
> Datatype("Padre de familia"@es) ==> error

I also pointed out that in SPARQL:

Lang("Padre de familia@es"^^rdf:text) ==> ""
datatype("foo"@en) ==> error

If you think I have misread, please quote the specification.  We are merely dealing with the base facts here.  If you agree that rdf:text does make observable changes to RDF and SPARQL we are done.

For example:

http://www.w3.org/TR/rdf-sparql-query/#func-lang

"""
Returns the language tag of ltrl, if it has one. It returns "" if ltrl has no language tag. Note that the RDF data model does not include literals with an empty language tag.
"""
So lang(Padre de familia@es"^^rdf:text) ==> ""


> I can't say I really thought about this particular thing in advance, but
> instinctively I'd say that the following should be the case:
>
> Datatype("Padre de familia"@es) ==> rdf:text
>
> I believe this might make sense from the SPARQL point of view. If,
> however, this is really causes problems for some people, we can add to
> the rdf:text document and "exception" and say that Datatype("Padre de
> familia"@es) should return "error".
>
> Regards,
>
>       Boris

It seems that there is an intent to change SPARQL and RDF by interpreting in a way that is different from the current specifications.  Because these are observable changes, we are just discussing readings of the specs, so please quote the text in the specifications.  Even if it would have been desirable to have in different in the first place, we are starting from the specifications of other working groups so they needs to be a big reason to change.

There is a simple change that can be made to the rdf:text document which is that when writing RDF, the forms in the current specifications MUST be used and because OWL2 and RIF processors are required to interpret the language tag and xs:string literals anyway, it is of no cost to OWL2 and RIF implementations.  This way, no observable change to RDF processors or to SPARQL is caused.

Then the better design can be recorded for whenever RDF is revised and it can be considered along side other approaches.

        Andy


--------------------------------------------
  Hewlett-Packard Limited
  Registered Office: Cain Road, Bracknell, Berks RG12 1HN
  Registered No: 690597 England

Received on Tuesday, 16 December 2008 10:38:30 UTC