W3C home > Mailing lists > Public > www-archive@w3.org > March 2004

Re: Named graphs etc

From: Pat Hayes <phayes@ihmc.us>
Date: Fri, 12 Mar 2004 10:59:08 -0600
Message-Id: <p06001f0fbc778fcc03ef@[10.0.100.76]>
To: Patrick Stickler <patrick.stickler@nokia.com>
Cc: "ext Chris Bizer" <chris@bizer.de>, <www-archive@w3.org>, "ext Jeremy Carroll" <jjc@hplb.hpl.hp.com>

>On Mar 11, 2004, at 19:39, ext Pat Hayes wrote:
>
>>
>>>On Mar 10, 2004, at 15:09, ext Chris Bizer wrote:
>>
>><snip>
>>
>>>
>>>>>
>>>>>Hmmm....  couldn't one view the insertion of graph qualification
>>>>>statements specifying assertion and authentication as being
>>>>>equivalent to a "speech act", the graph being the utterance?
>>>>>
>>>>
>>>>Also hmmm ... and I think we should forward this question to Pat.
>>
>>See earlier message on 'web acts'. It does seem odd to me to say 
>>that a graph can perform an act such as asserting. Suppose a graph 
>>slanders me: can I sue the graph for damages? We have to get 
>>genuine agents into the picture somehow.
>
>No, no, no, Pat.
>
>The graph is not being positied as a sentient entity.
>
>Rather, the owner/creator/publisher of the graph uses special
>vocabulary within statements in the graph to assert/sign the
>graph -- in a way that such qualificatations can be authenticated
>to a resonable degree.

I fail to see how the use of vocabulary IN a graph can POSSIBLY 
constitute a signature or warrant. Anyone can write anything into a 
graph.  I know your idea is that some kind of correlation between the 
'owner' of the graph and a reference in the graph to that owner is 
what does the trick: and I agree.

Jeremy suggests we allow

ex:graphname rdfx:assertedBy ex:thing .

I want us to essentially punt on what sort of thing exactly ex:thing 
is (its a 'web agent') and on exactly how to tell if a triple like 
this is being published by the person it says it is being published 
by. I think this is going to be a nasty thing to get sorted out and 
might take a long time and we should let others do it.

We could of course offer the pragmatic advice that if ex:thing is a 
graph or a web resource, then the agent is understood to be the owner 
of that resource. But this is a work-around, seems to me, rather than 
a principled way to handle this issue.  (Can't you just hear the 
debates this will produce? People are still arguing about using 
homepage URIs to identify people.)

I would like us to punt on that aspect of the whole matter, and just 
assume that there is some externally-provided way to determine if the 
agent doing the publishing is the one referred to in the graph, which 
is all that really matters. Having ex:thing be the URI of the graph 
or document is one way, but there might be others.

>By "self-asserting", I simply meant that the bits needed to
>determine if a graph is asserted are in the graph.

But they aren't: you have to know the URI of the graph as well as the 
graph itself, in any case.

>I.e. "self documenting programming languages" do not mean
>the code itself or the programming language is doing the
>documenting, rather that the documentation is expressed
>in some fashion native to the programming language and its
>intended intepretation.
>
>>
>>>>
>>>>1. If "assertion = speech act", the assertion *has* to take place in a
>>>>"context" for example a point in time.
>>>>Thus it is tempting to conclude that a graph is asserted, if it (1)
>>>>describes itself
>>>
>>>I accept this.
>>>
>>>>or (2) is described somewhere else with the properties
>>>>dc:author and dc:date.
>>>
>>>I don't accept this.
>>>
>>>This latter case is similar to one person saying what someone else
>>>said -- i.e. hearsay. All that the first person could assert is
>>>that the "speech act" occured and what its content was, but
>>>can't assert the content of that speech act.
>>
>>No, it can. That is, it can assert ANY content. A says: "Im just 
>>wanting to consider this as hypothetical: consider ...." Now, B can 
>>agree with A (that ... is hypothetical) or, B can say "I think that 
>>.... is true." No problem, B hasn't said that A said that .... is 
>>true.
>
>OK, I think I see where our disconnect is.
>
>Yes, any graph can be taken to be asserted for a particular purpose,
>and one agent can recommend to another agent that the graph should
>be presumed to be asserted for a given application, etc. but that
>is all about third-party assertion.
>
>I am, and have been, talking about authoritative assertion. How do
>we know if the owner/creator/publisher/original source of the graph
>has asserted the graph, or whether they are just a bunch of statements?
>
>Insofar as this latter question is concerned, I don't see one
>graph specifying the assertiveness of another graph as practical.

