W3C home > Mailing lists > Public > w3c-rdfcore-wg@w3.org > May 2001

Re: A shot at http://www.w3.org/2000/03/rdf-tracking/Overview.html#rdfms-resource-semanti cs

From: Frank Manola <fmanola@mitre.org>
Date: Wed, 09 May 2001 14:45:06 -0400
Message-ID: <3AF99032.5023E5DF@mitre.org>
To: w3c-rdfcore-wg@w3.org
As I said in an earlier message, I think we need to clarify what
"entity" means in our discussions.  In particular, we need to
distinguish between the definition of "entity" in the HTTP spec (where
it is some payload that can be returned) and the definition in Brian's
model, where "Entities are things like web pages, numbers and trees in
the park".  (If the Web develops to the point where accessing what's
identified by a URI can return a tree, I hope I get adequate warning
before doing it!)   

I take Brian's model as being something like this (although Brian is the
ultimate source of wisdom for *his* model):

There are things like numbers (conceptual things), trees in the park,
and people (physical things), that we think about or perceive
[complicated philosophical interlude omitted].  Call these things
"entities".  We want to talk about some of these things (that seem to be
distinct, or "have identity") on the Web.  Call those things
"resources".  We give the resources URIs in order to identify them .  

The mapping between a resource (identified by a URI) and the entity it
denotes is, at least to start, in the mind of the denoter (whoever
decided the entity needed to be a resource, and assigned a URI to it). 
Since there can be multiple denoters and assigners of URIs, multiple
resources can be mapped to the same entity (each denoter is
independently thinking of the same entity as a resource).  (NB1:  it
helps NOT to think about entities/resources that are HTML files within
filespaces controlled by the URI assigner;  this is an important special
case, but it IS a special case;  think of entities/resources that are
trees or people instead.  NB2:  At this point, it's well to also point
out that I'm assuming a 1-1 correspondence between URIs and resources,
and what varies between denoters is the way entities are associated with

How many resources get "created" for a given piece of physical reality
or situation depends on how the denoter wants to look at things.  For
example, we're reminded that accessing a resource like a Web page can
return different content at different times, even though the "resource"
remains the same.  That's a particular view that says that what the
resource denotes is the concept of the page as a container of varying
content.  There are lots of examples of this idea, e.g.,  "my car" can
be considered the same resource, even though various parts have been
replaced at various times.  We certainly want to support views like
that.  On the other hand, the denoter might want to actually define
separate resources to represent the different states or representations
of what, at another level, could be considered a single resource (if
they have distinct identity for that denoter's purposes).  For example,
I might have multiple replicas of a database or server distributed
around a network to improve performance.  At one level (e.g., that of an
end user), there's one resource (and one URI).  At another level (e.g.,
that of the administrator), there are (also) multiple resources and URIs
that identify the specific replicas.  We want to support that kind of
situation as well.  

Finally, even though you can imagine two resources being mapped to the
same entity, if different people are doing the mappings, it isn't
necessarily going to be easy to decide when two resources are really


jos.deroo.jd@belgium.agfa.com wrote:
> > >  Two resources r1 and r2 can be mapped by D to the same entity.  In that
> case
> > >  we say they are equivalent.
> >
> > I think this is a mistake -- there are many pages which return the same
> > entity (the same set of text) but we cannot assume from this that they have
> > equivalent resources. To do so would be a grave mistake.
> > The entity returned may vary over time while the resource stays the same.
> > Just because at one point in time they return the same entity does not mean
> > that they always will.
> maybe not if we talk about set-of-entities
> which could go like:
>   there is a set of resources called R
>   there is a set of uris called U
>   there is a function f:U->R
>     for all u element of U there exists a r element of R such that f(u) = r
>     (or we could represent a resource r as a skolem function of it's uri u)
>     so u1 = u2 => f(u1) = f(u2)
>     so u1 = u2 => r1 = r2
>   there is a set of set-of-entities called S
>     (s element of S is meant to represent the possible states of a resource)
>   there is a function g:R->S
>     for all r element of R there exists a s element of S such that g(r) = s
>     for all u element of U there exists a s element of S such that g(f(u)) = s
>     so u1 = u2 => s1 = s2
> --
> Jos De Roo, AGFA http://www.agfa.com/w3c/jdroo/

Frank Manola                   The MITRE Corporation
202 Burlington Road, MS A345   Bedford, MA 01730-1420
mailto:fmanola@mitre.org       voice: 781-271-8147   FAX: 781-271-8752
Received on Wednesday, 9 May 2001 14:46:15 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 20:24:00 UTC