Belllnesten

Link naar dit blog:
allergrootste.blogspot.nl/2018/03/belllnesten.html
edit jan.2019.

§2.8 Belnesten · hypers

Vorig blog §2.7 werkten we de eerste geneste rij in Bellen­blazer uit en vulden de n-dimensionale array ruimte. In deze dubbele array is elke iter voor­zien van een eigen unieke index.
Nu betreden we de hyper­dimensie met een dieper geneste rij van het derde niveau, afge­teld over een vierde niveau lengte index. Deze rij in matrix dimensie ver­diepen we later zelf tot een matrix. Zo door­gaand vormt dit de geneste arrays, die we hier alvast definiëren.

De regels, die arrays met indexen genest in indexen eva­lueren, blijven het­zelfde. En in Bellen­blazer is elke kind array uniek lid van zijn ouder array, her­haling is daar over­bodig. Deze structuur heet een com­plete index­ering. Maar dan moeten Bellen­blazer arrays voor gelijke out­put twee keer zo diep worden genest als de array ruimtes van Bird.¹⁴ Zie ook googo­logie box 2.6.

Variabele a is steeds de aas constante, die we van rechts buiten de array in­laden. Vars matchen werkt gretig, zodat er direkt na p in de expressie voor regel B.3. geen getal unit meer kan komen.
Tijdens de evaluatie krijgt variabele p=#{b,a} eerst bel b op bezoek en is ver­volgens alleen nog a in die regel. Hoewel een input expressie kan verrassen met andere waardes voor p op die plek.

Bellen­blazer B.IV con­struct *{2} geneste arrays.

