W3C home > Mailing lists > Public > public-awwsw@w3.org > May 2010

Re: sketch of an exposition

From: Pat Hayes <phayes@ihmc.us>
Date: Thu, 20 May 2010 01:15:42 -0500
Cc: AWWSW TF <public-awwsw@w3.org>
Message-Id: <0F27241C-B2D8-46F7-9FD7-F72538DB0C0B@ihmc.us>
To: Jonathan Rees <jar@creativecommons.org>

On May 17, 2010, at 4:40 PM, Jonathan Rees wrote:

> Apologies up front:
>  - sorry it's rough and unformatted.  I'm trying out expository ideas
> and terminology & wanted to get this out to you all for critique
>  - topic not covered: metadata subjects (DC, FRBR, etc.); redirections
>  - tell me which statements you disagree with! we thrive on
> statements that are interesting enough that one can argue over them.
>  - idle question: does every IR have a REST-representation?
>
> -Jonathan
>
> -------------------
>
> Axiomatic method = don't take anything for granted - if some result
> can't be proved from axioms already stated, do not assume that it is
> true.
>
> Assume a universe of discourse, which I'll call Thing.
>
> In formal treatments one needs a way to refer to (or name or
> designate) things.  For this purpose we may use URIs, although other
> notations may be useful too.

So, immediate question: are these names also in the UoD? Are URIs  
Things? I suspect the answer has to be Yes, but that makes things more  
complicated and less 'standard' already, because standard FOL keeps  
names and things strictly segregated. (For a very good reason, to  
avoid paradoxes.)  Suggest that you USE names in the axioms which are  
distinct from the URIs, which should be treated as objects in the UoD.  
(In fact, you do this already, with things like 'T' and 'U'.)

>
> Reference is not objective; when a URI refers to a Thing it's
> because someone has chosen to have it do so.

Really? How is that choice manifested functionally? What if two people  
make different choices for the same URI? Lots of hard questions here.

Seems to me that 'personal' choice is a red herring. What matters for  
any actual use of referential names is that some *community* of people  
has somehow conspired to use a name referentially among themselves.

>
> Reference does not imply any special knowledge of a Thing.

True, though it might presuppose SOME knowledge.

>  I can
> talk about a thing without knowing eactly which thing I'm talking
> about

Thats a different point.
(1) I can refer to X without knowing all about X
(2) I can refer to X without knowing if I'm referring to X

1 is much more plausible than 2.

> - for example, I might be communicating partial knowledge
> (properties) that I received from someone else.

Yes, but if we are communicating and I understand a name in the  
message to refer to X but you intended to refer to Y, usually we have  
a genuine MIScommunication. That is different from me misunderstanding  
something you say about X, while still knowing that it is X you are  
referring to.

>  Reference is not
> "identification".

True, but thats a different point. God alone knows what  
'identification' is supposed to mean.

>
> We'll suppose that (in any given conversation or context) a URI refers
> to at most one Thing.

Havnt you changed the rules by saying 'refer to' simpliciteur here?  
Surely according to the above, its the person doing the referring, not  
the URI. (OR maybe that particular use of the URI, by the person with  
the intent, is what refers...)

> An agent may take a URI to refer to no Thing at
> all, or refer to a Thing by multiple URIs, or not take any URI to
> refer to some Thing.

I don't follow this. What is the third option, exactly?

>
> If a URI U refers to some thing T then <U> is another name for T.

I think you mean, if U refers to T then WE can use '<U>' as a name for  
T, in our axiomatic meta-theory. Right? You need to keep two sense of  
'name' distinct. There are the names we are talking ABOUT - the URIs -  
and the names we are USING. They aren't the same idea.

BIG ISSUE. You have not yet said what you mean by 'refer' here. This  
'refer' is not the referential use of names in the axioms!  That is  
the relationship between our meta-names, things like "R" and "T" and  
"W", and the things in the UoD that they denote. This is a  
relationship between URIs (which are things, I presume) and other  
things, ie its a relationship between things in the UoD, so it needs  
to be axiomatized just like any other relationship.

>
> Some Things will be what we call 'REST-representations'.
>
>   For now think of them as being similar to HTTP 'entities' - they
>   consist of content and a few headers such as media type.
>   But we'll figure out the details later.
>
>   We don't assume that these REST-representations are 'on the wire'
>   or associated with particular events or messages.
>   We reserve the right to refer to them using URIs, but generally
>   this will be unnecessary.

Well, WE will certainly need to refer to them, but WE (ie, we writing  
the axioms) can use our names freely to suit our axiomatic purposes.  
You use "R" just below to refer to a REST-representation, for example.  
(No URIs visible anywhere here.)

