3.2.2
The Fz, The Fuga & The Megafuga
 
PREV>> 3.2.1 - Plexing & The Googol Series

Beyond the Googolplex: Inventing Big Numbers
 
 Edward Kasner may have been a professional mathematician, but you don't have to be a mathematician to come up with numbers even larger than a googolplex. Such was the case for software developer and IT stategist Alistair Cockburn (pronounced Co-burn).
 
 Much like how Edward Kasner was assisted by Milton Sirotta in his exploration of the very large, Alistair's own foray into large numbers was triggered by an ongoing argument between his kids over whose space commander ruled the most star systems. Although most kids will simply end such an argument by saying a "jillion" or "infinity" this was apparently not the case in Alistairs home. No, in Alistair's home the winner was whoever could name the largest actual number, no "fakes", "transfinites" or "my number is one more than any number you can come up with" nonsense, just a straight no holds barred large number duel.
 
 So usually the "game" would continue until someone said their space commander ruled "a million stars". Since this was the highest named number the kids knew the game would pause for awhile until the youngest would decide to be unsporting and just say a "million million million ..." seemingly without end and pretty much win by sheer moxy if nothing else. That's how the game went until one day Alistair decided to bestow the wisdom of the gods upon his kids and tell them about the astronomical googol and the unfathomable googolplex (which we went over in the last article). His kids were seriously impressed with the googolplex and even more surprised that a kid had come up with the name.
 
 After this revelation his kids would argue until someone said their space commander ruled "a googolplex stars". Again they were stumped. That is until one day Kieran, the youngest, eventually had a flash of inspiration and came up with a "gargoogolplex" which he defined as a googolplex googolplexes. This little incident spurred the others on, include Alistair himself, to take this game even further. They eventually came up with a series of even larger number names and Alistair found the excersize so entertaining that he eventually wrote an internet article, circa 2001, on the numbers they had come up with on his own website. The article is titled "A fuga really big numbers" and can still be found online at:
 
 
 The article became well known and what you might call a small success. The numbers and functions Alistair came up with also became part of large number lore. Alistairs numbers eventually found there ways on other web pages on large numbers and various large number lists. Unfortunately there was some misinterpretation regarding his numbers, which I'll explain. Alistairs numbers also have some of their own limitations and ambiguities. None the less Alistairs exploration of the very large shows that virtually any one, even kids, can come up with numbers WAY larger than a googolplex. Make no mistake, googolplex is already a horrendously large number, as I showed in the previous article, but it simply pales in comparison to the numbers that can be generated with just a tiny bit of additional mental effort, let alone what can be done with a serious go at large numbers. Alistairs numbers are also an excellent way to introduce people to the large number game and how to get started. So let's get started...
 
The gar, the Fz, & the Fuga
 
 Alistair liked the idea of using the prefix "gar-" to increase the size of the numbers. This is really not that much different than the way "-plex" was used to increase the size of a googol. We can use the function gar(n) to represent any number appended by the gar prefix. According to Kieran's definition:
 
gar(n) = n * n
 
 Following the logic we can give names to lots of numbers, simply by changing the number appended to gar. Some examples:
 
gartwo = gar(2) = 2 * 2 = 4
 
garthree = gar(3) = 3 * 3 = 9
 
garfour = gar(4) = 4 * 4 = 16
 
garfive = gar(5) = 5 * 5 = 25

garsix = gar(6) = 6 * 6 = 36

garseven = gar(7) = 7 * 7 = 49

gareight = gar(8) = 8 * 8 = 64

garnine = gar(9) = 9 * 9 = 81
 
garten = gar(10) = 10 * 10 = 100

...
 
garhundred = gar(100) = 100 * 100 = 10,000
 
garthousand = gar(1000) = 1000 * 1000 = 1,000,000
 
garmillion = gar(1,000,000) = 1,000,000 * 1,000,000 = 1,000,000,000,000
 
garbillion = gar(1,000,000,000) = 1,000,000,000 * 1,000,000,000 = 1,000,000,000,000,000,000
 
gartrillion = gar(1,000,000,000,000) = 1,000,000,000,000 * 1,000,000,000,000 = 10^24
 
...
 
gargoogol = gar(10^100) = 10^100 * 10^100 = 10^200
 
gargoogolplex = gar(10^(10^100)) = 10^(10^100) * 10^(10^100) = 10^(2*10^100)
 
 Note that a gargoogolplex is actually 1 followed by 2 googol zeroes. More importantly observe that:
 
