Re: Ed's / Ian's View

On Tue, 2011-04-05 at 17:46 +0100, Nathan wrote:
> Hi All,
> 
> I think Ed and Ian's view can be summarized as follows:
> 
> At the abstract level, you make statements about typed resources rather 
> than just resources, so rather than saying:
> 
>    dc:creator(x, "alice");
>    foo:mass(x,2140);
> 
> You're actually saying:
> 
>    dc:creator(U₁(x), "alice");
>    foo:mass(U₂(x), 2140);
>    and.. disjoint(U₁(x), U₂(x));
> 
> Where U₁ and U₂ are different universes, on the web, and not on the web.
> 
> Over the years this has been surfaced in many ways, different examples 
> include:
> 
>    <x> :accessibleVia "x"              == U₁(x) U₂(x)
>    *<x>  foaf:isPrimaryTopicOf <x>     == U₂(x) U₁(x)
>    _:x foaf:isPrimaryTopicOf <x>       == U₂(x) U₁(x)
>    tdb:x foaf:isPrimaryTopicOf <x>     == U₂(x) U₁(x)
> 
> and the inference one (Ed's William Shakespeare example, and as outlined 
> above), which is to have the properties specify whether <x> in the 
> surface syntax is referring to U₁(x) or U₂(x).
> 
> The William Shakespeare example / universe inference approach was 
> falling apart when it came to properties like dc:creator on resources 
> like wikipedia pages about Books, which to IanD's credit he pointed out, 
> and to which Ed responded by effectively saying "well we need a separate 
> ontology for talking about things in U₁".
> 
> Other cases mentioned (by IanD and others) take the approach of saying 
> things like "I'll only use x to refer to things in U₂, not U₁", which 
> was later expanded on with the Content-Location suggestion to 
> effectively say "I'll only use x to refer to things in U₂, not U₁, and 
> if I need to refer to things in U₁ I'll provide some other name for that 
> thing" ... but I think it still had the same sentiment of using the 
> properties to suggest whether the thing being discussed was in U₁ or U₂, 
> for example by saying <x> a :Person, or <x> a :Document but not both.

Nice summary.  All of these approaches fall apart upon examination.

> 
> To me this outlines that:
> 
> - there's a kind of distinction being made by people that there are two 
> classes of resources, the documents/irs/things on the web, and the 
> everything elses. (there are two unvierses)

Right, but this dichotomy is a mirage.  It is neither necessary nor
sufficient, and the basic reason comes back to the fundamental ambiguity
in the identity of any resource.  The IR/non-IR distinction is merely
one example of what occurs whenever one makes a finer distinction about
the identity of a resource r, distinguishing the X-aspect of r from the
non-X-aspect of r.  It doesn't matter what the X-aspect is -- the
principle is the same.  I tried to explain this in a rough draft here:
http://dbooth.org/2007/splitting/
Some day I should get around to finishing that document, but hopefully
the ideas will be clear enough.

> 
> - that one approach is to use properties to say which universe the x you 
> are talking about belongs in ( use x to refer to both U₁(x) and U₂(x) )

That's Ed's approach, right?  Okay for some limited cases, but won't
work as a general solution.

> 
> - that another approach is to only use x to refer to either U₁(x) or U₂(x)

But it does not solve the problem -- it only postpones it.  The exact
same problem still shows up in other ways, because the root of the
problem is the fundamental ambiguity of resource identity, and the fact
that what is unambiguous to one application may be ambiguous to another
application that requires finer distinctions.

> 
> - that another approach is to use some surface syntax (quotes or *) or 
> other form of uri (tdb:) to refer to either U₁(x) U₂(x).

Syntax cannot solve the problem either, because it is a *semantic*
problem.

> 
> And that currently our solutions are:
> 
> - to use absolute iris for things in U₁, and frags for things in U₂
> - to use x to refer to things in U₁ and y to refer to things in U₂, 
> where 303(x,y)

Right, but as I mentioned above, this does not solve the problem either.
It merely postpones it.

> 
> It's interesting to me though, that it almost every solution (other than 
> the infer from properties one) has a build in notion that when you have 
> U₁(x) and U₂(x), then U₁(x) provides information about U₂(x), and U₁(x) 
> != U₂(x). Seems to be a running thread there.. even though I know 
> strictly speaking that you can say use frag iris to refer to a web 
> page.. but I don't see anybody actually doing that.. so maybe people are 
> happy with disjoint classes of names, one for things on the web and one 
> for things that aren't?

You have almost touched on a key element: that there is an implicit
assumption that necessarily U1(x) != U2(x).  But this is a fallacy.
*Some* applications need to distinguish U1(x) from U2(x), but others
don't.  I.e., applications that have no need to distinguish U1(x) from
U2(x) will produce correct output even when U1(x) is assumed to be
owl:sameAs U2(x), just as applications that only need to distinguish
chocolate from vanilla may not care if different varieties of vanilla
are conflated.



-- 
David Booth, Ph.D.
http://dbooth.org/

Opinions expressed herein are those of the author and do not necessarily
reflect those of his employer.

Received on Tuesday, 5 April 2011 20:35:54 UTC