猫头鹰物化与rdf物化

Question

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?

Answer 1

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.

Answer 2

I believe that owl:{subject,predicate,object} reflected an early proposal for the URIs for these RDF properties. They were never part of any specification so while not officially deprecated, they are not used. The owl:annotated{Source,Property,Target} URIs are the ones in the official spec Ignazio links to.

The fact that we have two vocabularies (RDF, OWL2) for reification is unfortunate but deemed necessary by the OWL2 spec developers. There are some other differences - eg OWL reified axioms must be blank nodes.

Answer 3

The owl annotation you've shown is only for annotations on axioms in RDF, as described here: https://www.w3.org/TR/owl2-mapping-to-rdf/

Reasoners are unaware of reified statements, as this reification is a syntactic workaround for RDF only - other syntaxes do not reify axioms in order to annotate them, or to nest annotations. (Having spent some time debugging the OWLAPI code that deals with nested annotations, I would like to express my gratitude to the authors of those syntaxes where nesting annotations is straightforward).

I am not aware of owl:annotated* properties being deprecated. They're part of the current OWL2 to RDF mapping.