Antoine Zimmermann wrote:
Jeremy, et al.,
I think people are already showing the money but they do it 2 cents
after 2 cents ;-) Here is my little 2 cent contribution.
To start with, I am on the side of the people in favour of allowing
literals in the subject position. I've read the discussion and pondered
the arguments on each side carefully, but I'm still convinced that it
would ultimately be the better option to allow them. I understand the
concern of those who would have to rework their architectures. Yet I
don't believe that the cost exceeds the benefits for those who are
starting to implement and for future implementations and future
developments of the standards.
As Sandro said, RIF is using triples with literals as subjects, as
Robert Fuller said (in the LOD list), reasoners are internally inferring
triples with literals in subject position, and other use cases (more or
less convincing) have been proposed here. Why can't those inferences and
facts be exposed and published in an RDF document?
Now I'd like to show some of the strange things that happen when you
combine SPARQL with inference regimes, that are due to the inability to
have literals (in the syntax) as subject.
Assume that you have the following data, harvested from the Web:
:www dc:creator "Tim Berners-Lee" .
:www dc:creator "Tim Berners-Lee"^^xsd:string .
:www dc:creator :timbl .
:timbl owl:sameAs "Tim Berners-Lee" .
Note that literals are commonly used with dc:creator so this example is
fairly realistic.
Now, let us consider the following query:
SELECT ?x WHERE {
?x a rdfs:Resource .
}
under the RDFS-entailment regime, this would provide the following answer:
?x --> :timbl
Now, the following query:
SELECT ?y WHERE {
?y a rdfs:Literal .
}
would provide no answer (under RDFS-entailment) and:
SELECT ?z WHERE {
?z a xsd:string .
}
would provide no answer (under RDFS-entailment).
Now, imagine a SPARQL engine with an "RDFS+sameAs"-entailment regime.
The three queries above would give the following results:
?x --> :timbl // first query
?y --> :timbl // second query (I can infer that :timbl is a rdfs:Literal)
and the last would give nothing.
Now consider the query:
SELECT ?t WHERE {
?u a rdfs:Literal .
?u owl:sameAs ?t .
}
It would give:
?t --> "Tim Berners-Lee"
?t --> :timbl
However, the query:
SELECT ?u WHERE {
?u a rdfs:Literal .
?u owl:sameAs ?t .
}
would give ?u -> :timbl .
This is very weird for me.
Something else that keeps coming up, a subset of owl always comes in to
conversations, obviously owl:sameAs - there was a proposal from one Jim
Hendler [1] at a RDF workshop thing to perhaps do something about moving
these up a level to RDFS.
[1] http://www.w3.org/2009/12/rdf-ws/papers/ws31
Didn't seem to get much feedback or thoughts (afaik), but given the
climate perhaps it's worth giving some strong consideration to as a
community.
(Or just doing because it's a bloody good idea & would remove OWL from
virtually every conversation we end up having).
ps: my only comment/addition to this was to add in Restriction's too
Best,
Nathan
forking again, sorry!
