Declaring both sub- and super-properties in instance data, or just sub- properties?

Question

If I have a simple ontology that includes a subproperty axiom:

ex:hasChair rdfs:subPropertyOf ex:hasParticipant .

I want to assert that "Paul Pill was the chair of the example conference, and Jack Jill was a participant in the example conference." Is it correct to write:

:exampleConference a ex:AcademicConference ;
                   ex:hasChair :paul_pill ;
                   ex:hasParticipant :jack_jill .

or do I also need to explicitly specify that Paul Pill was a participant (even though hasChair is a subproperty of hasParticipant)? That is, do I need to write:

:exampleConference a ex:AcademicConference ;
                   ex:hasChair :paul_pill ;
                   ex:hasParticipant :paul_pill, :jack_jill .

Answer 1

It very much depends on whether you'll have a reasoner or not when you're trying to retrieve data from your ontology. Saying that

hasChair ⊑ hasParticipant

is equivalent to the first-order formula:

∀x,y.(hasChair(x,y) → hasParticipant(x,y))

That means that it logically follows from hasChair(exampleConference,paulPill) that hasParticipant(exampleConference,paulPill). However, you'll need an OWL (or RDFS) reasoner to prove it for you if you only assert the hasChair sentence. If you assert both the hasChair and hasParticipant sentences, then you won't need a reasoner to find out that hasParticipant(exampleConference,paulPill).

A similar question was asked on the Jena users' mailing list recently about inverse properties.

If a have a functional/inverse-functional pair, should I createStatement both directions, or should I use some sort of inference device to fill in? I'm creating a lot of triples here, so I'm inclined to just make them myself for fear of a very slow traverse of a large model.

That is, if you had a property participatesIn, and it were the inverse of hasParticipant, the question is whether it's sufficient to assert

hasParticipant(exampleConference,paulPill)

or whether you should do both

hasParticipant(exampleConference,paulPill)
participatesIn(paulPill,exampleConference)

The answer is much the same: if you have a reasoner, then one is sufficient. If you don't, then you probably want both.