Re: reifiesDomain-14 (Re: proposal: a reifier should reify only one "thing")

I am arguing that WITH reifiers they are, but if you understand the
distinctions in the models.

Here's a representation of the Neo4J model that Felix illustrated:

[image: Neo4J Model-2024-04-19-212552.png]

The rectangles are subject or objects, the stadia are properties. Note that
the same property seems to correctly identify that there were two distinct
intervals for the marriage, one open-ended.

A naive translation to RDF of this particular model may look like this:

[image: Naive RDF-2024-04-19-213559.png]
The reification as shown here shows the initial assertion (Liz married
Richard), but it can't resolve the to and from relationships properly,
because there was hidden information. That information was that there are
in fact two separate predicates that are masquerading as a single predicate
using the label name MARRIED.

[image: RDF Reifiers-2024-04-19-215306.png]
In this case, I actually have two predicates, married1 and married2, that
differentiate the relationships, but then I use the "MARRIED" label (having
the same value for both married1 and married2) as what would appear to be a
common property. You don't ever see the hidden predicates (by definition),
but they are nonetheless there because each intrinsic predicate in a
property graph is unique.  Once you realize this is going on, you can see
that Neo4J and RDF are compatible, and you don't end up with an explicit
requirement for a hypergraph. (Note that the same thing happens with the
endpoints Liz and Richard - internally, each creation statement creates a
unique identifier for the node with the label of Liz and Richard,
respectively, but in general, this isn't as problematic because the syntax
hides this distinction.

*Kurt Cagle*
Editor in Chief
The Cagle Report
kurt.cagle@gmail.com
443-837-8725 <http://voice.google.com/calls?a=nc,%2B14438378725>


On Fri, Apr 19, 2024 at 2:32 PM ddooss@wp.pl <ddooss@wp.pl> wrote:

> Hi Kurt,
>
> I don't fully understand your position.  You compare the formal RDF-star
> model to just one implementation which is Neo4j.  These things are not
> comparable.
>
> Best,
> Dominik
>
> Dnia 19 kwietnia 2024 22:42 Kurt Cagle <kurt.cagle@gmail.com> napisał(a):
>
> For creating data
>
> CREATE        (liz:Person {name: 'Liz'}), (richard:Person {name:
> 'Richard'})
>
> CREATE        (liz)-[:MARRIED {from: 1964, to: 1975}]->(richard)
>
> CREATE        (liz)-[:MARRIED {from: 1985}]->(richard)
>
>
>
> That does not bother them, and also not for querying the data
>
> MATCH (liz:Person {name: 'Liz'})-[m:MARRIED]->(richard:Person {name:
> 'Richard'})
>
> RETURN m.from AS StartYear, m.to AS EndYear
>
>
> Yes, but m:MARRIED is still a synonym for multiple (implicit) edge
> identifiers.
>
> I'm not saying that it should bother anyone on the LPG side. My argument
> is that to model it in RDF-Star, where there IS a distinction between the
> edge predicate and the reifier, requires that you recognize that what is
> depicted as one predicate in an LPG is actually an implicit mapping to
> multiple predicates in RDF.
>
> (liz)-[:MARRIED {from: 1964, to: 1975}]->(richard)
>
> is equivalent to:
>
> <<:married1 | :liz :married-1 :richard>> :from 1964; :to 1975  .
> <<:married2 | :liz :married-2 :richard>> :from 1985.
> :married1 rdfs:label ":MARRIED".
> :married2 rdfs:label ":MARRIED".
>
> If you just use a single :married predicate, you get
>
> <<:married | :liz :married :richard>> :from 1964; :to 1975 .
> <<:married | :liz :married :richard>> from: 1985.
>
> which creates the potential where you would end up retrieving:
>
> :married :from 1985; :to 1975 .
>
> which is clearly impossible
>
>
>
> *Kurt Cagle*
> Editor in Chief
> The Cagle Report
> kurt.cagle@gmail.com
> 443-837-8725 <http://voice.google.com/calls?a=nc,%2B14438378725>
>
>
> On Fri, Apr 19, 2024 at 1:11 PM Sasaki, Felix <felix.sasaki@sap.com>
> wrote:
>
> “The user usually doesn't see the predicate identifiers directly; they
> only see the label“
>
>
>
> For creating data
>
> CREATE        (liz:Person {name: 'Liz'}), (richard:Person {name:
> 'Richard'})
>
> CREATE        (liz)-[:MARRIED {from: 1964, to: 1975}]->(richard)
>
> CREATE        (liz)-[:MARRIED {from: 1985}]->(richard)
>
>
>
> That does not bother them, and also not for querying the data
>
> MATCH (liz:Person {name: 'Liz'})-[m:MARRIED]->(richard:Person {name:
> 'Richard'})
>
> RETURN m.from AS StartYear, m.to AS EndYear
>
>
>
> Best,
>
>
>
> Felix
>
>
>
> *Von: *Kurt Cagle <kurt.cagle@gmail.com>
> *Datum: *Freitag, 19. April 2024 um 21:53
> *An: *ddooss@wp.pl <ddooss@wp.pl>
> *Cc: *Pierre-Antoine Champin <pierre-antoine@w3.org>, Lassila, Ora <
> ora@amazon.com>, RDF-star WG <public-rdf-star-wg@w3.org>
> *Betreff: *Re: reifiesDomain-14 (Re: proposal: a reifier should reify
> only one "thing")
>
> >> This is actually an error that arises in LPGs, because they have no way
> of differentiating #marriage1 from #marriage3.
>
> > It's not true. Most PG definitions or implementations allow you to
> create two edges with the same label and different properties.
>
>
>
> I'm saying that this is a modelling error with LPGs.  The edge contains
> the identifier in the assertion, not the nodes. In an LPG (specifically
> Neo4J):
>
>
>
> (Liz marries Richard) [from 1964; to 1975]
>
> and
>
>
>
> (Liz marries Richard) [from 1985]
>
> are distinct because the predicate "marries" carries the (implicit)
> identifier, and any query is actually an query on the text of the labels.
>
>
>
> This is equivalent to
>
>
>
> <<:liz :marries-1 :richard>> [:from 1964 ; to: 1975] .
>
> <<:liz :marries-2 :robert>> [:from 1977 ; to: 1981] .
>
> <<:liz :marries-3 :richard>> [:from 1985] .
>
>
>
> :marries-1 rdfs:label "marries" .
>
> :marries-2 rdfs:label "marries" .
>
> :marries-3 rdfs:label "marries" .
>
>
>
> The user usually doesn't see the predicate identifiers directly; they only
> see the label, so they don't recognize that the first and third statements
> actually have different predicates with the same name. That is CERTAINLY
> the case for Neo4J; I'm not sure about other LPGs.
>
>
>
>
>
>
>
> *Kurt Cagle*
>
> Editor in Chief
>
> The Cagle Report
>
> kurt.cagle@gmail.com
>
> 443-837-8725
>
>
>
>
>
> On Fri, Apr 19, 2024 at 12:30 PM ddooss@wp.pl <ddooss@wp.pl> wrote:
>
> Kurt Cagle <kurt.cagle@gmail.com>:
>
> <<#marriage1 | :liz :marries :richard>> a :Event;
>
>        :bride :liz ;
>
>        :groom :richard ;
>
>        :startYear 1964 ;
>
>        :endYear 1975 ;
>
>        .
>
>
>
> This works in the case where Liz later marries Bob:
>
>
>
> <<#marriage2 | :liz :marries :robert>> a :Event;
>
>        :bride :liz ;
>
>        :groom :robert ;
>
>        :startYear 1977 ;
>
>        :endYear 1981 ;
>
>        .
>
>
>
> But gets into trouble when Liz and Richard decide to remarry:
>
>
>
> <<#marriage3 | :liz :marries :richard>> a :Event;
>
>        :bride :liz ;
>
>        :groom :richard ;
>
>        :startYear 1985 ;
>
>        .
>
>
>
> This is actually an error that arises in LPGs, because they have no way of
> differentiating #marriage1 from #marriage3.
>
>
>
> It's not true. Most PG definitions or implementations allow you to create
> two edges with the same label and different properties.
>
>
>
> Best,
>
> Dominik
>
>
>
>