emsenn's Log, 2026-03-28, 1016h

Coming back from weird math

Alright, today I'm trying to dig myself out of my infatuation with my weird math, and bring myself back toward using its ideas to get myself a better presence on the Web.

The math... is only ever going to work as well as it works. My recent foray into it affirmed: by all known standards of math, it's broken math. I can see where it breaks from normal math - or, from my perspective, where normal math inherits Platonic metaphysics - a lot more clearly, though, which should help, but that also means, I need to put it down and only pick it up to use it.

And, I have gotten better at seeing its shape, and how that manifests in things like data & knowledge systems.

The trick now is trying to bring the ideas out of strict formal math world, and into the world of things I can talk about.

And so in this log, I'm going to try and practice that.

Planning this log

One thing I've realized is that I keep tripping myself up in multiple ways, because I'm always trying to talk about two (or more) things at once, and one thing I've realized from trying to explore this philosophy mathematically is that that's not simply be being a sloppy thinker and writer, but a natural consequence of how I think stuff works, as I'll hopefully make clear shortly.

I bring it up BEFORE saying anything meaningful, though, to highlight that I'm going to first speak about a very specific paradoxical phenomenon, a "primordial" paradox, and that's one thing. Then, I'm going to talk about how that phenomenon shows up as a recurring process, specifically in my ontology and epistemology.

From there, my hope is to stretch into, and here's how I'm using that to shape how I'm taking notes and writing software - which I'm hoping to be the useful part of this log for myself, as that should help me consolidate my recent math explorations with my less-recent philosophical explorations with my old software explorations.

Harnessing the void

"Why does something exist, instead of nothing," is trivially answered, "because nothing is still a thing."

But if we're more specific, nothing is a configuration: it's relationlessness, which is, unfortunately, a relation of having no relation with relating.

This sounds tautological, but being more specific again, we can see that "relation of having no relation with relating" is a very specific thing: a subject (relation), a predicate (having no relation), and an object (the... object? the... subject again, but from a different perspective?)

Hidden in the parentheticals, we see the question has just changed shape, from a paradox, to a hypothesis that can conjectured about: what is that there, on the right-hand side of that mysterious little statement?

We also can see we have more than what we started with: we have the mysterious little statement, itself: "<something> having relation with <something>".

In fact, if we're careful, we'll see, that's all we have that we haven't already firmly defined.

And so, relating must be "having relation with something," which again sounds tautological until you turn it back toward our specific paradox: we're now defining relationlessness as "the relation of having relation with <something>"... which has not actually resolved the paradox. But it has described it in more detail. Which is to say: we have a hypothesis for the theory for the hypothesis we've just created.

Relationlessness is still on the left-side, with Relating in the middle, but now instead of having Relating on the right-hand, we have this new thing, Relating-with-Relating.

At this point, we have this little paradoxical contraption that takes Relationlessness, and through taking it seriously, creates a stream of directional Relating, which serves as a theory for hypothesis we just used to theorize about the first hypothesis, which itself was about a paradox. As this directional Relating moves through the structuration of theorem that asserted it originally, which is itself directional, the configuration is "spun": one side facing toward conjecture, one side facing toward proof.

Now the... hypothesis, theorem language, it's helpful in explaining the logic in some ways, but obfuscates that this isn't just external reasoning we're applying, but is what is happening, within this broken funky lopsided algebra we've made around Relationlessness: rather than having any sort of truth or zero to appeal to, this algebra can only create formulas that witness configurations of this directional relation.

That paragraph didn't help.

But maybe that means I'm ready to move on to the next section.

Absurdity of knowledge

Absurd, in the old sense, means a thing that is true because it is true, and has no way to NOT be true.

Relationlessness, it would seem, is such an absurdity.

However, if we look at what just happened, we can see that Relationlessness went from an absurd prior truth, to something that is trying to relate, to something that is relating, to something that has related.

This is a progression from absurdity, to possibility, to necessity, to determination. However, critically, the determination is reliant on an absurdity, and so itself becomes the structure for future progressions of absurdity to determination.

And because this is not inert data, "this is true, that is false," but unsettled conjectures of relational being, any determination can never actually be proven fully true or false. All that can happen is that it can be structured, witnessed, proven, relative to other theories about proven things.

But if we were to untangle it, we'd see that every proof, no matter how internally robust, is structured on the same directional conjecture, which arises from "harnessing" the paradox of relationlessness as a generative, excitative force.

