This page will deal with array spaces and how they work, their sizes, positions within the array, prime blocks, and how they compare to ordinals and the Fast Growing Hierarchy. This is my second time to type this page out, my first rendition was lost due to my computer crashing in 2014.

Up to Dimensional Arrays

An array can be thought of as an ordered set of entries, where each entry has a value and a position. The positions of an array as well as the size can be represented by an X structure which act like ordinals. For linear arrays the positions are represented by non-zero integers - {0,1,2,3,4,5,6,7,8,....} and the size of the array is the number of positions. For a size n array, it goes from positions 0 to n-1. The base is position 0, and the prime is position 1. If the pilot is at position N then the prime block are positions 0 to N-1. Using BEAF, size 3 arrays grow at speed ω on the FGH. Size 4 arrays grow at speed ω2, size 5 arrays grow at speed ω3, and size n arrays grow at speed ωn-2. Size X arrays grow at speed ωω. X itself is equivalent to the ordinal ω.

Position X is the first entry of the second row, it passes up a size X array. The prime block of X is a size p array then go to next line - in other words: p spaces then "enter". Adding 1 is like pressing the space bar and adding X is like pressing enter. Position 5 is therefore 'space, space, space, space, space'. Position X is 'enter'. 1+X would be 'space enter' which will land on position X, so 1+X=X. Position X+1 is 'enter space' and would therefore be on the second space on the second row. We can let [X]p represent the prime block of X and therefore means "p spaces then enter". Following are various array positions, their 'space-enter' representation with their prime blocks:

0 - stay put - [0]p = {}

1 - space - [1]p = {0}

2 - space space - [2]p = {0,1}

3 - space space space - [3]p = {0,1,2}

4 - space space space space - [4]p = {0,1,2,3}

n - space space space space space ... space - [n]p = {0,1,2,3,4,5,...,n-1}

X - enter - [X]p = {0,1,2,3,4,5,...,p-1;}

X+1 - enter space - [X+1]p = {0,1,2,3,4,5,...,p-1;X}

X+2 - enter space space - [X+2]p = {0,1,2,3,4,5,...,p-1;X,X+1}

X+3 - enter space space space - [X+3]p = {0,1,2,3,4,5,...,p-1;X,X+1,X+2}

X2 - enter enter - [X2]p = {0,1,2,3,4,5,...,p-1;X,X+1,X+2,X+3,...,X+p-1;}

X2+1 - enter enter space - [X2+1]p = {0,1,2,3,4,5,...,p-1;X,X+1,X+2,X+3,...,X+p-1;X2}

X2+2 - enter enter space space - [X2+2]p = {0,1,2,3,4,5,...,p-1;X,X+1,X+2,X+3,...,X+p-1;X2,X2+1}

X3 - enter enter enter - [X3]p = {0,1,2,3,4,5,...,p-1;X,X+1,X+2,X+3,...,X+p-1;X2,X2+1,X2+2,...,X2+p-1;}

Before we go further, notice that the number of enters is the number multiplied to X and the number of spaces is the number added, so Xm+n = m enters followed by n spaces. '+' can also be thought of as the term "followed by", so X+5 means X followed by 5 spaces. Another thing to notice is that [X+n]p = [X]p+n - aka the prime block of X+n = the prime block of X followed by n spaces where the prime block of X is the first p spaces and then enter. Now lets look at [X2]p = [X+X]p = [X]p+[X]p = [X]p2. This means 'p entries then enter followed by p entries and then enter'. Next look at [Xm+n]p = [X]pm+n. This is 'p entries then enter' repeated m times followed by n entries. By the way Xm+n is equivalent to the ordinal ωm+n and an array of that size will grow at ωωm+n on the FGH.

We can also generalize these formulas to get the prime block function: [f(X)]p = f([X]p). What this means is that the prime block of an X structure (which is a function of X) is that same function of 'p spaces then enter' - so [X2]p = [X]p2 which is the square of 'p spaces then enter' which is 'p spaces then enter' times 'p spaces then enter' = 'p spaces then enter' p times and then enter2 (yes enter squared). So what does enter2 mean? - it means go to the next plane, in other words an enter of enters or "page break" a sort of "turn the page" which we can shorten to "page". So lets continue:

