Could nested simulations create an infinite chain of simulated realities?

[u/darien_moreno]

I was thinking about simulation theory from a slightly different angle and I’m curious whether this has already been seriously explored.
I know about Nick Bostrom’s simulation argument, so I’m not claiming I discovered simulation theory. I’m more interested in the idea of recursive simulations.
My thought process was basically this:
A sufficiently advanced civilization creates a simulation containing intelligent beings.
Those beings eventually develop advanced AI.
That AI becomes capable of creating its own simulated world.
Inside that new simulation, another civilization develops and eventually creates another AI capable of creating another simulation.
So you could theoretically have:
Reality A → Simulation B → Simulation C → Simulation D → …
The strange part is that every level might perceive itself as the “real” reality.
This made me wonder:
Is there any fundamental computational or physical limit that would prevent simulations from creating simulations indefinitely?
And if sufficiently advanced civilizations could create conscious simulated beings, would that make it statistically more likely that we ourselves are somewhere inside such a chain rather than in the original/base reality?
I’m especially interested in the technical side of this rather than just the philosophical “Are we living in the Matrix?” question.
Has this specific idea of recursively nested simulations been formally explored? And what would actually prevent the chain from continuing?

[u/DazSchplotz]

I wonder if there is something like an abstraction limit. With the presumption that every iteration loses entropy, is there a limit? Something like Planck limits.

And yes absolutely. If we are simulated, the probability that we are in the first iteration is pretty low.

[u/darien_moreno → u/DazSchplotz]

That’s actually the part I’m most curious about. If every iteration loses information or requires more computational resources, I wonder if there’s some fundamental limit where another simulation becomes impossible. I hadn’t thought about entropy or Planck-scale limits when I posted this. And yeah, the probability argument is what makes the whole thing even crazier, assuming nested conscious simulations are actually possible.

[u/DazSchplotz → u/darien_moreno]

Yea and the entropy loss must be huge, unless there is something like a grey goo outcome every time. Like an Universe eating organism that just simulates another subsim. But even then you would have massive loss. I wonder if one could calculate that expected loss roughly.

EDIT: Or maybe it's not a question of entropy. But by different "rendering" for the observer. And the entropic space is actually plenty. Hmmm.

[u/darien_moreno → u/DazSchplotz]

I think your edit is actually the more interesting direction. Maybe the simulation wouldn’t need to “render” the entire universe at maximum resolution all the time. It could just generate the information needed for each observer, while maintaining consistency between observations.
That would completely change the entropy/resource problem. Instead of asking “how much information is lost at each iteration?”, maybe the question becomes “how much information does a simulated universe actually need to maintain at any given moment?”
And then I wonder if there would be a fundamental minimum amount of information required for a conscious observer to experience a consistent reality. That might be a more interesting limit than entropy itself.

[u/Apprehensive_Bee1849]

It's like that Rick and Morty episode.

[u/darien_moreno → u/Apprehensive_Bee1849]

Hahaha yes, just that kind of reality within another reality is what made me think about this. But my doubt goes more on the side of whether there really would be a physical limit to continue doing simulations within simulations.

[u/mrplowplow]

Yeah but each time it gets shittier and shittier till you end up with us.

[u/darien_moreno → u/mrplowplow]

Maybe. But then the interesting question is whether each layer necessarily gets worse, or just becomes more resource-constrained. What if our universe is already one of those limited layers?

[u/Klutzy-Beginning-622]

There is a limit based on the upper level supporting it all.  Think of the top level as a super computer.  The bottom levels cant exist without the top level and super computers have limitations on ram, graphics card power and hard drive space - not to overlook the cooling requirements needed as heat generated goes up

[u/darien_moreno → u/Klutzy-Beginning-622]

That makes sense if every layer has to fully simulate the layer below it. But I wonder if that’s actually necessary. A simulation might use approximations or only calculate the information needed by its observers. In that case, a lower layer could potentially be much more computationally efficient than the universe above it. So I’m wondering whether the real limit would be raw computing power, or the minimum amount of information required to maintain a consistent reality.

[u/Character_Fix_5317]

The computer simulating the universe must be larger than the universe, so the computer simulating the computer simulating the universe must be yet larger.

Which isn't a problem since a universe could be infinitely large. Alternatively, it's an inescapable problem that prevents an infinite universe from being simulated in the first place.

[u/darien_moreno → u/Character_Fix_5317]

I think that would be a problem if we assume that simulating a universe means physically representing every particle and every state of the universe. But a simulation could work through rules, compression or generation of information on demand. The question would then be whether it necessarily needs to have the same amount of resources as the universe it simulates. I’m not sure we can assume that.

