Let's not lose too much time, and let's start!
*See "My Notations"
**Not coined by me
***Stands for "also known as"
Let's start with smaller numbers, like Goodol or Giddol, then we will go into larger numbers, like Gooftol or Fongulus.
Goodol group: This group includes goodol, goodolplex, giddol, gaddol, geedol, gidol, goddol, and gadol. First, we have goodol, which is equal to 10(1)100* or 1000. Second, we have goodolplex, which is equal to 10(1)(1)100* or 10000. Third, we have giddol or googol**, which is equal to 10(2)100* = 10^100. Fourth, we have gaddol or boogol**, which is equal to 10(3)100* = 10{100}10. Fifth, we have geedol or troogol**, which is equal to 10(4)100* or {10,10,10,100}. Sixth, we have gidol or quadroogol**, which is equal to 10(5)100* = {10,10,10,10,100}. Seventh, we have goddol or quintoogol**, which is equal to 10(6)100* or {10,10,10,10,10,100}. Eighth, and last, we have gadol or sextoogol** = 10(7)100* or {10,10,10,10,10,10,100}.
The rest of the numbers and groups are listed below. (Note: Some of the numbers are misordered due to the ill-definedness of some numbers, or other reasons.)
Monalong (alternatively Monalodue) = E1 = 10
Dialong (alternatively Dialodue) = E2 = 100
Trialong (alternatively Trialodue) = E3 = 1000
Tetralong (alternatively Tetralodue) = E4 = 10000
Pentalong (alternatively Pentalodue) = E5 = 100000
Hexalong (alternatively Hexalodue) = E6 = 1000000
Heptalong (alternatively Heptalodue) = E7 = 10000000
Octalong (alternatively Octalodue) = E8 = 100000000
Ennalong (alternatively Ennalodue) = E9 = 1000000000 (This continues with bigger greek prefixes.)
Grandol = D100#100* = 10^102
Greadol = D100#100#100*
Gigandol = D100##4*
Gorgedol = D100##5*
Guldol = D100##6*
Gaspdol = D100##7*
Goodondol = D100##10*
Goodonkosol = D100##20*
Goodontritol = D100##30*
Goodonpetol = D100##50*
Gudold = D100##100*
Graatadold = D100##100#100*
Greedold = D100##100##3*
Gruelohdold = D100##100##6*
Goodondold = D100##100##10*
Goodonkosold = D100##100##20*
Goodontritold = D100##100##30*
Goodonpetold = D100##100##50*
Gudolthra = D100##100##100* = D100###3*
Gudoltesla = D100###4*
Throodol = D100###100*
Tetroodol = D100####100*
Pentoodol = D100#####100*
Boodol (a.k.a.*** goobol**) = 10(100)10* = 100 & 10
Goddahlah = D100#^#100*
Goodahlah = D100#^#(D100)*
Dimenporal (a.k.a. gibbol**) = 10(1,2)100* = {10,100,2(1)2}**
Grandahlah = D100#^#100#100*
Dimenporalplex = 10(1)(1,2)100*
Graatadolddahlah = D100#^#100##100#100
Gotridahlah = D100#^#100#^#100* = D100#^#*#3
Goddolddahlah (alternatively Goddahlah-by-hyperion or Goddahlah-by-grandol) = D100#^#*#100
Goddahlah-by-deutero-hyperion (alternatively Goddahlah-by-gudold) = D100#^#*##100
Goddahlah-by-trito-hyperion (alternatively Goddahlah-by-throodol) = D100#^#*###100
Deutero-goddahlah = D100#^#*#^#100
Trito-goddahlah = D100#^##3
Griddahlah = D100#^##100
Kubidahlah = D100#^###100
Quartidahlah = D100#^####100
Goddathor = D100#^#^#100
Goddothol = D100(#^^4)100
Goddentol = D100(#^^10)100
Tethradthoth = D100#^^#100
Deutero-tethradthoth = D100#^^#*#^^#100
Tethradthoth ba'al (alternatively Tethridterator) = D100#^^#>#100
Dekastaculated-tethradthoth = D100#^^##10
Tethradcross = D100#^^##100
Tethradcubor = D100#^^###100
Tethraddekon = D100#^^(#^10)100
Tethradicoson = D100#^^(#^20)100
Tethradtope = D100#^^#^#100
Tethrarxiditri = D100#^^#^^#100
Tethrarxiditet = D100#^^#^^#^^#100
Tethrarxidipent = D100#^^#^^#^^#^^#100
Tethrarxidideck = D100(#^^^10)100
Tethrarxidicose = D100(#^^^20)100
Tethrarxidipenine = D100(#^^^50)100
Pentadicthulhum (alternatively Tethrarxidihect) = D100#^^^#100
Redmiral = {10,10(1)(1)10,10}
Tera-dimenporal = 10(2,2)100*
Peta-dimenporal = 10(3,2)100*
Biddol = 10(100,2)10*
Grand dimenporal = 10(1,3)100*
Baddol = 10(100,3)10*
Beedol = 10(100,4)10*
Bidol = 10(100,5)10*
Boddol = 10(100,6)10*
Badol = 10(100,7)10*
Troodol = 10(10,100)10*
Great dimenporal = 10(1,1,2)100*
Quadroodol = 10(10,10,100)10*
Miteral = 10(1-2)10*
Goorol (a.k.a. Oneoodol) = 10(1-2)100*
Boorol = 10(100-2)10*
Troorol = 10(10,100-2)10*
Goodtrol = 10(1-3)100*
Goodquadrol = 10(1-4)100*
Goodquintol = 10(1-5)100*
Godsol (To make it easier to read, I used "Godsol" instead of "Godssol".) = 10(1-100)10*
Modsol = 10(1-10,100)10*
Bodsol = 10(1-10,10,100)10*
Trodsol = 10(1-10,10,10,100)10*
Niteral = 10(1-1-2)10*
Durol = 10(1-1-2)100*
Dudtrol = 10(1-1-3)100*
Dodsol = 10(1-1-100)10*
Trurol = 10(1-1-1-2)10*
Twoodol = 10(1 \_2 2)10*
Grandol = D100#100*
Corboral = {10,100,1,2(1)2} (Reference: Corporawamba** (I call it "corboratrix") is equal to Corboral-sized array of tens, first member of the Corboral Group)
Cortroral = {10,100,1,2(1)3}
Cossoral = {10,10,1,2(1)100}
Gooftol = {10,100(1)1,2} (See Big Number Series: Gooftol Series)
Mossoral = {10,10,1,2(1)1,100}
Bossoral = {10,10,1,2(1)1,1,100}
Trossoral = {10,10,1,2(1)1,1,1,100}
Corbodal = {10,100,1,2(1)(1)2}
Cortrodal = {10,100,1,2(1)(1)3}
Cossodal = {10,10,1,2(1)(1)100}
Mossodal = {10,10,1,2(1)(1)1,100}
Corbotal = {10,100,1,2(1)(1)(1)2}
Corbottal = {10,100,1,2(1)(1)(1)(1)2}
Corboptal = {10,100,1,2(1)(1)(1)(1)(1)2}
Corboskal = {10,100,1,2(1)(1)(1)(1)(1)(1)2}
Corbospal = {10,100,1,2(1)(1)(1)(1)(1)(1)(1)2}
Corboxappol = {10,100,1,2(2)2}
Corbocolossol = {10,100,1,2(3)2}
Corboterossol = {10,100,1,2(4)2}
Corbopetossol = {10,100,1,2(5)2}
Corboectossol = {10,100,1,2(6)2}
Corbozettossol = {10,100,1,2(7)2}
Corboyotossol = {10,100,1,2(8)2}
Corboxenossol = {10,100,1,2(9)2}
Corbodimendecal (alternatively Corbodekolus) = {10,100,1,2(10)2}
Corboicosolus = {10,100,1,2(20)2}
Corbopenantolus = {10,100,1,2(50)2}
Corbohectolus = {10,100,1,2(100)2}
Corbogulus = {10,100,1,2(0,1)2}
Corbigulus = {10,100,1,2(0,2)2}
Corbagulus = {10,100,1,2(0,3)2}
Corbeegulus = {10,100,1,2(0,4)2}
Corbowgulus = {10,100,1,2(0,5)2}
Corbobulus = {10,100,1,2(0,0,1)2}
Corbotrulus = {10,100,1,2(0,0,0,1)2}
Corboplexulus = {10,100,1,2((1)1)2}
Corboduplexulus = {10,100,1,2((0,1)1)2}
Cobbatoth = {10,100,1,2((((((((((((((((((((((((((((((((((((((((((((((((((0,1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)2} (Last member of the Corboral Group)
Godgahlah-by-hyperion (a.k.a. godgoldgahlah**) = E100#^#*#100
Squatri = {3,3(2)2}
Squatet = {4,4(2)2}
Squapent = {5,5(2)2}
Squasept = {7,7(2)2}
Squadecal (a.k.a. xappol**) = {10,10(2)2}
Gozzol (a.k.a. coloxxol**) = {10,100(3)2}
Dimentet = {4,4(4)2}
Gorrol (a.k.a. teroxxol**) = {10,100(4)2}
Dimenpent = {5,5(5)2}
Gonnol (a.k.a. petoxxol**) = {10,100(5)2}
Gommol (a.k.a. ectoxxol**) = {10,100(6)2}
Dimensept = {7,7(7)2}
Goccol (a.k.a. zettoxxol**) = {10,100(7)2}
Little triakulus = 3^^7625597484987&3 = {3,3((((((((...((((((((1)1)1)1)1)1)1)1)...1)1)1)1)1)1)1)1)2} with 3812798742494 1's
Legitri (a.k.a. big boowa**) = {3,3,3/2}
Legitet = {4,4,4,4/2}
Legipent = {5,5,5,5,5/2}
Legisept = {7,7,7,7,7,7,7/2}
Legidecal = {10,10,10,10,10,10,10,10,10,10/2}
Legiattic goobol (a.k.a. the whopper**)= {10,100/2}
Grand whopper (a.k.a. legiattic gootrol) = {10,100/3}
Legiattic emperal = {10,10/10}
Whoppossol (a.k.a. legiattic gossol) = {10,10/100}
Legiattic hyperal = {10,10/10,10}
Legiattic diteral = {10,10//2}
Double whopper = {10,100//2}
Legiattic admiral = {10,10//10}
Legiattic redmiral = {10,10//10,10}
Whoppotriolus = {10,100///2}
Whoppotetrolus = {10,100////2}
Whoppopentolus = {10,100/////2}
Whoppohexolus = {10,100//////2}
Whoppoheptolus = {10,100///////2}
Whoppo-octolus = {10,100////////2}
Whoppoennolus = {10,100/////////2}
Whoppodekolus = {10,100//////////2}
Whoppoicosolus = {10,100////////////////////2}
Whoppopenantolus = {10,100//////////////////////////////////////////////////2}
Whoppogulus = {10,100(1)/2}
Whoppohectolus = {10,100////////////////////////////////////////////////////////////////////////////////////////////////////2}
Whoppochillolus = {10,100////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////2}
Reppohw eht ("The whopper" spelled backwards, a.k.a. farfarfarmoxxerpowdyer**) = {10,100\2}
Double reppohw = {10,100\\2}
Fongulus = {10,100((1)1)/2}
Bi-fongulus = {10,100(((1)1)1)/2}
Tri-fongulus = {10,100((((1)1)1)1)/2}
Quadra-fongulus = {10,100(((((1)1)1)1)1)/2}
Quinqua-fongulus = {10,100((((((1)1)1)1)1)1)/2}
Fomgulus = {L,X^^X}_100,100
Corbolegion (First member of Legiattic Corboral Group) = {10,100,1,2/2}
Cortrolegion = {10,100,1,2/3}
Cossolegion = {10,10,1,2/100}
Mossolegion = {10,10,1,2/1,100}
Bossolegion = {10,10,1,2/1,1,100}
Corboxappolegion = {10,100,1,2//2}
Corbocolossolegion = {10,100,1,2///2}
Corboterossolegion = {10,100,1,2////2}
Corbopetossolegion = {10,100,1,2/////2}
Corboectossolegion = {10,100,1,2//////2}
Corbozettossolegion = {10,100,1,2///////2}
Corboyottossolegion = {10,100,1,2////////2}
Corboxenossolegion = {10,100,1,2/////////2}
Corbodimendecalegion (alternatively corbodekolulegion) = {10,100,1,2//////////2}
Corboicosolulegion = {10,100,1,2////////////////////2}
Corbopenantolulegion = {10,100,1,2//////////////////////////////////////////////////2}
Corbohectolulegion = {10,100,1,2////////////////////////////////////////////////////////////////////////////////////////////////////2}
Corbogululegion = {10,100,1,2(1)/2}
Corbigululegion (alternatively corboxappodimenlegion) = {10,100,1,2(2)/2}
Corbocolossodimenlegion = {10,100,1,2(3)/2}
Corboterossodimenlegion = {10,100,1,2(4)/2}
Corbopetossodimenlegion = {10,100,1,2(5)/2}
Corboectossodimenlegion = {10,100,1,2(6)/2}
Corbozettossodimenlegion = {10,100,1,2(7)/2}
Corboyottossodimenlegion = {10,100,1,2(8)/2}
Corboxenossodimenlegion = {10,100,1,2(9)/2}
Corbodimendecadimenlegion (alternatively corbodekoludimenlegion) = {10,100,1,2(10)/2}
Corboicosoludimenlegion = {10,100,1,2(20)/2}
Corbopenantoludimenlegion = {10,100,1,2(50)/2}
Corbohectoludimenlegion = {10,100,1,2(100)/2}
Corboguludimenlegion = {10,100,1,2(0,1)/2}
Corbiguludimenlegion = {10,100,1,2(0,2)/2}
Corbaguludimenlegion = {10,100,1,2(0,3)/2}
Corbeeguludimenlegion = {10,100,1,2(0,4)/2}
Corbowguludimenlegion = {10,100,1,2(0,5)/2}
Corbobuludimenlegion = {10,100,1,2(0,0,1)/2}
Corbotruludimenlegion = {10,100,1,2(0,0,0,1)/2}
Corboplexuludimenlegion = {10,100,1,2((1)1)/2}
Corboduplexuludimenlegion = {10,100,1,2((0,1)1)/2}
Corbotriplexuludimenlegion = {10,100,1,2(((1)1)1)/2}
Cobbatodimenlegion = {10,100,1,2((((((((((((((((((((((((((((((((((((((((((((((((((0,1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)1)/2} (Last member of the Legiattic Corboral Group)
Leegol (a.k.a. big hoss**)= {L,100}_100,100
Ligol = {L2,100}_100,100
Bikuwaha (a.k.a. big bukuwaha**)= {L2,Bukuwaha}_100,100
Lugol = {L3,100}_100,100
Lagol = {L4,100}_100,100
SeveralLegend9998's Meameamealokkapoowa = {L100}_10,10 = {10,10 U 2} where U is the 100th L_gion mark. I call that mark "Loogion mark".
Meameameadulokkapoowa (a.k.a. meameamealokkabipoowa**) = {LL100,10}_10,10
Meameameatrilokkapoowa = {LLL100,10}_10,10
Here is the list of the numbers based on gooftol.
With subtraction suffixes:
Gooftolspeck = {10,90(1)1,2}
Gooftolcrumb = {10,95(1)1,2}
Gooftolchunk = {10,99(1)1,2}
Without a suffix or prefix:
Gooftol = {10,100(1)1,2}
With base prefixes:
Unary-gooftol = {1,100(1)1,2} (This will immediately return 1.)
Binary-gooftol (a.k.a. gooftolbit) = {2,100(1)1,2} (Trust me, this number is heavily unstable.)
Ternary-gooftol = {3,100(1)1,2}
Quaternary-gooftol = {4,100(1)1,2}
Quinary-gooftol = {5,100(1)1,2}
Senary-gooftol = {6,100(1)1,2}
Septenary-gooftol = {7,100(1)1,2}
Octal-gooftol (a.k.a. gooftolbyte) = {8,100(1)1,2}
Nonary-gooftol = {9,100(1)1,2}
If I'd put "Decimal-gooftol", then it'd just equal to gooftol itself. See gooftol above, or in Big Number Series.
Note: The rest of the numbers are bigger than the gooftol itself.
Undecimal-gooftol = {11,100(1)1,2}
Duodecimal-gooftol = {12,100(1)1,2}
Tredecimal-gooftol = {13,100(1)1,2}
Quattourdecimal-gooftol = {14,100(1)1,2}
Quindecimal-gooftol = {15,100(1)1,2}
Hexadecimal-gooftol = {16,100(1)1,2}
With addition suffixes:
Gooftolbunch = {10,101(1)1,2}
Gooftolcrowd = {10,105(1)1,2}
Gooftolswarm = {10,110(1)1,2}
With multiplication suffixes:
Gooftolding = {10,500(1)1,2}
Gooftolchime = {10,1000(1)1,2}
Gooftolbell = {10,5000(1)1,2}
Gooftoltoll = {10,10000(1)1,2}
Gooftolgong = {10,{10,5}(1)1,2}
Gooftolbong = {10,{10,8}(1)1,2}
Gooftolthrong = {10,{10,11}(1)1,2}
Gooftolgandingan = {10,{10,14}(1)1,2}
With the suffix "-plex":
Gooftolplex = {10,{10,100(1)1,2}(1)1,2}
Gooftolduplex = {10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}
Gooftoltriplex = {10,{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}(1)1,2}
Gooftolquadriplex = {10,{10,{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}(1)1,2}(1)1,2}
Gooftolquintiplex = {10,{10,{10,{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}(1)1,2}(1)1,2}(1)1,2}
Gooftolsextiplex = {10,{10,{10,{10,{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}(1)1,2}(1)1,2}(1)1,2}(1)1,2}
Gooftolseptiplex = {10,Gooftolsextiplex(1)1,2}
Gooftoloctiplex = {10,Gooftolseptiplex(1)1,2}
Gooftolnoniplex = {10,Gooftoloctiplex(1)1,2}
Gooftoldeciplex = {10,Gooftolnoniplex(1)1,2}
Gooftolcentiplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 101 tens in total
Gooftolkiloplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 1.001 tens in total
Gooftolmegaplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 1.000.001 tens in total
Gooftolgigaplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 10^9+1 tens in total
Gooftolteraplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 10^12+1 tens in total
Gooftolpetaplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 10^15+1 tens in total
Gooftolexaplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 10^18+1 tens in total
Gooftolzettaplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 10^21+1 tens in total
Gooftolyottaplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 10^24+1 tens in total
Gooftolxennaplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 10^27+1 tens in total
Gooftolvekaplex = {10,{10,{10,...{10,{10,{10,100(1)1,2}(1)1,2}(1)1,2}...(1)1,2}(1)1,2}(1)1,2} with 10^30+1 tens in total
Hyperdimensional Array Notation (HDAN)
My first and strongest array notation. Unfortunately, It's too hard to give the main definitions of it (And it'd be too complicated if I did so), but I can give "enough" amount of tips for you guys to understand.
If there are no +'s, then it's in the "Not Important" group.
If there's 1 "+", then it's in the "Minimally Important" group.
If there are 2 +'s, then it's in the "Almost Important" group.
If there are 3 +'s, then it's in the "Important" group.
If there are 4 +'s, then it's in the "Very Important" group.
If there are 5 +'s, then it's in the "Extremely Important" group.
a#(1)(1)(1)...(1)(1)(1)b with c (1)'s = a(1)(1)(1)...(1)(1)(1)ab with c-1 (1)'s, where # indicates the rest of the expression
a(2)b = a^b
a(1)(1)(1)...(1)(1)(1)(2)b with c (1)'s = a^(a*a*a*a*a*...*a*a*a*a*a*b) with c a*'s
a(b)(b)(b)...(b)(b)(b)d with c (b)'s = {a,a,a,a,a,...a,a,a,a,a,d,c} with b-1 a's
a(1,b)c = a(a(1,b)d,b-1)a where a(b,c)1 = a, a(#,1)b = a(#)b and d = c-1
a(b,c)d = a(b-1,c)(b-1,c)(b-1,c)...(b-1,c)(b-1,c)(b-1,c)a with d (b-1,c)'s
I will add some more later.
Dimendal Array Notation (DAN)
DAN is similar to BEAF, except that it uses different brackets and an "array of operator type". Here are the elements for an expression in DAN.
Base (b) is the first entry in the array. If the base doesn't exist, then the array returns 0.
Prime (p) is the second entry in the array. If the prime doesn't exist, or if it's equal to 1, then the array returns b.
Pilot (pl) is the first non-1 entry after prime. If the pilot doesn't exist, then the array returns b^p.
Copilot (cpl) is the entry that immediately exists before pl. The copilot doesn't exist if pl is the first entry in the row that pl is in.
Passenger (ps) is an entry that comes before cpl.
Airplane (a) is the whole array.
Here are some of the main definitions of DAN.
Base Rule: With one or two entries (Note that the actual bracket type is taller. I just can't put it.), <b> = b, <b,p> = b^p.
Termination Rule: Last entry is 1, <#,1> = <#> where # means the unchanged remainder of the array.
Collapsion Rule: p = 1, <b,1,#> = b.
Recursion Rule: Rules 1~3 don't apply; cpl becomes a, second entry inside cpl decreases by 1, pl decreases by 1, each ps becomes b, and the rest of the array remains unchanged.
Here are some examples of evaluating.
<6,7,8,3,1,5,8,9,3,2,7,10,4,2,5> = <6,<6,6,8,3,1,5,8,9,3,2,7,10,4,2,5>,7,3,1,5,8,9,3,2,7,10,4,2,5>
<64,1,7,2,3> = 64
<6,11,1,1,4,2,2> = <6,6,6,<6,10,1,1,4,2,2>,3,2,2>
<3,3,3,1> = <3,3,3> = tritri
<5,6> = 5^6
The definitions of Linear C Function goes as follows:
With one entry after C, nCm = nm
Last entry is 1, nC#/1 = nC# where # denotes the unchanged remainder of the expression
First entry is >1, nCm/# = ((n(n+1))/2)C(m-1)/#
Main input (the entry that comes before C) is 1, 1C# = 1
Otherwise, nC1/1/1/.../1/1/1/m/# = nCn/n/n/.../n/n/((n-1)C1/1/1/.../1/1/()/m/#)/(m-1)/#
Here is an example of evaluating.
2C2/1/3
= 3C1/1/3 via rule 3
= 3C3/(2C1/1/3)/2 via rule 5
= 3C3/(2C2/(1C1/1/3)/2)/2 via rule 5
= 3C3/(2C2/1/2)/2 via rule 4
= 3C3/(3C1/1/2)/2 via rule 3
= 3C3/(3C3/(2C1/1/2)/1)/2 via rule 5
= 3C3/(3C3/(2C1/1/2))/2 via rule 2
= 3C3/(3C3/(2C2/(1C1/1/2)/1))/2 via rule 5
= 3C3/(3C3/(2C2/(1C1/1/2))/2)/2 via rule 2
= 3C3/(3C3/(2C2/1/2)/2 via rule 4
= 3C3/(3C3/(3C1/1/2)/2)/2 via rule 3
Down-dimensional Array Notation (DDAN)
Down-dimensional Array Notation (DDAN) is similar to HDAN (See Hyperdimensional Array Notation), except that it's weaker. Why? Because weaker notations/functions are more accurate.
This notation is currently separated into 11 parts (By the way, when linking it with DDAN, you can replace "AN" with "DDAN" with those parts):
Linear Array Notation (LAN) uses one entry inside square brackets (called "dimension keys"). The growth rate is approximated with w+1 in the fast-growing hierarchy, where w denotes omega.
Extended Array Notation (ExAN) uses multiple entries inside dimension keys. The growth rate is approximated with w^w in the fast-growing hierarchy.
Dimensional Array Notation (DAN (Not to be confused with Dimendal Array Notation)) uses dimensional separators inside dimension keys. ("Dimensional Down-dimensional Array Notation" sounds redundant, but it isn't.) The growth rate is approximated with w^w^w in the fast-growing hierarchy.
Extended Dimensional Array Notation (ExDAN) uses multiple entries inside dimensional separators inside dimension keys.
Nested Dimensional Array Notation (NDAN) uses nested dimensional separators inside dimension keys.
First-order Array Notation (FoAN) uses subscripts for the dimension keys.
Extended First-order Array Notation (ExFoAN) uses multiple entries in the subscripts of the dimension keys.
Dimensional First-order Array Notation (DFoAN) uses dimensional separators in the subscripts of the dimension keys.
Extended Dimensional First-order Array Notation (ExDFoAN) uses multiple entries inside dimensional separators in the subscripts of the dimension keys.
Nested Dimensional First-order Array Notation (NDFoAN) uses nested dimensional separators in the subscripts of the dimension keys.
Second-order Array Notation (SoAN) uses backslashes after dimension keys.
Third-order Array Notation (ToAN) uses subscripts for the open brackets of the dimension keys.
High-order Array Notation (HoAN) uses superscripts for the close brackets of the dimension keys.
Now let's get into the first part, which is LAN, and here are some of the elements:
Base (b) is the leftmost "entry" in the expression.
Prime (p) is the rightmost "entry" in the expression.
Dimension key (d) is a pair of square brackets. This includes the content inside square brackets, their subscripts, the backslashes attached to them, etc.
Note: Excluding d, all uncapital letters represent a positive integer.
Here are the definitions of LAN:
With one d, b[1]p = b^p, b[n]1 = b.
p=1, b#[n]1 = b#b where # represents the rest of the d's.
Last d is 1, b#[1]p = b#(b^p)
Otherwise, b#[n]p = b#[n-1][n](p-1)
Here is an example.
3[3]3
=3[2][3]2 via rule 4
=3[2][2][3]1 via rule 4
=3[2][2]3 via rule 2
=3[2][1][2]2 via rule 4
=3[2][1][1][2]1 via rule 4
=3[2][1][1]3 via rule 2
=3[2][1]27 via rule 3
=3[2]7625597484987 via rule 3
=3[1][2]7625597484986 via rule 4
=3[1][1][2]7625597484985 via rule 4
and so on...
Now, time for the definitions of ExAN:
If there's one d, b[1]p = b^p, b[@]1 = b where @ indicates the rest of the d.
p=1, b#[@]1 = b#b
Last entry in the last d is 1, b#[@,1]p = b#[@]p
Last d contains only 1, b#[1]p = b#(b^p)
First entry in the last d is greater than 1, b#[n,@]p = b#[n-1,@][n,@](p-1)
Otherwise, b#[1,1,1,...1,1,1,n,@]p = b#[b,b,b,...b,b,b#[1,1,1,...1,1,n,@](p-1),n-1,@]b
Here is an example.
3[1,1,3]3
=3[3,3[1,1,3]2,2]3 via rule 6
=3[3,3[3,3[1,1,3]1,3]3,2]3 via rule 6
=3[3,3[3,3,2]3,2]3 via rule 1
=3[3,3[2,3,2][3,3,2]2,2]3 via rule 5
and so on...
Before giving the definitions of DAN, let me introduce a new notation called Angle Bracket Notation (AGN). (by the way, all uncapital letters (excluding d) represent a positive integer.)
If c=0, we have a<0>b = a. (Note that the actual bracket is taller.)
If b=1, we have a<c>1 = a.
Otherwise, a<c>b = a<c-1>b{c}a<c-1>b{c}a<c-1>b{c}...{c}a<c-1>b{c}a<c-1>b{c}a<c-1>b with b a's. (Tip: {1} is equivalent to a comma)
Note: b{c}a is not b^^^...(c arrows)...^^^a, it's just a dimensional separator.
Another note: When you see an expression in AGN in an expression in DDAN, you always evaluate AGN first.
Now, here are the definitions of DAN:
With one d, b[1]p = b^p, b[@]1 = b.
p=1, b#[@]1 = b#b
The last entry in the last d is 1, b[@%1]p = b[@]p where % is any separator, which may or may not be dimensional. (Also, if m<n, b[@{m}1{n}@*]p = b[@{n}@*]p)
The last d contains only 1, b#[1]p = b#(b^p).
The first entry in the last d is greater than 1, b#[n%@]p = b#[n-1%@][n%@](p-1)
The first entry in the first row in the last d is 1, and there exists a non-1 entry in the same row after it, b#[1,1,1,...1,1,1,n%@]p =
b#[b,b,b,...b,b,b#[1,1,1,...1,1,1,n%@](p-1),n-1%@]b
The first entry in any non-first row in the last d is 1, and there exists a non-1 entry in the same row after it,
b#[1{m_1}1{m_2}1...1{m_x}1,1,1,...1,1,1,a%@]p =
b#[b<(m_1)-1>p{m_1}b<(m_2)-1>p{m_2}...b<(m_x)-1>p{m_x}1,1,1,...1,1,b#[1{m_1}1{m_2}1...1{m_x}1,1,1,...1,1,1,a%@](p-1),a-1%@]b
Otherwise, b#[1{m_1}1{m_2}1...1{m_x}a%@]p = b#[b<(m_1)-1>p{m_1}b<(m_2)-1>p{m_2}...b<(m_x)-1>p{m_x}a-1%@]b
Here is an example.
3[2{3}4]3
=3[1{3}4][2{3}4]2 via rule 5
=3[1{3}4][1{3}4][2{3}4]1 via rule 5
=3[1{3}4][1{3}4]3 via rule 2
=3[1{3}4][3<2>3{3}3]3 via rule 8
=3[1{3}4][3<1>3{2}3<1>3{2}3<1>3{3}3]3 via rule 3 in AGN
=3[1{3}4][3<1>3{2}3<1>3{2}3<0>3,3<0>3,3<0>3{3}3]3 via rule 3 in AGN, referring to the tip.
=3[1{3}4][3<1>3{2}3<1>3{2}3,3,3{3}3]3 via rule 1 in AGN
=3[1{3}4][3<1>3{2}3,3,3{2}3,3,3{3}3]3 via rules 1 and 3 in AGN
=3[1{3}4][3,3,3{2}3,3,3{2}3,3,3{3}3]3 via rules 1 and 3 in AGN
and so on...
Extended Dimensional Array Notation (ExDAN)
This one allows separators to have multiple entries. For this to come true,
Extensible-D System (ExD) is composed of 2 (currently) parts: D#, and xD#. You will find out what these "symbols" mean.
Hyper-D Notation (D# for short) is a notation referring to HDAN, except that it's formally defined. Here are the definitions:
Base rule: Without hyperions (#'s): D[x]y = xy, D(x) = 10x (since the default base is 10, D[10]x = D(x) or Dx)
Termination rule: Last entry is 1: D@1 = D@ where @ indicates the rest of the expression
Recursion rule: Rules 1 or 2 don't apply: D@a#b = D@(D@a#(b-1))
Next, we have Extended Hyper-D Notation (xD# for short). Here, rule 3 becomes rule 4, and new rule 3 is created.
3. Expansion rule: Last separator (a single # or a consecutive set of #'s) has multiple #'s, D@a[b]c =D@a[b-1]a[b](c-1) where [b] is b consecutive #'s, which is equal to #^b
See "Big Number Series" for the numbers coined on ExD.
Fixing Almighty Array Notation
See Almighty Array Notation.
When we have an expression like a*(3,1,5,6,8,3,5,1,2), both the prime rule and recursion rule are applicable.
When we apply the prime rule, a*(3,1,5,6,8,3,5,1,2) is equal to a*(3), and that's okay.
When we apply the recursion rule, a*(3,1,5,6,8,3,5,1,2) is equal to a*(3,a*(3,0,5,6,8,3,5,1,2),4,6,8,3,5,1,2), which is ill-formed because the inner array contains a 0.
So I'll make it impossible to apply the recursion rule when the second entry is 1 and the prime rule when the second entry is greater than 1.
When we have an expression like a*(3,2,1,1,1,1,1,1,3), both recursion rules (for the second entry or non-second entry) are possible.
When we apply the one for the second entry, a*(3,2,1,1,1,1,1,1,3) is equal to a*(3,a*(3,1,1,1,1,1,1,1,3),0,1,1,1,1,1,3) which is ill-formed because the outer array contains a 0.
To fix this, I will deny applying the recursion rule for the second entry when the third entry is 1.
My googological ruler goes like this:
Class -3: Imaginary numbers
Class -2: Uncountable ordinals
Class -1: Ill-defined numbers
Class 0: Negative numbers
Class 1: 0 to 1.000.000
Class 2: 1.000.000 to F3(10)
Class 3: F3(10) to F4(10)
Class 4: F4(10) to Fw(10) (w is omega)
Class 5: Fw(10) to Fw^2(F3(10))
Class 5.1 (Sub-class): Fw(10) to Fw(F3(10))
Class 5.2: Fw(F3(10)) to Fw+1(F3(10))
Class 5.3: Fw+1(F3(10)) to Fw+2(F3(10))
Class 5.4: Fw+2(F3(10)) to Fw2(F3(10))
Class 5.5: Fw2(F3(10)) to Fw3(F3(10))
Class 5.6: Fw3(F3(10)) to Fw^2(F3(10))
Class 6: Fw^2(F3(10)) to Fw^w(F3(10))
Class 6.1: Fw^2(F3(10)) to Fw^3(F3(10))
Class 6.2: Fw^3(F3(10)) to Fw^w(F3(10))
Class 7: Fw^w(F3(10)) to Fw^w^2(F3(10))
Class 8: Fw^w^2(F3(10)) to Fw^w^w(F3(10))
Class 8.1: Fw^w^2(F3(10)) to Fw^w^3(F3(10))
Class 8.2: Fw^w^3(F3(10)) to Fw^w^w(F3(10))
Class 9: Fw^w^w(F3(10)) to Fw^w^w^w(F3(10))
Class 9.1: Fw^w^w(F3(10)) to Fw^w^w^2(F3(10))
Class 9.2: Fw^w^w^2(F3(10)) to Fw^w^w^w(F3(10))
Class 9.2.1: Fw^w^w^2(F3(10)) to Fw^w^w^3(F3(10))
Class 9.2.2: Fw^w^w^3(F3(10)) to Fw^w^w^w(F3(10))
Class 10: Fw^w^w^w(F3(10)) = Fw^^4(F3(10)) to F E0(F3(10)) (En is epsilon-n (e.g. E0 is epsilon-nought))
Class 10.1: Fw^^4(F3(10)) to Fw^^10(F3(10))
Class 10.2: Fw^^10(F3(10)) to F E0(F3(10))
Class 11: F E0(F3(10)) to F EE0(F3(10))
Class 12: F EE0(F3(10)) to F Z0(F3(10)) (Zn is zeta-n (e.g. Z0 is zeta-nought))
Class 13: F Z0(F3(10)) to F H0(F3(10)) (Hn is eta-n (e.g. H0 is eta-nought))
Class 14: F H0(F3(10)) to F P(w,0)(F3(10)) (P is phi)
Class 15: F P(w,0)(F3(10)) to F G0(F3(10)) (Gn is gamma-n (e.g. G0 is gamma-nought))
Class 16: F G0(F3(10)) to F P(w,0,0,0)(F3(10))
Class 17: F P(1,0,0,0)(F3(10)) to F T(W^w)(F3(10)) (T is theta, W is CAPITAL omega)
Class 18: F T(W^w)(F3(10)) to F T(W^W)(F3(10))
Class 19: F T(W^W)(F3(10)) to F S(E(W+1))(F3(10)) (S is psi)
Class 20: F S(E(W+1))(F3(10)) to Infinity
Class 21: Infinity to w
Class 22: w to w^2
Class 22: w^2 to w^w
Class 23: w^w to w^w^w
Class 24: w^w^w to E0
Class 25: E0 to E1
Class 26: E1 to Ew
Class 27: Ew to E(w^w)
Class 28: E(w^w) to EE0
Class 29: EE0 to Z0
Class 30: Z0 to H0
Class 31: H0 to P(w,0)
Class 32: P(w,0) to G0
Class 33: G0 to P(1,0,0,0)
Class 34: P(1,0,0,0) to T(W^w)
Class 35: T(W^w) to T(W^W)
Class 36: T(W^W) to the limit of countable ordinals
This is the end of this series, but make sure to check out my new googology series!