Simple Format for Implicit Reification

Is there any RDF serialization format (like Notation 3) that supports implicit reification for easily representing statements about statements?

For example, say I have the statement "Mary bought a house", which I would represent in N3 like:

:Mary :bought-a :house .

Now say I wanted to add meta-statements about this statement, such as "I heard this from Rob."

Intuitively, I'd like to be able to represent this by writing something like:

:Mary :bought-a :house .
    :heard-by :me .
    :heard-from :Rob .

However, I think the way this would "officially" be represented in N3 would be something like:

[ a rei:Statement;
  rei:subject [rei:uri :Mary];
  rei:predicate [rei:uri :bought-a];
  rei:object [rei:value :house]
] [
    :heard-by :me;
    :heard-from :Rob;
] .

which is obviously a bit more complicated and harder to read. It gets even more complicated if I need to make statements about statements about statements. e.g. "I heard this from Rob, while Rob was walking down the street".

What would be the correct and simplest way to represent this in an RDF serialization format?

In RDF, there is no way to do this other than reification, as explained by harschware. In N3, you can use the following syntax to talk about a triple:

{ :Mary :bought-a :house }  :heard-by  :me;  :heard-from  :Rob .

It is also possible to say something like this using OWL 2 Axiom annotations:

:Mary  :bought-a  :house .
[]  a  owl:Axiom;
    owl:annotatedSource  :Mary;
    owl:annotatedProperty  :bought-a;
    owl:annotatedTarget  :house;
    :heard-by  :me;
    :heard-from  :Rob .

Note that in OWL 2 DL, you would have to put the triple :Mary :bought-a :house and to declare explicitly :heard-beand heard-from as owl:AnnotationProperty. In OWL Full, there is no such constraint. If you want to say that Mary did not buy a house and you heard this from Rob, you can use:

[]  a  owl:NegativePropertyAssertion;
    owl:sourceIndividual  :Mary;
    owl:assertionProperty  :bought-a;
    owl:targetIndividual  :house;
    :heard-from  :Rob .

Alternatively, you could use a format like N-Quads or TriG to write about the assertion. In N-Quads:

<[namespace]Mary> <[namespace]bought-a> <[namespace]house> <[namespace]tripleX> .
<[namespace]tripleX>  <[namespace]heard-by>  <[namespace]me> .
<[namespace]tripleX>  <[namespace]heard-from>  <[namespace]Rob> .

where [namespace] has to be replaced by the actual namespace because N-Quads does not handle @prefix. In TriG:

:G { :Mary  :bought-a  :house . }
:G  :heard-by  :me;
    :heard-from  :Rob .

With TriG, you name RDF graphs so you can make statements about multiple RDF statements.

For your interest, the W3C RDF Working Group is currently discussion about the next version of RDF and plans to include graph identification at the core of RDF. So, if you can be patient enough, you'll be able to express your needs in fully standard RDF in (hopefully!) 2013 (and even before if you count the public working drafts).

I'm interpreting the question as "which RDF serialisations have syntactic sugar for reification?"

My answers are:

I assume you are already aware of RDF Refication:

I guess I'm not sure how what you are asking is significantly different than what is already offered in RDF refication, and what you mean by implicit. Using the current mechanism this is how I would go about it.

_:xxx rdf:type rdf:Statement ;
  rdf:subject :Mary ;
  rdf:predicate :bought-a ;
  rdf:object :house ;
  :heard-by :me ;
  :heard-from :Rob .

It seems a fairly simple format to me.

For many applications you don't need to reify individual triples so much as you need to reify the projection of triples against some axis.

If you've got a few triples that "I heard from Rob", you can put these into a graph called


if you want, for just a moment, to believe everything Rob says, you can union this graph with your other graphs when you do a query. If you want to not believe what Rob says, leave the graph out. You might decide you trust some of his triples and don't trust others and materialize the ones you believe in another graph.

You can make RDF statements about the graph


to contextualize statements in the graph and control what your toolset does with them.