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

RE: What do the ontologists want

From: Ziv Hellman <ziv@unicorn.com>
Date: Fri, 18 May 2001 19:58:46 +0200
Message-ID: <6194CD944604E94EB76F9A1A6D0EDD230E5561@calvin.unicorn.co.il>
To: "pat hayes" <phayes@ai.uwf.edu>
Cc: <www-rdf-logic@w3.org>
> >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.

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 road.

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 horror. 



Received on Friday, 18 May 2001 12:59:43 UTC

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