We present the Rule-based Query Answering and Reasoning framework (RuQAR). The tool supports ABox reasoning and query answering with OWL 2 RL ontologies executed by the forward chaining rule reasoners Jess and Drools. We describe RuQAR's main features, its architecture as well as implementation details. Ontologies, as a way of expressing knowledge, are becoming more and more popular in various elds, such as web technologies, database integration, medical systems etc. Ontologies can be expressed in the Web Ontology Language 2 (OWL 2). The language provides a set of pro les1 which o er important advantages in di erent application scenarios. Among them, the OWL 2 RL pro le is the most interesting one from our point of view. It enables an implementation of polynomial time reasoning algorithms in a standard rule engine. Nonetheless, a naive implementation of an OWL 2 RL reasoner is known to perform poorly with large ABoxes [3]. Additionally, description logic-based reasoners handle the TBox entailments better than the ABox ones. However, ABox reasoning can be performed more e ciently by a rule engine [7]. Nevertheless, the o cial list2 of OWL 2 reasoners supporting OWL 2 RL is limited. Moreover, combining an OWL 2 RL reasoner with a currently used forward reasoning engine can be a tricky task, because existing reasoners usually provide their own format and reasoning algorithms. Furthermore, there is a lack of native and e cient rule sets that support OWL 2 RL reasoning in many popular rule engines, especially considering ABox reasoning. This motivated us to provide a tool which supports the application of an OWL 2 RL-based knowledge base in a forward chaining rule engine. Nevertheless, we do not limit ourselves to one particular engine or implementation. Instead, we aim at providing an easy-to-use framework for performing ABox reasoning with OWL 2 RL ontologies in any forward chaining rule engine such that it can be used in many rule-based applications.
In this paper we provide a detailed description of the Rule-based Query Answering and Reasoning framework (RuQAR) which overcomes the aforementioned issues. The main goal of the tool is to support ABox reasoning as well as query answering within the OWL 2 RL pro le. The remainder of this paper is organized as follows. Firstly, we describe main features of RuQAR. Then, we present its architecture as well as implementation details. Finally, we provide conclusions along with future development plans. 2 2.1
The RuQAR framework is aimed at providing easy-to-use functions that will
support reasoning and query answering with ontologies within OWL 2 RL. These
tasks should be performed by a forward reasoning rule engine. For this, an
ontology needs to be transformed into rules that are readable by a chosen engine.
According to this we have developed the following features for RuQAR:
1. The Abstract Syntax of Rules and Facts (ASRF) which is used to rise an
abstraction level providing more universal representation of rules and facts.
As a result the syntax enables easy translation into the language of any rule
engine. An implementation of mappings between ASRF and the language of
a chosen rule engine is required.
2. Transformation schema of an OWL 2 ontology into a set of rules and a set
of facts expressed in ASRF. The transformation schema is presented in
Figure 1. Firstly, an OWL 2 ontology is loaded into the HermiT3 engine. Then,
TBox reasoning is executed. We perform the following reasoning tasks:
satisability checking, concept classi cation and subsumption as well as checking
equivalence and disjointness between concepts. Finally, the resulting
ontology is transformed into two sets: one of rules and one of facts. These sets
re ect TBox and ABox separately. Both are expressed in the ASRF
notation. By loading a translated and inferred ontology, produced by HermiT,
into a rule engine we can derive more consequences during ABox reasoning
than those supported by OWL 2 RL. However, it depends on an applied
ontology (whether or not it uses constructs that are beyond OWL 2 RL).
Nevertheless, RuQAR supports only rules that are presented in Table 1.
Moreover, since we use the OWL-API [
OWL 2
4. Support for the Semantic Web Rule Language (SWRL) [
Additionally, RuQAR checks if a rule is safe (whether each variable from the
rule's head occurs in the rule's body).
5. Mapping method between an ontology and a relational database. Currently,
we are developing an interface which is based on the R2RML speci cation.7
6. Query answering functions that allow for querying Jess and Drools engines
with their native methods as well as our own methods. One of our method
uses a relational database to store the ABox part of an ontology. Another one
provides some optimizations regarding rules that are used while processing
the query. It is based on a previously developed extended rules approach [
Reasoning
Transformations OWL-API o t n I s e l u R
Mapping
The architecture of RuQAR is presented in Figure 2. The tool contains a set of modules that provide di erent functionalities. If a module overlaps another one in Figure 2 it means that they share some part of the RuQAR's Java code. The tool contains the following modules:
This module uses OWL-API to handle ontology les as well as to extract the logical axioms from an ontology. The module creates ASRF rules and facts and is responsible for creating mappings between a relational database and an OWL ontology. It provides RulesInto interface which has to be implemented in order to translate the ASRF notion into the language of a selected reasoning engine. An implementation of this interface requires to de ne mapping between ASRF elements and the destination language. The current implementation provides mappings for Jess and Drools. Both engines use di erent languages as well as di erent approaches for rule and fact representations. Jess uses its own scripting language and represents rules and facts as internal Java objects. However, rules in Drools are represented as when...then... statements in which any Java class can occur (as a pattern). Moreover, facts can be represented as pure Java objects. As a result we developed an additional class Triple which can be applied in the body of each rule as well as to represent facts as Triple objects. Thus, we con rmed that the ASRF syntax can be applied in di erent rule reasoning engines.
The module provides a set of functions to handle reasoning engines. We can use this module to perform ABox and TBox reasoning separately using HermiT. We can manage Drools and Jess when performing ABox reasoning or query answering. We can save results as a new OWL ontology. Additionally, we can obtain the pro le information about a given ontology. Whether it is within OWL 2 RL or not. If it is not, the violations are provided (mainly due to the OWL-API functions).
This module supports query answering with Drools and Jess. We can use native methods of those engines or our (optimized) methods that include a relational database access. Application of our method requires rules to be modi ed. However, this module provides such a modi cation which can be applied automatically with the ASRF rules. As a result we provide an optimized set of rules which can be translated into Drools or Jess rules out of the box.
RuQAR implements our method of transforming OWL 2 ontologies into a set
of rules and a set of facts expressed in the ASRF syntax. Table 1 shows currently
supported rules by our implementation. This set comes from the speci cation of
OWL 2 [
In ontology-to-ASRF transformation we translate each logical ontology axiom
into its equivalent rule. As a result the transformation materializes the semantics
of a given ontology in a set of Datalog-like rules (we consider it as a non-naive
translation). Since we are focused on ABox reasoning, each rule should be
perceived as an implementation of the axioms from a given ontology. According to
this, we obtain a signi cant performance gain [
The transformation method may produce more entailments during reasoning than those represented by OWL 2 RL/RDF rules. It is caused by the fact that we apply TBox reasoning with a DL-based reasoner. However, it depends on the expressivity of a given ontology. Nevertheless, the application of our method to ontology beyond OWL 2 RL will not produce the same consequences as derived by an appropriate DL-based reasoner (in our case the set of inferences will be smaller). As a result, the reasoning with rules generated by our methodology is sound but not complete.
Since RuQAR generates rules and facts in the native language of a rule engine, the tool can be easily integrated into an existing environment. For example, assume that we have an application X which uses Drools to perform reasoning with some data. If we create an ontology that describes the data, and then we translate the data into RDF triples, we can employ RuQAR to generate rules (and facts) that can be easily and directly applied with X.
In this paper we presented the RuQAR tool which is a framework that provides many useful functionalities to: (i) perform ABox reasoning and query answering with OWL 2 RL ontologies executed by forward chaining rule reasoners, (ii) translate an OWL ontology into rules, (iii) use SWRL rules together with ontologies, (iv) manage reasoning engines and to (v) store OWL individuals in a relational database.
Moreover, presented work is the rst implementation of OWL 2 RL reasoning
in Drools and Jess (except the work presented in [
Currently, we are implementing R2RML mappings which will be useful to
measure the performance of query answering algorithms. In this case we are
going to use the NPD benchmark [
More information about the RuQAR framework can be found at its web page: http://etacar.put.poznan.pl/jaroslaw.bak/RuQAR.php. Acknowledgments. The work presented in this paper was supported by UMO2011/03/N/ST6/01602 grant and 04/45/DSMK/0124 project. 8 http://wiki.ruleml.org/index.php/Rule-Based_Data_Access