Friday 22 December 2017

Belnesten

Link naar dit blog:
allergrootste.blogspot.nl/2017/12/belnesten.html
edit jan.2019.

§2.6 Belnesten · vlak

Hoe dieper de arrays of rijen in een systeem genest zijn, hoe groter de ge­tallen die ermee ge­schreven kunnen worden.
Elke iterator of iter in de top array bevindt zich op het 1e niveau. Die begint met de eerste rij, waar elke sepa­rator of sep een enkel­voudige index heeft, zie §2.5. Steeds als we een iter in Bellen­blazer af­tellen, laden we een grotere bel b op naar de iter die ervoor komt.

Om hogere iteraties in de top array te kunnen noteren, breiden we de sep index uit tot een rij op het 2e niveau. Deze sep array krijgt zelf ook weer hogere indexen, genest op het 3e niveau.
Indexen op elk array niveau kunnen tot rijen ver­lengd worden. Iters en hun indexen tellen we af tot 0 en dan ruimen we een blazer element tijde­lijk weg. Aan de uit­einden van arrays komt een getal, geen sep.

Arrays zijn lexi­caal begrensd: ieder opener haakje [ links heeft een eigen sluiter haakje ] rechts, zie box 1.0. Om bij het begin van een geneste array het einde te vinden is in com­plexe ex­pressies verre van triviaal. Tijdens een scan moeten we het nest niveau op en af­tellen tot we weer een haakje van het ori­ginele niveau tegen­komen.
Ook onder­scheiden we Bird's dimen­sionale ruimtes, zie box 2.4. Wat vereist dat we gelijke arrays her­kennen, omdat we de ruimte er­tussen in blazers niet apart merken.

Bellen­blazer is qua array structuur een tellerij. In de evaluatie van een tellerij komt elke iter op een positie met een eigen index te staan.
Wát de huidige array is en wàt de index array, is relatief en ligt aan de match die de regel maakt. Bij verschillende soorten geneste arrays, de een in de ander, kunnen we het niveau van haakjes wel­licht expliciet aan­geven, zoals posities in blazers altijd hun eigen index krijgen.

We breiden nu de regels voor de eerste rij B.I uit en her­laden de eerste index. Als die index leeg komt, hebben we sub­totaal b zojuist ver­plaatst naar de iter rechts buiten de index array. Het sub­stituut getal zal dus van die iter moeten komen, niet van de nieuwe bel a, omdat de functie anders stokt…i Echt grotere getallen zouden dan niet snel van de grond komen.

De eerste index geeft de iter positie aan in de meest rechtse rij. De tweede index telt de rijen af in de twee-dimensionale ruimte. Binnen een matrix geeft die index het aantal rijen in het rechtse vlak.
De hele index rij beslaat de multi-dimensionale ruimte of matrix. In de eerste sub­index ,[d]p op het derde niveau lezen we het getal van de dimensie. Index p is het aantal dim d ruimtes, dat onder­deel is van de meest rechtse dim d1 ruimte.

De twee-dimensionale ruimte begint dus na de sub­index ,[1] die we hier af zullen korten tot , enkele komma.
We werken recursies over de twee indexen van het array vlak onder uit. De regels zijn: sep­arator elim­inatie (sep elim), bel en begin index intro­ductie (bel intro) en element intro­ductie (elem intro).

Definitie Bellen­blazer B.II specifiek voor het array vlak.

  • B.0. B.1.
  • B.2. ,[S]00
  • B.3a. [,[1S]1Z]a = [a,[1S]Z]a
  • B.3b. ,[,1n]b ,[b,n]a
  • B.4a. [b,[1n]1Z]a {n>0} = [,[n]b,[1n]Z]a
  • B.4b. [b,[1,n]1Z]a {n>0} = [,[,n]b,[1,n]Z]a

De aas a staat steeds rechts van de top array. Hier is variabele b>0 en constante a>1, maar door­gaans is bel b>a veel groter.
Equi­valentie werkt overal in de expressie, met voor­rang op andere regels. Voor­alsnog kan na elke eva­luatie een­duidig worden bepaald, welke regel daarna komt.

Bij het overladen van de bel had anders een kopie gebruikt kunnen worden, terwijl de origi­nele b in de array er­boven of in de basis al zou blijven staan. Maar we vinden het mooi als grote bellen b stap voor stap groeien, zolang het kan. Daarom ver­vangt regel B.3b. hier de zojuist opge­laden iter b door aas a.
Regel B.4b. telt de eerste index in ,[1,1n] af en ver­schuift een bel naar ,[,1n]b de nieuwe iter. Daarna kan regel B.3b. de oude bel inladen ,[b,n]a in de index array. Dan pas laadt B.3a. de nieuwe basis bel a, om ver­volgens in tandem met regel B.4a. de array van rechts naar links met een nieuwe rij elementen ,[i,n]a op te vullen.

# Googologie 2.6

