Contents:
The session started with a quick round of introductions of all participants. The workshop was opened by Sandro Hawke of W3C, workshop co-chair, with a short presentation to remind everybody of the focus and objectives of the workshop, and to introduce the program and rules of the play. There was a clear agreement from the audience and no objections have been voiced during this presentation. There was, however, a request for a demo session.
Stated Objective: to have the different involved communities introduced to each other, with their rule usage, history, goals, vocabulary etc, so as to make sure that everybody at the workshop shares a minimum of common background about other communities from the beginning
Terry Moriarty was the first speaker. Her talk is about Business Rules, illustrated the use of rules in a number of large projects (government non-DoD), and the need for a standard rule language in order to share business rules. Terry gave a business perspective, with the need to use/reuse the vocabulary and business terms that people are familiar with. A classification of rules was suggested, and some comparison to the needs and requirements of the Semantic Web as opposed to the business rules community. She refers to OWL, need for ontologies as well and ways to integrate the efforts from various communities.
The second talk was given by Eric Miller, W3C Semantic Web Activity lead. Eric stressed the importance of this workshop and focused on giving a Semantic Web perspective. He briefly described the WWW Consortium and its mission/structure, as well as many of its accomplishments. He also clearly stated the importance of the international and multi-cultural nature of W3C. Eric came back to the Web architecture and talked about a 'Web of Documents' as the basis for interoperability and interchange of information, enabling various communities to expose their information and share vocabularies, etc. Eric also talked about lessons learned from previous efforts, and how to work together to make this a success not just as a workshop but as a working group.
Michael Kifer gave the third and last talk of the session. His first slide displayed a proposed Semantic Web stack with 'Rules' next to OWL on top of RDF. Michael's focus was on describing theoretical foundations and requirements for a Semantic Web Rule language. He talked about the limitations and failure of past efforts and languages. He notes that although Prolog is a good/suitable language, it did not reach mainstream adoption (not popular with programmers and not close to what they expect from a programming language).
This session was ended with a general discussion involving all the session speakers. The discussion started with metadata, and their importance to the Web, and the need for rules to be business oriented. Terry argued that a lot of what is called 'metadata' is actually simply business data. The discussion moved to questions around the various users and the role of various logics. Are we expecting business people to write programs (SQL code, Prolog?). Some argued that Business users (particularly domain experts) are using tools and user interfaces that help them write rules and represent their expertise. Some suggest to let business users deal with rules that are not complex and leave the complexity to specialists and programmers. Eric Miller moved the discussion to URIs and advocating its use within the enterprise as a cost-saving solution and an integrated approach for information systems (even for non-webized applications). Tim Berners Lee followed with a comment on SPARQL and a unified format for various kinds of information. More discussion followed on the need for more players (mention of BPEL, BPMI, and other organizations in vertical domains). The last part of this general discussion focused on the needs and requirements of the business community (mostly simple complexity rules are needed) and the KR community that cares about logic and more expressive rule languages. However, MITRE argued that they see themselves needing requirements for both and sit in between the two communities.
Stated Objective: Briefly describe and justify each requirement/family of requirements; illustrate your requirements with examples; focus on requirements for exchanging rules; scope different sets of requirements as precisley as possible (with respect to usage, kind of rules, whatever is relevant)
Presentations by Ed Barkmeyer (NIST; NIST "Position Paper" for the W3C Workshop on Rule Languages for Interoperability), Colleen McClintock (ILOG; General Requirements for Production Rule Systems), Dan Connolly (W3C; W3C Process: A Means to an End).
Common rules needs are for converting between different representations of the same information, qualifying information, reasoning about relations between regions (containment, intersection...), and a rule language for engineering models must support variables, partOf properties, arithmetics constraints involving multiple properties, relations between properties. Ed Barkmeyer (presentation, paper) also pointed out that there are different kinds of rules (information model rules, business logic and workflow rules, semantic Web service specifications) and we need integration/interoperation of all kind of rules. Users do not want to read traces, but there is a need to be able to exchange proofs, explanations. External events need to be part of the language.
Brief discussion
Colleen McClintock (presentation, paper) presented requirements on a standard for exchangin production rules (concern 25 commercial products and 18 open source products in the Java rule engine space only). Two important points are that a standard rule language must be unambiguous with respect to execution (same rules with same data produce same results in different environments) and that it must be compatible with related standards (esp. OMG's Production Rules Representation and JSR 94's Rules Engine API). She proposes a layered standard with common core constructs and different sublanguages for different execution/inference semantics.
Brief discussion
Dan Conolly (presentation, paper) explained the W3C values and process and where the workshop fits.
Brief discussion
End users do not want to read traces, but how about a verification engine? A common bottom layer would allow to pass assertions to another engine (for validation, verification purposes). We may need a proof language to allow delegation and maintain trust
Representing assertions, and also queries/answers (and eventually proofs) which are the conclusions from those assertions, in terms of external-to-engine behavior of what's inferred, is a low hanging fruit. But the execution layer of engine is really procedural (differences in the engine behavior such as rule priority/sequencing and refraction may affect what actions get performed), without well established available theory, and thus seems fairly difficult to standardize on anytime soon. Rules can be disambiguated with respect to execution or with respect to results: what kind of rule language are we interested in, a programming language or a knowledge representation language?
It is easier to interoperate data than a procedural version of how an engine works. So, rather than trying to describe the internal variants of the engine behavior, it is usually simpler to define the expected behaviors in the standard, and the engine should then (be developed so as to) support the standard.
In MathML, different URIs are used to specify which semantic model was being used by the author, as it was not feasible to make all math engines come up with the same answer, even in standards math.
Stated Objective: Tell us to why the presented technology is a candidate, what requirements it fulfills; give us a feeling for what the technology is, do not go to deep into the technical details/is about; give us a couple concrete examples of what you can do and what you cannot do with the technology; do not bother to compare with other technologies, the discussion will take care of that :-)
Jos de Bruijn, DERI: presentation, paper
Brief Discussion:
Harold Boley, NRC Canada: presentation, paper
This presentation, more than any other, tried to claim the high ground, to say "this is what the first version of the standard should be". It was reiterated in later RuleML presentations: Datalog + NAF.
Brief Discussion:
Benjamin Grosof, MIT: presentation, paper.
Brief Discussion:
Tim Berners-Lee, MIT: presentation, paper
Brief Discussion:
Bijan Parsia, UMD: presentation, paper
Four approaches to OWL compatibility
1-3 == subsumed by SWRL, so standardize SWRL
Contributed Notes
Highlights
Harry Halpin: Tim [Berners-Lee, during the N3 presentation ] said "[ordinary] defaults and NAF wont work on the open web", and Bijan acknowledges the web being an "open world". Is RuleML maybe an XML a syntax for transferring rules around?
Harold Boley: There are closed sub-webs, eg all W3C Recs, all states. For those you can use NAF.
Tim Berners-Lee: Yes, when you're looking at a closed set, it's just a mathematical function
Benjamin Grosof: I use a broader definition of "Semantic Web" — "semantics" on the Web. The web is not open, it is a collection of stuff, on planet earth. Any given stuff on the web has an owner. [...] You need to close off your sets. There's a presumption in all Monotonic and Non-Mon work that you close off the world. Syntax for explicit scoping is useful, of course. I think there's a misconception here.
The issue came up several more times, and towards the end of the second day, it was easy to get smiles or laughter by referring to it. Presumably the humor helped diffuse the earnest tension around this issue of unknown complexity. At the end of the second day, there seemed to be some optimism that there's no real disagreement here.
This topic is listed as an issue in the report.
Stated Objective: Explain the context briefly; tell us what the standard is about and define its scope; explain the relationship with rule exchange and interopearbility on the Web, and focus on what your standard would require from or contribute to the specification of a rule language for interoperability (if anything); tell us what are your ideas for the ideal language, from your specific point of view
The production rule meta-model being specified within the Business Enterprise Integration Domain Taskforce at OMG was presented by Paul Vincent (presentation, paper). The current work is limited to forward-chaining and sequential rule processing, most typically found in business rules environments/engines. It is meant to define behaviors, not for generic knowledge representation. Model interchange will be based on OMG's XMI (XML Metadata Interchange). A standard rule language is required for run-time rule exchange: it has to be compatible with the meta-model, possibly a concrete syntax for it. NB: RuleMLparticipates to that work.
Brief discussion:
Daniel Selman presented (presentation, paper) a standard Java API for rule engines (JSR 94). The lightweight API does not specify the behaviour of the engine nor does it define an underlying rule language (so, no API to introspect rules, create rulesets, plug parser...). The message is that JSR-94 really needs a standard rule language. The requirements are that:
Brief discussion:
Donald Chapin presented (slides not available, paper) the Semantic of Business Vocabulary and Business Rule meta-model (SBVR, aka the semantic beaver), which was developed as an answer to OMG's Business Semantics of Business Rules RFP. SBVR is for business modeling by business customer, in their own terms, independent of implicit or explicit IS consideration or design decision, in the language that the business people use, to be created and maintained by the business staff. It is a synthesis of 4 previous established areas: terminology for translating natural lang documents (ISO 1807-1), business practices, formal logics (FOL with some extensions), linguistics and communication.
Brief discussion:
Although not presented at the workshop, the DAWG's SPARQL is obviously related.
Thirteen presentations were given in three sessions on Use Cases. Stated Objective: Explain the context briefly; tell us what the standard is about and define its scope; explain the relationship with rule exchange and interopearbility on the Web, and focus on what your standard would require from or contribute to the specification of a rule language for interoperability (if anything); tell us what are your ideas for the ideal language, from your specific point of view
Christine Goldbreich presented (presentation,
paper) a
use case on sharing the anatomical knowledge (ontology and
rules) that is needed to label brain parts in digitally
processed images (MRI). She claims the the ontology language
needs be integrated with the rule language in order to allow
navigating ontology associations/constraints within the
rules. She gives an example where solutions are missed if
this is not allowed.
Main requirements
Content rating is moving from PICS to RDF-based labels
because the notion of puting PICS label into content does not
fit with major companies' workflow. Phil Archer (presentation,
paper)
presented ICRA's use cases for rules in Internet
content rating. Nobody wants to meta-tag all the pages of a
large site (e.g. BBC has 5M pages) and that labelling and
rating must therefore be separates from page development. The
idea is that labelling and rating are rule-based (currently
done in RDF):
Brief discussion:
Doug Clark (presentation,
paper)
stressed the importance of project management as that most
organisation today are just collections of projects. He
identified five opportunity areas for rules in project
anagement : work breakdown, scheduling, performance (earned
value), maturity and status (reporting). The requirements on
rule languages are that:
The problem domain for Chris Matheus's use case (presentation,
paper) is
understanding what is going on in an evolving situation
(battlefield, financial market...). Requires domain
knowledge, abstraction, time dependent reasoning, sensor
fusion. Currently, they develop ontologies in OWL first, then
rules expressed in SWRL grounded in observable data annotated
with the ontologies; SWRL rules are converted to JESS or
their own engine for runtime execution.
Issues with SWRL:
Additional wishlist: Graphical definition/exploration of
rules; Explanations; Real-time or near real-tim performance;
Reasoning about uncertainty.
Srinivas Krovidy (
presentation, paper) made
the case for sharing rules in the martgage industry. The main
drivers are that next generation eCommerce applications
require shipping business rules along with data; improving
the mortgage business process (increased agility, better
integration of multiple players); emergence of industry data
standard (MISMO); and regulatory compliance requirements. A
standard rule language would be required to support
Brief discussion:
Dave Reynolds presentation (presentation,
paper)
focused on semantic Web oriented rules activities in HP (i.e.
not speaking for other activities involving, e.g. business
rules).Rules in Jena are based on N3, with negation except for extensional
predicates, forward-chaining (RETE) and backward-chaining
(tabled LP), targeted at RDF processing. There are about 20K
Jena users. The observation of the user groups and HP
usage shows significant usage of rules, split between
standalone RDF processing and rules layered on top of
RDFS/OWL; but little evidence for rules exchange. The use
cases demonstrate the need for RDF level processing. Some use
closed-world negation (thus require full non-monotonic
NAF?).
Brief
discussion:
Due to a late start of the session, the first use cases session was discussed along with the second one, at the end of session 6.
Harry Chen, Image Matters: presentation, paper.
Brief Discussion:
Jeffrey Ritter: presentation, paper.
I don't write code, but I do write rules; I make laws
Discussion:
Kurt Godden, GM: presentation, paper.
Brief Discussion:
Mark H Linehan, IBM: presentation, paper.
"In our experience, very simple business rules cover 60%, 80%, maybe 95% of the users." This became a touchstone for the rest of the workshop, perhaps best seen in contrast to Michael Kifer's presentation, standing for everything one can do with very simple rules, and how users can't handle Prolog.
Brief Discussion:
Contributed Session Notes
Note that discussion for Session 5 (Use Cases 1) and Session 6 (Use Cases 2) occured together.
Who writes the rules? How many are there? How fast does the engine need to be?
Four of the presenters "mostly need a standard for tool-independent-archiving" of rules; all of them need a standard for exchange of rules. What's a typical use case for sharing rules:
Do rules need to be published with a context, a pre-condition? XACML has targets like that. Of course such a condition can just be the first part of the rule.
Imagine Open Source rule bases. A payroll service provier could offer their rules, making deals much faster. FPML rules are published on their website, along with test cases. (financial) In natural language, with XML test cases. (reference implementation, FPML busines rules from ISDA) We need a language for open source rule sets! Who knows who all might use it? (And how could they be managed?)
Devasis Bassu from Telecoria offered another use case (telecom): Ordering of telephone services; cost per order; if you fill out the form badly you get charged extra -- so there's a market for people to check over your forms. If the rules could just be published! Rules technology makes business much easier. XML adoption is recent; Huge demand from ILECs; They want to lower their costs; Rules are in every aspect of Telecom.
Rule Systems provide competitive advantage (business efficiency), but they reduce customer lock-in.
The second candidate technologies session included the following talks:
We started the session with a talk by PatHayes introducing Common Logic, its concrete syntax and XML markup. Pat stated that the requirements of this language have been influenced by Semantic Web languages.
Stefan Decker presented TRIPLE, as an RDF Rule Language for interoperability. This language has been implemented and used in various experiments. Stefan argued for rules against writing code as a much faster development methodology.
The next talk was presented by Harold Boley on RDF/RuleML interoperability, discussing OO RuleML and N3 as well. Negation was briefly discussed here, including types of negation supported.
The session was concluded with a general discussion with all speakers. The key questions were related to the requirements, what constitutes a candidate technology for standardization, and finally each speaker was asked to clarify what is their proposal in this regard? A question to all speakers asking them to address formal syntax and semantics support in their proposal. Some of the participants argued for a simple set of features to start with instead of a very rich and complex language. However, warned the audience, a simple language (Datalog + NAF was mentioned a few times) must come with extensibility in mind (learning from the MathML experience and others).
The third use case session included talks by Gary Hallmark of Oracle, Thomas Roessler, and Suzette Stoutenburg. We had various perspectives including the business rules approach and the Semantic Web approach:
Gary Hallmark presented an argument for declarative rules but also rule flow. He also pointed that a standard language is important to lower project risks and lower development costs. He pointed to the importance of an easy syntax to use rather than using logic as a basis for rules syntax. Access to web services, use of programming language constructs (such as Java), and integrating non-declarative aspects in rules are all key requirements.
Thomas Roassler focused his talk on ruls languages for privacy-enabled identity management (access control, policy integration, etc). Thomas also mentioned event condition action rules (ECA) and constraints as types of rules needed for such an application.
Suzette Stoutenburg described the application of rules in government (for the DoD). Her application requirements included the need to reuse rules in a dynamic environment, to communicate and share rules between coalition partners in challenging conditions (multiple sources of input, information integration, etc). Uncertainty and probabilistic reasoning is also another requirement for MITRE. This talk expressed the move by the DoD to Semantic Web technologies (ontologies and and rules included). Suzette touched on the open versu closed world requirements but did not elaborate as those are not yet clear for MITRE.
The workshop closed with a special panel of people selected by the workshop chairs during the workshop. It was moderated by Danny Weitzner, W3C. The panel members were asked a few hours in advance to prepare a list of key features of this work, and to begin the session with a three-minute presentation of their their quickly-prepared list. See the panel presentations.
Customers demand standards to protect their rule assets from vendor lock-in. Rules should be portable and interoperable across vendors, platforms, and applications. Rule sets get repurposed, reused.
We should start simple (eg Datalog+NAF), to guarantee applicability, performances, and deployment. Make the minimal language but have a maximal language in mind as a unifying concept. Maybe use profiles (Rules Light / Rules Full). Define an extension mechanism.
The language should be compatible with existing standards (W3C - especially OWL, OMG) and methodologies (especially object-oriented programming). Plan the integration with OWL carefully, drawing on DLP, AL-Log, etc. Define an abstract syntax, an XML exchange syntax, and allow for multiple surface syntaxes including a frame-style one.
Bijan Parsia: Why do this work at W3C?
Jean-Francois Abramatic (Panel): Because the Web is the universe of networked information. A multi-app, multi-platform standards has no sense if it doesn't go to the web.
Benjamin Grosof: There are two central technical issues here: negation and actions (procedural attachments).
Jon Pellant, Paul Vincent (Panel): Yes, actions are important, and outside of regular logic.
Ed Barkmeyer (Panel): Negation will have to be handled carefully. [see issues]
Pat Hayes: Action are important, but I'm concerned about how they interact with the logic. I'm also scared because I've heard "NAF" to mean several things. "Need a way to say something is not in a set" -- that's perfectly classical.
Ian Horrocks: As a perpetrator of DLP, I'm embarrassed by this version of the layer cake I see with OWL and Rules intersecting. I find this "we're all happy" attitiude disingenuous. DLP shows that the bit in the middle is very small and not very useful. This new layer cake is proposing two completely different and mainly incompatible languages for logic on the web. What does this say to people now investing in OWL?
Jos de Bruijn: I've seen lots of cases where people are using rules engines to work with rules and OWL.
Anthony Finkelstein: (Echoing a point in Ed Barkmeyer's panel presentation) We need not just a standard rule language but rule engine interoperability. Maybe we could have one standard syntax but have different identified semantics for it.
Vassilis Tzouvaras: Yes, there are lots of important angles here, including uncertainty reasoning.
Ravi Raman: Let's follow Ed's suggestion and just tag rule sets, indicating the right semantics. This allows for the exchange of rules, and there's no need to convert immediately and completely.
Waleed Abdullah: The rule language has to be simple. RuleML is too complicated. So many acronyms, so many sublanguages, people just get lost. It wont get implemented.
Danny Weitzner: This applies to more than just RuleML. It's a challenge for everything produced by W3C.
Christian de Sainte Marie: It seems like using RDF for rules is more of a burden than is justified by the use cases we've seen.
Tim Berners-Lee: Rules should be able to operate on RDF data, but the rules themselves do not need to be writen in RDF.
Bijan Parsia: Amen.
Pat Hayes: Every language should have n-ary predicates. The Unique Names Assumption is also important for many players.
Gary Ng: I'd like to see a feature table. Semantics vs. what it does not allow you to say. Then the researches can be guided by features.
Michael Uschold: We need rules to support ontology-ontology mapping to enable information integration
Adrian Walker: Users need to be able to see explanations of how results were reached. This is true in general, but it's even more so in a distributed/web environment. Without it, no one will trust the results. We also need surface syntax which Google will happily index, so people can find rules.
Danny Weitzner (Moderator, Summarizing): In the last hour, what I heard was: there's interest in doing something, it has to be well defined, it has to be simple, it has to be compatible and learn from work out there, and finally everyone has an interest in being able to evolve from what they are doing now, to take careful steps to interoperation.
Workshop Adjourned.