##
#
...to *Be* superstars

People are invited to see Btrix front row, running against superpower stars. She may look like a drag queen – dragging behind in the drag races – but you just sit and wait!

### §1.3.1. Multiply by triple

Addition in Btrix is fundamental:
to add `a`

is the only way we may increase number value.
To all parameter arrays `a,b,1Z`

the same rule applies: adding one *apple* `a`

to her *basket* `b`

.

Simple addition `ab`

or `a+b`

is written as a triple array `a,b,1`

in Btrix
with factor `c`

.*=*1

- a,b,1
a,ab,_{3.}=**0**a,ab_{2.}=ab_{1.}=*≡*a+b **a**a,,1**+0**≡a,a,_{3.}=a,a_{2.}=a_{1.}=

Adding is a slow start compared to other Big number algorithms,
like Bowers & Bird,
where a whole array can be substituted for an entry.
While the rough boys trade in the stocks of former executives,
our royal matrix Btrix
has to pile up *apples* `a..`

till the end of time.

The motor of Btrix
is rule `3.`

of addition, defined below.

By repeated application of this rule on
`Btrix(`

we can multiply numbers.**a, 0,c**)

- 3.0 a,b,1c = a,ab,c (motor)

Subtract `1`

from third entry
and add `a`

to `b`

.
Repeat `==`

that by factor `c`

to add `a*c`

multiplied.
After `c`

is counted down to `0`

,
drop its comma by rule `2.`

and choose by `1.`

the second entry,
whose series of ones is output by `0.`

plain `=`

or in some `≡`

format
`a*c`

.*+*b

- a,b,c
**=**a,_{3.}=*.*a*..*b,*:c*a,a_{2.}=*{c}*ba_{1.}=*{c}*b1.._{0.}=*:a*c**+*b - a,,c
**=**a,a_{3.}=*{c}*,a_{2·1.}=*{c}***≡ a*c**

Given an expression `a,,c`

of Btrix
where her basket `b`

is empty,
we add `a`

repeatedly by rule
`3.`

until we arrive at
`a*c`

in the result.
So a double comma `,,`

at the start of
Btrix can be read as (functions like)
the single star `*`

of multiplication.

Here Btrix only puts the constant
`a`

one place higher, to add to `b`

.
There is still no *upload* of increased values,
which gains (super)power the further they travel over the array.

In the next section on powers the first such variable upload is introduced:
lifting the number of `a..`

gathered in `b`

one entry up, to refill `c`

for the next multiplication.

Eventually over the full row Btrix
will reach Knuth's superpowers (double recursion).

But superpowers can be expressed concisely in Bowers' original
Beaf system in just three entries.
Same in our algorithmic substitute for Beaf,
whom we lovingly call Eaf.

Start by expressing addition as before.
In Eaf the idea is
to drop the trailing entry `,1`

and to add by removing the single
`,`

from between.

Eaf(a,b,1) = Eaf(a,b) = Eaf(ab)≡ ab= a+b

Next multiply in
`Eaf(`

and continue with powers at
**a,b,2**)`Eaf(`

which is **a,b,3**)`a**b`

`= a^b`

where Bird's
`Beaf(`

is said to begin.**a,b,1**)

Generalize for third entries

to obtain the superpower formula.
We count down to *>*1`1`

and then apply the Eaf
rule for addition with precedence.

- Eaf(
**a,b1,c2**) = Eaf(**a,(**) == Eaf(**a,b,c2**),c1**a,**)*..*Eaf(**a,1,c2**)*..*,c1*:b:*= Eaf(**a,**)*..***1***..*,c1*:b1:* **= a****{c1}*b1 = a**{c}*(a**{c1}*b) == a**{c}**..*a*:b***= a^**= Beaf(^{..}(b+1)*^:c***a,b1,c**)

System Btrix has more variety
(a better resolution) than Eaf
systems. Vise versa, numbers expressed by linear arrays
in Beaf are much bigger
than those on Btrix front row.

An uphill struggle starts here,
as she must overcome superpowers by counting next entries.

### §1.3.2. Powers by upload

With four entries `a,,,d`

we like Btrix
to lift her constant base `a`

to the power `d`

.
To make this happen we introduce two new rules that upload values
from left to right in the array.

We only put an *apple* `a`

in *basket* `b`

when a right entry is decremented in return.
By rule `4.`

we count down `d`

in fourth entry,
one place past the main iterator.

The actual upload moves the value from basket
`b`

up in the array.
By rule `5.`

to the empty entry
`c`

here,
or generally up to the last entry of a sequence of
`,0`

that starts at `c`

.

- 3.1 a,b,1c,d
*{b≥0}*= a,ab,c,d (add`a`

) - 4.0 a,,,1d = a,a,,d (put
`a`

) - 5.0 a,b1,,1d = a,,b1,d
a,a,b,d (upload_{4.}=`b`

)

We combine the two rules `5·4.`

for the initial case of the same tandem for linear arrays,
which uploads variable `b`

to the end of the empty subarray `,..`

and refills the entries in between
with the constant `a`

.

If you were to leave the accumulated value of `b`

in place for the next upload by `5.`