I can tell I'm losing steam on how to explain this cleanly, but because everything grows from this inductive paradox, we end up with hypotheses "braiding" together to form new theorem, and as the cycle repeats, it becomes clear that what is the "relational algebra" used to witness one act of relating, is actually the "relational dynamics" of more primitive relations, themselves the "geometry" of more primitive relations, which is itself the "language" of more primitive relations, who themselves form the algebra of this relational witnessing cycle.

This is a wild set of ideas that is so similar to many existing ideas it's hard not to explain it wrong, or try and explain it through more familiar concepts.

What's important is that any relational configuration of sufficient complexity is simultaneously an algebra, language, geometry, and dynamic system, and because there is inductive complexity outside the system, this always results in a more complex system that treats the inductive system as its initial algebra.

And, as we determined, to the limit that we can, in our initial exploration of Relationlessness, Relationlessness is Relating to anything that meets the conditions of Relating-with-Relating.

Well, anything can be said to be Relating-with-Relating. And so anything fits into this configuration of relationality, and how specific of a proof we can offer beyond that depends on how much of the configuration we have specified between Relating-with-Relating (our least-Absurd Determination).

Now what we can do is look at what we've proven, for our relational algebra. We have Relationlessness, we have Relating, we have Relating-with-Relating. We can call Relationlessness Absurd, we can call Relating Possible, and that makes Relating-with-Relating Necessary, and so we can only conjecture that Relating-with-Relating is Relating with Relationlessness-Relating-with-RelatingWithRelating.

So if anything is Relating-with-Relating, then anything is Relating with Relationlessness-Relating-with-RelatingWithRelating, which gives us the same basic algebra, but over arbitrary whatever instead of Relationlessness.

What this gets us is a very robust way to say that saying something like "x relates to 3" is Absurd, because there is not enough relationality in the statement for it to be anything but true to limits of its own conjecture, while also treating it as a determination, something that is locally true.

This is, on its own, not very interesting. If more conjectures are added to the same relational configuration, it can still stay fairly boring: "y relates to 7" would be equally absurd, equally a Determination. The two conjectures would affirm the structuration of their hypotheses, which is actually not nothing, but it isn't that interesting.

If we throw in something like "x relates to y", we excite a new configuration.

None of this starts getting interesting until we start replacing what "relates to" means, which I suppose shows the problem of trying to spontaneously write examples of weird ideas, and why I was moving toward doing this hands-on with my data, which... again shows maybe it's just time to transition to the next paragraph.

But, this was useful in helping me discuss these things, which is a good deal of the point of this particular text.

The map is not the territory

So, in essence what we've been doing is showing that any relational configuration, any "this relates to that," can be seen as a sort of witnessing-process, where the internal rules - the internal witnessing-processes - of that "relates to" coordinates the claim somewhere between Absurd and Determined, through Possible by way of Necessary, depending on how exactly the witnessing processes orient the configuration being witnessed.

One important thing to understand is that what's happening here, in this text, is some form of that processing: I'm presenting, through English grammar, proposed relational configurations. And you're taking them in as proposals, and the rules of English serve to convey the "relational algebra" of what I'm saying. Well, more literally, the relational geometry, through English as a relational language, so that I can talk about the dynamics.

We think of words as atomic little things, if we think of them at all, but they're more like latent relational configurations, and depending on how you excite them, you end up with some configuration of Absurdities, Possibilities, Necessities, and Determinations.

Of course, keep in mind, that even Determinations are just Absurdities that have the weight of Possibility cemented into Necessity behind them, so no matter how coherent the structure may seem, when looking down on its conclusions, its important to understand that it's all rooted in an Absurd paradox, that Relating is Relating because Relationlessness cannot not be Relating. (I bet you hoped we were past the Rela-Re-Relating bits, huh.)

So, without any base case, without any "this is true" or "this is false" to rest things on, suddenly, everything familiar loses ground.

The best you can say is: Well, given what we're accepting as true, this is either trivially true, as in, not related to anything we've already done, and so its true because it says it is and we have no way to measure that: Absurd.

Or, if it relates to something Absurd, then, it becomes, relative to that, Possible, which makes the Absurd Necessary, and given it's the witness/structure for what's Possible, then it's Determined, making what's Possible Necessary and making space for new Possibilities.

