W3C home > Mailing lists > Public > www-rdf-logic@w3.org > December 2003

disambiguation of properties: explicitly or by assumptions?

From: David Martin <martin@ai.sri.com>
Date: Wed, 31 Dec 2003 17:20:03 -0800
Message-ID: <3FF375C3.2080006@ai.sri.com>
To: www-rdf-logic@w3.org

We (the OWL-S Services Coalition) would like to have (and solicit) some 
discussion here regarding the general issue of how much must be made 
explicit in an OWL ontology.  Here's a bit of background, and then 2 
particular questions to hopefully focus the discussion.  Please note 
that this is a very *general* issue that (seems to me) will come up over 
and over again on the Semantic Web (not just in declaring services), 
which is why I'm posting this here.  I include a tiny little bit about 
OWL-S, but only so as to ground the discussion in an example.

In OWL-S we have an ontology of processes.  The details aren't important 
here, except to say that an "atomic process" has inputs, very much like 
a procedure in a programming language.  So, we have a class 
AtomicProcess with property hasInput, which ranges over class Input.  We 
declare the inputs of a process in a perfectly straightforward manner; e.g.

<AtomicProcess rdf:ID="OrderBook">
   <hasInput><Input rdf:ID="BookName">.....</Input></hasInput>
   <hasInput><Input rdf:ID="CreditCardInfo">.....</Input></hasInput>
   ....

(What's in the 2 Input instances isn't important here, except that I'm 
assuming there's nothing in them that logically establishes they are 
distinct entities.)

A concern has come up that, with only declarations like the above, an 
OWL reasoner can't be sure if these are all of the inputs of OrderBook, 
or if these 2 inputs are distinct, or how many inputs OrderBook has. 
And of course that's clearly true; the above declaration is ambiguous on 
all of these points.

It's also true that we could add in additional declarations that remove 
the ambiguity.  For example, we could add a cardinality restriction that 
says "OrderBook has exactly 2 Inputs", and we could add a differentFrom 
statement that says "BookName and CreditCardInfo are 2 different things".

OK, some of us feel that we should add these additional declarations, so 
as to avoid any possible confusion or malfunction in an OWL reasoner 
that might be processing one of our knowledge bases.  Others of us 
(myself included) feel that it's extremely unfortunate, on practical 
grounds, to have to add in these "disambiguation declarations".  To my 
mind, some of the reasons for this view are:

     () For one thing, there's the issue of economy of representation: 
the number of differentFrom statements could get to be quite large. 
(For N inputs, (N choose 2) = (N * (N - 1)) / 2 differentFrom statements 
are required.)
     () While there are more economical ways of getting the same 
disambiguation, they still tend to be cumbersome, inelegant 
complications that obscure (from humans) what's most important about the 
knowledgebase.
     () No matter how you disambiguate, the presence of the 
disambiguation declarations makes it harder and more complicated to make 
changes to the knowledgebase.
     () No matter how you disambiguate, these declarations also make it 
harder and more complicated (or even impossible) to build on and extend 
the knowledgebase in a modular fashion.

(OK, I should probably substantiate some of the above points better, but 
this message is already too long.)

For those of us who are opposed to adding in the "disambiguation 
declarations", it seems we could avoid doing so by stipulating a set of 
assumptions, such as the "Unique Names Assumption" (UNA) that makes them 
unnecessary.  Of course, the UNA by itself isn't enough.  In the example 
above, UNA tells us there are at least 2 inputs, but it doesn't tell us 
that's *all* there are.  Here it appears some form of cardinality 
restriction is still needed.

There appear to be 2 issues on which we need to get clear:

(1) The technical question: is there some other assumption that could be 
called upon to eliminate the need for a cardinality restriction, **whose 
definition is clear enough and widely recognized enough to be useful, or 
might become so** (and thus is likely to be supported by reasoners)? 
Like perhaps some form of the closed-world assumption?  (We have some 
as-yet-inconclusive ideas about this, but I omit them here in the 
interest of brevity.)

(2) The "social" question: is it reasonable and workable for a group of 
ontology users (users of OWL-S in this case) to stipulate that all 
knowledge bases using a given ontology may be assumed to rely on 
assumptions such as UNA and whatever the answer to (1) is?

Comments appreciated.

Thanks,
David Martin

Disclaimer: this summary represents my perspective and reflects my 
desire to avoid specifying (what I'm calling) "disambiguation 
declarations" in OWL-S knowledge bases.  Other members of the OWL-S 
Coalition may have a different perspective.
Received on Wednesday, 31 December 2003 20:20:19 GMT

This archive was generated by hypermail 2.2.0+W3C-0.50 : Monday, 7 December 2009 10:52:48 GMT