gar(n) = n * n = n^2 implies gar(n) = n^2
 
 So adding gar means simply squaring the number substituted into the gar function. It should also be noted that from a certain point of view, a gargoogolplex is not really that much bigger than a googolplex, even though it is a googolplex times larger. Note that the second exponent (the 100) doesn't even increase by 1. This means that:
 
10^(10^101) > gargoogolplex
 
10^(10^101) is actually a googolplex^10. That means its a googolplex googolplex googolplex googolplex googolplex googolplex googolplex googolplex googolplex googolplexes where as a gargoogolplex is only a googolplex googolplexes. Furthermore 1 followed by a googolplex zeroes is much much larger than 10^(10^101).
 
 Alistair decided to take it one step further by changing the exponent from 2, to n. He defines a new prefix, Fz-, and a new function Fz(n). We can say:
 
Fz(n) = n^n
 
This can also be thought of as:
 
Fz(n) = n * n * n * ... * n * n with n copies of "n"
 
We can now "plug in" values into this new function, and for any given n, the output for Fz(n) will be greater than gar(n). So we can state:
 
Fz(n) > gar(n)
 
Provided that n is greater than 2. Notice that:
 
gar(1) = 1 * 1 = 1
 
Fz(1) = 1 ^ 1 = 1
 
Thus when n = 1 the gar and Fz are equivalent. When n = 2 we have:
 
gar(2) = 2 * 2 = 4
 
Fz(2) = 2 ^ 2 = 2 * 2 = 4
 
So again they are equivalent. Whenever n > 2 however Fz(n) is guaranteed to be larger than gar(n). This is easy enough to prove. Assume that n > 2. Now observe:    
 
Fz(n) > gar(n)
 
implies
 
n^n > n * n
 
implies
 
n^n > n^2
 
 In every case the base will be "n" for Fz and gar. If n > 2 this means that the exponent for Fz will be greater than 2 and therefore n^n will be greater than n^2. Thus Fz(n) > gar(n) when n>2.
 
 Let's try some values now to see just how quickly the Fz function grows:
 
Fztwo = Fz(2) = 2^2 = 2*2 = 4
 
Fzthree = Fz(3) = 3^3 = 3*3*3 = 27
 
Fzfour = Fz(4) = 4^4 = 4*4*4*4 = 256
 
Fzfive = Fz(5) = 5^5 = 5*5*5*5*5 = 3125
 
Fzsix = Fz(6) = 6^6 = 6*6*6*6*6*6 = 46,656

Fzseven = Fz(7) = 7*7*7*7*7*7*7 = 823,543

Fzeight = Fz(8) = 8*8*8*8*8*8*8*8 = 16,777,216

Fznine = Fz(9) = 9*9*9*9*9*9*9*9*9 = 387,420,489
 
Fzten = Fz(10) = 10^10 = 10*10*10*10*10*10*10*10*10*10 = 10,000,000,000

...
 
Fzhundred = Fz(100) = 100^100 = 100*100* ... *100 with 100 "100"s = 10^200
 
 Note that a Fzhundred = gargoogol. It's significant to note that the Fz function achieves the same number with a MUCH smaller number! We can of coarse continue this process with even higher values:
 
Fzthousand = Fz(1000) = 1000^1000 = 10^3000
 
A Fzthousand is close to the value for a millillion (10^3003) which we discussed in chapter 2-4.
 
Fzmillion = Fz(million) = million million million million ...  ... ... million million with a million "million"s =
 
(10^6)^(10^6) = 10^6,000,000
 
It's interesting to note that a Fzmillion basically uses the same basic strategy of repeating the name of a number over and over again to name a very large power of that number. This is the same trick that Kieran used before Alistair had told them about the googolplex. The advantage with saying a Fzmillion, as opposed to a kid simply saying a million as many times as he/she can muster is that there is virtually no way to say a million that many times. It can of coarse be done, but as we saw in chapter 2-1 doing virtually anything a million times is very time consuming, and at least a year should be allotted for any serious attempt to do so. Certainly no kid would be able to say a million a million times within a single day as there are only 86,400 seconds in each day which means saying a million about 11 times per second which is just impossibly fast. Furthermore, and more to the point, even if you could say a million that many times, why bother when a Fzmillion is so much quicker to say. But we aren't done yet, we can still use even higher numbers to create even larger numbers. It should be noted that while Fzmillion is phenomonally large, it is still smaller than a googolplex, so it's not really pushing the limits here. So let's move on:
 
