i wonder if there's any way to detect semantic correctness. usually you can detect syntactic correctness or errors by validating against a schema, but how might one be able to detect that a statement is nonsensical? i guess assuming no internal contradictions, then there should still be some external contradiction with whatever you define as "sensical".

something like "colorless green dreams" is semantically contradictory in that something can't be both colorless and green, but on a more subtle level you might define that dreams cannot have a color. or maybe they can, depending on how you define dream (i.e. a visual component may produce an image that may have color); so semantic precision is part of the issue. but while *you* may be precise, others may not be. adopting statements from others may lead to contradictions with your own axioms.

in a practical sense, fedi's data model is growing increasingly idiosyncratic because there is not enough consideration for having things make sense; the evolutionary path of fedi has been driven by compatibility, which entails copying what already exists even if it doesn't make sense

that said, the nonsensical nature of fedi-flavoured as2 representations is something that i can't really describe as a clear contradiction with anything. it just feels like there is a contradiction *somewhere*, but i can't pinpoint where exactly.

consider a `tag` a `Mention` which is a `Link`, instead of directly tagging a `Object`. on one hand, what does it mean to tag a Link? you're referencing a reference and you can't assume any transitivity, so how should that be interpreted?

given some hypothetical profile of as2, we might say that in this profile, the range of properties like as:tag is not Object or Link, but instead it should only be Object

honestly idk where it would actually be appropriate to use a Link anyway. i think as the value of something like as:url it might make sense if you want to qualify the reference, but it would have maybe made more sense to make as:url be a string value instead

really the most useful thing you can do with a link is give it a rel

but in a lot of cases if you have a link with a rel, then it also makes *more* sense to just make it a property of the object.

as2-core example 14 describes an Application whose `image` is a Link. that Link has a rel of "thumbnail". this makes no sense. `image` is "an entity that describes an image for this object". if the intent is to describe that the image is a thumbnail, then why not directly declare a thumbnail? this is even more confusing bc "thumbnail" isn't a registered link relation!

basically the functionality of reifying a Link in as2 is to be able to describe how a linked resource should be used... but this is the kind of approach that only really makes sense if you have a generic grab-bag of links. and fedi often overloads the `tag` property as this grab-bag... which makes it a lot harder to use `tag` as intended.

@trwnh
Semantics concerns itself with "meaning". Not with " reality". I think you're more in pragmatics territory tbh

@anantagd maybe? what i'm trying to get at is the idea that people might say something that doesn't mean what they think it means

@trwnh oh you mean AS2, not general formal reasoning

this reminded me of Gödel's incompleteness theorem

any sufficiently useful and consistent set of axioms will have some statement X that is unprovable under the existing axioms. Trying to get to 100% might introduce an inconsistency (and being consistent is more important than being complete)

that's not to say that some axiomatic mathematical spaces aren't provably complete (many are), but that sometimes completeness lags and that's okay, so long as it's not contradictory, and as long as there are enough axioms to be useful

@risottobias if we're trying to reason about as2 then the problem is that a lot of what fedi produces is semantically incorrect

like if you were to consider all subjects which have a `tag` of a certain resource, you will get zero results because fedi ended up being indirect with everything. nothing is ever declared to be a tag; instead, we tag a *reference* to the thing.

@trwnh I don't think formal arguments about semantic verification are the issue here. I mean, one could use a more strict kind of schema or different representation to lock things down, but I think the underlying problem is due to design. Different networks want to do different things.

How is a Masto post like a Reddit post? How is a Peertube video like a Masto post? Can a Peertube video comment have a video in it? Why not?

Like, if you reduce all the networks only to what is semantically shared, there isn't that much in common to specify, and if you specify every extension and rule of every network, then anyone implementing a client will be overwhelmed.

Provided there is a forum where network developers can work out inter-network specifics, that might be as good as it gets...?

@sixohsix no, they actually share a lot at the semantic level! the difference is almost entirely in presentation, enforced at the application level.

the problem is implementers stuff everything into a Create-Note-shaped hole, declare width/height on an Image instead of on the binary asset, tag Links instead of actual Objects, and so on. schema doesn’t help because everything is optional and the vocabulary is loose enough to allow basically anything. it’s valid grammatically, otherwise nonsense.

@sixohsix this is clearly a case of semantic confusion all over the place, basically. the intended definitions are overloaded by implementers who don’t know any better — even official examples can be wrong!

and at some level the differences between different things start to matter; for example querying a graph for posts tagged with a certain thing will show you 0 results because no one tags the actual thing, they tag a link instead. you end up needing application-level logic to make sense of it

@sixohsix and programmatically there’s not really a straightforward way to take a reference and “unwrap” it into the object identifier. you can’t just take the href; you need to make a specific HTTP call with a specific Accept header, then extract the id from that (which may be different from the href, and often *is* different). generic graph-based reasoning tools don’t know to do this. they shouldn’t need to do this. just use the id directly.

@trwnh ah, okay, I think I understand. Though I don't understand what it is about the spec that encourages this to happen. I'll have to read a lot more. Thanks for explaining.

@sixohsix i think it might just be a mix of giving you too many parts and no instructions (or what instructions you have may be incorrect)

for fedi, i’m pretty sure it’s the thing i pointed out about compatibility being valued more than correctness. which is to say: few if any of the “popular” implementations actually care about graphs. they mostly use AP only as a way to pass bits of arbitrary HTML and JSON around. then they throw away all that stuff after converting it to a “post”