W3C home > Mailing lists > Public > www-rdf-interest@w3.org > December 2003

RE: Trust, Context, Justification and Quintuples

From: Jos De_Roo <jos.deroo@agfa.com>
Date: Sat, 20 Dec 2003 14:11:35 +0100
To: "Graham Klyne <gk" <gk@ninebynine.org>
Cc: "Chris Bizer" <chris@bizer.de>, "Jeremy Carroll" <jjc@hplb.hpl.hp.com>, www-rdf-interest@w3.org
Message-ID: <OF5264EE82.1B71ABD4-ONC1256E02.0048461F-C1256E02.0048804A@agfa.be>


Assuming (-- taken from Tarski)

==
Whenever, in a sentence, we wish to say something about
a certain thing, we have to use, in this sentence, not
the thing itself but its *name* or *designation*.
(this is also the case when the thing talked about
happens to be a word or a symbol)

Every expression should differ (at least in writing)
from its *name*.

Forming the *name* of an expression can be done by placing
it between quotation marks.

The same thing can have many different *names*.
==

and assuming N3's { and } as quotation marks

then we at least have one of the different means
for naming graphs.


I understand your example

ID => { < a, b, c >
         < a1, b1, c1 >
         < a2, b2, c2 > }

ID => { < a3, b3, c3 > }

as giving 1 name to 2 *different* things which I guess
was not the intention and which is bad of course.


I've never felt the need for more than {triples} names;
those names are written on documents which have URI's
and those URI's are the pivotal points.

--
Jos De Roo, AGFA http://www.agfa.com/w3c/jdroo/


                                                                                                                                          
                      Graham Klyne                                                                                                        
                      <gk@ninebynine.org>         To:       "Jeremy Carroll" <jjc@hplb.hpl.hp.com>, "Chris Bizer" <chris@bizer.de>,       
                      Sent by:                     <www-rdf-interest@w3.org>                                                              
                      www-rdf-interest-req        cc:                                                                                     
                      uest@w3.org                 Subject:  RE: Trust, Context, Justification and Quintuples                              
                                                                                                                                          
                                                                                                                                          
                      19/12/2003 18:56                                                                                                    
                                                                                                                                          
                                                                                                                                          





At 13:31 19/12/03 +0100, Jeremy Carroll wrote:
>I suggest that instead of a quadruples or quintuples approach that this
>difference in semantics is better reflected by naming graphs (sets of
>triples).

FWIW, this is just what I do in my current software.

But I note that it is, in information terms, pretty much equivalent to
using quads, where the 4th item is a context id.

quads->labelled graphs:
   collect statements by context id
   use context id as graph label
   put statements, without context id, into appropriately labelled graph

labelled graphs->quads:
   for each statement of each labelled graph:
     construct a quad that is the statement
     PLUS the graph identifier as its context id

It's informally stated, but I think that's a bijection.

But, then you say:
>whose to say that there is not another quad somewhere

I think you have a point here, but I'd also ask:

Who's to say that one of your named graphs doesn't have another triple
somewhere?

Or, to put it another way, what do you do with:

ID => { < a, b, c >
         < a1, b1, c1 >
         < a2, b2, c2 > }

ID => { < a3, b3, c3 > }

?

#g
--

BTW, Chris, in my original response to you, I didn't advocate using
reification (though I did once argue its use as a way to abstractly
represent quads in "pure" RDF).



------------
Graham Klyne
For email:
http://www.ninebynine.org/#Contact
Received on Saturday, 20 December 2003 08:12:00 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:52:03 GMT