De array functies van Bowers & Bird (B&B) rollen series van gelijke separa­toren uit. Dit schept een ruimtelijke structuur, waar de­zelfde index arrays in verschil­lende posities kunnen staan.
Zowel 1.) de B&B snellere start, als 2.) de B&B arrays met herhaalde indexen, zijn over­bodig voor het maken van grote getallen, zodra we de nest diepte direkt opblazen.

Het 1e) bleek uit ons Btrix systeem, dat langzaam op gang komt, maar net als B&B sub­arrays her­haalt. Met het begin trio drukt Btrix dubbele recursie uit, net als de eerste rij in Bellen­blazer. Met de index voor dimensies benadert Btrixj de lineaire array van B&B. Ondanks de voor­sprong van B&B lopen zij met hun geneste arrays niet verder uit op Btrix, qua niveau.k
Ten 2e), door herhaling van seps ver­dubbelt bij B&B per genest array niveau de ex­pressieve kracht, ten op­zichte van onze bel­nesten die elke sep apart indexeren. We geven hier twee argu­menten voor:

2a.) Uit de eerdere vergelijking in box 2.4 bleek, dat een structuur met unieke seps met index [n] op het 3e array niveau, dezelfde ge­tallen maakt als her­haalde seps met index [n1] op het 2e niveau.
Aas­blazer is een super radix, waar elke array apart reduceer­baar is en dus blijft de gevonden pro­portie op ieder niveau van kracht. Maar omdat het puur om de data capa­citeit van struc­turen gaat, ver­wachten we dat ook in Bellen­blazer de unieke index arrays dubbel genest zijn ten opzichte van de her­halende, bij even grote uitkomsten.

2b.) Beide geneste structuren hebben we al eens afgelopen met onze Alexal super radix. Toen bleek de structuur van unieke indexen op genest niveau :kk: en :kk1: gelijk aan herhaalde indexen op :k: niveau. We werkten de vloei­bare arrays van Alexa uit tot tetratie. En net als bij Aas­blazer kwam per nest een expo­nent op de machts­toren.
Ook zochten we een natuurlijk algoritme, om de unieke index struc­tuur opnieuw te laden met sub­totalen. De eerste poging was Blixam die bel b ver­laadde en verving door aas a. De tweede opzet heette half geneste arraysn en daar hielden we bel b en stuurden een kopie.

Chris Bird herhaalt14 elke separator, zodat zijn array niveau's twee keer zo­veel indexen bevatten dan bij unieke seps. Maar halvering van nest­diepte stelt weinig voor, verge­leken bij de bel op/inlaad recursie, in de wed­loop tussen Bellen­blazer en Bird's arrays. Door hierna de diepte op te blazen met de bel valt die factor 2 ver­schil in het niet.

Hier ontwikkelen we Bellen­blazer over de tweede dimensie, met rijen in het array vlak. Net zo lang als er verge­lijkbare expressies zijn in het systeem voor grote getallen van de wis­kundige John H. Conway.
Conway's pijlketen15 [Conway's chained arrows] is een recur­sieve functie, die getallen ver voorbij de Ackermann functie noteert.
Conway bedacht zijn pijl­keten als vervolg op Knuth's pijlen ofwel ^ super­machten. Zijn enkele pijlen spelen dezelfde rol als komma's in een array functie.

Vanaf super­machten a{c}b = abc bouwt Conway verder aan zijn hyper­macht functie, waar met elke vol­gende pijl z een dubbele re­cursie (over de hele ex­pressie) wordt genest in y.
Conway lost zijn keten van de rechter zijde op, zonder de voor­laatste para­meter y=1 opnieuw te laden. De laatste para­meter 1 0 of de laatste twee 1z 0 vallen weg, zodra z of y zijn afge­teld.

Stapsgewijze definitie C.I van Conway's pijlen.

  • ab = ab
  • X1z = X
  • X1 = X
  • Xy1z1 = X(Xyz1)z == X(..X..)z :y:

Een getal herhalen a.. is vermenigvuldigen, primi­tieve recursie. Die operatie herhalen geeft een macht. En zo, door operaties meerdere keren te herhalen .. krijgen we supermachten: dubbele recursie.
Bij herhaling zet z in y nu een dubbele recursie in over de hele keten, tot de binnenste y is afge­teld. Over de hele lengte van de pijl­keten vormt dit de volgende hogere functie, een tripel recursie.

Voorbij supermachten liggen de gebieden van de hyper­machten en de snel groeiende hier­archie. Dit zijn vage historische aan­duidingen voor functies, waar Conway's pijl­functie con­crete grenzen heeft.
We zullen het begrip hyper invullen zoals Bird16. In het verlengde van zijn ene multi-dimensionale index drukt hij de hyper-dimensies uit met een rij indexen. Zo volgt bij Conway na de super­machten c een rij para­meters, die elk dezelfde re­cursie toe­passen op de hele expressie. Conway's pijl­keten is dus de hyper­macht functie bij uitstek.