X2 - page

X2+1 - page space

X2+2 - page space space

X2+X - page enter

X2+X3+5 - page enter enter enter space space space space space

X22 - page page

X23 - page page page

X25+X7+3 - page page page page page enter enter enter enter enter enter enter space space space

Following are some X structures that lead to redundant results:

3+X5+X2 - space space space enter enter enter enter enter page which lands on X2

X2+2+X - page page space space enter which lands on X2+X

Notice how the order effects the result.

space enter page = page

space page enter = page enter

enter space page = page

enter page space = page space

page space enter = page enter

page enter space = page enter space

Only if we start with larger structures and add smaller ones afterwards do they become new structures, if we start with smaller structures and add larger ones, we might of well just omitted the earlier small structures.

The prime block of X2k+Xm+n = k pages of p lines with p spaces then go to next page - m lines of p spaces then enter - then n spaces. Next in line would be X3 which fills up the first 'book' or three dimensional space. [X3]p = [X]p3. The ordinal equivalent is ω3 and an array of this size reaches ωω3 on the FGH. The cube of enter could be called "book break" or "go to next book", we'll shorten this to "book". The prime block of X3 would be p pages of [X2]p then enter^3. Following are a few examples:

X3 = book

X3+3 = book space space space

X3+X2+4 = book enter enter space space space space

X3+X2+X+1 = book page enter space

X34 = book book book book

Enter passes up an endless array of spaces, page passes an endless arrays of enters, book passes an endless array of pages, and shelf passes an endless array of books where shelf break would be enter^4. We could continue this trend up the dimensions.

X4 = shelf, prime block will have p books of size [X3]p then enter^4.

X5 = gondola, prime block will have p shelves of size [X4]p then enter^5.

X6 = room, prime block will have p gondolas of size [X5]p then enter^6.

X7 = floor, prime block will have p rooms of size [X6]p then enter^7.

X8 = library, prime block will have p floors of size [X7]p then enter^8.

X9 = street, prime block will have p libraries of size [X8]p then enter^9.

X10 = block, prime block will have p streets of size [X9]p then enter^10.


XX = omniverse, where the prime block would be [XX]p - now we have a p dimensional block of size p then enter^X - enter^X?, this is enter^enter - uh oh.

We now pass an entire omniverse with a potentially infinite number of dimensions onto a second omniverse which also has a potentially infinite number of dimensions. Before this point, all of the structures looked a bit like polynomials. Position XX passes a dimensional space and is the size of dimensional arrays. BEAF at this level reaches ωωω on the FGH.

Up to Super Dimensional Arrays

There is a wrong way to add dimensions by keeping the added dimensions in the same omniverse - this is like adding more spaces to the same row without pressing enter. If we did this, the next dimensions would be X1+X = XX. So the trick is to go to the next omniverse aka enter^enter before adding more entries and more dimensions. What we want to approach next is XX+1. Lets go up the structures.

XX+n - omniverse then n spaces in next omniverse.

XX+X - omniverse then a full row in next omniverse. This is enterenter then enter.

XX+X5 - omniverse then a full 5-D block. This is enterenter gondola.

XX2 - two omniverses.

XX3 - three omniverses.

XXn - n omniverses.

XXX = XX+1 - this is a row of omniverses = enterenter space = enterenter times(not plus) enter. Where 'plus enter' means go to next row, 'times enter' means a row of the previous.

XX+1+k where k is anything up to an omniverse - this is a row of omniverses then k

XX+1+XX - this is a row of omniverses then an omniverse in the next potential row of omniverses.

XX+12 - two rows of omniverses.

XX+1n - n rows of omniverses.

XX+1X = XX+2 - a full plane of omniverses, this is enterenter space space = enterenter times enter2 = enterenter times page or a page worth of omniverses.

XX+3 - a realm of omniverses.

XX+n - an n-space of omniverses.

XX2 - an omniverse of omniverses. This is enterenter enter

XX3 - an omniverse of omniverse of omniverses.

XXn - an omniverse of omniverse of omniverse ..... of omniverses (n times) - YIKES, this sounds bad.

