A while back I was thinking about how one would implement a time-oriented system for keeping notes. When thinking about the differences between points and ranges in time, I naturally came to the conclusion that a second technically covers a range of time as well.

Then, because I’m me, instead of saying “oh, milliseconds would do nicely as a ‘point’ in time”, I went straight to planck times.

The question then of course, is: How much space do you need to store the number of planck times that have elapsed since the start of the universe?^{1}

So, a planck time consists of 5.39106e-44 ± .00032e-44 seconds, and inversely a second contains 1.85492e43 ± .00011e43 planck times.^{2}

Additionally, we know the age of the universe as being 4.354e17 ± .012e17 seconds, or .4354 ± .0012 Es.

So, to store the number of elapsed Planck times, we need enough bits to store 4.354e17 ± .012e17 s × 1.85492e43 ± .00011e43 t_{p} s^{-1} = 8.07632168e60 ± .00047894e60 t_{p} . With plenty of room to grow needed, of course.

So, that’s our goal, roughly 8e60 planck times. Let’s begin with some sizes you’ll get on most systems, programming in C or something like it:

No. Bits | Maximum number of planck times t_{p} |
Number of seconds s | 10 * log_{10}(s) |
---|---|---|---|

8 | 0xFF = 255 | 1.3747203e-41 ± .0000816e-41 | -409 |

16 | 0xFFFF = 65535 | 3.533031171e-39 ± .000209712e-39 | -385 |

32 | 0xFFFF_FFFF = 4294967295 | 2.31544263853827e-34 ± .00013743895344e-34 | -336 |

64 | 0xFFFF_FFFF_FFFF_FFFF = 18446744073709551615 | 9.94475041060126e-25 ± .000590295810358706e-25 | -240 |

None of those integers come close to talking about a lot of time. Only that 64-bit number doesn’t look (too) small written in yoctoseconds, specifically ≈.99 ys.

The last column (which is rounded to nearest integer, as you might’ve suspected) exists for this handy graphical chart of the beginning of the universe. For eight bits, we’re almost halfway through the Grand Unification Epoch^{3}, while 16 bits is farther into it. 32 bits we finally get to experience the next phase, the beginning portion of the Electroweak Epoch (as well as mostly through the inflationary epoch). At 64 bits, we’re half-way through that electroweak epoch.

OK, what if we used two 64-bit numbers to represent a 128-bit integer?

128 | ≈3.4e38 (it’s a 39 digit number, or in the duodecillions) | 1.83448265701279e-05 ± .0001088903574147e-05 | -47 |

All of a sudden, we jump from being just under 1 ys to being just under 20 µs. On the handy graphical chart, we finish up in the electroweak, skip quarks, and land right towards the start of the Hadron Epoch.

That’s nice and all, but still not even one second. How about a 256-bit integer?

256 | ≈1.1e77 (78 digits!) | 6.24242100603726e33 ± .000370534685559412e33 | 338 |

That graphical chart will not help us now. We could write 6.24242100603726e33 s as 6242421006.03726 Ys, but it still manages to look like a huge number. It’s decillions of seconds, or hundreds of quattuorvigintillions of planck times. **That’s 14.3 quadrillion times the estimated age of the universe**. I could keep going, but I think you get the picture.

The reason why I created this post was because exponential growth. You’ve probably heard of that old story with the rice and the chessboard, or something like it. It does a good job of demonstrating how exponential growth works.

Until I had come across this question, and tried to solve it, I had no deep understanding of exponential growth, despite that story and all the rest. It surprised me that doubling the number of bits from 128 to 256 would bring me sufficient bits to talk about events here and now, billions of years after the universe started. I went from a couple dozen microseconds to the age of the universe 14 quadrillion times over, and only knowing I could blame exponential growth kept me from distrusting my results longer.

So I thought I should share this. Put out there another example of how quickly exponential growth takes things out of hand. Maybe it’s just because I discovered this on my own, but I think there’s nothing quite like this question to help you understand that kind of growth.

And if I ever do write a note-keeping program, you’d rest assured knowing your timing will only ever be limited by general relativity. Because it only takes 32 bytes for me to give that 🙂 .

Maybe in a follow-up post I can post a table of numbers of bits that aren’t just powers of two, and a graph as well. Sounds like something fun to look at, at least.

(By the way, you only need 203 bits at minimum, as that’ll get you 1.6 times the age of the universe. Since bit-level control in programming is a great bother, a minimum of 26 bytes will get you 50 times the age. Though by this point 4 64-bit numbers (or 8 32-bit ones) would be easier to manage, I should think 🙂 .)

^{1}While choosing some sort of epoch would make the numbers smaller for things relevant to us, if you’re dealing in planck times, chances are you’ll want to talk about the beginning of the universe no matter what epoch we count from. This way lets us avoid throwing a bit away on indicating the number’s sign.

^{2}You’ll forgive me if I got the error calculations wrong in this post, I don’t usually mess with them. I in fact only did it here for completeness’ sake. I used the simpler formulas that assume we’re playing with standard deviations, for those who know these things better.

^{3}Just to point this out: it takes just 255 planck times to get roughly halfway through the point in the universe where the electronuclear force was a thing. *Only 255*.