Direct Continuation of: Large Numbers, Part 4: Epsilon and Phi

Welcome back to our epic saga on making numbers that are so large they defy words. Ok, so maybe it’s only epic for nerds of the highest caliber, but all you people who cling to some sense of a socially constructed normality can skip this one and come back Friday.

Anyways, we started this mission by explaining magnitude, and making it known that you should just give up comparing magnitudes of numbers because it just won’t be comprehensible. We then explained Knuth up-arrow notation, our first attempt to make something big.

Later, we jumped past the largest number actually used in mathematics, Graham’s Number, and dumped Knuth’s notation for Conway’s chained-arrows, which make even bigger things. We then extended this notation multiple times to produce something quite daunting.

Then we took a plot twist: part 3 ditched ad-hoc systems like Conway’s and introduced ordinals, functions that grow through use of “diagonalization”. We went from the simplest ordinal ω to the more complex ω^3.

Then we proved why ordinals are the best for making large numbers — a general definition of ordinals let them go forever, and we smashed the heck out of our multiple extensions of Conway by ω^5. And we kept going, to ω^ω, to ε(0), to ζ(0), …all the way to Γ(0), using the Veblen Function.

Some things to remember: an ordinal is actually an infinite set of all ordinals smaller than it. And we define a system to make numbers through ordinals this way:

• f(a) = a+1
• f_a(x) = f_a-1^x(x)
• f_O(x) = f_D(O)(x)
• f_O+a(x) = f_O+a-1^x(x)

…where a is any finite number, O is any infinite ordinal, and D(O) represents taking O and replacing it with the “x”th member of the set defined by O.

The Extended Veblen Function

So where do we go now? We left off with the Veblen Function getting to φ(1, 0, 0). But this is even further extendable, we can get to φ(1, 0, 0, 0) and φ(1, 0, 0, 0, 0).

φ(1, 0, 0, 0) is the ordinal that defines the series “φ(1, 0, 0), φ(φ(1, 0, 0), 0, 0), φ(φ(φ(1, 0, 0), 0, 0), 0, 0), …”.

φ(1, 0, 0, 0, 0) is the ordinal that defines the series “φ(1, 0, 0, 0), φ(φ(1, 0, 0, 0), 0, 0, 0), φ(φ(φ(1, 0, 0, 0), 0, 0, 0), 0, 0, 0), …”.

The Small Veblen Ordinal

As you can probably guess, this can continue out forever. Luckily when it comes to ordinals, forever is capable of being notated. We can take the φ() function and use an “@” sign to designate how many 0′s follow a number. So φ(1, 0, 0, 0, 0) would be also written as φ(1@4), and φ(1, 2, 3, 0, 0, 6) would also be written as φ(1, 2, 3@2, 6).

This means we can define φ(1@ω), which defines the series “φ(1, 0), φ(1, 0, 0), φ(1, 0, 0, 0), φ(1, 0, 0, 0, 0), …” or “φ(1@1), φ(1@2), φ(1@3), φ(1@4), …”. φ(1@ω) is the Small Veblen Ordinal.

Remember that this is no small upgrade from Γ(0) or φ(1, 0, 0). A jump from φ(1@2) to φ(1@3) is large, but not nearly as large as a jump between φ(1@4) and φ(1@5), etc. At this magnitude, it’s perhaps impossible to keep the differences in size in mind, but it’s something to note, especially when comparing to non-ordinal systems of making large numbers. …Though I would never expect any such system to ever make it to f_φ(1@5)(5).

The Large Veblen Ordinal

So if we can define φ(1@ω), we can also go for φ(2@ω) and φ(3@ω). We can also go for φ(φ(1@ω)@ω) and φ(φ(φ(1@ω)@ω)@ω). Eventually we get to φ(1@ω+1), which defines the series “φ(1@ω), φ(φ(1@ω)@ω), φ(φ(φ(1@ω)@ω)@ω), …”.

This allows us to easily continue the Veblen Function with other ordinals. We can define φ(1@ω2), φ(1@ω^ω), φ(1@φ(1,0)), and φ(1@φ(1,0,0)). This all finishes at the series “φ(1@0), φ(1@φ(1@0)), φ(1@φ(1@φ(1@0))), φ(1@φ(1@φ(1@φ(1@0)))), …”, which is the Large Veblen Ordinal.

After that, we can go no further with the Veblen Functions, because φ(1@LVO) is still the LVO.

