home‎ > ‎3.2‎ > ‎

3.2.1

3.2.1
Plexing & The Googol Series

1 followed by ...

When trying to come up with a really large number the first instinct is usually to write 1 followed by a lot of zeroes, or to define a number as 1 followed by a lot of zeroes. This is precisely what we are going to do now. Only we are not simply going to define some large number. Rather we're going to define the process. Basically we want a function that takes "n" as input, where n is a natural number (counting number), and returns 1 followed by "n" zeroes as output. We will call this, for lack of a better name, the "plexing function". We now define:

plex(n) = 1000000000 ... ... ... ... ... ... ... ... 00000000 with "n" zeroes

We can write this more succinctly using exponential notation:

plex(n) = 10^n

We now have a simple but powerful tool to generate some very large numbers.

The Googol

Using our new function we now define the "Googol" in the following way:

Googol = plex(100) = 10^100 =

10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,
000,000,000,000,000,000,000,000,000,000

A Googol is 1 followed by a hundred zeroes. In the illion system A googol can also be named "ten duotrigintillion" in the short scale or "ten sexdecilliard" in the long scale.

The story about how this number got coined tends to go something along these lines. Sometime around the 1920s or 30s, depending on the account, the American mathematician Edward Kasner was trying to come up with a name for 1 followed by a hundred zeroes in order to interest children in the wonders of mathematics. On a walk with his nephews he asked them for suggestions. Nine year old Milton Sirotta suggested calling it a "googol". Amazingly the name has stuck and become universally recognized, even garnering enough acceptance to make it into the english dictionary.

To give us some sense of perspective on the size of a googol, the sun contains only about 10^57 sub-atomic particles. How many sun's would we need to have a googol particles? To find out we simply divide a googol by 10^57 right? So we obtain:

(10^100)/(10^57) = 10^(100-57) = 10^43

It would take 10^43 suns! Still not impressed? Well consider this. That means we would need about ten million trillion trillion trillion suns! There aren't even that many stars in the observable universe! There are only about 10^80 sub-atomic particles in the observable universe. That means we would need about a hundred million trillion observable universes to have a googol particles. Pretty insane.

Another way we could think about it would be to ask how much volume a googol particles would actually take up. Recall that most of the cosmos is empty space. What if we were to condense matter to the point where particles were pressing up against each other. 10^-18 meters is sometimes given as the diameter of a proton. Let's assume that every sub-atomic particle has about this radius. How large would a sphere packed solid with a googol sub-atomic particles be? To find out we can use the formula for the volume of a sphere and solve for the radius. We can say

V = (4/3)pi*r^3

The volume will be equal to (10^100)*(10^-18m)^3 since we have a googol subatomic particles. Let's see what we can obtain for the radius:

(10^100)*(10^-18)^3 = (4/3)pi*r^3

10^100 * 10^-54 = (4/3)pi*r^3

10^46 = (4/3)pi*r^3

r^3 = (3/4)pi*10^46

r ~ 2.8668 x 10^15

Incredibly this sphere would have to be about 5.6 quadrillion meters across! That would be about a half a light year in diameter. That is WAY bigger than the entire solar system. It would be about 300 million trillion times the volume of our sun. That's a lot of particles!

The Googolgong

Googolgong = plex(100,000) = 10^100,000

This number is NOT merely a thousand times a googol. Rather it's a googol raised to the power of a thousand! That's a Googol googol googol googol googol ... ... ... ... ... ... googol googol googol where you have to say a googol a thousand times. This is easy enough to prove:

googol^1000 = (10^100)^1000 = 10^(100*1000) = 10^100,000

So what does this mean in terms of scale? Are we going to need at least a googol observable universes to have enough particles? Nope, it's much much worse. You see, if an observable universe (also known as a hubble volume) only contains 10^80 particles, then having a googol of them would only amount to:

10^80 * 10^100 = 10^(80+100) = 10^180

10^180 particles. Not even close. To reach a googolgong particles we are going to need a much more radical description. To reach a googolgong particles envision this:

