A neat trick could be to avoid simulating the internal computer by recognizing that it is running the same computation, and instead of simulating a computer running the same computation, just use the same information you are already computing, and copy it over where it is relevant to the on-screen output.
So, essentially replacing the simulation with an oracle of sorts for the rest of the world they are in.
This would allow the internal simulation to be just as detailed, because it would just be re-using the same results.
Of course, that only works if it is a simulation of exactly the same world.
I suppose if the simulation was the same except for a small intervention, then you could maybe use what you are already computing as a starting point, and then compute the difference that result from the intervention.
But, because of chaos stuff, I imagine that that would quickly spiral out to the point where it wouldn’t save much computation.
If you are willing to fudge things though, you could make it so that the results of the interventions are subtly adjusted in order to make the differences that result from them not effect much, and where they would be negligible, make them zero,
and with the recursive nature of it, could fudge the results to make it go to a fixed point (or cycle) more quickly, so that you don’t end up having infinitely many distinct levels.
Edit: of course, I don’t think this could be done in our universe, for our universe, or even for one very similar to our universe. We might be able to do something similar for a much much simpler world. And if we specifically hard code in a part of the world which represents “a computer simulating this world”, then that’s no issue, though it isn’t particularly satisfying/surprising. It isn’t a surprise that a videogame can have a scaled down copy of its window drawn as a texture on some object in the game.
Also, this version wouldn’t really suggest the “infinitely many copies are in the fixed point part, and only finitely many are above that part of the sequence” thing, because the chain would just stop once it becomes cyclic or a fixed point.
Also, there might be like, fundamental issues preventing detecting whether a computation in the simulation is simulating the same thing? Quine-ing is possible, so the issue isn’t representing the same code, but “detecting whether some process is equivalent to running some code” seems like it might be an issue.
Like, with Rice’s theorem or something.
Like, when simulating a game of life world, is it possible to automatically eventually detect all parts of it that are doing something equivalent to, e.g. enumerating primes?
Like, all parts for which there is a fast algorithm for computing that part of it using the sequence of primes and visa versa?
Or, eventually finding all such parts that last indefinitely and aren’t interrupted/broken .
Actually, I’m guessing yes, that should be possible. Dovetail together all “fast algorithms” that attempt to predict parts of the state using the list of primes, (and where the primes can also be quickly computed using that state through another “fast algorithm”), and then only keep the ones that are working.
All the ones that eventually stop working should be eventually ruled out, and the dovetail process should eventually find all the ones that do work.
Ah, but wait, that doesn’t result in conclusively deciding “yes, there is one here”, only giving candidates.
Well, still, for fast translations between the states of the simulated prime finding machine, and lists primes, I expect there should be a proof that,
Err, wait, no.
Well, kinda.
If the machine doesn’t just enumerate primes, but instead enumerates primes, but after the 2^(2^n) -th prime, looks at the n-th candidate for a proof of a self-contradiction in ZFC, and if it is a valid proof of a self-contradiction, messes stuff up and no longer computes primes,
(Or maybe instead of checking all of the n-th candidate, checks one step of the current candidate),
then ZFC can’t prove that this will always produce primes.
We could maybe say that this doesn’t count as doing the same computation, because there’s no sufficiently good correspondence between the states and the sequence of primes, but, eh.
On the other hand, if one settles for merely high confidence that some particular process in the simulation is computing whatever program, before replacing it with something that just gets the results of that computation from outside, you could probably use logical induction? Or, use logical induction for “it can be accurately predicted by this at least until time t in the simulation”, and then use the simplification until time t.
Of course, that’s not practical, because the current best known logical induction algorithm is much too slow. But theoretically.