Re: voting against use of rdf:ReificationProperty

Hi Greg, Enrico,

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

 Ah yes, I had not understood the synthesis of the problem either. Thanks for clarifying.

>> 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.
> 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).
> Clearly, you get bizzarre consequences, IMHO.
> 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.

My two cents remain the same here. They will see "rdf:object" appearing as a ReificationProperty - a feature of RDF 1.2 - and _:a and _:b may be flagged as rdf:Statements - a feature of RDF 1.0-1, if those semantics are also implemented. Under RDF 1.2 semantics, inferring rdf:object as a reificationProperty simply explicates the implications of what is being said: in this case, rdf:object being used as a reificationProperty. The fact that the author is relying on old-style reification is not relevant IMO. Apologies if I'm still misunderstanding.

This may be a problem for them, or not. I agree that there is no mistake in their model, since there is no particular inconsistency (in contrast to e.g., OWL cardinality constraints being violated). Personally, I would likely not choose to model things that way, and it is certainly against the intended usage. 

I believe this is in line with the overall Semantic Web philosophy, at least as I have interpreted it. The implications of what is said are simply explicated, unless there is an explicit contradiction. E.g., when a subject occurs without the domain type of the property, RDFS explicates the implication of this, namely that the subject has said type. In OWL, when a functional property occur twice with different object IRIs, OWL explicates the implication, namely, these object IRIS should refer to the same resource (lack of unique name assumption). In both cases, you can add extra statements that would raise an inconsistency (owl:differentFrom, etc.). You could do the same with rdf:reificationProperty and certain sets of properties, if that is something you want to do. This permissiveness may not be in line with your needs (it has _very_ often bitten me), which is why we have things like SHACL. I believe this permissive nature is due to the open world assumption, but that is another discussion :-)


Thanks,

W

> 
> cheers
> —e.