Graham's getal uit §2.2 wordt met [6,[1,1]64]3 bena­derd ≈> via het nesten van super­sterren in het derde item. Want de dominante super­macht 3*{6}2 = 3↑↑↑↑3 vormt de top van een toren van 63 dubbele recursies.
Ook is [6,[1,1]64]2 mini­maal kleiner <≈ dan Graham's getal. En met a=4 is die ex­pressie al veel > groter. Maar meestal nemen we het niet zo aas nauw met onze mini­maal groter ≈> bena­deringen.

De vergelijkingen beginnen met dubbele recursie, het trio in Conway's pijl­keten. We refereren naar de eerste rij formule van Bellen­blazer.

  • [b,[1,[1]1]1]a := [,[,1]b]a = [,[b]a]a = a*{b}a = aab- = a2b
  • [,[2]b,[1,1]1]a := a**b,[1,1]1 = a*{a^b}a ≈ ab22 {ab}
  • [b,[1,1]1c]a = [,[,1]b,[1,1]c]a := a*{b}a,[1,1]c = a*{a*{b}a}a,[1,1]c- = a*{..a*{b}a..}a :c: ≈> ab(..ab..) :c: = abc12
  • [1b,[2,1]1c]a := a,[1,1]b,[2,1]c = a*{..a..}a.,[2,1]c :b: ≈> aab2,[2,1]c ≈> aa(..b..)2 :c1: ≈> ab1c13
  • [1b,[1d,1]1c]a := a,[d,1]b,[1d,1]c ≈> aabd1,[1d,1]c ≈> aa(..b..)d1 :c1: ≈> ab1c1d2

Op zich drukte de Bellen­blazer rij met zijn 1e index super­machten uit, ongeveer als een pijl­keten met 3 para­meters.
Op de tweede rij met seps ,[d,1] houdt die index d- gelijke tred met Conway's 4e para­meter, als die de laatste in de keten is.

Evalueer Bellen­blazer's 2e index in verge­lijking met de hele pijl­keten van Conway. Met e rijen in het vlak is iter index d ongeveer gelijk aan a..d1 :e2 Conway's laatste para­meter z (en gelijker nog met een pijl­keten variant, die z zou af­tellen tot 0 in plaats van 1).

  • [b,[1,[1]2]1]a := [,[,2]b]a := ,[b,1]a = a,[b,1]a- ≈> aaa-b1
  • [b,[1,2]1c]a := ,[b,1]a,[1,2]c ≈> aaab,[1,2]c ≈> aab22,[1,2]c- ≈> aabc12
  • [1b,[1d,2]1c]a := a,[d,2]b,[1d,2]c ≈> aaabd1,[1d,2]c ≈> aab1c1d2
  • [b,[1,3]1c]a := a,[b,2]a-,[1,3]c ≈> aaaab,[1,3]c ≈> aaabc12
  • [b,[d,3]c]a ≈> aaabcd1
  • [b,[1,e]1]a ≈> a..b :e1>2
  • [b,[d,e]c]a ≈> a..bcd1 :e>0

Met index e maken we in Bellen­blazer de sprong over de hele keten van Conway. Die tweede index is even krachtig als Bird's 4e element [entry]. Check zelf het bewijs17 van Chris Bird, dat dit getallen in de orde van Conway's pijl­keten functie betreft…!

Bird's formule voor Conway's pijl­keten versus de Bellen­blazer formule met twee indexen, die onze dim 2 array ruimte met rijen van iters vult.

{a,b+1,c,d+1} {a>2,b>0,d>0}
   ≈> a..bc1 :d1 <≈
[1b,[1c,d]1]a := a,[c,d]b

Doordat we indexen in Bellen­blazer aftellen tot 0 loopt onze d hier 1 voor op Bird's para­meter waarde. De Bellen­blazer rij was trager, dus begint deze index array 2 posities verder.
In box 2.6 zagen we, dat door complete index­ering de oneven array niveau's in Bellen­blazer functio­neren als sepa­rator her­haling in Bird's array ruimtes. Dat begint op ons 1e of top niveau. De factor 2 niveau verschil van geneste arrays blijft onze grootste achterstand op Bird.

Welke formule Conway's pijl­keten het dichtste benadert…? Voor het ver­volg is dit onbelang­rijk. Maar doe onze demon­stratie over en druk Bird's functie uit in Bellen­blazer…!

