Re: voting against use of rdf:ReificationProperty

Hi Greg,


you can’t use triple terms in RDF 1.1, but you can reify reifications via triple terms in RDF-star, e.g.
    
    :r rdf:reifies <<( :s :p :o )>> ;
       :a :b .
    :q rdf:reifies <<( :r rdf:reifies <<( :s :p :o )>>  )>> ;
       :c :d .

Doesn’t that solve your problem?


And we probably should actively discourage mixing RDF standard reification and RDF-star reification, because not only does it make the property rdf:object an instance of class rdf:ReificationProperty (which is not thaaat problematic IMHO), but in addition to that the subject of an RDF standard reification becomes also an occurrence of the triple term in object position, and that seems pretty unwelcome to me. 
E.g.:

    :r rdf:reifies <<( :s :p :o )>> .
    :t a rdf:Statement ;
       rdf:subject :r ;
       rdf:predicate rdf:reifies ;
       rdf:object <<( :s :p :o )>> .

:t is now both a reification of ':r rdf:reifies <<( :s :p :o )>> .' (because of RDF 1.1 standard reification) and '<<( :s :p :o )>> ' (because rdf:object also acts as an RDF-star reification property).


But it shouldn’t surprise us too much that two different meta-modelling mechanisms can have strange and un-welcome interactions when applied to each other.


Best,
Thomas


> On 2. Sep 2024, at 21:38, 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
>