The Fast-growing Hierarchy: A Journey up an Endless Ladder
This is a work in progress.
In math, there exists a series of functions, each function building on the last, that generate stupendously, unbelievably large numbers. This is called a fast-growing hierarchy. For our purposes, we’re going to call what we’re using the fast-growing hierarchy, as we will follow the most traditional and most common set of rules.
Introduction to hyperoperators
Although addition might seem like the most basic mathematical operation, it turns out that there is an even simpler operation that addition is built on: the successor function. Written S(n), it is an extremely simple function—so simple that most people don’t even know about it. It can take any natural number n (or 0) as an input, and all it does is simply move to the next natural number. So…
…and so on. In general,
This forms the basis for addition and all hyperoperators that follow. (Don’t worry, I’ll explain what that means in a second.)
Addition is simply repeated application of the successor function.
a is the number you begin with, and b is the number of times you’re moving to the next number. For example:
This expression is equivalent to using the successor function on the number 3 twice.
And what do you know? You get 5. This is a common way of teaching addition to people that aren’t familiar with it; it’s described as simply counting up from a certain number a certain number of times. This is that explanation, just expressed in terms of mathematical definition. Here’s another example.
2, the first number in the expression, is the initial number being processed, and 4, the second number, is the number of times it’s being processed. In general,
The definition of the next operation, multiplication, is much more well-known.
The most important concept to remember in order to understand the hierarchy is that each function describes repeated application of the last. In this case, multiplication is repeated addition. a is the number you’re adding to itself repeatedly, and b is the number of times you do it.
I’m evaluating the addition one step at a time for a reason that will become clearer later on. 3 is the number being manipulated, and there are 4 steps. Here’s another example:
We can once again generalize this with:
Of course, there is another operation, and it’s exponentiation. It works in exactly the same way (except that it’s not commutative).
The base, the first number, is what you’re multiplying, and the exponent, the superscript, is how many times you’re doing it.
If we really want to break exponentiation down into the successor function, we can.
It’s tedious, but it works! First, unpack the power into multiplication—3 raised to the 2nd means multiplying 3 by itself (since there are two 3s there). You’ve already got a simplified multiplication expression, since there’s only 2 numbers, and 3 times 3 is 3 added to itself 3 times. Start from the right, with 3 + 3 being 3 applications of the successor function to 3 (counting up 3 numbers from 3). That’s 4, 5, 6. Now, add 6 to 3, which means 6 repetitions of the successor function on 3. 4, 5, 6, 7, 8… 9!
Each one of these operations (addition, multiplication, exponentiation) is called a hyperoperator (that’s what I was talking about before). And believe it or not, we can continue. The next operation is called tetration, and, yep, it’s repeated exponentiation. Using Donald Knuth’s up-arrow notation, tetration is written as:
As always, a is the number being manipulated and b is the number of copies.
Understandably, towers of exponents can be more difficult to understand intuitively, so here are a couple examples of evaluations.
Performing these higher hyperoperators with any number larger than 2 generates ridiculously large results very quickly.
As you can probably guess, this continues on. Next comes pentation, which is repeated tetration and is written with three arrows.
Pentation is really hard to evaluate. But don’t worry, we’ll talk about it in more detail later when we meet an enormous beast that shall not yet be named.
Pentation is followed by hexation, heptation, octation… it never ends. Countless notations have been created that extend this basic idea of recursion to incredible heights. However, I’m going to be focusing on one in particular, one that is immensely powerful, the original focus of this article—the fast-growing hierarchy.
Chapter I: The Initial Series
The skyscraping ladder begins in the same place the hyperoperators do—the good old successor function. Except in the fast-growing hierarchy (or FGH for short), it’s known as f₀ (pronounced “eff sub zero” or “eff zero”).
This is a familiar situation! Put in a number, and it spits out the next one! Here are the values of f₀ with inputs 1 to 4.
Although it isn’t defined this way, we can express this function algebraically:
It’s pretty clear that this function alone isn’t going to get us very far. But don’t take it for granted! Just like the successor function being the basis for addition, multiplication, exponentiation, tetration, pentation, etc., the fast-growing hierarchy would not exist without f₀. It’s the bottom rung on the ladder: unimpressive on its own, but carrying the weight of infinity on its shoulders.
Next up, the second function of the hierarchy. Somewhat predictably, it gets the name f₁. Similar to what we saw before, its definition is based on repeated applications of the previous function.
Let’s evaluate some values of f₁!
Unlike traditional mathematical operations like addition and multiplication, which have two inputs, these functions only have one. For example, take the expression “2 × 3”. Remember that the first number, 2, is the one being added to itself repeatedly, and the second number, 3, is the number of repetitions. With the f functions, there’s only one number to put in, as in “f₁(3)”. That 3 takes care of both roles, acting as both the number being manipulated and the number of repetitions. (Note: The 1 under the f isn’t an input, it’s just the name of the function.)
So, okay, f₁ is a tiny bit faster than f₀. In fact, as you can see, it also forms a pattern, this time outputting 2, 4, 6, 8, and so on. Therefore, we can say that:
Doubling is certainly faster than adding one, but we can do much better. I think you can see where this is going.
Our third function! What better way to witness its power than to plug in some values?
Before moving on to plugging in 3 and 4, I want to explain what’s going on here verbally, as it can look like a bit of a mess.
First, plugging 2 into f₂ tells us to use 2 layers of the previous function, f₁, on the number 2. We then work from the inside out, first focusing on the innermost f₁(2). Again, this means to use 2 layers of the previous function, this time f₀, on the number 2. This means counting up by ones 2 times from 2, which gets you to 4. We’re now left with a single layer of f₁, but now the input is 4. This means 4 layers of f₀ on the number 4, which is simply counting up by ones 4 times from 4, which gets you to 8. Woohoo!
Using our shortcuts of f₀(n) = n + 1 and f₁(n) = 2n, we could make this a lot faster:
Hopefully this makes a bit more sense now. Here’s the output when you plug in 3.
Jesus Christ. The full step-by-step evaluation process gets out of hand pretty quickly, which is why finding shortcut equations becomes very important. Let’s use f₁(n) = 2n.
Using the doubling shortcut, we get the same answer in a much shorter time. If you’re comfortable, you can skip the step of writing out 2 • n and just double the number in your head.
Hey, we’re getting somewhere! 2, 8, 24, 64 is definitely a faster sequence. It also has its own shortcut equation, but it’s slightly less elegant than simply adding one or doubling.
This means we now have an exponential function! But we can go further. So much further.
Okay, if you’re not already familiar with large numbers, I recommend sitting down. This function is a monster. It blows f₀, f₁, and f₂ way out of the water, without question. Let’s check it out.
With any f function, plugging in 1 always returns 2 because it simply sends the 1 down the entire chain without adding any layers.
2,048 is a pretty big number to reach with just the second input. How large do you think an input of 3 will be? A million? A billion? A trillion?! Let’s find out.
I’m going to break this up into parts to make it easier to digest.
We’re down to two layers and so far it’s totally manageable.
Whoa! We got a number in the millions! Pretty big, but the world deals with amounts of money much larger than that. We still have everything under control.
Oh fuck.
This is a really large number. It’s what you get when you take 402,653,184 and double it… 402,653,184 times. It’s already beyond anything physical you could possibly count in the universe, and it’s even hard to find in theory! Here’s how to write this number in scientific notation.
That’s a 120 million digit number. Typing it out by hand with no breaks for sleeping, eating, or anything else, would take 280 days! If you more realistically committed six hours a day to typing digits (which is ridiculous, don’t do that) it would take more than three years.
Before we even attempt to plug in 4, let’s just step back for a second and acknowledge how big of a jump that was.
+----+---+------+------------------+-----+
| | 1 | 2 | 3 | 4 |
+----+---+------+------------------+-----+
| f₀ | 2 | 3 | 4 | 5 |
+----+---+------+------------------+-----+
| f₁ | 2 | 4 | 6 | 8 |
+----+---+------+------------------+-----+
| f₂ | 2 | 8 | 24 | 64 |
+----+---+------+------------------+-----+
| f₃ | 2 | 2048 | 7 x 10^121210694 | ??? |
+----+---+------+------------------+-----+The leap from f₂ to f₃ is mind-blowing. I mean, you can feel how ridiculous it is just by listing each function’s values one after another!
2, 3, 4, 5. How simple and easy!
2, 4, 6, 8. Oh, fancy, skipping by twos!
2, 8, 24, 64. Aww, it’s actually kind of fast now!
2, 2048, 120 million digit number that would take 3 years to type. O_O
See now why it’s called the fast-growing hierarchy? They weren’t kidding.
Now that you’ve (hopefully) appreciated the power of this function, we have to plug in 4 and see what happens!
Three layers to go.
Two layers to go, and good God, here we go again.
Lord have mercy. This number has over 300 quintillion (300,000,000,000,000,000,000) digits and we still have to put it through one more layer of f₂.
And there you have it. That’s a number not with 300 quintillion digits, but one with nearly 10 to the power of 300 quintillion digits. Here’s a way to imagine this number. It might not give you an intuitive, palpable grasp, but it should help you at least understand it a bit better.
Okay, picture yourself typing out the 300 quintillion digit number from the previous step. If you were type digits 24 hours a day, non-stop, by the time you were done, if the universe is still around, every star in the Milky Way Galaxy will have died out. Printing it out on A4 paper at 12 pt font, the sheets of paper would stretch from Earth to Pluto and back more than 3,000 times. That’s a big number, right? Okay, now imagine a number with that many digits. A number with a digit count equal to the number that took trillions of years to type. That’s f₃(4).
Unfortunately, we don’t get any special shortcut formula for f₃. The algebraic equivalent is simply too long and complicated to offer any kind of easier solution. From this point on, we’re working with approximations—but remember, they are just as precise as they are large.
Ready to continue? Well, just as with the hyperoperators, this series of f functions continues indefinitely. Let’s see two more in detail before making our first major leap of faith.
No surprise there! But how powerful is it?
Well, we knew that was going to happen.
Oh God. Just plugging in 1 through 3, f₃ grew from 2 to 2,048 to 10¹²¹²¹⁰⁶⁹⁴. Now, f₄ is asking us to plug in 2,048. That’s more than two thousand iterations of f₂! Each new iteration requires us to plug the current number into n • 2ⁿ. Because exponentiation grows so much more quickly than multiplication, not worrying about the coefficient makes for a much simpler yet extremely accurate approximation. (Trust me on this one. Multiplying a tower of exponents by a single number isn’t going to affect its value in the least.) So:
Let’s convert it into a tower of 10s so that it can be easier to understand.
To write out this number, first write a 1 followed by 616 zeroes.
Perfect. Now write a number with this many zeroes.
Got it? Okay, now write a number with that many zeroes.
Got it? Now write a number with that many zeroes.
Got it? Now write a…
Repeat this process a total of 2,047 times, and you’ve got f₄(2).
Yeah. How on earth are we supposed to simplify this any further? Well, remember tetration, the repeated application of exponentiation? Even though f₃ doesn’t have an exact shortcut formula, it does have an approximate one:
Here’s the definition for tetration again, just as a refresher.
Using this formula, we can progress.
That’s a stack of “2 to the power of 2 to the power of 2 to the…” 10¹²¹²¹⁰⁶⁹⁴ levels high!
Parentheses are not needed, just remember that tetration and all higher hyperoperators are evaluated from right to left, just like exponents.
That’s our number!
Please excuse the poor handwriting, but hopefully this visual helps. It’s a stack of 2s with a height that is a stack of 2s with a height that is a 1 followed by 121,210,694 zeroes.
But, of course, we can go further.
Let’s just go straight to plugging in 3 this time. We know that plugging in 1 will give us 2, and plugging in 2 will create a ridiculously large number, but the jump from 2 to 3 is the first huge gap.
We already know the value of f₄(3), so let’s plug it in.
Eek. We need a general formula for f₄ now. Don’t worry, you don’t have to figure it out yourself, I’ll just reveal it:
We’ve reached pentational growth rates! Let’s finish off this evaluation.
I don’t know about you, but when I get to this stage I start experiencing a kind of desensitization. I don’t feel the size of these numbers anymore. I just start seeing patterns of arrows and losing my grasp on the hugeness of their values. Don’t worry if this is happening to you; I know what it’s like. When we meet the enormous beast that shall not be named, I’ll provide more visual aid for understanding the higher hyperoperators.
Either way, that’s our function. This process goes on forever, each function immeasurably more powerful than the last.
In general,
The m+1th function is equal to the mth function repeated n times.
Have you noticed a pattern beginning to occur with the shortcut formulas? I don’t blame you if you haven’t. I’ll list what we’ve encountered so far.
Do you see it? Each function uses a hyperoperator, starting with addition for f₀, then followed by multiplication for f₁, exponentiation for f₂, tetration for f₃, pentation for f₄… Each new f function closely follows the next corresponding hyperoperator! Does this pattern hold for further functions? Yes!
We can create a generalized formula for this too. The mth function always uses m minus 1 arrows! The superscript on the arrow tells us how many arrows to write.
Take a deep breath. That was a lot. Feel free to take a break or re-read anything if you need.
Surely, with our infinite arsenal of ever-increasing power… surely, surely there cannot be a number too large—a number so big that using our f functions to reach it is not any faster than writing out its digits one by one. Right?
R-right?
Chapter 1.5: The Enormous Beast that Shall Not Be Named
N-no, what? It can’t be! We just went through so much turmoil creating this ladder of unconquerable strength! How could anything outpace it?
It’s time. Let me introduce you to the beast. It calls itself Graham’s number.
It was introduced by Ronald Graham and Bruce Lee Rothschild in 1971 in a paper about Ramsey theory, a combinatorics-like branch of mathematics, in this case concerned with higher-dimensional geometry. It received a bit of a cult following after Martin Gardner popularized it in 1977, calling it “the largest number ever used in a serious mathematical proof.” It was even recognized as such by the Guinness Book of World Records in 1980. This may have been true at the time, but since then the record has been broken several times. This does not discredit Graham’s number however!
To understand its size, let’s first go through the hyperoperators, using the number 3 each time.
Alright, those are all very simple. We encountered this with tetration before as well:
The number starts to grow very quickly from tetration on.
3 pentated to the 3rd means tetration with 3 3s.
Then, we can plug in 3↑↑3 from before, making sure to evaluate from right to left.
Pentation gets us to a tower of 3s 7.6 trillion high. In each of those 7.6 trillion steps, the exponent becomes 3 to that exponent, all the way down to the last 3 at the bottom.
Now we’re pentating 3 to the 7.6 trillion high tower of 3s from before.
So you’re recalculating the height of the tower with each new number over and over. How many times? 3↑↑↑3 times! 3 hexated to the 3 gets a special designation.
We can keep going with this.
And going.
And going!
At this point, it’s less about grasping the actual size and more just understanding the process of getting there and appreciating its shape. Each new hyperoperator visually adds a kind of dimension to the procedure, making the entire map stretch vertically, then horizontally, then vertically… zooming out more and more. But let’s go back to g₁ for a moment.
This number is mind-blowingly huge, but it was a bit easier to get a grasp on than the ones that followed. Is this Graham’s number? No—it’s the first half of the journey. This second half is going to take it up to eleven. It’s the reason that not even FGH’s f functions, nor hyperoperators, can get there quickly.
The fact that g₁ exists makes it seem likely that a “g₂” does too. And it does! Just like g₁, it’s also two threes separated by a certain number of arrows. How many? Ten? A hundred? A googolplex?!
O_O
Yeah. Remember how each arrow added an entire layer of complexity? How each additional arrow created a function so much more powerful than the last? The function we use to reach g₂ has not 10 arrows, not 10¹⁰⁰ arrows, but 3↑↑↑↑3 arrows.
THIS MANY ARROWS!!!!!
We’re not at Graham’s number yet, though.
You heard me.
You heard me.
This process repeats indefinitely. Each new g number has a number of arrows equal to the previous one. The number of new monumental leaps taken per g number is the last g number.
Graham’s number, written G, is g₆₄.
Here’s one final visual representation to help this really sink in.
Long story short, it’s enormous. No f function is powerful enough to each it. As we’ve seen:
So g₂, having g₁ arrows, already exhausts the efficiency we built up:
Having to go all the way to the g₁th function just to get to the next g number is very inefficient. We were able to go beyond a googolplex by plugging 4 into function 3… yet to reach a Graham’s number we have to go all the way to function g₆₃.
I mean, that’s basically just the Graham’s numberth function. We need a much more powerful system. Something that can express Graham’s number much more simply; much more efficiently. Has the fast-growing hierarchy reached its end? Will we have to say goodbye?
Chapter 1.75: It’s All Greek to Me
No. The answer is no. If you’re familiar with FGH you’d be laughing your ass off at that question. The elementary f functions, f₀, f₁, f₂, f₃… are so unbelievably weak compared to the rest of what FGH has to offer.
The next function I’m going to introduce might not make sense until you meet its successor, so stick with it for now. We’ve used every single number now—the f functions go off into infinity. What comes next?
To continue, we’re going to have to become familiar with transfinite ordinals. If you’re versed in set theory, you’ll likely know about these, but they’re not well-known in everyday math. They’re called transfinite because they are larger than every finite number, but calling them infinite numbers isn’t really any different (it’s mostly for disambiguation).
Numbers can be broken up into two groups: cardinal numbers and ordinal numbers. Cardinals count amounts while ordinals count the order of things. In English, the cardinal numbers are one, two, three, four… while first, second, third, fourth… are the ordinal numbers.
In math it’s similar. For example, imagine a race with five runners. Counting all the runners will get you, well, five. Five is thus the cardinal number you’d use to represent the set of runners; it’s the set’s cardinality.
If you then were to list the runners in order by what place they each finished in, you’d get runner #1, runner #2, #3, #4, and #5. In set theory, however, it’s convention to start at 0, so the winner of the race would be deemed runner #0, second place would be #1, third #2, fourth #3, and finally fifth at #4. The ordinal number used to represent this set is simply the next place number you’d need. In this case, that’s #5, so this set’s corresponding ordinal number—its order type—is five.
Why is this distinction important? What does it have to do with the fast-growing hierarchy? Bear with me for one more concept and then in Chapter II I’ll explain the connection.
Imagine you have a room with an infinite number of boxes inside. If you add a box to the room, how many boxes are there now in total? Infinity plus one? Well, that just equals infinity. With the new box, the room would be indistinguishable from its previous state without it. There would still be an infinite number of boxes. If you owned a hotel with an infinite number of rooms, each room occupied by one guest, and a new guest came to the lobby wanting to check in, you could simply move guest #1, who was originally in room #1, to room #2, guest #2 from room #2 to room #3, and so on, leaving an empty space in room #1 for the new guest #1. The hotel looks exactly the same—there are still an infinite number of rooms with one guest each; no changes have occurred despite adding a guest. Infinite cardinal numbers work this way, and I won’t get too into it here because this is deviating from our focus, but adding to an infinite amount, or multiplying it, or raising it to a power… regardless, its size does not change.
What we’re more interested in are infinite ordinal numbers. Ordinals count order, and despite seeming similar to cardinals, this is a crucial difference. Imagine lining up each of the infinite number of boxes in this hypothetical room. Now imagine that each successive box is half the size of the last. They would create a line with an infinite number of boxes that still had an end; the boxes would converge to infinity at a singularity, like this:
That’s an infinite number of things in a finite amount of space—reminiscent of Zeno’s famous Dichotomy paradox. But what would happen if we added one new box on the end, after the infinite line runs out?
If we were to count up all the boxes in this space, we’d still have an infinite number, as we figured out earlier. We could just move the box on the right into the infinite line and it would look exactly the same as it did before. The problem arises when we try to name it. With the initial infinite line, we could call the first box 0, the second 1, the third 2, and so on, naming each box after a natural number, to infinity. But what do we call the box on the right? If we move it into the pile, sure, it’ll get a numbered name, but it’s not. It’s beyond the pile. It comes after an infinite number of boxes. We’ve already used up every number naming the boxes within that line! What on earth do we call it, box A? Do we start using letters now?
Believe it or not, that line of thinking is almost exactly correct. The only difference is that a more efficient naming system for this process has already been devised. The first box after the infinite line of boxes is the ωth box. ω (omega) is the first, smallest transfinite ordinal number, so it’s the first label after all the natural numbers. There’s no other way to label an item that comes after an infinite number of things! To quote Michael Stevens of Vsauce from his video titled “How To Count Past Infinity”:
If you got ωth place in a race, that would mean that an infinite number of people finished the race, and then you did.
The most difficult part of this concept is probably understanding how anything can “come after” an infinite number of things. Set theory allows for a slew of phenomena you wouldn’t typically encounter in elementary math, among these being infinite sets. The converging lines are a way to make it a bit easier, as it’s more intuitive to think about placing an object after a line of infinite things that ends somewhere visually. That way you can imagine the infinity compressed into a specific spot, bounded by a finite space, then move on from that spot, acknowledging its endlessness but being able to picture more beyond it. If you’re ready to do that, the next parts of FGH will be easy to follow.
After ω comes ω+1. After ω+1 is ω+2. It’s just like the normal natural numbers, just less familiar. If it helps, imagine ω as the “new” or “alien” 0. We started at 0 and counted to infinity, transcending our world and entering the “omega world”, where we once again started at 0, but this time it’s just called ω. ω+1 is the equivalent of 1, and ω+2 is 2. The “omega plus” at the beginning is just a note saying “Hey, you counted to infinity before you got here! Remember that.”
We can then continue through ω+4, ω+5, ω+6… through all the natural numbers again… and yes, we can in fact count to infinity again, ending up at ω+ω!
We can also call this ω•2, or just ω2. (Not 2ω, because multiplication with transfinite ordinals isn’t commutative!) After ω2 comes ω2+1! Eventually you’ll get to ω3, ω4, ω5… all the way up to ω•ω, or ω². Arithmetic with omega goes on for a while, and we’ll get to know it even better soon. Now, finally, we’re ready to continue building the ladder of FGH.
Chapter II: An Extendable Ladder
With a new, much longer list of numbers, we can give ourselves a lot of room to develop FGH! We’re going to use transfinite ordinals to extend the f sequence. Here is the first of these functions!
But wait, ω comes after every finite number. If we’re using the ωth f function, wouldn’t it generate an infinite number? What we’re trying to do is find really large numbers, not infinite ones.
That line of reasoning makes sense, but this is not the case! In the fast-growing hierarchy, ω is used as a sort of placeholder. Here’s how it’s defined.
(You can also write this as f_ω, with the underscore representing subscript text, just like ^ represents superscript.)
All this function does is give n both responsibilities—plugging n in means that n is both the function number and the number being plugged into said function. So,
and so on. ω is just a placeholder for the function number, forcing the input to replace it. This function is a form of diagonalization. To make this easier to understand, let’s apply it to something more familiar: multiplication tables.
You can see the numbers growing more quickly the farther to the right or down you look. Multiplying by 11 or 12 gets large numbers more quickly than multiplying by 2 or 3. But what’s a way to generate even larger numbers? Squaring! Drawing a diagonal line through this multiplication table gets you the square numbers, which grow more quickly than any possible vertical or horizontal line. What you’re doing here is turning a function with two unique inputs into one with just one. Traveling horizontally in row 3, you get 3×1, then 3×2, then 3×3, and so on. Traveling vertically in column 3, you get the same, just in reverse: 1×3, 2×3, 3×3… But traveling diagonally from the top left, you get 1×1, 2×2, 3×3… and so on. Both numbers being multiplied are the same, and the sequence grows more quickly.
+----+---+---------+--------------------+----------------------+
| | 1 | 2 | 3 | 4 |
+----+---+---------+--------------------+----------------------+
| f₁ | 2 | 4 | 6 | 8 |
+----+---+---------+--------------------+----------------------+
| f₂ | 2 | 8 | 24 | 64 |
+----+---+---------+--------------------+----------------------+
| f₃ | 2 | 2048 | 10^121210694 | 10^10^10^21 |
+----+---+---------+--------------------+----------------------+
| f₄ | 2 | 2↑↑2048 | 2↑↑2↑↑10^121210694 | 2↑↑2↑↑2↑↑10^10^10^21 |
+----+---+---------+--------------------+----------------------+It’s the same with our chart of FGH values. I’ve been showcasing each function by moving horizontally—explaining f₁(1), f₁(2), f₁(3), and f₁(4) first, then moving on to f₂’s values, then f₃’s, and continuing that way. Drawing a vertical line makes for much faster growth, but the diagonal line is still the most efficient route!
+----+---+---+--------------+----------------------+
| | 1 | 2 | 3 | 4 |
+----+---+---+--------------+----------------------+
| fω | 2 | 8 | 10^121210694 | 2↑↑2↑↑2↑↑10^10^10^21 |
+----+---+---+--------------+----------------------+That’s not all the power that f_ω holds, however. In fact, its most staggering ability by far I have yet to cover. It shows up in the next function. What did we do every time we went to the next function before?
We can extend this principle to transfinite ordinals by changing m to an alpha (α).
This means we can now treat ω like any old finite number and add one to it, creating the next FGH function.
This function… is so goddamn powerful. At first glance it seems like it might seem like the leap between function 4 and 5, or 5 and 6, but it dwarfs those. Why? Well, each repetition of f_ω means plugging the input into the subscript. Let’s check out how quickly this grows.
We already know plugging in 1 always outputs 2, this doesn’t change with omega.
Can you already see why this function is going to be mind-blowing? We’re going to have to calculate large numbers and then plug them in as the FUNCTION number! But I won’t get ahead of myself. The innermost omega function means plugging in 2 and creating f₂(2).
Then we calculate f₂(2).
Do you see? Now we have to use function 8!!
And that’s just ω+1 with an input of 2! 3 is gonna be a nightmare. But when has that ever stopped us?
Oh my God, we have to use the 10¹²¹²¹⁰⁶⁹⁴th function. That’s okay, remember that we have this formula to help us out:
Remember that the superscript on an arrow is the number of arrows—so we’ve got 10¹²¹²¹⁰⁶⁹⁴ arrows there. We’re not done, though, we still have one more omega layer.
It’s starting to look a bit too crazy again. This is the 2↑¹²¹²¹⁰⁶⁹⁴(10¹²¹²¹⁰⁶⁹⁴)th f function with an input of 2↑¹²¹²¹⁰⁶⁹⁴(10¹²¹²¹⁰⁶⁹⁴). Using f function to arrow count rule again, we can write this number’s approximate value.
This is 2 with 2↑¹²¹²¹⁰⁶⁹⁴(10¹²¹²¹⁰⁶⁹⁴) arrows followed by 2↑¹²¹²¹⁰⁶⁹⁴(10¹²¹²¹⁰⁶⁹⁴). Let’s do one more value of ω+1 and then I’ll explain the pattern that’s occurring here.
We can approximate 2↑↑2↑↑2↑↑10^10^10^21 as 2↑↑↑4, making this expression more tolerable.
Use the arrow rule.
Again, with this many arrows, the difference between 2↑↑↑4 and 2 becomes negligible. It’s just like rounding a decimal.
And finally:
Four layers of arrow counting! This is 2 with 2 with 2 with 2↑↑↑4 arrows arrows arrows! Or, visually:
Does this look familiar?
As it turns out, ω+1 follows the same pattern that the Graham’s number g numbers do! Each new g number has a number of arrows equal to the previous one, adding a layer of arrow counting. ω+1’s values are doing the same thing. This means we can express Graham’s number with ω+1! As an approximated recap,
Each new value adds a layer. Graham’s number undergoes 64 iterations of “now take that number of arrows, now take that number of arrows, now…!” and ω+1 adds an iteration per increment in value. f_ω+1(3) has three layers, f_ω+1(4) has four… so f_ω+1(64) has 64. Since Graham’s number is g₆₄:
So none of the finite-numbered functions could get there, but adding 1 to ω made it a piece of cake. Sure, the Graham’s numberth f function can give you a number larger than Graham’s number, but so can f₀! Plug Graham’s number into f₀ and you’ve got Graham’s number plus one. That’s not the point—our goal is to create large numbers with small ones, and no function before function ω+1 grows more quickly than Graham’s g function.
What’s next? Yes, it’s likely what you’re thinking!
Trying to evaluate numbers from this function is extremely difficult using up-arrow notation. Here’s why.
Each successive value of ω+1 adds a layer of arrow counting, meaning we now have 2↑↑↑↑↑↑↑↑2 layers of arrows to deal with.
See what’s going on here? It’s the same pattern of extending vertically and horizontally over and over that the hyperoperators did with power towers. This time, however, they aren’t powers, they’re arrows!
As I mentioned before, many people have created notations that go far beyond up-arrow notation. These people are known as googologists, named after the study of discovering and naming large numbers, googology.
(One of the best online resources in this field is the aptly named Googology Wiki, offering more than 10,000 articles about large numbers, notations, people, and more. I highly recommend checking it out if you’re interested in big numbers!)
Some of the most well-known googological notations are Jonathan Bowers’ BEAF, Sbiis Saibian’s Hyper-E Notation, Leo Moser’s polygon-based Steinhaus–Moser notation, Chris Bird’s BAN, Lawrence Hollom’s hyperfactorial array notation, Hyp cos’ strong array notation, and Bashicu’s elusive Bashicu matrix system.
I may write another article in the future detailing some of these systems, but for now I’m going to stay focused on the fast-growing hierarchy.
[WORK IN PROGRESS! STAY TUNED]
Chapter III: Congratulations, Class of 2020
With knowledge of ε₀, you’ve earned your honorary bachelor’s degree in transfinite ordinals. Keep in mind that we’ve already gone so much further than most. The majority of people don’t even know what a googolplex is, and here we are at a point so high on the ladder that numbers created up here exhaust notation systems built by individuals for the sole purpose of creating large numbers.
