model Uncle using class restrictions

Question

I have been creating a toy ontology to further learn the Top Braid Composer tool when I hit an OWL modeling question. I figured out using restriction classes how to say when a Person is a Nephew. In the ontology below you can see a hasBrother property, which links a Parent instance to a Brother instance. hasBrother links a Person to a Brother. Tim hasParent Betty, and Betty hasBrother Lloyd. So, my restriction classes let me determine a Nephew from the hasParent and hasBrother links I just mention, so that when I run SPIN I can tell Tim is type Nephew. But I can't figure out how to state the inverse, and figure out that Lloyd is type Uncle. If you look at my Uncle class it is merely a subClass of Person at the moment.

  # baseURI: file:///SpinTest/spintest.owl
  # imports: http://spinrdf.org/spin

  @prefix :        <http://www.yarcdata.com/ontologies/SpinTest#> .
  @prefix owl:     <http://www.w3.org/2002/07/owl#> .
  @prefix rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
  @prefix rdfs:    <http://www.w3.org/2000/01/rdf-schema#> .
  @prefix spin:    <http://spinrdf.org/spin#> .
  @prefix xsd:     <http://www.w3.org/2001/XMLSchema#> .

  <file:///SpinTest/spintest.owl>
        rdf:type owl:Ontology ;
        spin:imports <http://topbraid.org/spin/owlrl-all> ;
        owl:imports <http://spinrdf.org/spin> .

  :Betty
        rdf:type _:b2 , _:b3 , :Parent ;
        :hasBrother :Lloyd .

  :Brother
        rdf:type owl:Class ;
        rdfs:subClassOf :Sibling .

  :Lloyd
        rdf:type :Brother .

  :Nephew
        rdf:type owl:Class ;
        rdfs:subClassOf :Person ;
        owl:equivalentClass _:b4 .

  :Parent
        rdf:type owl:Class ;
        rdfs:subClassOf :Person .

  :Person
        rdf:type owl:Class ;
        rdfs:subClassOf owl:Thing .

  :Sibling
        rdf:type owl:Class ;
        rdfs:subClassOf :Person .

  :Tim  rdf:type _:b4 , _:b5 , :Nephew , :Person ;
        :hasParent :Betty .

  :Uncle
        rdf:type owl:Class ;
        rdfs:subClassOf :Person .

  :hasBrother
        rdf:type rdf:Property ;
        rdfs:domain :Person ;
        rdfs:range :Brother .

  :hasParent
        rdf:type rdf:Property ;
        rdfs:domain :Person ;
        rdfs:range :Parent .

  :hasUncle
        rdf:type rdf:Property ;
        rdfs:domain :Person ;
        rdfs:range :Uncle .

  _:b4  rdf:type owl:Class ;
        owl:equivalentClass :Nephew ;
        owl:intersectionOf (:Person _:b5) .

  _:b5  rdf:type owl:Restriction ;
        owl:onProperty :hasParent ;
        owl:someValuesFrom _:b3 .

  _:b3  rdf:type owl:Class ;
        owl:intersectionOf (:Person _:b2) .

  _:b2  rdf:type owl:Restriction ;
        owl:onProperty :hasBrother ;
        owl:someValuesFrom :Brother .

Accepted Answer

Just do the same as for nephew, with the inverse properties. For nephew, you should have:

:Nephew  owl:equivalentClass  [
    owl:onProperty  :hasParent;
    owl:someValuesFrom  [
       owl:onProperty  :hasBrother;  # It should be sibling in fact
       owl:someValuesFrom  :Person
    ] .

It should be said that a nephew is male, but anyway. So for uncle:

:Uncle  owl:equivalentClass  [
    owl:onProperty  [ owl:inverseOf :hasBrother ];  # or :hasBrother if it's asserted to be symmetric
    owl:someValuesFrom  [
       owl:onProperty  [ owl:inverseOf :hasParent ]; # or :hasChild if it's defined
       owl:someValuesFrom  :Person
    ] .

But better in my opinion is to use property chains:

:hasUncle  owl:inverseOf  :hasNephew;   # disregarding gender issues
    owl:propertyChainAxiom ( :hasParent :hasBrother ) .

Still, you should do something about gender or use something neutral, like :hasUncleOrAunt, :hasNephewOrNiece, etc. Anyway, family relations are complicated ;)

model Uncle using class restrictions

Follow this question

Upcoming Events

Related questions