Which is me trying to say rather than True/False, we end up with a much stranger logic, where there are superficially four values (Absurd, Possible, Necessary, and Determined), but Absurd and Determined are two ends of the same open inquiry, exciting new Possibilities and affirming what's Necessary, respectively, so what looks like a four-valued truth system turns into something closer to a linear logic that does something like term normalization, where every relational configuration boils down to some configuration of various Absurdities. When we're working in the abstract, that Absurdity is Relationlessness, but in practice, that Absurdity is any datum in our system: anything that has to be taken "a priori" to the relationality being calculated.

Given almost all data systems boil down to some sort of key: value, where we can assume : is Relating in its most general, this means we have a way to look at data systems as epistemologies developed by this relational ontology; geometries structured by this relational algebra.

But critically, : almost never just means Relating, the way = in math cannot mean equivalent without defining (usually impliclty) the mathematical universe in which you're operating. Which means that the map constructed via this geometry - and the physics of that relational world, its climate & weather - are skewed, twisted, and broken.

But it's exactly those ways in which these systems fail that's of interest to me. After all, the inductive paradox of the whole way of thinking is rooted in Relationlessness failing to hold to its own constraints, exciting a system entirely around witnessing that failure.

If we "flip" how we've been looking at this, and remember that this is both an abstract metaphysics and means of ontologizing and conducting epistemology, then suddenly those failures stop looking like where the "math" breaks. Instead, they shape the internally-induced conjectures that form the boundary - algebra - between the unbounded Absurdities and our theorized Possibilities, themselves structured by what's Necessarily Determined by our already-accepted Absurdities.

If we look at this structure as the map, and the world of Absurdities it relies on as its territory, then we can see: not only is the map not the territory it maps, but it isn't even mapping that territory: it's mapping the structuration that makes the territory possible. If we think of data systems, that means that we aren't looking at what data is there, we're looking at what Absurdities and Relations - initial algebras - must exist to let the data be there, in the first place.

And if we accept that rather than traditional results like False or Null or whatever, we'll get irreducible configurations of how our Absurdities relate, then we find ourselves with something that has some sort of funky infinite coalgebra, and the transinite & finite algebra that are determined by that.

And if we remember that our Absurdities are Absurd because they, like Relationlessness, try to claim Relating without Relation, and this irreducible configuration is their oreitnation relative to that primitive Absurd configuration, then we can recongize that what we have over any data is a filtered spatiotemporal manifold, where what has been Determined becomes the structure for the entanglement of what is Necessary and Possible, and that entanglement is governed by the relatioanl configuration of the Determined.

So, not a map, but a snapshot of the rules/structure that make the map's subject Necessary.

Practical implications?

I've been babbling on this for a bit without really being clear on why. There's a great number of reasons. Some are deeply spiritual and theological, others are more straightforwardly logical.

The practice that most concerns me these days is establishing a much more robust knowledge system, for my own use and the use of peers. I have... many notes, on many topics. Some are just, notes about known things, and others are my own conjectures I've built ontop of that, and none of this is clear.

I've waffled on which tools to use a lot over the years, but advancements in AI have made this sort of stuff newly fascinating to more people, and so there are clear community standards that I can align with. Before, really the only sort of people who cared about how to encode meaning in text files were the sort of folk who cared about note-taking systems: certain kinds of researchers, writers, and tech workers, and with that little interest, there was a decent amount of fragmentation between what tools to use. Among folk around me, it was mostly: serious folk used Org-mode and Org-roam, and if you weren't so serious, you used Obsidian and Markdown files.

Markdown, being way more popular in general, albeit not containing almost any of the complex knowledge-management stuff Org-mode has by default, became the standard for formatting text used by AI systems, like the AGENTS.md that shows up in so many Github repositories these days.

I like open-access, open-science stuff, and so the appearance of this stuff in the field made it a de facto community standard to use Markdown with "Yet Another Markup Language" (YAML) frontmatter.

So I've been converting my notes and writing and everything to that, and so I end up with something like:

---
title: "emsenn's Log, 2026-03-28, 1016h"
date-created: 2026-03-28T10:18:00
authors: [emsenn]
---

## Coming back from weird math

This gets us, as you can see, a bunch of Absurd relational configurations, and complicating things more, we're saying that the file itself is witnessing this relational configuration: it's the key: to this whole file as a value.

But wait.

