Saturday, 6 June 2015

Superstar entries

Woman with masks, a writing: the devil is in the loins

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 ~

The Dhammapada says:
      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