W3C home > Mailing lists > Public > public-rule-workshop-discuss@w3.org > August 2005

RE: phasing proposal

From: Boley, Harold <Harold.Boley@nrc-cnrc.gc.ca>
Date: Sat, 27 Aug 2005 21:01:41 -0400
Message-ID: <E4D07AB09F5F044299333C8D0FEB45E94E015C@nrccenexb1.nrc.ca>
To: "Sandro Hawke" <sandro@w3.org>, <public-rule-workshop-discuss@w3.org>

> Here's a possible phasing of the work.  I imagine each phase taking
> roughly a year.  This is totally biased to put what I think is easy
> first, and pre-supposes a particular Web-and-RDF-centric approach to
> external conditions and actions.  It also ignores the current debate
> about using FOL as an interlingua; if something better emerged, it
> could perhaps be dropped in to the same place in this sketch.

Here is a revised version of Phase 1 (a revised Phase 2 should follow
as soon as we have a working consensus on Phase 1). This version brings
together the FOL and S/NAF strands of our discussion: Work package (4)
is on knowledge exchange between the two.

According to the multi-stack architecture(+), there should be stacks
of Web languages including OWL, Rules, and SparQL. As described in
"A Realistic Architecture for the Semantic Web" (RuleML 2005 paper by
Michael Kifer et. al), these stacks can perform knowledge exchange
by following the 'predicate export' model of Thomas Eiter et al.
The WG can use this for the OWL/SWRL stack, which is based on FOL,
and the LP rules stack, which is based on NAF/SNAF.

In this way, the Web Rules WG will explore, right away, a special but
paradigmatic case of rule interoperation, namely between certain
FOL subsets (2) and corresponding SNAF-enhanced rule languages (3).
Other interoperation cases will be dealt with in work package (1).

Phase 1:

1 For all of the following packages, provide test and use cases.
  Develop techniques for mapping between these cases written in
  the evolving Web Rules language and in relevant existing languages.
  Maintain a library of rulebase cases as well as translators mapping
  from and to the rulebases written in the Web Rules language.

2 XML syntax for Datalog, Horn logic, and other subsets of FOL,
  up to full FOL, using the FOL RuleML Member Submission as input
  Extend by the XML Concrete Syntax of the SWRL FOL Member Submission

  - Explain how RDF instance data fit in, and permit syntactic sugar
    for predicate variables in RDF queries (e.g., in a binary P(s,o)
    HiLog term, which can be mapped to an apply(P,s,o) triple.)

  - Introduce a scope/context/module/ruleset construct based on
    the ones of N3, TRIPLE, and FLORA-2.

3 Provide Scoped NAF (SNAF) for all FOL subsets L for which the
  semantics of L+SNAF is well-understood and sufficient use cases
  exist (at least for L = Datalog and L = Horn logic).
  Explore uses cases where certain FOL subsets containing NEG can
  be implemented via SNAF.

4 Knowledge exchange between L+SNAF and FOL subsets by each viewing
  the other as "black box" with a well-defined interface established
  through exportable predicates. Generalize the uni-directional
  approach of AL-log to bi-directional exchange, as exemplified
  for logic programming and description logics by Thomas Eiter et. al
  in a KR04 paper (see RuleML 2005 paper by Michael Kifer et. al:
  Builtins can be considered as uni-directional special case:

  - Identify datatype builtins from those proposed for cwm, FORUM,
    SWRL, SPARQL, etc. for use in corresponding L+SNAF and FOL

  - Show how one can use RDF/SPARQL data sources to provide access
    builtins that listen to external (programmatic, side-effect-free)

5 Explore how to generalize external data access builtins to builtins
  that are triggered via external event sources, e.g. by representing
  events as special facts.

  - Events could be received via any of the standard technologies
    (messaging, distributed notifications, etc.), as in ECA (Event
    Condition Action) and CEP (Complex Event Processing) paradigms.

  - Algin such external conditions with the event handling in
    Semantic Web Services (and, generally, Web Services).

6 Provide primitives for a selected set of action types, where the
  action instances can, e.g., again be represented as special facts,
  asserted on successful rule application.

  - At minimum, provide primitives for changing the underlying state
    of the knowledge base through Assert and Retract (and Update,
    which can be implemented via a Retract followed by an Assert).

  - Consider the callMethod primitive of PR RuleML (RuleML Production
    Rules Language), which allows the assertion of action facts and
    supports method calls (including Web Service calls).

  - Explain how one could implement actions via persistent/recurrent
    SPARQL or SQL queries, or similar calls to external systems.

-- Harold

(+) An alternative stack architecture for the Semantic Web was
proposed by several groups at the W3C Rules4Interop Workshop and
adapted for the talk "Web for real people" by Tim Berners-Lee:
Received on Sunday, 28 August 2005 01:01:40 UTC

This archive was generated by hypermail 2.3.1 : Tuesday, 6 January 2015 19:48:34 UTC