Re: Understanding reifiers and edges

For the dual purpose of A) getting a better feel for many-to-many
reifiers in practice, and B) experimenting with annotation naming
syntax (see [1]), I just updated my TriG-star parser and RDF
visualizer to try out some of that. Here's a view of a TriG dataset
containing various examples:

    https://niklasl.github.io/ldtr/demo/?url=../test/data/reifiers-misc-m2m.trig&edit=true

(It's editable, just running in the browser with nothing persisted.
The editor area is toggled with the button in the bottom right
corner.)

This is also an example of how named graphs and m2m reifiers are
indeed orthogonal for, on the one hand, dataset partitioning, and on
the other, describing different kinds of situations and events which
underlie simple triples, including granular triple provenance.

Best regards,
Niklas

[1]: <https://github.com/w3c/rdf-star-wg/issues/116>





On Tue, Apr 23, 2024 at 10:42 PM Niklas Lindström <lindstream@gmail.com> wrote:
>
> 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 Wednesday, 24 April 2024 20:54:16 UTC