When it comes to reification, the most obvious solution is RDF reification, but it seems OWL2 has its own vocabulary for that, I'd like to understand why. Let's take an example: if I have the following dataset (it's a tiny subset of the dataset we're using, which uses OWL):
@prefix : <http://purl.bdrc.io/ontology/core/> .
@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#> .
bdr:T123 a :Topic ;
rdfs:seeAlso bdr:T1129 .
I can reify and annotate the seeAlso statement with RDF like this:
_:b0 a rdf:Statement ;
rdf:subject bdr:T123 ;
rdf:predicate rdfs:seeAlso ;
rdf:object bdr:T1129 ;
rdfs:label "reification 1" .
But it's quite easy to find some examples (here, here, etc.) of things like:
_:b1 a owl:Axiom ;
owl:subject bdr:T123 ;
owl:predicate rdfs:seeAlso ;
owl:object bdr:T1129 ;
rdfs:label "reification 2" .
First question: my understanding is that the owl:subject,predicate,object are deprecated, is that so?
The other way to reify and annotate a triple with OWL seems to be:
_:b2 a owl:Axiom ;
owl:annotatedSource bdr:T123 ;
owl:annotatedProperty rdfs:seeAlso ;
owl:annotatedTarget bdr:T1129 ;
rdfs:label "reification 3" .
(it's what is used by Protege for instance) but I cannot understand the difference between the RDF reification+annotation and the OWL reification+annotation... Is the OWL way just a way to tell the reasoner not to take the reification into account? What are the other difference?
RDF reification provides a way to talk about a statement in RDF. The reification triples say that there is a resource of type statement that expresses what the RDF triple bdr:T123 rdfs:seeAlso bdr:T1129 says. Then you can add statements about this statement, regardless of whether the reified statement is true. For instance, you could say that the statement represents Akira's opinion, or that the statement is true between 1942 and 2017.
OWL 2 axiom annotations provide a way to add information about an axiom. The annotation says something about the axiom, not necessarily about what it expresses. For instance, it may say that the axiom was added to the ontology in October 2014, which does not mean that the statement holds in 2014. The OWL 2 annotation mechanism is defined according to the OWL 2 structural specification and functional-style syntax, where an axiom annotation is written like this:
AnnotationAssertion(
Annotation(rdfs:label "reification 1")
rdfs:seeAlso bdr:T123 bdr:T1129
)
Note that, in OWL 2, rdfs:seeAlso is defined as an annotation property, so the original assertion (bdr:T123 rdfs:seeAlso bdr:T1129) is itself an annotation assertion. As you should see, there is no reification here. As Ignazio said, the owl:annotated* terms only exists in the mapping to RDF graphs.
To make an analogy with programming, you can imagine a programme where one wants to manage programming instructions as first class citizens. For instance, if the programming language allows you to write:
MyClass.myMethod(param1,param2); // Instruction I1
And you want to have an in-memory structure for telling when such an instruction was executed, you could introduce a class that reifies instructions:
Instruction ins = new Instruction(...); // Construct Instruction I1
ins.setExecutionTime("2017-08-13T10:42:42");
This is analogous to RDF reification. Now, I could also say that the instruction was added to the code there by Béatrice. However, this is not saying something about the instruction per se, but about its occurence in the code. So it would be better expressed like so:
MyClass.myMethod(param1,param2); // this was added by Béatrice
This is analogous to an OWL 2 annotation.