XX2 - an omniverse of omniverse of omniverse of omniverse of.........forever......, lets call this a 'biomniverse'. This is worse. This is enterpage. The prime block will be a pom of pom of pom of pom ....of poms p times where pom is the prime block of an omniverse followed by enterpage.

XX2+k where k can be any space less than a biomniverse - a biomniverse then k.

XX22 - two biomniverses.

XX2+1 - a row of biomniverses.

XX2+2 - a plane of biomniverses.

XX2+X - an omniverse of biomniverses. Prime block is a pom of piboms (prime block of biomniverse).

XX2+X2 - an omniverse of omniverse of biomniverses.

XX22 - a biomniverse of biomniverses.

XX25 - a biomniverse of biomniverse of biomniverse of biomniverse of biomniverses.

XX3 - a biomniverse of biomniverse of biomniverse of biomniverse of ..... forever - aka a 'triomniverse'

XX3+X - an omniverse of triomniverses.

XX3+X2 - a biomniverse of triomniverses.

XX32 - a triomniverse of triomniverses.

XX4 - a triomniverse of itself forever, this is a quadromniverse.

XX5 - a quadromniverse of itself forever, this is a quintomniverse.

XXX - continue through the series, sexomniverse, septomniverse, octomniverse, .... megomniverse, .... gigomniverse, ..... infomniverse. This is super dimensional space. BEAF at this level reaches ωωωω on the FGH. This is enterenterenter.

Notice something interesting here, if we add 1 to a structure, we get structure plus a single entry. If we multiply two to a structure, you get two structures. If you add one to the exponent, you get a row of structures. If you multiply 2 to the exponent, you get a structure of structures. If you add one to the second exponent, you get a structure to itself forever.

Up to Trimensional Arrays

Before we continue, lets introduce a friend of mine, his name is Jack. Jack loves to climb beanstalks - aka powertowers of X. He starts at ground zero, but needs to grow before he can climb to the next rung. He starts at plus 1 and needs to grow to the size of the beanstalk itself to reach 'times 2', he doesn't stop there, he needs to reach 'times X' before he climbs to the next rung and then he reduces back to 'plus 1', this is because 'times X on rung n' is the same as 'plus 1 on rung n+1'. Ground zero on the beanstalk is at height 0, the exponent is at height 1, and so on. The height of the beanstalk is where there is a value less than X, but greater than 0. For superdimensional space, we are at height 3, since XXX = XXX1. Lets watch Jack climb the beanstalk.

XXX+1 - Jack is on ground zero.

XXX+n - Jack grows a bit.

XXX+X - Jack gots a ways to go.

XXX+XX - Jack is getting bigger now.

XXX+XXX = XXX2 - Jack has finally made it to 'times 2'.

XXX3 - He's going for the home stretch.

XXXn - He's almost there.

XXXX = XXX+1 - YES, Jack made it to height 1, took him a while.

Now for Jack to grow, he needs help from his brother, for he can't grow until 'Jack 2' reaches him - observe.

XXX+1+1 - Jack 2 starts out.

XXX+1+X - Jack 2 grows.

XXX+1+XXX - Jack 2 is as big as Jack 1 was, but still has a ways to go to reach 'times 2'

XXX+1+XXX+1 = XXX+12 - Jack 2 has finally reached 'times 2'

XXX+1n - Jack 2 is going for the home stretch.

XXX+1X = XXX+2 - Jack 2 climbs to where Jack is and is absorbed into Jack which is now +2.

XXX+2+1 - Another Jack starts at the bottom, lets speed things up.

XXX+3 - That was a big jump.

XXX+n - A humongous jump.

XXX+X - Jack continues to grow. This is an omniverse of super dimensional spaces.

XXX+Xn - Jack's getting bigger.

XXX+XX = XXX2 - Jack is now at 'times 2'. This is a super dimensional space of super dimensional spaces.

XXXn - Jack is almost there.

XXXX = XXX+1 - Jack is at height 2 now. This is a super dimensional space of itself forever. YEEE AAAAaaaaa - mommy .

XXX+1+1 - Jack 2 on ground level.

XXX+1+1 - Jack 2 on level 1.

XXX+1+1+1 - How many brothers does Jack have again?

