Re: voting against use of rdf:ReificationProperty

> On Sep 2, 2024, at 11:24 AM, William Van Woensel <william.vanwoensel@gmail.com> wrote:
> 
> 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 
>     ]

This isn’t the same thing. Your version would be a SPIN representation of:

?this ex:p << <s> <p> <o> >> .

Instead of:

?this ex:p <<( <s> <p> <o> )>> .

These are different patterns being encoded. I think I understand your point, but wonder if your understanding of the “intended use” would preclude using SPIN to model arbitrary query patterns like this?


> 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?)

I see your point, but this is NOT the same thing. Your rewrite is a reification of:

 <x> <y> << <a> <b> <c> ~ _:r >>

It is NOT the intended reification of:

<x> <y> <<( <a> <b> <c> )>>

If we’re moving to a model where many different reification properties can be used with triple terms, triples using those properties encode meaning beyond just associating a reifier with a triple term, and so I think it’s important to be able to talk about those statements directly. If we only allowed triple terms in statements with rdf:reifies as the predicate, then I think the reifier could probably be used in the way you describe (though the SPIN case might require some changes), but with arbitrary predicates, these triples *themselves* become important subjects of further annotation.

> 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?

I think I’d probably make a much stronger point: precluding the SPIN usage (and other examples like it) would *be a problem*.

thanks,
.greg