# 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