User talk:SamSim/Sandbox
From Wikipedia, the free encyclopedia
Jonathan Bowers' "Exploding Array Function" is a highly recursive system of notation capable of expressing numbers unimaginably larger than anything found in Knuth's up-arrow notation, Conway's chained arrow notation or Steinhaus-Moser notation.
Contents |
[edit] Layout
[edit] Definitions
- A Bowers array, A, is a finite-dimensional array of entries. The default value of an entry in an array is 1. Trailing ones can always be safely ignored - or, conversely, an array which is too small for whatever reason can always be padded out with additional ones to any size necessary. Note that these entries appear in a natural order, one after the other. Any array can be represented in-line, regardless of dimension or size, using certain notation for "new row" and "new plane" etc., which will be described below.
- The first entry of an array is the base, b. An array always evaluates to a (usually very, very, very large) power of this base.
- The second entry of an array is the prime entry, p. If an array has only the base on the top row, then we extend the top row to {b,1}, giving p = 1.
- Following this (in order, as seen above), the array will contain a sequence of zero or more ones, followed by the first non-1 entry, which is called the pilot, d. Note that the pilot may be simply the third entry in the array; alternatively, it may be on a different row, plane or dimension. If there is no pilot (that is, nothing follows but ones) then the array evaluates to bp.
- The entry immediately before the pilot is the copilot. If the pilot is the third entry, the copilot and the prime entry are the same entry. If the pilot is the first entry on a row, there is no copilot at all. The rest of the time, the copilot is equal to 1.
- A structure is a complete row, plane, 3-space, 4-space etc. making up part of the array. Things like "columns" do not count as structures; a structure exists as a single continuous block when the array's entries are written out in order. Note that a zero-dimensional structure is simply an entry.
- A previous structure is any structure which comes wholly before the pilot. This means entries before the pilot but on the same row, rows coming before the pilot's row but in the same plane, planes coming before the pilot's plane but in the same realm, and so on.
- The prime block of a structure (where the structure has n dimensions) is a pn block of entries from that structure. The prime block of an entry is the entry itself, the prime block of a row is the first p entries on that row, the prime block of a plane is a p-by-p square in the top left corner of that plane, and so on. Note that the prime block of a structure may be bigger than the structure itself if the structure is sparsely populated, or empty.
- The prime block of all previous structures is the union of the prime blocks of every previous structure.
- The airplane is the union of the pilot, all previous entries, and the prime block of all previous structures. Note that this will always include the copilot, if there is one, as well as the prime entry and the base.
- The passengers are all the entries in the airplane except the pilot and the copilot. This will always include the prime entry and the base.
[edit] Rules for evaluating an array
Let v(A) be the value expressed by an array once fully evaluated.
- As mentioned above, if p = 1 then v(A) = b, regardless of what comes after p.
- As mentioned above, if there is no pilot, then v(A) = bp.
- Otherwise, the prime entry is greater than 1, and the pilot exists. In this case:
- Decrement the pilot
- Let all passengers take on the base value. Note that the prime entry is among the passengers, and the base value remains unchanged.
- If the copilot exists, replace it with v(A'), where A' is the original array, except with the prime entry decremented
- Leave the remainder of array unchanged
Then evaluate the new array instead.
[edit] Standard form for in-line arrays
Let (0) be used to represent "next entry" in the same way that (1) represents "next row" and so on.
Let (a)k be used as shorthand for .
Now observe that every array mentioned so far can be represented inline in the following standard form:
Where
- b is the base
- p is the prime entry
- (X) is a series of instructions for reaching the row of the pilot, whatever dimension it may be in
- k0 is the number of terms before the pilot on the row on which it appears
is the pilot
is the remainder of the array.
(X) can be put in the following standard form:
, where any of the k may be zero.
You will see that each element of (X) defines a previous structure, and that each previous structure defines a prime block. Thus it is (X) which dictates exactly what gets filled up with bs when we take our first step in evaluating A. b and p act as parameters for this operation.
- (1) in A gets replaced with
in the new array, where there are p bs in a row.
- (2) in A gets replaced with (1)p(2) where each (1) is treated as above.
- (3) is replaced with (2)p(3) where each (2) is treated as above.
- Generally, (n) is replaced with (n − 1)p(n) where each (n) is treated as above.
For example:
Here, b = 8 and p = 2. So (3) becomes (2)(2)(3) becomes (1)(1)(2)(1)(1)(2)(3) becomes 8,8,(1)8,8,(1)(2)8,8,(1)8,8,(1)(2)(3), which is then simplified to 8,8(1)8,8(2)8,8(1)8,8(3), so:
Here, b = 8 and p = 8. So (1) becomes 8,8,8,8,8,8,8,8(1), so:
Get all that? Let's go for some examples.
[edit] Linear arrays
Let be a variable representing any sequence of entries.
- {b} = {b,1} = b
.
.
For example, with three-entry arrays:
, identical in form to Knuth's up-arrow notation.
Moving on to another pertinent example found with the smallest four-entry arrays:
Therefore {3,64,1,2} < Graham's number < {3,65,1,2}.
Already, then, we are moving beyond the largest useful numbers.
Named numbers in the "linear array" range include:
Name | Value |
---|---|
corporal | {10,100,1,2} |
corporalplex | {10,corporal,1,2} |
boogol | {10,10,100} |
boogolplex | {10,10,boogol} |
biggol | {10,10,100,2} |
biggolplex | {10,10,biggol,2} |
baggol | {10,10,100,3} |
baggolplex | {10,10,baggol,3} |
beegol | {10,10,100,4} |
beegolplex | {10,10,beegol,4} |
bigol | {10,10,100,5} |
boggol | {10,10,100,6} |
bagol | {10,10,100,7} |
troogol | {10,10,10,100} |
troogolplex | {10,10,10,troogol} |
triggol | {10,10,10,100,2} |
triggolplex | {10,10,10,triggol,2} |
traggol | {10,10,10,100,3} |
traggolplex | {10,10,10,traggol,3} |
treegol | {10,10,10,100,4} |
trigol | {10,10,10,100,5} |
troggol | {10,10,10,100,6} |
tragol | {10,10,10,100,7} |
quadroogol | {10,10,10,10,100} |
quadroogolplex | {10,10,10,10,quadroogol} |
quadriggol | {10,10,10,10,100,2} |
quadriggolplex | {10,10,10,10,quadriggol,2} |
quadraggol | {10,10,10,10,100,3} |
quadreegol | {10,10,10,10,100,4} |
quadrigol | {10,10,10,10,100,5} |
quadroggol | {10,10,10,10,100,6} |
quadragol | {10,10,10,10,100,7} |
quintoogol | {10,10,10,10,10,100} |
quintoogolplex | {10,10,10,10,10,quintoogol} |
quintiggol | {10,10,10,10,10,100,2} |
quintaggol | {10,10,10,10,10,100,3} |
quinteegol | {10,10,10,10,10,100,4} |
quintigol | {10,10,10,10,10,100,5} |
sextoogol | {10,10,10,10,10,10,100} |
septoogol | {10,10,10,10,10,10,10,100} |
octoogol | {10,10,10,10,10,10,10,10,100} |
tritri | {3,3,3} |
tetratri | {3,3,3,3} |
pentatri | {3,3,3,3,3} |
hexatri | {3,3,3,3,3,3} |
heptatri | {3,3,3,3,3,3,3} |
ultatri | ![]() |
supertet | {4,4,4,4} |
superpent | {5,5,5,5,5} |
superhex | {6,6,6,6,6,6} |
supersept | {7,7,7,7,7,7,7} |
superoct | {8,8,8,8,8,8,8,8} |
superenn | {9,9,9,9,9,9,9,9,9} |
iteral (also called superdec) | {10,10,10,10,10,10,10,10,10,10} |
tridecal | {10,10,10} |
grand tridecal | {10,10,10,2} |
general (also called tetradecal) | {10,10,10,10} |
generalplex | {10,10,10,general} |
pentadecal | {10,10,10,10,10} |
pentadecalplex | {10,10,10,10,pentadecal} |
hexadecal | {10,10,10,10,10,10} |
hexadecalplex | {10,10,10,10,10,hexadecal} |
heptadecal | {10,10,10,10,10,10,10} |
octadecal | {10,10,10,10,10,10,10,10} |
ennadecal | {10,10,10,10,10,10,10,10,10} |
iteral (also called duperdecal) | ![]() |
iteralplex | ![]() |
As we can see, these arrays are getting longer and longer. Can we find a convenient way to succinctly express arbitrarily long arrays? The beauty of array notation is: yes we can.
[edit] Two-row arrays
To show the commencement of a second row in-line, we use (1). Thus:
As we come to see, evaluating a two-dimensional array boils down to iterating the top row until it collapses to just two entries, then doing this:
...then starting over.
Infinity scrapers in this range:
Name | Value |
---|---|
tritri | ![]() |
tetratri | ![]() |
pentatri | ![]() |
hexatri | ![]() |
heptatri | ![]() |
ultratri | ![]() |
supertet | ![]() |
superpent | ![]() |
superhex | ![]() |
supersept | ![]() |
superoct | ![]() |
superenn | ![]() |
iteral (also called superdec) | ![]() |
tridecal | ![]() |
general (also called tetradecal) | ![]() |
pentadecal | ![]() |
hexadecal | ![]() |
heptadecal | ![]() |
octadecal | ![]() |
ennadecal | ![]() |
duperdecal (also called iteral) | ![]() |
truperdecal (also called iteralplex) | ![]() |
quadruperdecal | ![]() |
dupertri | ![]() |
latri | ![]() |
goobol | ![]() |
goobolplex | ![]() |
gibbol | ![]() |
gabbol | ![]() |
geebol | ![]() |
gibol | ![]() |
gobbol | ![]() |
gabol | ![]() |
boobol | ![]() |
bibbol | ![]() |
babbol | ![]() |
beebol | ![]() |
bibol | ![]() |
bobbol | ![]() |
babol | ![]() |
troobol | ![]() |
tribbol | ![]() |
trabbol | ![]() |
treebol | ![]() |
tribol | ![]() |
trobbol | ![]() |
trabol | ![]() |
quadroobol | ![]() |
quadribbol | ![]() |
quadrabbol | ![]() |
quadreebol | ![]() |
quadribol | ![]() |
quadrobbol | ![]() |
quadrabol | ![]() |
quintoobol | ![]() |
quintibbol | ![]() |
quintabbol | ![]() |
quinteebol | ![]() |
quintibol | ![]() |
quintobbol | ![]() |
quintabol | ![]() |
gootrol | ![]() |
gitrol | ![]() |
gatrol | ![]() |
geetrol | ![]() |
gietrol | ![]() |
gotrol | ![]() |
gaitrol | ![]() |
bootrol | ![]() |
trootrol | ![]() |
quadrootrol | ![]() |
gooquadrol | ![]() |
booquadrol | ![]() |
trooquadrol | ![]() |
quadreequadrol | ![]() |
gooquintol | ![]() |
emperal | ![]() |
emperalplex | ![]() |
gossol | ![]() |
gossolplex | ![]() |
gissol | ![]() |
gassol | ![]() |
geesol | ![]() |
gussol | ![]() |
hyperal | ![]() |
hyperalplex | ![]() |
mossol | ![]() |
mossolplex | ![]() |
missol | ![]() |
massol | ![]() |
meesol | ![]() |
mussol | ![]() |
bossol | ![]() |
bissol | ![]() |
bassol | ![]() |
beesol | ![]() |
bussol | ![]() |
trossol | ![]() |
trissol | ![]() |
trassol | ![]() |
treesol | ![]() |
trussol | ![]() |
[edit] Three-row and larger two-dimensional arrays
Note how the prime block of all previous structures becomes larger as the arrays do. Add a second row, for example, and this kind of thing starts happening:
Name | Value |
---|---|
Diteral | ![]() |
Diteralplex | ![]() |
Dubol | ![]() |
Dutrol | ![]() |
Duquadrol | ![]() |
Admiral | ![]() |
Dossol | ![]() |
Dossolplex | ![]() |
Dutritri | ![]() |
Dutridecal | ![]() |
Xappol | ![]() |
Well, this is getting dashed inconvenient once again. If only we could use... THE THIRD DIMENSION!!!
[edit] Multidimensional arrays
For a multidimensional arrays (which have been evaluated down to only two entries in the first row), the prime block of all previous structures becomes a square plane, or cube, or higher-dimensional cube. Observe:
Name | Value |
---|---|
hyperal | ![]() |
dutritri | ![]() |
dutridecal | ![]() |
xappol | ![]() |
xappolplex | {10,xappol(2)2}, a xappol-by-xappol array of tens |
grand xappol | {10,10(2)3} |
dimentri | {3,3(3)2}, a 3-by-3-by-3 array of threes |
colossal | {10,10(3)2}, a 10-by-10-by-10 array of tens |
colossalplex | {10,colossal(3)2}, a colossal-by-colossal-by-colossal array of tens |
terossol | {10,10(4)2}, a 10-by-10-by-10-by-10 array of tens |
terossolplex | {10,terossol(4)2}, a terossol-by-terossol-by-terossol-by-terossol array of tens |
petossol | {10,10(5)2}, a 10-by-10-by-10-by-10-by-10 array of tens |
petossolplex | {10,petossol(4)2}, a petossol-by-petossol-by-petossol-by-petossol-petossol array of tens |
ectossol | {10,10(6)2}, a 10-by-10-by-10-by-10-by-10-by-10 array of tens |
ectossolplex | {10,ectossol(6)2}, an ectossol-by-ectossol-by-ectossol-by-ectossol-by-ectossol-by-ectossol array of tens |
zettossol | {10,10(7)2}, a 10-by-10-by-10-by-10-by-10-by-10-by-10 array of tens |
yottossol | {10,10(8)2}, a 10-by-10-by-10-by-10-by-10-by-10-by-10-by-10 array of tens |
xennossol | {10,10(9)2}, a 10-by-10-by-10-by-10-by-10-by-10-by-10-by-10-by-10 array of tens |
dimendecal | {10,10(10)2}, a 10-by-10-by-10-by-10-by-10-by-10-by-10-by-10-by-10-by-10 array of tens |
gongulus | {10,10(100)2}, a 10^100 array of tens |
gongulusplex | {10,10(gongulus)2}, a 10^gongulus array of tens |
gongulusduplex | {10,10(gongulusplex)2}, a 10^gongulusplex array of tens |
gongulustriplex | {10,10(gongulusduplex)2}, a 10^gongulusduplex array of tens |
gongulusquadraplex | {10,10(gongulustriplex)2}, a 10^gongulustriplex array of tens |
Well, that pretty much covers multidimensional arrays of unlimited dimension. Where next?
[edit] Superdimensions
The next step Bowers made is to make it possible to concisely express arrays-within-arrays. We do this by adding an extra parameter to our "navigation" instructions, (1), (2), (3) etc. This extra parameter defines the "dimensional set" to which the first parameter applies. Instructions of the form (a,0) are equivalent to (a) as before and show how to move within an inner array. Commands of the form (a,1) tell you how to move between these inner arrays, as they are arranged in a larger array. For example (0,1) says to move one array to the right. (Note that (0,0) = (0) can be used to represent "next entry", usually done with a comma.) (1,1) says move onto the next row of arrays. (2,1) the next plane, and so on.
The same rules for evaluating the array-of-arrays still apply. However, the definition of "previous structure" now includes entire previous arrays, rows of arrays, planes of arrays and so on, so we need to extend the definition of "prime block" to these new structures. We say the prime block of a previous array is a p^p array, the prime block of a row of arrays is a row of p p^p arrays, and so on.
Thus, for example:
- {b,p(0,1)2} = {{b,p},{2}} = {{b,p(p)2},{1}} = {{b,p(p)2}} = {b,p(p)2}, a p^p array of bs
- {b,p(0,1)d} = {{b,p},{d}} = {{b,p(p)2},{d − 1}}
- {b,p(0,1)1,d} = {{b,p},{1,d}} = {{b,p(p)2},{v(A'),d − 1}}
- {b,p(0,1)1,1,d} = {{b,p},{1,1,d}} = {{b,p(p)2},{b,v(A'),d − 1}}
- {b,p(0,1)(0,1)2} = {{b,p},{1},{2}} = {{b,p(p)2},{b,p(p)2}}
, a row of p p^p arrays of bs, containing p * pp = p1 + p bs altogether
- {b,p(x,1)2} = {{b,p(0,1)2},p(x)2}, containing px + p bs altogether
Named numbers expressible in this form:
Name | Value |
---|---|
hyperal | ![]() |
dimentri | {3,3(0,1)2} = {3,3(3)2}, a 3-by-3-by-3 array of threes |
dimendecal | {10,10(0,1)2} = {10,10(10)2}, a 10^10 array of 10s |
We can continue to extend our notation to incorporate arrays-of-arrays-of-arrays, using a third dimensional set, signified (a,2).
- {b,p(0,2)2} = {{{b,p}}{{2}}} = {{{b,p(p)2},p(p)2},{{1}}} = {{b,p(p)2},p(p)2} = {{b,p(0,1)2},p(p)2} = {b,p(p,1)2}, containing p2p bs altogether
- {b,p(x,2)2} = {{b,p(0,2),p(x)2}}, containing px + 2p bs altogether
And as this preponderance of arrays-within-arrays becomes more tedious, we can keep going:
- {b,p(0,y)2} = {b,p(p,y − 1)2}, containing pyp bs altogether
- If x > 0, {b,p(x,y)2} = {{b,p(0,y)2},p(x)2}, containing px + yp bs altogether
Spot the pattern yet?
More named numbers expressible in this form:
Name | Value |
---|---|
dulatri | {3,3(0,2)2} = {{3,3(0,1)2},3(3)2} = {dimentri,3(3)2}, a 3^3 array of dimentris |
trilatri | {3,3(0,3)2} = {{3,3(0,2)2},3(3)2}, a 3^3 array of dulatris |
gingulus | {10,100(0,2)2} = {{10,100(0,1)2},100(100)2}, a 100^100 array of 100^100 arrays of tens |
gangulus | {10,100(0,3)2}, a 100^100 array of ginguluses |
geengulus | {10,100(0,4)2}, a 100^100 array of ganguluses |
gowngulus | {10,100(0,5)2}, a 100^100 array of geenguluses |
gungulus | {10,100(0,6)2}, a 100^100 array of gownguluses |
It is relatively straightforward to extend our navigational notation to a third argument, a fourth, and eventually unlimited arguments.
- {b,p(0,0,1)2} = {b,p(0,p)2}, containing
entries altogether at the lowest level
- {b,p(x,0,1)2} = {{b,p(0,0,1)2},p(x)2}, with
entries
- {b,p(0,y,1)2} = {{b,p(0,0,1)2},p(0,y)2} = {{b,p(0,p)2},p(0,y)2} = {b,p(0,y + p)2}, with
entries
- {b,p(x,y,1)2} = {{b,p(0,y,1)2},p(x)2}, with
entries
- {b,p(0,0,2)2} = {b,p(0,p,1)2}, with
entries
- {b,p(0,0,z)2} = {b,p(0,p,z − 1)2}, with
entries
- {b,p(x,y,z)2} = {{b,p(0,y,z)2},2(x)2} = {{b,p(0,y + zp)2},2(x)2}, with
entries
- {b,p(0,0,0,1)2} = {b,p(0,0,p)2}, with
entries
- {b,p(x,y,z,t)2} = {{b,p(0,y + zp + tp2},p(x)2}, with
entries
, with
entries altogether at the lowest level.
Name | Value |
---|---|
trilatri | {3,3(0,0,1)2} = {3,3(0,3)2}, a 3^3 array of 3^3 arrays of 3^3 arrays of threes, with ![]() |
trimentri | {3,3(0,0,0,1)2} = {3,3(0,9)2}, with ![]() |
bongulus | {10,100(0,0,1)2} = {10,100(0,100)2}, with ![]() |
bingulus | {10,100(0,0,2)2} = {10,100(0,200)2}, with ![]() |
bangulus | {10,100(0,0,3)2} = {10,100(0,300)2}, with ![]() |
trongulus | {10,100(0,0,0,1)2} = {10,100(0,1002)2}, with ![]() |
quadrongulus | {10,100(0,0,0,0,1)2} = {10,100(0,1003)2}, with ![]() |
goplexulus | ![]() ![]() |
[edit] Adding extra dimensions to the navigation notation
Observe that is a structure with
entries in it altogether at the lowest level.
Let's apply a similar kind of navigational instructions to this notation as we did to the original array notation. That is,
where there are p zeros, with
entries.
where there are p zeros, with
entries.
where there are p+1 zeros, with
entries.
, with
entries.
Note the overlap which arises if the first row in the navigation notation has more than p commands, for example:
- {2,2(0,0,1(1)1)2} = {2,2(0,0,2)2}
Name | Value |
---|---|
trimentri | {3,3((1)1)2} = {3,3(0,0,0,1)2}, with ![]() |
goplexulus | ![]() ![]() |
As the second row of entries expresses multiples of pp, so the row after that expresses multiples of (pp)2 = p2p, the row after that (pp)3 = p3p, and so on. Then the next plane expresses (by row) multiples of , multiples of
, multiples of
and so on.
- {b,p(4,2(1)6,7(1)7,8(2)7,8,5)2} contains
entries at the lowest level.
The plane after that, the family. The plane after that, the
family.
The next 3-space, the family. The 3-space after that, the
family. The next 4-space, the
family. The next 5-space, the
family. The next 6-space, the
family...
[edit] This is getting complicated
What is going on here is not really recursion. Each additional layer of notation is just making it easier and easier to express ever larger levels of arrays-within-arrays. Regardless of how we expand our notation, everything will eventually collapse back to {b,p(x,y)2} = {{b,p(0,y)2},p(x)2} for some x and y. This structure has px + yp entries in it at the lowest level.
This is a p^x array of p^p arrays of p^p arrays of ... p^p arrays, where there are y nested p^p arrays.
Noting this relationship, we can simplify our analysis of the structures we are creating.
This notation is all becoming largely superfluous because Bowers hasn't used it to describe many numbers.
In general, then, we know how to render any power of p into a set of nested arrays. And we can use array notation to generate that power of p in the first place. Keep watching.
Name | Value |
---|---|
goduplexulus | {10,100((0,1)1)2} = {10,100((100)1)2}, a ![]() |
gotriplexulus | ![]() ![]() |
goppatoth | a ![]() |
goppatothplex | a ![]() |
triakulus | a ![]() |
kungulus | a ![]() |
kungulusplex | a ![]() |
quadrunculus | a ![]() |
tridecatrix | a {10,10,10} array of tens |
humongulus | a {10,10,100} array of tens |
golapulus | a {10,100(100)2} = gongulus array of tens |
golapulusplex | a golapulus array of tens |
[edit] Are we there yet?
For most arrays , we find A = bz(A)b for some (usually unspeakable) value of z(A). Let's say A corresponds to a structure of b^b arrays of b^b arrays of ... b^b arrays of b^b arrays of entries, where there are z(A) nested layers of arrays. Call this "an A-type array". (If A is small and the power of b generated is not divisible by b, but just b^p for some p, an A-type array would be just a b^p array of entries.)
This means we can turn almost any array, regardless of size, into a power of b and then into nested set of arrays. We can continue that recursive sequence further still by introducing some more notation. Let's say:
- A & i = an A-type array of is
- A & i & j = an (A-type array of is)-type array of js
- A & i & j & k = an ((A-type array of is)-type array of js)-type array of ks
and so on.
Name | Value |
---|---|
tritri | 3 & 3 = {3,3,3} |
tetratri | 4 & 3 = {3,3,3,3} |
pentatri | 5 & 3 = {3,3,3,3,3} |
hexatri | 6 & 3 = {3,3,3,3,3,3} |
heptatri | 7 & 3 = {3,3,3,3,3,3,3} |
ultatri | 27 & 3 = ![]() |
supertet | 4 & 4 = {4,4,4,4} |
superpent | 5 & 5 = {5,5,5,5,5} |
superhex | 6 & 6 = {6,6,6,6,6,6} |
supersept | 7 & 7 = {7,7,7,7,7,7,7} |
superoct | 8 & 8 = {8,8,8,8,8,8,8,8} |
superenn | 9 & 9 = {9,9,9,9,9,9,9,9,9} |
iteral (also called superdec) | 10 & 10 = {10,10,10,10,10,10,10,10,10,10} |
tridecal | 3 & 10 = {10,10,10} |
general (also called tetradecal) | 4 & 10 = {10,10,10,10} |
pentadecal | 5 & 10 = {10,10,10,10,10} |
hexadecal | 6 & 10 = {10,10,10,10,10,10} |
heptadecal | 7 & 10 = {10,10,10,10,10,10,10} |
octadecal | 8 & 10 = {10,10,10,10,10,10,10,10} |
ennadecal | 9 & 10 = {10,10,10,10,10,10,10,10,10} |
iteral (also called duperdecal) | 10 & 10 = ![]() |
hyperal | 2 & 2 & 10 = {2,2} & 10 = ![]() |
dutritri | {3,2} & 3 = ![]() |
dutridecal | {3,2} & 10 = ![]() |
xappol | {10,2} & 10 = ![]() |
xappolplex | {xappol,2} & 10 = a xappol-by-xappol array of tens |
dimentri | 2 & 3 & 3 = {3,3} & 3 = a 3-by-3-by-3 array of threes |
colossal | {10,3} & 10 = a 10-by-10-by-10 array of tens |
colossalplex | {colossal,3} & 10 = a colossal-by-colossal-by-colossal array of tens |
terossol | {10,4} & 10 = a 10-by-10-by-10-by-10 array of tens |
terossolplex | {terossol,4} & 10 |
petossol | {10,5} & 10 |
petossolplex | {petossol,5} & 10 |
ectossol | {10,6} & 10 |
ectossolplex | {ectossol,6} & 10 |
zettossol | {10,7} & 10 |
yottossol | {10,8} & 10 |
xennossol | {10,9} & 10 |
dimendecal | 2 & 10 & 10 = {10,10} & 10 |
googol | {10,100} = 10100 |
gongulus | googol & 10, a 10100 array of tens |
gongulusplex | {10,gongulus} & 10 |
gongulusduplex | {10,gongulusplex} & 10 |
gongulustriplex | {10,gongulusduplex} & 10 |
gongulusquadraplex | {10,gongulustriplex} & 10 |
golapulus | gongulus & 10, a gongulus-type array of tens |
golapulusplex | golapulus & 10, a golapulus-type array of tens |
golapulusplux | gongulus & 10 & 10 & ![]() |
trimentri | {3,3,2} & 3 = a ![]() |
goplexulus | {100,3,2} & 10 = a ![]() |
goduplexulus | {100,4,2} & 10 |
gotriplexulus | {100,5,2} & 10 |
goppatoth | {10,100,2} & 10 |
goppatothplex | {10,goppatoth,2} & 10 |
triakulus | 3 & 3 & 3 = {3,3,3} & 3 |
kungulus | {10,100,3} & 10 |
kungulusplex | {10,kungulus,3} & 10 |
quadrunculus | {10,100,4} & 10 |
tridecatrix | 3 & 10 & 10 = {10,10,10} & 10 |
humongulus | {10,10,100} & 10 |
This type of recursion exhausts itself pretty quickly so let's introduce the real second stage of array notation: legion arrays. Use the forward slash "/" for the beginning of a new legion and let's add the new rule:
{b,p / 2} = {b&b&...&b} where there are p bs.
Name | Value |
---|---|
tritri | {3,2 / 2} = 3 & 3 |
supertet | {4,2 / 2} = 4 & 4 |
superpent | {5,2 / 2} = 5 & 5 |
superhex | {6,2 / 2} = 6 & 6 |
supersept | {7,2 / 2} = 7 & 7 |
superoct | {8,2 / 2} = 8 & 8 |
superenn | {9,2 / 2} = 9 & 9 |
iteral | {10,2 / 2} = 10 & 10 |
triakulus | {3,3 / 2} = 3 & 3 & 3 |
big boowa | {3,3,3 / 2} |
great big boowa | {3,3,4 / 2} |
grand boowa | {3,3,big boowa / 2} |
super gongulus | {10,10(100)2 / 2} = 10 & ... & 10 with a gongulus of tens |
wompogulus | {10,10(100)2 / 100} |
wompogulusplex | {10,10(100)2 / wompogulus}, presumably |
It is more or less trivial to extend the notation to include (/2), (/3), (/4), ... , (/0,1), (/1,1), ... (/0,2), (/0,3) and so on and so on in legion form. This is familiar ground we have trodden many times - all we are doing is flooding the previous structures with bs separated by ampersands instead of commas. The result is legions of legions of legions of etc. etc. ad infinitum.
Name | Value |
---|---|
guapamonga | {{10,10(100)2},10 (/100) 2 }, a 10^100-type legion array of gonguluses |
guapamongaplex | {{10,10(guapamonga)2},10 (/guapamonga) 2}, a 10^guapamonga-type legion array of 10^guapamonga arrays of tens |
big hoss | {100,100 //////.......///// 2} - with 100 /'s. |
great big hoss | {big hoss, big hoss /////.......///// 2} - with big hoss /'s |
meameamealokkapoowa | {Not Defined Yet} |
meameamealokkapoowa oompa | {Not Defined Yet} |