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

RE: What do the ontologists want

From: Danny Ayers <danny@panlanka.net>
Date: Sat, 19 May 2001 00:20:45 +0600
To: "Ziv Hellman" <ziv@unicorn.com>, "pat hayes" <phayes@ai.uwf.edu>
Cc: <www-rdf-logic@w3.org>
RE: What do the ontologists wantI guess one benefit from using triples is
you're dealing with a common base line - something like a normal or
canonical form. It's pretty straightforward to say how to deal with triples,
at least on a syntax level, going n-ary makes it a bit trickier, I'd have
thought. Any relation can be reduced to 3-ary, but going from x-ary to y-ary
might not be so straightforward! As RDF is intended to be machine readable,
I would think using triples would be the best bet.
For n-ary we can always use tags :

Danny Ayers

  -----Original Message-----
  From: www-rdf-logic-request@w3.org [mailto:www-rdf-logic-request@w3.org]On
Behalf Of Ziv Hellman
  Sent: 18 May 2001 23:59
  To: pat hayes
  Cc: www-rdf-logic@w3.org
  Subject: RE: What do the ontologists want

  > >I have no objection to binary predicates; I could
  > >even live with all predicates being binary if it would allow me to
  > >speak for lots of ontologists. :)
  > The restriction to binary (plus unary, ie at-most-binary) predicates
  > is mildly inconvenient but quite live-with-able, I agree. That's two
  > ontologists on the list.
  > Pat

  At the risk of being on the receiving end of a hailstorm of flames from
the regulars on this list, I will toss a spanner into the works here and
question the use of triples.

  As correctly pointed out above, using triples is essentially reducing
everything to binary predicates. Now it is certainly provably true that
every multi-ary relation can indeed be reduced to a collection of binary
predicates, and this has been known for a very long time. The RDF spec even
notes this and provides examples for doing so. The question is whether too
high a price is paid in certain cases.

  On the one hand, essentially reducing the world to binary predicates is
what the OO and XML communities have done for a long time, with the
attributes assigned to objects really being binary predicates. This
viewpoint can be understood as stemming from looking at most relations as
functional, in the sense that, as the canonical RDF example puts it, if one
asks "who is the creator of this resource?" and the answer is "Ora Lassila",
then one is working with a binary predicate associating a specific resource
with a specific person. So far so good.

  On the other hand, standard mathematics and logic, KIF, the relational
data-base world, and even full-power UML, all permit the use of multi-ary
relations and do not limit themselves to binary predicates. Why?

  I think the reason has to do with the fact that although it appears at
first that one is gaining simplicity by using only binary predicates, or
encoded triples, in practice when one is forced to exchange a
straightforward n-ary predicate with a clumsy collection of binaries, the
simplicity one has seemingly gained is more than lost in the translation. If
we really are going to create a world-wide web of semantic meanings for a
plethora of daily needs, this issue may need to be addressed again down the

  Take as simple an example as requesting a bank balance. This requires a
relation that is at least 3-ary: at minimum one needs the account number and
the date&time. The balance cannot be assigned as a simple attribute of the
account, because its value changes with time, and it certainly is not an
"attribute" of the date&time alone. For another, more complicated example
that is a canonical one I use, consider a travel agent asked by a customer
the flight seating he/she has been assigned. The travel agent will respond
that in order to answer the question, one needs to know at minimum the
quadruple of {name of the customer, the date of the flight, the airline
carrier, the flight number} -- because the seating of a particular person on
a particular flight is not an attribute of any one element in that list, but
an attribute of the full quadruple.

  Again, I know that these examples can be reduced to encoded triples -- but
is the resulting clumsiness worth it compared to the straightforward
multi-ary statement? And perhaps more to the point, consider that in order
to really take off, the SW will eventually have to come into contact with
the data the world has stored in relational data-bases, which routinely make
use of reams of tables representing very large multi-ary relations. If the
industrial world is told that uploading/downloading this data through the SW
will require painfully chopping up the tables into an explosion of triples,
waiting for the transmission traffic to complete and then reconstituting
from them the tables at the other end, one may fear that it will recoil in


Received on Friday, 18 May 2001 14:25:47 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 22:45:37 UTC