W3C home > Mailing lists > Public > public-ldp-wg@w3.org > October 2012

Re: Speech Acts, indexicals, REST & RDF

From: Roger Menday <roger.menday@uk.fujitsu.com>
Date: Wed, 17 Oct 2012 16:48:11 +0100
CC: public-ldp-wg Working Group <public-ldp-wg@w3.org>
Message-ID: <92763EE5-7759-4BA4-B3C7-42EE8562FE50@uk.fujitsu.com>
To: Henry Story <henry.story@bblfish.net>

> Yesterday during the LDP conf call, as we were discussing ISSUE-20 [0], I mentioned how looking at this with philosophical lenses could help locate the problem. Roger Menday asked me to clarify. 

Henry,

Thanks for your email. It is a big one - I need to re-read again this evening. 

Actually, It wasn't just clarification I was after .... because, I still don't think that the LDP interpretation of creation is that we are POSTing a Graph (which then gets grounded) - after all, a child isn't given whole to the mother. 

I prefer the function described in [5] as "providing a block of data, such as the result of submitting a form, to a data-handling process". Isn't form submission is a good model ? - and it would be good to read more discussion about the LDP equivalent of forms (?)

regards, 
Roger

> [5] http://tools.ietf.org/html/rfc2616#section-9.5

>  I am also sending this to the  public-rdf-comments working group, as the discussion on the ldp list has brought us to wonder on numerous occasions if the "RDF concepts and abstract syntax" should not contain and develop a notion of relative-uri-graphs "direct graphs" as done by the rdf-direct-mapping spec [8]. The following is an argument from the history of philosophy and of logic towards the importance of that. (We do have working use cases too of course)
> 
> So yesterday, I was pointing out an interesting parallel between the history of philosophy of language and some debates in the semantic web space. First we should remind ourselves of the development of mathematical logic in the 20th century. Starting with Frege [1] at the end of the 19th century, who revolutionised logic by mechanising it in pretty much the way we know it today. His work was taken up by Bertrand Russel's whose pre World War I Principia Mathematica embarked on the project to lay the logical foundations for mathematics. Wittgenstein his student be considered to have condensed this book into the short "Tractatus Logico Philosophicus" which was an inspiration for the philosophical movement known as the Vienna Circle, at which Carnap, Gödel, and other famous thinkers participated. Most of them then fled either to England or the US as the second world war broke out. Btw. for those who are interested, but don't have much time you can follow this in the comic strip "Logicomix" or if you have more time in the excellent book "The Information" by James Gleick. 
> 
> So all of logic up to that point seems to have been mostly concerned with the rules for how to move from one true sentence to another. In mathematics, sentences are usually necessarily true, and context does not appear. Btw. This functional point of view, led in programming to functional programming languages: these gain their power through precisely the same feature, namely the ability to substitute functions for their values, similarly to the way logic allows one to substitute co-referring expressions salva-veritate.
> 
> So this is pretty much the type of work that led in my opinion straight to RDF-semantics [3]. In this type of work, context is eliminated as far as is logically possible, in order to allow for simple merging of information. There are no indexicals in this system - words such as I, you, he, we, they, now, here, there, actually - since those would require context of the utterance, or of the writing, to be taken into account. For example if we have 2 sentences uttered in some contexts ( indicated by {..} ) 
> 
> A == { I am happy }
> B == { I am drinking coffee now }
> 
> then we cannot treat "I" as a name ( a URI if you will allow me that jump into webby language ), since the referent of the "I" in A could be different from the referent of the "I" in B. If one knew the context then one would be able to transform the above sentences into ones without the I. Eg if one added the following contextual information
> 
>  A was said by Joe on 29 July 2012 at 7:30 am
>  B was said by Joe on 29 July 2012 at 7:30 am
> 
> Then one could transform the initial sentences into
> 
> A == { Joe is happy on 29 July 2012 at 7:30 am }
> B == { Joe is drinking coffee on 29 July 2012 at 7:30 am }
> 
> from which we can deduce that Joe is happy and drinking coffee on the 29 July 2012 at 7:30 am.
> Once all context has been eliminated, merging becomes a mechanical process, salva veritate. 
> 
> Having said that one may wonder whether one is loosing something by moving to a completely decontextualised sentence. David Lewis in a few of his writing argues that we do loose something, since we could know all the facts about ourselves in the universe, and yet not know it was describing us. That is "I am Joe" is an important fact to know for Joe. It is what may get him to act on discovering for e.g. that "A bucket of cold water is about to be dropped on Joe".
> 
> The closest we have in the semantic web to indexicals are relative URIs. These allow documents to speak about themselves and other relatively located documents without them needing to know their Universal Resource identifier. Eg:
> 
>  R1 == { <> a foaf:PersonalProfileDocument;
>             foaf:primaryTopic <#me> .
>          <#me> foaf:name "Joe" . }
> 
>  R2 == { <> foaf:primaryTopic <#me> .
>          <#me> foaf:blog </blog> . }
> 
> Here again we need to know the context in order to express the same relations in a non context sensitive manner, so that we can then merge the information: for <> does not refer to the same thing independently of the context of where the document was found - which web server uttered it, to stretch the meaning of 'utter' in order to make the point.
> Just as to know what "I" means we need to know who uttered/wrote the sentence in which it appears, or in order to know what "you" means we need to know who uttered it, and what the context was ( who was the person speaking to), so in order to know what <> refers to we need to know the context of the utterance, which will provide the base URI which we need to transform the relative-URL-graph into a plain RDF-graph. In HTTP this is defined by standards such as RFC2616's definition of GET [4] or POST [5]. 
> 
>  What is clear when looking at these protocols, is that we are no longer just looking at how sentence are logically deduced from one another, but how one can do things with them. This is parallel to the breakthrough work by J.L.Austin 1951 work "How to do things with words" [6] where he showed how context influences how a sentence works. For example a priest saying of a couple, during the right ceremony, "I pronounce you man and wife" is not stating a fact that was true, but is making it so. Similarly when the chair says "the session has ended" he is not stating a truth but making it true by saying it. Or if I make a promise to do something, I am not stating a truth about the future, but making a commitment to do something to make that sentence true. 
> 
> It is important I think to see that it took close to 60 years from the beginning of logic to Austin's work, which was later extended by John Searle ( teaching at Berkeley ), and many others I think under the label of pragmatics. It should therefore not be surprising either that the same type of clash should have appeared in the semantic web space and gone unnoticed by many respected members of the community since pragmatics and semantics research can pretty much evolve orthogonally. And it is not surprising either that these issues should pop up in the Linked Data Profile Working Group, since this is looking at the pragmatics of what could be called document acts. I am not the first to notice this relationship btw. Dan Connolly wrote up something for the TAG "A Model of Authority in the Web" [9] where he made the connection.
> 
> So let us look a bit more closely again at the definition for POST [5] 
> 
> [[
>   The POST method is used to request that the origin server accept the
>   entity enclosed in the request as a new subordinate of the resource
>   identified by the Request-URI in the Request-Line. 
> ]]
> 
> [[
>   If a resource has been created on the origin server, the response
>   SHOULD be 201 (Created) and contain an entity which describes the
>   status of the request and refers to the new resource, and a Location
>   header (see  section 14.30).
> ]]
> 
>  Here the action of POSTing a graph is the action that creates a resource which
> will be the one against which relative URLs will be decontextualised. And this
> is what ISSUE-20 is about [0]. 
> 
>  If we wish to talk about such an action without recourse to syntax - ie in a semantic
> manner - it would be useful to be able to have a notion of a relative-url-graph - 
> formalised by the rdf-direct-mapping spec as a "direct graph" [8], which would be a set
> of triples, containing possibly relative URLs, which could be absolutized at a later 
> point. This seems to be missing in the RDF1.1  concepts and abstract syntax which
> I think is confusing to implementers of RDF specs, who are confronted with serialisations 
> such as Turtle that have relative URLs and yet the abstract syntax which does not.
> 
> So here of course the argument for the importance of indexicals takes on a new 
> importance. 
> 
> Just as the I can say "I like philosophy" without knowing what my
> name is, so the creator of a document may want to express all kinds of relations 
> about himself without knowing what the absolute URLs of his foaf 
> file is going to be as he puts the relations together. In order to create 
> the initial graph the agent-in-a-context who is building the graph does 
> not need to know the name of the context, since he is in the context, and 
> so he can take advantage of indexical grammars to rapidly constitute the 
> relations needed. Indeed there is much less risk that an agent-in-a-context
> make a mistake using indexicals since those refer necessarily to the speaker
> in the context, making it close to impossible for a mistake to appear.
> 
> It is only by POSTing that the server to which the collection  creates
> the final base URL. And even that server need not know it's name, which
> would not be a problem since the POSTer knew it, and hence will be able
> to transform the relative URLs into absolute ones.
> 
> So I am sorry for this rather long description of the problem, but I think
> understanding the context of the problem, will help move the debate to the 
> level at which it needs to take place, as it would also be all to easy to
> get lost in spec wording details, where the problem is in fact a logical/
> pragmatic one.
> 
> 	Henry
> 
> 
> [0] http://www.w3.org/2012/ldp/track/issues/20
> [1] http://en.wikipedia.org/wiki/Frege
> [2] http://www.logicomix.com/en/
> [3] http://www.w3.org/TR/rdf-mt/
> [4] http://tools.ietf.org/html/rfc2616#section-9.3
> [5] http://tools.ietf.org/html/rfc2616#section-9.5
> [6] http://en.wikipedia.org/wiki/J._L._Austin#How_to_Do_Things_With_Words
> [7] http://www.w3.org/TR/rdf11-concepts/
> [8] http://www.w3.org/TR/rdb-direct-mapping/#emp-addr
> [9] http://www.w3.org/2001/tag/dj9/story.html
> 
> Social Web Architect
> http://bblfish.net/
> 


Received on Wednesday, 17 October 2012 15:49:05 UTC

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