Fzbillion = Fz(billion) = (10^9)^(10^9) = 10^9,000,000,000
 
Fztrillion = Fz(trillion) = (10^12)^(10^12) = 10^12,000,000,000,000
 
...
 
Fzgoogol = Fz(googol) = googol^googol = (10^100)^(10^100) = 10^(10^102)
 
Take note of the Fzgoogol. It is actually A LOT bigger than a gargoogol. A gargoogol is simply 10^200, or 1 followed by 200 zeroes. A Fzgoogol however is 1 followed by a hundred googol zeroes. A Fzgoogol is also "just a little larger" than a googolplex (relatively speaking of coarse). In fact a Fzgoogol is equal to a googolplex^100. It may seem strange at first that raising a googolplex to the 100th power only increases the second exponent by 2, but it follows from the laws of exponents:
 
(10^(10^100))^100 = 10^(100*10^100) = 10^(10^2*10^100) = 10^(10^102)
 
 Although this seems counter-intuitive keep in mind that the second exponent, or "hyper exponent" is much powerful than an ordinary exponent. Increasing an ordinary exponent by one merely multiplies the value 10 fold. Increasing a hyper exponent by one however takes the original number and raises it to the tenth power!
 
 Note that a Fzgoogol is already larger than a gargoogolplex! So what happens when we plug a googolplex into the Fz function:
 
Fzgoogolplex = Fz(googolplex) = (10^(10^100))^(10^(10^100)) = 10^(10^100*10^(10^100)) =
 
10^(10^(100+10^100))
 
 A Fzgoogolplex, it turns out, is just a little bit larger than 1 followed by a googolplex zeroes, which is most commonly referred to as a googolduplex. In fact it is equal to googolduplex^googol. That's a pretty large number, though we could have achieved a similiar result simply by applying the -plex function twice, as you can see. Let's also compare a gargoogolplex with a Fzgoogolplex...
 
Where as a gargoogolplex is merely a googolplex googolplexes...
 
a fzgoogolplex is a googolplex googolplex googolplex googolplex ... ... ... ... googolplex googolplexes where you have to say a googolplex a googolplex times!
 
That's MUCH MUCH larger than a gargoogolplex and no body is going to top that...
 
 Or so Alistair falsely reassures us before unveiling his families next innovation. First he comes up with a new prefix , "fuga", to go one step further in this gimmick. Alistair tells us that the name comes from a combination of "fugue" and Kieran's "gar" prefix. It is also supposed to be pronounced "Few-ga", though every time I see it, it reads "foo-ga" to me. Now it was observed that the Fz only exponentiated once. So Alistair dreams up the ultimate five your old trump card, a googolplex raised to the googolplex raised to the googolplex ... seemingly without end. So Alistair defines fuga-"number" as "that number raised to that number that number of times". There is a certain degree of ambiguity in such a phrase. Thankfully Alistair shows us some examples that make his meaning clear. Firstly we have...

Fugatwo = Fuga(2) = 2^2 = 4

 This is no different than Fz(2) or even gar(2). What about 3?

Fugathree = Fuga(3) = (3^3)^3 = 27^3 = 19,863

This is much larger than gar(3) = 9, and Fz(3) = 27. Moving on...

Fugafour = Fuga(4) = ((4^4)^4)^4 = (256^4)^4 = 4,294,967,296^4 ~ 3.4028 x 10^38

Compare this to gar(4) = 16 and Fz(4) = 4^4 = 256. Already the number is huge, and we only plugged in 4!. Let's try the numbers up to ten:

Fugafive = Fuga(5) = (((5^5)^5)^5)^5 = ((3125^5)^5)^5 = (298,023,223,876,953,125^5)^5 ~

(2.350988x10^87)^5 ~ 7.18212x10^436

Fugasix = Fuga(6) = ((((6^6)^6)^6)^6)^6 ~ 8.01905x10^6050

Fugaseven = Fuga(7) = (((((7^7)^7)^7)^7)^7)^7 ~ 8.695801x10^99,424

Fugaeight = Fuga(8) = ((((((8^8)^8)^8)^8)^8)^8)^8 ~ 9.384262x10^1,893,916

Fuganine = Fuga(9) = (((((((9^9)^9)^9)^9)^9)^9)^9)^9 ~ 1.175370x10^41,077,011

