14:04:01 <RRSAgent> RRSAgent has joined #rdf-star
14:04:06 <RRSAgent> logging to https://www.w3.org/2024/07/05-rdf-star-irc
14:04:06 <Zakim> RRSAgent, make logs Public
14:04:07 <Zakim> please title this meeting ("meeting: ..."), gkellogg
14:04:15 <gkellogg> meeting: RDF-star SemTF 2024-06-21
14:04:27 <doerthe> doerthe has joined #rdf-star
14:04:32 <gkellogg> present+
14:04:47 <doerthe> present+
14:05:12 <gkellogg> scribe: gkellogg
14:05:32 <gkellogg> tl: argues for needing unasserted asssertions
14:05:59 <gkellogg> ... Note my argument, but my interpretation of the WG position.
14:06:06 <gkellogg> s/Note/Not/
14:06:42 <gkellogg> pfps: from the CG report, quoted triples don't need to be asserted.
14:07:00 <doerthe> thank you, gregg, for scribing :)
14:07:00 <Souri> Souri has joined #rdf-star
14:07:06 <Souri> present+
14:07:27 <gkellogg> tl: A lot of people use the term "assertion" without "endorcing" them.
14:08:13 <gkellogg> pfps: Let's stick with already defined RDF terms. We can say that a triple is an element of the graph. Being an element of the graph makes it asserted.
14:08:46 <gkellogg> ... Standard reification is a way of talking about a triple that may not be an element of the graph.
14:09:31 <gkellogg> ... I think standard reification works well, so why do we have RDF-star? Developers are too lazy.
14:10:01 <AndyS> present+
14:10:15 <gkellogg> ... It does lead to a lot of "star" queries; it's up to implementors to make them perform.
14:10:37 <gkellogg> ... An implementor could create an optimization for the reification structure.
14:10:49 <AndyS> q+
14:11:03 <gkellogg> ack AndyS
14:11:29 <gkellogg> AndyS: There's another situation, which is partial reifications
14:11:34 <tl> q+
14:11:40 <gkellogg> ack tl
14:11:43 <AndyS> and over specification
14:12:18 <gkellogg> tl: Before the last meeting, I didn't think there was a way of speaking about a statement without endorsing it.
14:12:54 <gkellogg> ... If a statement was not in the graph but was annotated, and then later put into the graph, we have lost the fact that it was previously not asserted.
14:12:54 <niklasl> Alice isn't in the graph (well, the fictional Alice may be...).
14:13:42 <pfps> pfps has joined #rdf-star
14:13:52 <pfps> q+ to discuss temporal aspects
14:14:24 <gkellogg> ... Once it's clear that the annotation is on a triple contained within the graph implies the need to explicitly tag when the triple became part of the graph.
14:14:34 <doerthe> q+
14:15:12 <gkellogg> ... The connection between a tripling being in the graph and its being annotated is fragile.
14:15:44 <gkellogg> ... Most of the time, (for me), annotations are performed on triples that are members of the graph.
14:16:13 <gkellogg> ... It would be easier to model using N-ary relations.
14:16:36 <gkellogg> zakim, make logs public
14:16:36 <Zakim> I don't understand 'make logs public', gkellogg
14:16:43 <gkellogg> rrsagent, make logs public
14:16:54 <gkellogg> rrsagent, generate minutes
14:16:55 <RRSAgent> I have made the request to generate https://www.w3.org/2024/07/05-rdf-star-minutes.html gkellogg
14:17:08 <gkellogg> pfps: You've lost me when you start talking about time.
14:18:03 <gkellogg> ... RDF has some facilities such as datasets. You could say that an IRI represents a version of a graph and talk about that.
14:18:31 <gkellogg> tl: I was not referring to temporal assertions.
14:18:39 <niklasl> q+
14:18:55 <niklasl> It's crystal clear. The triple is the triple.
14:19:19 <gkellogg> tl: If you want different viewpoints in the same graph, it's not clear when each was added.
14:19:27 <gkellogg> ack doerthe
14:19:39 <pfps> Agree, the triple in an embedded triple *is* the triple.  It doesn't refer to the triple or allude to the triple or anything else besides being the triple.
14:19:45 <pfps> ack pfps
14:19:45 <Zakim> pfps, you wanted to discuss temporal aspects
14:19:58 <gkellogg> doerthe: I don't really follow your reasoning.
14:20:25 <gkellogg> ... When you want to add knowledge to the graph ... You can do everything with predicates.
14:20:53 <gkellogg> ... When a triple is added it's not about Alice's relation to it, its a description of the world. It doesn't matter who added it.
14:21:22 <gkellogg> q?
14:21:28 <gkellogg> ack niklasl
14:21:31 <pfps> The whole point of having the rdf:reifies relationship is to allow annotations of different "incarnations" (or whatever) of the triple.
14:21:55 <gkellogg> niklasl: I "think" I understand what tl means, but I think two arguments are being conflated into one.
14:21:56 <pfps> But when I think about it, maybe the n-ary use case doesn't need a stand-off relationship.
14:22:13 <gkellogg> ... I agree with pfps and doerthe; it's not contentious.
14:22:34 <gkellogg> ... You can't relate the triple to a graph, as the graph is a model and you can't step out of that.
14:22:43 <pfps> nicklasl:  The graph is the graph, it is not something that changes.
14:22:51 <gkellogg> ... You can't say "i believe this" unless it's in the graph.
14:22:51 <enrico> enrico has joined #rdf-star
14:22:58 <enrico> present+
14:23:27 <gkellogg> ... It's important to get that clarity. You can add to your vocabulary various notions that you don't need to refer to the relationship denoted by the triple.
14:23:31 <tl> q+
14:23:50 <gkellogg> ... A reifier that reifies such a relationship is atomic.
14:24:40 <gkellogg> ... I think your conflating with qualification. Specific properties are one form of qualification.
14:24:42 <pfps> Well, "i believe this" is not something that RDF handles.
14:25:33 <gkellogg> ... I don't think that standard RDF reification is enough.
14:25:37 <gkellogg> q?
14:25:39 <gkellogg> ack tl
14:26:12 <gkellogg> tl: the agrument about N-Ary relationship can be made about anything. We're trying to make things easier.
14:26:31 <pfps> If all that the WG is about is to make the syntax easier, then why not just do that and only that?
14:26:33 <gkellogg> ... You could also structure the graph into N-Ary relations and primary statements.
14:26:42 <niklasl> LPGs don't model N-ary relationships, do they?
14:26:52 <pfps> There has to be something more than just bettere syntax.
14:27:28 <gkellogg> ... N-Ary relations can be hard to use, so other syntactic forms have been suggested.
14:27:59 <niklasl> Not all the detailing. One more granular "sublevel". LPGs cannot relate relators, for instance.
14:27:59 <pfps> That depends on the meaning of "models".   If you mean this in a strong sense, there is nothing in LPGs (syntax, data structures, semantics) that is n-ary.
14:28:00 <gkellogg> ... You can do that with N-Ary relations if you base your annotations on that.
14:28:25 <gkellogg> ... Using RDF-star for qualification, but this can add to the confusion.
14:28:57 <niklasl> You are using that relation in natural language right not (:endorses).
14:29:03 <niklasl> s/not/now/
14:29:09 <doerthe> why can't we use two different predicates?
14:29:10 <gkellogg> ... If two people make a statement about a triple, you can't distinguish if one acts as if it was asserted, and the other does not.
14:29:33 <pfps> But triples are sufficient for encoding anything, so both RDF 1.1 and LPGs can encode n-ary relations.  The standard way of doing this is reification - not standard RDF reification but creating a node for the n-ary relationship and linking it to the n arguments.
14:29:33 <enrico> q+
14:29:35 <gkellogg> ... Most of the use cases will want annotations to be about statements in the graph.
14:29:47 <pfps> q+
14:30:06 <gkellogg> ack enrico
14:30:17 <doerthe> :Bob  :saysAndMeans << :s :p :o>>. :Alice :says << :s :p :o>>. :s :p :o.
14:30:34 <pfps> q-
14:30:49 <gkellogg> enrico: I don't like the discussion of "asserted"; it's yet another use case. The current RDF-star can capture this.
14:31:17 <gkellogg> ... If you want asserted stuff, you may lobby for a different thing.
14:31:31 <gkellogg> ... Overloading "RDF reifies" is just wrong.
14:31:34 <pfps> +1 to doerthe (with the provisio that a stand-off relationship may be needed)
14:31:39 <tl> q+
14:32:07 <gkellogg> ... You can use best practices for deciding how to represent somthing.
14:32:25 <niklasl> +1 also to doerthe
14:32:37 <gkellogg> ... RDF only expresses facts. Any name is meaning less until you have a schema. Otherwise, it's just a convention.
14:32:49 <pfps> And it is perfectly fine to have a graph that contains only  :Bob :saysAndMeans << :s :p :o>>. :Alice :says << :s :p :o>>.
14:33:29 <gkellogg> tl: I'm frustrated that the pitfalls of what we're taking about are unacknowledged.
14:33:47 <Souri> q+
14:33:55 <gkellogg> ... Reifiers can refer to unasserted triples, and qualifies to N-Ary relations.
14:34:09 <gkellogg> ... The qualified thing would be asserted.
14:34:16 <gkellogg> q?
14:34:20 <gkellogg> ack tl
14:34:38 <gkellogg> ... A thing is asserted if it is qualified.
14:34:39 <niklasl> Enrico means the {| |} and only that.
14:34:41 <gkellogg> ack Souri
14:35:18 <gkellogg> Souri: I'm trying to understand what you're looking for. There's rdf:qualifies, which applies to :q1 (a qualifier).
14:35:43 <gkellogg> ... For the triple :alice :buys :car, it has to be in the graph to be true.
14:35:50 <pfps>  "A thing is asserted if it is qualified."  Really?  That's a fundamental change to RDF that overturns just about everything.
14:36:19 <niklasl> q+
14:36:37 <gkellogg> tl: We want to be sure people don't mis-understand the annotation.
14:36:47 <pfps> q+
14:36:55 <gkellogg> ack niklasl
14:37:10 <pfps> q+ to dig deeper on qualification implies assertion
14:37:51 <gkellogg> niklasl: I've been thinking if the annotation syntax could expand to both the assertion (qualifies or asserts). Once the triple appears, what would that mean?
14:37:59 <gkellogg> ... What if it's not there?
14:38:15 <pfps> q-
14:38:20 <gkellogg> ... If it's in the graph and you have a reifier of it, that's all you need.
14:38:22 <pfps> +1 to niklasl
14:38:47 <gkellogg> ... If you want to say something more about a reifier, you can use a specific type.
14:39:36 <gkellogg> ... If you have both a start and end date, it's reasonable to expect that the associated triple is no longer in the graph.
14:40:38 <gkellogg> ... You can do most things using sub-properties, but if you want the annotation syntax to be shortcut for that, you need more.
14:40:56 <gkellogg> tl: I would loose the annotation syntax.
14:41:10 <gkellogg> niklasl: Turtle syntax would look horrible.
14:41:28 <Souri> Would a graph that, in its entirety, contains just the following "statement", be considered invalid (because it does NOT have any asserted triples to go with the qualification)?  q1. rdf:qualifies <<( :alice :buys :car )>> .
14:41:33 <gkellogg> q?
14:41:45 <gkellogg> q+
14:42:06 <enrico> enrico has joined #rdf-star
14:42:42 <gkellogg> tl: you'd have to state ever annotation that needs to be asserted. Or, you don't have unasserted annotations.
14:42:59 <gkellogg> ... I'm annotating something I want to express.
14:43:16 <AndyS> If    x rdf:qualifies  T , does ?a rdf:refies ?b match it?
14:43:23 <AndyS> q+
14:43:27 <gkellogg> niklasl: You do this when you created the graph. doerthe showed an example of this.
14:43:29 <enrico> present+
14:43:49 <gkellogg> tl: We can always mint new properties.
14:44:03 <gkellogg> ack gkellogg
14:44:11 <tl> s/can/can't/
14:45:18 <niklasl> Yes, gress is correct; a graph is an immutable state, "adding" or "removing" results in new graphs.
14:45:25 <niklasl> s/gress/gregg/
14:45:32 <gkellogg> gkellogg: Want's to point out that graphs are static and immutable.
14:45:45 <doerthe> but isn't RDF also about adding properties? You define your vocabulary, use it and hopefully others use the same vocabulary and we have an agreement. So, from your point of view: if we add two (better named) predicates to RDF itself, are we then fine? (I try to understand the problem, please see me question like that :) )
14:46:02 <pfps> q+
14:46:19 <gkellogg> tl: Saying that we support the use case of unasserted assertions is wrong.
14:46:21 <gkellogg> q?
14:46:24 <gkellogg> ack AndyS
14:46:48 <gkellogg> AndyS: If you've used the "qualifies" predicate, would that match "reifies" in a query?
14:47:09 <gkellogg> tl: As I unerstand querying you can with << >> syntax.
14:47:16 <niklasl> You can use both << >> and {| |} in SPARQL-star.
14:47:22 <gkellogg> ... I presume we need to support both syntaxes.
14:47:40 <gkellogg> AndyS: You're not able to treat all qualifies as reifies; you have to look for both.
14:48:25 <Souri> q+
14:48:35 <gkellogg> ... The trouble with super-types and super-properties it is the only time SPARQL would need to make this happen.
14:49:24 <gkellogg> AndyS: If we talk about graph merge, I believe that's not a set operation. Once you merge two graphs, you are endorsing them both.
14:49:48 <gkellogg> tl: My example doesn't have anything to do with merging. It might contain multiple viewpoints.
14:50:23 <gkellogg> q?
14:50:27 <gkellogg> ack pfps
14:50:29 <doerthe> q+
14:50:32 <pfps> q-
14:50:57 <AndyS> ack Souri
14:51:00 <gkellogg> pfps: I was trying to reiterate that point that we're going into temporal aspects; Let's not do that.
14:51:25 <gkellogg> Souri: You're saying that rdf:qualifies can be used only on things which are asserted.
14:51:53 <gkellogg> ... Using it one something that is unasserted doesn't make sense.
14:52:12 <gkellogg> ... If someone uses "qualifies" you need to ensure that the triple is asserted.
14:52:27 <gkellogg> ... Using qualifies implies that the triple as asserted.
14:52:56 <niklasl> So tl, you just want a different syntax for the annotation macro? It doesn't sound like that's all you want.
14:53:05 <gkellogg> pfps: It doesn't get added to a graph, it becomes an implication of the graph.
14:53:39 <gkellogg> Souri: When I query a graph using "qualifies" where the associated triple is not asserted would be an error.
14:53:45 <pfps> q+
14:54:15 <pfps> q+ to say that this seems like breaking the correspondence between SPARQL querying and simple entailment
14:54:15 <gkellogg> tl: If you use the <<>> syntax, it gets converted into N-Triples, there you get the rdf:qualifies predicate.
14:54:43 <gkellogg> Souri: I might get an N-Triples file with a single statement.
14:55:00 <gkellogg> tl: That would be incomplete.
14:55:07 <niklasl> And now you're arguing for entailment instead.
14:56:51 <niklasl> PG mode expected it to be asserted, but it wasn't an expansion macro, it was ... entailment? Wishful thinking?
14:56:51 <gkellogg> AndyS: In Olaf's paper, all triples were asserted. If you only have assertion mode, you can't talk about false things.
14:57:10 <gkellogg> ... Where are ocurrances.
14:57:23 <gkellogg> tl: I'm always talking about occurrences.
14:57:42 <niklasl> Do you want sugar for assertion of triple plus the triple as a term, or a singleton property which is a subPropertyOf the property?
14:57:54 <gkellogg> q?
14:57:57 <gkellogg> ack doerthe
14:58:11 <pfps> q-
14:58:48 <gkellogg> doerthe: Looking at your example, you talk about two levels, but there are three things: what one says, what the other says, and what is true.
14:59:15 <gkellogg> ... Independently of Alice and bob, there is what is true.
14:59:32 <gkellogg> ... The act of adding a thing to a graph becomes confusing.
15:00:02 <gkellogg> ... What is missing in our examples is a shortcut syntax.
15:00:28 <gkellogg> tl: The shortcut syntax is not part of N-Triples.
15:00:39 <niklasl> The annotation syntax: <s> :p <o> {|  a :Reifier |} .
15:01:20 <niklasl> Expands to: <s> :p <o>. _:r1 rdf:reifies <<( <s> :p <o> )>>. _:r1 a :Reifier .
15:01:41 <gkellogg> q?
15:01:57 <niklasl> Nothing is lost. _:r1 is clearly related to the same <s> :p <o> that is in the graph (the abstract relationship itself).
15:02:40 <gkellogg> tl: This is many to one, not many to many. Qualifying things that are many to many doesn't make sense.
15:02:51 <niklasl> Yes, if you're looking for singleton properties, that is many-to-one. And *not* n-ary.
15:03:04 <gkellogg> ... If you use reification it's an object to which you can add more triples.
15:03:05 <niklasl> q+
15:03:23 <gkellogg> ack niklasl
15:03:29 <enrico> q+
15:03:53 <gkellogg> niklasl: I think you would have an easier time arguing for singleton properties.
15:04:13 <gkellogg> tl: I'm conflating issues.
15:04:47 <gkellogg> niklasl: I think Kurt is arguing for something similar. His solution is reification in one case, and singleton properties in the other.
15:05:39 <gkellogg> ... I try to keep many to one and many to many separate.
15:06:05 <gkellogg> ... The annotation syntax represents both the assertion and the reifier.
15:06:19 <gkellogg> ... Thanks to transparency, they refer to exactly the same thing.
15:06:48 <gkellogg> q?
15:07:19 <gkellogg> ... If this is hard to understand, and people can't understand many to many, it's going to be a problem.
15:07:30 <gkellogg> ack enrico
15:07:52 <gkellogg> enrico: rdf:reifies should be called "rdf:blob", the point is how you use it.
15:08:20 <gkellogg> ... The many to one I've discussed and produced a Wiki about why you don't need it. You get it from many to many.
15:08:48 <gkellogg> ... Can the current spec represent what you want to express? If it can, this will be a new chapter.
15:09:23 <gkellogg> ... If there's no confusion about what reification is (no conflations, please), can we capture our use cases correctly?
15:09:55 <gkellogg> ... The use cases are satisfied, why do we need something new?
15:10:15 <gkellogg> ... If you can do anything you want with our language, you need a strong argument to add something new.
15:10:56 <gkellogg> tl: Everyone would need to add another triple to say they mean it.
15:11:07 <pfps> q+
15:11:08 <gkellogg> ... You can do it, but it's not feasible.
15:11:33 <gkellogg> ... Using rdf:blob is so undefined, we could use named graphs.
15:12:09 <gkellogg> enrico: No, it is defined. we should use "blobifier". It's intended to define different relations.
15:12:30 <gkellogg> ... The concept has been used for a very long time.
15:12:30 <tl> s/we could use named graphs./we would get into the same situation as with named graphs./
15:12:52 <niklasl> Well, rdf:relationOf then (another round of naming?)
15:12:57 <gkellogg> ... relations capture many different things.
15:13:17 <niklasl> Or rdf:relatorOf (I'll stop here)
15:13:18 <gkellogg> ... <<John Loves Mary>> :added :yesterday.
15:13:40 <pfps> q+ to comment about infeasbility
15:13:53 <gkellogg> ack pfps
15:13:53 <Zakim> pfps, you wanted to comment about infeasbility
15:14:38 <gkellogg> pfps: tl said something about infeasibility; as far as I can tell, there is no extra burden placed by adding the possibility of annotating triples that are not in the graph.
15:15:24 <gkellogg> ... To have embedded triples, you need more complicated data structures. To talk about them as being in the graph, you need a bit more, but that's it. I don't see where in infeasibility comes in.
15:15:40 <niklasl> q+
15:16:03 <gkellogg> tl: Bob annotates a statement in the graph. He'd also need to add another annotation "and I mean it".
15:16:05 <pfps> q+
15:16:34 <gkellogg> ... First you had Olaf's version that asserted and annotated at the same time.
15:17:01 <gkellogg> ... Now, you have a triple, you annotated it, and then you talk about it.
15:17:14 <doerthe> it has nothing to do with the opacity, that is a different discussion (which we should not have now :) )
15:17:44 <pfps> q+ to talk about extra triples
15:18:04 <gkellogg> tl: If it's a use case we should support it unambiguously.
15:18:07 <gkellogg> ack niklasl
15:18:41 <tl> :s :p :o .
15:18:44 <gkellogg> niklasl: I don't see your graph clearly. I'm not sure if your example is ambiguous.
15:18:58 <tl> << : s :p :o >> a :Whatever ;
15:19:09 <tl> :and :IacctuallyMeanIt .
15:19:48 <gkellogg> tl: I you need to say that I think the triple should be there.
15:20:16 <gkellogg> niklasl: The relator/reifier is also described. And the triple is in the graph.
15:20:38 <gkellogg> ... That's epistemology.
15:20:50 <gkellogg> tl: N-Ary makes this clear.
15:21:05 <gkellogg> niklasl: Your argumentation is ambiguous.
15:23:14 <gkellogg> tl: I'm trying to deal with the performance issues of singleton properties.
15:24:07 <gkellogg>  [Discussion too rapid to capture]
15:24:44 <pfps> I don't buy that there is any significant extra effort - on the part of users or implementors.
15:24:44 <pfps> But even if all embedded triples have to be in the graph, then there is still three triples :s :p :o .  :bob :says <<:s :p :o >> . :bob :asserts <<:s :p :o >> .
15:24:44 <pfps> The only distinction is that with embedded triples that are not in the graph, implementations have to be able to handle triples that are not in the current graph, which they more-or-less have to do if they implement RDF datasets.
15:24:44 <pfps> Now you could have a semantic extension to RDF where :bob :asserts <<:s :p :o >> . entails :s :p :o .
15:25:08 <gkellogg> q?
15:25:15 <gkellogg> ack pfps
15:25:15 <Zakim> pfps, you wanted to talk about extra triples
15:25:23 <gkellogg> chair: gkellogg
15:25:54 <gkellogg> pfps: Allowing embedded triples to not be in the graph adds no extra burden other than for implementors.
15:26:05 <gkellogg> ... If they're implementing datasets, they need to do that anyway.
15:26:35 <gkellogg> ... Presumably, you could require that triple IDs are unique to a graph, but that's wasteful, as there will be overlap.
15:26:43 <Souri> q+
15:26:47 <gkellogg> ... The added extra implementation burden should be minimal.
15:27:18 <gkellogg> ... Even if all embedded triples have to be in the graph, you still need triples for each. (in the graph, bob said, bob asserted).
15:27:30 <gkellogg> ... Then SPARQL is no longer simple entailment.
15:27:42 <pfps> But putting that into SPARQL means that SPARQL querying is simple entailment.
15:27:53 <gkellogg> ... Standard SPARQL entailment is simple entailment.
15:28:42 <gkellogg> ... A syntactic shortcut makes it looks like there are fewer triples.
15:29:01 <gkellogg> tl: Once you go to N-Triples, the sugar is gone and you need to write three triples.
15:29:16 <niklasl> q+
15:29:45 <gkellogg> pfps: If you're writing N-Triples, then you do. If you require people to do that and not use Turtle, you're doing a dis-service to your users.
15:30:16 <gkellogg> tl: The mapping needs to add a new triple.
15:30:26 <gkellogg> pfps: I don't expand Turtle before I send it to you.
15:31:21 <gkellogg> AndyS: You're fighting between expressivity and ease of expression.
15:32:25 <tl> :s :p :o {| :a :b |}
15:33:37 <pfps> +1 to gkellogg
15:34:02 <enrico> +1 to gkellogg (but I am optimist)
15:34:06 <enrico> q+
15:34:09 <pfps> bye all
15:34:21 <gkellogg> rrsagent, generate minutes
15:34:23 <RRSAgent> I have made the request to generate https://www.w3.org/2024/07/05-rdf-star-minutes.html gkellogg
15:34:36 <enrico> q-
15:34:40 <doerthe> I also am an optimist :) We can still come together
15:34:52 <doerthe> (but I  share the concerns)
15:35:23 <enrico> The current baseline is the way to go - I don't see still why we should diverge from it.
15:36:23 <Souri> Would multiple sets of qualifying attributes be allowed? :alice :buys :car . :q1 rdf:qualifies <<( :alice :buys :car )>> . :q2 rdf:qualifies <<( :alice :buys :car )>> . :q1 :paidWith :cash ; :amount 500 . :q2 :paidWith :creditCard ; :amount 1000 .
15:36:32 <pfps> pfps has left #rdf-star
15:38:09 <AndyS> q+
15:38:17 <AndyS> ack Souri
15:41:35 <AndyS> ack niklasl
15:47:12 <Souri> I see "isAsserted?" as a global variable (within a graph scope). It either is true or false. Use of rdf:reifies does not affect that global variable in any way.
15:47:25 <Souri> This is how we have it today.
15:48:26 <enrico> q+
15:49:42 <AndyS> ack AndyS
15:55:46 <doerthe> I also have to leave. It could help to take a break before we further discuss. So, please consider to take a break :) Bye
15:56:18 <gkellogg> gkellogg has joined #rdf-star
15:58:40 <niklasl> Thomas, I *think*  you might want something like: ex:singletonPropertyOf rdfs:subPropertyOf rdfs:subPropertyOf ; owl:propertyChainAxiom ( ex:qualifies rdf:predicate ) .  # *if* a triple term entails an rdf:Statement. Then you have turned the reifier into a qualification of the property used as a predicate (specifically a subproperty, and that
15:58:40 <niklasl> specific relationship would be entailed by the chain axiom).
16:05:29 <niklasl> Actually, no, it needs even more convolution.( Still, a subproperty is already possible; and could be related from the reifier.)
16:16:55 <gkellogg> gkellogg has joined #rdf-star
16:18:13 <doerthe> doerthe has joined #rdf-star
16:27:13 <gkellogg> gkellogg has joined #rdf-star
16:58:35 <gkellogg> gkellogg has joined #rdf-star
17:15:58 <gkellogg> gkellogg has joined #rdf-star
17:20:22 <gkellogg> gkellogg has joined #rdf-star
17:20:52 <gkellogg> zakim, end meeting
17:20:52 <Zakim> As of this point the attendees have been gkellogg, doerthe, Souri, AndyS, enrico
17:20:54 <Zakim> RRSAgent, please draft minutes
17:20:56 <RRSAgent> I have made the request to generate https://www.w3.org/2024/07/05-rdf-star-minutes.html Zakim
17:21:02 <Zakim> I am happy to have been of service, gkellogg; please remember to excuse RRSAgent.  Goodbye
17:21:02 <Zakim> Zakim has left #rdf-star
17:21:06 <gkellogg> rrsagent, bye
17:21:06 <RRSAgent> I see no action items