Today the Alexa
radix system for big numbers will be nested to great depth.
We extend the first row defined in
last blog
to multiple dimensions and then to nested arrays.
§3. Nested arrays
In all arrays the position of an entry, specified by its left separator,
determines the function or power of its value.
We can start with the comma
,
or [1]
in row space, and either go on to count a series of commas
(row format),
or index positions directly in a subarray
(sentry format).
In the common row format
same separators (seps) always occur, as they are expanded in series,
increasing in power towards the right.
In sentry format expressions can be evaluated completely
without repetition of seps.
Here a pair of an indexed sep and number entry is called a sentry.
Duplicate seps in the input are allowed,
but this could be expressed with unique seps instead.
Any array function can be written either with sentries or rows, but the
Alexa
sentry format behaves as a fluid.
In a fluid system the sentries can be moved about
inside their parent array without changing the result.
There are no rows or dimensions there, just sets of sentries,
as sentries can freely hop over each other, in series or alone.
The only restrictions on the movement of fluid sentries are:
not to leak from their parent brackets or to seep into some subarray.
Fluid radix system Alexa
can have her sentries roam freely,
because she persistently uploads the constant a.
Solid systems like Blixa
upload the variable b, which is fast growing,
and those array entries have to be rigidly kept in order.
There is no need for unique seps [p,X]
in a solid system, so usually that number p
to count subarrays [X]
is represented by positions in the parent space.
The rules defined for linear
Alexa
in the
last blog
cover all nested arrays as well.
In a fluid evaluation rules can be applied in any order.
Sentries [X]n
can be reduced individually and the resulting numbers added up on the left,
while the parent array is evaluated at the same time.
However, to preserve the radix character of
Alexa
,
where no entry becomes larger than
a=10
,
we should evaluate expressions consistently from left to right.
§3.1. Sentry to row format
In sentry format each array in
Alexa
holds a fluid set of sentries:
sep & entry pairs that may float about during an evaluation.
We can translate this to row format:
a solid structure for multiple seps of the same type.
One nested row contains the information
of two levels of nested senties.
Vice versa we can translate the array functions of Bird
to a format where all substructures are unique.
This just doubles the number of nested levels.
_{[1]}n = ,_{[]}n = ,n _{[1]}m_{[2]}n = ,m,n _{[n]}1 = ,{n}1 _{[,1]}n = ,_{[1]}n _{[1,1]}n = ,_{[1]},n _{[n,1]}1 = ,_{[1]},{n}1 _{[,2]}n = ,_{[1]},_{[1]}n _{[,n]}1 = ,_{[1]}..1 :n _{[[2]1]}n = ,_{[2]}n _{[n[2]1]}1 = ,_{[2]},{n}1 _{[m,n[2]1]}1 = ,_{[2]}.,_{[1]}..,..1 :n :m _{[[2]n]}1 = ,_{[2]}..1 :n _{[[n]1]}1 = ,_{[n]}1 _{[[,1]1]}n = ,_{[,1]}n _{[[,1]n]}1 = ,_{[,1]}..1 :n _{[[n,1]1]}1 = ,_{[n,1]}1 _{[[,n]1]}1 = ,_{[,n]}1 _{[[[2]n]1]}1 = ,_{[,,n]}1 _{[[[n]1]1]}1 = ,_{[,{n}1]}1 _{[..n..]}1 :kk: = ,_{[..n..]}1 :k: _{[..n..]}1 :kk1: = ,_{[..,{n}1..]}1 :k:
Differences between the sentry format on the left, and the row format on the right:
 In row format we prefix a separator comma to all subarrays.

A plain comma equals sep
[1]
in sentry format, but sep,_{[]}
within rows. 
Nested subarrays
[X]
on the row are matched with seps on even sentry levels. Their repetitions on the row can be matched with seps on odd sentry levels, which are coloured green for contrast.
Other googologists count their entries down to 1
,
not to void
, like we do here.
But they leave the room to combine separators
[X][Y]
unused in their algorithms.
Recursion theorists often put new and faster entries on the left:
in reverse direction.
You can choose the notation styles you like for your own projects,
but we find our sentry format is natural for nested arrays,
because the number output figures.
§3.2. Nested Alexa
Calculate some basic nested arrays in
Alexa
.
Apply her
rules
for the linear system, styled in sentry format.
_{[1]}p = ,p = a,p = aa,p = a*p
_{[2]}p = ,a_{[2]}p = a*a_{[2]}p = a^2*p
_{[p]}1 = _{[p]}a = a^p*a = a^p
_{[[1]1]}p = _{[,1]}p = _{[a]}p = a^a*p
_{[1,1]}p = _{[,1]}a_{[1,1]}p = a^a1_{[1,1]}p = a^a1*p
_{[2,1]}p = a^a2_{[2,1]}p = a^a2*p
_{[p,1]}1 = _{[p,1]}a = a^ap
_{[,2]}p = _{[a,1]}p = a^aa*p
_{[,p]}1 = a^(a*p)
_{[[2]1]}p = _{[,a]}p = a^a^2*p
_{[1[2]1]}p = _{[[2]1]}a_{[1[2]1]}p = a^(a^2+1)*p
_{[p[2]1]}1 = _{[p[2]1]}a = a^(a^2+p)
_{[,p[2]1]}1 = _{[a,p[2]1]}1 = a^(a^2+a*p)
_{[[2]p]}1 = _{[,a[2]p]}1 = a^(a^2*p)
_{[[p]1]}1 = _{[[p]a]}1 = a^a^p
_{[[,1]1]}p = _{[[a]1]}p = a^^3*p
_{[[,1]p]}1 = _{[[a]p]}1 = a^^3^p
_{[[1,1]p]}1 = _{[[,1]a[1,1]p]}1 = a^(a^a1*p)
_{[[p,1]1]}1 = _{[[p,1]a]}1 = a^a^ap
_{[[,p]1]}1 = _{[[a,p]1]}1 = a^^3+*p
_{[[[2]p]1]}1 = a^^3+*a*p
_{[[[p]1]1]}1 = a^^3+^p
In Alexa
the next nested array
expresses the next power on top of a power tower.
This follows easily from recursion over
_{[S]}1
= a^S
where the subarray S
can be independently reduced to number.
_{[..S..]}p :n: = p*a^^n+^S
Depth of nesting in Alexa
translates to the tetration ^^
exponent n
which dominates these functions,
against shallower subarrays S
.
The radix aspect of Alexa
lifting a digit length p
to a power a^p
has lost importance.
To remove the linear top or drop the bottom nest
decreases depth n by just 1
.
To classify his linear array space Bird counted it as ω
.
He notated his arrays in row format
and nested them to ω
depth.
In the previous section we saw that row format with its multiple seps
takes half the nested levels of our sentry format with unique seps.
Here ω^^ω
= ε_{0}
so Bird's nested arrays count up to class
ω^^ωω
= ω^^ω+^ε_{0}
= ε_{1}
.
After rows come planes and then cubes, etcetera, who is to say what format is the natural? It's our result of tetration here, that suggests that unique separators between entries are elemental. We choose the sentry format for all our array functions.