With the superstar operator we can kick the physical universe's quantum ass! Count stars.
 5*{0}5 = 5+5
= 1{5}1{5}
= 10 
a*{0}b = a+b
= 1{a}1{b}
= ab = ba  1*5 = 1(1*4)
== 1..(1*1) :4
= 11111 = 5 
a*1b = a(a*b)
== a..(a*1) :b
= a.. :b1  2**8 = 2*(2**7)
== 2*..(2**1) :7
= 2*2*2*2*2*2*2*2 = 256 
a**b1 = a*(a**b)
== a*..(a**1) :b
= a*..a :b  3***3 = 3***2+**3
== 3***1+**3**3
= 3**27 = 7625597484987 
a***b1 = a***b+**a
== a***1+(**a){b}
= a(**a){b}  2****3 = 2***2***2 = 2***4
= 2**2**2**2 = 2**2**4
= 2**2*2*2*2 = 2**2*2*4
= 2**2*8 = 2**16
= 2*..2 :15
== 65536  2*****3 = 2****4
= 2***2***4
= 2***65536
= 2..**2. 65535:
= 2^..65536 :65532
≈ 10^^65532+^19728 
#
a*{c1}b1 = a*{c}(a*{c1}b)
== a*{c}..(a*{c1}1) :b
= a*{c}..a :b  a*{c1}b = a^{c>0}b (Knuth's arrows)
The two operands a and b1
form the base of this superstar operation.
In the end this is completely reduced ==
to a total of b operations with one star less,
over operands a
.
Equal operations (without brackets) are evaluated from the right.
§1 Star counter reload
The power motor of superstars inserts a
maximal substitute expression (with its b
just 1
smaller) in the right operand.
This main step can be taken as long as a star
can be counted off from the first index
c of its array.
We keep our motor running most of the time…
To resolve arrays we start left inside and scan ltr.
An empty entry will be rare, but we can reload
it by a big interim result from box b at base.
In exchange the next iterator on the right is decremented,
at index d
or else the first right entry that is available
(not 0
).
Evaluation of a superstar array with two entries. #

a*{c1,d}b1 = a*{c,d}(a*{c1,d}b)
(motor)
== a*{c,d}(..a*{c1,d}1..) :b:
= a*{c,d}..a :b  a*{0,d1}b = a*{b,d}b (reload)
 a*{c,0}b = a*{c}b (end)
Our superstar function over the row is comparable to the linear array of
Chris Bird,
who substitutes a decremented expression
for all entries 1
in his arrays.
Impressive but futile, because raising
b by just 1
in our system is enough to overtake Bird's again.

a*{1,1}2 =
a*{,1}(a*{1,1}1)
= a*{,1}a = a*{a}a = a*{a1}2 <
Bird {a,2,1,2} = {a,a,{a,1,1,2},1}
= {a,a,a} = a^{a}a = a*{a2}2 
a*{1,1}3 =
a*{a*{a}a}(a*{a}a)
< a*{2+a*{a1}2}2 <
Bird {a,3,1,2} = {a,a,{a,2,1,2},1} =
= {a,a,a*{a1}a} = a*{2+a*{a2}2}2  so a*{1,1}b < Bird {a,b,1,2} < a*{1,1}b1
 a*{2,1}2 = a*{1,1}a < Bird {a,2,2,2} = {a,a,1,2}
 a*{2,1}3 = a*{1,1}(a*{1,1}a) < Bird {a,3,2,2}
 a*{1,2}2 = a*{a,1}a < Bird {a,2,1,3} = {a,a,a,2}
 so a*{c,d}b < Bird {a,b,c,d1} < a*{c,d}b1
The values b we reload are sufficient and maximal.
Since all our entries are counted down to 0
(instead of 1
as in Bird),
each next entry gives the superstar system a slight edge.
With 4 parameters both systems grow as fast
as the row of Conway's chained arrows.
§2 Linear superstar array
Inspired by Jonathan Bowers' original
array functions,
we extend the star index *{c
to a linear or row type ,R}
array,
with iterators over the star counter.
Brackets can be {}
curly
or square []
for arrays,
these differ visually, not formally.
In any type array *{c,T}
the 0th entry c quantifies or counts
superstars, and indices in type T
reload the left empty entries recursively.
If we append multiple stars this just adds up quantifiers.
For typed arrays that won't work,
because reloads are dominant,
while we reduce superstar constructs from left to right.

a*{c}*
b = a*{c1}b = a**{c}b

a*{c,T}*
b < a*{c1,T}b
=
a**{c,T}b
< a*{1,T}*{c,T}b
=
a**{,T}*{c}*{,T}b
< a*{c,T}*{1,T}b (for
T>0
)
You can append two or more star types that don't match
and resolve that operator construct ltr.
Just copy the right stars over,
until the left stars are fully reduced.
These variations deviate from the throughput expressions
produced normally in our system.
We won't append indexed star operators,
they don't help to get bigger.
Because we count entries down to 0
parts of a row ,..,R
are eventually left empty.
These empty indices wait to be replaced with big values
b'
growing recursively in the star's right operand:
the box.
The reload rule and the power rule are equally strong over the row
(shown in Blixa below).
And the reload of entries in nested arrays is stronger (see next blog).
The principle of counting penultimate structures
with a reload from the box always wins.
Evaluation rules for our linear star array,
abbreviated to a row R
of indices.
#
 a*{}b = ab (add)
 a*{1R}1 = a (unity)

a*{1R}b1 = a*{R}(a*{1R}b)
(power rule)
== a*{R}..a :b 
a*{,{k1}1R}b = a*{,{k}b,R}b
(reload rule)
== a*{b.,b..,R}b :k  a*{R,}b = a*{R}b (row end)
Starting from multiplication, the main reduction step stores
box in box
.
We select the inner subexpression,
copy it, decrement operand b by one,
and replace the new box b with this reduced copy.
And in the end all we add is number apples a
again (and again).
Last year we created a basic radix system,
where the main step stores an apple in the bin
.
Just counting off entries (without reload) this
Alexa system
is comparable to Bird's reference spaces.
With structure dominating the rules,
it is persistently slower than what we do here.
In Alexa each next
entry
is an extra multiplication:
merely a power over the
row.
Then we applied the reload rule that sends values b
to entries 0
in the same context,
and reached superpowers on the row.
Here we express superpowers with three parameters,
but expanding the same structures the
Blixa system
should soon catch up.
In theory Blixa is simply one small row behind,
but we made a mess of our
comparison
with other fast growing systems,
and left the Alexa & Blixa construction project unfinished.
Sometimes alternative formats for superstars, such as the function
*(a,b,R)
can be convenient, compare Bird.
It helps the scanner to resolve all parameters ltr.
But later on we will want to multiply index arrays.
So to keep the operands a and b
on the base level let them stand out clearly
for next generations of arrays.
In our
5th blog
article Birth of the Superdeep
we devise a ltr system to resolve superdeep infix stars,
where we use pluses to make operations wait (instead of brackets).
This push
system pushes smaller operations to the left
and should also work for numbers.
Next our
3d blog,
we take it easy and meet nested arrays
that increase at half speed.
~ Superstar Ghost Rider ~
He who walks in the company of fools suffers a long way. Company with fools, as with an enemy, is always painful. Company with the wise is pleasure, like meeting with kinsfolk.
Therefore, one ought to follow the wise, the intelligent, the learned, the much enduring, the dutiful, the elect. One ought to follow a good and wise man, as the moon follows the path of the stars *****************
No comments:
Post a Comment