Prospects for Development

10²⁶ ops isn’t too bad, actually. That’s 100 yottaflops (10²⁴). IBM Roadrunner, in 2009_17ya, clocks in at 1.4 petaflops ($1.4\cdot {10}^{15}$). So our hypothetical low-powered laptop is equal to 350 billion Roadrunners ($\frac{5.009001024732046\cdot {10}^{26}}{1.4\cdot {10}^{15}}=3.577857874808605\cdot {10}^{11}$).

OK, but how many turns of Moore’s law would that represent? Quite a few⁷: 38 doublings are necessary. Or, at the canonical 18 months, exactly 57 years. Remarkable! If Moore’s Law keeps holding (a dubious assumption, see Moore’s Second Law), such simulations could begin within my lifetime.

We can probably expect Moore’s Law to hang on for a while. There are powerful economic inducements to keep developing computing technology—processor cycles are never cheap enough. And there are several plausible paths forward:

But in any case, even if our estimate is off by several orders of magnitude, this does not matter much for our argument. We noted that a rough approximation of the computational power of a planetary-mass computer is 10⁴² operations per second, and that assumes only already known nanotechnological designs, which are probably far from optimal.⁸

Even if we imagine Moore’s Law ending forever within a few turns, we can’t exclude humanity forever remaining below the computing power ceiling. Perhaps we will specialize in extremely low-power & durable processors, once we can no longer create faster ones, and manufacture enough power the slow way over millennia. If we want to honestly affirm #1, we must find some way to exclude humanity and other civilizations from being powerful enough forever.

Limits of Investigation

This is a weak method of investigation, but how weak?

Very.

Suppose we assume that the entire universe is being simulated, particle by particle? This is surely the worst-case scenario, from the simulator’s point of view.

There are a number of estimates, but we’ll say that there are 10⁸⁶ particles in the observable universe. It’s not known how much information it takes to describe a particle in a reasonably accurate simulation—a byte? A kilobyte? But let’s say the average particle can be described by a megabyte—then the simulating universe needs just $1,000\cdot {10}^{86}$ spare bytes. (About 10⁵⁵ ultimate laptops of data storage.)

But we run into problems. All that’s really needed for a simulation is things within humanity’s light cone. And the simulators could probably ‘cheat’ even more with techniques like lazy evaluation and memoization.

It is not necessary for the simulating thing to be larger, particle-wise, than the simulated. The ‘greater size’ principle is information-theoretic.

If one wanted to simulate an Earth, the brute-force approach would be to take an Earth’s worth of atoms, and put the particles on a one-to-one basis. But programmers use ‘brute-force’ as a pejorative term connoting an algorithm that is dumb, slow, and far from optimal.

Better algorithms are almost certain to exist. For example, Conway’s Game of Life might initially seem to require n² space-time as the plane fills up. But if one caches the many repeated patterns, as in Bill Gosper’s Hashlife algorithm, logarithmic and greater speedups are possible.¹² It need not be as inefficient as a real universe, which mindlessly recalculates again and again. It is not clear that a simulation need be isomorphic in every step to a ‘real’ universe, if it gets the right results. And if one does not demand a true isomorphism between simulation and simulated, but allows corners to be cut, large constant factors optimizations are available.¹³

And the situation gets worse depending on how many liberties we take. What if instead of calculating just everything in the universe, the simulation is cut down by orders of magnitude to just everything in our lightcone? Or in our solar system? Or just the Earth itself? Or the area immediately around oneself? Or just one’s brain? Or just one’s mind as a suitable abstraction? (The brain is not very big, information-wise.¹⁴) Remember the estimate for a single mind: something like 10¹⁷ operations a second. Reusing the ops/second figure from the ultimate laptop, we see that our mind could be handled in perhaps $\frac{1}{5.4258\cdot {10}^{33}}$ of a liter.

This is a very poor lower bound! All this effort, and the most we can conclude about a simulating universe is that it must be at least moderately bigger than the Planck length ($1.616252\cdot {10}^{-35}$ m) cubed.

Investigating

We could imagine further techniques: perhaps we could send off Von Neumann probes to the far corners of the universe, in a bid to deliberately increase resource consumption. (This is only useful if the simulators are ‘cheating’ in some of the ways listed above. If they are simulating every single particle, making some particles move around isn’t going to do very much.)

Or we could run simulations of our own. It would be difficult for simulators to program their systems to see through all the layers of abstraction and optimize the simulation. To do so in general would seem to be a violation of Rice’s Theorem (a generalization of the Halting Theorem). It is well known that while any Turing machine can be run on a Universal Turing machine, the performance penalty can range from the minor to the horrific.

The more virtual machines and interpreters there are between a program and its fundamental substrate, the more difficult it is to understand the running code—it becomes ever more opaque, indirect, and bulky.

And there could be dozens of layers. A simulated processor is being run; this receives machine code which it must translate into microcode; the machine code is being sent via the offices of an operating system, which happens to be hosting another (virtualized) operating system (perhaps the user runs Linux but needs to test a program on Mac OS X). This hosted operating system is largely idle save for another interpreter for, say, Haskell. The program loaded into the interpreter, Pugs, happens to be itself an interpreter… If any possible simulation is excluded, we have arguably reached at least 5 or 6 levels of indirection already (viewing the OSs as just single layers), and without resorting to any obtuse uses of indirection¹⁵.

Even without resort to layers, it is possible for us to waste indefinite amounts of computing power, power that must be supplied by any simulator. We could brute-force open questions such as the Goldbach conjecture, or we could simply execute every possible program. It would be difficult for the simulator to ‘cheat’ on that—how would they know what every possible program does? (Or if they can know something like that, they are so different from us as to render speculation quisquillian.) It may sound impossible to run every program, because we know many programs are infinite loops; but it is, in fact, easy to implement the dovetail technique.