>
> Posit a relationship, which I'll call 'W', between some Things and
> some 'REST-representations' e.g. W(T,R).
>
>   The intent is for W to capture what gets written variously
>     R is "an entity corresponding to" T (RFC 2616 10.2.1)
>     T "corresponds to" R (RFC 2616 10.3.1)
>     R is a representation of the state of T (Fielding and Taylor)
>     R "encodes information about state" of T (AWWW glossary)
>     R "is a representation of" T (AWWW 2.4)
>
>   We permit the same REST-representation to be W-related to multiple
>   Things, i.e. W(T,R) and W(T',R) is consistent with T != T'.
>
>   We permit one Thing to be W-related to more than one
>   REST-representation, i.e. W(T,R) and W(T,R') is consistent with
>   R != R'.
>
>   If you don't accept web architecture as expressed in RFC 2616 in
>   its rudiments, you should stop reading here.
>
> Let us stipulate that a GET/200 HTTP exchange expresses a
> W-relationship between a Thing and a REST-representation.  That is:
>  1. If a URI U refers to a Thing <U>, and
>  2. an HTTP request GET U results in a 200 response carrying
>     REST-representation R, then
>  3. we will interpret the exchange as communicating W(<U>, R).

Well, OK, but I still want to know what the first condition means.  
Right now, this is essentially vacuous since 'refers to' could mean  
anything.

>
>   WHETHER WE CHOOSE TO BELIEVE W(<U>, R) IS ANOTHER STORY.
>   (Consider a buggy or malicious proxy.  HTTPbis starts to address
>   believability by trying to specify a notion of 'authority'.)
>   ISSUES OF TRUST AND AUTHORITY WILL BE TREATED SEPARATELY (if we get
>   around to it).

Good.

>
>   We might fudge this by speaking of "credible" HTTP exchanges without
>   saying exactly what that means (as indeed one cannot say).
>
> The implication goes in only one direction: a credible GET U/200 R
> exchange implies W(<U>, R), but the absence of such an exchange does
> not imply that W(<U>, R) is not the case.
>
> In fact there may be other ways to communicate or infer W(<U>, R) -
> by consulting a cache, for example.
>
> A consequence (or precondition) of this stipulation is that for each
> URI U for which there is a GET/200 exchange, there exists a Thing <U>
> that U refers to.  Roughly speaking, all web URIs refer to
> *something*.

That isn't a consequence of the rule given above, and I don't see why  
its a precondition. If U doesnt refer to anything, then the first IF  
condition of the rule is false, so the rule is trivially satisfied.

However, it is plausible, so why not stipulate it? You are writing the  
axioms, after all :-)

>
>   This is the way in which the web is "grandfathered" into the
>   semantic web.
>
>   Although it's not falsifiable, this seems to be the idea that IH
>   denies (there are no resources).
>
> This is a powerful constraint.  Since servers are "authoritative",
> they can produce whatever 200 responses they like for a URI that they
> control, and not violate protocol.  That is, for an *arbitrary* set of
> REST-representations concoctable by a server, we've committed to
> allowing the existence of a Thing that has those REST-representations.

We aren't committed yet, but maybe we should be. But why does this  
apply to any *set* of REST-reps?  Nothing in the rule given refers to  
such sets. Seems to me you have a lot more axioms to write before this  
can be proven.

>
> Note on what is NOT provable at this point
>
>   We haven't created a way to falsify any W-statement.  That is,
>   there is no way to infer the W(T,R) does not hold.  Therefore this
>   theory is satisfiable by having a single Thing T, that all URIs
>   refer to, having the property that W(T,R) for all
>   REST-representations R.
>
> Note on time
>
>   Although W is time-sensitive, we'll ignore time as it is not
>   helpful to account for it right now.  later we'll redo the
>   treatment to take time into account.
>
>   So W is OK as a binary relation for now.  Later it might be
>   W(X,R,t).

Or it can still be binary, but X can be timesliced:  W(s(X, t), R). I  
would recommend this as a stronger (more expressive) way to deal with  
time.

>
> Note on RDF
>
>   RDF is just a vector for FOL, and FOL is a lot easier to read and
>   think about, so better to start with FOL and then render it in RDF
>   (and perhaps other notations) later on.

Hmm. RDF is way weaker (less expressive) than FOL. But whatever, I  
suspect it doesnt really matter. We are using at least negation and  
implication in the axioms already, and implicitly using universal  
quantifiers. So we are using FOL.

>
> No number of GET/200 exchanges can tell you what a resource is.
> There are several reasons for this.
>  1. The absence of a GET/200 giving W(T,R) does not mean that W(T,R)
>     isn't true.
>  2. Two Things T,T' could have W(T,R) but not W(T',R) for some
>     REST-representation R not hitherto obtained by a GET/200 exchange.
>  3. T and T' could agree on the truth or falsehood of *every*
>     W-statement and *still* be different

What does this mean? A Thing has an opinion about truth of statements??

>
> Information distinguishing such Things, if it were available, would
> have to come through a different channel (e.g. RDF).
>
> httpRange-14
> ------------
>
> Let IR be a proper subclass of Thing containing the domain of W,
> i.e. suppose W(T,R) implies that T is in IR.
>
> Properties of IR:
>   Grandfathering: "web resources" (those for which we get 200s) are  
> in IR
>     - this is a consequence of the above stipulation.

Only if their URIs (the ones that deliver the 200's) refer to  
something. They might not.

Perhaps you mean, those referred to by a URI from which we get a 200.  
In which case, OK, yes.

>   TimBL: "generic resources" are in IR (genont)
>   TimBL: literary works are in IR  (Pat Hayes disagrees)
>
>   TimBL: dogs and people are disjoint with IR
>     (by extension: anything physical)
>   TimBL: strings and numbers are disjoint with IR
>     (by extension: anything mathematical)
>   TimBL: REST-representation is disjoint with IR
>     (JAR doesn't see the point)
>   Pat: RDF graphs are not in IR

Follows from Tim's no-math criterion above. RDF graphs are  
(normatively defined to be) sets.

>
>   TimBL: members of IR are not determined by their W-relations
>     i.e. one might have W(T,R) = W(T',R) for all REST-representations
>     R, yet T != T'   [time sheet example]

Sad, if true.

Pat

>
> We have three theories of IR in the works now: Dan's speaks-for
> theory, Alan's what-is-on-the-web theory, and JAR's property-transfer
> theory.
>
>

------------------------------------------------------------
IHMC                                     (850)434 8903 or (650)494 3973
40 South Alcaniz St.           (850)202 4416   office
Pensacola                            (850)202 4440   fax
FL 32502                              (850)291 0667   mobile
phayesAT-SIGNihmc.us       http://www.ihmc.us/users/phayes
Received on Thursday, 20 May 2010 06:16:44 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 20:21:08 UTC