Imagine a hubble volume, floating in a vast sea of infinite darkness. Now imagine it shrinking down to the size of a sub-atomic particle as we zoom out to larger and larger scales. Imagine also that there are many hubble volumes floating around in the local space, and as we zoom out there are more and more of them. Now imagine a truly vast space in which there are as many hubble volumes as there are particles within a hubble volume. That is, we can imagine we have 10^80 hubble volumes floating around. You can even imagine that this is just another universe in which each particle is itself a universe of our scale! Yikes! But that is only 10^160 particles so far. Now imagine that this "2nd order hubble volume" is just a merely sub-atomic particle in a third order hubble volume! Now we can imagine a 4th, 5th, 6th, 7th, 8th order hubble volume, and so on. How many orders would we have to go to reach a Googolgong particles? Well the 1,250th order hubble volume would contain roughly a Googolgong particles!

Now go back to what we said a googol particles would be. We would need about a hundred million trillion hubble volumes. However this would only be a tiny part of a 2nd order hubble volume. Yet you would have to go out to 1250 orders to reach a googolgong. A googolgong is not a couple billions or trillion times larger than a googol. It is completely in another league. If you haven't considered these ideas before they can get pretty dizzying. This however is pretty much business as usual in the world of large numbers, and we've only just begun. Next we will consider the googolplex!

The Googolplex

According to some tellings of the "googol and googolplex" story, it was milton sirotta who also coined a googolplex and defined it as 1 followed by as many zeroes as you can write before getting tired. Edward Kasner being a mathematician however would never settle for such an inpercise definition, yet he must have found the possibility of a number still larger than a googol intriguing. He therefore decided to have a googolplex defined as 1 followed by the largest number he had come up with, which was a googol of coarse. Some tellings also say that Kasner had come up with a googolplex as an afterthought. Whatever the case may be a googolplex has also established itself and found its way into dictionaries. We can therefore define the googolplex as follows:

Googolplex = plex(googol) = plex(10^100) = 10^(10^100)

Perhaps you see now why I chose to call this a "plexing" function. We can use the -plex as a root that when added to a number generates 1 followed by that many zeroes. Thus a googol-plex is by definition 1 followed by a googol zeroes. A lot of impressive things have been said about a googolplex, and they are all more or less true, with no exaggeration neccessary. Here are some of the more popular illustrations of its size.

Perhaps the most common thing said about the googolplex is that you could NEVER write it out fully in decimal notation no matter how hard you tried. That in itself is a little hard to grasp at first. Surely its a simple matter to write it out in decimal. Afterall we can write a googol in decimal right? Yes, but can you write out a googol of anything, let alone a googol zeroes? That's the point. Even in decimal notation it would contain an exponential number of symbols so that it would be quite literally unwrittable. Perhaps your still not convinced. Heres the part where some number crunching is usually carried out to bring the point home. Well here it goes:

Okay, perhaps we couldn't write it out within our lifetime, but how long would it take to write out a googol zeroes?
That's a valid question. Well let's just say for argument sake that instead of writing it out you got a printer to print it out. Let's say it can print a line of 50 zeroes about every 2 seconds. How long would it take to print out a googolplex? A hopelessly long time of about 10^91 years. What?! That's barely smaller than a googol itself! Well actually it's about a billionth of a googol, but I know what you mean. This time scale is so long that the universe would have to be about 10^81 times its current age in order for the printer to have enough time.

Hopefully your are now fully convinced of the futility of trying to write out a googolplex in decimal notation. But there is also a much more basic reason why writing out a googolplex is clearly impossible, besides the amount of man hours it would require. We wouldn't even be able to stuff all of the stacks of paper that a googolplex would be written out on into the observable universe! That may seem totally incredible, but it pays to recall that there are only 10^80 sub-atomic particles in the observable universe. You might recall however that most of the universe is empty space, and we were able to compact a googol particles into a sphere with a diameter of about half a light year. Couldn't we somehow fit a googol zeroes in the observable universe then?

Well here is some number crunching for the skeptics. Firstly we need to find the volume of the observable universe. A good way to come up with an estimate is to let the radius of it be as many light years as the age of the universe. Currently the age is estimated at about 13,000,000,000 years. The speed of light is about 300 million meters per second. Combining this all into the formula for the volume of a sphere we obtain:

(4/3)pi*(3e8*60*60*24*365*1.3e10)^3 ~ (4/3)pi*(1.23e26)^3 ~ 7.79 x 10^78 m^3