Collapsing Functions

Luckily, we have something far more powerful to make use of. So far, we’ve been using a specific principle: make use of larger and large infinite ordinals to define larger and large finite numbers. But couldn’t we make use of infinite ordinals to define larger ordinals? The answer is yes, but it’s a little tricky. We’re going to make what is called an ordinal collapsing function.

The general idea is that we’re going to start with a set of numbers and then expand that set through multiple steps, using some simple rules, and then use ordinals to expand upon the pattern.

Here’s what our first ordinal collapsing function looks like:

C(L, 0) = {0, 1}
C(L, S+1) = C(L, S) ∪ C(β, δ) ∪ C(β, ω) ∪ {λ+μ, λ*μ, λ^μ} : β < L, δ <= ω, λ, μ ∈ C(L, S)
C(L, ω) = min(ξ) such that ξ ∉ C(L, χ) : ξ < ω

Now for the big question: what the hell do all those symbols mean? And what kind of numbers do they make?

C(L, 0) = {0, 1}

First, this indicates we are looking at a function called C(L, S), which requires two variables: a value for L and a value for S. Here, I’m using L to stand for Level and S to stand for Step, but that’s not important.

Whenever you look for C(L, 0) — calling C() where L is any number and S is 0 — you will get the set {0, 1}.

So what is C(5, 0)? The set {0, 1}.
What is C(1393080, 0)? The set {0, 1}.
What is C(G, 0), where G is Graham’s Number? The set {0, 1}.
What is C(whatever, 0) with any friggin number? The set {0, 1}.

Easy enough.

C(L, S+1) = …

This is the bulk of what is going on — it’s how we expand the set to have larger stuff. It also involves a lot of symbolic math, but it’s not really that hard.

Basically, to find C(L, S+1), you must first start with the set C(L, S). Then you look at that set, and for every number in it, do the following: (1) add a set of (λ+μ, λ*μ, λ^μ} — three values, whatever they may be. (2) add the complete set C(β, δ). (3) add the ordinal C(β, ω).

All of the little symbols will take on each and every value, individually, that is in the previous set C(L, S), except where restrictions apply. For instance, β must be smaller than L, and δ must be ω or less.

To make this a lot less complicated, here’s an example:

What is C(0, 1)? First we must start with C(0, 0), which is {0, 1}. Then for each value in C(0, 1), we add stuff.

We add {λ+μ, λ*μ, λ^μ} for all combinations. This means we will be adding the sets {0+0, 0*0, 0^0}, {1+0, 1*0, 1^0}, {0+1, 0*1, 0^1}, and {1+1, 1*1, 1^1}.

We then try to find a set C(β, δ) to add, but since β must be smaller than L, which is 0, there are no valid sets we can add. Same with C(β, ω) — nothing valid to add.

This means C(0, 1) will be the set {0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 2, 1, 1}. We can shorten this to {0, 1, 2} for our purposes.

