Define the system and fathom his growth.

#### §4. Blixa system 1

`Blixa`

is styled after our
Btrix
system.
Formatting and output rules are simple.

**0.0**Blix[**a`M**] ≡**`M**(format)*≡*M**1.0**Blix[**a`b**] = b (output)**0.1**_{[1]}≡ , (comma)

We use a grave accent ```

to hide the system constant `a` on its left.
This inert separator can be thought of as

having a negative index._{[-]} ≡ `

List the main rules for evaluating nested arrays in the
`Blixa`

system.

**2.0**=_{[]}**0**(void)**3.0**_{[S]}] = ] (end)**4.0**_{[S][}=_{[}(clear)**6.0**`b,1 = `ab, (add)**5.0**`_{[R]}1 = `a_{[R]}{R*≠*0} (start)**6.0**`b1**→**_{[1S]}1 = `**→**_{[S]}b1_{[1S]}(upload)**7.0**`b1**→**_{[,1S]}1 = `**→**_{[b1,S]}a_{[,1S]}(subload)

The difference with `Alexa`

where a constant `a` is uploaded,
is that in `Blixa`

upload rule 6.
searches on the right `→`

to insert a subtotal `b`.
Though most of the time the algorithm will operate at ground level,
the rule matching sentry

can also be nested._{[1S]}1n

##### §4.1. Linear Blixa

Apply the `Blixa`

rules to linear arrays.
This
blog
already gave a concrete example.

- Blix[
**a`**]_{[1]}n*0.*≡ ,n*5.*= a,n-*6·2.*= aa,n-- =*6·2.*= a*{n}*,*3·**1.*= a*n _{[1]}m_{[1]}n*V.*= a*m,n*V.*= a*m*+*a*n = a*mn_{[2]}n1*5.*= a_{[2]}n*6.*=*5.*_{[1]}a_{[2]}n-*V.*= a*a_{[2]}n-*6.*=*5.*_{[1]}a^2_{[2]}n--*V.*= a^3_{[2]}n-- == a^n1_{[2]}m_{[2]}n*V.*= a^m_{[2]}n*V.*= a^m***a^n = a^mn

Gray coloured rules reuse results from the calculation above.

We derive the following helper rules from the main system of
`Blixa`

.

**6.1**`b1,1*6.*= `a_{[]}b,*2.*= `a1b, (increment)**6.2**`b1_{[1R]}1*6.*=*5.*`_{[R]}1b_{[1R]}(base upload)**6.3**`b1**→**_{[,1S]}1*6·2.*= `a**→**_{[1b,S]}1 (upload index)**5.1**`_{[1R]}2*5.*= `a_{[1R]}1*6.*= `_{[R]}a_{[1R]}(start upload)**5.2**`_{[,1R]}1*5·**6.*= `a_{[a,R]}=*5.*`_{[a,R]}1 (start index)

The upload of accumulated totals from base entry ``b`
increases function speed, so that the third separator
`[3]n`

already expresses
`a^^n`

`= a***n`

tetration.

_{[p1]}n1*6.*=_{[p]}a_{[p1]}n-*V.*= a**{p}*a_{[p1]}n-*6.*=_{[p]}a**{p}*a_{[p1]}n--*V.*= a**{p}*a**{p}*a_{[p1]}n-- == a**{p1}*n1 = a**→**n1**→**p {p*>*0}_{[p]}m_{[p]}n*V.*= a**↓**m**↓**p_{[p]}n*6.*=_{[p-]}a**↓**m**↓**p_{[p]}n-*V.*= a**↓**(**a**)**↓**m**↓**p**↓**p-_{[p]}n- == a**↓**(*..***a****↓**m**↓**p*..*)**↓**p-*:n:*= a**↓**mn**↓**p =_{[p]}mn

The last line proves how adjacent same seps can be merged
by addition of entries.

We write the Ackermann-type function
`a`

**↓**b1**↓**c1`= a`

with Conway's arrows.**→**b1**→**c

##### §4.2. Conway's down arrows

John Horton Conway let his row of chained arrows start with
`a`

to equal superpowers **→**b**→**c`a^`

as defined by
Knuth's arrows.
From the three entries and rule 1.
of chained arrows, rule 0.
can be retraced, which completes Conway's system.*{c}*b

a**→**0**→**b = a^b (starter)R**→**1**→**1**→**z = R {z*≠*0} (inside stop)R**→**2**→**1 = R (outside drop)R**→**3**→**y1**→**z1 = R**→**(**R**)**→**y**→**z1**→**z {y*≠*0,z*≠*0} (motor)

Wildcard `R`

is a substring
`p`

_{i}**→***..*q

where entries
*:r≥0*`p`

are positive numbers.
Same with _{i}*>*0*,*q*>*0

for final word **↓**`Z`

below.

We define a variation on chained arrows that we call
Conway's down arrows.

Here the rules have to be applied in order, so that identity
1. has precedence over rule
2. in the evaluation of
`a`

for example.**↓**b**↓**1**↓**1 = a

a**↓**0**↓**b = ab (start`+`

)a**↓**1**↓**R**↓**1**↓**Z = a**↓**1**↓**Z = a (identity`a`

)R**↓**2**↓**y1**↓**1 = R**↓**(**R**) (drop**↓**y**↓**1`↓0`

)R**↓**3**↓**y1**↓**z1 = R**↓**(**R**)**↓**y**↓**z1**↓**z (substitution)

Our function of

down arrows increases approximately as fast as
**↓**

chained arrows.**→**

The first three entries
`a`

already express **↓**b**↓**c`a*`

superpowers.*{c}*b

a↓b1↓12.= a↓(a)↓b↓10.= a(a) =↓b↓12:0.= a..(a)↓1↓1:b1.= a..:b1= a*b1 a↓b1↓23.= a↓(a)↓b↓2↓1 =3:1.= a↓(..a..)↓1:b:V.= a*..a:b= a**b1 a↓b1↓c1 =3:1.= a↓(..a..)↓c:b:=V.= a*^{..}b1*:c1= a→b1→c

The temporary V.
rule applies an arithmetic result, derived via the line(s) above.

Continue our comparison of both types of Conway's arrows over the row.

`a`**↓**b**↓**2**↓**1 *2·1.*= a**↓**b**↓**a
≈ a**→**2**→**a < a**→**2**→**2**→**2
a**↓**b**↓**c1**↓**1 *2.*= a**↓**b**↓**(**a****↓**b**↓**c**↓**1) =*2:1.*= a**↓**b**↓**(*..***a***..*) *:c:*
≈ a**→**b**→**(*..***a***..*) *:c:* > a**→**b**→**c**→**2
a**↓**b**↓**c1**↓**d > a**→**b**→**c**→**d1
a**↓**R**↓**y**↓**z < a**→**R**→**y**→**z1 < a**↓**R**↓**y1**↓**z

With Conway's down arrows we have an alternative tool to work out array functions. Let arithmetical operations inside have preference over the evaluation of Conway's arrows.

##### §4.3. Multidimensional Blixa

We compare `Blixa`

with
down ↓ arrows,
and make both systems match on the fly.

Here all variables `n`

are not empty.*>*0

_{[,1]}n1 = a_{[,1]}n = a_{[a]}n =_{[a]}n1 = a**↓**n1**↓**a_{[,1]}m_{[,1]}n = a**↓**m**↓**a_{[,1]}n = a_{[a↓m↓a]}n = a**↓**n1**↓**(**a**)**↓**m**↓**a_{[1,1]}n2 =_{[,1]}a_{[1,1]}n = a**↓**a**↓**a_{[1,1]}n =_{[,1]}a**↓**a**↓**a_{[1,1]}n =_{[a↓a↓2↓1]}a_{[1,1]}n- = a**↓**a**↓**3**↓**1_{[1,1]}n- == a**↓**a**↓**n2**↓**1 > a**→**a**→**n1**→**2- UNDER CONSTRUCTION
_{[2,1]}n1 =_{[1,1]}a_{[2,1]}n- = a**↓**a**↓**a**↓**1_{[1,1]}n- =_{[a↓a↓2↓2]}a_{[1,1]}n-- = a**↓**a**↓**3**↓**2_{[1,1]}n-- == a**↓**a**↓**n2**↓**2 > a**→**a**→**n1**→**3_{[p,1]}n = a_{[p,1]}n- = a_{[pa]}n- =_{[ap]}n = a**↓**n**↓**ap_{[,2]}n = a_{[,2]}n- = a_{[a,1]}n- =_{[a,1]}n = a**↓**n**↓**aa_{[p,2]}n = a_{[p,2]}n- = a_{[pa,1]}n- =_{[ap,1]}n = a**↓**n**↓**aap_{[p,q]}n = a**↓**n**↓**a*q+p_{[2,1]}n1 =_{[1,1]}a_{[2,1]}n- ≈ a**→**a**→**2**→**4_{[2,1]}n- ≈ a**→**a**→**3**→**4_{[1,1]}n-- ≈≈ a**→**a**→**n1**→**4_{[p,1]}n1 ≈≈ a**→**a**→**n1**→**p2

The linear array covers superpowers,
but the next index `Blixa`

already expresses the row of Conway's chained arrows.

_{[,2]}n1 = a_{[,2]}n =_{[a,1]}a_{[,2]}n- ≈ a**→**a**→**a**→**a2_{[,2]}n- ≈_{[a→a→a→2→2,1]}a_{[,2]}n-- (with a→*..*1→z ≈ a2) ≈ a**→**a**→**a**→**3**→**2_{[,2]}n-- ≈≈ a**→**a**→**a**→**n1**→**2_{[1,2]}n1 =_{[,2]}a_{[1,2]}n- ≈ a**→**a**→**a**→**a**→**2_{[1,2]}n- ≈_{[,2]}a**→**a**→**a**→**2**→**3_{[1,2]}n-- (with a→*..*1→z ≈ a) ≈≈ a**→**a**→**a**→**n1**→**3_{[p,2]}n1 ≈≈ a**→**a**→**a**→**n1**→**p2_{[p,q1]}n1 ≈≈ a**→***..*n1**→**p2*:q2*

We are confident that the number obtained at nesting depth
`n` for `Blixa`

will be as fundamental as tetration `a^^n`

was
for deep nested `Alexa`

in the previous section.

#### §5. Superfast growing

##### §5.1. Nested Blixa

Presume all variables
`p`

have *>*0,n*>*0`1`

or more.

_{[[2]1]}n =_{[,a]}n = a**→**n**→**a^2_{[1[2]1]}n =_{[[2]1]}a_{[1[2]1]}n- = a**→**a**→**a^2_{[1[2]1]}n- = a**→**(**a**)**→**a**→**a^2**→**a^2_{[1[2]1]}n-- = a**→**n**→**a^2*+*1_{[p[2]1]}n = a**→**n**→**a^2*+*p_{[,2[2]1]}n =_{[a,1[2]1]}n = a**→**n**→**a^2*+*a*2_{[[2]2]}n =_{[,a[2]1]}n = a**→**n**→**a^2***2_{[[2]p]}n = a**→**n**→**a^2***p_{[[3]p]}n = a**→**n**→**a^3***p_{[[p]1]}n = a**→**n**→**a^p