I'm playing with deriving instance type from its value information using value restrictions:
:SpaceMission rdf:type owl:Class .
:shuttleUsed rdf:type owl:ObjectProperty ;
rdfs:domain :SpaceMission .
:Apollo11 rdf:type owl:NamedIndividual .
:Mission11 rdf:type :SpaceMission , owl:NamedIndividual ;
:shuttleUsed :Apollo11 .
:ApolloMission rdf:type owl:Class ;
owl:equivalentClass [ rdf:type owl:Class ;
owl:intersectionOf ( :SpaceMission
[ rdf:type owl:Restriction ;
owl:onProperty :shuttleUsed ;
owl:hasValue :Apollo11
]
)
] .
The single value restriction owl:hasValue works fine and the SPARQL for type of :Mission11 returns :SpaceMission and :ApolloMission as expected. Then I add the second value restriction for definition of the class :ApolloMission:
:Apollo13 rdf:type owl:NamedIndividual .
:ApolloMission rdf:type owl:Class ;
owl:equivalentClass [ rdf:type owl:Class ;
owl:intersectionOf ( :SpaceMission
[ rdf:type owl:Restriction ;
owl:onProperty :shuttleUsed ;
owl:someValuesFrom [ rdf:type owl:Class ;
owl:oneOf ( :Apollo11
:Apollo13
)
]
]
)
] .
(The restriction type has automatically changed from owl:hasValue to owl:someValuesFrom). In this case the expected inference of type :ApolloMission for the individual :Mission11 is not returned, but only the :SpaceMission. Do I have something wrong? Or the the type inference is only possible with value restriction of type owl:hasValue?
I'm using Jena's OWLMicroReasoner and running the SPARQL query for
{<:Mission11> a ?type}. Maybe it is not able to infer from owl:someValuesFrom restriction. As I said the owl:hasValue restriction did work with Jena's micro reasoner. Does Jena's built-in reasoner support the owl:someValuesFrom restriction?
It's generally more helpful if you can provide an entire ontology that we can work with for testing. This one isn't too big, so it wasn't too hard to recreate. At any rate, I've reproduced it, and it's included at the end of this answer.
The inference is valid in OWL
The inference you're looking for is valid in OWL, and we can see that by using a logically complete OWL reasoner, e.g., Pellet. We'll see this in Protégé (but you could have used Pellet with Jena, too.) Here's what the ontology, recreated in Protégé look like:
Then, when we enable the Pellet reasoner and ask for instances of ApolloMission, we get Mission11, as expected:
Since you said you were asking for the types of Mission11, perhaps you used a query like asking for superclass of {Mission11}. This produces the expected classes, too:
Reproduced Ontology
Why you don't get some results with Jena's reasoners
Jena's reasoners are not complete. That doesn't mean that they're not finished; complete is a technical term in formal reasoning describing a reasoner (or algorithm, etc.) that means that there are correct inferences according to the semantics of the language that the reasoner won't produce. The reason that Jena's reasoners are incomplete has to do with the implementation strategy (using a rule-based reasoner), and with efficiency considerations (we can accept a trade-off between speed and the inferences that we can get).
For more about Jena's reasoners, you should look at Reasoners and rule engines: Jena inference support from the documentation. It's not entirely up to date though, as it says, for instance:
but as the following code shows, there is, in fact, support for
owl:oneOfin some of the reasoners, and so some of the reasoners can make the ApolloMission inference that you want.Jena provides a number of reasoners, and the easiest way to get an OntModel that is connected to them is by using the static OntModelSpecs that are declared in OntModelSpec. The following Java code shows that with the final ontology that you provided, the different reasoners provide different results. (The reflective code for getting the different OntModelSpecs is a bit hackish, but for a quick example, it's fine.) The code constructs an OntModel for each of the declared specs starting with "OWL_", and runs the query against them.
The output follows. Some of the reasoners can infer that Mission11 is an ApolloMission. These are the ones used by the specs:
OWL_MEM_RULE_INF,OWL_MEM_MINI_RULE_INF,OWL_DL_MEM_RULE_INF, andOWL_LITE_MEM_RULES_INF. It looks like you might want to stick to reasoners that haveRULEin the name.