3.1.2. Bowers' Linear Array Notation I

(back to 3.1.1)


In the last article we were introduced to the work of Jonathan Bowers, with its history, a bit about the man himself, and why his work is important to googology. Now we're ready to finally examine his googology in depth. In this page we'll learn about linear array notation, the simplest subset of his famous large number system known as BEAF. It's a simple notation that is a polyadic function much like Conway chain arrow notation, but much more powerful than all the popular large number notations, and arguably more natural than Conway's chain arrows. Here I'll walk through this notation, with its definition and examples of how it works. Are you ready for some numbers way bigger than any we've seen previously, devised by the father of modern googology himself? If you are, then let's begin.

About Bowers' Array Notation

Bowers' large number notation begins with the hyper-operators, nothing more, nothing less. If you recall my article on Knuth's up-arrows, I mentioned in the introduction that there are many googological notations that are based on the hyper-operators. Here are some examples:

- Bowers' array notation

- Bird's array notation

- Conway chain arrow notation

- Hollom's hyperfactorial notation

- Aarex's extended up-arrows

- Joyce's G function

- The N-growing hierarchy (a sibling of the fast-growing hierarchy designed to be able to express the hyper-operators)

The hyper-operators are a very natural place to start a large number notation, due to how intuitively they work, and the fact that they're an extension upon the familiar operators addition, multiplication, and exponentiation.

Bowers explains on his old website (the large number pages of which Sbiis Saibian archived here) that he learned about the hyper-operators in a book whose name he doesn't remember. From there, he came up with a notation to extend upon the hyper-operators. He came up with three notations for that: extended operator notation, array notation, and extended array notation. He notes on his old website about each of the three notations:

The extended operator notation and the array notation are two ways of writing the same thing, the array notation is cleaner looking, but the extended operator notation can give one a feel of how large the numbers get. The extended array notation leads to unspeakably enormous numbers, so huge that the other notations can't even come close.

I should clarify on the slightly misleading claim that "the extended operator notation and the array notation are two ways of writing the same thing". Technically array notation is wider-ranged than operator notation, since while extended operator notation works as a notation for arrays of 3 to 8 entries, array notation allows any number of entries (just like Conway chain arrow notation).

Also, to clarify on the claim that "the extended array notation leads to unspeakably enormous numbers, so huge that the other notations can't even come close", extended array notation, as its name suggests, is an extension to the array notation. In this article we'll focus on extended operator notation and array notation, while we won't learn about extended array notation until section 3.2, let alone his even further extensions.

Ruleset of Bowers' Array Notation

Bowers' array notation allows you to evaluate any set of positive integers separated by commas and put into curly brackets, for example {53,6,1,7,2} or {3,2,6}. This is much like Conway chain arrow notation, which lets you evaluate any se of positive integers separated by right-arrows. However, Bowers' notation is much more powerful due to having a different set of rules, and in my opinion it's more aesthetically appealing as well - in fact, I myself got around to understanding how Bowers' arrays work several months before understanding how Conway's chain arrows work.

Jonathan Bowers came up with the following set of rules for his notation (this below is exactly how he wrote it, except for the red text and my notes):

Rule 1: Condition - only 1 or 2 entries - {a} = a, {a,b} = a^b (formerly a+b - we'll get into why he changed this rule later)

Rule 2: Condition - last entry is 1 - {a,b,c,...,k,1} = {a,b,c,...,k} (in other words remove trailing 1's).

Rule 3: Condition - 2nd entry is 1 - {a,1,c,d,..,k} = a.

Rule 4: Condition - 3rd entry is 1 - {a,b,1,..,1,d,e,..,k} = {a,a,a,..,{a,b-1,1,..,1,d,e,..,k},d-1,e,..,k} - the ".." between the 1's represent 1's - there can be any number of ones, from 1 "1" (3rd entry alone) to a string of 1s - the last 1 of this string is what becomes {a,b-1,1,..,1,d,e,..,k} all entries prior becomes "a". For an array like this {3,2,1,1,1,5,1,2} the last 1 in the string is the one before the 5 (not the one after - since it is a different string of 1s).

Rule 5: Condition - Rules 1-4 doesn't apply - {a,b,c,d,...,k} = {a,{a,b-1,c,d,...,k},c-1,d,..,k}.

NOTE: Bowers explains that he likes to use angle brackets (< >) instead of curly brackets ( { } ) for his notation, but he says that angle brackets don't like to show up right on his website. Although I have no problems using angle brackets with Google Sites, since Bowers presented all his large numbers in his notation using curly brackets, they have become the standard way to type out Bowers' notation. Sbiis Saibian is an exception to this, as he sometimes uses < > for Bowers' array notation - angle brackets are also commonly used when working with Bowers' notation in handwriting,

NOTE 2: Bowers also explains that the rules should be followed like so: you should follow the first rule such that the rule's condition applies, but all the previous rules' conditions don't apply.

For example, to find which rule you should follow to evaluate the array {3,1,3}, here's what you do: check if rule 1 applies - it doesn't apply (array has 3 entries, not 1 or 2), so you check if rule 2 applies - it doesn't apply (last entry isn't 1), so you check if rule 3 applies, which it does (2nd entry is a 1).

These rules should be easy enough to understand, except for the fourth rule which is a bit of a mouthful. If you don't quite get all of them, that's OK - we'll go over lots of examples to understand how they work in not too long. Let's continue with the rules for Bowers' operator notation.

Rules of Bowers' Operator Notation

As I said earlier, Bowers' operator notation works as an alternative notation for arrays of 3 to 8 entries. Here is how the notation works:

3-entry arrays: {a,b,c} = a{c}b.

4-entry arrays: {a,b,c,d} = a{{{...{{{c}}}...}}}b, with d pairs of brackets

After 4-entry arrays, Bowers' operator notation is cumbersome to type out. He describes his operator notation for 5 or more entries like so:

I have operator notations for up to 8 entry arrays ( i.e. {a,b,c,d,e,f,g,h}), however they will be quite cumbersome to type out - a,b,and c are shown in numeric form, d is represented by angle brackets (as seen above), e is shown by [ ] like brackets, but rotated 90 degrees, where the brackets are above and below (uses e-1 bracket sets), f is shown by drawing f-1 vertical Saturn like rings around it, g is shown by drawing g-1 X-wing brackets around it, while h is shown by sandwiching all this in between h-1 3-D versions of [ ] brackets (above and below) which look like square plates with short side walls facing inwards.

With that description, the operator notation for 5-entry arrays is quite clear. Here is a picture of what it would look like:

The operator notation for arrays of 6-8 entries, however, is not so clear based on Bowers' brief descriptions. Sbiis Saibian, on his page on Bowers' operator notation (link), has made pictures showing his best guesses on what that notation would look like:

6 entries:

7 entries:

8 entries:

and that's as far as Bowers' operator notation goes. Obviously, after 4 entries it becomes very impractical to type out, and isn't quite as neat looking as linear array notation to say the least. On the other hand, as Bowers points out, the operator notation better for giving people an idea of how big the numbers are. We'll go into more depth about the strengths and weaknesses of this notation later, but for now let's go on to some examples of the notation, as well as Bowers' googolisms defined in that notation. It's difficult to understand any googological notation (especially if you're a beginning googologist) without examples of how it works, so we'll go through an extensive array of examples to understand how Bowers' notation works.