i. Hoe heten de grote getallen?, gg: Nummer namen App in "Ogen op Stokjes!" voor de jeugd (iteror 2014).
j. Bird's lineaire array lengte is gelijk aan Btrix' multi­dimensionale index, gg: Cubic and Dimensional in "Bea's dimensions" voor Btrix matrix (iteror 2014).
k. Btrix dim-rij wisseling is even snel als Bird's rij-dim wisseling, verder nesten ver­andert deze struc­turele afstand niet, gg: Nesting depth in "Beat nested arrays" voor Btrix matrix (web 2014).
l. Als alle sub­structuren uniek zijn, ver­dubbelt dit het aantal geneste niveau's, gg: Sentry to row format in "Alexa 2nd - Fluid Structures" voor Brobding­nagians (blog feb 2015).
m. Hoofdregels: opladen, subladen, gg: Blixa system in "Blixa Nested Arrays" voor Brobdingnagians blog (concept apr 2015).
n. Onze arrays zijn half genest, gg: Half nested arrays in "Big number systems" voor Iteror (blog okt 2015).
14. Bird's geneste arrays, behandelt recursieve functies met limiet ordinaal ε0, Chris Bird, Nested Array Notation, 2012.
15. Onze eigen pijl­keten notatie benoemt nog veel grotere ge­tallen, p.61 in Conway & Guy "The Book of Numbers" 1996.
16. Is een [a,b,c,...] dimensionale array, Chris Bird, p.1 in Hyper-Dimensional Array Notation, 2017.
17. Bewijs dat Bird's lineaire array met 5 of meer elementen voorbij Conway's pijl­keten gaat, Chris Bird, Proof, 2006.
Gulliver redt de vloot van Lilliput

Tuesday 28 November 2017

Bellenblazer

§2.5 Bellenblazer

We gaan een array functie ontwerpen voor grote ge­tallen met simpele, natuur­lijke regels. Dit Bellen­blazer systeem heeft een con­stante aas a>0 en een varia­bele bel b0 in de basis. Door de aas her­haald op te tellen bij de bel groeit daar een sub­totaal, waar­mee we afge­telde ite­raties keer op keer nieuw leven inblazen.
Het grote idee van bellen­blazen13 is, dat ook zonder substi­tutie van de hele functie (sub­expressies), maar enkel met optellen en substi­tutie van varia­belen (op­laden) een functie maxi­maal kan worden.

Het Bellen­blazer algo­ritme begint met het op­tellen van a.. azen.
Voor de eerste iter in de rij, de factor c van vermenig­vuldiging, staat sep­arator ,[1] die we ook wel := schrijven als , enkele komma.

  • [,[1]1]a := [,1]a = [a,]a = [a]a = a
  • [b,[1]2]a := [b,2]a = [ba,1]a = [baa]a = aab
  • [b,[1]1c]a := [ba,c]a == [ba{1c}]a = a*c1+b

We schuiven b hogerop in de functie en zetten a er­voor in de plaats in de basis. Dit is niet signi­ficant kleiner dan een regel die een kopie van b ver­laadt. Dat kan ook, maar leidt tot verdub­belen, meteen al zonder vermenig­vuldiging. Dit zagen we met Super­plussen in box 2.1 en met Péter's functie en later weer met ons Wiele­waal systeem.

We zullen Bellen­blazer expressies op twee manieren schrijven. Onze uitgeklede array notatie helpt om bere­keningen op te bouwen:
Strikt volgens de defi­nitie, de bel binnen de array [b,X]a en de aas rechts er­buiten. Bel b tellen we van rechts bij.
Of zonder functie haken b,X maar met a erin genoemd. We keren een bel ba alvast om ab uit de array vorm.

Na index 2 komt iter d van machts­verheffen, wat vermenig­vuldiging a*.. her­haald. De 3e iter e stapelt machten a^.. als een toren van expo­nenten, te be­ginnen met de hoogste expo­nent. Dit is een bel b, die we met een pop operator \^ boven­op de reeks machten plaatsen.

  • [,[2]2d]a := a,[2]1d = 0,[1]a,[2]d = a*a,[2]d == a*..a,[2]1 :d = a**d2 = a^(d+2)
  • [b,[3]1e]a {b>0} = [,[2]b,[3]e]a := a**b,[3]e == a**..b,[3]1 :e = a**..b :e1 = a^^e1\^b

De Bellen­blazer rij is een lineaire array functie die Knuth's pijlen ^{n} weer­geeft. We willen dat de iteraties kloppen met deze super­machten, waarbij we iters en al hun indexen (niet alleen de eerste in sub­arrays) af­tellen tot ze leeg 0 zijn en dan opruimen.

Na dit stroeve begin verloopt de evaluatie van Bellen­blazer soms zelfs makke­lijker dan die van super­sterren. De regels van beide sys­temen ver­schillen enigs­zins, maar de­zelfde getallen kunnen we met super pop­sterren of met Bellen­blazer arrays uit­drukken.
Neem twee passages uit de eva­luatie naar een getal a****f3, waar varia­belen met dakjes ^^ staan voor in­middels uit­gewerkte getallen. Popster intro met pop­schuiven == vatten we in Bellen­blazer samen = met de regel voor op­laden van de bel van links.

  • a*{4}3f = a+*{3}a*{4}2f == a*{3}a+*{3}a*{4}1f == a^^-a+*{2}a*{3}1+*{3}a*{4}1f = a*{2}a^^-a+*{3}a*{4}1f == a^^a+*{3}a*{4}1f == a*{3}a^^^2+*{3}a*{4}f == a^^^3+*{3}a*{4}f
  • [,[4]3f]a := a,[4]2f = ,[3]a,[4]1f == a^^a-,[3]1,[4]1f = ,[2]a^^a-,[4]1f == a^a^^a-,[4]1f = ,[3]a^^a,[4]f == a^^a^^a,[4]f === a^^..a :f2 = a^^^f3