So the volume of the observable universe is about 7.79x10^78 cubic meters. So how much space would a single zero take up. Well it depends how large or small its written, but we can assume that a zero can be written on a half centimeter square without much trouble. Paper can be as thin as about a tenth of a milimeter. Multiplying these dimensions in meters we obtain:

(0.005m)(0.005m)(0.0001m) = 0.0000000025 m^3

That's incredibly small. Yet when we divide the volume of the universe by the minimal volume required for each zero we obtain only about 10^87. That means we can't stuff more than about 10^87 digits into the universe. Maybe 10^88 if we write it really small on really thin paper, but that's it. We aren't going to make it to a googol.

If we can't even write out a googolplex, what possible hope to we have of imagining the size of the number itself! Well remember how we described multiple levels of hubble volumes within hubble volumes like a series of babushka dolls to explain the size of a googolgong. Well to reach a googolplex particles we would not go to the 1,250th order hubble volume, but would have to ascend to a maddeningly high 125,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,
000,000,000,000,000,000,000,000,000th order hubble volume. That's 1.25x10^98 orders! That is the truly insane magnitudes we are talking about. I doubt you've heard the googolplex described in this way before, but I think this really brings out the other worldliness of these numbers.

The Googol Series: The Googolplexian and Beyond...

The googolplex is often cited as the "largest named number" because it is universally recognized. This is a somewhat questionable claim on account of many other numbers with well established names, such as skewe's number, and graham's number to name a few. Also a googolplex is really just the very beginning of the large numbers game. Consider this, if we can have 1 followed by a googol zeroes, why not 1 followed by a googolplex zeroes! Now we'd need to go up to the googolth order hubble space just to have enough space to write out the damn thing, let alone have that many particles! Some names have been suggested for this number, such as the "googolplexian", a "gargoogolplex", or the "googolplexplex", but none of these work very well in my opinion. There does seem to be some concensus that a "googolduplex" is probably the best choice. This is the term that Jonathan Bowers, myself, and many others use. Essentially its a shortening of "googolplexplex" by using the latin prefix for two. Notice how we can define a googolduplex:

Googolduplex = plex(googolplex) = plex(plex(googol)) = plex(plex(10^100)) = plex(10^(10^100)) =

10^(10^(10^100))

A googolduplex is simply a googol plugged into the plex function twice. Also notice:

n-plex = plex(n)

Now we have a sequence of terms. A googol, googolplex, and googolduplex. Each successive term is 1 followed by a number of zeroes equivalent to the previous term. In theory we can extend this series beyond a googolduplex as far as we'd like. However as always, there is considerable qualification needed in that statement. We can certainly extend it pretty far. 1 followed by a googolduplex zeroes is called a "gargantugoogolplex". That name will come up again in our next article. However this name does not lend itself to further extension. Instead we can simply increase the latin prefix by one for each successive term to obtain the sequence:

Googoltriplex = 10^googolduplex = 10^(10^(10^(10^100)))

etc.

In fact we can simply adapt the prefixes for the -illion series to suit the new googol series. The googol series however grows much much faster than the illion series. For the illion series, only 3 zeroes are added each time we move up the sequence, but in the googol series the number of zeroes added is constantly increasing by larger and larger amounts.

Plexing needn't only be applied to the googol and its derivatives however. We can create various plexing series simply by choosing different initial values. Since I didn't know about the googol or googolplex as a kid, when I decided to invent really large numbers the first thing I did was to have 1 followed by a centillion zeroes:

plex(centillion)

I continued plexing, starting with a centillion, to begin my first sequence of very large numbers. These numbers can even be named using the plex convention we've established:

centillionplex = 10^(10^303)
centillionduplex = 10^(10^(10^303))
centilliontriplex = 10^(10^(10^(10^303)))
etc.

Note that the googol series is actually a recursive series, because it's repeatidely plugging numbers into the plex function. When a function is repeatedly plugged into itself we can use a special short hand:

Let f^m(n) = f(f(f(f(f( ... f(f(f(n))) ... ))))) where there are "m" nested functions

This is what is known as a functional power. Now look how we can simplify the googol series:

