Re: properties as nodes etc.

On June 30, Seth Russell writes:
> > Let's call R the n-ary relation, RC the class which reifies R, and
> > ri the i-th property of RC in correspondence with the i-th
> > argument of R.  The following would be the additional constraint
> > that RDF is unable to state, but that is necessary to properly
> > encode the n-ary relation:
> >
> > \forall x1...xn . R(x1,...,xn) <-->
> >     \exists-unique z . RC(z) \and r1(z,x1) \and ... \and rn(z,xn)
> 
> I believe that is already implied by the Model Theory.  Every RDF
> triple of the form (<SUBJECT1> <PROPERTY1> <OBJECT1>) is a unique
> instance of <PROPERTY1> ....that's what RDF already does for us.

First of all, n-ary relations (or, if you like, n-ary properties) are
not even expressible in RDF, only binary properties are expressible.
For binary properties, it is probably true (I haven't checked the MT
for this) that:

\forall x1 x2 . R-as-property(x1,x2) <-->
    \exists-unique z . R-as-class(z) \and Domain(z,x1) \and Range(z,x2)

The problem we are discussing here is how to properly encode n-ary
properties using only binary ones.

> > On June 30, Seth Russell writes:
> > > if you want to expliticidly designate that each event is unique,
> > > then give it a uri, instead of leaving the node anonymous.
> > > Otherwise just continue to add restrictions until only one such
> > > event can qualify.  I guess I don't see the problem.
> >
> > In this way you impose by hand the above uniqueness constraint, by
> > explicitly writing the URI for the unique event. But does this URI
> > really exist? Most of the time it is just a fictitious object of
> > which you want just to state the existence. This would correspond
> > to FORCE any user of a database to have an EXPLICIT key for each
> > n-ary relationship: most of the time you don't have it -- it is
> > just the combination of the keys of the participating entities.
> 
> Well like I said there are two ways to do it.  The best way, imho,
> is to put sufficeint constraints on the Bnode such that only one
> event in the world will be satisfied.

I completely agree, and the additional constraint you need is the one
I've written. But how can you write such a constraint in RDF?

> But using URIs works in RDF systems too.  And there are URI schemes
> which can be automatically generated, so the URI string does not
> need to 'really exist'.

Well, it is not easy to generate a scheme which always grounds
CORRECTLY the above constraint, since you may not always know
explicitly the fillers of all the properties, but still have valid
inferences for the uniqueness of the node (e.g., coming from other
constraints, possibly expressed in DAML+OIL). Which URI do you enforce
in this case? You should resort to an existential variable, but then
you need again the additional constraint to enforce the uniqueness on
it (see my final example).

> My point is that your objection to RDF for n-array relationships is
> unfounded.  Could you please supply us with an actual real world
> test case if you really think RDF is deficient here?

Your example in:

> http://robustai.net/mentography/ConceptualDependency2.gif

is not a valid example of a n-ary relation, since you may actually
have different instances of John giving to Mary a candy (e.g., in
different times and locations).

The general scheme in:

> http://robustai.net/mentography/arity.gif

is also missing the point: the additional uniqueness constraint is not
enforced. The problem is: how to write this constraint in RDF?

If you ask me an example on the fly, I tell you the following:

teach(john,cs336,sem2,2001/2002)
teach(john,_z,sem2,2001/2002)

which becomes, reified:

teach(_x)
prof(_x,john)
course(_,cs336)
semester(_,sem2)
acad-year(_,2001/2002)

teach(_y)
prof(_y,john)
course(_y,_z)
semester(_y,sem2)
acad-year(_y,2001/2002)

How can you tell whether _x and _y denote distinct URIs?  You can't,
but you would make a mistake to leave things as they are above without
the additional constraint. In fact, if from the ontology you have the
information that professors in the 2nd semester teach at most one
course, then the lack of the additional constraint has the consequence
that the inference that _x and _y denote the same URI is lost.  Note
that there is no easy syntactic way to derive from a generic ontology
all the facts that may lead to the applicability of the uniqueness
constraint.

So my conclusion is: in order to capture correctly the encoding of
n-ary relations you need to enforce the additional uniqueness
constraint.

cheers
-- e.

Enrico Franconi                     - franconi@cs.man.ac.uk
University of Manchester            - http://www.cs.man.ac.uk/~franconi/
Department of Computer Science      - Phone: +44 (161) 275 6170
Manchester M13 9PL, UK              - Fax:   +44 (161) 275 6204

Received on Sunday, 30 June 2002 17:57:15 UTC