you don't need rule `4.`

and your resulting numbers would be larger.
However, the gain in growth rate is insignificant
against an extra multiplication of the
Btrix input, we can prove.

Take expression `a,b,c,d`

and put `d1`

instead of `d`

for a test.
Drive to `a,b+a*c,,d1`

then upload and drive to
`a,a*b,a*c,d`

.
The test basket `a*b`

is a factor larger than the original,
and future uploads in the test will be larger too.
To test array rows consider we only need `1`

to add to `d`

, but after that
`d`

itself and other entries
(when emptied) will be uploaded with values larger
than in the original row evaluation
(under the same right entries).

We translate expressions of linear Btrix
to postponed operator format.
Here the operator `+*`

is a postponed multiplication in
`a**d1`

which reduces to **+***b`a**d`

and further to
**+***a*b`a*`

where factor *..*b *:d1*`b`

ends the repetition of factors `a`

.

Postponed stars `+*`

wait to be dropped on the left, see the
table
in the appendix.

The operation with the smallest number of stars is reduced first, that is minority precedence. Else a sequence of equal operations is resolved right associatively.

- a,b,c,d1
a,v,,d1_{3.}=**with****v ≡ (a,b,c)**≡ a*c**+**ba,,v,d_{5.}=**but if v***=***0**thena,a,,d_{4.}=a,_{3.}=**a*v**,,da,_{5·3.}=*.***a***,,*..*a*v*:d*_{2·1.}=**a****..*v*:d1*= a**d1**+***v**+***a*c**+**b**+***a***0****+**a = a**d1 if b*=***0**and c*=***0**

So the expression `a,,,b`

in Btrix
is exactly equal to `a**b`

or
`a^b`

exponentiation, and to
`Beaf(`

in the arrays of Chris Bird.
In contrast, we have to wait for the definition of a multidimensional
Btrix matrix, to approximate
just four entries in Beaf.**a,b,1**)

### §1.3.3. Tetration

The expression `a,,,,b`

over five entries in Btrix
equals the superpower `a***b`

called tetration.
Tetration is a power tower of size `b`

,
written with arrowheads as `a^^b`

or as a double recursion
`Beaf(`

in the function notation of Bird's system.**a,b,2**)

The properties of tetration
and its inverse operations is vastly unchartered arithmetic.
Numbers like `5^^5`

are just too big to make practical sense in our small universe.

The rules of tetration and other superpowers in
Btrix continue those of powers.
Tetration is a linear array of length `5`

,
and our system for linear arrays is defined in the next section.

Again translating to postponed operator format,
the operator `+**`

expresses a postponed power in
`a***e1`

,
reduces to **+****b`a***e`

and further to
**+****a**b`a**`

boasting power *..*b *:e1*`b`

on top of a power tower with
`e`

exponents `a`

.

- a,b,,,e1 = a,,,b,e
*{b>0}*= a,(**a,,,b**),,,e = a,**a**b**,,,e (result from powers) == a,*.***a****,,,*..*b*:e1***= a***e1****+****b - a,,,,e1 = a,a,,,e
**= a***e****+****a = a***e1 - a,b,c,d,e = a,(
**a,b,c,d**),,,e = a,**a**d**,,,e**+***a*c**+**b**= a***e****+****a**d**+***a*c**+**b

Multiple commas `a,{4}e`

function like the stars `a*`

of superpowers. Inserting one comma *{3}*e`,`

on the row should increase numbers more quickly than
boosting the right entry.

Counting separators in between empty entries
in Btrix runs `**`

behind the superpowers expressed in Bird's
`Beaf(`

with just two commas of original input.
But evaluation in Beaf
requires many commas more of throughput
(within bracketed subexpressions).**a,b,c**)

Consider a simple system, where all separators are void
and collapse to zero, and entries `n..`

on ground level are added by default.
Without main rules for the arrays,
such an empty system Nix
can be used to classify separator types.
Provided we fill all structures with substructures of size `n`

<like Chris Bird does with his
<angle bracket>
rules>
and finally with entries `n`

,
before we let our arrays collapse to ground zero.

Start at `n,n = nn`

with powers `n,n,n,n = n*4`

and the row `n,.. `

*:n*`= n**2`

by rule of Nix.
This drops all structure (from the input left)
and adds up entries `n`

to a class norm, for now expressed with minority stars
(in the output right).

Our classification has a natural base `n`

and will soon run on a par with Bird's
`ω`

-based separator spaces,
which take off properly at
`[n]`

multiple dimensions.

Because a row has dimension one,
Bird
calls the linear array a 1-space.
He separates entries with the first index
`[1]`

and so happens to initialize the first nested array.

### # Linear arrays

The first row of entries in the Btrix
matrix is equivalent to David Hilbert's function
in his On the Infinite (1925,
in the guise of a double functional algorithm).

Btrix separator commas
`,{k2}`

are comparably equal to superpower stars
`*`

and to Knuth's arrows
*{k1}*`^`

(distant by two classes in primitive recursion).*{k}*

Despite that values are only being added, moved and counted down,
linear Btrix covers the whole hierarchy
of primitive recursive functions.