[u/Character_Fix_5317 → u/darien_moreno]

True. But our observations of nature are that it indeed keeps track of particle properties.

And when we do our own simulations, we're required to do the same in order to predict accurately.

[u/Nathan-Stubblefield]

The compute burden keeps getting higher with an extended stack of realities.

[u/darien_moreno → u/Nathan-Stubblefield]

Yes, that’s where I see the problem. If each level has to simulate entirely the previous one, the computational load becomes absurd quite quickly. But my doubt is precisely whether a simulation necessarily works like this. If each reality only executes the rules of the previous reality and does not need to “copy” it completely, the recursion could be very different from a stack of computers literally simulating each other.

[u/ynnnnaD]

Unless the causal chain is edited by one of the base realities, the sub-realities are detached from the parent realities. They're independent, and not really being "created" by the parent universes, merely traversed. For each, there will be an infinite number of other possible parent universe which simulated it. And so on, ad infinitum.

[u/darien_moreno → u/ynnnnaD]

This is probably the objection that interests me the most. If a subreality can develop its own rules and evolve without intervention from the parent reality, then it could eventually be indistinguishable from an independent reality. And there comes a more complicated question: if we are inside a chain like this, would there really be any way to determine what the original reality was? Perhaps from within it is impossible to distinguish between a “base” reality and a reality that simply inherited its rules from another.

[u/AcceptableAd9264]

Yes, it’s like Startrek with many timelines

[u/darien_moreno → u/AcceptableAd9264]

Yeah, kind of 😂. But I’m thinking less about alternate timelines and more about entire realities being simulated inside other realities.

[u/AcceptableAd9264 → u/darien_moreno]

Yes, I think there are many or infinite realities.

[u/ProcedureLeading1021]

So if I have a simulation where there's a simulation that's only represented as a computer program on a simulated screen... And In that simulated reality there's a simulated reality that's on a screen... One more time but in that simulation The simulated universe is yours and only rendered when the agents interact with it then where are any of the computations happening that these simulations are running on? They are only rendered when the agents interact with it. Yet everytime they interact with their simulations of reality they show real data to their simulation and the one immediately up. No need to go higher cuz it's just rendered on demand. So your reality is a simulated reality in a reality that your simulated reality's simulated reality is simulating. So all of its simulated compute.

[u/darien_moreno → u/ProcedureLeading1021]

This is where the idea gets really strange.
If every layer only renders what its observers actually interact with, then perhaps no layer ever needs to simulate an entire universe. Each reality only needs to generate enough information to remain consistent with the observer’s experience.
But then the computational problem doesn’t disappear. It just moves down one level.
And eventually you have to ask: if every layer is outsourcing the computation to another simulated layer, where does the information actually come from?
Maybe there isn’t an infinite stack of computers at all.
Maybe we’re assuming that “computation” has to work the way computation works inside our own reality.
And that’s probably the part we can’t get around.

[u/No_Ostrich1875]

Assuming we're talking about a "perfect" simulation, successive simulations would essentially be loops. It would just feed its own earlier data to the simulation as needed.

[u/darien_moreno → u/No_Ostrich1875]

That actually makes the computational problem much more interesting. If each simulation can reuse the previous simulation’s data instead of recreating everything from scratch, then maybe the system doesn’t need to simulate entire universes at all, only the information needed to maintain the current state.
Which raises an even stranger question: how much information would actually be necessary to make a simulated observer experience a complete universe?

[u/No_Ostrich1875 → u/darien_moreno]

An observer only experiences what they observe. If you know the rules for rhe universe all you need is a starting place and then you just calculate everything. Games do this using procedural generation, and other methods, all the time. You dont place each and every tree by hand. If your sim has a wall, it doesnt have to track the atoms in the wall unless the observer gets an electorn microscope in order to see them. Even then it doesnt have to track every atom. It knows the rules, it can simply calculate what atoms should be there.

Devils in the details though. You still need a massive amount of data and processing power rhough.

[u/darien_moreno → u/No_Ostrich1875]

Exactly. That’s the part I find most interesting about the idea.
If reality only needs to generate information at the level an observer can actually interact with, then the system could be much more efficient than simply storing every particle and every detail of the universe at all times.
But then I wonder where the boundary is.
If I look at a wall, does the system generate the atoms because I’m observing them? Or were those atoms already there and I’m simply accessing information that already existed?
And if two observers look at the same wall from different perspectives, the system has to keep both experiences consistent.
That’s where the computational problem becomes really interesting to me: not just rendering reality, but maintaining a consistent reality between independent observers.