Fugaten = Fuga(10) = ((((((((10^10)^10)^10)^10)^10)^10)^10)^10)^10 = 10^1,000,000,000

 As you can see, a fuga is a big improvement over the gar and fz and grows very rapidly. In fact it grows even faster than the plex function which we introduced in the last article. The value of the plex function merely increases 10 fold every time its input increases by one. Fuga(10) is already a number with a billion and 1 digits (1 followed by a billion zeroes to be exact). So what happens when we plug in some even bigger numbers into this function? What would Fuga(100) be?

Fugahundred = Fuga(100) =

((( ... (((100^100)^100)^100) ... ... )^100)^100)^100 with 100 copies of "100" =

100^(100*100*100* ... ... *100*100) with 100 copies of "100" = 100^(100^99) = 100^(10^198) =

10^(2*10^198)

 So a Fuga(100) is already greater than a googolplex! Let's try some higher values...

Fugathousand = Fuga(1000) =

((..((1000^1000)^1000) ... ... )^1000)^1000 with 1000 copies "1000" =

1000^(1000^999) = 10^(3*10^2997)

Fugamillion = Fuga(1,000,000) =

((..((1,000,000^1,000,000)^1,000,000) ... )^1,000,000)^1,000,000 with 1,000,000 copies of

"1,000,000"
=

10^(6*10^5,999,994)

Fugabillion = Fuga(1,000,000,000) = 10^(9*10^9,999,999,991)

Fugatrillion = Fuga(1,000,000,000,000) = 10^(1.2*10^11,999,999,999,989)

...

Fugagoogol = Fuga(googol) =

((..((googol^googol)^googol) ... ... )^googol)^googol with a googol copies of a "googol" =

googol^(googol^(googol-1)) =

(10^100)^((10^100)^((10^100)-1)) =

10^(100*10^((100*10^100)-100)) =

10^(10^((10^102)-98)) ~

10^(10^(10^102))

So a fugagoogol is already somewhat larger than a googolduplex. Of coarse the "102" at the top is deceptive and actually means a number MUCH larger than a googolduplex. Recall that the second exponent was much more powerful than the first. Well the third is even worst. Every time the third exponent increases by 1 you take the original value, find out how many zeroes it has and raise this number to the tenth power and that's how many zeroes the new value will have. It should be noted this is much more powerful than simply raising a number to the tenth power. When we raise a power of ten to the tenth power, the number of zeroes gets multiplied by 10. However simply squaring the number of zeroes would mean that the number of zeroes got multiplied by the number of zeroes. However you have to raise the number of digits to the tenth power to increase the third exponent by one.

 Just as an example , let's increase a googol in this manner. Since it has 100 zeroes we have to take that number and raise it to the tenth power. Thus we would then have 100^10 or 10^20 zeroes. This number would be 10^(10^20), which is very larger, much larger than a googolgong (10^100,000) though less than a googolplex (10^(10^100)). If we applied this again we would get 10^(10^200). Basically increasing the third exponent by 1 multiplies the second exponent 10 fold which in turn raises the first exponent to the tenth power!

 So A fugagoogol is also a 1 followed by a googolplex^100 zeroes. Now what if we plug in a googolplex?

Fugagoogolplex = Fuga(googolplex) =