Didn't we just go through a whole big dance of hard-to-read nonsense in order to establish that if the file witnesses this configuration, than this configuration, albeit Absurd on its own, becomes Necessary for the file to witness them, which Determines them, at least locally.

So, while any relational configuration witnessed/claimed in the frontmatter is Absurd, definitionally, it's Determined locally, which makes the file its own witnessable relational configuration. It can't prove anything is True or False, because we aren't working in a system that has those, and haven't witnessed them as any sort of relational configuration yet.

All we can do is prove how something is determined. We might only care whether or not it is, but that's us throwing out the structure to check a predicate, and that might be fine, but we might want the full structure.

Which, if we were to apply this to all my babbles, would show... that we have a lot of Determinations about date-created Relating to all sorts of strings, we would have lots of Determinations that authors relates to emsenn.

And that's about all we'd have: a very sillily formal way to look at what is obviously there in the frontmatter.

But can this formality get us anything? Well, we can say that title is a Determination of kind relating to author and date-created.

If we're claiming that relation/configuration, then we'd need to witness/prove it. Which means it's Necessary, something else is Possible, and what makes that is something Absurd: the actual relational configuration between these configurations.

At that point we can just, make some Absurd Determinations like "kind then author" "author then date" to fill in the gaps, and suddenly we have... an exceptionally overwrought mechanism for string concatenation!

The real question becomes, can we configure relations in such a way that they start to constrain each other's possibilities and determine what's necessary, rather than just show Absurd everything else?

For that, we'd need to start building a more complex ontology ontop of what we've already established, but notably this wouldn't mean involving any new algebra. Instead, it'd mean witnessing the configuration of the Absurdities we already have: what configures a date-created? Well, our calendar system, and the datetime on Earth when the witness was configured, the relation occurred. Which shows we either have to assert a calendar system, like with external software providing the rules, or write the rules within our own relational algebra.

But I'm realizing I've already kind of talked myself into a weird spot here, trying to show how this system can provide the exact sort of stable predicates that is exactly what it fails to do.

These rules I'm talking about would be just, local facts, and violation wouldn't be "violation" in some external sense of things, but more like... divergent claim, and across more complex systems of configuration, there'd be an irreducible configuration of Abstractions required for the claim to be true.

In practice, extending our example, this would let us see "hey, within this directory, we've asserted authors relates to emsenn 800 times, but this one file asserts something different.

This is much softer than something like schema, but allows for a different sort of approach: rather than treating data as invalid until it adheres to the rules, we can look at what structures are already firmest in our data, what diverges, and how.

If we need the "strictness" of traditional logic, we can simply say that things which deviate from norms get dropped, or treated as errors, or whatever.

So the question becomes, is there a way to use key: value stuff in Markdown frontmatter, in my notes, with these ideas, to help me start weaving together the various ideas that I'm working with in various parts of the notes? (For this, we'll assume two keys are the same if they're exact string matches.)

This is where I think things get interesting. We've been saying key: value, but like I highlighted, it's actually more like file -> key -> value

This means that what we're doing with our frontmatter is essentially writing very simple sentences: subject -> predicate -> object.

Only as I just spent too long explaining, we don't have predicates, and we also dont' have subjects or objects: we don't have anything solid and true like those things are: instead, we have witnessing of relational configurations, each of which boils down to some sort of Absurdity.

And if we conjecture that all these Absurdities are related, in some way, then we end up with a pool of file, key, and value, that if they overlap, provide more information about the relational configuration of that given token: date-created ends up being densely configured with relations to various timestamps, and each of those timestamps is its own Absurdity, determined by that date-created configuration.

Where things get more interesting is if we switch from

authors: emsenn

to emsenn: babble... or would it be babble: emsenn?

Well, until I use it, because we're working with self-determining Absurdities, it doesn't matter. And if I use it both ways? Well, we end up with both. Which would be a contradiction if we were imposing some external sense of truth, but there is no established "truth" for what's a "legitimate" relation between the two.

Which configuration would be more-Determined, that is, literally more woven into the structure we'd be using to make this determination, would depend on what else is already in the system.

This gets more interesting when we look at something like a research paper.

We might normally write some frontmatter about citations: with its own cite-item: {authors: [citation-author]} setup, for authors, DOI, etc. We might separately have a tags: [main-topic, subtopic].

What if instead we mapped the keys from our citations directly to the topics they're related to, in our text, i.e. cite-item: main-topic.

that there was a relation between the two was already established by the existing frontmatter being within the same file, but now we have an explicit configuration of how the two relate.

