--> |
| R u l e M L |
<-- |
Rules in (and for) the Web have become a mainstream topic since inference rules were marked up for E-Commerce and were identified as a Design Issue of the Semantic Web, and since transformation rules were put to practice for document generation from a central XML repository (as used here). Moreover, rules have continued to play an important role in AI shells for knowledge-based systems and in Intelligent Agents, today both needing a Web interchange format, and such XML/RDF-standardized rules are now also usable for the declarative specification of Web Services.
The Rule Markup Initiative has taken initial steps towards defining a shared Rule Markup Language (RuleML), permitting both forward (bottom-up) and backward (top-down) rules in XML for deduction, rewriting, and further inferential-transformational tasks. The initiative started during PRICAI 2000, as described in the Original RuleML Slide, and was launched in the Internet on 2000-11-10. Besides the previous XML-only RuleML and the current XML/RDF-combining RuleML, there is also an approach towards an RDF-only RuleML. Complementary efforts consist of the development of (Java-based) rule engines such as Mandarax RuleML and XSB-RDF RuleML. There now exists an initial RuleML design and a Version 0.8 system of DTDs for basic RuleML sublanguages.
Contents
| News-Events
| MissionStatement: The goal of the Rule Markup Initiative is to develop RuleML as the canonical Web language for rules using XML markup, formal semantics, and efficient implementations. RuleML covers the entire rule spectrum, from derivation rules to transformation rules to reaction rules. RuleML can thus specify queries and inferences in Web ontologies, mappings between Web ontologies, and dynamic Web behaviors of workflows, services, and agents. Approach: Rather than focusing on academic research prototypes, RuleML is about rule interoperation between industry standards (such as JSR 94, SQL'99, OCL, BPMI, WSFL, XLang, XQuery, RQL, OWL, DAML-S, and ISO Prolog) as well as established systems (CLIPS, Jess, ILOG JRules, Blaze Advisor, Versata, MQWorkFlow, BizTalk, Savvion, etc.). The Initiative develops a modular RuleML specification and transformations from and to other rule standards/systems. Moreover, it coordinates the development of tools to elicit, maintain, and execute RuleML rules. It also collects use cases, e.g. on business rules and reactive services. |
The participants of the RuleML Initiative constitute an open network of individuals and groups from both industry and academia. We are not commencing from zero but have done some work related to rule markup or have actually proposed some specific tag set for rules. Our main objective is to provide a basis for an integrated rule-markup approach that will be beneficial to all involved and to the rule community at large. This shall be achieved by having all participants collaborate in establishing translations between existing tag sets and in converging on a shared rule-markup vocabulary. This RuleML kernel language can serve as a specification for immediate rule interchange and can be gradually extended - possibly together with related initiatives - towards a proposal that could be submitted to the W3C.
| If you want to review rule principles, (then) you may look at Rule-Based Expert Systems. (BTW, this is itself a simple rule.) If you want to review XML principles, you may go to the beginning of Knowledge Markup Techniques. |
Rules are being used for many interconnected purposes, capturing regularities in application domains such as the following:
Rules can be stated (1) in natural language, (2) in some formal notation, or (3) in a combination of both. Being in the third, 'semiformal' category, the RuleML Initiative is working towards an XML-based markup language that permits Web-based rule storage, interchange, retrieval, and firing/application.
Markup standards and initiatives related to RuleML include:
The RuleML Initiative consists of the participants represented here by their logos.
2001-05-11: "RuleML, the emerging standards effort on XML Rules knowledge representation, continues to progress in its design -- and also in its acceptance; notably, IBM this past month joined as participant and publicly disclosed that it is prototyping support for RuleML. Presentation materials from two recent W3C meetings, and a new short overview conference paper, are now available: see http://www.mit.edu/~bgrosof/#XMLRules." (Also see: alphaWorks Posting. Contact: Hoi Chan.)
Some initial steps taken by the RuleML Initiative have been to structure the area of rule markup, to raise issues and identify tasks, and to propose tentative rule tags/attributes.
The current RuleML design shows the big picture of how we conceive and formalize rule markup; this has been the basis of much of our more specific work.
2001-01-31: A preliminary RuleML DTD has been released:
RuleML DTD Version 0.7.
2001-07-11: A revised DTD version has been finalized:
RuleML DTD Version 0.8.
2001-09-25: A preliminary XML Schema for a Datalog subset of RuleML has been released:
RuleML Schema Version 0.8.
2002-04-02: A query DTD version has been realized (cf. Queries):
RuleML DTD Version 0.8.
The discounting business rules example shows some of the features:
discount.ruleml
(discount.ruleml.txt).
As in many deduction approaches, RuleML queries are regarded as headless implications, symmetrically to regarding facts as bodiless implications. They enumerate the bindings of all their free (existentially interpreted) variables.
Queries were added to RuleML 0.8 as a third top-level element of rulebases besides facts and imps (since this extension is purely additive, all queriless RuleML 0.8 rulebases should still validate). This gives us "for free" all refinements of RuleML's existing system of sublanguages via the _body role of queries: because of RuleML's DTD inheritance, additions were only required for ruleml-datalog.dtd (ruleml-datalog.dtd.txt) and urcbindatagroundfact.dtd (urcbindatagroundfact.dtd.txt). In particular, ruleml-datalog.dtd's query-extended rulebase definition is inherited by ruleml-hornlog.dtd, where queries in datalog use only inds and vars but queries in hornlog automatically also permit cterms (because hornlog atoms permit cterms).
RuleML queries are illustrated by our business-rule example discount.ruleml (discount.ruleml.txt) and by Eric Prud'hommeaux's RDF Query example wsdl-rdf-query.ruleml (wsdl-rdf-query.ruleml.txt).
This query incorporation into RuleML assumes that the sublanguage expressiveness should be the same for 'assertions' (facts and imps) and for the 'requests' (queries) on them. So, it cannot, e.g., express queries on ground triples (containing no variables) via non-ground triples (containing variables): creator.ruleml (creator.ruleml.txt). However, users can still employ one rulebase (module) with its DTD for 'assertions', and another rulebase (module) with a different DTD for 'requests'.
Via Object-Oriented RuleML (OO RuleML) object-centric knowledge representation with facts (instances) and rules (methods) is now directly supported.
An experimental RDF translator for a subset of RuleML 0.7 is available in XSLT: RuleML in RDF Version 0.2. RuleML 0.8 now stands in the direct Context of RDF.
2001-06-20: Michael Sintek has implemented a (Java) parser for an RDF version of the Horn-logic subset of RuleML 0.8; it reflects an RDF RuleML syntax by (Java) classes that currently generate textual Horn clauses but could be adapted for generating the XML RuleML syntax: The FRODO rdf2java Tool. A converse translator from XML RuleML 0.8 to RDF RuleML 0.8 should be easier to write in XSLT than was possible for the above-linked RuleML 0.7 translator.
The FLIP Group uses RuleML in machine learning: About using RuleML for expressing machine learning knowledge. In the LispMiner project work with RuleML is directed towards statistical association rules.
Since RuleML should help rule-system interoperation, (XSLT, ...) translators for RuleML rulebases are rather important. Please send us further translator pairs between your system and RuleML -- even if your translators are (still) partial.
In February 2001 Mike Dean created the first operational RuleML rulebase, GEDCOM, with rules on family relationships (child, spouse, etc.) run via XSLT translators to the XSB, JESS, and n3/cwm engines.
2001-09-17: Harold Boley has specified XSLT translators between the Horn-logic subsets of RuleML and RFML. These can make implementations of both systems available to each other and permit, e.g., a preliminary HTML rendering of RuleML rulebases. The XSLT stylesheets may also serve as blueprints for specifying further translators to/fro RuleML.
2001-09-19: Andreas Eberhart implemented an alpha version of OntoJava. The basic idea is to automatically map Protégé ontologies, instances defined in them, and RuleML rules into a sinlge Java main memory DB / rule engine that can then be used as the basis of an application. He is looking forward to hearing of your ideas and input.
2002-02-04: Andreas Eberhart
extended OntoJava
by reaction rules:
<java>
runtime.Loader.load("http://localhost:8080/servlet/SearchGate?flight="
+ <var>F</var>.name, false);
</java>
This example loads RDF info into the DB, which comes from a kind of Web Service.
So emails can be sent as well, etc.
While this is not 'cross-platform', it should be interessting from an engineering
point of view.
2002-07-08: Said Tabet created an XSLT stylesheet for transforming from a version of RuleML to Jess. The full Java environment for running this is available from Said Tabet.
One or more rule engines will be needed for executing RuleML rulebases. On 2000-11-15, the RuleML Initiative thus joined forces with the Java Specification Request JSR-000094 Java Rule Engine API. This cooperation will enable a direct cross-fertilization between the complementary specifications of the open XML-based Rule Markup Language and of the Java runtime API for rule engines.
2001-06-04: Jens Dietrich implemented the first complete input-processing-output environment for RuleML. To download the api (source code) click Mandarax RuleML. Any feedback is welcome! If you have problems, don't hesitate to contact Jens for assistance.
2001-06-26: Michael Sintek has implemented a small XSB-based engine that can also be looked at as the first RuleML querying agent. It's a servlet (running in Tomcat) that receives RuleML rulebases in RDF RuleML syntax (since he uses The FRODO rdf2java Tool) together with some queries, evaluates them with XSB Prolog (in auto-tabling mode, which should be equivalent to bottom-up evaluation!), and returns the result as an HTML page containing the bindings as facts of instantiated queries. A future version must, of course, return a RuleML file. Simply try this URL. Click on 'example' and paste the RDF RuleML popping up into the input window (note that pasting XML/RDF cannot be directly done in IE, only in Netscape; use "view source" in IE). Alternatively, you can use the Prolog parser and RDF translator to generate the RDF RuleML. Since we cannot guarantee that the above URLs always work (server reboots etc.), this picture shows the agent in action. Any feedback is welcome! If you have problems, don't hesitate to contact Michael for assistance.
2002-02-06: Bruce Spencer further refined The Design of j-DREW, a Deductive Reasoning Engine for the Semantic Web.
2002-03-08: Jens Dietrich has finally published Mandarax 1.6 with major improvements, including new docs and all the features discussed in the Mandarax Dagstuhl Talk. One of the new packages is xkb_b1.jar -- it contains a modular driver to translate rule bases to XML and vice versa. I.e., there are tiny adapter objects responsible for exporting/importing rules, facts, terms etc. This should enable us to set up a reference application for any new standard in hours.
RuleML Participant Jens Dietrich's Oryx (version 2.1) has a graphical Knowledge Editor for business rules and a Repository that contains the description of predicates, functions, and database connections. "Oryx works with open XML based formats, support for the emerging RuleML standard and the open source Mandarax XKB 1.0 format is included." (http://www.jbdietrich.com).
Michael Sintek has implemented a Prolog parser and RDF translator to generate RDF RuleML.
Andreas Eberhart wrote a small tool that allows you to convert Prolog (currently, Datalog) rules to RuleML. This Prolog2RuleML tool is available both online and as a command line version.
A library of RuleML rulebases is being accumulated here as a collection of use cases for further design discussion and as examples for practical rule exchange (RuleML Library). The highest version of RuleML (currently 0.8) should be used whenever possible. If you have an entry, please send us its pointer.
If you are interested to join the RuleML Initiative, please send a link describing your work related to rule markup to Harold Boley & Said Tabet; same for general RuleML questions/suggestions. Depending on your specific RuleML interests, you may also contact some RuleML Technical Group (select above) or some RuleML Participant (select above). If necessary, you can also address all RuleML Participants (RuleML distribution list).
Site Contact:
Harold Boley.
Page Version: 2003-06-07
"Practice what you preach": XML source of this homepage at index.xml (index.xml.txt);
transformed to HTML via the adaptation of Michael Sintek's SliML XSLT stylesheet at homepage.xsl (View | Page Source)
