The cat is out of the bag, or is it? Schrodinger has some thoughts on that. I had my musings on reality as a simulation stirred up in my journey in Steem Speak this weekend. I've been pondering things around that for a bit again, just like last time. It inspires little musings that I decide to put into words.

I have written a lot of simulations in my lifetime. Mostly for fun and other than a few friends and family they typically have not entered the wild. I also have a passion for game development and an area of particular interest has been procedural generation. I've been super curious about that since David Braben and Ian Bell managed to squeeze an epic space simulation with over a thousand planets that could be visited, traded with, etc in a 48K computer. I would play this game Elite on my 64K Commodore 64, but I was often writing little games for my friends and myself on this computer and I found it pretty amazing that there was so much information in this computer and it did very little disk access. Even had it used disk access, during this time the amount that could be fit on floppy disks of the time would still have made these thousands of planets an impressive feat. There were a lot of people wondering how it was done. Especially in the demo scenes. The demo scenes loved procedural generation as they always had to try to ONE UP the other demo teams by making something really cool happen from a tiny program.

The Making of ELITE (Computer Videogame)

It doesn't seem particularly impressive today in a time when we have massively more RAM, disk space, processing, and graphical power. That game was technologically amazing for it's time.

In games there would be some other amazing examples early on. The game Starflight built a top down space RPG where you were more or less a starship captain, and you started at a station, you explored the galaxy without any of it beyond the space station being revealed. You encountered alien species, and you spoke, traded, and fought with them. Yet, you could also land on all of those thousands of planets (it had more than Elite) and they all had surfaces you could explore and find life forms which you could fight, ignore, capture, etc. You would find ancient ruins with artifacts, and you'd find many different minerals to acquire. This was done in a very small foot print. It was a bit larger than Elite in terms of storage space, but not much larger. It came out years later. This also was accomplished with procedural generation.

Meanwhile the demo scenes never stopped pushing this to extremes. They even created competitions where they would hand out awards to the best demo under 64K of RAM. The entries that float to the top are typically mind blowing in how amazing what they managed to get the machine to do in that amount of memory is.

Chaos Theory - Awesome 64k Demo! [720p HD]

Just in case you don't understand how amazing that is. All of that is generated by a 64K file. That means there are no additional texture files, no additional music files, no additional sound files, etc. Everything you see in such a demo comes from the 64K demo.

EDIT: This post and all of its still images take up more than 64K used by that demo... let that sink in.

I presented this past history and information to hopefully get you in the proper frame of mind. There are many different ways to approach a problem. This is also true when designing things inside of a computer, and it is true of simulations and games. If you look at games we are increasingly trying to better and better simulate reality, or create new realities. This technology and what we are able to simulate has been growing at truly mind blowing rates.

I became fascinated by computers and programming in 1982. I was interested in video games earlier than that. In that time I've seen games go

from this:

To this:

The detail and the acceleration on approaching oneness (aka singularity) with reality is pretty staggering. Most of this does not tap into procedural generation at all. Most AAA companies just throw people at a problem, and they work within the confines of whatever the latest and greatest at that time. They don't always focus on keeping things as small or efficient as possible. It tends to be the smaller individuals and others who cannot afford a huge art team so they are trying to find ways to cut corners. How can they for example, create all the textures and art they need when they don't have a texture artist dedicated to their team? How can they generate all the levels when they don't have a level designer?

Often the answer is to go procedural. They code mathematically based functions, methods, algorithms that when given a certain amount of input, which is generally simply a few numbers can generate large amounts of content. It can generate textures, it can generate levels, it can generate music, it can even generate NPC behavior.

Minecraft is an example of this... It graphically may not look like much to people who were becoming enamored with more and more realistic imagery. That was not where the amazing stuff is. The amazing thing is the infinite nature of the world, the fact each world is vastly different from the last based upon a single number seed you use when creating it. You can tear down and construct things, it has life forms, it has time and weather, etc. For most of the creation of all of those things it was done by a single person. He did wonderful things. If I were to condemn anything in the design it would be the choice to use Java as the language it is based upon. Yet it made him a billionaire. It's wizardry is all in procedural design, and good game play choices.

(Official) Minecraft: The Story of Mojang (Pt. 1/2) - Proof of Concept for Feature-Length

(Official) Minecraft: The Story of Mojang (Pt. 2/2) - Proof of Concept for Feature-Length