Array systemen voor grote ge­tallen starten we links met kleine ite­raties en bouwen de grotere struc­turen rechts aan. We redu­ceren iters in een expressie l-r van links naar rechts, de grotere later. Series af­komstig van de meest rechtse ite­raties zijn het langst, maar die komen dus pas later in de eva­luatie vol­ledig aan bij de bel.
Voor Bellen­blazer is bepalend dat we iter­atoren links 1Z willen af­tellen en daar­na recht­streeks op­laden met de bel. In de bel moeten we dus steeds aan de rechter kant erbij tellen, wat kortere series a.. alvast naar links duwt, want na opladen komen die het eerst aan de beurt.
Wat links staat is kleiner en evalueren we eerder en blijft links houden. Dit is onze array telvorm.

Maar als we commu­tatief optellen zoals Cantorf, dan vallen kleinere getallen weg als er rechts een groter on­eindig ge­tal naast staat. Terwijl we ons algo­ritme willen af­stemmen op het blazen van on­eindige azen. Kleinere series ω.. moeten blijven bij­dragen aan het totaal.
Om de uitkomst af te lezen uit de array expressie draaien we een bel gewoon ωb om. Zo krijgen onze onein­dige getallen de wis­kundig gang­bare r-l tel­richting, de Cantor telvorm.
Mocht de wis­kunde over­stag gaan en de l-r richting van onze arrays over­nemen (eerst links klein dan rechts groot), dan kan regel B.0. de moge­lijk on­eindige output bw alsnog zo laten.

Definitie Bellen­blazer B.I van de construct *{1} array rij.

  • B.0. [bw]a = wb
  • B.1. [b,[1]1Z]a = [ba,[1]Z]a
  • B.2a. [X,[n]]a = [X]a B.2b. [b,[n],Z]a = [b,Z]a
  • B.3. [,[1n]1Z]a = [a,[1n]Z]a
  • B.4. [b,[2n]1Z]a = [,[1n]b,[2n]Z]a

Deze regels matchen door = de hele expressie. Onder voor­behoud in B.4. dat {b>0} kunnen ze in elke volg­orde worden toe­gepast.
De lege sep ,[] is hierbij niet nodig, maar zou kunnen weg­vallen met poptellen, zodat a,[]b1 per unit 1 links bijtelt tot b1a.

De primitieve stap met optellen van aas en bel in regel B.1. is een klasse *{0} constructie. Hoofdregel B.3. itereert over elementen ,[n] in de *{1} rij structuur, waar­mee we super­machten uit­drukken. Echte functie recursie met nesten van sub­expressies is on­nodig, want in diep geneste arrays is het opladen van bel b vrijwel maxi­maal.

Hulpregels b.I voor notaties := en samen­vatting in Bellen­blazer.

  • b.1. ,[1]1 := ,1
  • b.2. [b,Z]a {aZ} := b,Z
  • b.3. [1b,[2S]1Z]a = [a,[1S]b,[2S]Z]a

In een systeem met binaire code kan aan ge­tallen een 0 vooraf gaan. Andere tekens krijgen een dubbele nul prefix 001{n} met nummer. Leeg getelde elementen worden dan gevolgd door 000 tekens.

Tekens voor evaluatie, vervang de linker expressie door die rechts:
 = Evaluatie van de gehele expressie.
== Pas voorgaande evaluaties herhaald toe.
`= Herschrijf de eerste l-r match in expressie.
=` Evalueer de match die l-r het eerst eindigt.
 ≡ Is altijd equivalent, maar l-r met voorrang.
?= Werk operaties uit met voorrangsregels.
=! Werk operaties strikt rechts associatief uit.
:= Ga over naar een alternatieve notatie.
=: Keer de evaluatie richting tijdelijk om.
 ≈ Is ongeveer gelijk aan.
≈> Is insignificant groter dan.
<≈ Is insignificant kleiner dan.
=# Waardes in volgorde van evaluatie.

Formuleren we de eerste rij van Bellen­blazer, de lineaire array, met super­macht operaties.

  • [,[1n]1f]a := a,[1n]f = a,[n]a-,[1n]f- = a*{n}a,[1n]f- == a*{n}(..a..) :f: = a*{n1}f1
  • [f0.,[1ni]fi..]a :r {f>0} = f0.+*{ni}a*{1ni}fi.. :r = ..a^{ni}fi\*{ni}.f0 r:

Links in de array kan de bel vanaf f0=0 beginnen, als deze optelt + bij een element ,[1]f1 dat a her­haald optelt.
Of bel f0>0 vermenig­vuldigt * na her­haald vermenig­vuldigen, als eerst het element ,[2]f1 komt. Dit is nog commu­tatief.
Anders volgt eerst ,[1n1]f1 wat een super­exponent *{n1}b blaast op een toren van ope­raties *{n1}a die we van rechts uit­werken.
Uit de eva­luatie volgt dat elke vol­gende index op de rij ni1>ni een hogere super­macht is. Maar de bel die we op­laden onder een index kan daar­voor ni<ni- gevormd zijn uit hogere super­machten. Dat ligt dan aan de input expressie.

