# Re: blog: semantic dissonance in uniprot

```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