Speech Acts, indexicals, REST & RDF

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. 
  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/