論文獎則是頒發給 Stanford 大學設計 Protege 知識庫發展與編輯系統的研究團
隊。整個研討會最後在下午 5：00 左右圓滿完成。我也和大家互相告別之下回到
自己的住處。
Yuh-Jong Hu1, Ching-Long Yeh2, and Wolfgang Laun3
1 Emerging Network Technology (ENT) Lab.
Department of Computer Science National Chengchi University, Taipei, Taiwan
hu AT cs.nccu.edu.tw
2 Department of Computer Science Engineering Tatung University, Taipei, Taiwan
chingyeh AT cse.ttu.edu.tw
3 Thales Rail Signalling Solutions GmbH, Austria
wolfgang.laun AT gmail.com
Abstract. The RuleML Challenge started in 2007 with the objective of inspiring the issues of implementation for management, integration, in-teroperation and interchange of rules in an open distributed environment, such as the Web. Rules are usually classified as three types: deductive rules, normative rules, and reactive rules. The reactive rules are further classified as ECA rules and production rules. The study of combina-tion rule and ontology is traced back to an earlier active rule system for relational and object-oriented (OO) databases. Recently, this issue has become one of the most important research problems in the Semantic Web. Once we consider a computer executable policy as a declarative set of rules and ontologies that guides the behavior of entities within a system, we have a flexible way to implement real world policies with-out rewriting the computer code, as we did before. Fortunately, we have de facto rule markup languages, such as RuleML or RIF to achieve the portability and interchange of rules for different rule systems. Otherwise, executing real-life rule-based applications on the Web is almost impos-sible. Several commercial or open source rule engines are available for the rule-based applications. However, we still need a standard rule lan-guage and benchmark for not only to compare the rule systems but also to measure the progress in the field. Finally, a number of real-life rule-based use cases will be investigated to demonstrate the applicability of current rule systems on the Web.
1 Introduction
The RuleML Challenge competitions started in 20074, so the RuleML-2009 Chal-lenge will be the third year for the rule system competition. We offer participants the chance to demonstrate their commercial and open source tools, use cases, and applications for rule related technologies. For the past two RuleML Challenge
4 RuleML-2007 Challenge, http://2007.ruleml.org/index-Dateien/Page787.htm
competitions, only a minimum set of requirements was given for evaluating the submitted demo systems. The criteria were that declarative rules should have to play a central role in the application, and that the demo systems should preferably be embedded into a Web-based or distributed environment, etc. The Challenge winners were selected and 1st and 2nd places were awarded with pres-tigious prizes.
The RuleML-2009 Challenge follows similar processes and the evaluation cri-teria are the same as in the previous two events. But we consider inviting more participants to submit their rule related systems in this year. In the RuleML-2009 Challenge, we organize events as two tracks, one is by invitation, to demonstrate a commercial or open source environment for its rule systems, and the other is open to general public for a real system competition. In addition to the demo systems with reports submitted to the RuleML Challenge website5, it is also possible to submit demo papers describing research and technical details, and the selected papers will be published in additional special Challenge proceed-ings, such as CEURS. A final selection of revised papers from the Challenge proceedings will be resubmitted to a special issue of a journal for publishing.
In this RuleML Challenge survey paper, we point out the possible research and implementation challenges for rule systems on the Web that are related to the Challenge competition events in the forthcoming years.
1.1 Challenges for Rule Systems
Rules as human understandable policies are everywhere in our daily life to im-pose human behaviors. For example, before you take a flight, you need to read airline check-in and boarding time rules in the policy statement of your booking itinerary receipt. If you violate any rule you might miss your plane. Related situations in this scenario of using rules are early-bird conference registration, special discount hotel reservation, payment and refund policies, etc. These rules as policies are represented as human understandable natural language. However, we still need to transform these natural language policies into computer pro-gramming rules for computer system understanding and automatic execution.
Sometimes, not all of the rules imposed on a human are necessarily and possi-bly represented as software programs to accomplish automatic execution in our computer systems. Usually, these rules restrict only human behavior, without di-rect connection with any software system. For example, we have law for privacy protection and digital rights management but not all of privacy rights and dig-ital rights for human are required to be represented and evaluated in computer systems.
There are several challenges while implementing rule systems on the Web.
Rules should be allowed to cope with the data model, such as RDB/OO-DB, or a knowledge base, such as an ontology, to permit query and modification ser-vices on the data models. Policies imposed on human behavior are declared in some policy language by the combination of rules and an ontology (or database),
5 http://ruleml-challenge.cs.nccu.edu.tw
and these policies can be automatically interpreted and executed by a computer.
There should be a standard language and framework for rule systems to enable rule interchange services on the Web. A certain number of use cases are easily represented and executed by rule and ontology reasoning engines with rule in-terchange and ontology merging standards to ensure rule interoperability and ontology compatibility.
In the early computer development stage, imperative programming languages such as C and Java were used to represent rules and execute them on a com-puter system. But these rules are inflexible and not easy to maintain when they are distributed on the Web and require interchange and integration between rule systems. Moreover, imperative programming languages are not appropriate to express concepts of human policies as computerized rules. Recently, people use declarative programming to specify the rules and execute them automati-cally, where XML is used as a standard syntax representation for interchange of declarative rules, such as RuleML [1], RIF [2], etc.
Even though an XML-based standard rule language and framework provides rule interchange service, pure XML cannot specify a well-defined semantics for rules. So people in the standard rule community constructed a logic foundation behind rule languages and their framework, to preserve the integrity of syntax and semantics of rules interchange for various rule systems. Similarly, OMG SBVR intends to define the vocabulary and rules for documenting semantics of business vocabulary, facts, and rules, as well as an XMI schema for interchange of business vocabularies and rules among organizations and between software tools6
In this paper, we first introduce the classification of rules, then, in section 2, we address the issue of rules, and databases and ontologies . In section 3, the current status of a declarative policy as the combination of ontology and rules will be introduced. In addition, Semantic Web Service (SWS) processes also require a declarative policy to express and execute Web Service rules to control information sharing and service execution. In section 4, we examine current different rule management systems and engines. In section 5, we investigate different rule interchange languages. In section 6, we look into the use cases that are possibly represented and executed by the rule systems. Finally, we conclude this study in section 7.
2 Rule and Data Model
2.1 The Classification of Rules
Rules are classified as three types: deductive rules (or derivation rules), nor-mative rules (or integrity rules), and reactive rules (or active rules). One can use deductive rules and facts to trigger a forward or backward reasoning en-gine to derive implicit facts. Normative rules pose constraints on the data or on the business logic to ensure their consistency in the database or knowledge
6 http://www.omg.org/spec/SBVR/1.0/
base. Without reactive rules, we cannot update a database or knowledge base by using deductive rules only.
Reactive rules are further subdivided into event-condition-action (ECA) rules and production rules. ECA rules are rules of the form ON Event IF Condition DO Action, where Action should be executed if the Event occurs, provided that the Condition holds. Production rules are rules of the form IF Condition DO Action, where Condition queries the working memory containing the data on which the rules operate. Action should be executed whenever a change to the underlying database makes Condition true [2].
In reactive rules, we verify the satisfaction of conditions and also execute the action whenever message arrival or timer event triggers the rule. Declarative rules extend their executive power by the combination of rule semantics and imperative programming in the action part.
2.2 Rules and Databases
As early as 1980, Ullman pointed out the principles of the integration of database and knowledge base systems [3] [4]. The foundation of database is relation algebra with SQL as a declarative database query language. However, first order logic (FOL) was also proposed as a way to represent “knowledge” and as a language for expressing operations on relations. The roots of relational theory is logic, and so we cannot deny that the foundation of relational DBMS is based on logic [5].
The simplest data model of FOL is “Datalog”, which was coined to suggest a version of Prolog suitable for database systems where it does not allow function symbols in Datalog’s predicate arguments. In the IDEA methodology, deductive rules and reactive rules were built on top of the object-oriented (OO) database as a way to express operations on the OO data model [6].
2.3 Rules and Ontologies
Concepts of the Semantic Web have been proposed by Tim Berners-Lee et al.
since 2001 [7]. Graph-based RDF(S), including RDF and RDF-schema were the first standardized ontology languages to represent an ontology’s schema and instances. Then, standardized ontology languages based on Description Logic (DL) [8], i.e., OWL-DL (later OWL 2), enhanced RDF(S) that plays the major role of knowledge representation for the Semantic Web. However, the logic pro-gram (LP) rule language was also introduced because of the limited expressive power of a DL-based ontology language in some situations, such as property chaining, and the manipulation of events, states, and actions.
Initially, the “rule” layer was laid on top of the “ontology” layer in the Seman-tic Web layered architecture but it has undergone several revisions reflecting the evolution of layers7. The most recent layered architecture of rule and ontology layers is one where they sit side by side to reflect their equal status but with some basic assumption differences between ontology and rule, such as the open world
7 http://www.w3.org/2007/03/layerCake.svg
assumption (OWA) vs. the closed world assumption (CWA), or the non-unique name assumption (non-UNA) vs. the unique name assumption (UNA) [9].
It will be a challenge to resolve these basic assumption differences when we combine rule and ontology to execute rule systems on the Web.
Rules and RDF(S) Inspired from F-Logic, TRIPLE8 was one of the earliest rule languages using Horn rules to access the RDF datasets. Another rule lan-guage called Notation3 (N3) uses a CWA forward reasoning engine to access the ontologies generated from RDF(S) 9. SPARQL is another W3C standardized query language for querying RDF datasets. SPARQL queries are represented as Datalog rules so SPARQL’s CONSTRUCT queries are viewed as deductive rules, which create new RDF triples from the RDF datasets.
Rules and OWL In addition to the Semantic Web Rule Language (SWRL) [10], Rule Interchange Format (RIF) is an emerging rule interchange language from W3C RIF WG [2]. It intends to provide core and extend languages with a com-mon exchange syntax for all of the classification rule languages, i.e., deductive, normative, and reactive rules. The requirements of integrating different types of rules with possible data (and meta data) accessing representation, i.e., RDB, XML, RDF, and OWL, drive the development of a RIF core interchange format, theRIF Core, and its extensions, RIF dialects. Another recent development is to combine RIF and OWL 2 in RIF, RDF, and OWL that specifies the interactions between RIF, RDF and OWL for their compatibilities10.
2.4 Combination of Rule and Ontology
A one-way knowledge flow exists from an ontology module to a rule module for knowledge acquisition, where an ontology module’s instances are imported as basic facts and filtered with conditions in the rules. This passive knowledge query only uses deductive rules. If a rule engine derives implicit new facts not in an ontology module and furthermore updates new facts back to an ontology module, then it provides another reverse knowledge flow from a rule module to an ontology module. In this two-way knowledge flow process, normative and reactive rules are also required to check the knowledge consistency and trigger the message passing for updating the ontology’s knowledge base.
The idea of combining rules and ontologies is to fulfill a goal of two-way knowledge flow. The combination is classified as two types: tightly coupled inte-gration and loosely coupled inteinte-gration [11]. In the tightly coupled inteinte-gration model, all of the terms in the rule’s body and head are specified in the ontol-ogy schema, but in the loosely coupled integration model we do not have this requirement. So, some rules have their own defined terms in the rules’ body or
8 http://triple.semanticweb.org/
9 http://www.w3.org/2000/10/swap/doc/cwm
10http://www.w3.org/2005/rules/wiki/OWLRL
head. This loosely coupled integration model enhances the expressive power of ontology and rule as compared to the tightly coupled one.
Description Logic Program (DLP) [12] and SWRL are two well-known tightly coupled integration models. In general, both DL and LP are subsets of FOL in knowledge representation but each has its own part that cannot be expressed in the other part. DLP only takes intersection of DL and LP so knowledge repre-sentation in this model is limited. In SWRL, the major knowledge reprerepre-sentation is OWL-DL with additional Datalog rules from LP to enhance the lack of prop-erty chaining in OWL-DL. In SWRL, DL-safe is the condition where variables occurring in each rule’s head are also required to occur in its body to ensure the decidable reasoning of the rule engine. The availability of SWRL rule and ontology integration development in the popular Prot´eg´e environment11 makes the SWRL model the most attractive one for people to use.
In the loosely coupled integration, DL-log [13], AL-log [14], and DL+Log [15]
are three well-known models. In these models, rules are extended to Horn rules.
Besides, not all of the terms in rules are required from ontology so rule module in these models provides more powerful knowledge representation and rule reason-ing than the ones in SWRL. However, none of loosely coupled integration models provide standardized XML markup languages and a development environment, as SWRL does in Prot´eg´e. Obviously, this will be a challenge to represent and execute rule systems for loosely coupled integration on the Web. Moreover, the reactive rules [16] have not been seriously considered in all of the ontology and rule integration models. This will be the biggest impediment to implement rule and ontology systems for distributed applications on the Web.
3 Policy as Ontology and/or Rule
Since computers understand the data semantics in the Semantic Web, people are much more satisfied with the search results when a semantic search engine is fully developed. Policy-aware Web extends Semantic Web that provides comput-erized policies, such as privacy protection or digital rights management policies for computers to understand and execute automatically [17]. However, pure rule and/or ontology languages are not explicit enough to represent policies that reg-ulate human behavior in the real world. We need a well-defined policy language that describes the concepts of rights, obligation, conditions, resources, etc. be-tween resource owner and user to represent and execute access control policies of resources on the Web.
Following [18], policies are considered as knowledge bases, allowing deontic classes, properties, and access control rules. This has the advantage that many operations are automated, thereby reducing ad hoc program coding to a mini-mum and enabling automated documentation. Regulations imposed on human behavior and activity are simulated by computerized policies that are specified by using policy languages, such as Rei or KAoS [19]. The semantics of these
11http://protege.stanford.edu/
policy languages is only DL-based, and needs to be further extended by using LP-based semantics of rule languages, such as RuleML, RIF or Protune [20].
Recently, AIR (AMORD In RDF) is a policy language that considers using both RDF ontology language and N3 rule language for the privacy protection policy execution12.
3.1 Policy for Semantic Web Services
The idea of Web Services in the SOA of distributed software systems has be-come a tremendous success. Semantic Web Services (SWS) employ Semantic Web technology in the Web Services area: service functionality, service inputs and outputs, preconditions and effects, etc.; all are expressed and executed in knowledge representation languages, i.e., ontology and rule languages [21]. A policy can be considered in the SWS because of using similar ontology and rule languages’ semantics on the Policy-aware Web. Thus policies are represented and executed as Web Service rules for the compliance of human regulations to control information sharing and service execution.
One of the challenges to implement rule systems on the Policy-aware Web is how to design and implement rules as computerized policy by the integration of rule and ontology. This computerized policy imitates human regulation for controlling information sharing and service execution for a composite web ser-vice on the Web. And the ultimate goal is the satisfaction of legal regulation compliance from the execution of a computerized policy. This idea is similar to the Legal Knowledge Interchange Format (LKIF) proposed in the past EU FP6 project [22].
4 Rule Management Systems and Engines
Before looking into the details of rule management systems, we need to decide about a rule management systems implementation platform. If we choose a rule system that is also embedded in the Semantic Web development environment, then we have several advantages. First, it provides sufficient facilities to imple-ment subsystems for rules and the data model. Second, both the ontology and rule languages used in the Semantic Web are complementary to each other so we can leverage on the declarative knowledge representation. Third, we have a standard query language or a rule language to support the access of underlying knowledge bases for ontology or rule bases. Finally, if applications are embed-ded in Java or some other popular imperative programming language, we have language typing, control flow, and interaction mechanism available for the im-plementation of application system on the Web.
12http://dig.csail.mit.edu/TAMI/2007/amord/air-specs.html
4.1 Rule Systems in the Semantic Web Framework
The SemWebCentral13is one of the well-known websites providing Open Source development tools for the Semantic Web. The Semantic Web system develop-ment framework can be subdivided into three subsystem modules: an
The SemWebCentral13is one of the well-known websites providing Open Source development tools for the Semantic Web. The Semantic Web system develop-ment framework can be subdivided into three subsystem modules: an