W3C home > Mailing lists > Public > public-owl-dev@w3.org > January to March 2007

Re: IFP and datatype properties

From: Ulrike Sattler <sattler@cs.man.ac.uk>
Date: Fri, 9 Mar 2007 15:03:07 +0000
Message-Id: <8634E21E-702B-48B8-9D2D-2C632771F20C@cs.man.ac.uk>
Cc: public-owl-dev@w3.org
To: Alex Tucker <alex@floop.org.uk>

On 8 Mar 2007, at 16:53, Alex Tucker wrote:

> Alan,
>> What i have done, for non-compound keys, is create a uri with the
>> value embedded as a string, use and object property and make that
>> inverse functional.
> We've been following a similar pattern, essentially preferring
> ObjectProperties over DatatypeProperties for the most part.  However,
> Ian's assertion that the "tractability of reasoning ... depends on the
> fact that they are typically *not* used in this way," worries me a
> little, if, as users, we've all been expecting IFPs to cope.

let me explain this dependency a little: IFPs (whether they are  
present explicitly or via the work-around described by Alan) should  
be harmless

- in case where you have individual names (even many of them), say  
a1, a2, ...., a1000000,... and all of the are related via the  
datatype property "hasID" to  some integer, and you have declared  
hasID as inverse functional: now, in case that there are 2  
individuals, say a17 and a23, that have the same hasID-filler, then  
a17 and a23 will be identified.

and they can be  dangerous (wrt current technology and to the best of  
my knowledge and only unless somebody comes up with some clever  
optimisations) if

- we have "many" existential restrictions, e.g., when (describing  
infinite lists) we say that every listelement has a next-successor  
who is a listelement,  and that next is inverse-functional, and that  
every listelement has an id-successor who is a non-negative integer  
smaller than 1,000,000...now if we would also say that id is inverse- 
functional, then this would mean that we could have 1,000,000  
listelements, but not 1,000,001, and thus we would either have to  
generate all 1,000,001 listelements, then guess which of them are the  
same to try to satisfy all our constraints, then fail -- or we would  
need to work with such "global cardinality" constraints (atmost  
1,000,000 listelements) directly - and our current reasoning  
techniques can't do the latter and will fail trying to do the former.

- now, if you consider the previous example, we could make it more  
complicated by saying that "odd" listelements have "even"  
listelements as next-successors, and that "even" listelements have  
odd listelements as successors, ... and then later say something  
about the id-successors of odd things, e.g., that they are below  
1,000,000: now it is even more tricky to see how many listelements we  
can have!

Cheers, Uli

> Alex.
Received on Friday, 9 March 2007 15:06:16 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 20:58:14 UTC