Iedere iteratie is de rechts bijge­telde serie 1.. in de bel weer langer dan daar­voor. Bellen worden naar iters en indexen ver­laden en van links weer afge­teld. Bij on­eindige :ω reeksen van a.. lezen we de output af ω: in Cantor's tel­richting.
Een samengestelde aas zouden we in aan­vang a=nω omkeren. En omega ω is in onze arrays van links oneindig af­telbaar. Omega keer min -{ω}ω afge­teld van omega telt de iter 0 leeg. Hoewel we min - tekens liever achter ge­tallen noteren.
In een successor functie Ωg zullen we ω opvatten als oneindige unit. Zoals unit 1 de natuur­lijke ge­tallen vanaf 0 telt, zo stamt unit ω af van 1 op een hoger plan.h

De Bellen­blazer rij geeft de elemen­taire ope­raties en super­machten mooi weer. Dit is onze natuur­lijke lineaire array functie.
Als sub­totaal b opgeladen wordt komt de bel leeg. Vanuit deze situatie moeten we diepere index posities opladen. Om zo'n functie natuurlijk en maximaal te maken voor geneste arrays, is dat mogelijk…?

f. Sommige verzamelingen getallen kunnen niet oneindig worden afgeteld, gg: Count from omega in "Bigger" voor Btrix matrix (iteror 2014).
g. Omega-telbaar binnen een bigOmega functie, gg: Omega oneindigheid in "Mathmuis... plaatst een Record Getal" voor NAW (concept 2010).
h. Een volgende grotere oneindigheid in Omega Ω, gg: Higher omega in "Omega jumps" voor Btrix matrix (iteror 2014).
13. Zolang de Bel leefde was de Bellen­blazer buiten zichzelf geweest, uit Peter Sloterdijk "Sferen" 2005, p.219 in Joke Hermsen "Stil de tijd" 2009.
Gulliver redt de vloot van Lilliput

Thursday 2 November 2017

Aasnesten

§2.4 Aasnesten

We kunnen Aas­blazer gebruiken als super radix systeem, zodat ieder geheel getal een unieke input ex­pressie heeft. In radix ex­pressies zijn alle para­meters en indexen kleiner dan het basis getal a.
De Aas­blazer evaluatie trein rijdt met aas a ver naar rechts de array in, vult station na station de voor­gaande elementen, tot getal a bij bel b aan­komt en uit­eindelijk optelt tot een groot output getal.

Aas­blazer A.II klasse *{2} geneste arrays.

  • A.0. a[bw] = wb
  • A.1. ,[] `= 0
  • A.2. ,[X]0 0
  • A.3. ,[1X]1 ,[X]a,[1X]

De laatste regel is de recursie stap, daarvoor de eliminatie regels.
We nesten rood in blauw ,[X] voor situaties die op elk array niveau voor­komen, groen in blauw ,[X] op top niveau.

Per regel A.1. valt de nulde komma ,[] weg, ook als er links geen getal staat: aan het begin van een sub­array. Nul sep elim is de enige `= aan l-r richting gebonden regel van Aas­blazer (hopelijk blijft dat zo). En dat komt alleen, omdat we zulke mis­plaatste nul seps rechts in de rij input toe­laten, en output zoals altijd uniek bepaald moet zijn.

De equivalentie A.2. verwijdert de seps van leeg­getelde iters 0 aan een array einde of middenin, op elk niveau in geneste arrays.
De meta-tekens 0 geven een leeg   getal aan op die positie in de expressie. Strikt genomen is het cijfer 0 niet aanwezig, aangezien alle getallen in ons systeem uit units 1.. bestaan.

Hulpregels a.II blijven bij aas­nesten van kracht.
Nu worden Aas­blazer's indexen dieper genest: met de tweede rij iters ,[d,1]c waarin de komma , het derde array niveau ,[1] opent.

Tel met de 2e index e het aantal azen a*e in de exponent, en daar met de 1e index d enen bij op.

  • a[,[,[1]1]1] = a[,[,1]1] = a[,[a]1] = a^a
  • a[b,[,1]c] = a[b,[a]c] = a^a*c+b
  • a[,[1,1]1] = a[,[,1]a] = a^a*a = a^a1
  • a[,[1,1]c] = a^a1*c
  • a[,[2,1]1] = a^a2
  • a[,[d,1]1] = a^ad
  • a[,[,2]1] = a^(a*2)
  • a[,[,e]1] = a^(a*e)
  • a[b,[d,e]c] = a^(a*e+d)*c+b

Door deze super radix een index dieper te nesten, gebruiken we al een dubbele expo­nent, zoals in expo­nentiële notatie.
Zo is 10[,[3,1]2] = 2E13 een recent schulden­plafond van de Ameri­kaanse over­heid, namelijk twintig biljoen dollar [US$ 20 trillion].

