Re: Strategies for inference over lists of values

At 17:51 22/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.)
> > >
> > [me]
> > >What do you mean by "strategy"?  Can you give an example of ad-hoc
> > >code?  Are we allowed to use OWL Rules?
> >
> > [Graham Klyne]
> > 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.
>...
> > 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.
>
>Whether you use 'fold' or recursive rules, at some point you're going
>to need an 'eval' operation that enables you to invoke actual
>procedures that compute things.  ('+', for instance).  For 'fold' to
>be anything like universal you're going to need higher-order
>functions, which would be a breathtaking addition to SWRL and other
>deductive systems.
>
>So, have you thought about what the 'eval' sublanguage would contain?

If I'm understanding your question properly, I'm thinking in terms of 
simple syllogisms and primitives defined on datatyped values; e.g. per [1] 
(such as '+', etc.).

I'm not thinking of adopting higher order functions here, so the 
universality of fold may be illusory.  What I was looking for was an 
approach that would extend the scope of simple "one-step" inference 
patterns to a repetitive mode in a principled and reasonably 
straightforward fashion, and fold seemed to be a useful candidate.

(Though I did choose to use Haskell as a basis for my software [2], 
precisely because I could use it to implement arbitrary new inference 
primitives while working within a declarative framework, so I'm not sure 
how breathtaking this really is.)

#g
--

[1] http://www.ninebynine.org/RDFNotes/RDF-Datatype-inference.html

[2] http://www.ninebynine.org/RDFNotes/Swish/Intro.html



------------
Graham Klyne
For email:
http://www.ninebynine.org/#Contact

Received on Tuesday, 23 March 2004 03:57:55 UTC