W3C home > Mailing lists > Public > www-webont-wg@w3.org > February 2002

UPDATE: why RDF syntax is not suitable for OWL

From: Peter F. Patel-Schneider <pfps@research.bell-labs.com>
Date: Wed, 13 Feb 2002 18:56:36 -0500
To: www-webont-wg@w3.org
Message-Id: <20020213185636C.pfps@research.bell-labs.com>
Here are my current thoughts on why OWL should not use the same syntax as
RDF, no matter what we do with the semantics.

Peter F. Patel-Schneider
Bell Labs Research

		Why Triples are Terrible for Syntax

Summary:  RDF containers, RDF reification, and DAML+OIL syntax all show
	  that triples are terrible for syntax.

Triples, at least RDF triples, are terrible for representing syntax.
These triples have all the wrong properties for representing syntax.
1/ They only allow three pieces of information to be collected into an
   atomic entity.
2/ There is no grouping of triples possible.
3/ There is no way to close off access to a triple.
4/ All triples are independent.

An RDF triple consists of three pieces, generally thought of as the
subject, predicate, and object of the triple.  Triples are collected into
documents, with no internal structure besides the enclosed collection of

To create larger syntactic units, a group of triples has to be used.  

This is done in RDF containers, where a collection of triples is used to
create a sequence or bag.  In essence, one RDF resource is used to
represent the sequence or bag, and it is related to its elements by
triples, each of which has the collection resource as its subject, one of a
sequence of special resources as its predicate, and a collection member as
its object.

RDF containers have caused lots of problems.  Because the special predicate
resources identify the ``position'' of the element in the collection it is
possible to have collections that are missing their ``first'' element.
Because there is no way of preventing the addition of more of these
triples, it is impossible to state that all the elements of the collection
have been given.  

For example, one document can have

	x:foo rdf:type rdf:Bag .
	x:foo rdf:_2 y:John .
	x:foo rdf:_3 y:Susan.

which is missing its ``first element''. Another document can augment x:foo,
as in 

	x:foo rdf:_1 y:Mary .

to result in a completed bag.  Yet another document can augment x:foo
further, as in

	x:foo rdf:_4 y:Joseph .
	x:foo rdf:_3 y:Andrew .

There is no way of determining the elements of this bag, as they can always
be augmented.

RDF reification also uses a collection of triples, four in this case.
A reified statement is represented by a resource.  This resource has
four triples; one giving rdf:Statement as the rdf:type of the resource, and
three more identifying the subject, predicate, and object of the resource.

Again, RDF reification has caused lots of problems.  Because the four
triples are independent, it is possible to have a reification without a
subject, predicate, or object.  To prevent multiple subject, predicates, or
objects, there is a special condition on reified statements that they can
have only one subject, predicate, or object triple.  This breaks the
general RDF model, and is only possible for concepts that are
defined in RDF itself, not for additions to RDF.

For example, 

	x:s1 rdf:type rdf:Statement .

is illegal in RDF, as it does not have the required three properties.

	x:s2 rdf:type rdf:Statement .
	x:s2 rdf:subject y:subject .
	x:s2 rdf:object y:object .
	x:s2 rdf:predicate y:predicate1 .
	x:s2 rdf:predicate y:predicate2 .

is illegal, but, again, only because there is special wording in the RDF
M&S that makes it so.

DAML+OIL uses its own lists in its syntax.  These lists are members of a
special class, List.  A list is either the empty list or has a first
element and a remainder.  

DAML+OIL lists have several problems.  It is possible to create a list
without a first element or a remainder.  It is possible to create lists
with several first elements or several remainders.

For example,

  x:foo daml:intersectionOf x:list .
  x:list daml:first x:Person .
  x:list daml:first x:Rock .
  x:lsit daml:rest daml:nil .

has a list with two first elements.

Some DAML+OIL syntax constructs work like RDF reification.  The construct
is represented by a resource that is a member of a special class.  There
are several triples, each of which have that resource as subject, that
together embody the construct.  

Again, this sort of construction has problems because of the properties of
triples.   First, some of the triples can be missing, so, for example, it
is possible to create a hasClass restriction without a property.  Second,
there can be multiple triples, so, for example, it is possible to create a
hasClass restriction with two properties or two classes.

For example, 

   x:foo rdf:type daml:Restriction .
   x:foo daml:onProperty x:age .
   x:foo daml:hasClass x:c1 .
   x:foo daml:onProperty x:shoesize .

is a possible restriction, which has an unusual meaning.

None of the above problems are really solvable using RDF triples.  A much
better syntax carrier would allow syntax to be represented as tuples or,
even better, as trees.
Received on Wednesday, 13 February 2002 18:57:34 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 23:04:27 UTC