The blank node way Re: Can there be a URI for the concepts "I" ...

Hi Joshua and John

Back to early stages of this thread. I mostly agree with Joshua that 
indirection is needed, but there is another way to use blank nodes, 
which nevertheless allows using the URIs for "I" etc with a context-free 
semantics. Think of "I' as the role of the locutor is some context, not 
the locutor itself. The locutor differs, but the role is always the same.
And try to represent the utterance context itself as a bnode.
cx: is the prefix for your "context ontology".

_:c      rdf:type     cx:UtteranceContext
_:c      cx:contextResource   
<http://www.kashori.com/archives/2006_12_17_archive.html>
_:c      cx:role      <http://kashori.com/ontology/indexicals.owl#I>
_:c      cx:actor      <http://www.kashori.com/JohnBlack/foaf.rdf#jpb>

Whatever the context, the semantics of 
"http://kashori.com/ontology/indexicals.owl#I" is the same, it 
represents the role of the locutor. What is contextual is the actor 
playing the role.
Note that this looks like a topic map association ...
With such a structure, you can easily query stuff like

ALL cx:UtteranceContext
WHERE
cx:actor = <http://www.kashori.com/JohnBlack/foaf.rdf#jpb>
cx:role = <http://kashori.com/ontology/indexicals.owl#I>

Bottom line: What URIs are good at identifying without ambiguity are 
property values (RDF objects). Using them to identify subjects is not 
always a good idea. In this case, having a URI for the context itself 
would certainly be useless and maybe over-specifying. With no URI, you 
are free to let applications decide which contexts are considered the 
same or not, based on specific rules on properties. Some applications 
would decide that all contexts where role "I" is played by "John Black" 
are the same, and will cluster all contextResource properties, some 
other will not.

This is yet another variation on the "Every subject is a blank node" theme.
See also 
http://lists.w3.org/Archives/Public/public-esw-thes/2006Dec/0033.html

Cheers

Bernard

Joshua Tauberer a écrit :
> John Black wrote:
>   
>> Are the following URI allowable according to web and semantic
>> web standards? Are they ambiguous? Are they useful? In each case,
>> the referent would depend on the context of the use[1] of the URI.
>> http://kashori.com/ontology/indexicals.owl#I
>> http://kashori.com/ontology/indexicals.owl#you
>> http://kashori.com/ontology/indexicals.owl#this
>> http://kashori.com/ontology/indexicals.owl#it
>> http://kashori.com/ontology/indexicals.owl#here
>> http://kashori.com/ontology/indexicals.owl#there
>> http://kashori.com/ontology/indexicals.owl#now
>>     
>
> I think one of the major benefits of RDF is that applications completely
> oblivious to any schemas can still at least make one conclusion about
> URIs, which is that if two documents use the same URI, they are
> referring to the same thing.  Context-dependent URIs break this.  It
> might be fine in some cases, but in general it would break the principle
> that <indexicals.owl#I> refers to the very same thing no matter where it
> appears.
>
>   
>> Therefore they would only be of use if they could be embedded in a
>> structure that specified a context.
>>     
>
> That would be fine, except afaik the only way to publish a triple in an
> embedded context is with N3 formulas.  You can't, for instance, create
> an embedded context in RDF/XML.  (It wouldn't be sufficient to add a
> triple to an RDF/XML document to say "hey, this is one of those
> documents where you interpret <indexicals.owl#I> as ME" because it
> doesn't solve the problem that oblivious applications won't know to do
> that.)
>
> But, there is a way to get around these problems, which is to use some
> indirection.  Actually, that actually parallels the real-world side of
> things.  That is, we're not all named "I" (in the sense that a URI is a
> name for something).  "I" is really a function from a context to an
> individual.  The closest thing to a function in RDF is a predicate, so
> you could do this (in N3):
>
> <> indexicals:isBeingReadBy _:you .
> <> indexicals:isBeingReadAtLocation _:here .
> (then you go on to make assertions about _:you and _:here.)
>
> where <> is the URI for the document itself, and _:you and _:here are
> bnodes.  Like this, an application isn't going to make the mistake that
> the same person is the "I" of every document.  Here it says "someone is
> reading the document", and just when the applications understands
> indexicals:isBeingReadBy it can say "Oh, and _:you is actually me!".
>
> (I'm not positive that that actually solves every problem, but it seems
> to be a step in the right direction.)
>
>   

-- 

*Bernard Vatant
*Knowledge Engineering
----------------------------------------------------
*Mondeca**
*3, cité Nollez 75018 Paris France
Web:    www.mondeca.com <http://www.mondeca.com>
----------------------------------------------------
Tel:       +33 (0) 871 488 459
Mail:     bernard.vatant@mondeca.com <mailto:bernard.vatant@mondeca.com>
Blog:    Leçons de Choses <http://mondeca.wordpress.com/>

Received on Tuesday, 2 January 2007 09:19:17 UTC