In our experience, some ontology users find it much easier to convey logical statements using rules rather than OWL (or description logic) axioms. Based on recent theoretical developments on transformations between rules and description logics, we develop ROWL, a Prote´ge´ plugin that allows users to enter OWL axioms by way of rules; the plugin then automatically converts these rules into OWL DL axioms if possible, and prompts the user in case such a conversion is not possible without weakening the semantics of the rule.
It has long been argued, that rules are much more intuitive and easier to master than description logics, in terms of what their intended meaning is. We find this substantiated throughout our experiences as teachers and as ontology modelers which frequently work with domain experts.
To give just a simple example: The exact semantics behind a logical axiom such as
in our experience often remains somewhat unclear even for people with significant exposure to ontologies and ontology modeling. On the other hand, a rule such as
In this section, we provide some examples of translations of rules into OWL axioms
in an attempt to convey an intuitive understanding of our transformation. For a formal
and complete of such procedure we refer the reader to [
The following rule can be used to characterize all individuals taking courses and working for a department as student workers.
attends(x; y) ^ Course(y) ^ worksFor(x; z) ^ Dept(z) ! StudentWorker(x) (1)
We transform this rule into a DL axiom via a series of equivalence preserving transformations. First, we detect that both y and z are variables that can be “rolled up,” as they only occur in a single object property. Thus, these variables can be sequentially removed from the rule, resulting in the following:
Furthermore, we can unify all unary atoms of the form C(x), i.e., sharing the same variable x, yielding:
(9attends:Course u 9worksFor:Dept)(x) ! StudentWorker(x) The previous rule can then be directly translated into OWL as the following axiom:
For the next example, we have the following rule, which specifies that “all mice are smaller than all elephants.”
Translating such a rule into OWL requires us to first connect the variables in the body. We do so by adding atoms of the form U (t; u) with U the universal property, i.e., owl:topObjectProperty.
The previous rule can be directly translated into OWL resulting in the following three axioms where RMouse and RElephant are fresh object properties not previously occurring in the ontology:
RMouse U
Modeling OWL with Rules: The ROWL Prote´ge´ Plugin
Certain rules cannot be expressed in OWL employing our approach. For example, the following rule, which characterizes the set of individuals taught by their own uncle, cannot be translated by our approach.
hasFather(x; y) ^ hasBrother(y; z) ^ taughtBy(x; z) ! TaughtByUncle(x) Note that, such a rule cannot be reduced in the same way as rule , since every variable occurs in at least two atoms with object properties as predicates.
In cases, such as the previous one, in which a rule cannot be translated into OWL
using a set of DL axioms, our implementation will suggest several options to translate
such rule using nominal schemas [
attends(?x, ?y) ˆ Course(?y) ˆ worksFor(?x, ?z) ˆ Dept(?z) -> StudentWorker(?x) When the “Convert to OWL Axiom” button is clicked, ROWL will attempt to apply the rules-to-OWL transformation described in the previous section to the given rule. If successful, a pop-up will appear displaying one or more OWL axioms resulted from the transformation, presented in Manchester syntax. These axioms can then be integrated into the active ontology.
If the given rule cannot be transformed into OWL axiom, ROWL will prompt the user if they still want to insert the rule into the ontology as an SWRL rule with annotation. If the user agrees, ROWL will switch to its SWRL tab and proceeds in the same way as adding a rule via the original SWRLTab. Note that ROWL is separate from the original SWRLTab, hence any SWRL rule added via ROWL will not affect rules added through the original SWRLTab.
Note that once the axioms generated from rules are added into the ontology, the plugin does not provide a way to undo it and recover the original rule from which the axioms were generated. That is, when a user enters a rule through this plugin and converts it to OWL axioms, the active ontology is either augmented with the generated OWL axioms or SWRL rules. To have this feature, we need a way to record which axioms were generated from which rules. This will be considered as part of future development of this plugin.
Finally, a feature of ROWL not found in SWRLTab is the possibility to automatically add declarations for classes and properties if the inserted rule contain classes or properties not yet defined in the ontology. For example, in the rule above, the original SWRLTab requires that attends and worksFor to be already defined as object property, while Course, Dept, and StudentWorker as class in the ontology. This would add a little bit more freedom for the user to enter any rule (s)he wishes during modeling because (s)he does not need to first exit the plugin and declare the classes and properties directly in Prote´ge´.
Acknowledgements. This work was supported by the National Science Foundation under award 1017225 III: Small: TROn – Tractable Reasoning with Ontologies.