• B.0. [bw]a = wb (uitlaad)
• B.1. [b,[1]1Z]a := [b,1Z]a = [ba,Z]a (belaad)
• B.2. ,[S]0 ≡ 0 (ontlaad)
• B.3. [,[1S]1T]p =` [p,[1S]T]a (inlaad)
• B.4. [p,[1S]1 {S>0} =` [,[S]p,[1S] (oplaad)

Als we regel B.4. in de top array gebruiken, dan schuift bel b naar rechts om een nieuwe iteratie op te laden. Is de index array klaar, dan begint de lege bel per regel B.3. met een kopie van aas a.
Maar soms kreeg de nieuwe sep array ,[,S]b een positie index 0. Dan moet de geneste array eerst worden aan­gevuld. De bel moet uit de iter ,[,[1S]1T]b worden over­geladen ,[S]b naar de hoogste lege index vanaf links, want dat is de enige manier om de sub­array te maxima­liseren. Eerst laden we de iter b per regel B.3. in zijn eerste index en daarna schuiven we b even­tueel door per regel B.4. naar de lege index die opge­laden moet worden.
De iter in regel B.3. wordt direkt vervangen door aas a. Soms zullen we steeds verder af­dalen: in een cascade van azen, met onderaan de bel, op weg naar de diepste index­loze array. We passen deze regels toe vanaf de eerste match die =` links eindigt. Zo klopt steeds, dat de origi­nele bel b per regel B.4. als iter van de sub­array is ge­laden, vlak voor­dat daar de nood­zaak ont­staat om een index op te laden.

De methode om de bel van de iter naar de hoogste lege index over te laden, beweegt in een cascade omlaag door geneste arrays. Of­schoon het wel een eeuwigheid duurt om de ver­vangen iters a weer minstens op peil b te krijgen, toch kost dit minder dan 1 tel bij b.
Want stel dat we de eerste index b1 maken en de aas iter 2. Tel die af tot 1, dan krijgen we links ervan ons eigen element. Dit element zal compleet reduceren tot een nieuwe bel b' groter dan de oude bel. Die is zeker groter, omdat de uitge­werkte index array zelf b bevat. Tel de iter nog eens af en de hogere index array vervalt. Een grotere b' laadt dan op als iter van het bedoelde element.
En dit volgt in het ongun­stigste geval, met eerste index b en aas a=2. Bij elke andere index en/of grotere a groeit ons eigen ele­ment met iter b' nave­nant groter. Wat bewijst, dat het opwaar­deren van regel B.3. zodat die bel b overal substi­tueert (in de index laadt, maar ook in de iter laat), minder pre­steert dan 1 op­tellen bij b. Toch is ook die extra tel in ons geneste systeem insigni­ficant.∴

Door de lege bel en iters in de cascade van de regels B.4. en B.3. op­nieuw te vullen met aas a, komen er natuurlijker grote getallen tot stand, dan door overal een kopie van b te laden. Dat goldt ook al voor machten en bij de super­machten op de eerste rij van §2.5.
Met de tweede index op het 3e niveau nemen we de oplaad & inlaad cascade in gebruik. Tegelijk komen boven­op de hyper­pijl →→ een serie Conway pijlen → met para­meters, om recursief het aantal dimensies weer te geven van Bellen­blazer.

• 4 2 3 2 4 2 3 2 §2.7 [b,[1,[1]1,[1,[1]1]1]1]a := [,[,1,[1,1]1]b]a := ,[b,[1,1]1]a =` ,[,[,1]b]a = ,[,[b]a]a ≈> a→↑{b}a = a→→a→b
• [1b,[2,1,[1,1]1]1]a := a,[1,1,[1,1]1]b ≈> a→→a→a,["]b- ≈> a→→a→(..a..) :b ≈> a→→a→b→2
• [1b,[1c,1,[1,1]1]1]a := a,[c,1,[1,1]1]b =: a,["]1,["]b- ≈> a→→a→a-→c,["]b- ≈> a→→a→(..a..)-→c :b ≈> a→→a→b→c1

Steeds voegt de 1e index een rij toe, met lengte c. We verge­lijken dit met de vol­gende Conway → schakel rechts, zodat duide­lijk wordt, dat dit een dubbele recursie blijft, maar voor­taan over hyper-dimensies.

Daarna vormt de 2e index weer een vlak van rijen, net als in §2.6. Die verge­lijken we met de hele pijl­keten lengte, de tripel recursie die een Conway-Knuth pijl →↑ rechts laat noteren.
We voeren een aantal regels tege­lijk uit, eerstens bijv. 4 2 3 3 uit de Bellen­blazer defi­nitie, en verge­lijken dan met een eerder resultaat.

• [b,[1,2,[1,1]1]1]a := ,[b,1,[1,1]1]a ≈> a→→a→a→b
• [1b,[2,2,[1,1]1]1]a := ,[a,1,[1,1]1]a,[-"]b- ≈> a→→a→a→a,[-"]b- ≈> a→→a→a→b→2
• [1b,[1c,2,[1,1]1]1]a := ,[--"]a,[-"]b- =: a,[-"]1,[-"]b- ≈> a→→a→a→a-→c,[-"]b- ≈> a→→a→a→b→c1
• [b,[1,d,[1,1]1]1]a ≈> a→→.a→..b :d
• [1b,[c,d,[1,1]1]1]a ≈> a→→.a→..b→c :d = a→→a→↑d2 {a=b=c}

In onze notatie kunnen we met quotes ["] of ['] een eerdere array aan­halen. Het origineel staat dan in de lijn erboven of anders rechts in de expressie zelf. Dit helpt ons schrijf­ruimte besparen.
We kunnen gequote index arrays [-"] af­tellen met min tekens. Om daarna de eerste index nog eens [--"] af te tellen.

De indexen ,[m] noteren dimensies, hier van een dubbele matrix. Het element ,[1,1]b gene­reert bel­lachelijk veel matrixen. Waar­bij elke super-matrix het aantal dimensies aan­geeft van de matrix ervoor.

Steeds herleiden we uit een eerder eva­luatie patroon de alge­menere evaluaties. Bijv. hier nemen we de uit­werking in het tweede item over uit §2.7 uit een con­clusie. Veri­fieer dat dat patroon met §2.7 in het eerste item niet precies klopt, omdat na de hyper de eerste pijl →a als 1 extra telt bij →↑b, wat wel volgt uit de demonstratie…

• [b,[1,1,[2]1,[1,1]1]1]a := ,[a,b-,[1,1]1]a ≈> a→→a→↑b1
• [1b,[1,1,[3]1,[1,1]1]1]a ≈> a→→.a→↑..a :b = a→→a→↑↑b1
• [b,[1,1,[4]1,[1,1]1]1]a ≈> a→→a→↑↑↑b
• [b,[1,1,[1,1]2]1]a := ,[a,[b]a-,["]1]a =: a,[1,1,[1b]1,["]1]1 ≈> a→→a→↑{b}a = a→→a→→a→b
• [1b,[1,1,[2,1]1]1]a := ,[a,["]b]a =: a,[1,1,["]b]1 ≈> a→→..a→a :b ≈> a→→↑b1

Een index array ,[1,1,[1,1]1,2] in het laatste item zou precies zo uit­werken. Maar de evaluatie trein in Bellen­blazer produ­ceert zo'n tweede rij met (binnen de ouder array) her­haalde ,[1] nooit, niet in de top array en niet in sub­arrays. Regel B.4. maakt elke index links kleiner. Deze geordende structuur verschilt van Bird's ruimtes.
We hoeven dus alleen de tweede rij ,[i,1]pi.. in onze verge­lijking te be­trekken. Bij sub­element ,[1,2]1 bouwen we die straks aan, met een lengte :b van de bel.

Zowel index vorm [a,[m]b als de pijl operatie →↑{m}b1 stapelen een rij van b recursies van type m1. Met ,[1,1]2 geeft dat twee →→ hyper­pijlen en bij ,[1,1]b de herhaling →→↑ ervan.
We verspillen zo een hoop opera­toren helaas, omdat getallen links in Bellen­blazer arrays na hyper­pijlen →→ rechts komen te staan. Zonder her­laden valt elke 1→Z weg en dat maakt de pijl­functies lang­zamer, in Bellen­blazer kan y=1 op­nieuw mee­doen met de ge­blazen bel.

We hebben nu genoeg voor­beelden gezien, om de alge­mene defi­nitie van dit soort →{n}↑{m} pijl­functies te geven. We noemen ze:
Conway-Knuth hyper-recursieve pijlen
Zulke getallen zijn verschrik­kelijk groot ja. En we raken hier pas aan het begin van Bellen­blazer en Bird's hyper-dimensionale arrays.¹⁶

In deze duale operator houden we de Conway hyper­pijlen →.. links en de Knuth super­pijlen ↑.. rechts gescheiden. Alleen de tussen­stap in de reductie van hyper­pijlen wijkt even van dit plan af.
Onze definitie gebruikt de volgende kaart sym­bolen. Pas het formaat en de stijl ervan aan door op de box te klikken [voor mobiel].

• ♥ ≡ →{n}↑{m} {m>0||n>0}
• ♠ ≡ →{n}↑{m} {n=1||m>0}

Conway's recursie wordt met ♠ beperkt, zodat de hypers →{n>1} zonder supers (uit ♥) niet onder zijn regel vallen. En hoewel we er geen bezwaar in zien, komen super­pijlen x↑{m}y→z vanzelf niet zo voor in de evaluatie trein.

Definitie C.II van recursie met Conway-Knuth Hyperpijlen.

• y*z ≡ y.. :z
• y♥1 =! y (init z)
• y↑z1 =! y*y↑z (macht) == y*..y :z
• y♥↑z1 (Knuth pijlen) =! y♥y♥↑z == y♥..y :z
• ♥1♥z =! 0 (init y)
• X♠y1→z1 (Conway pijlen) = X♠(X♠y→z1)→z == X♠(..X..)→z :y:
• x→y = x↑y
• ♥→z =! ♥↑z (pijl init)
• ♥→y→z1 (Hyper pijlen) =! ♥↑→y→z == ♥↑{z}→y→1 =! ♥↑{z1}y

De evaluatie links van sub­array ,[2,1] nemen we over van eerdere ,[1,1] uit­werkingen. Bellen­blazer voegt met dimensie index ,[m] eerst extra supers ↑{m} toe, die samen hypers →→ vormen.
Het inladen van bel b naar diepere niveau's ,[b] in Bellen­blazer zal de vaart erin houden bij het maken van grote getallen.

• [1b,[2,1,[2,1]1]1]a := a,[1,1,[2,1]1]b = a→→↑a,["]b- ≈> a→→↑(..a..) :b: = a→→↑b1→2
• [b,[1,2,[2,1]1]1]a := ,[b,1,[2,1]1]a ≈> a→→↑a→a→b
• [b,[1,1,[2]1,[2,1]1]1]a := ,[a,b-,[2,1]1]a ≈> a→→↑a→↑b
• [b,[1,1,[3]1,[2,1]1]1]a ≈> a→→↑a→↑↑b
• [b,[1,1,[1,1]1,[2,1]1]1]a := ,[,[b]a,["]1]a =: a,[1,1,[1b]1,["]1]1 ≈> a→→↑a→↑{b}a = a→→↑a→→a→b
• [b,[1,1,[2,1]2]1]a ≈> a→→↑a→→↑b

Uit element ,[2,1]c komt links een rij indexen p0.,[i]pi.. met lengte :b die de lengte :b' bepaalt voor de latere rij indexen.
Het evaluatie patroon is nu helder en het einde van het stapelen met alleen → en ↑ pijlen komt in zicht, bij de 1e hyper index in m,[1]n op het 3e rij niveau in Bellen­blazer.

• [b,[1,1,[3,1]1]1]a ≈> a→→↑↑b
• [b,[1,1,[1,2]1]1]a =: a,[1,1,[1b,1]1]1 ≈> a→→↑{b}a = a→→→a→b
• [1b,[1,1,[2,2]1]1]a =: a,[1,1,[1,2]b]1 ≈> a→→→..a→a :b ≈> a→→→↑b1
• [b,[1,1,[1,3]1]1]a =: a,[1,1,[1b,2]1]1 ≈> a→→→↑{b}a = a→→→→a→b
• [b,[1,1,[1,1,[2]1]1]1]a := ,[,[,b]a]a =: a,[1,1,[1,b]1]1 ≈> a→{b}↑{a}a = a→{b1}a→a

Uit deze patro­nen leiden we een formule met meer­dere para­meters af. Wat meer naar links in de expressie staat doet er rela­tief min­der toe en een iter is minder signi­ficant dan zijn index array.

[b,[d,e,[m,n]f]c]a
 ≈> abcde→{n1}↑{m}f
  = abcde→{n2}f→m

Twee maten bepalen deze duale pijlen: het aan­tal Conway →{n} hypers en het aan­tal Knuth ↑{m} supers. Wat over­een komt met de twee indexen m,[1]n van dimensie m en de eerste hyper­dimensie n in Bellen­blazer.
Voor hogere indexen zullen we de struc­tuur en het algo­ritme van deze hyper­pijl functie verder moeten expanderen.

We hadden de Conway-Knuth definitie ook op kunnen zetten als een gemengde ♦ pijlen­mix →↑{mi}.. met :n1 maten mi in serie. Dat is dan te verge­lijken met de rij hyper-indexen [m0.,[i]mi..] :n in Bellen­blazer.
Zulke hyper­pijlen stapelen al de vorige functies weer boven­op de volgende operator. Net zoals we in Bellen­blazer bel b af­leiden van de linker sub­expressie en die uit­komst in­laden in de diepste vrije index.

Maar geneste arrays noteren de grootste getallen en we kunnen hier al rijen indexen of pijl arrays →S↓ aan Conway's functie hechten.
Laat een geneste functie recursie­pijlen ↑{k} af­tellen als index. We scheiden die met sep­pijlen ← die werken als komma en als het ware terug ver­wijzen naar de functie­pijl → als openings­haakje. De pijl array loopt door tot de vrije stop­pijl ↓ die het sluit­stuk is van de operator.

Verder nesten kan door sep­pijlen ←→S↓ te indexeren. Of door op de even index niveau's een sep­pijl ←S↓ als opening te ge­bruiken met → als komma, en op on­even niveau's →S↓ met ← als komma.
De eerste methode zouden we kunnen toe­passen bij her­haalde seps in de stijl van Bird. De afwis­seling van pijl opera­toren per niveau past beter bij de comp­lete index­ering in de stijl van blazer sys­temen. Steeds komen pijl ↑.. indexen over­een met getal 1.. indexen in arrays.

Als de [m index, die dimensies van iter­ator posities telt in Bellen­blazer, na de eerste hyper index ,[1]n verder wordt uitge­breid tot een hyper rij met lengte ,[p] op het vierde niveau, dan noteren we getallen met hyper­dimensionale arrays.
Hoewel onze hyper-ruimte even groot is als die van Bird, is de getallen output een orde van grootte kleiner. Want wat bij Bird een Ackermann functie over {a,b,c} is, vergt in Bellen­blazer de lengte ,[c] van de eerste rij. En Bird's lineaire array verge­lijkt met matrix dimensies ,[m] in Bellen­blazer. Zodat onze index [p] van hyper-dimensies gelijk komt met Bird's multi-dimensies en iter n daar­over de lengte aan­geeft van zijn dimensies. Ons element ,[p]n loopt dus twee niveau's achter.

Met het vol­gende ge­neste ele­ment ,[s]q maken we van de dimensie index in Bellen­blazer een matrix. In gelijke ruimtes blijft het blazen van bellen b onge­veer even sterk als Bird's op­laad systeem. Daar­om is de output van onze matrix in matrix gelijk aan de geneste rij bij Bird, dat is zijn hyper-dimensionale array. Onze index [s] op het vijfde niveau eve­naart dus de lengte van Bird's hyper-index array.
Als we doorgaan met rij in rij nesten, dan kan elke index een matrix en elke matrix haar hyper-matrix omvatten, zo­als in een ma­troesjka pop. De eva­luatie regels gaven we in de alge­mene defi­nitie B.IV voor geneste arrays.

Na een langzame start is het Bellen­blazer algo­ritme vrij­wel maxi­maal, alleen onze index struc­tuur rijdt 2 op 1. Elk on­even niveau is gelijk aan een niveau van Bird. Dat zullen we nog be­wijzen door onze expressies te verge­lijken met de PDFs¹⁸ die Chris Bird bij MRob deponeerde, in het volgende hoofdstuk.
Daar zullen we overal een groei­bel a substi­tueren, zoals de Aas­blazer radix A.II overal constante a oplaadt. En we verge­lijken deze blazer Wielewaal met een systeem Vogel, dat niet zo mas­sief is als Bird maar dui­delijk gelijk­waardig.

Denkwerk in uitvoering

De syntax is →S↓ met tag S die uit diverse pijlen kan bestaan. Als S=0 dan zijn dit gewone haakjes (X) maar verder is de variatie aan haakjes indexen voor woorden X, die hogere pijl­types be­schrijven, bijna even groot als de ermee uitge­drukte getallen. Al die woorden kunnen weer worden genest, door elkaar ook, zolang hun begin tags ↓T maar een­duidig te vinden zijn.
Het zijn net tags <T> met X tekst inhoud </T> in html.

Om de natuurlijke ontwikkeling van Aas­blazer te blijven monitoren, hebben we met onze Bellen­blazer cascade versus de Conway-Knuth hyper-recursie voor­lopig genoeg grote getallen op voor­raad.
In het vervolg van Bellen­blazer itereren we over array nest diepte met diepen, arrays in serie waar­over gg eerder al blogde.^{q r s}

Een nieuw idee is om naast de functie array ook meerdere arrays in serie te zetten. Ten­einde deze per definitie grotere getallen ψ uit te laten drukken (indexeren), dan fysisch gezien met de functie alleen kunnen worden gemaakt. Een berg van niet-standaard getallen ψ, een soort eindige ω, die buiten het huidige systeem vallen.

Dit zou een twee­traps raket met de aritmetisatie²⁰ van onze (ongeveer) maximale systemen zelf kunnen vormen. Dat wil zeggen, mits de introductie van nieuwe operator tekens te automa­tiseren valt, dan zijn deze telbaar en kunnen we erover itereren in een hogere array functie. Zulke cycli van aritmetisatie kunnen we in theorie indexeren met een volgend hogere array functie. :-) Ad infinitum…

d*e[n[ *h[a[a[g]·
·[2]*]*]*][0][1]*][∞]*

Tenslotte deze opzet voor bellen­blazerij met een strikte l-r notatie van kleine naar grote concepten in RGB kleuren.
Hiermee eindigt mijn Reuzen Getallen Bootstrap werk–versie voor de expositie:

• “Naar Amritsar mijn vriend”   een video installatie van Giga Gerard    Maldoror, Wagenstraat 123, maart 2018

^q. Een herschrijf algoritme voor diepe series arrays, gg: Serial deeps in "Deep attachments" voor Btrix matrix (concept 2014).
^r. We definiëren een systeem van diepe arrays of diepen, gg: Deep numbers in "Big number systems" voor Iteror (blog mei 2015).
^s. Los diepe ster operaties met arrays net zo op als superster operaties met getallen, gg: Birth of the Superdeep in "Big number systems" voor Iteror (blog mei 2015).

^14. Bird's geneste arrays, behandelt recursieve functies met limiet ordinaal ε0, Chris Bird, Nested Array Notation, 2012.
^16. Is een [a,b,c,...] dimensionale array, Chris Bird, p.1 in Hyper-Dimensional Array Notation, 2017.
^18. Een systeem voor snel groeiende recursieve functies, dat de functies van Jonathan Bowers en anderen ver te boven gaat, in Christopher M. Bird's Super Huge Numbers, een serie van 9 PDFs over Bird's arrays + 3 bijlagen, 2017.
^20. Codeer tekens en termen als getallen, ch.5 in John Stillwell, "Reverse Mathematics", 2018.