((..((googolplex^googolplex)^googolplex) ... ... )^googolplex with googolplex copies of "googolplex" =

googolplex^(googolplex^(googolplex-1)) =

10^10^X

where X = 10^(googol+100)-googol+100

Basically X ~ googolplex, so 10^10^X is approximately a googoltriplex. It is also possible to prove that it is necessarily larger than a googoltriplex. We do this overestimating the contribution of negative factors while ignoring the benefit of positive factors and showing the resulting estimate is still greater than the intended value. It follows that if the estimate is less than a fugagoogolplex and the estimate is larger than a googoltriplex then a fugagoogolplex must be larger than a googoltriplex. First we look at the X, or second exponent:

10^(googol+100)-googol+100 > 10^(googol+100) - googol


So we have 1 followed by a googol+100 zeroes minus a googol. It should be understood that subtracting a googol from 10^(googol+100) will make nearly no difference. However we can not simply drop this negative factor, and instead must overestimate its effect. Imagine this:

 10^(googol+100) - googol =

10000000000 ... ... ... ... 000 ... 00000 (with googol+100 zeroes)

                       - 10 ... 00000 (with 100 zeroes)

=

                           9999999999 ... ... ... ... 990 ... 00000 (with a googol "9"s followed by 100 zeroes)

this is greater than...

                           9000000000 ... ... ... ... 000 ... 00000 (with a googol+99 zeroes)

which is greater than 10^(googol+99)

Thus X > 10^(googol+99)

It follows that ...

Fugagoogolplex > 10^10^10^(googol+99) > 10^10^10^(googol) = googoltriplex

Therefore...

Fugagoogolplex > googoltriplex

 Note the amount of effort required to show that a Fugagoogolplex is larger than a googoltriplex. In the world of large numbers it is easier to prove one number is larger than another when it is MUCH larger. The "closer" the two numbers are the more difficult it is to decided which of the two is larger. You might say that that is not always true since its easy to show that a googolplex+1 > googolplex. However, when one number is used to generate a still larger number then it is definitely larger, even if the difference is relatively small. The difficultly lies in numbers that were defined using different functions but are still relatively close together. A googoltriplex is built using the plex function while the fugagoogolplex uses the fuga function. To compare these it is necessary to break both down to their common building block: exponentiation. The laws of exponents can then be used to compare the values more directly.

 Now Alistair wraps up his article not with a fugagoogolplex, but a fugagargoogolplex, because he knows Kieran would just top it with fugagargoogolplex. This number is not that much larger than a fugagoogolplex. Basically a fugagargoogolplex is

10^10^X

where X = 10^(gargoogol+200)- gargoogol + 200

Ignoring the trivial terms We can say a fugagargoogolplex is approximately...

10^10^10^10^200

(right to left resolution)

 Alistair describes a fugagargoogolplex as "a number so big it boggles the ears just in the speaking". After reaching this apex Alistair wonders how long it will takes his kids to realize they could just continue by saying "fuga fuga fuga ... "

Prologue: The Megafuga and Beyond...

 After having dabbling in generating large numbers and writing his infamous article, Alistair began a forum of sorts on what he and his kids had come up with. One of his friends , Stephan Houben almost immediately alerted him to the fact that repeated exponentiation is ambiguous because the result depends on the order in which the operations are carried out. This is not true for addition and multiplication. Note that:

3+3+3 = 9

and

3*3*3 = 27

No matter what order you choose to resolve the expression. But consider the following expression:

3^3^3

Let's say we resolve it from left to right, as is standard with the usual order of operations (PEMDAS). We would then have ...

3^3^3 = 27^3 = 19,683

 This is also the same as fuga(3). If we carry out the operations from right to left however, what happens? Let's find out...

3^3^3 = 3^27 = 7,625,597,484,987

 This is much larger. How about taking it to the next level:

3^3^3^3 = 27^3^3 = 19,683^3 = 7,625,597,484,987

So we obtain about 7 trillion when resolving from left to right. But watch what happens when we resolve in the reverse order...

3^3^3^3 = 3^3^27 = 3^7,625,597,484,987 ~ 10^(3.6*10^12)

It's a number with about a trillion digits! Or more accurately it's 3 to the power of about 7 trillion. This is much much larger, and the disparity between the fuga and right to left resolution only gets worse as the values climb.

 This happens because exponentiation, unlike addition and multiplication, is not commutative. To say a binary operation (or function) is commutative means that changing the order of the inputs does not change the output. Thus for addition and multiplication we can say:

a+b = b+a

and

a*b = b*a

However in the case of exponents it turns out that

a^b =! b^a

 For almost all values of a and b (there is the notable exception of 2^4 = 4^2, but these are rare exceptions to the rule). For example note that...

3^4 = 3*3*3*3 = 81 & 4^3 = 4*4*4 = 64

Therefore

3^4 =! 4^3

 
 Since exponents do not commute for all values of a and b, exponentiation is said to be non-commutative.

 For this reason stacking exponents is considered somewhat ambiguous. However, since right to left resolution generates much larger numbers, and the goal is to generate the largest possible numbers, this resolution has become standard. In fact, repeated exponents resolved from right to left is an operation known as "tetration". We will be learning more about this later in the chapter.

 In any case, Stephan suggested that Alistair keep fuga unchanged, but he could define a new prefix, suggesting "megafuga", that would involve right to left resolution. Alistair took this suggestion, and thus the megafuga was born. We can define the megafuga as...

Megafuga(n) = n^n^n^n^ ... ^n^n with n copies of "n" resolved from right to left

 The megafuga is very close to the concept of tetration, but it is not exactly the same function. First off the megafuga is a unitary function, while tetration is a binary function (as we will see). However, it is possible to define megafuga using tetration.

 So let's see what a Megafuga can do. First let's start with the small values...

megafugatwo = megafuga(2) = 2^2 = 4

Nothing new here...

megafugathree = megafuga(3) = 3^3^3 = 3^27 = 7,625,597,484,987

This is much larger than fuga(3) = 19,683...

megafugafour = megafuga(4) = 4^4^4^4 = 4^4^256 ~ 4^(1.34x10^154) ~ 10^(8.07x10^153)

A megafugafour is already larger than a googolplex! That is pretty impressive. Let's try some higher values...

megafugafive = megafuga(5) = 5^5^5^5^5 = 5^5^5^3125 ~ 5^5^(1.911x10^2184)

This number is already larger than a googolduplex!

megafuga(6) = 6^6^6^6^6^6 = 6^6^6^6^46,656

megafuga(7) = 7^7^7^7^7^7^7 = 7^7^7^7^7^823,543

megafuga(8) = 8^8^8^8^8^8^8^8 = 8^8^8^8^8^8^16,777,216

megafuga(9) = 9^9^9^9^9^9^9^9^9^9 = 9^9^9^9^9^9^9^387,420,489

megafuga(10) = 10^10^10^10^10^10^10^10^10^10

It should be noted that by megafuga(6) we already passed up the fugagargoogolplex! The megafuga is not merely a little more powerful than the fuga, it is WAY more powerful. The fuga function actually is on par with hyperexponential growth. That is, the number of digits increases exponentially. But the growth of the megafuga function requires a completely new kind of term. We can say it exhibits "tetrational growth". While exponential growth happens in the real world, and hyperexponential growth might be possible when considering the growth in the number of parallel universes, nothing is science or science fiction really comes close to tetrational growth. Basically it means going from exponential to hyper exponential, to double hyper exponential, ... etc. It transcends the growth rate exhibited by increasing ANY level of exponent (recall the concept of the first , second and third exponents). Megafuga(10) is a very huge number, although we did consider even larger ones in the last article. As a kid I was always very impressed with this number ( I had come up with it independently).

 What if we plug even larger values into a megafuga? The numbers get so large that it becomes impossible to quantify them for example ...

megafugahundred = megafuga(100) = 100^100^100^100^ ... ^100^100 with 100 copies of "100".

This number is larger than a googolnovemnonagintiplex which is plex^99(googol) or plex(googol,99). You might have guessed already that the megafuga is able to go up one member of the googol series every time we increase the increment by 1. In fact, it grows a little bit faster than the googol series, making it the fastest growing function we have considered as of yet.

 Let's skip ahead then, and plug in a googolplex...

megafugagoogolplex =

googolplex^googolplex^googolplex^ ... ^googolplex^googolplex

with a googolplex copies of "googolplex"

 That's a "power tower" of googolplexes, a googolplex terms high. This number is pretty close to the size of the googolplexth member of the googol series. This was the biggest number mentioned in the previous article.

 So is that it?!

 
Sort of. Alistair didn't coin anything beyond the megafuga, however he did eventually learn that the sequence of operations of addition, multiplication, exponentiation, can be continued with tetration, pentation, hexation, ... and so on to infinity. As Alistair says this implies that there is also centation, googolation, googolplexation, ... gargoogolplexation...etc.

 This means that we could have say...

 a googolplex googolplexated to the googolplex

 a gargoogolplex gargoogolplexated to the gargoogolplex

 a fzgoogolplex fzgoogolplexated to the fzgoogolplex

 a fugagoogolplex fugagoogolplexated to the fugagoogolplex

 a megafugagoogolplex megafugagoogolplexated to the megafugagoogolplex

 etc.

 How huge are these?! It's so large that I can not even use stacked exponents to even have a chance
to explain their size. In fact these numbers are way beyond anything we have considered yet. The only numbers that we have considered that would surpass these would be those we considered in chapter 2-3 in the article "Imagining Big Numbers". It is also interesting to note that...

Fz(n) = n exponentiated to the nth

Megafuga(n) = n tetrated to the nth

We could theoretically imagine continuing this sequence, with a function defining n pentated to the nth, then a function defining n hexated to the nth, and so on. Naturally Alistair would suggest a function to simply have n n-ated to the nth. For this we can use "booga" and then we can say that...

booga(1) = 1 + 1 = 2

booga(2) = 2 * 2 = 4

booga(3) = 3^3 = 27

booga(4) = 4 tetrated to the 4th = 4^4^4^4 ~ googolplex

booga(5) = 5 pentated to the 5th

How large is booga(5)? It is much much larger than a megafugagargoogolplex! And we could continue all the way to a ...

boogagoogolplex

which would be a googolplex googolplexated to the googolplex.

 Thus we can now give a name to all the above numbers. Of coarse we can always just say "booga booga booga ... " to scare away the competition :)

