weighted RDF predicate (owl:ObjectProperty)

Question

in RDF a statement is represented with S,P and O; In OWL the owl:ObjectProperty represents the predicate logic.

 (S) (P) (O)   
  I like dog

<owl:Class rdf:about="Person" />
<owl:NamedIndividual rdf:about="I">
    <rdf:type rdf:resource="Person"/>
    <like rdf:resource="Dog"/>
</owl:NamedIndividual>

<owl:Class rdf:about="Pet" />
<owl:NamedIndividual rdf:about="Dog">
    <rdf:type rdf:resource="Pet"/>
</owl:NamedIndividual>

<owl:ObjectProperty rdf:about="like">
    <rdfs:domain>
        <owl:Restriction>
            <owl:onProperty rdf:resource="like"/>
            <owl:someValuesFrom rdf:resource="Person"/>
        </owl:Restriction>
    </rdfs:domain>
    <rdfs:range>
        <owl:Restriction>
            <owl:onProperty rdf:resource="like"/>
            <owl:someValuesFrom rdf:resource="Pet"/>
        </owl:Restriction>
    </rdfs:range>
</owl:ObjectProperty>

But how about to describe "the degree" I like dogs? How can I give a property or value to a predicate? One solution I got is to extend one (S,P,O) statement to 3 statements. For example,

(S)             (P)        (O) 
 Person       isSrcOf    LikeRelation
 Pet          isTargetOf LikeRelation
 LikeRelation hasValue   [0~100]

It should work but obviously it will let ontology 3 times bigger :(

I appreciate any suggestion!

Answer 1

I wouldn't use RDF reification, not in this case and almost not in any case. RDF reification just makes the things always more complicated. As you commented it will inflate your ontology, but not just that, it'll also make your ontology very difficult for applying OWL reasoning.

I've dealt with the same scenario that you've presented and most of times I've ended up with the following design.

(S) (P) [ (P) (O) (P) (O)]
I like [ 'what I like' Dog , 'how much I like it' 'a lot']

Class: LikeLevel //it represents class of things a person likes with a degree factor.

ObjectProperty: likeObject
    Domain: LikeLevel
    Range: Pet //(or Thing)

ObjectProperty: likeScale
    Domain: LikeLevel
    Range: xsd:int //(or an enumeration class i.e: 'nothing', 'a bit', 'very much',...)

ObjectProperty: like
    Domain: Person
    Range: LikeLevel

If you want to represent some instance data with this model (in RDF/Turtle syntax):

:I :like [ a :LikeLevel; 
   :likeObject :dogs;
   :likeScale 5.7] . 

In this case I'm creating a blank node for the object LikeLevel but you could create a ground object as well, sometimes you might want/need to avoid bNodes. In that case:

:I :like :a0001 .
:a0001 a :LikeLevel; 
   :likeObject :dogs;
   :likeScale 5.7.

This design can be consider a light case of reification, the main difference with RDF reification is that keeps the ontology design in the user's model.

Answer 2

Your suggestion is a valid one; it is called reification and is the standard way of representing properties inherent to a relationship between two items in an ontology or RDF graph, where statements are made in a pairwise manner between items - it is a limitation of the data model itself that makes reification necessary sometimes.

If you're worried that reification will inflate your ontology, you could try the following instead, but are generally less desirable and come with their own problems:

1. Create specific properties, such as somewhatLikes, doesntLike, loves; this may be suitable if you have a limited set of alternatives, and don't mind creating the extra properties. This becomes tedious and cumbersome (and I'd go so far as to suggest incorrect) if you intend to encode the 'degree of likeness' with an integer (or any wide range of alternatives) - following this approach, you'd have properties like likes0, likes1, ..., likes99, likes100. This method would also preclude querying, for example, all dogs that a person likes within a range of degree values, which is possible in SPARQL with the reification approach you've specified, but not with this approach.
2. Attach the likesDogs property to the Person instance, if the assertion can be made against the person onto all types/instances of Dog, and not individual instances. This will, of course, be dependent of what you're trying to capture here; if it's the latter, then this also won't be appropriate.

Good luck!

Answer 3

I think @msalvadores gets it wrong.

Let's forget about the dogs and likes. What we are really doing here is:

a x b
axb y c
axb z d

where axb is the identifier of the a x b statement, a, b, c, d are subjects or objects and x, y, z are predicates. What we need is binding the a, x, b resources to the axb statement somehow.

This is how reification does it:

axb subject a
axb predicate x
axb object b

which I think is very easy to understand.

Let's check what msalvadores does:

:I :like [ a :LikeLevel; 
   :likeObject :dogs;
   :likeScale 5.7] . 

we can easily translate this to axb terms

a x w
w type AxbSpecificObjectWrapper
w object b
w y c

which is just mimicking reification with low quality tools and more effort (you need a wrapper class and define an object property). The a x w statement does not makes sense to me; I like a like level, which objects are dogs???

But how about to describe "the degree" I like dogs?

There are 2 ways to do this as far as I can tell with my very limited RDF knowledge.

1.) use reification

stmt_1
    a LikeStatement
    subject I
    predicate like
    object dogs
    how_much "very much"

2.) instantiate a predicate class

I like_1 dogs
like_1
    a Like
    how_much "very much"

It depends on your taste and your actual vocab which one you choose.

How can I give a property or value to a predicate?

I don't think you understand the difference between a predicate and a statement. A great example about it is available here: Simple example of reification in RDF

Tolkien wrote Lord of the rings
Wikipedia said that

The statement here:

that: [Tolkien, wrote, LotR]

If we are making statements about the statement, we write something like this:

[Wikipedia, said, that]

If we are making statements about the predicate then we write something like this:

[Wikipedia, said, wrote]

I think there is a big difference. Reification is about making statements about statements not about predicates...

Answer 4

A sentence from Jena's document just catch my eye.

...OWL Full allows ... state the following .... construction:

<owl:Class rdf:ID="DigitalCamera">
  <rdf:type owl:ObjectProperty />
</owl:Class>
..

does OWL Full really allow an ObjectProperty be a Class as well? If an ObjectProperty could be a Class, and could have individuals then I could describe a statement with

S_individual P_individual O_individual

and I could have further properties on P_individual. Is it right? or am I missing some points?

since the following RDF is valid, a corresponding OWL should be achievable.

<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:j.0="http://somewhere/" > 

  <rdf:Description rdf:about="http://somewhere/Dog_my_dog">
    <j.0:name>Lucky</j.0:name>
  </rdf:Description>
  <rdf:Description rdf:about="http://somewhere/like_dog">
    <j.0:degree>80</j.0:degree>
  </rdf:Description>

  <rdf:Description rdf:about="http://somewhere/Cat_my_cat">
    <j.0:name>Catty</j.0:name>
  </rdf:Description>
  <rdf:Description rdf:about="http://somewhere/like_cat">
    <j.0:degree>86</j.0:degree>
  </rdf:Description>

  <rdf:Description rdf:about="http://somewhere/Person_I">
    <j.0:name>Bob</j.0:name>
    <j.0:like_dog rdf:resource="http://somewhere/Dog_my_dog"/>
    <j.0:like_cat rdf:resource="http://somewhere/Cat_my_cat"/>
  </rdf:Description>

</rdf:RDF>