Re: voting against use of rdf:ReificationProperty

Hi Greg,

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


You make a good point: IIUC, in case of reificationProperty, there is a need to break up _reification statements_ themselves, since the property then provides extra information. And, that currently leads to unintended consequences, such as the "meta-property" rdf:object / sp:object / ... being inferred as a reificationProperty; and the statement's resource being treated as a reifier/identifier for its triple term component.

My only solution at this point would be to further break up the triple term as well (which I believe you propose as well):

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

To cope with the fact that <o> may be a nested triple term, this breaking down would have to be applied recursively.

At least personally, I wouldn't see this as a major problem, since it also allows one to more easily introspect the triple term, i.e., using its individual components. This meta-modelling aspect could be a note in the recommendation.


W

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