So you may be wondering when I am going to get to more on the simulation hypothesis... This hypothesis is based around some pretty deep thoughts and some of these thoughts are easy to see as barriers if you don't have a firm grasp of what procedural generation is and how it works. With a powerful enough computer everything around you could be a product of such techniques.

So how would we know?

That is the big question. "How would we know if we were inside of a simulation?" It really depends upon the simulation and the capabilities of whatever device, machinery, computer, etc it is running inside of.

Yet the places to look for clues would be at the boundaries of infinity. This is where problems occur in our modern simulations, but even in things like Minecraft it can take a literal week of your real life running in a single direction to reach the edges where the math starts resulting in strange things happen. This is simply due to the amount of memory used to allocate a number. If it were increased by even one more byte per number that would turn the week(s) running in one direction into year(s). The amount of memory you use to represent a number exponentially increases the capabilities in terms of the size of the numbers and the precision (aka decimal side) of a number you can represent. I gave some more technical examples of this last night in this post. If you want a more technical explanation check that out.

So this means as we go outwards and look further and further away we would eventually likely reach parts of the simulation where strange things are happening. This of course is also assuming they design simulations today, or if they are people like us today. The other direction we can look is inward. The more you can zoom in on the microscopic level then perhaps we can find where strange things are happening. In some sense we may actually have found this... or maybe we have not.

There is another thing to consider though, another aspect of infinity I have not written about before. Time. You can look at time as units when an action can happen. So for your simulation to work you need to decide on a smallest unit of time. What is the absolute smallest amount of time where you still want some event to be able to occur. Once you have the smallest unit of time you set your loop/timer up to fire every unit of that time. Let's call that a tick. Anything that is larger in time than that can easily be constructed by those ticks. The important thing is that there needs to be a minimum from which to build this clock upwards from.

That is the direction of infinity where we might be able to find clues...

We use atomic clocks and clocks of increasingly more accurate time measurement in our reality. Yet are we also confirming motion, and actions actually occur in those increasing levels of precision? That is what we should be looking for.

If we reach a unit of time where no motion and no activities of any kind occur then that could be evidence of the existence of a TICK.

You could still represent mathematically smaller units of time inside that simulation, but in terms of action they wouldn't actually matter. The easiest way I can explain this at the moment is to imagine a timer where the tick was 1 second. (I know it is not, but using 1 second makes this example easier). Even though no actual actions happened beyond 1 second you could still talk using numbers about 0.5, 0.1, 0.0001 seconds, etc. Being able to talk about faster times doesn't mean things actually happen faster than 1 second.

So I think we should try to find that? Though as with the other forms of infinity depending upon the computer being used that could be an amazingly long journey.

Perception of Time

An interesting thing to ponder though is time in terms of the perception of it. Your mind would also be constrained by the TICK as described above. How fast you can think would be tied to that in some way as your thoughts and the process of them occurring and moving around in your mind are also actions. This means you would not realize how long that tick actually is. Anything outside of that tick would be beyond the actions in your mind and thus, not be perceivable to YOU.

The interesting thing in this case is NOT necessarily what is going on inside the simulation. It is what is happening outside the simulation.

In whatever realm the computer that is running the simulation resides these TICKs could be happening very slow, or very very fast. These would be further time dilation effects.

If the simulation was so slow that the computer was lagging it might go along at 1 TICK for every 10 TICKs in the universe where the actual computer resides. To the observer out there it'd be like watching a stop motion game, or perhaps it would be like watching a game running at 30 Frames Per Second... Wait!! We actually do that quite often... That's right the simulation would not need to run as fast as the reality it is in, as long as the perceivable side seemed real to the observers. Yet we do things in simulations that are actually pretty interesting.

We will run simulations with faster tick times than our own reality. Thus a day, month, year, etc may pass in a second depending upon the observer. This is popular with things like Sim City and other simulations.

In fact there is nothing stopping us from simulating a reality within our own reality on our computers other than the tick speed. The tick speed of our simulation would have to be at the lowest fundamental level at least slower (might be able to get away with the same) as our own.

So if our reality was 1 second ticks, then nothing would stop us from eventually simulating a reality in our computers with 2 second ticks.

Watching for clues...

The clues to whether we are in a simulation truly are likely to be found at the edges of infinity. Though another place to look is at the speed of actions in relation to time.

Here are my previous related posts to this subject:

• If reality were only a simulation how would WE the simulants be able to know for sure?
• If you and I are part of a simulation have you considered time, and seeing outside of that simulation? Real Life 2.0 (RL2.0)
• Now the really weird question. What if you're not real and I am just observing you?

Steem On!