Some Misunderstandings & ambiguities

 Alistairs numbers have been misinterpreted and this has lead to some confusion on certain large number sites, which have incorrectly coined numbers within his system.

 The most common mistake is to misinterpret gargoogolplex as 1 followed by a googolplex zeroes, or a googolduplex. According to the original article however it was defined as googolplex^2, which is much much smaller. Someone also seems to have extended this faulty naming scheme one further with the gargantugoogolplex, which would be 10^10^googolplex. This is the origin of the name megafugagargantugoogolplex, which is the largest number appearing on some large number lists. While certainly very large within its erroneous definition, we can name the exact same value by calling it a megafugagoogoltriplex. Furthermore this "plex naming scheme" is far more extendable.

 The are also a few minor issues with Alistairs numbers. One problem is that a term like a gargoogolplex could actually be confusing. Is a gargoogolplex...

gar(googolplex) or plex(gargoogol)

These numbers are completely different. In fact a plex(gargoogol) is much larger. The same applies to all of Alistairs prefixes. One way to resolve this might be to assume that suffixes must always be carried out first with prefixes applied from right to left, or from inside out. For example a ...

fugafugagoogolplex = fuga(fuga(googolplex))

 In a post-script to his article, Alistair claimed that fuga(n) = n^n^2 or a little less. It turns out that it is actually higher than this, not less. It is not difficult to prove that fuga(n) must be equal to n^n^(n-1). To show this we use the exponential law:

