Re: voting against use of rdf:ReificationProperty

Hi Greg,

I will just reply here, if you don't mind. I think you raise a good point with SPIN. (Before, I got hyperfocused on mixing old and new style reification, which was perhaps a red herring to me.)

But, I think these examples do not correspond with the intended use of triple terms and reification properties, which is, at least as I understood it, as follows:

- Associate a reifier/identifier with a triple term, using a reification property.
- Then, use the reifier to describe the triple term (albeit as subject or object) in any subsequent triple.

E.g., in your example:

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

Under this intended use, would become:

_:r rdf:reifies <<( <s> <p> <o> )>> .

 [ sp:subject spin:_this ;
      sp:predicate ex:p ;
      sp:object _:r 
    ]

And in the prior example: 

>> _:b a rdf:Statement .
>> _:b rdf:subject <x> .
>> _:b rdf:predicate <y> .
>> _:b rdf:object <<( <a> <b> <c> )>> .

This becomes:

_:r rdf:reifies <<( <a> <b> <c> )>> .
_:b a rdf:Statement .
_:b rdf:subject <x> .
_:b rdf:predicate <y> .
_:b rdf:object _:r .

(I think this may address your final example as well?)

In your original examples, the flagging of rdf:object or sp:object as a reificationProperty still points out the problem: the "object" property is used to associate an identifier/reifier with a triple term, which is not the intention of these properties. (E.g., the outer blank node of the SPIN description should not be used to identify <<( <s> <p> <o> )>>.)

But, I think your point is that it should not be a problem. I'm unsure whether the rewritten examples mesh with your goal of breaking down triples?


W


> On Sep 2, 2024, at 1:23 PM, Gregory Williams <greg@evilfunhouse.com> wrote:
> 
> 
> 
>> 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/>
>