Arrays of 0 to 3 Entries

Trivial arrays: 0, 1, and 2 entries

Bowers' linear array notation supports arrays of any number of entries. The three smallest types of arrays - zero entries, one entry, and two entries - all behave rather trivially.

Zero entries - There is only one possible array of zero entries. It is called the "empty array", and it is denoted {}. The empty array evaluates to 1.

Why does the empty array evaluate to 1? Well, the second rule of Bowers' linear array notation is:

Condition - last entry is 1 - {a,b,c,...,k,1} = {a,b,c,...,k}

This rule tells us that if an array ends in 1, you can remove the 1 in the end. This implies that any linear array at all is the same as that array with a 1 appended to the end. This would mean that the empty array {} is the same as the arrays {1}, {1,1}, {1,1,1}, etc, which all evaluate to 1.

One entry - All one-entry arrays (arrays of the form {a}) evaluate to the number in the array, by definition (rule 1 of the notation). This means that {1} = 1, {2} = 2, {100} = 100, etc. Not very interesting behavior.

Two entries - Arrays of two entries ({a,b}) evaluate to ab. This means that two-entry arrays are equivalent to exponentiation. Here are some examples:

{1,25} = 1

{46,1} = 46

{3,5} = 243

{5,3} = 125

{10,10} = 10,000,000,000

{100,100} = 100100 = 10200

These values aren't anything new or impressive, but that's OK - every googological notation has to start off somewhere.

Two-entry arrays used to evaluate to a+b, but Bowers changed it to ab by Chris Bird's suggestion. If you recall the previous article, I mentioned that Chris Bird devised a sibling to Bowers' array notation that begins nearly identical to Bowers' notation but with a different base rule (which Bowers himself later adopted). Bowers' base rule was that {a,b} was a+b, but Bird's base rule was that {a,b} = ab. There are two main reasons why Bird chose that rule:

1. {a,b} = ab matches better with Bowers' second rule (1's at the end of arrays can be removed). With the old base rule, {a,1} is a bit of an ambiguous value: if you follow the second rule, {a,1} = {a} = a, but if you follow the first rule, then {a,1} = a+1.

Note that making the rule {a,b} = a*b would fix part of the problem ({a,1} would equal "a" no matter what rule you follow), but would that still isn't as good of a choice as setting {a,b} = ab. The reason why that is brings us to the second reason why Bird suggested changing the rule:

2. {a,b} = ab makes Bowers' notation easier to compare with Conway chain arrows. In Conway's notation, a->b = ab; this was not explicitly stated in his Book of Numbers but it easily follows from the "rules" he did give for his notation, as we saw not too long ago when we learned about Conway's chain arrows.

A third reason why it's better to have {a,b} = ab as a base rule is that doing so gives the notation some nice properties that it doesn't have if you make 2-entry arrays evaluate to a*b or a+b. Specifically, arrays with the base rule {a,b} = ab have the property that all arrays that start with 1 evaluate to 1. This is not the case with arrays where the base rule is addition or multiplication. If {a,b} is set to be a+b or a*b, then {1,b} would be equal to b+1 or b respectively, rather than evaluate to 1.

Let's move on to 3-entry arrays, also known as trientricals.

3-Entry Arrays (Trientricals)

Arrays with 3 entries, or trientricals, are denoted as {a,b,c} with Bowers' array notation, or as a{c}b with Bowers' operator notation. Unlike with 0, 1, or 2 entry arrays, trientrical arrays produce huge numbers very easily.

As it turns out, trientrical arrays are just another way to write up-arrow notation - more specifically, {a,b,c} is another way to write a^cb (or a->b->c using Conway chain arrows), as is a{c}b. This is in fact fully intentional, as Bowers' array notation is itself a generalization of the hyper-operators. If you want to see an inductive proof of how Bowers' arrays translate to up-arrows, look here.

Jonathan Bowers defined a variety of googolisms using his 3-entry arrays. If you recall the article on Knuth's up-arrows, we've already learned about many of those googolisms, such as the giggol or tritet. Here is a list of Bowers' trientrical googolisms in size order:

* tridecal is pronounced /TRI-da-cal/

