Re: voting against use of rdf:ReificationProperty

Hi Greg,

> On Sep 4, 2024, at 3:11 PM, Gregory Williams <greg@evilfunhouse.com> wrote:
> 
> 
> 
>> On Sep 3, 2024, at 4:37 AM, William Van Woensel <william.vanwoensel@gmail.com> wrote:
>> 
>> 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.
> 
> I think you’d have to pursue something like that in the SPIN case, but I don’t think it fully resolves the problem. In the example above, if we replace <o> with another triple term, so that in part it would be:
> 
> <statement> rdf:reifies <<( <s> <p> <<( <x> <y> <z> )>> )>> .
> 
> Then I think you’re suggesting the recursive breaking down of the my:object property, so that instead of:
> 
> <statement> my:object <<( <x> <y> <z> )>> .
> 
> You would have:
> 
> <statement> my:object <statement2> .
> <statement2> a my:Statement ; my:subject <x> ; … .
> 
> But that is different from what was said. <statement> is meant to reify a triple whose object is a triple term, but now it’s actually reifying a triple whose object is another reifier. That felt like it made more sense a long time ago before we went in the direction of reifiers that could reify multiple triples. If you had a 1:1 correspondence between a reifier and reified triple, I think I could understand making a substitution like this, because you’d just follow the reifier to its reified triple. But now it just feels like an entirely different statement (reification of a Wedding, for example, instead of a single fact about the wedding like `<<( :liz :married :Richard )>>` ).

Quick late night reply. I'm focusing on the following aspect (so I may be getting your overall problem wrong):

> If you had a 1:1 correspondence between a reifier and reified triple, I think I could understand making a substitution like this, because you’d just follow the reifier to its reified triple.


I believe the problem lies in the direct mapping between RDF 1.2 reification and your custom reification. In the former, reifiers have a many-to-many relation with triple terms, which is causing a "fan trap" here: i.e., when referring to a reifier such as <statement2>, you no longer know which triple term it was associated with, as it can be associated with any number of triple terms. (Sorry to bring up ER modelling; I believe there has been some discussion about this, but it was before my time though :-)

But, in your custom reification, you can do what you want; e.g., you could have a single <tt> (for triple term) instance to represent an RDF 1.2 reification:

<statement_1> rdf:reifies <<( <s> <p> <<( <x> <y> <z> )>> )>> . # RDF 1.2 reification

<tt_x> a my:TripleTerm # custom reification
 my:subject <s> ;
 my:predicate <p> ;
 my:object <tt_y> ;
 my:reifier <statement_1> ;
 my:reificationProperty rdf:reifies .

<tt_y> a my:TripleTerm
 my:subject <x> ;
 my:predicate <y> ;
 my:object <z> . 

Then you can have:
<statement_1> rdf:reifies <<( <a> <b> <c> )>> .
<statement_2> rdf:reifies <<( <s> <p> <<( <x> <y> <z> )>> )>> .

With e.g., 
<tt_z> a my: TripleTerm
 my:subject <a> ;
 my:predicate <b> ;
 my:object <c> ;
 my:reifier <statement_1> ;
 my:reificationProperty rdf:reifies .

Etc, without losing information, I think.

In hindsight - this "custom reification" is starting to look pretty close to an abstract syntax tree of your RDF 1.2 statements...


W

> 
> thanks,
> .greg
>