XXX+1+2 - Jack 3 absorbs into Jack 2 when it climbs.

XXX+12 - Jack 2 is at 'times 2' on level 1.

XXX+2 - Jack 2 absorbs into Jack on level 2.

XXX+n - Jack is growing while on level 2.

XXX2 - Jack is at 'times 2' on level 2. How big is this? let S be a super dimensional space, let S1 be an S of itself forever, S2 is an S1 of itself forever, S3 is an S2 of itself forever, continue with S4, S5,... S10000,.... forever. AAAAAAAA Mommy, he's scaring me again.

XXX3 - Jack grows even more. Let T be the space mentioned above, T1 is a T of itself forever, T2 is a great movie - wait - it is T1 of itself forever, T3 is T2 of itself forever, T4 is T3 of itself forever, T5,..T6,..T1000 (liquid terminator - wait), ...., T billion, ....forever - now we reach this space.

XXXX = XXX2 - Jack goes to level 3 raising the invisible 1 to a 2. How big is this space? remember how we did that thing starting from a space and doing a 'space of itself forever' to get the next space and continue through an infinite series of space types to get to some super space - do THAT an infinite number of times starting from S space.

XXX2+X - take the above space, call it V, make an infinite series of V spaces to get to this one where Vn+1 is a Vn of itself forever.

XXX22 - do an infinite series of infinite series of spaces past V

XXX3 - do an infinite series of infinite series of infinites series of spaces of itself forever to get to this one.

XXXX - Jack finally climbed to the top of this beanstalk reaching height 4, he is an invisible 1 now. How big is this space? it is an infinite series of infinite series of infinite series of infinite series of ...........forever - of spaces of itself forever. WHAT!!!!! - HA HA HA HAHAHAHAHAHAHA!!!!! We are at trimensional space now.

Up to Tetrational Arrays

Before we continue, lets think of another way to generate prime blocks. Consider the pilot which is at a position A, the pilot set is all positions that come before A. What we need to do is find out if some position B is n the prime block [A]p. Notice that the X structures we use to show positions in an array are tree-like strings of X, +, and integers with implied + and ^. We can refer to these integers as coefficients, these coefficients include the invisible 1's on top of a power tower of X's. Coeficients come in three flavors: small, bounded, and unbounded. Small ones are smaller than the prime, the other two are equal or larger than the prime. Bounded coefficients will go outside the pilot set if that coefficient grew to some massive size, unbounded coefficients will remain in the pilot set, if it grew without bounds. Lets consider an example:

let A = XXXX+67+XX3+XX2+89+X78 + XXX4+X54 and prime = 7

let B = XXXX+67+XX3+XX2+89+X78 + XXX4+X53

let C = XXXX+579+XX4+XX2+9989+X78 + XXX4+X54

let D = XXXX+23+XX+55+XXX4+X5

Lets check to see which of B,C, and D are in the prime block of A. First we need to see what sort of flavors the coefficients are in. Here they are again but color coded with some hidden 1's exposed.

let A = XXXX+67+XX3+XX2+89+X78 + XXX4+X54 and prime = 7

let B = XXXX1+67+XX3+XX2+89+X78 + XXX4+X53

let C = XXXX1+579+XX4+XX2+9889+X78 + XXX4+X54

let D = XXXX1+23+XX1+55+XXX4+X5

The red coefficients are of the small flavor since they are smaller than the prime which is 7. The green ones are the bounded sort, by raising them to a higher value, they will eventually escape the pilot set. For example, if the 7 in B grew to an 8 then B would come after A and would be outside the pilot set. The blue ones are unbounded, it doesn't matter how big they got, it would never get them outside the pilot set. For example, if the 79 in C grew to utter oblivion, the 5 right before it wouldn't reach 6, so this coefficient is unbounded. If there are any unbounded coefficients then it is outside the prime block. Therefore B and D are in the prime block and C is not. This rule works for anything within tetrational space arrays, when we go past tetration arrays, we also need to consider the heights of each coefficient, below is A where the heights are color coded, height 0 is black, 1 is purple, 2 is orange, 3 is yellow, and 4 is cyan.

let A = XXXX1+67+XX3+XX2+89+X78 + XXX14+X154

