Re: Semantics TF: 'weak' transparency and entailments driven by reification

Thomas,
the whole point is that triple terms are NOT “asserted”, and this means exactly the following.
A triple term <<(:a :b :c)>> interprets :b to be a rdf:Property - in the same way as if :b would appear in property position in a top-level asserted triple, e.g., the top level asserted triple :d :b :e.
However, observe that, even if :b is of type rdf:Property, the following holds:

  *   if :b appears in property position in a top-level asserted triple then an “assertion” (via IEXT) is made between its subject :d and its object :e;
  *   if :b appears in property position in a triple term then an “assertion” (via IEXT) is NOT made between its subject :a and its object :c.

So, no entailment can hold involving triple terms, since a property in a triple term are void and do not say anything about its relation to its subject and its object.
By design, this semantics has been devised exactly to capture transparency but no entailments.
—e.

On 14 Jan 2025, at 14:04, Thomas Lörtsch <tl@rat.io> wrote:

Hi SemanticsTF-ers,


maybe someone has a moment to explain to me in more detail what is going on with entailments on reified triple terms (or rather the lack thereof) - because the revelation during the last Semantics TF meeting before christmas that triple term reifications don’t support entailment really came as quite a shock to me (both the fact itself and that I seem to have missed it for quite some time), and it took me some time to wrap my head around it. As it stands I’m pretty sure I disagree with what Dörthe and Niklas said about the subject, so we probably will need to discuss this (probably not this week, as we’re still discussing triple terms themselves, but soon-ish, and I always need some time to process these issues).


Niklas' example from the chat (https://www.w3.org/2024/12/20-rdf-star-minutes.html) was:

   :loves rdfs:subPropertyOf :knows .
   :a rdf:reifies <<( :bob :loves :sue )>> ;
       a :Lie .

   should not imply

   :a rdf:reifies <<( :bob :knows :sue )>> ;
       a :Lie .

At first sight this sounds convincing. However, the example uses some kind of negation which can be a tricky subject in itself, so let’s try something more middle-of-the-road and take an example that just adds more detail:

   :loves rdfs:subPropertyOf :knows .
   :a rdf:reifies <<( :Bob :loves :Sue )>> ;
       :since :CarolsBirthdayParty .

   should not imply

   :a rdf:reifies <<( :Bob :knows :Sue )>> ;
       :since :CarolsBirthdayParty .

By intuition, that seems more convincing. However, the intuition might rely on a closed world assumption: when we say (in RDF) that Bob knows Sue since 2023, we’re not saying he didn’t know here in 2022.  Is that contrived? When it comes to reasoning, "normal" intuitions do not always hold. So, I’m still not convinced.


What could be a more abstract description, what is "really" going on? It seems to me that the root of the problem is that the reifier refers to the more specific subtype, and - of course(!) - annotations on the subtype are not necessarily true of the supertype. This is also the case with standard triples. Take for example:

   <http://ex.org/GrumpyPerson>
       rdfs:subClassOf <http://schema.org/Person> ;
       a <http://ex.org/DifficultPerson> .

From that we wouldn’t entail that

    <http://schema.org/Person>  a <http://ex.org/DifficultPerson> .

because what we said about the more specific <http://ex.org/GrumpyPerson> doesn’t necessarily apply to the more general <http://schema.org/Person> - that is how sub classes are defined. On the other hand we know that everything that is true about a <http://schema.org/Person> is also true about an <http://ex.org/DifficultPerson>. Now let’s apply that to triple terms:

   :loves rdfs:subPropertyOf :knows .
   :a rdf:reifies <<( :Bob :knows :Sue )>> ;
       a :Lie .

   _should_ (at least by my intuition) imply

   :a rdf:reifies <<( :Bob :loves :Sue )>> ;
       a :Lie .

This seems to work, and I guess that's because it respects the flow direction of inheritance in subproperty relations. In other words: it looks like applying entailment on triple terms is not the problem per se, it must just not be applied the wrong way round.
Let’s check on the example that doesn’t rely on negation but just adds more detail:

   :loves rdfs:subPropertyOf :knows .
   :a rdf:reifies <<( :Bob :knows :Sue )>> ;
       :since :SuesBirthdayParty .

   should not imply

   :a rdf:reifies <<( :Bob :loves :Sue )>> ;
       :since :CarolsBirthdayParty .

And it doesn’t since :knows doesn’t entail :loves.

So, aren't we okay? What is the problem with entailing reified triple terms as long as we observe the proper direction of entailment? Or what am I missing?


Best,
Thomas