[Pellet-users] A lot of descendant queries

[Alan Ruttenberg]

Hi Brandon,

There are definitely inferred ones. In the GO cellular component  
ontology I counted 800 explicit restrictions and compute 20000  
inferred relationships. To see how this happens consider the following.

Every A is a B
Every B is part of some C
Every C is a D


 From this we can also infer:

Every A is part of some C (because every A is a B and every B is -  
both explicit)
Every A is part of some D (because each is part of some C and every C  
is a D - one inferred, one explicit)
Every B is part of some D (because each is part of some C and every C  
is a D - both explicit)

That's why the double recursion. You recurse once to go up the isas  
gathering all part-ofs and once through the part-ofs, gathering all  
is-as. Minding the fact that both is-a and part-of are transitive,  
something that isn't used in this example.

Note that 1 explicit part-of has yielded 3 inferred ones.

-Alan

(let's hope I got that all right. I'm sure someone will correct me if  
not :)

On May 3, 2007, at 2:56 PM, Ibach, Brandon L wrote:

> Alan,
> 	I think I just confused the issue by including the SPARQL query.
> Let me try again.  I admit that I probably don't understand the  
> possible
> complexity, here, but it seems like what you're trying to do is, as  
> you
> say, basically compute role inclusions, but over, as Bijan termed  
> them,
> conditionals, or relationships between classes.  Essentially, the
> restriction that you're looking for subclasses of is a relationship
> between classes that you want to project along the class hierarchy.
> Please correct me if I'm wrong about anything, so far.
> 	If this is the case, my next question is whether this relation
> could ever exist without being explicitly stated in the ontology in  
> the
> form of a restriction.  To the best of my knowledge, without having
> thought too hard about it, this isn't even possible.  If that's true,
> then you should be able to find every instance of this relationship by
> iterating the restrictions in the ontology and asking Pellet for
> subclasses of those that are someValuesFrom restrictions on  
> partOf.  It
> seems to me that this might involve significantly fewer calls to
> getSubClasses, which should address both the memory consumption and
> execution time issues.
> 	If my reasoning about this is wrong in any way, I apologize and
> welcome any criticisms as a learning experience.
>
> -Brandon :)
>
>
> -----Original Message-----
> From: Alan Ruttenberg [mailto:alanruttenberg at gmail.com]
> Sent: Thursday, May 03, 2007 1:21 PM
> To: Ibach, Brandon L
> Cc: Evren Sirin; pellet-users at lists.owldl.com
> Subject: Re: [Pellet-users] A lot of descendant queries
>
> This would be equivalent to the calls I made *if* the sparql engine
> implemented TBOX queries, which I understand not to be the case in
> the current version.
> -Alan
>
> On May 3, 2007, at 1:15 PM, Ibach, Brandon L wrote:
>
>> 	My tendency is to always find a way to do things that doesn't
>> involve writing code, if I can do it in a more declarative style, so
>> SPARQL is my weapon of choice.  Of course, I have no idea if this
>> would
>> be any faster, but what about something like (completely untested,
>> so it
>> may fail for any number of reasons):
>>
>> SELECT ?c ?p
>> WHERE { ?p rdfs:subClassOf [
>>            owl:onProperty ex:part_of ;
>>            owl:someValuesFrom ?c ] }
>>
>> 	I'm thinking that starting by iterating over the restrictions
>> might be faster than iterating over all classes and then over each
>> restriction for each class, unless the reasoner is somehow able to
>> optimize the search for appropriate restrictions, such as having them
>> indexed by the object of the someValuesFrom.
>>
>> -Brandon :)
>>
>>
>> -----Original Message-----
>> From: pellet-users-bounces at lists.owldl.com
>> [mailto:pellet-users-bounces at lists.owldl.com] On Behalf Of Evren  
>> Sirin
>> Sent: Thursday, May 03, 2007 7:47 AM
>> To: Alan Ruttenberg
>> Cc: pellet-users at lists.owldl.com
>> Subject: Re: [Pellet-users] A lot of descendant queries
>>
>> On 5/1/07 3:44 PM, Alan Ruttenberg wrote:
>>> Hi,
>>> I'm using pellet to compute inferred class level part_of relations
>>> between classes in GO.
>>> The way I do this is to load the ontology and then iterate over all
>>> classes c asking for descendants of
>>> (restriction part_of (some-values-from c))
>>>
>>> This takes quite a while. Is there a fast way to do this?
>>>
>> I cannot think of any straightforward way that is faster. So you
>> want to
>>
>> compute the mereological hierarchy similar to subsumption  
>> hierarchy. I
>> think the same strategy (and similar optimizations) for computing the
>> subsumption hierarchy would apply here. That is you compute told
>> part_of
>>
>> relations, do a top search for each concept to find what it is  
>> part of
>> and do a bottom search to find what parts it has.  This strategy
>> avoids
>> many unnecessary tests and reuses the previously found information
>> effectively. A lot of the code inside Pellet classifier could be
>> reused
>> but there is still a fair amount of work that needs to be done to
>> customize the classification code for this purpose.
>>
>> Cheers,
>> Evren
>>> -Alan
>>>
>>> _______________________________________________
>>> Pellet-users mailing list
>>> Pellet-users at lists.owldl.com
>>> http://lists.owldl.com/mailman/listinfo/pellet-users
>>> _______________________________________________
>>>
>>> Sponsored by Clark & Parsia, LLC http://clarkparsia.com/
>>>
>>
>> _______________________________________________
>> Pellet-users mailing list
>> Pellet-users at lists.owldl.com
>> http://lists.owldl.com/mailman/listinfo/pellet-users
>> _______________________________________________
>>
>> Sponsored by Clark & Parsia, LLC http://clarkparsia.com/
>