diff --git a/orbitmines.com/src/routes/papers/2024.AUniversalLanguage.tsx b/orbitmines.com/src/routes/papers/2024.AUniversalLanguage.tsx
index 505b5ce..80e1ed0 100644
--- a/orbitmines.com/src/routes/papers/2024.AUniversalLanguage.tsx
+++ b/orbitmines.com/src/routes/papers/2024.AUniversalLanguage.tsx
@@ -140,11 +140,11 @@ const AUniversalLanguage = () => {
- Perhaps you could consider this as my attempt to provide proper infrastructure for that exploration.
+ Perhaps you could consider this as my attempt to provide proper infrastructure for that exploration. Perhaps not just exploration, perhaps better communication.
- Though, in my ignorance, only recently - and amazingly after naming it Rays - did I become properly aware of the scope of this project . And so, even though I still need to learn more about his history at some point, allow me to take on ' naming: A Universal Language.
@@ -160,12 +160,34 @@ const AUniversalLanguage = () => {
- Not much of a somewhere. But
+ Not much of a somewhere. But the basic premise becomes this: I don't know what things around me look like. Let's start by looking around me in some direction:
+ I don't yet know what this is or means, I just know I moved in some direction. You'll start to see the pattern of what we're doing here: I need to start traversing to find things around me - otherwise I can't know about them.
+
+
+
+ Alright now let's try to move backwards.
+
+
+
+
+
+ You'll see that there's no recollection of what we just did. In order to say even something as simple as that, we need some notion of memory. We need some way remember what we just did. Let's try it again with a notion of memory of where we've already been:
+
+
+
+
+
+ ...
+
+
+
+ Essentially what any of this comes down to. Is things are entirely inferred from surrounding context. Yet your abstractions can be ignorant of how you're using them. Whether something is a function, number, geometry, topology, ..., structure becomes quite hard to say when you consider its surrounding context [REPHRASE]. More usefully what we're doing here, is saying: "Can you see a difference? And can you ignore it?"
{/* TODO: This needs to be different, not good*/}
@@ -187,17 +209,41 @@ const AUniversalLanguage = () => {
{/* TODO Link to reversibility here>>>. */}
+
+
This needs some restructure, good ordering here
+
+ ?
+ ...TODO... This way, you can just draw a single line (or even arbitrary structure), and say: "What if I wanted to regard that as the same? What would happen?". The answer to those are far from obvious.
+ Note that whenever you have a self-reference through operators. Either we break the recursion there through some implementation. Or we simply decide to stop orbiting. And say it could be any of these things, it could be any of some superposition of things.
+
+
+ {/*A simple example could be the difference INITIAL + NEGACTIVE VS TERMINAL + NEGATIVE VS INITIAL/TERMINAL*/}
{/* TODO Elena; "Formalism rosetta stone?" */}
+ Almost always with any abstraction, you'll see the following simple pattern: (1) First one of something, (2) then more of things like it, (3) then some recursive construction of that thing. And noticing that is far from obvious.
+
+
+
+
+ But this introduces a rather hard problem, namely that: .
+
+
+ Part of any task then, becomes this: . This should somewhere be quite intuitive: You can use tools without knowing how to make those tools. Essentially wanting to understand unknowns, might as well be called reverse engineering: How is it done? How can it be replicated, decomposed, ..., understood?; What aspects of it can I understand?
+
+
+
@@ -209,7 +255,7 @@ const AUniversalLanguage = () => {
Note that with compression, we're always necessarily partially ignorant of context and relying on some invariance . Thus, any story about compression, becomes a story of rediscovery. Bringing with it an incredibly complicated world: You will have to deal with redundancy, ambiguity, forgetting, assumption violation, ..., inconsistencies. Where changes in resources, ..., capabilities will always play a role in how, ..., when one can compress. Or even better: This will *always* play a role in any (partial) translation. It's just often ignored as a problem.
+ className="bp5-text-muted">how, ..., when one can compress. Or even better: This will always play a role in any (partial) translation. It's just often ignored as a problem.
@@ -293,15 +339,36 @@ const AUniversalLanguage = () => {
+
+ Version control, causal histories, theorem proving, ..., a (programming) language are all rather similar. Always we consider some sort of persisting, surviving, ..., crafted items whose rediscoverability is not entirely obvious. In the case of version control, or reversibility, the gnawing question becomes: "What if I didn't know about something?"
+
+
+
+
+
+ nor could rely on these things I currently know about.
+
+
+
+
+
+ could I rediscover this other thing I'm interested in?"
+
+
+
+
+
-
+
-
+ {/*I suspect that we've always lacked a proper tool to think across fields. E*/}
And to wrap up this "Wrapping up" arc, allow me to repeat a few things already alluded to in my 2023 thought excerpts : & . Which by default should carry over to everything I write down. Though repeating it might be necessary.