In Aas­blazer is elk element een machts­factor: de index array vormt een macht van a met rechts zijn factor of cijfer.
Als we de machts­factoren binnen een geneste array met regel A.3. apart uit­werken, zetten we die index rij om naar een enkel getal. Dit index getal fungeert dan weer als expo­nent, ergens in de grote brede boom van machten van a.

Druk de dubbele exponent a^a^n uit met indexen op het 2e niveau in Aas­blazer, waar de dubbel geneste 1e index de posities aan­geeft.

  • a[,[,[2]1]c] = a^a^2*c
  • a[,[d,[2]1]1] = a^a^2*a^d = a^(a^2+d)
  • a[,[,[1]e,[2]1]1] = a^(a^2+a*e)
  • a[,[,[2]2]1] = a^(a^2*2)
  • a[,[,[2]f]1] = a^(a^2*f)
  • a[,[,[3]1]1] = a^a^3
  • a[,[,[3]g]1] = a^(a^3*g)
  • a[,[,[n]1]1] = a^a^n

Als we een groot getal in een radix noteren, verschilt de expressie lengte11 niet signi­ficant van de unaire vorm. Zonder indexen, in een radix systeem waar machten gegeven zijn door hun plaats, scheelt dit slechts de eerste expo­nent in de machts­toren. Dus radix ex­pressie lengte is nauwe­lijks kleiner dan het grote getal zelf.
De recursie in regel A.3. definieert Aas­blazer als radix. De rest is index­ering. Daarom is Aas­blazer een mini­maal algo­ritme.

De input expressies van non-random grote getallen blijven in de Aas­blazer super radix goed leesbaar, omdat er geen reeks nullen hoeft te worden toe­gevoegd. Ons systeem doet het cijfer 0 in de ban. Ook lege plaatsen hoeven niet voor te komen, als we elementen na hun laatste iteratie meteen via regel a.3. op­ruimen.
Toch is de super radix structuur in de uitwerking van grote getallen niet bijster klein. Het aantal elementen dat Aas­blazer voor de evaluatie van a^a^n in gebruik neemt is a^n. Tijdens passages in Aas­blazer wordt de ex­pressie lengte iets groter dan bij een tradi­tionele radix, maar blijft bijna een exponent kleiner dan bij unaire notatie.

# Googologie 2.4

Als we telbare of meervoudige separatoren ,[S].. hadden gebruikt, dan zou zo'n systeem de begin positie van elke index rij uitsparen. Dit geldt voor meerdere gelijke seps (met dezelfde index array) die iter posities aan­geven, niet de vele mixe varianten die moge­lijk zijn.
Hierboven in Aas­blazer representeert de eerste index d dat meer­voud. De index rij in S zou daarop met e beginnen, waar de meer­voudige e index moet ite­reren over aan­tallen {d} via een aparte regel.

Om meer expansie uit onze seps te halen, kunnen we deze beter met iter en al her­halen. Zo'n array systeem (dat o.a. Bird toepast) heeft ook andere regels nodig, om de maten van dimensies te ver­groten.
Een element is een sep-iter paar, dat in een rijen in rij struc­tuur op een bepaald array niveau is genest.
Doordat de exacte positie, die een iter betekenis geeft, afhangt van voor­gaande index arrays, staan alle elementen vast in een file, binnen lagen van array dimensies. Afge­telde elementen tussen­in mogen niet ver­vallen. We zouden ook cijfers 0 kunnen in­lassen, of (zoals bij Bird) ite­raties af­tellen tot 1 en deze alleen aan het array einde ver­wijderen.

Vergelijk de Aas­blazer indexering met een systeem dat meer­voudige komma's her­haalt. We schetsten met opeen­volgende separa­toren het multi­dimensionale aspect van onze dubbel geneste [n] index.

  • ,[d] = , (sep in rij 1)
  • ,[,1] = ,, (open rij 2)
  • ,[d,1] = , (sep in rij 2)
  • ,[,e] = ,, (rij sep in vlak 1)
  • ,[,[2]1] = ,,, (open vlak 2)
  • ,[,e,[2]1] = ,, (rij in vlak 2)
  • ,[,[2]f] = ,,, (vlak in kubus)
  • ,[,[3]g] = ,{4} (3e in 4e dim)
  • ,[,[n]m] = ,{n1} (dim seps)

Als dezelfde index arrays herhaald worden binnen hun dimensie, lijkt zo'n structuur op een matrix. Deze matrix notatie loopt per nest een niveau op onze notatie uit. Het meer­voudige aspect scheelt daarbij maar één index, dat laten we vanaf nu achter­wege.

Dan blijkt het tweede sub­array niveau [n] bij unieke seps overeen te komen met de eerste sub­array [n1] van her­haalde seps. Binnen dieper geneste arrays zal het­zelfde structuur ver­schil gelden.
De vertaling tussen beide systemen is daarmee gegeven. Met unieke index posities zijn onze blazers twee keer zo diep genest, als we met her­haalde indexen hoeven doen.