(a^b)^c = a^(b*c)

 It follows from this definition that ...

fuga(n) = (( ... ((n^n)^n)^n) ... )^n)^n with n copies of "n" =

n^(n*n*n* ... *n*n*n) = n^(n^(n-1)) = n^n^(n-1) right to left resolution

 Alistairs prefixes, it must also be admitted, are not terribly potent, with the exception of the megafuga.  The Fz is an exponential class function, while the fuga is a hyper exponential function. The fuga and the megafuga functions are the only ones that are significantly more powerful than the plex function. None the less, most of the names coined by adding an Alistair prefix to a googolplex are still much larger than the ordinary person will usually think about, especially the megafugagoogolplex.

In Conclusion: This is Just the Beginning

 So where do we go from here? We could of coarse continue in the spirit of Alistair cockburn and come up with more and more prefixes. One good way to achieve a sequence of such prefixes would be to name a new prefix , define a new function, call it f1(n) and then say:

f1(n) = megafuga(megafuga(megafuga(...(megafuga(n)) ... )) with n copies of "megafuga"

 We can then use this trick again to define a new function as iterations of the previous function. Thus:

f2(n) = f1(f1(f1 ... f1(f1(n)) ... )) with n copies of "f1"

f3(n) = f2(f2(f2( ... f2(f2(n)) ... )) with n copies of "f2"

etc.

 It should be clear, that if we continue in the style of Alistair we would need a name for every single one of these prefixes. You can imagine that we would either quickly run out of ideas, words, and would have to resort to some sort of extendable scheme. As we have seen these can be very difficult to construct logically.

 Furthermore, it turns out that this sequence of f functions would still be transcended by the booga function that I mentioned. It turns out that every function will increase by one operation level. Just as megafuga is on par with tetration, f1 would be on par with pentation, f2 with hexation, and so on. But what are these "operation levels" and how do they work?! This requires an entire discussion in itself. In the coming articles we will be learning about this very thing. As you will see, the operation levels allow us to transcend the kinds of large numbers people usually generate. Often peoples first ideas about what a "extremely large number" is, before knowing much about large numbers, is that it must be something like 1 followed by a lot of zeroes, or a power tower with a ridiculous number of 10's. But this is only the very beginning. We can go beyond power towers with operation levels. This will bring us to numbers larger than most of the numbers we talked about in the first two sections. Before the end of this chapter we will be able to start working with numbers larger than any numbers discussed yet.