She succeeds on the strength of her *upload rule*.
This is a simpler rule than upload in Beaf,
but not significantly slower in principle.
It is the motor rule that slows her down.

List the rules for evaluation of linear arrays in
Btrix.

Trailing commas can be dropped
(by rule `2.`

)
and the output `b`

read
(by rule `1.`

)
in the end.

Rule `3.`

and rule `4.`

both add *apple* `a`

to *basket* `b`

,
after decrementing the first available number on the right.
What we call upload is defined by rule
`5.`

for the row.

- 3.2 a,b,1Z = a,ab,Z (motor)
- 4.1 a,,{k1}1Z = a,1,{k1}1Z
*{k>0}*a,,{k}1,Z_{5.}=a,a,{k1}Z (put)_{3.}= - 5.1 a,b1,{k1},1Z = a,,{k1}1b,Z (upload)
a,a,{k1}b,Z_{4.}=*.*a-,*..*b,Z*:k*

Upload rule `5.`

counts off the active iterator (Bowers' array pilot)
on the far right, then shifts value `b`

to stop short and fill the empty entry before
(Bowers' co-pilot).

Only at the start of an evaluation
rule `4.`

serves a purpose,
later rule `4·5.`

can be applied in one go, culminating in a complete substitution
over the free part of the array.

A peculiar consequence of having two upload shifts is that
```
a,1,,Z = a,,,Z
```

and for postponed superstars
*{1 ∈Z}*

`X`**+****{k1}*1 = X

whilst
`X ≠ X`**+****{k1}***0**

on the right.We translate a row of entries in Btrix to superpowers, achieving equivalence by postponed operators. Superpowers can be expressed with only

`2`

iterator entries in an *array function*.

- a,b,{r1}1q = a,{r1}b,q
**a,{r1}b**),{r1}q**a***,{r1}q (superpower as before)*{r}*b*.***a****{r}**..*b*:q1***= a****{r1}*q1**+***b*{r}* - a,,{r1}1q = a,a,{r1}q
**= a****{r1}*q**+***a*{r}**{q**>*0}*{r1}*q1*{q**≥*0}**Eaf(****a,q1,r2**) = Beaf(**a,q1,r**) - a
*.*,p_{i}*..*,q*:r1*= a,v,{r1}q**where**v = a*.*,p_{i}*..**:r1*_{ }**= a****{r1}*q**+***v == etc.*{r}***~>****Eaf(****a,q1,r2**)**= a****{r1}*q1

The previous section featured the class 4

superpowers of *tetration*.

For an example of the evaluation train of
`11,,,,,111`

pentation
(`2^^^3`

or `2****3`

)
we refer to the
table
in the appendix.

There you also find
the rules of *postponed superstars*.
With this support system the function array of
Btrix
can be translated precisely to operator format.

To use these systems for comparisons in the next chapter,
we define the first row of
Eaf and Beaf –
with rule precedence by list order – covering Bird's
linear arrays.
Here are no `0`

entries.

- Eaf(
**a,b**)**= ab****= a+b**(primitive) Beaf(**a,b**)**= a^b****= a****..*1*:b* - Eaf(
**a,X,1**) = Eaf(**a,X**) (finalize) Beaf(**X,1**) = Beaf(**X**) - Eaf(
**a,1,Z**)**= a =**Beaf(**a,1,Z**) (inner drop for rule`5`

) - Eaf(
**a,b,1,2Z**) = Eaf(**a,a,b,1Z**)_{ }(upload rules)**&**Eaf(**a,b**)*.*,1*..*,2Z*:k1*= Eaf(a,a,*≥*2)*.*1,*..*b1,1Z*:k***so**_{ }Eaf(**a,b**)*.*,1*..*,2Z*:k*= Eaf(*≥*1)*.*a,*..*b,1Z*:k1*Beaf(**a,b1**)*.*,1*..*,1Z*:k*= Beaf(*≥*0)*.*a,*..*f,Z*:k1*_{ }**f =**Beaf(**a,b**)*.*,1*..*,1Z*:k* - Eaf(
**a,b1,2Z**) = Eaf(**a,(**) (motor rule) == Eaf(**a,b,2Z**),1Z**a,**)*..***a***..*,1Z*:b:*Beaf(**a,b1,1Z**) = Beaf(**a,f,Z**) (initial case`k`

of rule*=*0`4`

)**&**_{ }**f =**Beaf(**a,b,1Z**)

The *Easy Array Function* (Eaf)
uploads entry `b`

straight,
instead of a predecessor expression.
Now Beaf's results
need not be greater than Eaf's
(due to this easy upload rule).
We can just increase entry `c`

to cause one extra nesting in `b`

accordingly (let the motor rule do the work).

Eaf(a,3,2,2) = (a,() = Eaf(a,a,1,2),1,2a,a,()a,a,a)<~Beaf(a,3,1,2) = (a,a,() = Beaf(a,2,1,2)a,a,()a,a,a)

Observe that
`Eaf(a,b,1Z)`

`< Beaf(a,b,Z)`

`≤ Eaf(a,b,2Z)`

falls within (an ever tighter) range
(towards the lower Eaf bound).