W3C home > Mailing lists > Public > public-rdf-dawg@w3.org > July to September 2006

Re: ISSUE: Malformed literals and non-lexical literals

From: Pat Hayes <phayes@ihmc.us>
Date: Thu, 17 Aug 2006 00:58:30 -0700
Message-Id: <p06230944c109ccdb91fb@[192.168.1.6]>
To: Bijan Parsia <bparsia@cs.man.ac.uk>
Cc: RDF Data Access Working Group <public-rdf-dawg@w3.org>

>I'm breaking this issue out and consolidating it.
>
>Under RDF, RDFS, and the D variants interpretations, some things 
>which are spelled like literals do not denote literals, and 
>somethings which are not spelled like literals do denote literals.

Terminology check. "literal" is a *syntactic* term in RDF. Literal 
values are what they normally denote, and the class of all literal 
values is rdfs:Literal. ' "foodle"^^xsd:number ' is a literal. That 
particular literal denotes a non-literal value in any 
D-interpretation with D containing xsd:number.

I think what you mean is, some literals do not denote literal values, 
and some non-literals (URIrefs and bnodes) may denote literal values. 
The first was a design decision, the second is semantically 
inevitable, unless we made RDF into a sorted logic.

>Beside each line I indicate the semantics under which the condition 
>holds using the following key: RDF for at least RDF interpretations, 
>RDFS for at least RDFS, *(D) for at least under (* +  D-entailment

Which D? Im guessing you mean the XSD version.

>), and obviously, the datatypes have to be part of the datatype theory.
>
>Literals:

None of these are literals. They are all non-literals which denote 
literal values.

>	:x where
>		x rdf:type rdf:XMLLiteral. (RDF)
>	_:b where
>		 _:b rdf:type rdf:XMLLiteral (RDF, but _:b doesn't 
>stand for a particular literal)
>	:x where
>		:x rdf:type rdfs:Literal (RDFS)

That is really all you need. The others all entail one of the above.

>	:x where
>		:x :p :y. :p rdfs:domain rdfs:Literal (or 
>rdf:Literal) (symmetric with range) (RDFS)
>	:x where
>		x rdf:type xsd:integer (RDF(D))

These 'where's aren't really needed. Any URIref *could* denote a 
literal value. The conditions you note - and they really all boil 
down to membership in rdf:XMLLiteral (RDF) or rdfs:Literal (RDFS) - 
are what would *entail* that the term denotes a literal value.

>The rest should be obvious. I may have missed some.

Yes, you can do it with subproperty and subclass as well.

>Non-literals:
>	"<"^^rdf:XMLLiteral (RDF)
>	"a"^^rdf:integer (RDF(D))
>	"-5"^^rdf:positiveInteger (RDF(D))
>(there are range and domain things analogous to the RDFS ones)
>
>(The latter are non-literals because they are illformed.

No, they *are* literals. They don't denote literal values.

>Illformed literals denote a non-literal element of the domain.

Quite.

>)
>
><http://www.w3.org/TR/rdf-mt/#RDFINTERP>
>""" The third condition requires that ill-typed XML literals denote 
>something other than a literal value: this will be the standard way 
>of handling ill-formed typed literals."""
>
>If I understand the current intention of the current document, 
>isLiteral returns false for all the above literals and true for all 
>the above non-literals, even under datatype semantics (which is the 
>only other semantics mentioned in the document).

My understanding is quite different, that isLiteral is a purely 
syntactic check on the form of the binding term. In other words, it 
means exactly what it says. Similarly for isBnode, of course, which 
would be meaningless or incoherent if understood as a predicate on 
denotations.

>I find that counterintuitive at the very least. Perhaps we could 
>wave away the literals above by constraining isLiteral to only the 
>lexical form, but under RDF semantics "<"^^rdf:XMLLiteral *is not a 
>literal*.

No, it really is a literal. See above.

>  (Is simple + datatype a possible combination? In which case all the 
>RDF weird literals/non-literals will also be in Simple(D)).
>
>I'll also note that:
>	"-5"^^rdf:positiveInteger < "5"^^rdf:positiveInteger
>
>should be an error, not false (I think).

That seems correct, indeed.

>This goes with the weird case:
>	:x rdf:type xsd:positiveInteger.
>	:y rdf:type xsd:negativeInteger.
>
>Let ?x/:x and ?y/y:
>	what does ?x > ?y evaluates to? Even if we think that 
>isLiteral is a special case, it's hard to see that the comparisons 
>should be (as I said before). Especially as some of them are 
>detectable for the lexical form of the binding.

Not sure I follow your reasoning here.

Pat
-- 
---------------------------------------------------------------------
IHMC		(850)434 8903 or (650)494 3973   home
40 South Alcaniz St.	(850)202 4416   office
Pensacola			(850)202 4440   fax
FL 32502			(850)291 0667    cell
phayesAT-SIGNihmc.us       http://www.ihmc.us/users/phayes
Received on Thursday, 17 August 2006 07:58:57 GMT

This archive was generated by hypermail 2.3.1 : Tuesday, 26 March 2013 16:15:27 GMT