You may remember some of these numbers from my article on Knuth's up-arrows. As you can see, most of these numbers are either numbers based on the googol and googolplex (giggol, giggolplex, gaggol, geegol, etc), or numbers of the form {x,x,x} (the numbers whose names start with "tri-") - the latter family of numbers, as we learned earlier in the article on up-arrow notation, is known as the Ackermann numbers. The only numbers listed above that don't fit one of these two categories are the boogol family (boogol, boogolplex, ... ), which is also based upon the googol, and the decker, which is a power tower of 10 10's (the name likely comes from the prefix deca- for 10).

One thing of note here is that Jonathan Bowers chooses not to interpret x-plex as simply meaning 10x. If -plex is interpreted that way, then, for example, a gaggolplex would only be 10 to the power of a gaggol - another way to think of it is that since a gaggol is a power tower of 10^^^99 tens, a gaggolplex would be a power tower of only one more ten, i.e. a power tower of 10^^^99+1 tens, rather than the MUCH larger number that is ten pentated to a gaggol. Instead of defining -plex as meaning 10x, Bowers chose to interpret it something like this: if x = f(100), then x-plex is f(x). This is an informal definition, and one that is not followed by all of Bowers' googolisms using -plex (the golapulusplex interpets -plex a different way from how it's usually used in Bowers' googolisms), but its mechanics should be quite clear from the table of Bowers' trientrical googolisms shown above.

If you want a recap on how big these numbers are, here are visual representations of some of these numbers:




10^10^10^10^10^ ... ... ... ... ^10^10

100 10's


3^3^3^3^3^3^3^ ... ... ... ... ... ... ... ... ... ^3^3^3

7,625,597,484,987 3's


10^10^10^10^10^ ... ... ... ... ^10^10

10^10^10^10^10^ ... ... ... ... ^10^10 10's

100 10's






These numbers, which are among the smallest of Bowers' googolisms, are already incomprehensibly huge!!! The representation of a tripent above, which is {5,5,5} in array notation, is crazy mind-boggling, and it's still 5 levels of hyper-operators away from something like a tridecal, or MUCH worse, a boogol, which is ninety levels of hyper-operators away from THAT, or a boogolplex, which is itself a boogol levels of hyper-operators!!!

But despite the crazy size of these numbers, they're just the beginning of Bowers' array notation, and in fact they don't even tap into the power of Bowers' extension to the hyper-operators, which is where we reach 4-entry arrays. 4-entry arrays are as far as we will go in this article; in the next article we'll learn about arrays with 5 or more entries.

Bowers' four-entry arrays are also known as tetrentricals (from "tetra-" + "entry"). They are written {a,b,c,d} in array notation, and as a{{...{{{c}}...}}b (with d pairs of curly brackets) in Bowers' operator notation. In this subheading we'll walk through these arrays, gaining an understanding of how they work. To do this, we will use a method commonly used to explain Bowers' array notation: using Bowers' tetrentrical hyper-operators, an extension to the system of hyper-operators to Bowers' 4-entry arrays. In each subheading we'll examine a different operator or group of operators, starting with expansion and going on through Bowers' system of operators.

Expansion - a{{1}}b or {a,b,1,2}

Expansion is a 2-argument operator that is the simplest of Bowers' tetrentrical hyper-operators. It's defined as {a,b,1,2} using array notation, or a{{1}}b using operator notation. In this subheading we'll learn how this operator works with some examples of it. Just like with the hyper-operators (both the strong ones and the weak ones), we'll look at examples of expansion with the base of 1, the base of 2, the base of 3, etc, to get an idea of what this operator is and how powerful it is.

As Jonathan Bowers explains, a expanded to b, or a{{1}}b, evaluates to a{a{a{ ... a{a}a ... }a}a}a, with b a's from the center to one end. This means that:

a{{1}}1 = a

a{{1}}2 = a{a}a = a^aa

a{{1}}3 = a{a{a}a}a = a^a{a}aa

a{{1}}4 = a{a{a{a}a}a}a = a^a{a{a}a}aa

and so on. Another way to put this is that a expanded to 1 is a, and a expanded to b (b>1) is equal to a^^^...^^^a with "a expanded to b-1" arrows.

Can we substantiate this claim? Yes we can - all we need to do is try evaluating such expressions in expansion using the rules of Bowers' array notation. Here are the rules of the notation again for reference:

Rule 1: Condition - only 1 or 2 entries - {a} = a, {a,b} = a^b

Rule 2: Condition - last entry is 1 - {a,b,c,...,k,1} = {a,b,c,...,k} (in other words remove trailing 1's).

Rule 3: Condition - 2nd entry is 1 - {a,1,c,d,..,k} = a.

Rule 4: Condition - 3rd entry is 1 - {a,b,1,..,1,d,e,..,k} = {a,a,a,..,{a,b-1,1,..,1,d,e,..,k},d-1,e,..,k} - the ".." between the 1's represent 1's - there can be any number of ones, from 1 "1" (3rd entry alone) to a string of 1s - the last 1 of this string is what becomes {a,b-1,1,..,1,d,e,..,k} all entries prior becomes "a". For an array like this {3,2,1,1,1,5,1,2} the last 1 in the string is the one before the 5 (not the one after - since it is a different string of 1s).

Rule 5: Condition - Rules 1-4 doesn't apply - {a,b,c,d,...,k} = {a,{a,b-1,c,d,...,k},c-1,d,..,k}.

So with these rules, we'll use induction to show how expansion translates to up-arrows as follows: show that {a,1,1,2} is a, then that if b ≥ 1, {a,b+1,1,2} is equal to {a,a,{a,b,1,2}} (or a^{a,b,1,2}a).

It's easy to see that {a,1,1,2} evaluates to a. Here's why: the conditions for rules 1 and 2 of the notation don't apply, and so we use rule 3 to evaluate the array to a - this is because rule 3 states that if an array's second entry is 1.

As for the second part of the proof, we just need to evaluate {a,b+1,1,2} as a general case.

Since rules 1 to 3 don't apply for the array {a,b+1,1,2}, we need to follow rule 4 of array notation to evaluate this array.

Now rule 4 of linear array notation is a rather awkwardly phrased rule, but with the generalized 3-rule set of Bowers' notation in general (we'll learn about that in a later article), it's clear what expressions with the 3rd entry as 1 evaluate to. However, even with rule 4 written in Bowers' set of 5 rules for linear arrays, its method is fairly clear - we can write it in words like so:

