Re: voting against use of rdf:ReificationProperty

> On Sep 2, 2024, at 2:54 AM, Franconi Enrico <franconi@inf.unibz.it> wrote:
> 
> On 1 Sep 2024, at 23:09, Gregory Williams <greg@evilfunhouse.com> wrote:
> 
>> I’m not sure I follow the reasoning here, and perhaps I’ve been too terse in my example in previous messages. When you say "in a different standardised context,” what do you mean? I’m imagining a case where somebody wants to use RDF 1.0-style reification because they want to specifically make "statements about statements”. If they were to to model two different statements using the existing vocabulary for reification, they might get something like this:
>> 
>> # original two statements
>> <s> <p> “o” .
>> <x> <y> <<( <a> <b> <c> )>> .
>> 
>> # reification of those statements
>> _:a a rdf:Statement .
>> _:a rdf:subject <s> .
>> _:a rdf:predicate <p> .
>> _:a rdf:object "o" .
>> 
>> _:b a rdf:Statement .
>> _:b rdf:subject <x> .
>> _:b rdf:predicate <y> .
>> _:b rdf:object <<( <a> <b> <c> )>> .
>> 
>> # whatever "statements about those statements" the user wanted:
>> _:a <q> "some annotation" .
>> _:b <q> "some other annotation" .
>> 
>> I think this is perfectly reasonable, and I’m trying to understand what the reificationProperty proposal means for this example (or what value it brings). We would see that in this case `rdf:object rdf:type rdf:reificationProperty` (in addition to other entailments), and I’m not sure what (if any) impact that might have on the rest of the data.
> 
> OK,I guess that I now see where do you come from.
> So, If I understand well, your issue is somehow about backward compatibility.

Yes, but I don’t think it is *only* about backward compatibility. This problem will occur in any modeling that de-structures triples and breaks them apart into constituent parts. Old-style reification does that, but so do things like SPIN[1] where you might see a SPARQL triple pattern modeled as:

 [ sp:subject spin:_this ;
      sp:predicate ex:p ;
      sp:object <<( <s> <p> <o> )>>
    ]


> Namely: what happens to graphs using perfectly valid “old-style” reification together with RDF-star style reification (according to <https://github.com/w3c/rdf-star-wg/wiki/RDF-star-%22alternative-baseline%22>)?
> In the example above, there will be the entailments:
> rdf:object a rdf:reificationProperty.
> <y> a rdf:reificationProperty.
> 
>> I don’t think there is any "mistake in their model” here, which suggests to me that at least in some cases it is reasonable to have a property whose range includes both triple terms *and* non-triple terms. I’m interested here less in whether “both cases are fine,” and more in whether “both cases AT THE SAME TIME are fine” (and therefore whether it’s even right to talk about “WHICH one makes sense in their context”).
> 
> Note that the above happens only when you MIX old style reification with RDF-star style reification in the same graph.

As noted above, I don’t think that’s true.

> That is, you use old style reification (with rdf:object) for a triple which contains a triple term (which cannot happen in RDF-1.1).

If I were to try to replace "old-style" reification vocabulary with something new but equivalent (because we’ve hypothetically recommended against mixed-use), I’d probably end up like:

<statement> a my:Statement ;
  my:reifies <<( <s> <p> <o> )>> .

Do we agree that this might be reasonable (where in my domain, a my:Statement can only reify a single triple)?

If I wanted to explicitly break out the statement components, I might then add:

<statement> a my:Statement ;
  my:reifies <<( <s> <p> <o> )>> ;
  my:subject <s> ;
  my:predicate <p> ;
  my:object <o> .

And the minute I try to apply this pattern to reifying a statement with a triple term as an object, wouldn’t I be right back to the same issue? I’m not sure why or how we’d want to restrict people from doing this sort of modeling if it made sense in their domain.


> Clearly, you get bizzarre consequences, IMHO.

Can you expand a bit on this? What are the consequences here you think are bizarre?

> So, we need to state in the documentation of RDF-star that it is not advisable to use old style reification together with RDF-star style reification in the same graph - a perfectly reasonable request, I guess.

Given the examples above, I don’t know how much such a narrow recommendation would be useful. 

thanks,
.greg



[1] https://spinrdf.org <https://spinrdf.org/>