Understanding reifiers and edges

For Thursday's discussion it would be great if those who can to take
some time, especially those favoring "edge properties", to look at
various definitions and patterns for reification using many-to-many
notions (including such patterns for N-ary relations, like [1]).
Enrico has mentioned many formal references. Here is just a short one
in UML: [2]. (We've also given several examples on the list
(marriages, book collaborations, pipe connections); but I think formal
definitions may be more convincing to those who remain unperturbed.)

I also tried to see things more from the LPG perspective. We already
know that the edges in LPGs are not identified by their vertices and a
label, but by a unique id. Enrico has pointed to this more than once,
and it was recently very clearly illustrated by Kurt in [3].
(Otherwise, if they were just the two vertices and the edge label,
that would simply be the seminal mistake all over again; preventing
the entire point of distinguishing edge properties. Something Kurt
also illustrated as the "naive" approach [4] (which I readily concur
with).)

This actually makes edge properties *very* similar to singleton
properties [5]. A pattern that has been dismissed for multiple reasons
(e.g. [6]). But in fact, at least Neo4J refers to the label of edges
as their *types*. And that is exactly how singleton properties are
explained in the aforementioned paper (their proposed
`rdf:singletonPropertyOf` is defined as a subproperty of `rdf:type`).
(This similarity is also shared by RDFn (named triples), as Thomas
pointed out quite some time ago [7].)

I continue to favour many-to-many reifiers, as they appear more
intuitive to me. Simple relationships, as abstracted using triples,
always stem from something more concrete and/or detailed, that reify
them in some way. Depending on which perspective and distance that
reifier is conceptualized from, one or more triples will be naturally
reified. I find it *harder* to rely on an a priori domain-restrictive
notion of an edge as a slightly more "instantiated" relationship of
the same "type" as a simple predicate. I found it odd when I first
encountered Neo4J over a decade ago, and I still find it constrained
by implementation (or *perhaps* representation), rather than reason. I
can see cases for it (ex:MarriedToDirectedEdge), cases beneath it
(ex:TripleToken), and cases clearly beyond it (ex:DescriptionIngest,
ex:CataloguerSuggestion, ex:Marriage, ex:BookCollaboration,
ex:TJunctionConnection). Using rdf:reifies to link from an instance of
any of those concepts to one or more triples simply works for all such
cases alike.

And yes, in *some* of them making an OWL restriction on the
cardinality for rdf:reifies to have an effectively functional
*semantic* behavior for some specific class is perfectly fine. But not
built-in to RDF proper. (And, to also answer Dörthe, absolutely not as
a syntactic restriction; but I don't think anyone is asking for that?)

(For fun I also checked with a certain famous, pretrained neural
network, asking: "In conceptual modeling, can one single reification
reify multiple simple relations?", and got: "Yes, in conceptual
modeling, it's possible for a single reification to reify multiple
simple relations. Reification is the process of representing abstract
concepts or relationships as concrete entities or objects.", along
with yet another example: an Assignment reifying the two relations X
workedOnProject P and X aquiredSkill Y. I leave it to you to determine
how much of a hallucination that was.)

Best regards,
Niklas

[1]: <https://www.w3.org/TR/swbp-n-aryRelations/#useCase3>
[2]: <https://d37djvu3ytnwxt.cloudfront.net/assets/courseware/v1/947b66081249d2aa46671a9f04b8503a/asset-v1:KULeuvenX+UMLx+1T2017+type@asset+block/UMLx_6b_AssociationReification.pdf>
[3]: <https://lists.w3.org/Archives/Public/public-rdf-star-wg/2024Apr/0134.html>
[4]: <https://lists.w3.org/Archives/Public/public-rdf-star-wg/2024Apr/att-0134/Naive_RDF-2024-04-19-213559.png>
[5]: <https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4350149/>
[6]: <https://graphdb.ontotext.com/documentation/9.4/free/devhub/rdf-sparql-star.html#singleton-properties>
[7]: <https://lists.w3.org/Archives/Public/public-rdf-star-wg/2022Dec/0029.html>

Received on Tuesday, 23 April 2024 20:43:16 UTC