13:47:41 <RRSAgent> RRSAgent has joined #rdf-star
13:47:46 <RRSAgent> logging to https://www.w3.org/2024/04/19-rdf-star-irc
13:47:46 <Zakim> Zakim has joined #rdf-star
13:48:29 <TallTed> Meeting: RDF-star WG - Semantics Task Force
13:48:44 <TallTed> RRSAgent, draft minutes
13:48:45 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
13:48:52 <TallTed> RRSAgent, make logs public
13:49:19 <TallTed> previous meeting: https://www.w3.org/2024/04/18-rdf-star-minutes.html
13:49:19 <TallTed> next meeting: https://www.w3.org/2024/04/25-rdf-star-minutes.html
13:50:23 <gkellogg> gkellogg has joined #rdf-star
13:52:56 <TallTed> scribe: ?scribe?
13:52:56 <TallTed> chair: ?chair?
13:53:14 <TallTed> RRSAgent, draft minutes
13:53:15 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
13:54:38 <TallTed> topic: Continuing discussion: is rdf:reifies functional or not?
13:58:03 <niklasl> niklasl has joined #rdf-star
14:00:35 <pchampin> hi all, I will be ~30 minutes late, apologies
14:02:00 <enrico> enrico has joined #rdf-star
14:02:05 <enrico> present+
14:02:18 <TallTed> present+
14:02:23 <fsasaki> fsasaki has joined #rdf-star
14:02:41 <tl> tl has joined #rdf-star
14:02:43 <TallTed> RRSAgent, draft minutes
14:02:45 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
14:04:40 <gkellogg> gkellogg has joined #rdf-star
14:05:06 <doerthe> doerthe has joined #rdf-star
14:06:36 <gkellogg> present+
14:06:45 <enrico> enrico has joined #rdf-star
14:06:51 <enrico> present+
14:06:58 <tl> present+
14:07:26 <TallTed> agenda: https://www.w3.org/events/meetings/6d0cd306-0be8-4267-865a-6272cc8d9da4/20240419T100000/
14:07:27 <agendabot> TallTed, sorry, I did not recognize any agenda in https://www.w3.org/events/meetings/6d0cd306-0be8-4267-865a-6272cc8d9da4/20240419T100000/
14:07:47 <TallTed> RRSAgent, draft minutes
14:07:48 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
14:09:30 <doerthe> present+
14:09:45 <Souri> Souri has joined #rdf-star
14:09:52 <Souri> present+
14:12:24 <AndyS> AndyS has joined #rdf-star
14:12:47 <tl> q+
14:14:49 <enrico> q?
14:14:55 <TallTed> ack tl
14:16:06 <niklasl> niklasl has joined #rdf-star
14:16:15 <niklasl> present+
14:17:22 <Souri> q+
14:17:34 <doerthe> q+
14:19:01 <enrico> q+
14:20:50 <fsasaki> q+
14:21:05 <niklasl> tl: can LPG object attributes be annotated?
14:21:06 <fsasaki> q-
14:21:06 <enrico> q-
14:21:39 <doerthe> yes souri said
14:21:41 <niklasl> Souri: true
14:22:05 <enrico> q?
14:22:13 <enrico> ack souri
14:22:53 <niklasl> Souri: lots of differences between LPGs and RDF; attributes is one. The edge has the same restriction (cannot link edges).
14:23:38 <niklasl> ... but RDF lacks the edge property feature
14:24:00 <niklasl> ... but we obviously cannot restrict RDF 1.2 to what LPGs do
14:24:01 <niklasl> q+
14:25:27 <enrico> q+
14:25:49 <niklasl> ... I completely agree on many-to-many, but I see two shortcomings; one reifier for two terms, but I may still want to have describe triple terms. Also, do statements about a "to-many" reifier apply to each, or to the reifier
14:26:19 <enrico> q?
14:26:26 <TallTed> RRSAgent, draft minutes
14:26:27 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
14:27:01 <TallTed> s/ ?scribe?/ niklasl/
14:27:18 <TallTed> RRSAgent, draft minutes
14:27:19 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
14:28:53 <tl> q+
14:29:08 <AndyS> q?
14:29:22 <niklasl> ... overall, many-to-many is fine, but we need to adress and document handling for these shortcomings
14:29:30 <enrico> ack doerthe
14:29:58 <niklasl> doerthe: [aside] any good introduction to LPGs?
14:30:31 <niklasl> enrico: there is a new guide to the upcoming LPG standard (the GQL standard arrived yesterday - 600 pages)
14:31:19 <niklasl> doerthe: the only way to make the many-to-one relationship is to go back to referential opacity
14:31:47 <enrico> q?
14:32:12 <niklasl> ... we can define a property graph shape to define the LPG restrictions
14:32:37 <TallTed> s/ ?chair?/ enrico/
14:32:41 <enrico> The paper summarising LPGs: https://drops.dagstuhl.de/storage/00lipics/lipics-vol255-icdt2023/LIPIcs.ICDT.2023.1/LIPIcs.ICDT.2023.1.pdf
14:33:32 <doerthe> thank you enrico
14:33:39 <Souri> From my earlier posting:
14:33:39 <Souri> Following are some of the issues I see with multi-valued (i.e., many-to-many) rdf:reifies:
14:33:39 <Souri> 1) a single reifier cannot associate with two identical triple-terms (needed for parallel edges), and
14:33:39 <Souri> 2) creates a confusion regarding whether the annotations hanging from the single reifier applies to every triple-term individually or only to the set of triple-terms as a whole.
14:33:40 <Souri> My feeling is that It is important to be able to be able to hang annotations  independently:
14:33:40 <Souri> 1) to individual triple-terms, and
14:33:40 <Souri> 2) to a mutli-set of triple-terms as a whole.
14:34:53 <TallTed> RRSAgent, draft minutes
14:34:54 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
14:35:39 <enrico> q?
14:35:43 <pchampin> q+
14:35:45 <enrico> ack nikasl
14:35:57 <enrico> ack nicklasl
14:36:06 <TallTed> ack niklasl
14:36:10 <enrico> ack niklasl
14:38:46 <TallTed> ack enrico
14:39:04 <pchampin> +1
14:39:07 <niklasl> enrico: there is a confusion between the reifier and the triple term
14:39:52 <niklasl> ... the same triple can be reified in many ways, both as a marriage or the utterance of the triple
14:40:12 <niklasl> ... in either case, you attach the property to the *reifier*
14:40:38 <Souri> q+
14:40:44 <niklasl> ... in the case of a many-to-one edge annotation, create a new reifier for that
14:40:50 <doerthe> problem could be that this is not closed?  Not sure
14:41:48 <niklasl> ... "John married Sue; *it* happened in May; and *it* was said yesterday". The *it* here are two different reifiers, with different types and different properties.
14:42:06 <enrico> ack tl
14:42:50 <niklasl> tl:  If you have a reifier for many triples and you want to say more about one of those, do you have to rewrite your queries?
14:42:55 <niklasl> ... can we reify reifiers?
14:43:24 <niklasl> ... to speak about all three reifers?
14:43:27 <doerthe> but why? I could also do that more directly
14:43:47 <niklasl> <niklasl> Agreed (I i think)
14:44:04 <niklasl> <niklasl> (agreed with Dörthe)
14:44:17 <TallTed> ack pchampin
14:44:31 <TallTed> RRSAgent, draft minutes
14:44:32 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
14:44:48 <niklasl> pchampin: Something niklasl said, how do I know that the triple is reified by the marriage?
14:44:49 <niklasl> q+
14:45:29 <niklasl> ... you can reifiy the statement twice, once as a marriage and once as a statement
14:45:37 <niklasl> <niklasl> Yes, exactly.
14:46:02 <enrico> q?
14:46:07 <niklasl> <niklasl> declare rdfs:domain on the properties you describe reifiers with and you don't have to type them explicitly.
14:46:12 <enrico> ack Souri
14:46:43 <pchampin> q+
14:46:47 <niklasl> Souri: a document has sentences, paragrapghs, sections, chapters I  think of these [...]  as a paragraph.
14:47:32 <niklasl> ... we can have a sequence of sentences. I want to speak about each sentence, and also about the paragraph itself.
14:47:42 <niklasl> ... And model that using RDF.
14:47:56 <fsasaki> present+
14:50:07 <niklasl> ... with a collection of sentences as a paragraph [...] I lose the ability to talk about each sentence. With a member relationship I can have each sentence and the paragraph as a [ordered] collection of those
14:50:40 <TallTed> RDF is pretty far removed from natural language. RDF (especially if you add RDFS and/or OWL) is much closer to first-order-logic.
14:50:43 <niklasl> <niklasl> Yes, and that's OK. But it's *fundamentally* different from the reification of a marriage.
14:50:52 <tl> @Souri of course, but it will in general be considered too cumbersome
14:51:10 <AndyS> present+
14:51:10 <niklasl> +1 to TallTed re. natural language / RDF /  first-order-logic
14:51:38 <enrico> -1 to TallTed re NL vs RDF
14:51:44 <enrico> q?
14:51:50 <niklasl> q-
14:52:01 <tl> @Souri that's why I asked for nesting reifiers, i.e. reifying reifications. that could be done when needed and omitted otherwise
14:52:06 <niklasl> Souri: My motivation is no not lose that.
14:52:10 <enrico> q+
14:52:20 <niklasl> s/that\/that ability./
14:52:45 <niklasl> pchampin: Ora is asking about the many to many case; how to explain this easily.
14:53:01 <niklasl> ... I think the right way to explain this is to explain it per reifier type.
14:53:42 <niklasl> ... and then we explain "I can do this for that"
14:53:44 <enrico> q?
14:53:47 <enrico> q-
14:54:19 <enrico> q+
14:54:27 <enrico> ack pchampin
14:54:33 <niklasl> ... second point; let's not fortitiously use rdf:reifier when we actually *want* a set of reifier.
14:54:49 <tl> so should we define an "rdf:edgeOf" as ubproperty of rdf:reifies, with range cardinality 1 ?
14:54:57 <niklasl> ... Define a paragraph property ex:hasSentence
14:55:16 <niklasl> ... let's not pretend everything is related using rdf:reifier
14:55:55 <niklasl> ... Also, using many-to-many to represent a graph is not enough, it has inference problems.
14:56:08 <doerthe> q+
14:56:10 <niklasl> [see pchampin:s email]
14:56:36 <niklasl> [or perhaps wait until an amendment]
14:56:42 <tl> and another subproperty "graphOf"?
14:56:50 <doerthe> q-
14:57:07 <doerthe> (I wanted to complain about the example :D )
14:57:12 <niklasl> enrico: a triple term only denotes itself, not "the statement"
14:57:14 <pchampin> s/[see pchampin:s email]/https://lists.w3.org/Archives/Public/public-rdf-star-wg/2024Apr/0096.html
14:57:38 <TallTed> RRSAgent, draft minutes
14:57:39 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
14:58:09 <niklasl> ... if sentences are things that you can utter, create a list of those reifiers. The sentences are the reifiers of triples.
14:58:12 <Souri> q+
14:58:41 <enrico> ack enrico
14:59:08 <AndyS> ack souri
14:59:28 <pchampin> q+
14:59:33 <TallTed> s/"s/that\/that ability./"/""/
14:59:34 <TallTed> s/motivation is no not lose that/motivation is to not lose that ability/
14:59:39 <TallTed> RRSAgent, draft minutes
14:59:41 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
14:59:47 <niklasl> Souri: When I see a multivalued reifier it seems to create a box (???) ; but perhaps there is a mismatch here?
15:00:08 <tl> q+
15:01:08 <niklasl> ... a convention to hang from the reifier if it is a box
15:01:55 <niklasl> ... I'm quite OK with the many-to-many, I don't see the necessity to explain that to people who only want to do LPG style modelling  it
15:02:04 <niklasl> s/modelling  it/modelling/
15:02:21 <TallTed> s/"s/that\/that ability./"//
15:02:25 <TallTed> RRSAgent, draft minutes
15:02:27 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
15:03:27 <enrico> q?
15:03:35 <enrico> ack pchampin
15:03:49 <niklasl> pchampin: I still believe in the email I wrote
15:04:06 <doerthe> q+
15:04:16 <niklasl> ... to Souri: be careful, the reifier is not really a box; because of the open world assumption
15:04:37 <niklasl> ... It *may* reify more triples than what we know of
15:05:08 <niklasl> <niklasl> And that is exactly why it's very problematic if it is functional in any logical sense of functional!
15:05:24 <Souri> agree to: multi-valued (rdf:reifies .., .., .., . ) vs. set-valued (RDF named or default graph)
15:05:54 <niklasl> q+
15:06:50 <Souri> open box :-)
15:06:51 <niklasl> +1
15:06:55 <enrico> ack tl
15:07:23 <enrico> or not?
15:07:35 <enrico> (Schrödinger's cat)
15:08:03 <pchampin> q+ to respond to tl about "distributive" properties
15:08:06 <niklasl> tl: how to convert a multi-edge reifier to simple ones?
15:08:31 <niklasl> ... do we convert them to a set of LPG reifiers, with a forEach semantics?
15:08:36 <fsasaki> q+
15:08:37 <Souri> q+
15:08:55 <niklasl> <niklasl> I think it's an OK "hack"o to be able to query many-to-many  in LPGs
15:09:13 <enrico> ack doerthe
15:09:22 <niklasl> [... missed what clashes between tl:s and enrico:s examples]
15:09:45 <niklasl> doerthe: there is no negation, so they could have loved each other before [their mutual love]
15:11:44 <niklasl> pfps: about the restrictive implications: very problematic [...]
15:12:08 <enrico> ack niklasl
15:12:42 <tl> how do we translate a multi-edge annotation to LPG? is it safe to convert them to (necessarily single edge) LPG edges all with the same annotations, effectively applying a for-each-semantics? i think it is, but i haven't heard other opinions. also it somehow collides with the intuition that a reifier is an entity on its own, not a set of abstract
15:12:42 <tl> triples.
15:12:55 <AndyS> q+
15:13:52 <Souri> q-
15:15:40 <enrico> ack pchampin
15:15:40 <Zakim> pchampin, you wanted to respond to tl about "distributive" properties
15:16:48 <niklasl> pchampin: you can't have your cake and eat it. If a property has a domain of Person, you cant put it on a set of persons. But if the domain *is* ListOfPersons, you can have semantics for that. A proerty like :nameForEach .
15:17:14 <niklasl> <niklasl> ex:nameForEach owl:propertyChainAxiom (ex:memberOfList ex:name) .
15:18:06 <niklasl> pchampin: the property on a Wedding is on the wedding. You *might* think of it as a [shorthand]
15:18:40 <enrico> to see how to express distributive properties in the context of a language like RDF (it was description logics), see my very old paper https://link.springer.com/article/10.1007/BF00974106
15:18:40 <niklasl> <niklasl> that's what I try to illustrate by e.g. :reifiesSubject rdfs:subPropertyOf meta:implicates; owl:propertyChainAxiom (rdf:reifies rdf:subject) .
15:19:52 <AndyS> q-
15:20:06 <niklasl> fsasaki: To Souri: With different RDF data producers. If some of these has a one-to-many, can you merge these easily? Or if you want to cross-query across datasets in the opposite, case, how would that work?
15:20:12 <enrico> ack fsasaki
15:20:20 <niklasl> ... Ora is atalking about cross-queries
15:20:28 <niklasl> s/atalking/talking/
15:22:05 <niklasl> Souri: if you have many-to-one in two graphs with the same reifier and merge them; the same reifier basically become two reifiers [?] ; if you query that, we mark the dataset and if we don't want it to be multi-valued we raise a validation error.
15:22:16 <enrico> q+
15:24:12 <niklasl> fsasaki: so you're stuck with validation errors, and the users have no easy way to fix that?
15:24:19 <pchampin> q+
15:24:48 <niklasl> Souri: if you require such validation; but we don't enforce such validation, if the user don't want to restrict to many-to-one we can handle it
15:25:10 <niklasl> fsasaki: but then the user must update the data?
15:25:34 <niklasl> Souri: we don't interpret their data, it's their business. If its invalid to them we just raise that.
15:26:03 <TallTed> RRSAgent, draft minutes
15:26:04 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
15:27:01 <niklasl> enrico: There's been a lot of work many years ago, how to add generalized quantifiers to the abox. For each in the group, etc. Natural language about multiple entites ("Tom, Dick and Harry each ate a pizza", how many pizzas were eaten?, They carried a piano, etc.)
15:27:17 <enrico> ack enrico
15:27:24 <niklasl> ... see my link above (my 30 year old paper)
15:28:14 <doerthe> just for the record: properties  in NL are not necessary binary.  "It rains"? "Paul gives Mary the book"?
15:28:39 <enrico> Paul gives TO Mary the book
15:29:08 <TallTed> present+ pchampin, pfps
15:29:08 <AndyS> q+
15:29:12 <niklasl> pchampin: If two people are using many-to-one and reify different triples for the same wedding, we can't in general require the functional restriction.
15:29:37 <niklasl> <niklasl> but my pipe example was inspired by the very much too simple example 2 in https://lists.w3.org/Archives/Public/public-rdf-star/2021Dec/att-0001/rdf-star-neptune-use-cases-20211202.pdf
15:30:18 <enrico> q+ on data integration
15:30:23 <niklasl> ... the many-to-many is not a useful pattern to start with, but it may be necessary for data integration
15:30:25 <niklasl> +1 to that
15:30:41 <AndyS> ack pchampin
15:30:50 <doerthe> The to comes from your native language. but let's stick to rain, in linguistics I learned that this is considered 0-ary
15:30:55 <niklasl> ... If you put the same reifier on multiple triples, probably you have an n-ary relation, and here is how to handle that
15:31:07 <enrico> Unary relations are fine
15:31:10 <niklasl> <niklasl> but meanwhile, group them to the reifier
15:31:34 <enrico> ack andys
15:31:43 <fsasaki> for the record, my question was triggered not by the modeling aspect of data integration but by the workflow aspect. I am thinking of different data producers who use different modeling patterns, leading to issues discovered by a data consumers, and then the need to fix the errors again by the data producers. My impression is that many-to-many will
15:31:43 <fsasaki> lead to more such process cycles needed.
15:32:30 <niklasl> AndyS: Pierre-Antoine touched on this - if you look at Brian's example; given any LPG example, it can be automatically translated to RDF. Thomas also mentioned that in looking at the relationship between the two, there are two subproblems, going from the one to the other, and vice versa.
15:32:31 <fsasaki> s/not/not only/
15:33:08 <niklasl> ... If the explanation becomes very abstract and can't readily be automatic, it can change the perception of what we're doing
15:33:37 <niklasl> enrico: the killer application of RDF has always been data integration
15:33:43 <AndyS> s/Brian/Bryan/
15:33:50 <doerthe> there are predicates which cannot exist in a binary way. "Enrico gives book" is not a valid sentence in English (and yet, my example does not work, Enrico could give love :D, but there are predicates like that)
15:33:54 <niklasl> ... and a colleague of mine recently submitted a use case exactly on the line of the wedding
15:33:57 <enrico> q?
15:34:01 <enrico> ack enrico
15:34:01 <Zakim> enrico, you wanted to comment on data integration
15:37:27 <TallTed> "model it properly" is a slippery slope. "proper" changes over time, with different perspective and/or observer.
15:37:42 <enrico> +1 TallTed
15:37:51 <TallTed> RRSAgent, draft minutes
15:37:52 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
15:38:03 <niklasl> Agreed, TallTed! I think I put it too strongly. Thomas is softening it I thikn.
15:38:08 <niklasl> s/thikn/think/
15:38:26 <TallTed> RRSAgent, draft minutes
15:38:27 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
15:39:10 <niklasl> Caring for the generally expected, flat and simple case, and adding a "maginalia" model in up front is *also* a valid usage pattern! Just not well-known in the RDF world.
15:40:10 <niklasl> (Right now of course, I see it everywhere in my daily work. Wearing RDF-star-colored glasses.)
15:40:32 <TallTed> RRSAgent, draft minutes
15:40:34 <RRSAgent> I have made the request to generate https://www.w3.org/2024/04/19-rdf-star-minutes.html TallTed
15:40:42 <TallTed> Zakim, bye
15:40:42 <Zakim> leaving.  As of this point the attendees have been enrico, TallTed, gkellogg, tl, doerthe, Souri, niklasl, fsasaki, AndyS, pchampin, pfps
15:40:42 <Zakim> Zakim has left #rdf-star
15:40:57 <TallTed> RRSAgent, bye
15:40:57 <RRSAgent> I see no action items