There's ways in which this can get very fascinating: accepting our return values will always be irreducible relational configurations, we can start examining the algebraic and categorical qualities of our knowledge.

The question becomes... how to actually do this, over real-world Markdown files - and, the more implicit and more implicit question: why do this?

There's two answers to why:

This helps me see what open questions exist in the specific locales of knowledge I'm investigating, what conjectures might address them, and what underlying absurdities would need to be more well-defined before those questions can resolve.

This helps me provide a different sort of provenance on the Web: not just what the underlying a priori claims are, but how they relate in order to form whatever conjectures the piece is making.

Neither of those are very easy to demonstrate in the abstract though, so that brings me to the question of how to implement this system, given the a priori determination that we must use open-access/-science tooling to relate to this weird underlying philosophy, to relate it to conjectures about how to think and act in the real world around me.

Given the scope and diversity of knowledge I investigate, it's hard not to jump immediately to a set of tech like PydanticAI, clingo, rqlite, FastMCP, and others... but then that doesn't leave me very tethered to the flatfile means of operating with computers I've grown used to, and is becoming even more prevalent, like I mentioned, with AI agents.

So the question I think looks more like a script that can be pointed at a file and creates its relational configuration, and gives us that, probably as JSON-LD? Although at other times, I've considered TTL, and SHACL, with the idea that this lets us more immediately treat the object as a geometry with an algebra.

What is Absurdities, philosophically, becomes our Tokens, and our conjectures/witnessing/relating-with-relating becomes the edges between them.

They key thing is that directed edges would be created not off of the key to the value, but off of the file to the value, with the key typing the edge.

And then the next step would be making it so that the script can be pointed at a folder, rather than directory, such that it would take in the whole contents as locale, constructing a single graph orienting all our tokens to their most-Determined relations.

From there, subdirectories, and I will have an incredibly messy graph to work with.

The temptation, like I said, is to look at something like LangGraph immediately, because even though they're just ordinarily YAML, giving them ontological weight weirdly corresponds to letting them work like models in multi-model agential systems, only instead of taking in arbitrarily strings, they take in and return a very limited vocabulary.

I think what I'm seeing is that I need at least two data classes, Token and Claim, with Claim being two tokens held in a directional/oriented relationship.

Going back

---
title: "emsenn's Log, 2026-03-28, 1016h"
date-created: 2026-03-28T10:18:00
authors: [emsenn]
topics:
- emsenns-web-presence
---

Ten tokens, five claims. But the whole thing itself represents is one claim between two tokens - the file and these claims together.

So we need three classes: one for Bases, one for Tokens, and one for Claims... well, but now Claims and Tokens are the same thing: an oriented/directional relation between two Bases.

So, ten Bases, five primitive Claims, and then the compound claim that all these things relate to the file, which means the file would have to be its own Base, and... what holds the Claims together?

Philosophically

Base to Base relation is a Claim Base to Claim relation is a Claim Claim to Claim relation is Claim

So every Claim reduces to a pair of Bases, the left-base and right-base, to bring it back to the language at the start of the conversation.

That's exactly what I wanted, so then the challenge is to stop glossing over how "reduces" and things work.

We have two classes, and we need to treat one as the node in our graph, and the other is used to populate the edges.

So then we can query a base, and see the structure of the claims that "determine" it - hold it to one side of the claim - and the claims that derive from it - hold it on the other.

And if we query a claim, we'd get the structure of the claims and their underlying bases to see what's used in supporting that particular claim.

And if we query a claim that doesn't exist, we'd get the structure that would support that particular claim.

And, I'm conjecturing, there's some cool algebra and category math we can do to those structures.

Which I guess shows me I need two tools: something for taking a snapshot of the relational structure of a file or directory or whatever, and then another for examining that snapshot.

I'm just assuming there's a standard way to read YAML into Python, and save that data to Sqlite; that's easy enough. The snapshot reader is the more interesting question, and I wo wonder if PydanticAI and LangGraph wouldn't be the right tools from the beginning, with a FastMCP server on top.

(I of course immediatley begin wondering about hooking that up to the live filesystem, so that each file gets treated as its own model with a bespoke MCP "server" talking to LangGraph and PydanticAI...)

But I should focus on: if I get this graph, how do I do anything with it.

First in the abstract, and then with a goal toward getting it on the Web in some interactable way.