Well, I disagree. It is practical because if first-party references 
can be made safe, then so can third-part ones; and it seems to me to 
be extremely useful as a tool for providing warrants and so on.

>>>
>>>Restraining the boostrapping machinery to each graph prevents
>>>folks from speaking on behalf of others.
>>
>>You don't speak on behalf of others by using their words to make an 
>>assertion that they havn't made. If you SAY that they have made an 
>>assertion that they havn't in fact made, or if you pretend to be 
>>them, then you are lying: and we need to be able to check up on 
>>liars and detect the lies quickly and reliably.
>
>How? If the publisher of a graph says nothing about whether the graph
>is asserted or not, how can anyone disagree with me if I say it is?

People can say whatever they like. Why should anyone believe them, is 
the question. Ultimately, the only firm authority for a claim that A 
asserted something is an actual assertion by A. If we can check an 
assertion by A to the effect that A asserts a first-person graph, 
then we can just as easily, using the same mechanism, check an 
assertion by A that A asserts a third-person graph. Asserting doesn't 
have to have an implicit 'this graph' in it in order to be checkable.

>Having to rely on other (potentially infinite number of) other graphs
>to determine the assertiveness of one particular graph seems to
>introduce an horrifically inefficient and burdensome bootstrapping
>mechanism.

Nobody is proposing that. The only way to check whether any graph is 
asserted is to confirm who said it. You, the reader who is trying to 
figure out who is asserting what,  have to be able to trace a triple 
of the form "A asserts..." back to a graph authored by A (whatever 
exactly "authored" means). I think we agree on this, by the way. The 
only thing that we disagree on it whether or not those three dots 
have to refer to the graph that contains that triple, and I see no 
good reason for that restriction. It doesn't provide a graph-ish way 
to check true assertion unless you can check graph authorship, in any 
case.

>Restricting the machinery to each specific graph alone, either by
>some fancy semantics or by pushing it out to the syntactic layer
>(i.e. XML attribute values, etc.) seems the only reasonable approach
>to me.
>
>The moment you have to start chasing chains of bootstrapping statements
>in graph after graph to get a final determination regarding one
>particular graph, is the moment you loose more folks now unsure about
>deploying RDF.
>
>KISS please!

I agree about KISS, but inserting self-referential constructions 
which break (put severe strain on) the semantics and have to be 
handled by an OWL-incompatible new layer of processing doesn't seem 
KISSish to me.  And in any case, if you introduce the rdfx:assertedBy 
property, how are you going to stop people from using it in 
third-party ways? The RDF specs essentially say that they can if they 
want to.

>>>>2. Publishing an unasserted graph on the Web wouldn't be a speech act.
>>>
>>>It wouldn't necessarily be.
>>>
>>>If no explicit statement is made within the graph that the graph
>>>is asserted, then it is not (necessarily) a speech act.
>>>
>>>I.e. it is the act of using particular machinery to explicitly
>>>indicate that a graph is asserted that constitutes the speech
>>>act.
>>>
>>>If it were explicitly stated in the graph that the graph was
>>>*not* asserted, then it would simply be a document (quoted
>>>statements).
>>>
>>>Some agent may, for whatever reason, still wish to treat those
>>>statements as asserted, but that is then contrary to the explicitly
>>>expressed intended purpose of those statements by the publisher
>>>of the graph (e.g. taking it out of context, etc.).
>>>
>>>Similar to my saying: "The following is false: 'sugar always tastes
>>>bitter'" and you treating that as if I has actually asserted
>>>that "sugar always tastes bitter".
>>
>>I bet what will happen is this (whatever we say about it :-) . 
>>There will be a way to explicitly non-assert, like quoting; and 
>>there will be a way to be absolutely and iron-clad clear about 
>>asserting and who is doing the asserting, checkable by secure 
>>signatures.  And then there will be cheap-and-cheerful publication 
>>which is not marked in any way in particular but is widely accepted 
>>for many useful purposes as being asserted as a kind of happy 
>>default that enables smart search engines, etc., to get their stuff 
>>done when no serious $$ depends on the result. What we need to do 
>>is to suggest how to do the former without being so tight-assed 
>>that we try to legislate the latter out of existence, because that 
>>would be like ordering the tide to stop rising. I think that a way 
>>forward is to leave the status quo to do the cheap-and-cheerful, 
>>but adding a way to be more secure in the former style when 
>>required. To do that I think we need a way to provide an 
>>external-to-RDF way to ultimately warrant the checkable assertion 
>>forms, since that way of proceeding will almost certainly require 
>>tort-law applicable ways of tracing the legal agents who are making 
>>the iron-clad assertions (promises, contracts, etc.). And once we 
>>have that, there is no harm in allowing 'external' assertion of 
>>content, and quite a lot of utility in allowing it.
>
>
>Um. Er. That is *precisely* what I have been proposing...

