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.

Deodorize

The link to §3.2 is broken. 🙁 – Guglielmo

@JimL. Thanks. The link is updated. – Deodorize

Answer 1

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) ∧ 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) ∧ 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 • topObjectProperty • R_Mouse ⊑ 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.

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>

Hourglass

Thanks Joshua, but my problem is if OWL 2 supports rolification. I browsed through the language specification, but it did not mention that. – Deodorize

each of which is expressible in OWL2 - so how's it expressed in OWL 2? (I know it can be expressed in description logic) – Deodorize

@Deodorize 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. – Hourglass

@Deodorize "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. – Hourglass

I think hasSelf is not rolification. It is a restriction that produces a class from a property. w3.org/TR/owl2-syntax/#Self-Restriction – Deodorize

@Deodorize 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. – Hourglass

@Deodorize 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. – Hourglass

I see. I think I misunderstood how we define classes and properties. Thanks for your detailed explanation. – Deodorize

@Deodorize 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! – Hourglass