W3C home > Mailing lists > Public > www-rdf-logic@w3.org > May 2003

Re: What's the difference? rdf:about, owl:sameIndividualAs

From: Jimmy Cerra <jimbobbs@hotmail.com>
Date: Mon, 26 May 2003 02:01:43 -0400
To: <www-rdf-logic@w3.org>
Message-ID: <000301c3234c$48503ad0$1a6afea9@picard>


I'm a little confused by the revisions, so please excuse any
misunderstandings of my part.

> [Tom] >
> rdf:about is a syntactical device to identify the subject of a triple
> a serialized RDF graph.  owl:sameIndividualAs is a predicate, used as
> of a triple to assert a statement.

I agree in principle.

> > [Jim] >
> > <owl:Thing rdf:about="uri#foo" />
> [Tom] >
> Right, it has the effect of
> an empty statement about uri#foo.

No it is definitely _not_ an empty statement about uri#foo.  According
to the spec [1]:

> [Dave Beckett] >
> It is common for RDF Graphs to have rdf:type arcs from subject nodes.
> These are conventionally called Typed Nodes in the graph, or Typed
> Elements in the RDF/XML. RDF/XML allows this triple to be expressed
> concisely. by replacing the rdf:Description node element name with the
> namespaced-element corresponding to the RDF URI Reference of the value
> the type relationship.

Thus, the example XML uses the official shorthand for typed nodes - the
statement corresponds to the following serialization:

<rdf:Description rdf:about="uri#foo">
  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing" />

Furthermore, as a consequence of the shorthand notation (for the
official serialization) the following is _also_ a complete statement
about a blank node:

<owl:Thing />

That corresponds to the following:

  <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Thing" />


> > [Jim] >
> > However, I could also
> > say that a blank node that is identical to the resource identified
> > "uri#foo" is an individual:
> >
> > <owl:Thing>
> > <owl:sameIndividualAs rdf:resource="uri#foo" />
> > </owl:Thing>
> >
> [Tom] >
> You just asserted that owlThing, a predefined class, is the same
> individual as uri#foo. From that, if I do not know anything else about
> uri#foo, I could infer that the node uri#foo is the same node as the
> representing &owl;#Thing (or whatever the right URI is)

No, I definitely did not assert that owl:Thing is the same as uri#foo!
I stated two triples in that xml fragment (assume "_blankNode"
represents the blank node for the following):

1) _blankNode rdf:type owl:Thing
2) _blankNode owl:sameIndividualAs uri#foo

Thus it was stated that (in English):

1) The blank node is a (rdf) type of (owl) Thing.
2) The blank node is the (owl) same individual as (uri) foo.

Thus, anything that we state about the blank node must also be true
about (uri) foo.

> > [Jim] >
> > then the resource identified by
> > "uri#foo" must have the same properties - mainly that it is an
> > individual.
> >
> [Tom] >
> No, just a Resource.

From the spec [2]:

> [Smith]:
> Every individual in the OWL world is a member of the class owl:Thing.

Since uri#foo has rdf:type of owl:Thing, then it _must_ be an

> [Tom] >
> At any rate, using sameIndividualAs on a  node, blank or not, either
> identifies it as the same node as another, or there is a
> It still has nothing to do with rdf:about.

I disagree.  Here's how I see the RDF universe:

I view each node in a graph as being an abstract entity with _no_
relation to the outside world (ie, nodes exist only in the RDF
universe).  A node can have an alias represented as an uri.  Nodes
without an alias are called blank nodes.

OWL's sameIndividualAs property is used to state that a particular node
(that is an individual, not a class or property) in one graph or part of
a graph is actually the same as another node in another graph (when the
two graphs are merged) or part of the same graph.

Thus, in the RDF universe one node can effectively have two aliases.
One specified by the uri assigned to it (by the rdf:about attribute, for
instance) and another one assigned by the sameIndividualAs property.
Since blank nodes have no uri initially assigned to it, then the owl
predicate can be used to assign an alias to it.

Thus, even though rdf:about and owl:sameIndividualAs different purposes,
they do the same thing: assign an alias to a node.  Since they do the
same thing, I don't understand why each is necessary.

> [Tom] >
> There are many ways to identify resources by inference.  That does not
> mean that all statements that feed those inference are equivalent.
> Anyway, rdf:about  is not a resource or property, so they are not
> equivalent.
> ...
> So there is no way the two are the "same thing" or equivalent.  One is
> construction device, one is a part of a graph.

If it does the same thing, then what does it matter?

> [Tom] >
>  Besides that, the sense in which rdf:about "identifies" a
> resource is very different - it indicates in the serialization which
> to construct or to attach an arc to.  The predicates represent, of
> the arcs themselves.

I am starting to think that all nodes in RDF are blank and that the uri
that identifies one is simple a property of that node.

Jimmy Cerra

] "I had to learn very early not to limit
]  myself due to others limited imagination."
]  - Dr. Mae C. Jemison


[1] http://www.w3.org/TR/rdf-syntax-grammar/#section-Syntax-typed-nodes

[2] http://www.w3.org/TR/owl-guide/#DefiningSimpleClasses
Received on Monday, 26 May 2003 02:01:50 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:52:46 GMT