0

My task is to construct two classes in owl. The Base class describes resources that contain several properties e.g. p1, p2 and p3. The other class, the Sub, shall describe resources similar to the Base class with the restriction, that they do not contain one of its properties, e.g. p1, but only p2 and p3. For example, the class Car would describe vehicles that contains some properties and one of them is 'hasMotor'. The class Bicycle would also describe vehicles with the restriction, that they do not have motor.

I use cardinality restrictions to define such classes:

@prefix : <http://sample.org/test#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix xml: <http://www.w3.org/XML/1998/namespace> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@base <http://sample.org/test> .

<http://sample.org/test> rdf:type owl:Ontology ;                         
                         owl:versionInfo "0.2"^^xsd:string .


:p1 rdf:type owl:DatatypeProperty .
:p2 rdf:type owl:DatatypeProperty .
:p3 rdf:type owl:DatatypeProperty .

:Base rdf:type owl:Class ;
      rdfs:subClassOf [ rdf:type owl:Restriction ;
                        owl:onProperty :p3 ;
                        owl:someValuesFrom xsd:string
                      ] ,
                      [ rdf:type owl:Restriction ;
                        owl:onProperty :p2 ;
                        owl:someValuesFrom xsd:string
                      ] ,
                      [ rdf:type owl:Restriction ;
                        owl:onProperty :p1 ;
                        owl:someValuesFrom xsd:string
                      ] .


:Sub rdf:type owl:Class ;

     owl:equivalentClass [ rdf:type owl:Class ;
                           owl:intersectionOf ( :Base
                                                [ rdf:type owl:Restriction ;
                                                  owl:onProperty :p1 ;
                                                  owl:qualifiedCardinality "0"^^xsd:nonNegativeInteger ;
                                                  owl:onDataRange xsd:string
                                                ]
                                              )
                         ] .

But the Sub class is concluded by Pellet reasoner to be equivalent to Nothing. How should the two mentioned classes be described in owl?

igorbr
  • 35
  • 5
  • Classes don't have properties in OWL; it's not an object oriented programming language. properties may have domains and ranges, but the properties aren't tied to the classes in any sense. – Joshua Taylor Feb 06 '14 at 20:51
  • What "inference results [were] produced by Pellet reasoner" that didn't make sense? I've explained what the axioms mean in [my answer](http://stackoverflow.com/a/21613989/1281433), and why you get the subclass relationship that you do, but you didn't mention the particular results that you're curious about, so I don't know whether we've addressed them or not. – Joshua Taylor Feb 06 '14 at 21:05
  • I modified the original text – igorbr Feb 06 '14 at 22:20
  • The new text is rather different from the original text. I'll reiterate though; properties don't belong to classes. Logical implications are "inherited". If you say that a Vehicle has at least two wheels and then define Unicycle as a subclass of vehicle and say that it has exactly one wheel, then Unicycle is going to be equivalent to owl:Nothing, because it can't have any instances (because nothing can have at least two wheels *and* exactly one wheel). The explanation I gave in my answer still holds. – Joshua Taylor Feb 07 '14 at 02:05

1 Answers1

4

What the axioms mean…

But I cannot understand the inference results produced by Pellet reasoner. The restriction on the existence of the property seems not to work. How can I define such a class?

You haven't said what the inference results that Pellet produces are, so it's hard to explain them in particular. But, we can still take a look at what your axioms are saying. OWL classes are really like sets, and the restrictions that you're defining are making assertions about the elements of those sets. When you say, for instance, that

Base &sqsubseteq; ∃prop.String

What you're saying is that

1. If some x is a Base, then there is some String s such that prop(x,s).

Now, you have two more axioms:

Sub &sqsubseteq; Base
Sub &sqsubseteq; =0 prop.String

These say that

2. If some x is a Sub, then x is also a Base.
3. If some x is a Sub, then there are exactly zero Strings s where prop(x,s).

…and why Sub is a subclass of everything else.

Moreover could you please explain why the Sub class is inferred to be a subclass of ObjProp.

Your ontology isn't inconsistent, but you do have the typically undesirable state of affairs that one of your classes, Sub, can't have members. Why is this the case? Well, suppose some x is a Sub. Then, because x is a Sub, it has exactly zero strings. Of course, every Sub is also a Base, so x is also a Base. Since it's a Base, then it must have at least one string. It can't have zero and at least one, so we can't actually have any instances of Sub. Since Sub is the empty class (i.e., equivalent to owl:Nothing) it's a subclass of every other class.

Joshua Taylor
  • 84,998
  • 9
  • 154
  • 353
  • 1
    Correct analysis. I would add, as suggestions for repair: first, Base and Sub do not strike me as classes that should be subclass of each other, but maybe subclasses of a common superclass, which is equivalent to the common restrictions. Base would then add (some p3 xsd:string) and Sub would have (0 p3 xsd:string) as extra restrictions. Second, Sub should not be defined /equivalent/ to the definition to use. Defining classes by equivalence is often tricky in the way shown in this example - I've seen it cause unintended and difficult to understand inferences quite often. – Ignazio Feb 07 '14 at 07:20