W3C home > Mailing lists > Public > public-semweb-lifesci@w3.org > March 2009

Re: blog: semantic dissonance in uniprot

From: Bijan Parsia <bparsia@cs.manchester.ac.uk>
Date: Wed, 25 Mar 2009 17:49:43 +0000
Cc: Mark Wilkinson <markw@illuminae.com>, Phillip Lord <phillip.lord@newcastle.ac.uk>, W3C HCLSIG hcls <public-semweb-lifesci@w3.org>
Message-Id: <0E611C17-39DC-4509-8002-3E684C345C45@cs.manchester.ac.uk>
To: Oliver Ruebenacker <curoli@gmail.com>
On 25 Mar 2009, at 17:03, Oliver Ruebenacker wrote:

>     Hello Mark, All,
>
> On Wed, Mar 25, 2009 at 12:25 PM, Mark Wilkinson  
> <markw@illuminae.com> wrote:
>> I agree - the issue also came up at the BioHackathon last week...  
>> basically,
>> as Tom Oinn phrased it, "if you're thinking of using owl:sameAs...  
>> don't!"

I love Tom! I've been saying this for years ;)

My bugaboo, of course, is the use of sameAs to equate arbitrary terms  
(including classes and properties). Using sameAs for *mapping* is  
definitely the wrong thing, esp. when

>  Is that a suggestion to abolish owl:sameAs?

I'm not sure what that means. owl:sameAs is never going away from OWL.

However, it's a tool with very specific aspects. It's a *strong* tool  
and often says more than what many people want to say.

>> Another predicate is needed that is less "rigourous" -  
>> owl:kindOfLike  :-)
>
>  What do we gain from non-rigorous statements?

"rigorous" is not the right term. "Less strong" is the point

For example, in programming languages, there is usually a notion of  
*identity* (i.e., pointer identity) and *various* (sometimes  
parameterizable) notions of *equality*. Identity is generally  
stronger. E.g., the *very* same object in memory (so same type, same  
physical location, etc.).

So (in pseudocode),
	x := 1.0 %a float
	y := 1.0 %a *different* float...i.e. allocated to a different address
	z := 1 % an integer

%suppose we have "is" as pointer identity, "=" as type safe equality,
%and "==" as coercing equality. Then

	x is x % This is true
	x is y % This is false because their pointers are different

	x = x
	x = y % These are both true because x and y are numerically equal  
floats.
	x = z % This is false because z is not a float and thus is not a  
numerically equal float

	x == x
	x == y
	x == z
	y == z %	These are all true since we can coerce them into numerically  
equal integers

sameAs is like pointer identity. It's very strong, and often what you  
don't need. In OWL, at the moment, that's all you have! (Well, you  
have things, like seeAlso, but they have *no* standard meaning.)

Every now and again, I whine about the over and mis use of sameAs and  
suggest that we come up with a set of more useful terms (with standard  
meanings, if only operational).

I think that giving the right tools would really really help!

Cheers,
Bijan.
Received on Wednesday, 25 March 2009 17:50:19 UTC

This archive was generated by hypermail 2.4.0 : Friday, 17 January 2020 17:20:41 UTC