Pointless Gigantic List of Numbers - Part 6 (order type Γ0 to ψ(Ω_w))

So I define the blasphemorgulus with my notation as E100#{{1}}#100, borrowing Bowers’ extended operator notation. Get ready for some new giants ...

Gonguldeus

{X,100,1,2} & 10

This is a number I coined comparable to a blasphemorgulus. It is an expansional-array level number, and it's of order of the Ackermann ordinal.

Grand blasphemorgulus

E100#{{1}}#100#2

Grand grand blasphemorgulus

E100#{{1}}#100#3

Grangol-carta-blsphemorgulus

E100#{{1}}#100#100

Blasphemorgulus-by-deuteron

E100#{{1}}#100#{{1}}#100

Blasphemorgulus-by-hyperion

E100#{{1}}#*#100

Deutero-blasphemorgulus

E100#{{1}}#*#{{1}}#100

Blasphemorgulfact

E100(#{{1}}#)^#100

Terrible blasphemorgulus

E100(#{{1}}#)^^#100

Horrible blasphemorgulus

E100(#{{1}}#)^^^#100

Horrendous blasphemorgulus

E100(#{{1}}#)^^^^#100

Godsgoblasphemorgulus

E100(#{{1}}#){#}#100

Ohmygosh-ohmygosh-ohmygoblasphemorgulus

E100(#{{1}}#){#{#}#}#100

E100(#{{1}}#){#{{1}}#}#100

Or E100(#{{1}}#){X}#100 where X is the blasphemorgulus array. But no, this is not equal to E100#{{1}}#>#2 - that’s a higher construction which will be seen in a bit. Moving on...

Blasphemormygosh-blasphemormygosh

E100(#{{1}}#){#{{1}}#}(#{{1}}#)100

Blasphemormygosh-blasphemormygosh-blasphemormygosh

E100(#{{1}}#){(#{{1}}#){#{{1}}#}(#{{1}}#)}(#{{1}}#)100

Whoa now. This is starting to get messy. If this is hard to read, it’s equal to E100A{A{A}A}A100 where A is (#{{1}}#).

But this is itself the start of a new sequence - let (a){{1}}#x mean a{a{a...{a{a}a}...a}a}a with x a’s from the center out. So this is also equal to E100(#{{1}}#){{1}}#3. As you can see we’re starting to get into iterating the blasphemorgulus, but in a slightly different way that we’re used to.

Blasphedeumorgulus / tweilasphemorgue

E100(#{{1}}#){{1}}#100

Blasphetrimorgulus / freilasphemorgue

E100((#{{1}}#){{1}}#){{1}}#100

The series continues with fioril-, finn-, sex-, sjornal-, attal-, neiul-, and tenasphemorgue, then we can skip to:

Hunderlasphemorgue / blasphemorguliterator

E100#{{1}}#>#100

Saibian defines this as equal to E100{#,#+1,1,2}100 (which matches with his idea of the climbing method), but all the next Extended Cascading-E numbers are my own definitions.

Enormaxul

200![200(2)200]

The next major HAN number - comparable to blsphemorguliterator. As you can see HAN is amazingly powerful, and it has a lot more awesomeness coming our way.

Blasphemorgulditerator

E100#{{1}}#>(#+#)100

Dustaculated-blasphemorgulus

E100#{{1}}#>#{{1}}#100

Hectastaculated-blasphemorgulus

E100#{{1}}#>#{{1}}#> ... ... ... >#{{1}}#100, 100 #{{1}}#s

Now this is as far as I’ve developed my extension to Extended Cascading-E - it's most likely equal to E100#{{1}}##100, though I can't say with certainty. It is needless to say that Sbiis Saibian will eventually decide on something of his own when he gets his whole hyperion array space theory done. We could continue with:

Grand hectastaculated-blasphemorgulus

E100#{{1}}#>#{{1}}#> ... ... ... ... ... ... >#{{1}}#100, hectastaculated-blasphemorgulus #{{1}}#s

... and then resort to only other notations, like BEAF, hyperfactorial array notation, and the fast-growing hierarchy.

Gongultreus

{X,100,1,3} & 10

This is another number I coined with the array-of operator. It's much larger than any of my extensions to the blasphemorgulus.

Enormabixul

200![200(2)200(2)200]

Comparable to an {X,X^2,1,3} array.

Gongulquadeus

{X,100,1,4} & 10

Enormatrixul

200![200(2)200(2)200(2)200]

Comparable to to an {X,X^2,1,4} array.

Enormaquaxul

200![200(2)200(2)200(2)200(2)200]

Comparable o an {X,X^2,1,5} array.

200![200(3)200]

Another unnamed HAN number - arrays with (3)s are comparable to 5-entry array arrays. This is comparable to an {X,X^2,1,1,2} array of 200s.

Generatrix

{10,10,10,10} & 10

How incredible is this array of 10’s (which I coined)? Insane beyond belief, and its name was extrapolated from the analogy,tridecal:tridecaltrix::general:?

Incredulus

{10,10,10,100} & 10

Another number I coined, which is a whopping troogol array of 10’s!!! This number is about the breaking point of tetrentrical arrays.

Incridulus

{10,10,10,100,2} & 10

Incradulus

{10,10,10,100,3} & 10

Increedulus

{10,10,10,100,4} & 10

Pentadecatrix

{10,10,10,10,10} & 10

Tercredulus

{10,10,10,10,100} & 10

A quadroogol array of tens.

Tercridulus

{10,10,10,10,100,2} & 10

Tercradulus

{10,10,10,10,100,3} & 10

Tercreedulus

{10,10,10,10,100,4} & 10

Pencredulus

{10,10,10,10,10,100} & 10

Excredulus

{10,10,10,10,10,10,100} & 10

Epcredulus

{10,10,10,10,10,10,10,100} & 10

Ogcredulus

{10,10,10,10,10,10,10,10,100} & 10

Iteratrix

{10,10(1)2} & 10 = 10&10&10

This number is an iteral array of tens which can be expressed as 10&10&10 or alternately as {10,3/2} (see also the entry for a triakulus in part 5) since {a,b/2} = a&a&a......&a with b a's.

Goobawamba

{10,100(1)2} & 10

This number is a goobol array of tens, a number of order type ψ(Ω^{Ω^w}) (also known as the small Veblen ordinal, or SVO for short). It's about as far as I myself currently have figured out how to easily define BEAF with the array of operator. I'm not exactly sure how to go further, because (for example) setting {X,2X(1)2} = {{X,X(1)2},X(1)2} just doesn't work.

Why is that? The whole reason I chose, for example, X^^2X = (X^^X)^^X is because n^^2n (where n is a number) APPROXIMATES (n^^n)^^n - the same holds true, for example, when comparing n{{1}}2n vs (n{{1}}n){{1}}n. However, {{n,n(1)2},n(1)2} is NOT EVEN CLOSE to {n,2n(1)2} - this shows that defining the structures is now much harder at this point.

Fortunately, Hyp cos of Googology Wiki has an "analysis" of BEAF in terms of the FGH, which gives informal proposals on how big BEAF numbers "should" be in terms of the FGH. What he does is not only a full coverage of BEAF, but it's also helpful for determining how to work with BEAF past {X,X(1)2} & a. The methods for getting to things like {X,X,2(1)2} & a are kind of confusing, but they're reasonably unproblematic.

I'm currently trying to figure out how to work with BEAF past the SVO. But for now, from here on out, in BEAF numbers I will rely on Hyp cos's "analysis" for determing how big they are. I put "analysis" in quotation marks because the analysis isn't very formal (BEAF past dimensional arrays in itself isn't formal), and it's better to describe it as an informal proposal on how big BEAF numbers "should" be and how BEAF "should" be worked with past tetration arrays.

f_ψ(Ω^Ω^w)(100)

This is a number used to discuss order type ψ(Ω^{Ω^w}) in the fast-growing hierarchy. It's about {X,102(1)2}&100 in BEAF, with the array of operator. ψ(Ω^{Ω^w}) is often called the small Veblen ordinal, usually abbreviated to SVO. That ordinal can be thought of as φ(.......,0,0,0,0,0) since it represents the limit of the multi-argument phi function, and after this point you need to use ordinal collapsing functions, either the theta function or the psi function. I opt for the psi function because it's both simpler and more wide-ranged. But I should point out that there are several ways one can define the psi function, so in this list I will use the most common variant, the Bachmann psi function which is limited at the mysterious Takeuti-Feferman-Buchholz ordinal.

The small Veblen ordinal is another classic benchmark point in the FGH - for example it represents what is believed to be the growth rate of Bowers' linear array-arrays, and according to Sbiis Saibian (through communication) it will be the growth rate of hyperion linear-arrays when they're released. This ordinal is also the growth rate of Hollom's hyperfactorial dimensional arrays. Like epsilon-zero, the SVO is another point where googological functions become harder to work with and define. For discussion of this kind of thing in BEAF, see the previous entry.

Destruxul

200![200(200)200]

This is another number of order type of the small Veblen ordinal in the FGH. It is a number coined by Lawrence Hollom, and lies at the limit of linear array-arrays. It opens up a whole new realm of crazy hyperfactorial arrays, starting with making the number in parentheses itself an array.

The-Veblen-Bachmann-Ordinal Range

{X,X(1)2} & a ~ X^^X & X & a

(order type ψ(Ω^{Ω^w}) ~ ψ(ε_Ω+1)

Entries: 51

~ f_{ψ(Ω^(Ω^w*w))}(3)

This is a lower-bound for the famous number TREE(3), arguably the most famous number larger than Graham's number. It is notable because it is a number used in serious mathematics that is (far) larger than the "record-holder" Graham's number. It was discovered by mathematician Harvey Friedman from a problem in graph theory. Friedman has worked with mathematical sequences in graph theory and other fields that lead to some really big numbers. I have met Harvey Friedman in person before - at the time I was in fourth grade and I was invited to a sort of mathematics gathering at a nearby university. I have a picture with me, him, and the university's president in my bedroom to this day, with Friedman's signature.

The most famous sequence Friedman has studied is the TREE sequence, which arises out of a problem in graph theory. The problem asks how long a sequence of k-labeled trees can be such that no tree is homeomorphically embeddable into a previous tree. Kruskai's tree theorem tells us that such a sequence must be finite, but how long can such sequences get? TREE(k) is the maximum length of such a sequence of k-labeled trees. TREE(1) is equal to 1, TREE(2) is equal to 3, but TREE(3) explodes to a number that is INSANELY huge, undescribably larger than Graham's number.

Unlike Graham's number TREE(3) is not an upper-bound to the solution of a problem - it IS the solution to a problem. Therefore, really TREE(3) is a better example of a number used in serious mathematics than Graham's number, as it's not merely the smallest number that mathematicians could prove to be greater than the solution to a problem, but it is itself the unfathomably enormous solution to a problem.

Even by googological standards TREE(3) is quite sizable. It's not huge in the way a googolplex or Graham's number or even a GONGULUS is - none of those three numbers come even close to TREE(3)!!! It utterly leaves Graham's number way behind in a land of weeny tiny baby numbers because it's just so huge. While Graham's number is very easy to describe in terms of googological functions, TREE(3) is quite difficult to describe in googological functions. Functions that can approximate or bound TREE(3) are at such a high level that they are rather esoteric, because TREE(3) is just that big. While Graham's number is very easy to surpass with large number notations, TREE(3) is very difficult to surpass - therefore TREE(3) can be actually seen as a very large number in a whole new way, because it isn't easy to make a number this big.

At this point the most common way to approximate numbers is BY FAR the fast-growing hierarchy. The fast-growing hierarchy, as we saw earlier in the list, has a fairly simple definition but is very powerful. However, at this point even the fast-growing hierarchy is pretty difficult to understand, and requires a good amount of knowledge in googology, and a good amount of imagination.

TREE(n) has a growth rate comparable to at least f_{ψ(Ω^(Ω^w*w))}(n), making it pass the small Veblen ordinal in the fast-growing hierarchy. An upper bound for the growth rate is not known, but TREE(n) is believed to be in the ballpark of f_{ψ(Ω^(Ω^w*w))}(n), and in terms of Bowers' named numbers it's believed to be within the vast gap between a humongulus and a golapulus.

Incredibly, TREE(3) is still not the largest number that has been used in professional mathematics. There are even more powerful sequences that have been studied by Friedman and other mathematicians - one such sequence is Friedman's SCG sequence leading to a number even bigger than TREE(3) known as SCG(13) (seen later on the list).

Lower bound for SSCG(3)

~ f_{ϑ(Ω^ω^2,φ(ω^2*4,0,0))}(3)

This is a lower bound for SSCG(3) wth the SSCG function, a sibling of Harvey Friedman's SCG function. Hyp cos of Googology Wiki proved this bound, which is far larger than SSCG(0) = 1, SSCG(1) = 5, and SSCG(2) ~> 10^10^28.

Destrubixul

200![200([200(200)200])200]

A googolism by Lawrence Hollom. Comparable to f_α(200), where α is ψ(Ω^{Ω^ψ(Ω^Ω^w)}). If interpreted one way this means that this number is equal to about {X,X(1)2}&200&200, but if interpreted the other way (which i prefer) it's about {X,{X,X(1)2}(1)2}&200 - for more on that, and why I prefer the second way, see the entries for a gibbawamba and f_ψ(Ω^Ω^Ω)(100).

Destrutrixul

200![200([200([200(200)200])200])200]

Comparable to f_α(200), where α is ψ(Ω^{Ω^ψ(Ω^Ω^ψ(Ω^Ω^w))}). If interpreted one way this means that this number is equal to about {X,X(1)2}&200&200&200, but if interpreted the other way (which i prefer) it's about {X,{X,{X,X(1)2}(1)2}(1)2}&200.

Destruquaxul

200![200([200([200([200(200)200])200])200])200]

Continuing the pattern. This number is comparable to f_α(200), where α is ψ(Ω^{Ω^ψ(Ω^Ω^ψ(Ω^Ω^ψ(Ω^Ω^w)))}). If interpreted one way this means that this number is equal to about {X,X(1)2}&200&200&200&200, but if interpreted the other way (which i prefer) it's about {X,{X,{X,{X,X(1)2}(1)2}(1)2}(1)2}&200. Either way, this doesn't quite reach the large Veblen ordinal (ψ(Ω^{Ω^Ω})) (see two entries later).

Gibbawamba

{X,100,2(1)2} & 10

This is a number I coined that continues the pattern of dimensional array-arrays - the value is believed to be at the order type of the large Veblen ordinal in the fast growing hierarchy (see next entry).

f_ψ(Ω^Ω^Ω)(100)

This is yet another fast-growing hierarchy number used to discuss an order type, in this case ψ(Ω^{Ω^Ω}), known as the large Veblen ordinal or LVO for short. ψ(Ω^{Ω^Ω}) is the fixed point of α->ψ(Ω^{Ω^α}) and can be imagined as ψ(Ω^{Ω^ψ(Ω^Ω^ψ(Ω^Ω^....... ......)))}). In googology, this order type is most notable for being part of a debate regarding BEAF: is {n,n/2} of order type ψ(Ω^{Ω^Ω}) or ψ(Ω_w) in the fast-growing hierarchy? in the second case, ψ(Ω^{Ω^Ω}) is only about {X,X,2(1)2} & n.

I prefer the ψ(Ω_w) = {n,n/2} idea for two reasons. The first reason is pretty obvious: it is a more powerful interpretation of BEAF - since people in googology generally want their notations to be as powerful as they can make it, I think the second interpretation is the one Bowers himself (the creator of BEAF) is more likely to choose. But the second reason is a bit more controversial: the ψ(Ω_w) = {n,n/2} idea seems more widely accepted than the ψ(Ω^{Ω^Ω}) = {n,n/2} idea. Though neither is a totally certain interpretation, I choose the second largely because analyses of BEAF such as Hyp cos's seem to use that idea, and there are no analyses as extensive with the other ψ(Ω^{Ω^Ω}) = {n,n/2} idea.

All this goes to show that BEAF's ambiguity is a real problem, and a highly reflected one since ψ(Ω_w) is so much larger than the LVO, yet both are different interpretations of the same structure. And we still haven't reached a golapulus yet....unless we use the other approach (which I'm not using) where a golapulus would be of order type ψ(Ω^{Ω^w^w}) instead of ψ(Ω^{Ω^Ω^w}). Note that in the alternate case a golapulus would be smaller than a destrubixul, while in the case I'm using a golapulus would surpass anything in the destruxul family.

Now let's move on to some more BEAF constructions with their interpretations in terms of the FGH, with my idea.

Gabbawamba

{X,100,3(1)2} & 10

Boobawamba

{X,X,100(1)2} & 10

Troobawamba

{X,X,X,100(1)2} & 10

Goobawantra

{X,100(1)3} & 10

Note that I'm taking some liberty in naming the numbers just to make the names sound good.

Emperatrix

{X,X(1)10} & 10

Gossablossla

{X,X(1)100} & 10

Hyperlatrix

{X,X(1)X,10} & 10

Goobaduamba

{X,100(1)(1)2} & 10

Can be imagined {10,10...[100 10's]...10,10(1)10,10...[100 10's]...10,10} & 10.

Goobatriombia

{X,100(1)(1)(1)2} & 10

Goobaquardimbia

{X,100(1)(1)(1)(1)2} & 10

Goobaquindingia

{X,100(1)(1)(1)(1)(1)2} & 10

Goobasesixtia

{X,100(1)(1)(1)(1)(1)(1)2} & 10

Goobasebiptia

{X,100(1)(1)...[7 (1)s]...(1)(1)2} & 10

Goobagogdiktia

{X,100(1)(1)...[8 (1)s]...(1)(1)2} & 10

Goobanogdiktia

{X,100(1)(1)...[9 (1)s]...(1)(1)2} & 10

Xaplorgulus

{X,X(2)2} & 10

A number I coined equal to a xappol array of tens. It's about f_θ(Ω^w^2)(10) in the fast-growing hierarchy by Hyp cos's analysis. It's not too far from a golapulus anymore, if by not too far you mean we only have 98 more dimensions in the array used to define the array of a golapulus to go.

Goobadektimtia

{X,100(1)(1)...[10 (1)s]...(1)(1)2} & 10

Goxxablorg

{X,100(2)2} & 10

Based on Sbiis Saibian's array notation number called goxxol, which has an entry in part 5.

Gooxadworg

{X,100(2)(2)2} & 10

Goxxathrorg

{X,100(2)(2)(2)2} & 10

Goxxaquorg

{X,100(2)(2)(2)(2)2} & 10

Cosslorgulus

{X,X(3)2} & 10

A coloxxol array of tens.

Tesslorgulus

{X,X(4)2} & 10

Pesslorgulus

{X,X(5)2} & 10

Hesslorgulus

{X,X(6)2} & 10

Zesslorgulus

{X,X(7)2} & 10

Yosslorgulus

{X,X(8)2} & 10

Brosslorgulus

{X,X(9)2} & 10

Using my own extended SI prefixes because I can :D

Gosslorgulus

{X,X(10)2} & 10

Mosslorgulus

{X,X(20)2} & 10

Hasslorgulus

{X,X(30)2} & 10

Kysslorgulus

{X,X(40)2} & 10

Pisslorgulus

{X,X(50)2} & 10

Sasslorgulus

{X,X(60)2} & 10

Pexxlorgulus

{X,X(70)2} & 10

This number had to be renamed pexxlorgulus from my extended prefix pectra- for 1000^70 from pesslorgulus, so that it would not be confused with {X,X(5)2} & 10.

Nisslorgulus

{X,X(80)2} & 10

Zozzlorgulus

{X,X(90)2} & 10

{X,X(100)2} & 10 = 10^100 & 10 & 10

Yes, we FINALLY MADE IT to a golapulus, the next Bowerian googolism after a humongulus. Unlike all the previous array notation numbers I made up, this was actually named by Jonathan Bowers himself.

A golapulus, when comparing it against a humongulus, is SUCH A NEW KIND OF NUMBER. While a humongulus isn't too problematic to define under any BEAF variant, a golapulus reaches past the first brick wall you hit when trying to define BEAF and THEN some!

A humongulus is of order type φ(w,0,0) in the fast-growing hierarchy. But a golapulus, the VERY NEXT Bowerian number after a humongulus is believed to be of order type of ψ(Ω^{Ω^Ω^w}) - that skips several important ordinals like gamma-0, the SVO, and possibly the LVO! There are no Bowerian googolisms of order type of any of these three ordinals, only a humongulus at a much smaller order type and a golapulus at a much higher order type!

Why was Jonathan Bowers able to make this jump? Because of the cleverness of the array of operator. With just the array of operator added to BEAF, we can logically go from epsilon-zero all the way to either the LVO or θ(Ω_w), which represents the order type of numbers like 10&10&10&10&10.....&10 with 100 10's! That's a huge leap alright!

However, the array of operator has a HUGE problem: it's VERY informally defined. In fact, it's so informal that it's hard to decide how exactly to even define numbers with the operator! I myself am currently trying to figure out how to go further than the SVO with BEAF, which still doesn't reach the limit of the array of operator.

In any case, the next Bowerian googolism is a golapulusplex, a golapulus array of tens (and an exception to Bowers' usual interpretation of -plex). Let's just say that a golapulusplex is a whole new level of hard to define than a golapulus is!

Ginglapulus

{X,100(0,2)2} & 10

Now back to the main sequence of numbers I made up till I hit a golapulusplex.

Ganglapulus

{X,100(0,3)2} & 10

Note that the array of operator allows us to blast through numbers a lot quickly than we "should".

Geenglapulus

{X,100(0,4)2} & 10

Bolapulus

{X,100(0,0,1)2} & 10

Trolapulus

{X,100(0,0,0,1)2} & 10

Goplapulus

{X,100((1)1)2} & 10

Goduplapulus

{X,100((0,1)1)2} & 10

Gotriplapulus

{X,100(((1)1)1)2} & 10

f_ψ(ε(Ω+1))(100)

This number is an entry used to discuss yet another order type in the fast-growing hierarchy, this time the Bachmann-Howard Ordinal, or BHO for short - the BHO can be imagined as ψ(ΩΩ^Ω^Ω......). The BHO is significant in many places in mathematics, and in a few places in googology.

For one thing, the BHO represents a milestone point in functions. But also, the BHO yet again exemplifies the issue of BEAF. Remember that there are two main beliefs about BEAF: the idea that {X,X/2} is the LVO, and the idea that it’s ψ(Ωw). That’s a bigger gulf than you might think - in the second idea BEAF reaches well past the BHO and probably transcends the theta function entirely and maybe even the psi function, but in the first BEAF likely doesn’t even make it to the BHO! My current idea of BEAF is built upon the more powerful idea, and therefore I plan on having it hit the BHO - however I haven’t reached that yet, and it isn’t easy to do that with the difficulties of actually trying to define the array of operator.

Also, an early version of Chris Bird’s arrays had the BHO as the growth limit, and the BHO in the slow-growing hierarchy is equivalent to the important epsilon-zero in the fast-growing hierarchy, which I discuss in part 5.

Extremexul

200![1(1)[2200,200,200,200]]

This number is another major jump in Hollom’s hyperfactorials. It goes straight to the higher hyper-nested arrays - I won’t claim to actually know how they work, though they involve higher-order brackets, specifically things like [2 which are known as “second-type brackets”. This value is comparable to order-type of the BHO in the fast-growing hierarchy.

The Higher-Sublegion Range

X^^X&X&a ~ {X,X/2}

(order type ψ(εΩ+1) ~ ψ(Ωw)

Entries: 15

Extremebixul

200![1(1)2200,200,200,200,200]

Now, naturally, we’ll continue adding entries to add onto the arrays’ power. This number is about fψ(ζ(Ω+1))(200) in the FGH.

Extremetrixul

200![1(1)2200,200,200,200,200,200]

About fψ(η(Ω+1))(200) in the FGH.

Extremequaxul

200![1(1)2200,200,200,200,200,200,200]

About fψ(φ(4,Ω+1))(200) in the FGH.

Hypertriakulus

3&3&3&3 = {3,4/2}

This is a pentational-array-array number I coined simply to show how BEAF isn’t as much of dichotomy between well-defined and ill-defined as it is a continuum between the two: this number vs the triakulus shows this kind of thing. While a triakulus can easily become fully defined if one allows liberty with some guesswork, the same cannot be said about a hypertriakulus. I am yet to be able to reach that construction in my variant of BEAF, but once I do I’ll probably be able to go all the way to the limits of the array of operator.

Tetrakulus

4&4&4&4 = {4,4/2}

This number is an extrapolation from a triakulus which can be expressed as 3&3&3 - I coined this number to show how (a) unfathomably larger it is than a triakulus and (b) much more difficult it is to define. It can be thought of as a “supertet array of 4’s” array of 4’s - since supertet is unfathomably larger than tritri, a supertet array of 4’s is most definitely unfathomably larger than a tritri array of 3’s, and then a supertet array of 4’s even MORE so.

Golapulusplex

{10,10(100)2}&10&10 = 10^100&10&10&10

Now for a leap up to Bowers' golapulusplex. While a golapulus is a gongulus array of tens, a golapulusplex is a golapulus array of tens! Note that this is an unusual interpretation of the -plex suffix, since normally Bowers uses -plex to indicate simple recursion (e.g. gongulusplex = {10,100(gongulus)2}), but here he does something entirely different - once again that’s taking advantage of the array-of operator.

A golapulusplex is a whole new level of “hard to formalize” than a golapulus, because now we’ve reached dimensional-array-array-arrays (O_o), and those require whole new ideas on how to work with the separatotrs - for instance how do you define {X,2X(X^^X)2}&10 vs {X,X(X^^X)2}&10?

This number is about fψ(Ω_2^Ω_2^w)(100) in the fast-growing hierarchy - note that _ indicates subscript just like ^ indicates superscript.

Pentakulus

{5,5/2} = 5&5&5&5&5

This number is 5 5’s with the array-of operator, a ““superpent array of 5’s” array of 5’s” array of 5’s.

Hexakulus

{6,6/2}

In general, {a,b/2} = a&a&a......&a&a with b a’s.

Heptakulus

{7,7/2}

Oktakulus

{8,8/2}

Ennakulus

{9,9/2}

Big Mac / Dekakulus

{10,10/2}

This is a number I coined as a googolism that seems to be missing from BEAF - one that direectly welcomes you to the next level of notation like a goobol or gongulus does. It is equal to 10&10&10&10&10&10&10&10&10&10 with the array-of operator. (yes I based the name upon the hamburger)

Lower bound for SCG(13)

~ f_{ψ(Ω_w)}(13)

This is a "weak" lower bound for SCG(13), a number that appears in serious mathematics but is EVEN BIGGER than the incredibly monstrous TREE(3).

What exactly is SCG? SCG stands for Subcubic Graph, a function that, like the TREE function, was devised by Harvey Friedman. It's somewhat similar to TREE but it's about subcubic graphs instead of k-labeled trees.

SCG(x) is then defined as the length of the longest possible sequence of subcubic graphs G₁, G₂, ... G_n such that G_i has at most i+x vertices and none is homeomorphically embeddable into a later graph.

The function grows INCREDIBLY quickly, zooming past epsilon-zero, gamma-zero, the SVO, the LVO, and even the BHO. Hell, it's far more powerful than the TREE function! Here's some information on values of SCG(x):

SCG(0) can be shown to equal 6.

Hyp cos of Googology Wiki proved SCG(1) to be at least of order type epsilon-two in the fast-growing hierarchy.

He also proved SCG(2) to be at least of order type of the SVO, although in both of those bounds he uses a nonstandard choice of fundamental sequences for ordinals.

SCG(x) grows at a rate somewhere beyond what would be comparable to f_{ψ(Ω_w)}(x) in terms of the fast-growing hierarchy, making it an incredibly powerful function that, like TREE(x), is quite simple. SCG(13) was chosen as a large number to use in particular because Harvey Friedman had a specific sequence in mind.

Incredibly, SCG(13) is STILL not the largest number to appear in professional mathematics ... there are beaten by something devised by Friedman called finite promise games, which even beat Loader's number, which is itself one of the largest numbers known ...

The Whopper

{10,100/2}

This is a number equal to 10&10&10 ... &10 with 100 10's, a name I coined in analogy to the big mac. Like the big mac, it's both named after a hamburger and meant as "a transition googolism" between the array-of operator and legion arrays.

f_{ψ(Ω_w)}(100)

This is just an entry to discuss the order type of the ordinal ψ(Ω_w), an ordinal with a special significance to googology. It is believed to represent the limit of the array-of operator, i.e. the limit of things like a&a&a&a .... &a with a a's, making it a major turning point in large numbers for those who like to use BEAF as a measuring stick (although many nowadays object to that usage because of BEAF's major ambiguities). This order-type is commonly used as a lower bound for numbers that are large by googological standards, numbers that hold a high spot among the googolisms.

In addition, this ordinal is the first point where the slow-growing hierarchy catches up with the fast-growing hierarchy, under the most common usage. That means that ψ(Ω_w) is the smallest ordinal α such that f_α(n) is in general comparable to g_α(n) (using the slow-growing hierarchy).

This ordinal is also the limit of Chris Bird's Hierarchial Hyper-Nested Arrays, a subset of his array notation which is currently limited at the ordinal ψ(Ω_Ω).

Now at this point, a full list of numbers after this point is yet to be released. When it is, part 7 of this list will be released. For now here are some notable numbers larger than the entry above:

The Infinite-Scraping Range

order type ψ(Ωw) ~ ????

Entries: 5

Meameamealokkapoowa oompa

{LLL......LLL,10}_10,10 with a meameamealokkapoowa array of L's

The infamous meameamealokkapoowa oompa is Jonathan Bowers' largest and most famous googolism. It is often again and again hailed as one of the largest numbers in the world, if not the largest, but it's so ambiguously defined (what does an "array of L's" actually solve to?!) that it has more recently gotten a kind of infamy among the googology community. Nobody has come even close to agreement on how it should be defined and how big it is, and many will refuse to call it a number! This is not that we hate Jonathan Bowers or his work, it's just that this is a very strange googolism. I can't help but believe that Bowers had some unique idea of what arrays of L's really decompose to, but he just didn't describe it on his website and we might not know for quite a long time. Let me stress once again that I do not hate Bowers' work - his work is worthy of a lot of merit for its aesthetic appeal and founding the spirit of modern googology.

Nonetheless, this could very well be among the largest numbers known, but is still beaten by something like...

100R{0,,, ...(100 commas)... ,,,1} using Hyp cos's R function

There are indeed googological notations that transcend however powerful Bowers' BEAF is believed to be. These are Wythagoras's dollar function, and Hyp cos's R function (Wythagoras and Hyp cos are both Googology Wiki users). It is not known which is more powerful, but since the dollar function is currently fairly unstable and under improvement I'll use Hyp cos's R function here.

Now the R function is a highly intricate and complicated function, and the pages which introduce it (Hyp cos's user page introduces that notation) are certainly not an easy read for beginning googologists. This number in particular is right around the limit of what the R function currently has. It is a truly cutting-edge notation, transcending even any known recursive ordinal in the fast-growing hierarchy, although neither of the functions have ay googolisms defined with them. What's surprising is that there are computable functions that can create numbers that are even more (MUCH more) "way out there" so to speak ...

Loader's number

D⁵(99)

Loader's number, along with TREE(3) and Rayo's number, is one of the most well-known numbers larger than Graham's number. Before I can explain what exactly it is, I'll describe how exactly this monstrous number came to be - although I discuss just that on some other earlier entries, I'll describe how Loader's number came to be for the sake of this being a standalone entry.

In 2001 there was a competition called Bignum Bakeoff hosted online by David Moews. The goal was to submit a C program with 512 characters or less. Entries were submitted through email. A total of twenty entries were submitted (nine from the same person), fourteen of which produced a large number. The winning program was titled loader.c and was submitted by Ralph Loader, and the number it outputs it today known as Loader's number.

As it turns out, Loader's number is not just any large number, but it is legitimately one of the largest numbers known. It totally crushes even the second-place program, marxen.c, which uses a variant of Goodstein sequences to get a bit past order-type epsilon-zero in the fast-growing hierarchy. Loader's program diagonalizes over the calculus of constructions which can easily generate numbers much larger than those any known notation can describe!

In Loader's program, the function D(n) is defined as the sum of all possible bit strings described by the first n expressions in the calculus of constructions. Then, the output of the program is defined as D(D(D(D(D(99))))), or D⁵(99) for short (the exponent denotes how many times the D(n) is applied to 99).

How does Loader's number end up so big? Diagonalizing over systems like the calculus of constructions is a MUCH more efficient way to generate large numbers than just inventing an iterative function. The calculus of constructions is in particular a good choice for a program to output the largest number you can, since it can be thought of as a programming language where every possible program terminates! By using the calculus of constructions, the D function has a growth rate that vastly exceeds any known ordinal in the fast-growing hierarchy!

The D(n) function, despite all this, is still a computable function! Why is that? Because a computable function is a function that can have a computer program written to calculate it, and D(n) is defined with a computer program! But why is that important? Because all computable functions are by necessity beaten by some of the uncomputable functions, functions that cannot be calculated using a computer program. The best-known and original uncomputable function is the busy beaver function, which is discussed at the entries for 107 and 4098. It has the mind-bending property of being able to create values larger than ANY computable function, no matter how powerful your function is, even if it's Loader's D function!!! But there's an additional important note I'd like to make: not all uncomputable functions are more powerful than all computable functions. For example, it's possible to use Turing machines to devise an uncomputable function that can only output 0 or 1, and that's obviously not even anywhere near as powerful as any googological functions!

In any case, Loader's number is currently honored as the largest named computable number (a number defined using a computable function). However, Loader's function is not the most powerful known computable function - Friedman's finite promise games and finite trees can lead to some EVEN MORE POWERFUL computable functions. There are a few googolisms that surpass Loader's number...

Rayo's number

Rayo(10¹⁰⁰)

Rayo's number is another one of the most famous numbers larger than Graham's number. In fact, for a while it was honored as the largest named number! Once again, first I'll explain how it came to be, then what it is.

Rayo's number came from a big number duel held at MIT in January 2007, where Adam Elga (a Princeton professor) and Agustin Rayo (a MIT professor) took turns coming up with a larger number than the previous number until one of them couldn't come up with a larger number. However there were a few constraints. You could not use semantic vocabulary (e.g. the smallest number larger than any number a human has named). You also could not invoke infinity. In addition there's a "gentleman's agreement" that your number should be something that cannot be made with tools your opponent introduced - for example if your opponent devises a fast-growing function F(n) and defines F(100), you can't respond with something like F(F(100)).

The duel began with Elga writing 1 on the board. Then Rayo responded by writing a long string of ones. Elga then retaliated by replacing half of the ones with factorials. Then they began to invent their own notations as the audience watched and asked questions about their functions. In the end Rayo wrote on the board:

"The smallest number bigger than any finite number named by an expression in the language of first-order set theory with a googol symbols or less."

and since Elga could not come up with a significantly larger number, Rayo won the competition. The number can in fact be generalized to a function, where "the smallest number bigger than any finite number named by an expression in the language of set theory with x symbols or less" is denoted Rayo(x), also sometimes denoted FOST(x) from FOST which stands for first-order set theory.

Now, Rayo's number itself uses a philosopher's trick (Rayo himself is not only involved in mathematics but also in linguistics and philosophy) - by using first-order set theory, we can easily diagonalize over any other numbers that were known at the time. It's far more powerful than the busy beaver function or even Adam Goucher's xi function! In fact it's very hard to come up with a significantly larger number.

From 2007 up to late 2014 Rayo's number was honored as the largest named number. However this is not strictly true, as people have made extensions upon it like "Rayoplex" meaning 10 to the power of Rayo's number, or Rayo(10^{10^100}). But those are not honored as numbers that trounce Rayo, because they are simply naive extensions. They follow easily from what Rayo defined, and thus do not bring anything new into the large number discussion! A more clever attempt was Kyodaisuu of Googology Wiki's Fish number 7, which was defined in October 2013 extends upon the set theory itself, by adding a new predicate to first-order set theory (FOST for short). However, as it turns out Fish number 7 does not really improve the strength of FOST very much. Nonetheless, as Nathan Ho (the founder of Googology Wiki) once said, Fish number 7 is a step in the right direction from Rayo's number.

Eventually Rayo's number was indeed trounced in a way that would most definitely be considered a good extension, with a new record-holder number:

BIG FOOT

FOOT¹⁰(10¹⁰⁰)

BIG FOOT is currently honored as the largest named number. It was defined by LittlePeng9 of Googology Wiki using something called first-order oodle theory (FOOT for short), a generalization and extension of first-order set theory. The name was suggested by Sbiis Saibian. It was developed in a Googology Wiki blog post, and then Nathan Ho decided to publish it on an article in his own personal website, with a few additions (mainly on the background of Rayo's number and extensions to the number).

First order oodle theory is like the set theory used to define Rayo's number, but augmented with the symbols [ and ]. With just those two symbols we can generate numbers vastly larger than any other extension to FOST people have yet devised (and all those other extensions are quite naive). With FOOT, we can define a function FOOT(x) as the largest number expressible with x symbols in FOOT, and with the FOOT function LittlePeng9 defined the monstrous number FOOT¹⁰(10¹⁰⁰) (the superscript 10 denotes how many times FOOT(x) is applied to 10¹⁰⁰).

Why is BIG FOOT honored as the largest named number while other extensions like Fish number 7 weren't? Because it was not a naive extension like the other extensions to Rayo's number (arguably this includes Fish number 7). Naive extensions are the best way to embarrass yourself in front of googologists, because anyone could come up with them, while the same cannot be said for coming up with numbers like Rayo's number, BIG FOOT, or even just Graham's number.

And that brings us to an important point: googology is not so much about finding the largest number as it is about continually finding better ways to make large numbers. As Nathan Ho once said, "googology is a never-ending quest to outrun itself".

So what is the largest finite number? There isn't one! But this fact does not mean that it's pointless to come up with the largest number you can. The ultimate point of googology is to come up with continually larger numbers! There is no limit to how large numbers can be, but there is a limit to how large numbers humans have thought up at any point in time (things like Sam's Number, a "number" described as so huge that it's impossible to describe, don't count!). There is also a number honored as the "largest named number", and that is currently BIG FOOT as it is a number that broke the record of Rayo's number while honoring the gentlemen's agreement of googology: you don't get bragging rights for coming up with naive extensions.

So we have reached the current ceiling of human large number knowledge, but we will never reach the end of numbers, as there are infinitely many numbers between BIG FOOT or any number out there larger than it and infinity.

If you really want to skip to infinity, you can go to my list of infinite numbers.

Planned for the future: PGLN7 (The Elder Gods), with the numbers in the "infinity-scraping range" and many more! I don't know when it'll be released though.