# ...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 3.= a,ab,0 2.= a,ab 1.= ab ≡ a+b
- a+0 ≡ a,,1 3.= a,a, 2.= a,a 1.= a
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(a,0,c)
we can multiply numbers.
- 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 =3.= a,.a..b, :c 2.= a,a{c}b 1.= a{c}b 0.= 1.. :a*c+b
- a,,c =3.= a,a{c}, 2·1.= a{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(a,b,2)
and continue with powers at
Eaf(a,b,3)
which is a**b = a^b where Bird's
Beaf(a,b,1)
is said to begin.
Generalize for third entries >1
to obtain the superpower formula.
We count down to 1
and then apply the Eaf
rule for addition with precedence.
- Eaf(a,b1,c2) = Eaf(a,(a,b,c2),c1) == Eaf(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^..(b+1) ^:c = Beaf(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
4.= a,a,b,d (upload
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+*b
which reduces to a**d+*a*b
and further to
a*..b :d1
where factor 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 3.= a,v,,d1 with v ≡ (a,b,c) ≡ a*c+b 5.= a,,v,d but if v=0 then 4.= a,a,,d 3.= a,a*v,,d 5·3.= a,.a*..a*v,, :d 2·1.= a*..v :d1 = a**d1+*v = a**d1+*a*c+b and = a**d+*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(a,b,1)
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.
§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(a,b,2)
in the function notation of Bird's system.
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+**b,
reduces to a***e+**a**b and further to
a**..b :e1
boasting power 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+*a*c+b,,,e = a***e+**a**d+*a*c+b
Multiple commas a,{4}e
function like the stars a*{3}e
of superpowers. Inserting one comma ,
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(a,b,c)
with just two commas of original input.
But evaluation in Beaf
requires many commas more of throughput
(within bracketed subexpressions).
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
*{k1}
and to Knuth's arrows
^{k}
(distant by two classes in primitive recursion).
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} 5.= a,,{k}1,Z == a,,1,{k}Z 3.= a,a,{k1}Z (put)
- 5.1 a,b1,{k1},1Z = a,,{k1}1b,Z (upload) 4.= a,a,{k1}b,Z == a,a,.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
{1∈Z}
and for postponed superstars
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,(a,{r1}b),{r1}q = a,a*{r}b,{r1}q (superpower as before) == a,.a*{r}..b :q1 = a*{r1}q1+*{r}b
- a,,{r1}1q = a,a,{r1}q = a*{r1}q+*{r}a {q>0} = a*{r1}q1 {q≥0} = Eaf(a,q1,r2) = Beaf(a,q1,r)
- a.,pi..,q :r1 = a,v,{r1}q where v = a.,pi.. :r1 = a*{r1}q+*{r}v == etc. ~> 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≥2 = Eaf(a,a,.1,..b1,1Z) :k so Eaf(a,b.,1..,2Z) :k≥1 = Eaf(.a,..b,1Z) :k1 Beaf(a,b1.,1..,1Z) :k≥0 = Beaf(.a,..f,Z) :k1 (Bowers' motor upload) f = Beaf(a,b.,1..,1Z) :k
- Eaf(a,b1,2Z) = Eaf(a,(a,b,2Z),1Z) (motor rule)
== Eaf(a,..a..,1Z) :b:
Beaf(a,b1,1Z) = Beaf(a,f,Z) (initial case
k=0of rule4) & 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,(a,a,1,2),1,2) = Eaf(a,a,(a,a,a)) <~ Beaf(a,3,1,2) = (a,a,(a,2,1,2)) = Beaf(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).