Archive of Our Own

A program of zeroes and ones is equivalent to the exact same sequence of ones and zeroes as long as the system running it can interpret it correctly.

Imagine that in Deep Time, vast stretches of yawning epochs from now, at a point when time might seem to crawl from the effects of the Landauer Limit or its equivalent — that is, whether one imagines a universal heat death or a big crunch — each might have loopholes to continued computation (as a measure of life in some form) such that vanishing computations might be performed with exceedingly long cooling times in the one, or relativistic effects might permit for effectively unlimited computation as one approaches singularity.

Whether the same might apply to a steady state of continuous creation and/or a constant and eternal fixed universe (presumably not even possible in real world physics), one might still imagine such stretches of times as applying to them eventually — it would, after all, only be a matter of time.

Now picture some Maxwellian demon, bearing a silver hammer that it uses to flip bits from zeroes to ones and ones to zeroes.  Taking its unordered list of all bits in such a universe, our demon's hammer would be aimed at the next bit at random.  Some bit somewhere, perhaps as far as possible in some random direction away from the current bit, perhaps its nearest neighbor, or somewhere in between — perhaps even that very same bit itself — would then feel the sting of the demon's hammer flipping it from¹

its current state to the reverse.  Whatever state a system begins with as a whole would [statistically] inevitably reach every possible ratio in the continuum, spending twice as much time in the middle as at either end alone.  I don't imagine that much time would really be spent at the exact balance of zeroes and ones, nor much at all at either end of all zeroes or all ones, but I'm thinking of the overall distribution as a bell curve thing.

Such a being would act as an agent of entropy when moving from a highly ordered set — whether mostly or all zeroes, or mostly or all ones — to one of things having been blended out into a bland mix of stochastic alternation.

This same being, however, would yet act quite contrarily as an agent of negative entropy, focusing regions and polarizing all of existence into opposed areas of all zeroes versus all ones, or nothing but one of these in particular throughout the whole.

If each of these is true, then the net result isn't one of entropy or of negative entropy on the whole, but of chaos.  Oh, this little demon isn't picking and choosing which way to jump from some confounding protocol, but the results are still just that: chaotic.

These last three points taken as a sort of syllogism might be more evident if one imagined hundreds of such demons tinkering at once.  Thousands of such demons.  Millions, and billions, and trillions of such demons.

Eventually though, one reaches a tipping point.  If nothing else, imagine every single parameter having its very own demon.  With every increment of time cycle in the system, each demon flips its specific bit, with a net result of not causing changes that matter as such (we'll assume here that time flip is observed as well).

Alone, that might not completely nail down a tipping point, so let's try one step further: every bit has two demons of its very own — one that flips that specific bit at the top of every time cycle, and one that somehow manages to do so halfway through every time cycle.  Would any differences made thus make any difference?

In the case of a computer seeking to operate a program, perhaps a constrained demon could be relied upon to swap every single bit of that program, permitting the OS to read the opening string of (let's say) thirty two zeroes or thirty two ones and know which way to read it: binary or “nibary” (so to speak).  This might be asking for too much though, and might still present an issue if the computer were to look while such a demon were still busy working.

Let's consider then a head string and a tail string... That might work, as long as the demon were flipping every bit as it went from start to end (or the other way around).  If it were leaping to and fro within the program, then one couldn't really expect it to mess with only the head or the tail and then the guts while leaving the tail or head (respectively) alone 'til the end as a calling card announcing its work to then have been completed.

One might try a CKSUM, but that too goes only so far.  Likewise, a library of multiple copies might not be entirely reliable, if the demon had somehow corrupted them all in some crucial way — unlikely though such might be, any imaginable bit decay is still an eventuality over Deep Time.

If the universe — the world that we live in, where you're reading this right now — were to run its underpinnings in such a manner, particles properties swapped in charge or chirality, and time, then this might be acceptable if the whole were completely flipped in every manner consistent with the original arrangement, leaving the occupants unable to discern a difference.

Things might be a little trickier if our demon were to run around flipping a single parameter at random for any given instance at random, always flipping something somewhere every Planck time, but just that one thing per.

O ~~~ O