Re: sameAs, similarTo, isLike

On 10-07-09 11:08, Dan Brickley wrote:
> +cc: Libby, FOAF co-editor
>
> On Thu, Jul 8, 2010 at 7:48 PM, Young,Jeff (OR) <jyoung@oclc.org> wrote:
>   
>> Here three ideas to relieve the pressure on owl:sameAs:
>>
>> 1) Promote the use of umbel:isLike
>> 2) Suggest to FOAF that they add an informal "sameAs" property to their ontology:
>> 3) Create our own "mashup" ontology with an informally defined mashup:sameAs property.
>>     
> So I think the sticking point here is the lack of a simple, intuitive
> name and definition. If I understand the core requirement, it's that
> it will sometimes be used between similar or easily-confused
> individuals, and sometimes with just one individual. If the LLD
> incubator comes up with a proposal that takes the pressure off of
> owl:sameAs, I think there's a reasonable case to add it into FOAF as a
> supporting general-purpose utility term. Naming is really hard though.
> Any suggestions?
>   

I'm not at all convinced this is a good idea. The meaning of
owl:sameAs is unambiguous even if it might be used improperly
sometimes.

For the problem at hand, identifying representations of a
resource, I think the best way is to make a "representation"
predicate somewhere:

	x a owl:Thing ;
		x hasRepresentation r1 ;
		x hasRepresentation r2 .
	r1 a foaf:Person ;
		r1 representationOf x .
	r2 a skos:Concept ;
		r2 representationOf x .

This is unambiguous and would solve the problem that the
OCLC folks have brought up (at the cost of more complicated
graph traversal queries, but that problem remains with any
isLike or similarTo that we might use or invent).

The trouble with "informal" similarity of statements is that
they quickly become meaningless without context. Almost
always you want to say "relevantly similar" and even if it
were straightforward to pick apart what "relevantly" means
it is impossible without context.

For example, a hammer and a wrench are similar in that they
are both tools. They are not relevantly similar if I am trying
to repair my bicycle.

A generic "similarTo" predicate might work if we had
ternary instead of binary relations, e.g.

	x sim:similarTo y for z

Or else you can express this as something like,

	s a sim:Similarity ;
		sim:one x ;
		sim:other y ;
		sim:context z .

Getting a machine to sensibly interpret similarity without
context (given that one of the ideas of RDF is to be machine
useable) is impossible. Getting a machine to interpret
similarity with context is one of the harder problems in AI.
Figuring out how humans do similarity is one of the hardest
problems in cognitive science.

I fear that generic ill-defined predicates such as umbel:isLike
or a FOAF alternative wouldn't help much.

Cheers,
-w

-- 
William Waites           <william.waites@okfn.org>
Mob: +44 789 798 9965    Open Knowledge Foundation
Fax: +44 131 464 4948                Edinburgh, UK

RDF Indexing, Clustering and Inferencing in Python
		http://ordf.org/

Received on Friday, 9 July 2010 15:50:00 UTC