abstract model

Earlier discussion has suggested that we need a 
clarification of the RDF abstract model and a more
precisely defined notation for representing it
in discussion and specification.

Bearing in mind Dan's comments that the spec is 
done, we are trying to tie up a few esoteric lose
ends, I've been trying to write down an abstract
model that is entirely consistent with M&S but
resolves some of the outstanding issues.  I think
I've got something that works - for me at least.
Needs polishing 

What follows is a minor clarification of the abstract
model and the start of the definition of a more precise
definition of a triple notation in the style of the
original m&s.

The abstract model is described in terms of the 
mathematical concepts of set and 3-tuple
or triple and is entirely consistent with the
original m&s

What follows:

  o bridges the dispute about anon resources.
    It states that all resources have at least
    one URI, and uses DanB's notion that an
    an anonymous resource represents, in effect,
    an existentially qualified variable.

  o remains true to the original distinction
    between a statement and its reification, but
    provides a notation that allows a statement
    to be conveniently treated as a Resource.

  o adds the concept of a Model to the abtract
    model, enabling us to discuss whether a 
    statement is in a model or not - something
    that it will be useful when discussing
    what model a representation represents.

RDF Abstract Model
==================

1.  There is a set called Resources.
2.  There is a set called Literals, which is disjoint
    from Resources.
3.  There is a subset of Resources called Properties.
4.  There is a set called Statements which consists of
    all 3-tuples from:

  Resources X Properties X (Resources union Literals)

5.  There is a set called Models.  A member of Models
    is a set of Statements.

6.  There is a mapping called Reification which a maps
    each member s of Statements onto a unique member r
    of Resources.  r is known as the reficiation of s.
    Here unique means given s1 and s2 members of
    Statements, Reification(s1) = Reification(s2) iff
    s1 = s2. 

7.  There is a mapping, called URI between the set of
    Resources and the set of strings defined in RFC ....
    to be URI's.  Each member of Resources is mapped to
    at least one URI.

NOTE:  In the abstract model, A statement consistes of
       a triple where the first member of the triple
       is a member of Resources.  It is not a member of
       the set of strings - it is not a URI.  Similarly
       the 2nd member is a member of Properties, not a
       member of strings, and the 3rd member is a string
       only if it is a member of Literals.

       A reified statement is just the resource.  The
       existence of a reference to a reified statement
       in a model does not imply any other properties
       e.g. rdf:type, rdf:subject etc, are also included.
       When a syntax represents a reified statement, it
       is the definition of the semantics of the syntax,
       i.e. the transform from the syntax to the abstract
       model, which defines what properties are actually
       represented.

       All resources have URI's.  Anon resources are 
       dealt with in the notation.


Informal Description of a Triple Notation for RDF
=================================================

The aim is that this notation can be used to clearly,
concisely and precisely, represent instances of the 
RDF abstract model in discussion and in specifications.

What follows is a bit long and tedious, but its quite
simple really.

  o Resources are represented by something in square
    brackets.  The something can be a URI, and anon
    generator or a statement.

  o Literals are enclosed in double quotes

  o Statements are 3-tuples in standard math notation

  o Models are sets of statements represented in
    standard math notation.

A member of Resources can be represented in one of three
ways.  It can be a URI enclosed in square brackets, e.g.

  [http://foo/bar]

in which case it represents the member r of Resources,
such that URI(r) = the string enclosed by the square
brackets.

It can be represented by the word 'anon' followed by
a colon and a name, all enclosed in square brackets
e.g.

  [anon:foo]
and
  [anon:bar]

in which case it represents some member of the set of
Resources.  Within some scope, [anon:name] will represent
the same resource wherever it is used.  [anon:name1] and
[anon:name2] may represent the same or different resources.
The scope should be clear from the context.

<logicians-only>
  I'm thinking that DanB is right, that anon resources
  are best thought of as representing variables.  They
  to be existentially qualified variables and
  [anon:name] is a Skolem constant representing
  a particular variable.
</logicians-only>

A property can be represented by a URI
enclosed in square brackets.  For convenience,
a URI may be represented in XML namespace
syntax, e.g.

    [rdf:type]

A literal is represented by a string of characters
enclosed in double quote symbols.  A double quote
symbol within the string of characters, is represented
by two double quotes, e.g.

   "a string with a "" double quote in it"

A member of Statements is represented by a 3-tuple in
standard mathematical notation using round brackets
with the components separated by commas.  The first
component is a representation of a resource, the second
of a property and the third of a resource or a literal,
e.g.

   ([http://foo/bar], [http://bar/foo], "foobar")
and
   ([anon:foobar], [http://bar/foo], [anon(barfoo)])

Note this is in a different order to M&S - but it is 
the order most commonly used in the list.

A name can be assigned to represent a resource, a literal
a statement or a model e.g.

  r = [http://foo/r]

The name can be substituted anywhere the designated entity
could appear.


Models will be represented using the common mathematical
notation of a list of members, separated by commas and
enclosed in curly brackets, e.g.

  { ([http://foo/bar], [http://bar/foo], "foobar"),
    ([anon:foobar],   [http://bar/foo],  [anon:barfoo])
  }

The final representation of a resource consists of 
a representation of a statement enclosed in square
brackets, e.g.

   [ ([http://foo/bar], [http://bar/foo], "foobar") ]

which represents the resource which is the reification
of the statment enclosed in the outer square brackets.
For this representation of a model, the existence of 
a reference to a reified resource in a model does not
imply any extra properties are also included in the
model.  If it is intended to represent a model containing
the rdf:type, rdf:subject etc statements for the reified
statement, then they must be explicitly represented, e.g.

      s = [ ([http://foo], [http://bar], "foobar") ]
      {  (s, [rdf:type],       [rdf:Statement]),
         (s, [rdf:subject],    [http://foo]),
         (s, [rdf:predicate],  [http://bar]),
         (s, [rdf:object],     "foobar")
      }


Brian McBride
HPLabs

Received on Tuesday, 12 September 2000 04:43:55 UTC