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

Re: What do the ontologists want

From: Seth Russell <seth@robustai.net>
Date: Fri, 18 May 2001 11:38:56 -0700
Message-ID: <00d201c0dfc9$cd2d6a20$b17ba8c0@c1457248a.sttls1.wa.home.com>
To: "Ziv Hellman" <ziv@unicorn.com>, "pat hayes" <phayes@ai.uwf.edu>
Cc: <www-rdf-logic@w3.org>
RE: What do the ontologists wantZiv,

I think that if you start composing your representations at the node level
rather than the arc level,what you percieve to be clumsiness will disappear
and you will see that triples gives you more flexiablility than fixed
position ntuples.

Let's suppose I compose a CycL kind of predicate like this {f,  Afrom,  Bto,
Csomething} and define the meaning of each position in the tuple, and
accumulate a bunch of instances of the tuples in my graph, and  then
subsequently find that I was missing a ~Dwiggy~ part of the concept.  With
the CycL technique I must redraw all of my predicates according to the new
knowledge ... not so with a node based slot system as proposed in [1].  With
such a slot based system I can very easily write into the inference engine
the idea that we may or may not have complete information about the concept.
The class\model nodes of instances tells us what we should anticipate and\or
seek out.  I call that more flexiable and more attuned to the way real world
models evolve.

[1] http://robustai.net/mentography/conceptualDependency.gif


---in response to---
From: Ziv Hellman
To: pat hayes
Cc: www-rdf-logic@w3.org
Sent: Friday, May 18, 2001 10:58 AM
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 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

Received on Friday, 18 May 2001 14:42:59 UTC

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