W3C home > Mailing lists > Public > www-rdf-logic@w3.org > March 2004

Re: Strategies for inference over lists of values

From: Graham Klyne <GK@ninebynine.org>
Date: Sun, 07 Mar 2004 09:22:33 +0000
Message-Id: <5.1.0.14.2.20040307085622.01eff528@127.0.0.1>
To: Drew McDermott <drew.mcdermott@yale.edu>, www-rdf-logic@w3.org

At 13:46 02/03/04 -0500, Drew McDermott wrote:
> > [Graham Klyne]
> > I'm wondering what strategies folks are using for inference over
> > collections (lists) of values in RDF (other than resorting to ad-hoc
> > code).  (Maybe also over containers, but the closure of lists makes the
> > problem easier to define.)
>
>What do you mean by "strategy"?  Can you give an example of ad-hoc
>code?  Are we allowed to use OWL Rules?

By "strategy", I mean here something like the outline of a general 
technique that can be used in a variety different situations.  Jos' 
response of using recursive rules in his backward-chaining reasoner, Euler 
[4], is an example.  An approach using OWL rules (or a pattern based on 
such) would indeed be interesting to me.

An example of "ad hoc" code would be a primitive function implemented in a 
reasoner that sums the integer values in a list.  Typically, an "ad hoc" 
solution would not be expected to generalize to an arbitrarily broad range 
of foreseeable problems.  (I imagine that folks using libraries like Jena 
might be writing Java code to deal with these situations.)

One of the reasons I asked this question was that I have been trying to 
combine some datatype-specific deductions (integer arithmetic) expressed in 
a scheme [1] inspired by the Pan/Horrocks paper [2], with collections 
(lists) of data which are antecedent facts for the desired composite rule 
of deduction.  I am finding that it is surprisingly awkward to use the 
generalized restriction for this purpose, and think that I am probably 
missing a trick here.  My own experiments suggest that I must combine the 
restriction with a more conventional (antecedent=>consequent) form of rule.

The (half-baked) idea I was considering as a way to deal with inference 
over a collection was to introduce a primitive along the lines of a 'fold', 
as found in functional programming languages (which has been shown to have 
some degree of universality for expressing recursive/repetitive functions 
[3]), and combine that with non-iterative/non-recursive inference patterns.

#g
--

[1] 
http://www.ninebynine.org/RDFNotes/RDF-Datatype-inference.html#sec-choice-constraint-classes

[2] Horrocks, I. and J. Pan, "Web Ontology Reasoning with Datatype Groups", 
2003.
     http://www.cs.man.ac.uk/~horrocks/Publications/download/2003/PaHo03a.pdf

[3] J. Functional Programming 1 (1): 1-000, January 1993
c fl 1993 Cambridge University Press 1
A tutorial on the universality and expressiveness of fold
Graham Hutton University of Nottingham
(also at http://www.cs.nott.ac.uk/~gmh/fold.pdf)

[4] http://www.agfa.com/w3c/euler/



------------
Graham Klyne
For email:
http://www.ninebynine.org/#Contact
Received on Sunday, 7 March 2004 18:12:21 GMT

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