I've been taking BEAF in an entirely different direction than multidimensional arrays. Much like those, these are technically just linear arrays of monstrous length (the number of entries itself being highly googological). Only these stay more or less linear themselves.

## The Basics

At the heart of CBEAF is a simple array, ⟨a,b⟩. It has a simple definition; ⟨a,b⟩ = {a,a,a...a,a,a} with b a's. When it has more than 2 arguments, it follows BEAF's rules. Functions of this kind are called "Class A" for brevity's sake; when they have two arguments, a and b, they define the function a level below it with b a's. A level above ⟨a,b⟩ is ｢a,b｣, and above that is ⸤a,b⸥. ⸤a,b⸥ can be generalized as :a,b:, and anything above it in level with multiples of colons (::a,b:: is ⸤a,a,a...a,a,a⸥ w/b a's, for example). These can all be generalized into integers, with BEAF at zero.

This infinite set, (0,1,2,3,4...) can be given a function {[a,b,c]}; a and b are the a and b of the defined function, and c defines the level. It covers levels 0 through ω and is itself superlevel 1; superlevel 0 is BEAF. {[a,b,c]} follows the "Class B" rules. When there are more than three arguments, it follows its own rule set. When its third argument is 1, no matter what is in the later arguments, it's equal to ⟨a,b⟩. When the fourth is 1, the function equals {[a,b,c,e^(e-1),f^(f-1)...]}. Everything is moved 1 closer to the front and taken to the power of itself, minus one. When any argument further than 4 equals one, the expression equals {[a,b,c,d]}. When none of this is true, it's broken down to {[a,b,{[a,b,c-1,d,e,f...]},d-1,e,f...]}. Got it? This is where I stopped at first, and it can give some wild numbers.

## Minor Interlude

First, mostly for my sake, I'll explain a second way of defining the levels (aka what I did in the Google document). In the doc, I set {[a,b,c,d...]} as the first level of super-compression, the soon-to-be explained /a,b/ as the second, //a,b// as the third, and so on. Levels of super-compression correspond to superlevels. Above these are levels of duper-compression, then levels of truper-compression, and so on, then levels of hyper-compression. These are really just naming differences.

## Going Deeper

We can continue further into the superlevels. Superlevel 2 is /a,b/, which is Class A, and is {[a,a,a...a,a,a]}, with b a's. Superlevel 3 is //a,b//. This continues on until superlevel ω, or duperlevel 1. Once again, duperlevel 0 is BEAF. Duperlevel 1 is <[a,b,c]>, a Class B expression that can call from every superlevel. Once again, an infinite set could be used to simplify this concept. Duperlevel 2 is \a,b\, or <[a,a,a...a,a,a]>, duperlevel 3 is \\a,b\\, or \a,a,a...a,a,a\ w/b a's, and so on, all the way up to duperlevel ω, or truperlevel 1. Truperlevel 1 is )[a,b,c](, and can call from every duperlevel. All of these superlevel variants can themselves be reduced into an even more compressed function, at hyperlevel 1. Hyperlevel 1 can call from every -perlevel below it; superlevel, duperlevel, truperlevel, etc. It's the first to have four arguments naturally.

## Hyperlevel 1

Hyperlevel 1 is ᄂa,b,c,dᄀ. A, b, and c are the a, b, and c of the called -perlevel, and d is the -perlevel being called. When d = 1, it's {[a,b,c]}, when d = 2, it's <[a,b,c]>, when d = 3, it's )[a,b,c](. When d = 4, however, it's instead noted as super4(a,b,c) (in the doc the 4 was subscript, I'll work on adding it here, too, perhaps). ᄂa,b,c,dᄀ can be generalized as superd(a,b,c). Hyperlevel 1 is a Class B-prime expression, with rules similar to a Class B expression. When c = 1, it's equal to ⟨a,b⟩, when e = 1, it's equal to ᄂa,b,c,d,f^(f-1),g^(g-1),h^(h-1)...ᄀ. When f = 1, it's equal to ᄂa,b,c,d,eᄀ, and when none of these are true, it's equal to ᄂa,b,c,ᄂa,b,c,d-1,e,f...ᄀ,e-1,f...ᄀ.

## Hyperlevel 2 and above

Hyperlevel 2 is ᄼa,bᄾ, and it is class A, so it's equal to ᄂa,a,a...a,a,aᄀ with b a's. Hyperlevels above 2 can be represented as ᄼ^(n-1)a,bᄾ^(n-1), where n is the hyperlevel. Hyperlevel ω, or Duhyperlevel 1, is ᄉa,b,cᄉ, and is Class B. Like usual, a and b are the a and b of the called hyperlevel, and c is the hyperlevel.

### Duhyperlevel 2+

Duhyperlevel 2 is ᅢa,bᅢ, which is equal to ᄉa,a,a...a,a,aᄉ with b a's, and it's Class A, as normal. Higher duhyperlevels are just ᅢ^(n-1)a,bᅢ^(n-1), where n is the duhyperlevel.

### Trehyperlevels and beyond

The limit of duhyperlevels is trehyperlevel 1, which is equal to ᆃa,b,cᆃ. It's Class B, and c is the duhyperlevel. Trehyperlevel 2 is ᆓa,bᆓ, which is once again a Class A. Beyond trehyperlevels, n-hyperlevel 1 is ᆷvna,b,cᆷvn, where v is signifies subscript and n is the n-hyperlevel. N-hyperlevel m is ᆸvn^m-1a,bᆸvn^m-1, which follows similar rules.

## Ultralevels

Ultralevels - oh boy. Ultralevel 1 is ᇰa,b,c,dᇰ, and is Class B-prime. Simple. Ultralevel 2 is class A, and is ᇴa,bᇴ, ultralevel n follows similar patterns to the duhyperlevels and such. Dultralevel 1 is ሀa,b,cሀ, and is Class B. Dultralevel 2 is ለa,bለ and dultralevel n is like ultralevel n. Trultralevel 1 is ሐa,b,cሐ, class B, n-ultralevel 1 follows patterns set by the n-hyperlevel 1's, and same goes for the n-ultralevel m's.

## Beyond the -levels

What's beyond the -levels? First, imagine that the "levels" are 0, the "superlevels" are 1, the "hyperlevels" are 2, the "ultralevels" are 3, and so on. This infinite series is covered by ቀa,b,c,dቀ, which is reminiscent of a Class B-prime, although d calls upon a certain -level 1. Levels beyond ultra- are represented using lev(a,b,c...)(n,m), where n is the -level, and m is the inner-level thing. Now what to call this level-beyond levels? Well, the metaphor being used for increasing between levels has always been similar to infinite lines. An infinite amount of infinite lines forms the plane. So, the first thing beyond the levels? The first plane. The defined array is technically 1-plane 1. 1-plane 1 can be used to transcend anything in the "Some Googolisms" section, by being able to transcend hyperlevels easily.

## Some Googolisms

It's high time for me to use this to make big numbers.

First up is the **bloopertri**. It's equal to ⟨3,3,3⟩, or (dupertri-1)pertri, where tritri is 1-pertri, dupertri is 2-pertri, and so on. The other name for it is dupertri-minun-pertri, but I like bloopertri better.

The second one actually uses bloopertri in its definition, and is equal to ｢3,3,3｣, or (bloopertri-1)bloopertri, where bloopertri is 1-bloopertri, dubloopertri is 2-bloopertri, and so on. Its name is **groopertri**, or alternatively, bloopertri-minun-bloopertri.

The third one uses groopertri in its definition, and is equal to /3,3,3/, or (groopertri-1)groopertri, with the same pattern as the above. Its name is **joppertri**, or dugroopertri-minun-groopertri.

The fourth is much of the similar, and is equal to //3,3,3//, or (joppertri-1)joppertri; same pattern once again. Its name is **fendatri**, or dujoppertri-minun-joppertri.

The fifth is a bit different, and is equal to \3,3,3\., or (dufendatri-1)fendatri. Its name is **lotsatri**, or dufendatri-minun-fendatri.

You might see a pattern here; the sixth is \\3,3,3\\, or (dulotsatri-1)lotsatri. Its name is **denatri**, or dulotsatri-minun-lotsatri.

Finally, for now, the seventh is only best representable using hyperlevel 1, and is equal to ᄂ3,2,2,2,2,2ᄀ. Its name is **powatri**, or en-tritri-fendatri.

There's a lot of room for name coining in this system.