OWL 2 rolification

Question

In description logic, there is a concept called "rolification" (OWL and Rules, Sec 3.2). It converts a concept (class) into a role (property). For example, when we rolify R(x), we get r(x,x). This technique is useful for expressing some rules in DL.

How do we do this in OWL 2? It seems that there is no direct support for rolification in OWL 2 specification.

@JimL. Thanks. The link is updated. – Yang Apr 06 '16 at 16:45 — Yang, Apr 06 '16 at 16:45

Joshua Taylor · Accepted Answer · 2015-05-26T19:13:51.570

Section 3.2 of the paper that you linked to says:

It is indeed possible to translate this rule into OWL 2—however this involves a transformation which we call rolification: The rolification of a concept A is a (new) role R_A defined by the axiom A ≡ ∃R_A.Self. Armed with rolification, we can now express rule (1) by the axiom …

OWL2 doesn't support expressing an axiom like Elephant(x) &wedge; Mouse(y) → biggerThan(x,y) directly. As I understand it, you manually use the process of rolification that the paper describes to produce a new axiom that can be expressed in OWL2 directly.

Rolification

As to the specific process, if you want to express something like Elephant(x) &wedge; Mouse(y) → biggerThan(x,y), you first rolify the classes Elephant and Mouse. This means that you introduce new roles (properties) R_Elephant and R_Mouse (but you do not delete the classes Elephant and Mouse). These new roles are such that R_Elephant(x,x) if and only if Elephant(x). This is enforced by adding the axioms

Elephant ≡ ∃R_Elephant.Self

Mouse ≡ ∃R_Mouse.Self

each of which is expressible in OWL2. With those two axioms in hand, you finally add the subproperty chain axiom

R_Elephant &bullet; topObjectProperty &bullet; R_Mouse &sqsubseteq; biggerThan

which is also expressible in OWL2. Since for any elephant e and any mouse m, we have that

R_Elephant(e,e)

topObjectProperty(e,m)

R_Mouse(m,m)

then by the subproperty chain axiom, we have that

biggerThan(e,m)

which is exactly what we wanted to express.

Axiom Syntax

In the input syntax accepted by Protege, these axioms are written as follows.

        Elephant EquivalentTo R_Elephant some Self
        Mouse EquivalentTo R_Mouse some Self
        R_Elephant o topObjectProperty o R_mouse SubPropertyOf biggerThan

In Protege they appear as follows.

elephant rolification axiom mouse rolification axiom subproperty chain axiom

In N3:

@prefix :        <http://www.example.org/rolification#> .
@prefix rdfs:    <http://www.w3.org/2000/01/rdf-schema#> .
@prefix owl:     <http://www.w3.org/2002/07/owl#> .
@prefix xsd:     <http://www.w3.org/2001/XMLSchema#> .
@prefix rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .

:Elephant
      a       owl:Class ;
      owl:equivalentClass
              [ a       owl:Restriction ;
                owl:hasSelf "true"^^xsd:boolean ;
                owl:onProperty :R_Elephant
              ] .

:R_Elephant
      a       owl:ObjectProperty .

:biggerThan
      a       owl:ObjectProperty ;
      owl:propertyChainAxiom
              (:R_Elephant owl:topObjectProperty :R_Mouse) .

:Mouse
      a       owl:Class ;
      owl:equivalentClass
              [ a       owl:Restriction ;
                owl:hasSelf "true"^^xsd:boolean ;
                owl:onProperty :R_Mouse
              ] .

<http://www.example.org/rolification>
      a       owl:Ontology .

:R_Mouse
      a       owl:ObjectProperty .

In RDF/XML:

<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns="http://www.example.org/rolification#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">
  <owl:Ontology rdf:about="http://www.example.org/rolification"/>
  <owl:Class rdf:about="http://www.example.org/rolification#Elephant">
    <owl:equivalentClass>
      <owl:Restriction>
        <owl:onProperty>
          <owl:ObjectProperty rdf:about="http://www.example.org/rolification#R_Elephant"/>
        </owl:onProperty>
        <owl:hasSelf rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</owl:hasSelf>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  <owl:Class rdf:about="http://www.example.org/rolification#Mouse">
    <owl:equivalentClass>
      <owl:Restriction>
        <owl:onProperty>
          <owl:ObjectProperty rdf:about="http://www.example.org/rolification#R_Mouse"/>
        </owl:onProperty>
        <owl:hasSelf rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</owl:hasSelf>
      </owl:Restriction>
    </owl:equivalentClass>
  </owl:Class>
  <owl:ObjectProperty rdf:about="http://www.example.org/rolification#biggerThan">
    <owl:propertyChainAxiom rdf:parseType="Collection">
      <owl:ObjectProperty rdf:about="http://www.example.org/rolification#R_Elephant"/>
      <rdf:Description rdf:about="http://www.w3.org/2002/07/owl#topObjectProperty"/>
      <owl:ObjectProperty rdf:about="http://www.example.org/rolification#R_Mouse"/>
    </owl:propertyChainAxiom>
  </owl:ObjectProperty>
</rdf:RDF>

Thanks Joshua, but my problem is if OWL 2 supports rolification. I browsed through the language specification, but it did not mention that. — Yang, Jun 07 '13 at 17:59
each of which is expressible in OWL2 - so how's it expressed in OWL 2? (I know it can be expressed in description logic) — Yang, Jun 07 '13 at 18:01
@Yang I've updated my answer with the Protégé input syntax and screenshots, as well as the N3 and RDF/XML serializations of an ontology containing these axioms. — Joshua Taylor, Jun 07 '13 at 18:12
@Yang "Rolification" isn't something that a language would typically support or not support. It's a translation of certain kinds of sentences in to (sets) of other kinds of sentences. A language (e.g., a particular description logic, or OWL) might not support the first kind of sentence, but might support the second kind of sentence. That's the case here; OWL2 doesn't support the first kind of sentence, but it supports the kinds of sentences that rolification produces. — Joshua Taylor, Jun 07 '13 at 18:17
I think `hasSelf` is not rolification. It is a restriction that produces a class from a property. http://www.w3.org/TR/owl2-syntax/#Self-Restriction — Yang, Jun 07 '13 at 18:24
@Yang As you say, `hasSelf` is not rolification, it is a particular kind of restriction. The paper that you linked to says: “The rolification of a concept `A` is a (new) role `R_A` defined by the axiom `A EquivalentTo some R_A Self`.” The rolification of the class _is_ the new role. By using the rolifications of classes, we can express things in OWL2 that we could not express in OWL2 without the rolifications of the classes. — Joshua Taylor, Jun 07 '13 at 18:32
@Yang Compare to the case of n-ary properties in OWL. OWL only has binary properties. But we can _represent_ arbitrary properties in OWL by _adding a new class and properties_ to represent the property. E.g., instead of _between(x,y,z)_ we use _betweenRelation(w)_, _firstArg(w,x)_, _secondArg(w,y)_, _thirdArg(w,z)_. Similarly, we can't write _Elephant(x) & Mouse(y) -> biggerThan(x,y)_ in OWL, but we can introduce two new roles `R_elephant` and `R_mouse` and get the same result. — Joshua Taylor, Jun 07 '13 at 18:39
I see. I think I misunderstood how we define classes and properties. Thanks for your detailed explanation. — Yang, Jun 07 '13 at 18:44
@Yang Glad to help! Thanks for pointing out this paper, it's got a lot of useful stuff. I hadn't heard of "rolification" before, but it actually might pretty useful to me in the near future! — Joshua Taylor, Jun 07 '13 at 19:15

OWL 2 rolification

1 Answers1

Rolification

Axiom Syntax

Linked