W3C home > Mailing lists > Public > semantic-web@w3.org > July 2010

Re: RDF Extensibility

From: Henry Story <henry.story@gmail.com>
Date: Fri, 9 Jul 2010 12:12:19 +0200
Cc: Bernhard Schandl <bernhard.schandl@univie.ac.at>, Reto Bachmann-Gmuer <reto.bachmann@trialox.org>, Pat Hayes <phayes@ihmc.us>, Linked Data community <public-lod@w3.org>, Semantic Web <semantic-web@w3.org>
Message-Id: <E6AF20D1-6D52-46D4-A0DB-E0B6B7927786@gmail.com>
To: Jakub Kotowski <jakubkotowski@gmx.net>
On 9 Jul 2010, at 11:42, Jakub Kotowski wrote:

> Henry Story schrieb:
>> On 9 Jul 2010, at 09:29, Bernhard Schandl wrote:
>> 
>>> Hi,
>>> 
>>>> I agree with Pat in that case, that it would just be easier not to put restrictions
>>>> in the abstract rdf syntax at all, instead of complicating things all over the place.
>>>> There are pragmatic reasons why sentences such as 
>>>> 
>>>> <http://bblfish.net/#hjs> "name" "Henry" .
>>>> 
>>>> are not going to be successful, the main one being that it is impossible to 
>>>> adjudicate what the relation "name" refers to is about.
>>> In that respect, "name" is not different than any URI one has never seen before. What about adding
>>> 
>>> "name" rdfs:subPropertyOf foaf:name .
>>> 
>>> to this example?
>> 
>> That would be an interesting theory one could have.
>> 
>> But what if someone else, whom you never met, had decided
>> that
>> 
>> "name" rdfs:subPropertyOf nuclear:NuclearAtomMustExplode .
>> 
>> and he published information with that meaning.
>> 
> <snip>
>> Or put it differently, if you come across a triple with a pure string
>> literal relation, how would you know what relation the literal
>> was referring to? Where is the ontology to be found?
>> 
> <snip>
>>   those types of issue seem to me to indicate that it is not practical to
>> have pure string literals in predicate position. The only solution will be to
>> assign some name space to them, such as 
>> 
>>  <http://bblfish.net/#hjs> "name"^^<http://xmlns.com/foaf/0.1/> "Henry" .
>> 
>> And as soon as a name space is assigned we can get going again.
> 
> This looks more like a typed literal, not a namespace.

And indeed, my point was to get you to see how oddly similar those two
notions are :-) 


> Otherwise, if literals somehow really had a namespace then you could use
> the idea of ontology hijacking [1] to decide which RDF graphs are
> authoritative and which not.

No need then for any hijacking, that's just such a 70ies thing [1].
 
You could just follow your nose by dereferencing the "namespace", or 
the literal type to get the meaning.  We'd be back to linked data, 
but now with literals. How cool is that! :-)

So to understand the literal

"name"^^<http://xmlns.com/foaf/0.1/>

You would GET http://xmlns.com/foaf/0.1/

Perhaps that would just tell you that

"name"^^<http://xmlns.com/foaf/0.1/> owl:sameAs <http://xmlns.com/foaf/0.1/name> .

Super cool. 


> The problem is that literals don't have a namespace

Some of them do! Those that do are called typed literals :-)

> and they are not
> some meaningless local part of a URI, literals are resources the same
> way URIs are.

Indeed. No arguing that. Well in fact that's why we are arguing they
should be allowed in subject and predicate position too.


> So it seems triples like:
> 
> "name" rdfs:subPropertyOf nuclear:NuclearAtomMustExplode .
> 
> would always be not authoritative (literals have no namespace therefore
> there is no source that speaks authoritatively about them).

absolutely true for non typed literals.

> In this
> sense, inferences that use such triples would not be authoritative but
> they could well make sense and be useful to someone locally.

Indeed. It's just that you would have to be very careful about merging.
In my view for all practical purposes, literals of the type

 "hello" 
  "dog"@en  
  "string"^^xsd:string
  etc,

  Ie all pure literal strings, are not relations as a matter of fact.  
Those are a posteriori truths about them, and need not made to be logical
truths by incorporating that info the core RDF spec. You could get exactly
the same effect more easily by defining that the class of string literals
cannot be properties, by defining 

   xsd:string owl:disjointWith rdf:Property .

  This is just like the fact that foaf:Person is a class and not a relation. 
Some relations like <http://www.w3.org/ns/auth/cert#hex> are both classes, 
relations and datatypes! But that is rare. 

   The advantage is that we can then allow certain literals to be predicates.
This may in fact make it easier to GRDDL some silly XML specs for example :-)

	Henry


> 
> Jakub
> 
> [1] Scalable Authoritative OWL Reasoning for the Web, Aidan Hogan,
> Andreas Harth, Axel Polleres, DERI Technical Report 2009-04-21, page 14
> http://www.deri.ie/fileadmin/documents/DERI-TR-2009-04-21.pdf
> 
> 
>> 
>>   Henry
>> 
>> 
>> 
>>> Best
>>> Bernhard
>> 
>> 
>> 
> 
[1] http://www.leblogducinema.com/2010/06/25/critique-carlos/
Received on Friday, 9 July 2010 10:12:52 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 1 March 2016 07:42:21 UTC