13:59:45 <RRSAgent> RRSAgent has joined #rdf-star
13:59:50 <RRSAgent> logging to https://www.w3.org/2024/10/04-rdf-star-irc
14:00:25 <TallTed> agenda: https://www.w3.org/events/meetings/6d0cd306-0be8-4267-865a-6272cc8d9da4/20241004T100000/
14:00:26 <agendabot> clear agenda
14:00:26 <agendabot> agenda+ Map the annotation syntax to rdfs:states, starting from  -> https://github.com/w3c/rdf-star-wg/issues/128 https://github.com/w3c/rdf-star-wg/issues/128
14:00:27 <TallTed> present+
14:00:29 <TallTed> meeting: RDF-star Semantics TF
14:00:31 <TallTed> rrsagent, draft minutes
14:00:33 <RRSAgent> I have made the request to generate https://www.w3.org/2024/10/04-rdf-star-minutes.html TallTed
14:00:35 <TallTed> rrsagent, make logs public
14:01:49 <TallTed> previous meeting: https://www.w3.org/2024/10/03-rdf-star-minutes.html
14:01:51 <TallTed> next meeting: https://www.w3.org/2024/10/10-rdf-star-minutes.html
14:02:51 <tl> present+
14:02:55 <william_vw> william_vw has joined #rdf-star
14:02:55 <Souri> Souri has joined #rdf-star
14:03:02 <Souri> present+
14:03:04 <william_vw> present+
14:03:26 <gkellogg> gkellogg has joined #rdf-star
14:04:40 <doerthe> doerthe has joined #rdf-star
14:04:46 <TallTed> RRSAgent, draft minutes
14:04:47 <RRSAgent> I have made the request to generate https://www.w3.org/2024/10/04-rdf-star-minutes.html TallTed
14:05:08 <doerthe> present+
14:07:06 <pfps> pfps has joined #rdf-star
14:07:16 <pfps> present+
14:09:17 <gkellogg> present+
14:09:34 <TallTed> scribe: pchampin
14:09:40 <pchampin> present+
14:09:51 <AndyS> present+
14:10:07 <TallTed> chair: enrico
14:10:35 <pchampin> topic: Thomas' proposal on rdf:states
14:10:53 <enrico> enrico has joined #rdf-star
14:10:57 <enrico> present+
14:11:11 <TallTed> RRSAgent, draft minutes
14:11:13 <RRSAgent> I have made the request to generate https://www.w3.org/2024/10/04-rdf-star-minutes.html TallTed
14:11:20 <pchampin> tl: sharing slides -> https://lists.w3.org/Archives/Public/public-rdf-star-wg/2024Oct/att-0018/states.pdf
14:12:43 <pchampin> tl: slide 4: discussing the intuitions about "unsasserted statements"
14:13:09 <pchampin> ... what's intuitive for logic is not for the real world
14:13:19 <pchampin> ... in PGs there is no such thing as unasserted assertions
14:13:51 <pfps> q+
14:14:30 <pchampin> ... slide 5: we could have a strong link between asserted statements and annotations, with a specific predicate rdf:states
14:14:34 <niklasl> niklasl has joined #rdf-star
14:14:51 <niklasl> present+
14:15:16 <pchampin> slide 6: we have 3 primitives, one in N-Triples and two in Turtle; I think users should only use Turtle
14:15:25 <pchampin> s/slide 6/... slide 6
14:15:53 <pchampin> ... slide 7: discrepancy between the user-facing syntax and what's in the database
14:16:26 <pchampin> q+ to talk about the example slide 7
14:16:45 <pfps> q+ to talk about the example on slide 7
14:16:54 <pchampin> ... this creates an ambiguity about whether or not Alice endorsed that statement
14:16:59 <pchampin> ... we don't want that
14:17:34 <niklasl> q+ to say "that doesn't say what Alice 'meant' anyway"
14:17:36 <pfps> I'm completely lost by this argument.
14:18:02 <pchampin> ... slide 9: proposal: 2 different reification properties, one for the << ... >>, and one for the annotation syntax {| ... |}
14:18:31 <william_vw> "most of the SW is about facts" - note that this may be due to the fact that reification was underspecified / terrible until now
14:18:57 <pchampin> ... this would make round-tripping work, and would satisfy user's intuitions IMO.
14:19:55 <pchampin> ... slide 10: discuss the drawbacks of this proposal
14:20:30 <pchampin> enrico: in slide 10, 2nd bullet, I think you mean "union" instead of "join"
14:20:36 <pchampin> tl: you are probably right.
14:21:13 <pchampin> ... the fact that the annotation syntax was never challenged is telling.
14:21:45 <pchampin> ... So capturing the intent of the annotation syntax with rdf:states seems valuable.
14:22:17 <pchampin> slide 11: we need to make a decision now, as we are specifying the syntax now
14:23:33 <AndyS> q?
14:23:39 <pchampin> ... [something about vocabularies for propositions]
14:24:01 <enrico> ack pfps
14:24:01 <Zakim> pfps, you wanted to talk about the example on slide 7
14:24:06 <pchampin> pfps: I find none this compelling.
14:24:33 <pchampin> ... You say it is not about propositional attitudes, but "says" in your example is a propositional attitude.
14:25:10 <pchampin> ... But then again it is not about prop. attitudes, because there is no relation between Alice's endorsement and the assertedness of the triple.
14:25:41 <pchampin> ... Roundtripping is a red herring; other syntactic shortcuts do not roundtrip either.
14:26:03 <pchampin> tl: w.r.t. propositional attitude, my 2nd example is not related to them.
14:26:16 <pchampin> pfps: the first example is, though.
14:26:25 <TallTed> the most common Turtle shorthand -- `:s a :p` -- doesn't roundtrip. it becomes `:s rdf:type :p` in a triple store.
14:27:09 <AndyS> https://www.w3.org/2024/08/16-rdf-star-minutes.html
14:27:16 <pchampin> ... and we have been over these arguments again and again.
14:27:17 <AndyS> https://www.w3.org/2024/08/02-rdf-star-minutes.html
14:27:24 <enrico> ack pchampin
14:27:24 <Zakim> pchampin, you wanted to talk about the example slide 7
14:27:24 <pchampin> TallTed: this is a different presentation.
14:27:31 <gkellogg> scribe+
14:28:12 <gkellogg> pchampin: In reverse order: In the last slide, you said we couldn't postpone it because of syntax discussions. But, nothing is final until REC.
14:28:42 <AndyS> q+
14:28:59 <gkellogg> ... Other arguments were stated by pfps. Using examples like "says" is a problem, as there are a lot of specific issues ...
14:29:32 <gkellogg> ... The problem with "says", is that when someone says something, they endorse it.
14:29:46 <doerthe> q+
14:30:16 <gkellogg> ... We could use "quote" instead of "says". Then, I have no preconceived assumption about what they mean.
14:30:59 <gkellogg> ... The assertedness tells you something about alice, but having multiple perspectives represented in a graph is fraught.
14:31:44 <gkellogg> ... I consider that the round-tripping issue is not an issue. If the triple is endorsed by the author, it doesn't matter what non-authors say.
14:32:02 <gkellogg> scribe-
14:32:13 <enrico> ack niklasl
14:32:13 <Zakim> niklasl, you wanted to say "that doesn't say what Alice 'meant' anyway"
14:32:25 <pchampin> niklasl: that's basically what I thought as well.
14:32:26 <niklasl> :Foo :madeOf :Bar {| :rejectedBy :Alice |} {| :believedBy :Bob |} . # Invokes other "intuitions"?
14:32:57 <pchampin> ... maybe the example above helps. I wouldn't say this example is strange.
14:33:10 <pchampin> ... That's ok to state that alice rejects an asserted triple.
14:33:12 <Souri> I feel strongly about maintaining independence (i.e., having no side-effects). Presence or absence of :s :p :o, the triple, in the graph, IMO, should be independent of the presence or absence of :r rdf:reifies <<( :s :p :o )>>. Anything one says about :r is about the triple-term <<( :s :p :o )>>, not about the :s :p :o triple, as far as RDF
14:33:12 <Souri> semantics is concerned. Data creators can connect them if they want to.
14:33:25 <pchampin> ... I disagree with what you claim is a common intuition.
14:33:35 <pchampin> q?
14:33:43 <pfps> I agree with this.
14:33:59 <pchampin> tl: Niklas, you model it the other way around, then you don't have a problem.
14:34:14 <pchampin> ... Of course we can educate the users to do it that way.
14:34:43 <pchampin> niklasl: the graph says what is true or not; if you want to model your interpretation process, you have to model it in the graph.
14:34:52 <enrico> ack andys
14:34:53 <doerthe> q-
14:35:04 <AndyS> https://lists.w3.org/Archives/Public/public-rdf-star/2020Aug/0041.html -- Holger Knublauch
14:35:12 <pchampin> AndyS: one of the problems I see is: taking an existing use-case that has been discussed long enough,
14:35:26 <pchampin> ... and repurposing it for something different.
14:35:51 <pchampin> ... See link above, the annotation syntax was meant to allow people to write less.
14:35:59 <pchampin> ... You are questioning the utility of this.
14:36:29 <pchampin> ... I don't think that we can or should repurpose the annotation syntax.
14:36:33 <Souri> q+
14:37:00 <enrico> ack souri
14:37:25 <pchampin> Souri: the more side effects we have, the more confusion it creates.
14:37:51 <pchampin> ... rdf:states would have imply the s p o in the triple term, I see that as a side effect.
14:38:27 <pchampin> ... For me, the triple S P O and :r rdf:reifies << S P O >> are independant as far as RDF is concern.
14:38:39 <pchampin> ... Even if users may chose to connect them.
14:39:09 <enrico> q+
14:39:13 <doerthe> q+
14:39:31 <pchampin> enrico: I'm not sure what we are really discussing.
14:39:56 <gkellogg> ack enrico
14:40:00 <pchampin> ... Is it rdf:states per se? Or whether there should be a shortcut for it?
14:40:09 <pchampin> q+
14:40:35 <TallTed> "states" could be a syntactic shortcut (that would translate to some specific RDF). "rdf:states" would be an RDF predicate.
14:40:52 <TallTed> "states" akin to "a"
14:41:02 <pchampin> ... I don't see this would be confusing for authors, as most of them would not enable RDFS entailemnt.
14:41:31 <TallTed> s/"rdf:states" would/"rdfs:states" would/
14:41:33 <pchampin> s/rdf:states/rdfs:states/g
14:41:52 <pchampin> tl: my proposal is to change the annotation syntactic sugar to use rdfs:states
14:42:58 <pchampin> ... the annotation syntax would create 2 triples, just like today, but use rdfs:states instead of rdf:reifies.
14:43:16 <pchampin> ... plus, rdfs:states only would entail the triple if it was not explicit
14:43:34 <pchampin> enrico: ok, so the macro would enforce the entailment provided by rdfs:states.
14:43:50 <TallTed> q+
14:43:54 <enrico> ack doerthe
14:43:55 <pchampin> ... So the question is whether people want this special thing.
14:44:10 <pchampin> doerthe: I have a similar question. I was not sure how you see rdfs:states.
14:44:43 <pchampin> ... enrico assumes that it would lead to some entailments, while my impression from your slide is that it would have no extra-semantics.
14:44:56 <tl> https://github.com/w3c/rdf-star-wg/issues/128
14:44:57 <gb> https://github.com/w3c/rdf-star-wg/issues/128 -> Issue 128 map the annotation syntax to `rdfs:states` (by rat10) [discuss-f2f]
14:45:21 <pchampin> ... We came here because you care about roundtripping the annotation syntax.
14:45:55 <Souri> Since rdfs:states is not part of RDF1.2 -- whether it should be added to RDFS vocabulary as an extension or not is not for us to decide right now
14:45:58 <pchampin> tl: the issue above gives the complete mapping to N-Triples.
14:46:13 <pchampin> ... I acknowledge the problem you raise in the issue.
14:46:45 <niklasl> q?
14:46:52 <AndyS> q+
14:47:15 <pchampin> ... Is it viable to tell peoplel to only use Turtle with the syntactic sugar, and only use triple terms if they really know what they are doing.
14:47:19 <niklasl> It would be "deleteable" *unless* RDFS entailment is used; if that is used, it would be "immutable" since the rdfs:states would imply it (*very* informally speaking). I see that as a potential problem.
14:47:53 <pchampin> doerthe: to be sure I understand, you want rdfs:states to entail the object triple term.
14:48:03 <pchampin> tl: you have to see it the other way, start with the annotation syntax.
14:48:14 <pchampin> doerthe: I would like to see it my way as well.
14:49:23 <pfps> I agree with doerthe - the shorthands are syntactic sugar, no more
14:49:35 <pchampin> tl: the current annotation syntax maps to 2 triples; if you destroy one of them, and serialize it back to Turtle, you get only the << ... >>
14:49:49 <enrico> ack pchampin
14:49:55 <pchampin> ... but yes, I would like RDFS entailment to entail the triple term back.
14:51:09 <tl> q+
14:51:20 <william_vw> scribe+
14:51:35 <william_vw> pchampin re-purposing the annotation syntax; becoming more than syntactic sugar
14:51:35 <enrico> q+
14:51:38 <tl> q-
14:52:09 <william_vw> pchampin when people write 2 things, they want both to stay together; that is the argument
14:52:17 <william_vw> pchampin: I find it adds complexity, and not convinced
14:53:07 <william_vw> pchampin: about educating users; the argument relies on a misunderstanding of stated triples; i.e., of how RDF works
14:53:24 <william_vw> pchampin: not convinced that it is part of people
14:53:29 <william_vw> ...'s intuition
14:53:49 <william_vw> pchampin: not opposed to having entailment for the original triple
14:53:54 <william_vw> scribe-
14:53:59 <william_vw> q+
14:54:31 <pchampin> tl: I'm having trouble accepting AndyS's argument. I'm not taking away anything or repurposing anything.
14:54:32 <pchampin> qq+
14:54:50 <pchampin> ... We didn't have the notion of reifier at the time.
14:55:48 <TallTed> q?
14:56:03 <pchampin> ... What I'm changing is how the annotation syntax is encoded, and ensure that with entailment, the intent of the annotation is preserved.
14:56:22 <niklasl> q+
14:56:38 <pchampin> ... About "says", I provided another example, with theories.
14:56:40 <pchampin> q-
14:56:54 <enrico> q-
14:57:40 <enrico> ack tallted
14:57:41 <pchampin> ... There are drawbacks, but that's a small price to pay.
14:57:50 <niklasl> Here is my attempt to answer that question about opposing theories: https://gist.github.com/niklasl/f4a5dee1b991ff5a19a33360c6fd3078?permalink_comment_id=5172827#gistcomment-5172827
14:58:00 <pchampin> ... I agree that I'm repeating myself, if you all disagree, then so be it.
14:58:16 <pchampin> TallTed: there is a regular concern about complexity. RDF is complex even if it seems simple.
14:58:23 <enrico> q+
14:58:25 <pchampin> ... Few people get it right the first time.
14:58:47 <pchampin> ... That's ok, we can't remove all complexity from the world.
14:59:20 <pchampin> ... We need to decide whether we are designing syntactic sugar on Turtle (and other concrete syntaxes) or on the abstract syntax.
14:59:33 <pchampin> ... I think that abstract syntax is not a good idea.
15:00:12 <pchampin> ... Round-trippable is a red-herring.
15:00:36 <pchampin> ... Syntactic sugar is useful for putting things in, not be able to say "this is how things were written".
15:00:41 <pchampin> ... Inference is something different.
15:01:08 <pchampin> ... I can infer new things from what is explicitly stated.
15:02:24 <pchampin> ... Baking too much semantics in rdfs:states (or other predicates) will cause confusion.
15:02:35 <pchampin> ... Putting sugar is less problematic.
15:03:22 <doerthe> you are assuming semantics here...
15:03:22 <enrico> ack andys
15:03:26 <pchampin> tl: slide 7 shows how you lose the info about who endorsed the triple.
15:03:28 <pchampin> pchampin: no!
15:03:51 <pchampin> AndyS: there is a difference between authoring data and accessing that data.
15:04:16 <pchampin> ... They happen at different types. Entailment is available when accessing.
15:04:50 <pchampin> ... What I think TallTed was getting at is: when you exchange database dumps today,
15:05:08 <pchampin> ... you exchange N-Triples or N-Quads, not Turtle, so you don't keep the sugar.
15:05:38 <pchampin> ... Finally, I don't believe that your examples are majority use-case, as you claim.
15:06:00 <pchampin> ... If you say "this triple has a source", it does not matter whether the triple is asserted or not.
15:06:11 <pchampin> ... You don't want the removal or adding of that triple to change the source.
15:06:33 <pchampin> ... That's the problem of requiring rdfs:states in one place, and not in another.
15:08:10 <pchampin> tl: this is a valid argument; but if you want more, you need to add it (and query it) all the time.
15:08:16 <enrico> ack william_vw
15:09:25 <pchampin> william_vw: N-Triples is used to exchange data, it is the grount truth. Hiding it under the rug is not a good idea.
15:09:45 <pchampin> ... Forcing some well-formedness on it is not something we can handwave.
15:09:53 <AndyS> s/grount/ground/
15:10:06 <pchampin> ... I think Pat Hayes once said "every RDF statements stands by itself"
15:10:21 <pchampin> s/by itself/on itself
15:10:58 <pchampin> ... Having a constraint that prevents rdfs:state to exist without the accompanying S P O goes against that.
15:11:43 <pchampin> ... In JS, you can add a semicolon at the end of a statement, but you don't have to. It is a matter of preference or policy.
15:11:46 <AndyS> q?
15:11:52 <pchampin> ... Should an editor or a linter add it if it's not there?
15:13:02 <Souri> q+
15:13:03 <pchampin> q+
15:13:08 <pchampin> q-
15:13:30 <enrico> ack niklasl
15:13:54 <Souri> Can't I use three different reifiers to separate out what ALice thinks, what Bob thinks, and what Dan thinks.
15:14:51 <pchampin> tl: someone could use 3 combinations to encode different semantics (rdf:reifies, rdfs:states + asserted, rdfs:states without asserted) but that would be a hack
15:15:39 <pchampin> niklasl: I agree with pchampin that there is a mistake in your example, where you assign an intent to the use of annotations.
15:16:04 <pchampin> ... Not sure about propositional attitude.
15:16:26 <pchampin> ... I also agree with william_vw that you seem to try to link the meaning of 2 triples with rdfs:states.
15:17:24 <pchampin> ... I don't know how we can assess what the majority of users thinks, but in the group, most of us don't interpret it that way.
15:17:37 <pchampin> q+
15:17:55 <pchampin> ... If you want to model that Alice endorses a triple, you can model that in your own vocabulary.
15:18:15 <pchampin> ... I would not say that RDF is complex. The interpretation is the complexity of it.
15:18:33 <pchampin> ... Coming back to your claim that in LPGs the edges exist;
15:18:46 <pchampin> ... they exist in the data, but there is no notion of assertion.
15:19:15 <pchampin> ... In LPGs, some edges have a property "certainty: 0.4", this does not assert the edge.
15:19:37 <pchampin> enrico: rescuing tl, I don't have an opinion about rdfs:states or the annotation syntax.
15:19:55 <pfps> How does rdfs:states make anything shorter?
15:19:57 <doerthe> but that is not what was proposed, right? tl wanted two triples?
15:20:07 <pchampin> ... If the use-case is preventing to write two lines, rdfs:state is a way to do that.
15:20:49 <TallTed> same meaning <> round-trip
15:20:55 <pchampin> ... Round-trip: Turtle and N-Triples are completely round-tripable, as they have the very same meaning.
15:21:12 <william_vw> niklasl - but that is about syntax and not semantics
15:21:17 <TallTed> comments are also lost, and they *may* be semantically important to the humans involved
15:21:29 <pfps> +1 TallTed
15:21:34 <tl> @doerthe look at the tl;dr in the issue linked above for the mapping
15:21:36 <william_vw> TallTed - sorry but I don't think that is what enrico meant
15:21:44 <pchampin> ... If you want to change the graph and want to retract a triple, and you wrote rdfs:states,
15:21:57 <pchampin> ... then you have to change it to rdf:reifies. You need to take seriously what you wrote.
15:22:37 <william_vw> @TallTed you can round-trip comments but they would be just as meaningless the first time
15:22:51 <william_vw> (regarding their machine-interpretable semantics)
15:23:14 <william_vw> q+
15:23:16 <niklasl> Of course. In OWL you can even entail <Liz> :spouse <Richard> from an "N-ary" ;Marriage.
15:23:22 <pchampin> ... If I write A subClass B, B subClass C and A subClass C, even if I remove A subClass B, A subClass C remains because I stated it explicitly.
15:23:36 <enrico> ack souri
15:23:50 <TallTed> william_vw -- if I load Turtle (which has comments) into an RDF store, and then dump that graph, I have lost the comments
15:24:12 <william_vw> @enrico I was talking about a well-formedness that is introduced by rdfs:states + assertion
15:24:12 <pchampin> Souri: I have a basic question: we are doing RDF. Why do we have to discuss RDFS, is it not out of scope?
15:24:28 <TallTed> s/load Turtle/load Turtle, NQuads, or NTriples/
15:24:41 <william_vw> TallTed -- say I have a system that keeps comments and can roundtrip them, it doesn'
15:24:50 <pchampin> ... Second question: if Alice and Bob have different opinions about SPO, we can associate two different reifies to them, and both can go their way.
15:24:51 <william_vw> t matter; they are meaningless from the RDF perspective
15:25:15 <william_vw> they are purely syntax
15:25:21 <TallTed> "say I have a system that keeps comments and can roundtrip them" -- that's completely jumped the rails around RDF
15:25:58 <pchampin> Souri, RDFS *is* in our scope, see the charter
15:26:22 <AndyS> q?
15:26:34 <pchampin> enrico: RDFS semantics is defined in the same REC as RDF's semantics
15:26:55 <pchampin> Souri: wasn't RDFS defined after RDF, historically?
15:26:59 <william_vw> @TallTed - let me rephrase - the fact that comments are not translated into RDF means they are meaningless from a machine-interpretable semantics viewpoint
15:27:02 <niklasl> There is noone who "says" the graph. It's simply true (*if* you decide interpret it). That's the simplicity. What that implies is interpretation upon that.
15:27:06 <pchampin> enrico: no, they were created at the same time.
15:27:14 <AndyS> q+
15:27:22 <enrico> ack enrico
15:27:22 <pchampin> q-
15:27:48 <enrico> ack william_vw
15:28:06 <pchampin> tl: if somebody writes N-Triples following the rules, they don't need entailment.
15:29:24 <pchampin> william_vw: to respond to enrico, what I meant with well-formedness: tl suggests that somebody writing rdfs:states in N-Triples should also write the asserted triple.
15:29:46 <pchampin> enrico: but with entailment, you don't *need* to add it.
15:30:12 <TallTed> q?
15:30:33 <pchampin> william_vw: yes, but we are talking about RDF.
15:30:41 <niklasl> Now you are discussing the two different questions at once?
15:30:43 <enrico> ack andys
15:31:00 <pchampin> tl: this is similar to lists; you *can* write ill-formed lists, but that's not a good idea.
15:31:55 <pchampin> AndyS: if you have a lot of triples (more than memory), you would use restricted forms of Turtle, which would not necessarily preserve annotations or the rdfs:states.
15:32:35 <pchampin> william_vw: enrico, it is true that you can write OWL-entailed triples in RDF, but as far as RDF is concerned, they do not exist.
15:32:55 <pfps> You can certainly write triples that use the OWL vocabulary in an RDF graph, and they then exist in the graph.
15:33:02 <doerthe> indeed, I think that tl and enrico's  understanding differ here
15:33:25 <pchampin> s/they do not exist/they do not exist until you wrote them
15:34:35 <pchampin> enrico: to summarize: we have again discussed about rdfs:states, which is an orthogonal choice to have multiple reifiers.
15:35:14 <TallTed> RRSAgent, draft minutes
15:35:15 <RRSAgent> I have made the request to generate https://www.w3.org/2024/10/04-rdf-star-minutes.html TallTed
15:35:37 <Souri> IMO, stay within RDF. And, rdf:reifies + (rdf:asserts property or rdf:ReificationProperty class) is sufficient.
15:36:04 <pchampin> ... The previous discussion about reification properties rules out rdfs:states.
15:36:15 <pchampin> AndyS: why?
15:36:26 <william_vw> @pfps - I meant the OWL inferences do not exist as far as RDF is concerned
15:36:27 <pfps> I don't see that either.
15:36:39 <niklasl> Me neither.
15:37:01 <niklasl> Only if rdf:ReificationProperty is somehow owl:oneOf (rdf:reifiies) ... ?
15:37:11 <pchampin> RRSAgent, make minutes
15:37:12 <RRSAgent> I have made the request to generate https://www.w3.org/2024/10/04-rdf-star-minutes.html pchampin
15:37:51 <TallTed> ...adjourned...
15:50:03 <gkellogg> gkellogg has joined #rdf-star
16:24:16 <TallTed> RRSAgent, draft minutes
16:24:18 <RRSAgent> I have made the request to generate https://www.w3.org/2024/10/04-rdf-star-minutes.html TallTed
16:24:24 <gkellogg> gkellogg has joined #rdf-star
16:24:24 <TallTed> Zakim, bye
16:24:24 <Zakim> leaving.  As of this point the attendees have been TallTed, tl, Souri, william_vw, doerthe, pfps, gkellogg, pchampin, AndyS, enrico, niklasl
16:24:24 <Zakim> Zakim has left #rdf-star
16:24:31 <TallTed> RRSAgent, bye
16:24:31 <RRSAgent> I see no action items