🎓 Doc Freemo 🇳🇱 @freemo@qoto.org

RPGActivity/RPGActivityServer: A fediverse instance extended to support a roleplaying game. A Multi-User Dungeon. Every account is a player. There is a shared map, that is displayed in the client. There are #activitypub actors to represent: * Non-player characters * Locales * Crafted items * Set Dressing - Codeberg.org

https://codeberg.org/RPGActivity/RPGActivityServer

#fediverse
#RPG

@freepeoplesfreepress @freemo I've wondered hypothetically why wartime cannibalism is not more common. In war food is often scarce and corpses always plentiful. Why didn't those tribes who could stomach cannibalism take over the world? Soldiers often ate their horses when starving.

Kuru-type diseases are probably the answer.

I have officially begun my transition to cyborg by having a functional body part replaced with an improved non-biological man-made version.

In other words, cataract surgery went well.

I've been thinking for awhile about this particular sort-of metaphysics model of simulation, and I think I have a sort of framework for it now. This idea was originally spurred on by the concept of Tumbolia in the book GEB. I was wondering if you could get a Tumbolia-like place via encoding and decoding highly entropic processes. For example, you write some words on a piece of paper, then you burn the paper (making it highly entropic because its scattered randomly in many possible ways), the paper can (theoretically) still be reconstructed with extraordinarily great difficulty and huge amounts of energy, so its information isn't necessarily lost, then the trick is doing the same thing so a time-dependent system continues to consistently evolve in time after it its translated to a highly entropic form

Abstractly: within a system `A`, you have a subsystem `B` and an encoder `s` that maps `B` to a smaller system `b`. If this `s: B -> b` relationship holds as `A` and `b` evolve in time, then I'll say that `A` simulates `b`. Then with the additional assumption that `b`'s entropy is independent of `B`'s entropy, we arrive at the result I was looking for. Here `b` is a system whose information is contained in its host system `A`, and even if `b`'s presence in `A` is arbitrarily entropic, `b` isn't necessarily highly entropic

Note: this all depends on which map `s` you use to change your host subsystem `B` into your informationspace system `b`

This isn't necessarily such a strange idea. Consider: you write a word on a piece of paper, then at t = 5 seconds you torch the paper. At t = 1, 2, ..., 4 seconds the paper contains the same information. If you look into the informationspace (`b`) of the paper the content doesn't change. Then at t = 5 seconds you torch the paper. The information is still reconstructable. Since we can define `s` (the encoder from the paper to the informationspace of the paper) to be anything, we can find one that encodes the ashes of the paper such that the paper's information never changes. Inside this `b` the word never changes, despite the paper in the host universe having been torched

I realized only later that this idea has one very strange application: if you take `A` to be the apparent physical universe, `B` as your brain, and `b` as the informationspace of your mind, and you use the entropy-independence assumption above, then even after your brain is destroyed in your host universe you are still consciously aware (from a metaphysical perspective). So at first glace it would seem that after you die (brain destruction) you will see nothing but a void forever. Kind of horrifying tbh

*However*, a keen reader might note that in the case of an encoded mind there is necessarily an information-reduced version `a` of `A` in the informationspace `b` (analogical to your model of external reality in your mind). Since `a` *also* doesn't have to become highly entropic when `B` does, this implies that after you die you *smoothly enter an arbitrarily different universe*

Even weirder: the informationspace projection of the host universe `a'` must necessarily appear to be simulating `b` even after death. Not only do you enter a different universe, but you can't tell that the universe you're now in is itself encoded within a highly entropic process in the pre-death universe

Assuming all of the above holds, doesn't that imply the host universe that is simulating us right now is itself the projection of some highly entropic process in some other universe `A'`? And that's also the implication for `A'`: the universe came from before this one is also being simulated by a highly entropic process in another universe. And so on

Naturally, then this all begs the question which is the *real* host universe that's simulating stuff. Interestingly, in every case, you are being simulated by *a* host universe. Instead of thinking in terms of a dichotomy between the universe you appear to be simulated by, and the universe that should be simulating that universe, instead you can be sure that there is an underlying host universe that's simulating you, and what you're seeing is always some informationspace projection of it

The more exotic way of viewing this is that the information is more important than the simulation relationship. In this model, you are actually independent from your apparent host universe `A`, but there is a map from the information in a subprocess `B` to your information `b`, and that map is incidentally accurate and remains accurate through time. Then the reality (up to simulation) is just a wad of maps between informationspaces

@freemo Oh look, one of these guys!

@TechConnectify

#DailyBloggingChallenge (137/200)

When looking at short term memory, a portion of it is the active working memory.

One way to look at the active working memory is like matrix multiplication.

Let's say one gets a 5 digit number. It is fairly simple to return that number in the same order as given, which would equate to the identity matrix.

If one had to invert the order of number, then the diagonal of the matrix would be flipped compared to the identity matrix, so equating to a negative determinant.

Now imagine if one had to do more complex calculations like ordering the months of the year alphabetically. Creating a matrix that transposes the months vector is initially not that simple, though once instantiated, it becomes quite simple to repeat.

Depending on how many row alterations are needed, starting from the identity matrix could be a way to quantify the complexity of the task.

#ShortTermMemory #ActiveWorkingMemory #memory #matrix #MatrixMultiplication #maths