Googol = plex(100) = plex(plex(2)) = plex^2(2)
Googolplex = plex(googol) = plex^3(2)
googolduplex = plex(googolplex) = plex^4(2)
etc.

We can also include the functional power as an argument for a new binary plex function. To do this we define:

f(n,m) = f^m(n)

Thus:
googol = plex(2,2)
googolplex = plex(2,3)
googolduplex = plex(2,4)
etc.

Consider this. We can't even write the googolplex out in decimal notation, yet it can easily be defined with the expression plex(2,3). That is why recursive functions are the key to our climb to infinity. They allow us to condense vast amounts of information into a tiny space. The expression plex(2,3) however is a little deceptive. This only works if we know the definition of the plex function, which requires us to know exponents. These definitions must be included in the amount of information used. However this information still pales in comparison to the neccessary decimal expansion, and so our recursive function still saves us considerable time and energy defining the googolplex. The function also allows us to express other values. For example:

centillion = plex(303,1)
centillionplex = plex(303,2)
centillionduplex = plex(303,3)
etc.

We could also create a series beginning with the googolgong:

googolgong = plex(5,2)
googolgongplex = plex(5,3)
googolgongduplex = plex(5,4)
etc.

Another way of thinking of the googol series is as a continually growing exponential tower. Remember how in the last article I said that we would resolve operations always from right to left. You'll now see why that comes in handy. Defining the googol series using stacked exponents we can say:

googol = 10^100
googolplex = 10^10^100
googolduplex = 10^10^10^100
etc.

If we resolve from right to left we get the same values as when the paranthesis were present. Basically right to left resolution allows us to omit paranthesis while remaining unambiguous.

Higher members of the Googol Series

Once we have established a sequence we can of coarse jump ahead in the sequence. Let's say we want to go up to the 101st member of the googol series. This would be:

googolcentiplex = 10^10^10^10^ ... ... 10^10^10^10^100 where there are 101 "10"s in the power tower

Now that's a mind-boggling number! There is very little that we can do at this point to bring home the sheer size of such a number. There is one illustration I can use however:

Imagine a pair of ten-sided dice (yes there is such a thing). There are 100 ways this dice can land. This will be "stage 0". Now we want to have as many d10s has we had combinations in stage 1. So now we can have a 100 d10s. These will have 10^100 possible ways of landing. That is "stage 1". Next we would have 10^100 d10s. That's so many were going to need a couple of universes to store them. Now find out how many ways they can fall. That would be 10^10^100 which would be "stage 2". Continue in this fashion until you reach "stage 101". That would be a googolcentiplex.

How far has the googol series been extended? Well the largest terms I've seen are:

googolmilliplex = plex(googol,1000)
googolmegaplex = plex(googol,10^6)
googolgigaplex = plex(googol,10^9)
googolteraplex = plex(googol,10^12)
googolpetaplex = plex(googol,10^15)

Terms can easily be incalcalated just as with the illion series, and we can also extend it further, at least alittle, by following the trend of using the SI prefixes. Thus we could continue with:

googolexaplex = plex(googol,10^18)
googolzettaplex = plex(googol,10^21)
googolyottaplex = plex(googol,10^24)

Technically this means the largest possible name under this naming scheme would be ...

googolnovemcentinonagintinovemyottanovemcentinonagintinovemzettanovemcentinonagintinovem
exa-novemcentinonagintinovempetanovemcentinonagintinovemteranovemcentinonagintinovemgiga-
novemcentinonagintinovemmeganovemcentinonagintinovemmillinovemcentinonagintinovemplex =

plex(googol,10^27-1)

One could theoretically continue by using my extended SI prefixes. This would get you to about:

googolecettaplex = plex(googol,10^300)

In any case using the SI prefixes is probably not such a great idea, because of its limited
extendability. Besides, we could always just get ahead of all this by going to the googolplexth member of the googol series, which is simply plex(100,googolplex) ... :)

So is the googol series the only way to reach large numbers. No. Is it the best way? Absolutely not.
As you will see, functions are far more powerful and easy to use than naming schemes when it comes to defining and building large numbers. In our next article we consider some of the work in large numbers done by Alistair Cockburn and Stephan Houben. As we will see, there are even faster growing functions than the plex function that we can define without much effort.