In Aas­blazer kan elke array tot een getal herleid worden, dat voor de array erboven een nieuwe expo­nent uit­drukt. Een her­haalbare matrix zal per geneste array twee expo­nenten aan zijn toren toe­voegen.
Als we dieper nesten, blijkt dat de super­exponent a^^n van tetratie precies bereikt wordt met nest niveau n in Aas­blazer. Als we dus onze super radix zouden matrix her­halen tot diepte n, dan zou de super­exponent a^^nn ver­dubbeld worden.
Dat is niet zo fraai. Daarom gebiedt de esthe­tiek, dat uniek index­eren de natuur­lijke notatie voor array functies is…

De overeenkomst tussen array niveau's en de uitgedrukte expo­nenten blijkt gaandeweg. Een ver­dieping van indexen voegt een expo­nent toe aan de machts­toren van de output.

Een array niveau dieper, voegen we de derde exponent toe aan onze super radix, met de eerste index op het 4e niveau.

  • a[,[,[,[1]1]1]1] = a^a^a = a^^3
  • a[,[,[,1]1]c] = a^^3*c
  • a[,[,[,1]e]1] = a^^3^e = a^(a^a*e)
  • a[,[d,[,1]e]1] = a^(a^a*e+d)
  • a[,[,[1,1]1]1] = a^(a^a*a) = a^a^a1
  • a[,[,[,2]1]1] = a^(a^a*a^a) = a^a^aa
  • a[,[,[f,g]1]1] = a^a^(a*g+f)
  • a[,[,[,[2]1]1]1] = a^a^a^2
  • a[,[,[,[2]h]1]1] = a^a^(a^2*h)
  • a[,[,[,[n]1]1]1] = a^a^a^n

In theorie zijn alle gehele getallen in dit domein uniek uit te drukken met cijfers 0<ci<a in deze super radix. Maar prak­tisch kunnen we slechts enkele markante grote ge­tallen schrijven.
De lengte van random getallen12 input in Aas­blazer is vanaf tetratie vrijwel gelijk aan de lengte als enen output. Zelfs in het domein tot 10^^4 ont­snappen de meeste ge­tallen aan al onze fysisch moge­lijke notatie systemen, willen we wedden…?!

Geneste arrays in Aas­blazer werken we uit tot tetratie.

  • a[,[,[,[,[1]1]1]1]1] = a[,[,[,[a]1]1]1] = a^a^a^a = a^^4
  • a[.,[..1].1] :n: = a^..1 :n = a^^n
  • a.[pi,..qi] :n>0: = a^(..1..)*qi+pi :n:

Neem een Aas­blazer expressie met geneste index tot array niveau 5, ongeveer gelijk aan een tetratie 2^^5. Tijdens de reductie daar­van tot een reeks enen, zullen in de top array een aantal van 2^^4 factoren voorbij­komen met elk hun eigen index array.
Voor de fysische uitwerking van zulke getallen zijn er in het hele heelal niet genoeg quantum bits. De quantum bit radix van de kosmos kan random ge­tallen schrijven tot 2^10^120 of kleiner eigenlijk, omdat de natuur­wetten alle infor­matie compri­meren.

Dat Aas­blazer een minimaal systeem is, maakt het geschikt voor het op­meten van systemen voor grotere ge­tallen. Op een expo­nent na telt onze super radix de ele­menten in ieder array systeem, dat zijn iteraties heeft inge­bed in dezelfde structuren.
We ontwikkelen Aas­blazer verder als super radix, terwijl we aas a blijven substi­tueren, en nieuwe regels afpassen op de super­machten. Zo zullen we auto­matische sjablonen vormen voor de struc­turen van Bellen­blazer, die bel b invoegt, maar geen rare andere regels toepast. En wat compu­teerbaar is, is in hogere zin weer recursief…!
Maar voorlopig gaan we met behulp van (de maximale structuren van) onze minimale functie een maximale getallen­blaas­machine ijken.

Lastig is nu nog om de overgang tussen types recursie te faci­literen. Een nieuwe hogere index n in Aas­blazer zal a^^n tellen bij het output getal. Con­struct *{2} bestaat uit geneste rijen. De nieuwe regel zal de nest­diepte dus ex­panderen, met één ver­dieping per stap, waar­mee we naar con­struct *{3} uit­breiden.
Is de vraag wat de simpelste regel in Aas­blazer is, waarvan de limiet naar de volgende super­macht a^^^ω gaat…?

e. Een combinatie van gemixte ster indexen, gg: Mixed minority stars in "Number operations" voor bigPsi (concept 2011).
11. Hoe codeer­systemen, codes en unieke descripties relateren aan waarschijn­lijkheid, ch.4 in Peter D. Grünwald "The minimum description length principle" 2007.
12. Het begrip random bij getallen heeft vele lagen, p.124 in Gregory Chaitlin "Meta maths, the quest for omega" 2005.
Gulliver redt de vloot van Lilliput