If the pilot was X^^X or higher, then the heights of coefficients would also matter, in A's case, the cyan 1 would be a problem for primes equal to or less than 4.

Lets continue the structures.

XXXX+1 - Jack on ground zero

XXXX2 - times 2

XXXX+1 - Jack climbs to level 1

XXXX2 - times 2 on level 1

XXXX+1 - Jack climbs to level 2

XXXX2 - times 2 on level 2

XXXX+1 - Jack climbs to level 3

XXXX2 - times 2 on level 3

XXXX2 - Jack turns invisible 1 to 2 on level 4

XXXXX - We now reach quadramensional space.

As Jack keeps climbing the beanstalks, he will cause the beanstalk to grow to greater heights.






XXXXXXXXXx*x*x*'''''''' = X^^n

At X^^X, we finally reach tetrational space. With BEAF, it reaches ε0 on the FGH, X^^X is also equivalent to ε0.

Up to X^^(X+1) Arrays

We have reached the limit of Peano arithmetic, so to get past Peano we need something with a little more kick, so lets pull out the 'electric guitar' - infinity barriers. These represents ground zero heights of the next infinity, we can think of the infinity barrier as pressing 'enter' on the power tower itself where 'space' on the power tower just adds another rung on the tower. The first height directly above the first barrier is at height X which passes all finite heights below the barrier. Height X has no predecessor, so it can't be pushed up from beneath in the same way as adding spaces before enter can't get things to happen after the enter. We can rewrite X^^X as X^^X|1 to show the infinity barrier, the 1 is at height X on this power tower.

One thought to get to X^^(X+1) would be X^(X^^X)|1, but does this actually work? What this does is push up the power tower by one unit of height, but anything above the barrier cant get pushed from underneith. X^(X^^X)|1 is just equal to X^^X|1. So X^(X^^X)|1 is not X^^(X+1) at all, but is only X^^(1+X) this is why we're stuck. In other words X^^X|1 = enter^^enter, X^^(1+X)|1 is just enter^^(space enter), X^X^X^X^X^(X^^X)|1 is enter^^(space space space space space enter). This will not get us anywhere, we are stuck going this way. What we want to reach is enter^^(enter space) which is X^^X|X. Many folks in the googology community has tried to define X^^(X+1), but these definitions don't quite capture the power of tetration past X. One thought is that X^^(X+1) is X^(X^^X+1), some might say it is at ε1. Others say ε1 reaches X^^(X2). In case you're wondering, ε1 is defined to be the limit of the inifinite sequence ε0+1, ωε0+1, ωωε0+1, ωωωε0+1,.... So what exactly is X^^(X+1) = X^^X|X, lets ask Jack, he knows how to climb a tower to increase the higher heights.

XXXXXXXXXx*x*x*''1 - this is X^^X|1 which we can shorten to T for tetration. Note that T=XT=XXT, etc.

XXXXXXXXXx*x*x*''1+1 - just like before, Jack starts on the bottom at height 0.

XXXXXXXXXx*x*x*''12 - Jack is at times 2, this is T2 or two tetration spaces.

XXXXXXXXXx*x*x*''1+1 - Jack climbs, this is actually TX. It is also XT+1 due to TX = XTX. This is a row of tetration spaces.

XXXXXXXXXx*x*x*''12 - Jack is times 2 on level 1. This is TT = XT2 which is a tetration space of tetration spaces.

XXXXXXXXXx*x*x*''1+1 - Jack's on level 2. This is TX = XXT+1. This is a tetration space of tetration space of tetration space of tetration space....forever.

XXXXXXXXXx*x*x*''12 - Jack on level 2 is at times 2. This is actually TT.

XXXXXXXXXx*x*x*''1+1 - Jack on level 3.

XXXXXXXXXx*x*x*''12 - Jack on level 3 at times 2.

XXXXXXXXXx*x*x*''1+1 - Jack on level 4.

XXXXXXXXXx*x*x*''12 - Jack on level 4 at times 2.

XXXXXXXXXx*x*x*''1+1 - level 5

XXXXXXXXXx*x*x*''1+1 - level 6

XXXXXXXXXx*x*x*''1+1 - level 7