If an array is of the form {a,b,#,d,@}, where # is any number of 1's (can't be 0), and @ is any number of entries (could be 0), then the last 1 before the number d changes to the array with b decreased by 1, b and all the other 1's in # change to a, d decreases by 1, and the rest of the array doesn't change.

So in the array {a,b+1,1,2}, "a" (the first entry) is a, "b" (the second entry) is b+1, d (the first entry after the string of 1's) is 2, and @ (all the entries after d) is nothing. Therefore, the array changes to:


since the last 1 before d changed to the array with b decreased by 1, b changed to a (there aren't any other 1's before d that change to a), and d decreased by 1. We can simplify this array a bit further by removing the 1 at the end, changing {a,a,{a,b,1,2},1} to {a,a,{a,b,1,2}}.

So we have shown that {a,1,1,2} is a, then that if b ≥ 1, {a,b+1,1,2} is equal to {a,a,{a,b,1,2}}. As a corollary of this, we can say that a expanded to 1 is a, a expanded to 2 is a{a}a, a expanded to 3 is a{a{a}a}a, and so on. That said, we're now ready to look at examples of expansion.

Cases of expansion with the base of 1 are, not surprisingly, trivial:

1{{1}}1 = 1

1{{1}}2 = 1{1}1 = 1^1 = 1

1{{1}}3 = 1{1{1}1}1 = 1{1^1}1 = 1{1}1 = 1^1 = 1

1{{1}}4 = 1{1{{1}}3}1 = 1{1}1 = 1^1 = 1

1{{1}}5 = 1{1{{1}}4}1 = 1{1}1 = 1^1 = 1


All these cases degenerate to 1, as you can see. This is the exact same behavior as we saw with the hyper-operators.

Here is an interesting side note (thanks to Sbiis Saibian for noting it in his page on Bowers' extended operators): in Bowers' old array notation (where a{1}b is a+b, a{2}b = a*b, a{3}b = a^b, a{4}b = a^^b, etc), expansion with the base of 1 has unusual behavior:

1{{1}}1 = 1

1{{1}}2 = 1{1}1 = 1+1 = 2

1{{1}}3 = 1{1{1}1}1 = 1{1+1}1 = 1{2}1 = 1*1 = 1

1{{1}}4 = 1{1{{1}}3}1 = 1{1}1 = 1+1 = 2

1{{1}}5 = 1{1{{1}}4}1 = 1{2}1 = 1*1 = 1


As you can see, in Bowers' old array notation 1{{1}}n is always 1 if n is odd and 2 if n is even. This is some pretty weird behavior alright, but at least it's a consistent pattern.

Expansion with the base of 2 is also a trivial case:

2{{1}}1 = 2

2{{1}}2 = 2{2}2 = 2^^2 = 4

2{{1}}3 = 2{2{2}2}2 = 2{2^^2}2 = 2{4}2 = 2^^^^2 = 4

2{{1}}4 = 2{2{{1}}3}2 = 2{4}2 = 2^^^^2 = 4

2{{1}}5 = 2{2{{1}}4}2 = 2{4}2 = 2^^^^2 = 4

This is quite different behavior from what we've seen with the hyper-operators with the base of 2; with the hyper-operators, only base-2 cases of the form 2^...^2 evaluate to 4, but with expansion, all cases with the base of 2 evaluate to 4. Still, this isn't unusual behavior, considering that they all evaluate to expressions of the form 2^...^2 anyway. The same holds true for Bowers' old array notation.

Let's try expansion with the base of 3:

3{{1}}1 = 3

3{{1}}2 = 3{3}3 = 3^^^3 (named tritri)

3{{1}}3 = 3{3{3}3}3 = 3^3^^^33

3{{1}}4 = 3{3{{1}}3}3 = 3^3^3^^^333


Now we're getting into some really big numbers here! While cases with the base of 1 and 2 are all trivial cases, the base of 3 gives us some much bigger numbers.

One thing you may notice is that expansion with the base of 3 heavily resembles the process for getting to Graham's number (i.e. the sequence G1, G2, ... G64). This can be seen more clearly if you think of it this way:

3{{1}}1 = 3

3{{1}}2 = 3^^^3

3{{1}}3 = 3^^^...^^^3 with 3{{1}}2 3's > G1

3{{1}}4 = 3^^^...^^^3 with 3{{1}}3 3's > G2

and so on.

Just like with Graham's number, expansion iterates the number of up-arrows with each term, leading to a growth rate much faster than anything involving the hyper-operators. What's particularly interesting is that expansion is only the very beginning of Bowers' 4-entry arrays and what lies beyond, and yet, it's already more than enough to keep up with Graham's number - 3 expanded to 3 is greater than G1, 3 expanded to 4 is greater than G2, 3 expanded to 5 is greater than G3, and if you follow the pattern, 3 expanded to 66 is the smallest such number that surpasses Graham's number.

Now think about that for a moment - Graham's number is very often described as the "world's largest number", and yet, Bowers' array notation already clobbers it very early on! This just goes to show that Graham's number, despite common beliefs to the contrary, is barely the beginning of the numbers googologists study.

Now Bowers didn't just stop after surpassing the "world's largest number". Unlike many other people, who are satisfied with merely surpassing Graham's number, Bowers went way way beyond into a whole new world of crazy numbers that leave Graham way behind in the dust! We'll be looking at such numbers shortly, but not before we look at some more examples of expansion with higher bases.

Expansion with the base of 4 behaves similar to the base of 3:

4{{1}}1 = 4

4{{1}}2 = 4^^^^4

4{{1}}3 = 4^^^...^^^4 with 4^^^^4 ^s

4{{1}}4 = 4^^^...^^^4 with 4{{1}}3 ^s


Note that this is pretty much identical to the process for getting to the Graham-Conway number, the alternate version of Graham's number from John Conway's Book of Numbers that is allegedly the "original version" of Graham's number. More specifically, 4 expanded to 65 is equal to the Graham-Conway number, which, to recap, can be defined like so: GC1 = 4^^^^4, GC2 = 4^GC14, GC3 = 4^GC24, etc, and the Graham-Conway number is GC64. It's interesting that Graham's number can't be compactly expressed in terms of Bowers' notation (falls between 3 expanded to 65 and 3 expanded to 66), but the Graham-Conway number can be.

Hopefully you get the idea of how expansion works. Jonathan Bowers defines two googolisms with expansion: the corporal and the corporalplex. They are equal to 10 expanded to 100 and 10 expanded to a corporal respectively, or {10,100,1,2} and {10,{10,100,1,2},1,2} respectively using array notation.

Now the corporal is a number very much like Graham's number, although larger. You can imagine it like so: let stage 1 be 10, stage 2 is 10^1010 (a tridecal), stage 3 is 10^stage 210, etc, and a corporal is stage 100 (note that stage n is always the same thing as 10 expanded to n). It's easy to see why this is larger than Graham's number - stage 2 is already much larger than 3^^^^3 (G1), stage 3 is bigger than 3^3^^^^33 (G2), etc, and stage 65 is thus already bigger than Graham's number. The corporalplex, meanwhile, is the corporalth stage using the idea above. Now that's a huge number alright - and yet, it's just the beginning of array notation.

Multiexpansion - a{{2}}b or {a,b,2,2}

Multiexpansion, noted a{{2}}b using operator notation or {a,b,2,2} using array notation, is the next of Bowers' extended operators after expansion. Just as multiplication is repeated addition, multiexpansion is repeated expansion, i.e. a{{2}}b = a{{1}}a{1}a{1} ... a{1}a with b copies of a. Yep it's that simple - if you want to understand why this is, think of it like so:

a{{2}}1 = {a,1,2,2} = a (rule 3 of array notation)

a{{2}}2 = {a,2,2,2} = {a,{a,1,2,2},1,2} (rule 5) = {a,a,1,2} = a{{1}}a

a{{2}}3 = {a,3,2,2} = {a,{a,2,2,2},1,2} (rule 5) = {a,{a,a,1,2},1,2} = a{{1}}({a,a,1,2}) = a{{1}}a{{1}}a


Although Bowers doesn't define any googolisms with multiexpansion, we should still look at some examples of how it works.

Base of 1:

1{{2}}1 = 1

1{{2}}2 = 1{{1}}1 = 1

1{{2}}3 = 1{{1}}1{{1}}1 = 1{{1}}1 = 1


Here's something you might be wondering: remember how expansion has strange behavior in the base of 1 in Bowers' old array notation (alternates between 1's and 2's)? Does the same hold for multiexpansion? Let's find out:

1{{2}}1 = 1

1{{2}}2 = 1{{1}}1 = 1 (since a{{1}}1 = a)

1{{2}}3 = 1{{1}}1{{1}}1 = 1{{1}}1 = 1


As you can see, in Bowers' old array notation, the weird behavior of expansion with the base of 1 vanishes when working with multiexpansion. This is a little odd, but it's nothing too weird.

Base of 2:

2{{2}}1 = 2

2{{2}}2 = 2{{1}}2 = 2{2}2 = 4

2{{2}}3 = 2{{1}}2{{1}}2 = 2{{1}}4 = 4

2{{2}}4 = 2{{1}}(2{{2}}3) = 2{{1}}4 = 4


Once again, trivial behavior. From here on out we can skip the bases of 1 and 2 and jump to base 3, since the behavior is just going to be trivial.

Base of 3:

3{{2}}1 = 3

3{{2}}2 = 3{{1}}3 = 3{3{3}3}3 = 3^^^...^^^3 with 3^^^3 3's

3{{2}}3 = 3{{1}}3{{1}}3 =:

3^^^... ... ... ^^^3

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

: : : : :

: : : : :

: : : : :

: : : : :

: : : : :

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^3 ^s

w/ 3^s

where there are 3^3^^^33 layers

Holy shit, now we're getting into some gigantic numbers. This is just 3 multiexpanded to the 3rd, and yet, it's already a number that humbles Graham's number. It's a number that's sort of like Graham's number, but constructed slightly differently, having not 64 layers, not 3^^^3 layers, but 3^^^...^^^3 with 3^^^3 ^'s of layers! Now think about how many layers of iterating up-arrows that is. It's crazy how we're already leaving Graham's number, which is so often thought of as a truly transcendent number, way in the past.

3{{2}}4 = 3{{1}}3{{1}}3{{1}}3, which is:

3^^^... ... ... ^^^3

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

: : : : :

: : : : :

: : : : :

: : : : :

: : : : :

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^3 ^s

w/ 3^s

where there are 3{{2}}3 layers

As you can see, with each step in multiexpansion we are feeding the number of layers of up-arrows onto itself. This means that 3 multiexpanded to 5 is like above with "3 multiexpanded to 4" layers, 3 multiexpanded to 6 is with "3 multiexpanded to 5" layers, and so on. Here's a visual guide to all the numbers of the form 3{{2}}x:

If we want to generate even bigger numbers, we can try multiexpansion with the base of 10:

10{{2}}1 = 10

10{{2}}2 = 10{{1}}10 =:











where each layer has as many up-arrows as the layer below it

10{{2}}3 = 10{{1}}10{{1}}10 =:




: : :

: : :

: : :





with 10{{2}}2 = 10 expanded to 10 layers

10{{2}}4 = 10{{1}}10{{1}}10{{1}}10, which is like above but with 10{{2}}3 layers

10{{2}}5 = 10{{1}}10{{1}}10{{1}}10{{1}}10, which is like above but with 10{{2}}4 layers

and so on.

As a last note, Bowers doesn't define any googolisms using multiexpansion - the next googolism of his after a corporalplex is the mind-bogglingly huge grand tridecal, which falls into the range of the next subheading.

Let's move on to the next operator, powerexpansion, and higher operators.

Powerexpansion, Expandotetration, ... - a{{n}}b or {a,b,n,2}

Powerexpansion is equal to a{{3}}b in operator notation, or {a,b,3,2} in array notation. It's the third of Bowers' extended operators. Its name originates like so: if expansion is addition and multiexpansion is multiplication, then powerexpansion is exponentiation ("power" because ab is read as a to the power of b or a to the b-th power). Its behavior is pretty simple: a{{3}}b (a powerexpanded to b) is equal to a{{2}}a{{2}}a{{2}} ... a{{2}}a with b copies of a. So for example:


= 3{{2}}3{{2}}3

= 3{{2}}3{{1}}3{{1}}3

= 3{{2}}3{{1}}3{3{3}3}3

= 3{{2}}3{{1}}3{3^^^3}3

= 3{{2}}X where X is:

3^^^... ... ... ^^^3

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

: : : : :

: : : : :

: : : : :

: : : : :

: : : : :

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^... ... ... ^^^3 ^s

w/ 3^^^3 ^s

w/ 3^s

where there are 3^3^^^33 layers

Note that the number visualized above (which has 3^3^^^33 layers of up-arrows) is NOT 3 powerexpanded to 3, but rather the number X such that 3 multiexpanded to X is 3 powerexpanded to 3.

This is the smallest non-trivial example of a powerexpansion, and it's already outrageously huge! If stage 1 is 3, stage 2 is 3 expanded to 3, stage 3 is 3 expanded to stage 2, and so on, then this is stage "3 expanded to 3^3^^^33".

For a larger example of powerexpansion, try to get your head around the number 10{{3}}10 ({10,10,3,2} in array notation), which evaluates to 10{{2}}10{{2}} ... 10{{2}}10, with 10 10's. You can imaging it as stage 1 = 10, stage 2 = 10 multiexpanded to 10, stage 3 = 10 multiexpanded to stage 2, and so on, and this is stage 10.

After powerexpansion comes expandotetration (name comes from expansion + tetration, the fourth hyper-operator), which is defined as a{{4}}b or {a,b,4,2}. This evaluates to:

a{{3}}a{{3}} ... a{{3}}a, with b copies of a

You should be able to see a pattern here - this is pretty much the same pattern as the hyper-operators, where a^^b = a^a^ ... a^a with b a's, a^^^b = a^^a^^ ... a^^a with b a's, and so on.

This pattern continues with the names expandopentation for a{{5}}b, expandohexation for a{{6}}b, and so on. Although these operator names were not explicitly given by Bowers, they're very obviously the kind of names Bowers had in mind - this is further supported when he mentions the names expandoenneation for a{{9}}b and expandodecation for a{{10}}b, while describing one of his googolisms, the grand tridecal, which is one of the four googolisms of Bowers' that are around the range of this subheading - the other three are the biggol, biggolplex, and biggolduplex.

Now how exactly are each of those numbers defined? First off, the grand tridecal, as the name would suggest, is a sibling of the tridecal (equal to 10{10}10). It's equal to 10{{10}}10 (10 expandodecated to 10) using operator notation, or {10,10,10,2} using array notation. It evaluates very similar to a tridecal: while a tridecal evaluates to


= 10{9}10{9}10{9}10{9}10{9}10{9}10{9}10{9}10{8}10{8}10{8}10{8}10{8}10{8}10{8}10{8}10{8}10

a grand tridecal evaluates to


= 10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{8}}10{{8}}10{{8}}10{{8}}10{{8}}10


Now let's stop and think about how big a grand tridecal is. Bowers himself comments that a grand tridecal dwarfs the "previous numbers" (i.e. the corporal and corporalplex), and he's right on there. While a corporalplex is 10 expanded to "10 expanded to 100", a grand tridecal is 10 expandodecated to 10, which is:

10 expandoenneated to "10 expandoenneated to "10 expandoenneated to "10 expandoenneated to "10 expandoenneated to "10 expandoenneated to "10 expandoenneated to "10 expandoenneated to "10 expandoenneated to 10" " " " " " " "

and that's just expressing the number in terms of expandoenneation, which is five levels of operation higher than even powerexpansion, which is itself a tricky operator to visualize. Let's just say that a grand tridecal is really huge, a big jump from the corporal and corporalplex, let alone Graham's number.

Up next is a biggol, which is even worse: while a grand tridecal is 10{{10}}10, a biggol is 10{{100}}10 or {10,10,100,2} - ninety levels of operators higher than a grand tridecal.

I should note that although the name "biggol" for 10{{100}}10 is usually listed alongside the other Bowerian googolisms, the name was actually coined by Chris Bird (who assisted in the construction of Bowers' notation, we'll learn more about his contributions to BEAF later), on the analogy googol:giggol::boogol:?. More specifically, while a googol is {10,100}, a giggol is {10,100,2}, and a boogol is {10,10,100}, by that logic a biggol should be {10,10,100,2}.

The biggolplex and biggolduplex are, unsurprisingly, the next two steps in recursion after a biggol - a biggolplex is 10{{biggol}}10, and a biggolduplex is 10{{biggolplex}}10. Those can also be written 10{{10{{100}}10}}10 and 10{{10{{10{{100}}10}}10}}10 respectively. It's not clear whether these names should be credited to Bowers or Bird, but since they're really obvious continuations of the name "biggol", I'll credit them to Chris Bird.

To recap, here are all the googolisms we've looked at that fall under the range of this and the previous two subheadings:

The Explosion Family - a{{{n}}}b or {a,b,n,3}

Next in line for us to learn about is the operator explosion, noted a{{{1}}}b in operator notation or {a,b,1,3} in array notation. It's an operator very analogous to expansion: while a expanded to b is a{a{ ... a{a}a ... }a}a with b a's from the center to one end, a exploded to b is a{{a{{ ... a{{a}}a ... }}a}}a with b a's from the center to one end. In other words:

a{{{1}}}1 = a

a{{{1}}}2 = a{{a}}a

a{{{1}}}3 = a{{a{{a}}a}}a


A simple explosion would be 3 exploded to 3 - let's try evaluating that and see what we get:


= 3{{3{{3}}3}}3

= 3{{X}}3, where X is 3 powerexpanded to 3

Now we are already in some serious trouble. We have a number which is 3{{X}}3 where X is itself an incomprehensibly huge number, 3 powerexpanded to 3. So this is sort of like 3 expando-"3-powerexpanded-to-3"-ated to 3. That's 3{{3}}3 levels of operations starting with expansion - in other words it's already a crazy huge number. And that's just the simplest non-trivial explosion.

For something bigger and better, try a number like 10 exploded to 10:


= 10{{10{{10{{10{{10{{10{{10{{10{{10{{10}}10}}10}}10}}10}}10}}10}}10}}10}}10

= 10{{10{{10{{10{{10{{10{{10{{10{{10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10}}


= 10{{10{{10{{10{{10{{10{{10{{10{{10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{9}}10{{8}}10{{


You get the idea - by the way, there aren't any Bowerian googolisms defined using explosion.

After explosion comes multiexplosion, a{{{2}}}b or {a,b,3,2}: a multiexploded to b is equal to:

a{{{1}}}a{{{1}}}a{{{1}}} ... a{{{1}}}a

with b copies of a.

For example, 3 multiexploded to 3 is 3 exploded to "3 exploded to 3", or 3 exploded to "3 expando-'3-powerexpanded-to-3'-ated to 3". There aren't any Bowerian googolisms defined using multiexplosion.

Following that is powerexplosion, a{{{3}}}b or {a,b,3,3}, which solves to

a{{{2}}}a{{{2}}}a{{{2}}} ... a{{{2}}}a

with b copies of a.

There is one Bowerian googolism defined using powerexplosion: the tetratri, equal to 3 powerexploded to 3. It's called tetratri because in array notation it's written {3,3,3,3}, and tetratri = four threes. It's a pretty cool number whose size Bowers explains like so:

Stage 1 = 3

Stage 2 = 3{{3{{3}}3}}3 - this is already a huge number equal to 3 expando-"3-powerexpanded-to-3"-ated to 3

Stage 3 = 3{{3{{3{{3{{ ... 3{{3{{3}}3}}3 ... }}3}}3}}3}}3 with Stage 2 3's from center out

Stage 4 = 3{{3{{3{{3{{ ... 3{{3{{3}}3}}3 ... }}3}}3}}3}}3 with Stage 3 3's from center out


This number is then stage stage 3. This means that if you write a list of numbers stage 1, stage 2, etc, then this is the Xth entry in the list, where X is:

3{{3{{3{{3{{ ... 3{{3{{3}}3}}3 ... }}3}}3}}3}}3

where the number of 3's from the center to one end is 3 expando-"3-powerexpanded-to-3"-ated to 3.

Bowers says that this number is pronounced /teh-TRA-tree/, but I always read it as /TET-ruh-try/; in my opinion this pronunciation makes more sense given how the prefixes tetra- and tri- are pronounced.

We can continue with explodotetration, explodopentation, and so on. There are two more Bowersisms around this range: the baggol 10{{{100}}}10 or {10,10,100,3}, and baggolplex 10{{{baggol}}}10 or {10,10,baggol,3}. Both of those numbers are analogous to the boogol and its relatives, being equal to 10 explodohecated to 10 and 10 explodo-baggol-ated to 10 respectively. Like the biggol and biggolplex, these numbers were coined by Chris Bird.

The Detonation Family - a{{{{n}}}}b or {a,b,n,4}

Just as a{{1}}b is called expansion and a{{{1}}}b is called explosion, a{{{{1}}}}b or {a,b,1,4} is called detonation:

a{{{{1}}}}b = a{{{a{{{a{{{ ... a{{{a}}}a ... }}}a}}}a}}}a with b a's from the center to one end.

Likewise, {a,b,2,4} = a{{{{2}}}}b = a{{{{1}}}}a{{{{1}}}} ... a{{{{1}}}}a with b a's is called multidetonation. Although the name was not explicitly stated by Bowers, it's the obvious name, following the pattern that if an operator {a,b,1,x} has the name "whatever", then the operator {a,b,2,x} has the name "multi-whatever". We can continue with powerdetonation {a,b,3,4}, detonotetration {a,b,4,4}, etc.

There are three Bowerian googolisms defined using operators in the detonation family: supertet = {4,4,4,4} (etymology: super + tet(ra)), beegol = {10,10,100,4}, beegolplex = {10,10,beegol,4}. The last two of these were probably coined by Chris Bird, since Bowers mentions that the biggol and baggol were created by Bird to analogize the boogol to the giggol, gaggol, etc - Googology Wiki credits the names "beegol" and "beegolplex" to Bird. Bowers notes that the former is not to be confused with a dog.

The supertet is another cool unfathomable number which you can imagine like so:

stage 1 = 4

stage 2 = 4{{{4{{{4{{{4}}}4}}}4}}}4 - already way bigger than the crazy huge tetratri

stage 3 = 4{{{4{{{4{{{ ... 4{{{4{{{4}}}4}}}4 ... }}}4}}}4}}}4 with stage 2 4's from the inside to one end


super-stage 1 = stage 1 = 4

super-stage 2 = stage stage stage stage 1 = stage stage stage 4

super-stage 3 = stage stage ... ... stage stage 1 with stage 2 stages


The supertet is then ... wait for it ... super-stage super-stage super-stage 4. Now think for a moment about how crazy huge this is. Already the second stage (not super-stage) dwarfs the unimaginably gigantic tetratri, and only with much more than a tetratri more stages, or stage 2 stages, or stage tetratri stages, or anything like that, would we get anywhere near reaching a supertet.

The beegol and beegolplex are crazy way more than that, even if we define super-super-stages, which are to super-stages what super-stages are to stages, or three or four or five "supers" - we'd need to go up to super-super- ... -super-stages, with about fifty supers, to reach a beegol, and half of a beegol supers to reach a beegolplex.

For a second recap, here's a list of all the googolisms we've looked at that fall under the range of the last two subheadings so far:

The Pentonation Family and Higher - a{{{{{n}}}}}b or {a,b,n,5}, etc.

After the detonation family comes the pentonation family, starting with pentonation itself, the operator {a,b,1,5} or a{{{{{1}}}}}b = a{{{{a{{{{a{{{{ ... a{{{{a}}}}a ... }}}}a}}}}a}}}}a with b a's from the center to one end. It's the largest extended operator Bowers explicitly names on his site. After that comes multipentonation, powerpentonation, pentonotetration, etc. The only Bowersism defined in the pentonation family is the bigol = {10,10,100,5}, which is probably better credited to Chris Bird.

The natural continuation of pentonation would be hexonation {a,b,1,6}, continuing with the pattern of Greek prefixes for numbers. This name was not explicitly stated by Bowers, and it's sometimes credited to Sbiis Saibian, since he gave the name for this operator on his page on Bowers' extended operators. However, I wouldn't really credit it to anyone in particular, since it's such an obvious continuation of the names that anyone could have come up with. After that would be heptonation, octonation, ennonation, deconation, for {a,b,1,x} where x is 7, 8, 9, 10 respectively; like "hexonation", those names are sometimes credited to Sbiis Saibian.

There are a handful of Bowerian googolisms that fall among this range. First off, the boggol and bagol are {10,10,100,6} and {10,10,100,7} respectively, and they serve to complete Chris Bird's set of numbers that analogize the giggol, gaggol, geegol series to the boogol. Bowers comments on the boggol, "boggles the mind doesn't it?", and on the bagol, "whatever you do, don't eat this many bagels".

The next number around this range is the general, equal to {10,10,10,10} or 10{{{{{{{{{{10}}}}}}}}}}10 (10 deconodecated to 10). It can alternately be called tetradecal (tetra- (4) + deca- (10)). On his "Infinity Scrapers" page (which lists very nearly all of his googolisms), he takes particular note of how big this number is.

The general evaluates to:



which is crazy huge. Bowers says that to get an idea of how huge this is, compare it to the far smaller number:

10{{{{{{{{{{1}}}}}}}}}}4 = 10{{{{{{{{{10{{{{{{{{{10{{{{{{{{{10}}}}}}}}}10}}}}}}}}}10}}}}}}}}}10

That is crazy huge, five families of extended operators away from the gigantic supertet, but it's a tiny dot compared to the general - it's nine levels of extended operators away, and nine levels of operators are waaaaaaaaayyyyyyy more than enough to make one number dwarf another - and that's still an understatement. Just imagine how crazy huge the general is.

Fourth in line is the troogol, which is {10,10,10,100}. Like the biggol, baggol, etc, its name was coined by Chris Bird. Its name comes from tri- plus "googol". This is because since a googol is {10,100} and a boogol (bi- + "googol") is {10,10,100}, a troogol would be {10,10,10,100}. Written out in operator notation it's equal to:

(that's 100 pairs of {})

Just imagine how much this dwarfs the general, which would only be about 10% as long written out like above. In Bowers' extended operators it's 10 hectonodecated to 10 (hecta- is the Greek prefix for 100). It's around the breaking point of four-entry arrays in Bowers' notation - this means that we're almost done with the range of numbers we'll cover in this page

The final two numbers in the four-entry-array range are the -plexes of the previous two: the generalplex is {10,10,10,general}, and the troogolplex is {10,10,10,troogol}. You can visualize these like so:

generalplex =

10{{{{{{{{{{{{{{{{ ... ... ... ... ... ... {{{{{{{{{{{{{{{10}}}}}}}}}}}} ... ... ... ... ... ... }}}}}}}}}}}10

10{{{{{{{{{{10}}}}}}}}}}10 pairs of {}


troogolplex =

10{{{{{{{{{{{{{{{{ ... ... ... ... ... ... {{{{{{{{{{{{{{{10}}}}}}}}}}}} ... ... ... ... ... ... }}}}}}}}}}}10

10{{{ ... {{{10}}} ... }}}10 pairs of {}

100 pairs of {}

and that's it.

To recap, here's a list of our last batch of Bowersisms:


Bowers' four-entry array notation may well be the most intuitive way to climb up to the range of numbers expressible with Conway chain arrows. They extend in a way that seems to follow naturally from the hyper-operators, and with only four entries we get to the same level as the arguably less natural Conway chain arrows, which use any number of arguments. How we know that they are at the same level of Conway chain arrows is a topic for later in this section. For now, let's move on to Bowers' notation with 5 or more entries, which leaves Conway's arrows or anything like that in the dust.

3.1.3. Bowers' Linear Array Notation II (coming soon)

3.1.4. Poly-Cell and Hyper-E Notation