Making statements about statements which are no reified

Question

Forgive me if I\'m misusing some terms, I\'m just becoming familiar with RDF and reification in particular.

What I\'m trying to understand is if/how you can make a s

Answer 1

The newly proposed approach called singleton property is exactly what you need. This approach is formally described in this paper "Don’t like RDF Reification? Making Statements about Statements Using Singleton Property". http://www.slideshare.net/ntkimvinh7/www2014-singleton-propertyfinal

In your example, instead of using reification, the triple can be represented using the singleton property approach, such as

ex:elvis-presley ex:is-alive#1 "true"^^xsd:boolean .

ex:is-alive#1 rdf:singletonPropertyOf ex:is-alive .

If you want to dispute this fact, you can use the singleton property ex:is-alive#1 because it can be globally unique if you use a UUID, instead of #1.

Answer 2

I think that reification is a topic that initially seems more useful than it actually tends to be in practice. You can have a triple in a graph:

s p o .

and you can have four triples in a graph:

x a rdf:Statement .
x rdf:subject s .
x rdf:preficate p .
x rdf:object o .

but that's about it. If someone happens to have four triples of the second form, and x happens to be a URI, then then you write triples about x. If it's a blank node, then you don't have a way of referencing it. In either case, x is said to be a reification of the triple s p o. That means that the question

Can you only reify statements that are explicitly formed as identified resources in their own right?

doesn't make a whole lot of sense. The reificiation of a statement s p o is a resource x that has the associated properties. "To reify s p o" doesn't really mean anything except "pick an x, and assert the corresponding triples about it."

It's very unlikely that anyone trying to assert s p o would write the second form. The second form tends to arise if you're trying to represent some statements about triples, e.g., "john says x . x a rdf:Statement . …".

If you want to decry someone's claim that Elvis lives, you'd probably just do

:elvisLives a rdf:Statement ;
            rdf:subject ex:elvis-presley ;
            rdf:predicate ex:is-alive ;
            rdf:object true ;
            :claimedBy <http://example.org/whoeverSaidIt> ;
            :hasValue false .

Alternatively, if you're in the realm of OWL, you can use a negative property assertion:

NegativeDataPropertyAssertion( ex:lives ex:elvis-presley "true"^^xsd:boolean )

The RDF representation would look like

_:x rdf:type owl:NegativePropertyAssertion .
_:x owl:sourceIndividual ex:elvis-presley .
_:x owl:assertionProperty ex:lives .
_:x owl:targetValue true .

You can see a similarity between the two approaches. OWL includes a sort of reification vocabulary with its owl:sourceIndividual, owl:assertionProperty and owl:targetValue.