XXXXXXXXXx*x*x*''1+1 - level 8

XXXXXXXXXx*x*x*''1+1 - level 9

XXXXXXXXXx*x*x*''1+1 - level 10

Jack will continue to climb to level 20, 30, 100, one billion, a gongulus, to infinity before he crosses that barrier to add 1 to the 1 on level X and then we get . . .

XXXXXXXXXx*x*x*''2 - This is actually the definition of ε1 and we are still not there, this is X^^X|2.

XXXXXXXXXx*x*x*''3 - Jack will need to climb this infinite beanstalk again to reach X^^X|3, this is ε2

XXXXXXXXXx*x*x*''4 - And again.

XXXXXXXXXx*x*x*''10 - and again and again and again and again and again and again to reach X^^X|10, this is ε9. Notice that the number above the barrier counts the number of times it is breached.

XXXXXXXXXx*x*x*''X - After Jack climbed the infinite beanstalk to reach Heaven (level X on the tower), not one time but an infinite number of times, we finally reach X^^X|X = X^^(X+1) aka enter^^(enter space). This is equivalent to εω which many in the googology community call ew in discust due to a dislike of the climbing method - strange.

Prime blocks will need to check all possible coefficients of all positions before the pilot to make sure there are no unbounded ones. Not only the coefficients, but their height's coefficients also. For example if a coefficient (a Jack) is at the height of 7 and the prime is 5, then check to see if this Jack can climb to height utter oblivion without going past the pilot. What does all this mean, well if Jack climbs to the prime height, he dies and goes to Heaven to get to any more of the prime block. The prime block of X^^X|X can't have Jack on level p or above, but can have him on level X. The X's in the power tower act as a backbone where Jacks can attach, think of them as empty postions in the tower if there is no Jack there, sort of like non active entrys on a row in an array and the Jacks activate them.

Up to X^^(X2) Arrays

Poor poor Jack, he needs to climb an infinite beanstalk to just add one to position X, but since postion X has an X, position X+1 is now an invisible 1. This beanstalk has a height of X+1. So beanstalks can have heights that are X structures? - we're doomed, well Jack is anyway.

XXXXXXXXXx*x*x*''X+1 - Jack climbed the infinite beanstalk again to Heaven, this is X^^X|X+1 which is equivalent to εω+1.

XXXXXXXXXx*x*x*''X2 - OK Jack get your arse back up that beanstalk, not once more, but an infinite number of climbs to change the +1 to a times 2 on level X, this is X^^X|X2 which is εω2.

XXXXXXXXXx*x*x*''X2 - Now position X+1 is 2 now, this is X^^X|X2 which means that the infinity barrier was breached X2 times.

XXXXXXXXXx*x*x*''XX - Now we finally reach X^^(X+2) = X^^X|XX which breached the barrier XX times. This is εωω.

XXXXXXXXXx*x*x*''XX+1 - One more breach to reach X^^X|XX+1.

XXXXXXXXXx*x*x*''XX+X - an infinite number of breaches more to reach X^^X|XX+X.

XXXXXXXXXx*x*x*''XX2 - lets add an infinite number of breaches an infinite number of times to get to X^^X|XX2, Jack is now at times 2 on level X.

XXXXXXXXXx*x*x*''XX+1 - Jack climbs to position X+1 to reach X^^X|XX+1.

XXXXXXXXXx*x*x*''XX2 - Jack at times 2 on level X+1 - this is X^^X|XX2.

XXXXXXXXXx*x*x*''XX2 - Jack climbs to level X+2 to add one to the invisible 1 - we are at X^^X|XX2. - OK Jack pick up the pace!

XXXXXXXXXx*x*x*''XXX - Jack climbs to position X+3 as an invisible 1, this is X^^(X+3) = X^^X|XXX, this is equivalent to εωωω.

As Jack climbs the beanstalk over and over again to reach new heights and cause the beanstalk to grow, we get closer and closer to a massive height that some googologist think is only ε1, that massive height of X2.

XXXXXXXXXx*x*x*''XXXXXXXXXx*x*x*''1 - this is X^^X|X^^X = X^^(X2). It is equal to εε0

More to come...

back to Big Number Central