"Semantic" rules (was FOL Axiomatic semantics of DL and RETE )

Chimezie  --

Interesting rumination on reasoners (below).  Thanks for the references.

You may like to ruminate further in the direction of "semantic" rules.
Apologies if you have already considered this, but here goes.....

It's possible to have a rule language and engine such that:

1.  changing the order of the rules does not change what is derivable -- a
rule just means what it says

2.  the rules are in open vocabulary English, yet the semantics are strict

3.  people with spreadsheet-level skills can edit and run the rules using a
browser

4.  step by step English explanations/plans, at the business or scientific
level are available on demand

5.  from the rules, the engine can automatically generate and run SQL that
would be too complex to write reliably by hand.  The results are explained
as in 4.

As you may know, all of the above is live, online in a Wiki-like system
called Internet Business Logic.  The URL is www.reengineeringllc.com, and
shared use is free.

There are a number of SW, lifesci and other examples that you can view, run
and change, using a browser.  You are welcome to write and run your own
examples too.

An overview paper  is


www.reengineeringllc.com/A_Wiki_for_Business_Rules_in_Open_Vocabulary_Executable_English.pdf

(There are also presentations, FAQs, and tutorials).

The engine is based on the  axiomatic semantics  in

    Backchain Iteration: Towards a Practical Inference Method that is Simple

    Enough to be Proved Terminating, Sound and Complete. Journal of
Automated Reasoning, 11:1-22

I'd be interested to hear whether any of this meshes with your thoughts
about   FOL Axiomatic semantics of DL and RETE.

Thanks in advance for comments,    -- Adrian



Internet Business Logic (R)
Executable open vocabulary English
Online at www.reengineeringllc.com
Shared use is free

Adrian Walker
Reengineering
PO Box 1412
Bristol
CT 06011-1412 USA

Phone: USA  860 830 2085



----------------------------------------------------------//--------------------------------------------

On Fri, 15 Sep 2006, William Bug wrote:
> I also believe Chemezie done very useful work in this arena
> (http://copia.ogbuji.net/blog/keyword/data), though,
> again, he'd be able to tell us more specifically how relevant it is to
> OWL-based applications.

Most of my recent rumination on reasoners has been shaped
first by Benjamin N. Grosof, Ian Horrocks, and Raphael
Volz's 2003 paper 'Description Logic Programs: Combining Logic Programs with
Description Logic' [1], by the work done by Bijan Parsia, Yarden
Katz, and Kendall Clark on Pychinko [2] , and by Jos Deroo's set of OWL
rules [3].

Pychinko was the first attempt (that I know of) to implement Notation 3
reasoning with Charles Forgy's RETE algorithm, with *very* impressive
performance results (which should come as no shock to those familiar
with the superiority of the RETE algorithm).

Unfortunately, most work in this area was focused on either adhoc rules -
standard expert system scenario - or rules written specifically to express
DL semantics.  Jos Deroo's great work with euler has
demonstrated that the OWL & RDF test cases can be passed by an explicit
set of N3 rules that express DL semantics.

There is ofcourse a concern with the use of N3 as the KR language - since
it's not 'officially' sanctioned, but my preference for it is mostly that
it more akin to Horn logic and full FOL than vanilla RDF/OWL.  The
additional expressiveness is very valuable for scenarios that require this
- DL reasoning primarily.

Ofcourse, as articulated in 'Description Logic Programs: Combining Logic
Programs with Description
Logic', not *all* of DL can be expressed by such a transposition, but
there is plenty of precendent in mappings from DL to FOL - which can be
expressed in N3 rules (and a good portion of which has already been
captured in the rules used to pass the OWL/RDF tests).

Along this line, I've been working [5] on a second generation (if you
will) attempt to implement a RETE-like N3 reasoning algorithm (it must be
called RETE-like because the original algorithm isn't even FOL-oriented).

The main problems I've run into are not with the function-free horn-like
subset of Notation 3 (where the
only builtins are filters and not N-ary functions) but with the issues of
variable dependence in a forward chaining system when you attempt to
support n-ary 'functions' on top of the RETE algorithm.  It begins to feel
more like a bastardization of
the algorithm that was really only meant for pattern matching.

This is mostly not an issue with DL semantics as a *majority* of it can be
expressed in function-free logical rules.

Ultimately, in my opinion, I think there is much value in research in this
area due to the unprecedented ability for logic programming algorithms
such as RETE (and it's derivatives RETE II, TREAT, SOAR) to handle *very*
large scale facts and rules.  And the reality is that the set of logic
rules that express DL semantics (mappings from DL to FOL) are quite
miniscule compared to the normal rulesets that logic programming systems
are built to handle and so the great potential exists to:

 - handle *much* larger fact bases and ontologies than standard
tableaux-based reasoners
 - develop expert systems that allow the use of *both* adhoc rulesets in
tandem with DL axiomatic rulesets

This latter point could even accomodate reasoning scenarios that fall
outside the capabilities of DL (such scenarios are well outlined in the
first paper)

My $0.02 (plus a little more)

[1] http://citeseer.ist.psu.edu/grosof03description.html
[2] http://www.mindswap.org/~katz/pychinko/<http://www.mindswap.org/%7Ekatz/pychinko/>
[3] http://lists.w3.org/Archives/Public/semantic-web/2005Aug/0059.html
[4] http://www.w3.org/2000/10/swap/doc/CwmBuiltins
[5] http://copia.ogbuji.net/blog/2006-07-14/fuxi-mapping-from-rete-to-n3