Well, OK, good. But if there is an external-to-RDF way of doing the 
warranting of assertion, then I don't see the need for a syntactic 
criterion like self-reference in a graph to signal the assertion. You 
still need to check the warrant: anyone can forge a self-reference; 
so the graphical 'sign' of assertion isn't any use anyway.

>If no explicit statements are made about assertion, for legacy reasons
>or out of sheer laziness, presume it is asserted (but keep at arms length,
>per se, insofar as liability/accountability is concerned).
>
>If there is an explicit statement that the graph is asserted, it's asserted.

Well, we have to say, if it is *entailed* that it is asserted, then 
its asserted.  But that's OK, and might be useful ("I hereby assert 
all the ontologies in this class of ontologies:...." )

The only place we differ is that you want this to be restricted to 
assertions of a graph within that graph. I see no good reason for 
this restriction, and if we abandon it then (1) we don't need to 
torture the semantics (2) a number of (seems to me) useful techniques 
are enabled, such as securely asserting content currently expressed 
in vanilla RDF, and allowing secure assertion behind firewalls to 
refer to content in the public domain (3) nothing in the named-graph 
model breaks.

>If there is an explicit statement that the graph is not asserted, 
>it's not asserted.

Again, say entails; but yes.

>
>Seems like that is a pretty cheap-and-cheerful approach, yet one that
>provides the key bits for authentication/trust/accountabililty for
>those who care...

Right. (We agree?? What happened????)

>
>>
>>>
>>>--
>>>
>>>In essence, a graph explicitly marked as unasserted is a quoting
>>>mechanism.
>>
>>Right. We could maybe do that, as Mark suggests, just by using the 
>>XML media type (though that seems a bit kludgey to me.)
>
>Yuck. And what about all the other serializations/expressions of RDF 
>graphs? So we'd
>end up with double the number of MIME types... no thanks.

I agree. Just thought Id mention it to see if it flew.

>>>A graph with no explicit marking for assertion is simply an
>>>ambiguous "utterance" which may or may not reflect the asserted
>>>beliefs of the source.
>>
>>but which is good enough for many purposes, right? Particularly if 
>>99% of the RDF on the planet is deployed this way with the general 
>>understanding that it is intended to be read and used.
>
>Right. See above. Again, I'm talking about what is needed as a foundation
>for authentication/trust/accountability, not whether any arbitrary set
>of statements might or might not be useful for some application.
>
>>
>>>
>>>A graph with explicit marking for assertion equates to an
>>>utterance within a context of "I assert/swear/affirm/believe/...
>>>that ...", which can serve as the basis for accountability
>>>(and of course, trust).
>>
>>Right, but only if the thing doing the swearing and affirming is 
>>something a bit more solid than a graph. It has to be the kind of 
>>thing that a court can put a restraining order on, or you or I can 
>>sue.
>
>It *is*. That thing doing the assertion is the entity associated with a
>signature or identified by a URI as the explicit authority, etc. I.e., if
>I am asserting a graph, that signature and URI will ascribe those statements
>to me.

Is that really true? That signatures can identify legal agents? I'd 
like to get an opinion on that from someone in law enforcement before 
committing to it. But my proposal is that we punt on this issue.

Pat

>Patrick
>
>--
>
>Patrick Stickler
>Nokia, Finland
>patrick.stickler@nokia.com


-- 
---------------------------------------------------------------------
IHMC	(850)434 8903 or (650)494 3973   home
40 South Alcaniz St.	(850)202 4416   office
Pensacola			(850)202 4440   fax
FL 32501			(850)291 0667    cell
phayes@ihmc.us       http://www.ihmc.us/users/phayes
Received on Friday, 12 March 2004 11:59:13 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 22:32:25 UTC