C(L, ω) = min(…

Now what’s going on here? It means we’re defining that we’re looking for the smallest (minimum) value ξ that isn’t in any possible C(L, S) for any finite S (S less than ω).

Now at first this seems impossible, because it looks like it involves infinite calculations. However, this is not the case, because we can take limits of things much like we’ve done in the past. I’ll show you how this works right now.

Calculating C(0, ω)

So earlier we found out what was in C(0, 1). Now let’s see what is in C(0, 2).

C(0, 2) tells us to start with C(0, 1), which is {0, 1, 2}. Then it tells us to add C(β, δ) and C(β, ω), but we can’t because β has no possible values when L is 0. Then it tells us to add {λ+μ, λ*μ, λ^μ} for 0, 1, and 2.

This results in adding the following sets: {0+0, 0*0, 0^0}, {1+0, 1*0, 1^0}, {2+0, 2*0, 2^0}, {0+1, 0*1, 0^1}, {1+1, 1*1, 1^1}, {2+1, 2*1, 2^1}, {0+2, 0*2, 0^2}, {1+2, 1*2, 1^2}, and finally {2+2, 2*2, 2^2}.

For unique values, we’re going to be adding 3 and 4, creating the set {0, 1, 2, 3, 4}.

We can extend this to see that C(0, 3) will be {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 16, 27, 64, 256}. C(0, 4) will include 256^256 as it’s largest number.

So far, this isn’t producing anything big, but bear with me. All that we really need to know now is how to calculate C(0, ω). What’s the smallest value that will never be produced by any level of C(0, S)? Well, it’s clear that, done enough times, C(0, S) is capable of creating any finite number. So the smallest value must be the smallest infinite number: ω itself.

C(0, ω) is ω.

Calculating C(1, 1) and C(1, 2)

So what is C(1, 1)? Well we have to go back to “C(L, S+1) = C(L, S) ∪ C(β, δ) ∪ C(β, ω) ∪ {λ+μ, λ*μ, λ^μ} : β

C(1, 1) tells us to start with C(1, 0), which is {0, 1} as we know. But then we can add C(β, δ) because we now have a β that is smaller than L and in the set: 0. So we add C(0, δ) for every δ in the set less than ω: 0 and 1.

We also get to add C(β, ω) for all valid β, which will be just the C(0, ω) we just calculated: ω.

Then we do {λ+μ, λ*μ, λ^μ} for 0 and 1.

So in summary, we're starting with {0, 1}, then adding C(0, 0) and C(0, 1), then adding C(0, ω), then adding the sets {0+0, 0*0, 0^0}, {1+0, 1*0, 1^0}, {0+1, 0*1, 0^1}, and {1+1, 1*1, 1^1}.

C(1, 1) is thus the set {0, 1, 0, 1, 0, 1, 2, ω, 0, 0, 1, 1, 0, 1, 1, 0, 0, 2, 1, 1}. Reordering and simplifying that set, we get {0, 1, 2, ω}.

Now for C(1, 2). This time we start with C(1, 1), and add C(0, 0), C(0, 1), and C(0, 2). We then get to add {λ+μ, λ*μ, λ^μ} for 0, 1, 2, and this time ω. This means we add {0+0, 0*0, 0^0}, {1+0, 1*0, 1^0}, {2+0, 2*0, 2^0}, {ω+0, ω*0, ω^0}, {0+1, 0*1, 0^1}, {1+1, 1*1, 1^1}, {2+1, 2*1, 2^1}, {ω+1, ω*1, ω^1}, {0+2, 0*2, 0^2}, {1+2, 1*2, 1^2}, {2+2, 2*2, 2^2}, {ω+2, ω*2, ω^2}, {0+ω, 0*ω, 0^ω}, {1+ω, 1*ω, 1^ω}, {2+ω, 2*ω, 2^ω}, {ω+ω, ω*ω, ω^ω}.

This is also where you need to know how to do math with ω. Remember that ω*2 is ω2, but 2*ω is just ω. Also, 2^ω is ω, but ω^2 is ω^2. (This is because there is a difference between 2*2*2*2*…*2 an infinite amount of times and ω*ω, twice.)

When all work is done, C(1, 2) is {0, 1, 2, 3, 4, ω, ω+1, ω+2, 2ω, ω^2, ω^ω}.

The Growth of This Collapsing Function

So we are seeing two different principles of growth with this collapsing function.

The first is that we get to add C(β, δ). This means something like C(1, 3) is going to be able to introduce C(0, J) where J is the largest number in C(0, 3) — C(0, 256). Something like C(4, 4) will be able to introduce C(3, J) with a rather large J, which will in turn contain even larger numbers.

The second is that we get to add C(β, ω). As we found out, C(0, ω) is ω. C(1, ω) however is the smallest number that can’t be produced by an infinite power tower of ω (ω^ω^ω^…^ω), which is ε(0). C(2, ω) will be the smallest number that can’t be produced by an infinite power tower of ε(0), which is ε(1). What is C(ω, ω)? The smallest number not in C(L, S) for any finite L or S, which will be the limit of all this: ε(ω).

We can also get large finite numbers — our ultimate goal of this section — directly from the collapsing function by asking what is the largest finite number in each set. We saw that the largest finite number in C(0, 3) is 256 and the largest finite number in C(0, 4) is 256^256. We’ll be able to expand on this more in future installments of this essay series.

So now we can see where this is headed: Eventually, we’ll be able to get ε(L) with C(L, ω). We can get ε(ε(0)) with C(ε(0), ω).

Overall, this is not very large — we have gotten nowhere near the Small Veblen Ordinal or the Large Veblen Ordinal, let alone getting to Γ(0) or even ζ(0).

In fact, it looks like our collapsing function is in a worse position than our Extended Veblen Function is. But do not fear, because with a few modifications to the collapsing function, we will be able to pass the LVO and keep on going.

Be Sociable, Share!

•