Reuzen Getallen Bouwerij

bij Giga Gerard

“Kom mee naar buiten allemaal,
Dan zoeken wij de wielewaal.
En horen wij die muzikant
Dan is zomer weer in 't land!”

Canon

X

§3. Dieper

In het vorige hoofdstuk §2 ontwikkelden we een plan voor het maken van grote getallen. Onze nieuwe serie blogs bouwen we van de grond af op, of omlaag eigenlijk, dieper in en dieper dan geneste arrays, hier in Giga Gerard’s
„Reuzen Getallen Bouwerij”.
En wat deze bouwmeester diepen noemt is een serie van geneste arrays [Xi].. die elkaars nest diepte recursief expanderen. Iedere array kan uitgebreid worden tot een diep.
Nadat een index array [][1X] is leeggeteld, blazen de tellers in de diepe array erna het aantal geneste niveau's ervoor recursief op.
Met diepen na de top array geven we een type index getallen aan, met name de groter eindige ψi limieten of hoger oneindige ωi.

Ons Vogel systeem is een simpele benadering van de array notaties van Chris Bird.0 Omdat dit Vogel telraam gelijk op gaat met Bird en goed vergelijkbaar is met de Wielewaal, zal er uiteindelijk een nieuw wereldrecord getal voorbij uw glas Guinness komen vliegen.
Als de evaluatie van een expressie wel in theorie uitvoerbaar is, maar fysiek gezien liever niet, dan heet de uitkomst ervan groot. Al deze arrays geven als uitkomst reusachtig grote getallen.

Lectori salutem Dudeldjo en anders niet.

X

§3.0 Supertrio

Natuurlijke getallen schrijven we met het teken 1 als een serie enen 1.. en variabelen a en b tellen direkt op als ab.
De unaire 1 is eenheid van getal en het minus teken - eenheid van aftelling. Zo komt 1-=0 leeg en getallen n1 nemen af - tot n.
Dit is onze unit notatie voor getallen. Dan staat 2 voor 11, teken 3 voor 111, de 4 voor 1111, enzovoort.
Grotere getallen in het tientallig stelsel schrijven we liever 108. met decimale punt. Bird's arrays zijn omgeven door krulhaken {Y} en we tellen er nog schools in op +1 en af -1.

Reeksen binnen expressies noteren we met repex zo:
Met ^{n} herhalen we het ^ macht teken n keer, wat trouwens gelijk is aan *{n1} bij supersterren.
Punten selecteren een woord .groep.. en de rep herhaalt dat woord :n aantal keer op die plaats. Tijdens zo'n rep incrementeren we indexen i of j vanaf 1. Ook zijn er dubbelzijdige reps :n: en reps n: van rechts, het wijst zichzelf.

Later in dit blog definiëren we een Wielewaal systeem, waar we de variabele a substitueren in een Aasblazer superradix structuur. In de basis verdubbelen we deze aasbel en kopieën ervan schuiven in de evaluatie naar rechts om lege ,0 tellers ,a op te laden. In ruil telt - de volgende teller af. Zo lossen we de hele functie rij op, terwijl laatste ,] posities afvallen en de bel naar de uitkomst toe groeit.
Zo'n array systeem waar een basis variabele door primitief optellen (de lege operatie) groeit en hogere tellers in de rij substitueert, noemen we een tellerij [number array, getal in getal].

Knuth's pijl operaties a^{c}b gingen sneller van start. Ook bij Bird en Vogel hebben supermachten maar drie {a,b,c} parameters. Samen zijn aas a, bel b en super c de tellers van het supertrio.
Deze compacte structuur heeft maximale output, omdat het systeem met elke superstap c-1 een subexpressie $ nest in plaats van de bel. Die $ is een kopie van de expressie met een stap b-1 minder.
Een array systeem waar een variabele door functie substitutie groeit en deze groeibel de lege tellers van alle hogere iteraties oplaadt, noemen we een telraam (function array, raam $ in raam).

Vermenigvuldiging * is de eerste herhaling. Het is jammer dat Bird, net als Knuth en Conway trouwens, met machtsverheffen ^ begint. Natuurlijker is om met drie parameters V(a,b,c) de supersterren a*{c}b = a^{c-}b weer te geven, zoals we in Vogel doen.

Vogel trio definitie V.O.

  • V.0. (a) = a
  • V.1a. (a,1) = a V.1b. (a,b1) = (a,b)a
  • V.2. (a,b,1) = (a,b)
  • V.3. (a,1,c) = a
  • V.4. (a,b1,c1) = (a,(a,b,c),c1)

Alle variabelen zijn unaire getallen 1.. :n>0 want in Vogel staan tellers in de top array nooit leeg. Deze voorwaarde moet duidelijk maken, welke regel(s) van toepassing zijn op de expressie.

Op het demonstratiebord hieronder evalueren we het Vogel trio tot de supermachten, zoals van Knuth en Bird.
Klik op dit dynamische bord <!--> om extra voorbeelden te tonen, of toets Ctrl-U en bekijk deze in de pagina bron.

  • (a,2) = (a,1)a = aa
  • V(a,b) == a.. :b = a*b
  • (a,2,2) = (a,(a,1,2)) = (a,a) = a*a = a^2
  • (a,b1,2) = (a,(a,b,2)) == (a,..a..) :b: = a*..a :b = a^b1 = {a,b+1}
  • V(a,b1,c1) = (a,(a,b,c1),c) == (a,..a..,c) :b: = a*{c}(..a..) :b: = a^{c}b1 = {a,b+1,c} <!-->

Misschien kon Hilbert in 1925 nog niet zonder functie indexen voor zijn hoger recursieve functies; in het bewijs van Ackermann uit 1928 werd de voorganger expressie zonder omweg genest.
Van hun parameter trio bleven in Péter's functie de twee tellers over, waarbij de constante a=2 impliciet gegeven is (met wat extra).

Het lijkt spectaculair om functies zo'n snelle start te geven, maar vanuit het oogpunt van geneste arrays maakt het weinig uit (slechts één nest niveau, blijkt later). Als we over een rij tellers de supermachten bouwen en bel b naar rechts opladen (tellerij), dan hoeven we geen subexpressies te nesten (telraam).

In de box waarderen we met het opladen van aas a de array structuur en met het opladen van bel b de systeem regels. Of deze traagste structuur en dit snelste algoritme ooit bij benadering samenvallen (convergeren, zoals geneste arrays met óf zonder subexpressie recursie dat later doen) is nog onduidelijk…

# Blazers 3.0

Binnen een rij structuur (zonder lengte limiet) laden we lege tellers op met een constante a. Zulke expressies noteren elk getal in radix a.

Definitie À.I van de Aasgier rij.

  • À.0. a[b] = b
  • À.1. a[R,] = a[R]
  • À.2. a[b,1R] = a[ab,R]
  • À.3. a[b,{n1}1R] = a[b,{n}a,R]

Bij deze lineaire array met komma's is regel À.2. een geval {n=0} van regel À.3. voor optellen. Behalve dat voor Cantor's oneindige getallen a=ω omkeren wel nodig is.
De rij expressie stopt, wanneer we gaan nesten na a[,{a}1]- wat decimaal het getal 9999999999. oplevert.

Dit Aasgier systeem kunnen we met geneste arrays uitbreiden tot een tetratie superradix, als bij Aasblazer nesten. De Aasgier notatie verschilt, als we indexen in onderste rijen scheiden met komma's.
Aas a is een radix 10 naar keuze. Dit systeem evalueert als een superradix, waarbij alle rij lengtes en tellers 0pa zijn. En als in de input 0<p<a geldt, dan geven geneste arrays (zonder diepte limiet) alle natuurlijke getallen uniek weer.

Met geneste superradix arrays drukken we een getal uit, dat niet eens een macht van a groter is dan de lengte van de tellers in de top array, mits alle lege tellers erbij staan. Min alle index arrays is de expressie lengte nog een factor kleiner en bovendien wordt die ene exponent steeds insignificanter.
Diep genest en met komma's (nullen) is Aasgier bij benadering een minimaal algoritme (net als unaire notatie) en geeft dus een maat voor pure structuur zonder de regels.


In Bellenblazer telt de primitieve stap aas a op bij bel b, maar over de lengte van de rij worden er supermachten uitgedrukt. We positioneren met unieke indexen en substitueren subtotalen b.
Stel dat we ook in Bellenblazer tellers tot p=0 aftellen, maar toch dezelfde input en output willen schrijven, dan moet de oplaadregel worden aangepast.

Definitie Buizerd rij functie B.I met komma's.

Opladen in Buizerd zouden we op allerlei manieren kunnen variëren: groot, groter, grootst. En toch is dit niet significant voor de uitkomst.

  • a[b,{n1}1R] <≈ a[a,{n}b,R]
  • <≈ a[b,{n>0}b,R]
  • <≈ a[ab,{n>0}b,R]

Deze oplaadregels produceren steeds minder natuurlijke output. En ondanks de minieme versnellingen blijven ze bijna een ^ supermacht achter lopen bij ons Wielewaal systeem. Waar precies de verschillen insignificant worden mag u zelf uitvogelen…!

We zullen Vogel en Bird nu vergelijken met een nieuwe array functie, die we zullen noemen naar de zomerse trekvogel uit een lied. Onze Wielewaal tellerij dupliceert getallen en verschuift ze.
De primitieve functie van Wielewaal is kopiëren en optellen. Tel een kopie op en het getal a verdubbelt tot aa. Herhaal dit c keer en het totaal a*2^c groeit exponentieel.

Na deze machtige start noteren de tellers rechts in de rij nog hogere iteraties of vormen van herhaling. En we schuiven subtotaal a door naar rechts om lege tellers opnieuw op te laden.
Zo leest de lengte van de eerste rij als de superexponent ^{r} van de uitkomst van de expressie. We maken supergrote getallen, ongeveer (maar niet exact) die van Knuth's pijlen.

Definitie Wielewaal rij functie W.I.

  • W.0. [a] = a
  • W.a. a[1R] = a1[R]
  • W.1. [R,] = [R]
  • W.2. [a,{n1}1R] {n0} = [a,{n}a,R]

Elke iteratie stap telt 1 af en we gaan door tot de teller 0 is. Zolang parameters geen positie index krijgen, moeten we de komma's ,, voor hun lege pi=0 plekken laten staan.

De Wielewaal functie gaat snel van start door ab (tegelijk aas en bel) te verdubbelen. Door dat te herhalen domineert de macht 2^c de uitkomst, maar daarna vlakt dit voordeel af. Zonder subexpressie nesten blijft de hele rij achter bij die van Vogel.
Klik op de borden <!--> voor uitwerkingen met concrete getallen.

  • a[1b] = a1[b] == ab1[] = ab1
  • a[b,1] = ab[,1] = ab[ab] = ab*2 = V(ab,2)
  • a[b,1c] = ab*2[,c] = ab.*2.. :c1 = ab*2^c1
  • a[,,1] = a[,a] = a*2^a ≈> V(2,a1,2) {a>1}
  • a[b,c,1] = ab*2^c[,,1] ≈> 2^c1[,ab*2^c] = 2^(c1+ab*2^c) ≈> V(abc,2,3) <!-->

De linker expressie is ongeveer groter dan ≈> de rechter expressie, als de linker output een vrij goede benadering geeft en groter is voor niet te kleine input waarden.

Voor waardes a=b=c=1 in de vergelijking hierboven gaat dat al op, want 2^5 > 3^^2 brengt ons over het kantelpunt heen. Hier luistert de 2^2^6 > 3^^3 minder nauw, maar hoger in de machtstoren zal 2^^d\^6 > 3^^d1 die verhouding in stand houden.

  • a[b,c,2] ≈> 2^(c1+ab*2^c)[,,1] ≈> 2^2^(c1+ab*2^c) ≈> V(abc,3,3)
  • a[b,c,d] ≈> 2^^d\^(c1+ab*2^c) ≈> V(abc,d1,3)
  • a[,,,1] = a[,,a] = a*2^a[,,a-] ≈> 2^^a\^a1 {a>1} ≈> V(a1,a,3)
  • a[b,c,d,1] ≈> 2^^d\^(ab*2^c)[,,,1] ≈> 2^^2^^d\^(ab*2^c) ≈> V(abcd,(abc,d1,3),3) <!-->

Met drie tellers bouwt Wielewaal een toren van d1 exponenten. Dit vormt na + * ^ de nieuwe operatie ^^ van tetratie.

Missen we een a, waarvan het basis 2 logaritme optelt bij de hoogste exponent, dan maakt dat op deze supermacht schaal bijkant niets uit.
Noteren we Wiel nu in pure array vorm.

  • [a,b,c,d] ≈> 2^^^d1\^^c\^(a*2^b) ≈> 2^^^d1\^^c1\^b1 ≈> V(abc,d1,4)
  • [a,,,,1] = a[,,a,a-] ≈> 2^^a\^a[,,,a-] ≈> 2^^^a\^^a1 {a>1} > V(a,a,4)
  • [a,b,c,d,e] ≈> abc^^^^e1\^^^d ≈> V(abcd,e1,5)
  • [a,{r1}1] = a[,{r}a] ≈> 2^{r}a\*{r}a > V(a,a,r1)
  • [a.,pi..] :r ≈> 2..^{i}pi1\. +Log(a/2) r: ≈> V(a.pi..,pr1,r1) :r- > apprr <!-->

Zo drukt Wielewaal W.I over de eerste rij supermachten uit, terwijl Vogel V.I en Bird volstaan met drie parameters. Dat kan omdat hun recursie subexpressies nest, wat telbare haakjes kost / kostbare haakjes telt. Extra tekens om Vogel expressies (.. in de bel ..) te openen en te sluiten, naast index [] haakjes dus. Wielewaal heeft geen aparte functie haakjes voorziening nodig.

In de box zagen we Buizerd functies de bel omhoog blazen. Zo krijgen we vrijwel even grote getallen als Wielewaal, omdat alleen de basisregel verschilt. Door superoperatoren ^.. te tellen vangen we een glimp van de onvoorstelbare grootte ervan.
Zouden er nog andere methoden zijn dan bel b opladen om zulke supergrote getallen te bouwen over een rij…?

X

§3.1 Toprij

In dit blog vergelijken we ons Vogel systeem met de lineaire array van Chris Bird.1 In dezelfde rij structuur loopt het Vogel algoritme volledig parallel aan Bird en produceert maximale (bij benadering de grootst mogelijke) getallen. Daarom dopen we dit onze toprij.
Bird's systeem is tamelijk gecompliceerd, maar we hebben het in appendix U enigszins versimpeld. Dat Uil systeem voor de lineaire array U.I voegt twee van Bird's dominante regels samen. Exact dezelfde input expressies en output getallen blijven geldig.

We vergelijken Bird via systemen U en dan V met W. Het vorige blog §3.0 behandelde drie parameters: het supertrio van U.O > V.O met de supermachten a^{c}b versus a*{c}b, waar in W.I ondanks de snelle opstart een hele rij voor nodig was.
Bird als Uil substitueert subexpressies $ ook in hogere tellers op zijn array rijen. Dat is overbodig, we zullen in het Vogel telraam deze expressie $ met 1 stap minder alleen nog in bel b nesten.

Vogel rij definitie V.I.

  • V.0. (a) = a
  • V.1. (a,b1) = a(a,b)
  • V.2. (R,1) = (R)
  • V.3. (a,1,R) = a
  • V.4. (a,b1,1R) = (a,(a,b,1R),R)
  • V.5. (a,b.,1..R) :k2 = (a,a.,1..b,R) :k1 == (a,a,1.a,..b,R) :k

Als een eerdere regel uit de lijst een match vormt met de expressie (of subexpressie), krijgt deze = voorrang in de evaluatie.
Afkorting R staat voor de rest van de array: een rij van recursie tellers of parameters pi>0. Woord R begint dus met een 1.. getal.

De Vogel toprij volgt Bird's lineaire array, alleen Vogel's super teller c loopt consequent - achter.

  • (a,2,2,2) = (a,a,1,2) = (a,a,a1) = a^{a}a = {a,2,1,2}
  • V(a,b1,2,2) = (a,a,(a,b,2,2)+1) == (a,a,..a..1) :b = {a,b+1,1,2}
  • (a,2,3,2) = (a,a,2,2) = {a,2,2,2}
  • (a,b,3,2) = {a,b,2,2}
  • V(a,b,c1,2) = {a,b,c,2}
  • (a,2,2,3) = (a,a,a1,2) = {a,2,1,3} <!-->

Door bij superexponent c een 1 op te tellen, ondervangen we in Vogel zowel de begin * versus ^ achterstand, als de functie substitutie rechts bij Bird. Zodoende nest regel V.4. in b een extra subexpressie, die regel V.5. oplaadt. En komen we gelijk op de rij.

  • V(a,b,2,3) = {a,b,1,3}
  • (a,2,c1,3) = (a,a,c,3) = {a,2,c,3}
  • V(a,b,c1,d) = {a,b,c,d}
  • (a,2,2,1,2) = (a,a,a1,a) = {a,2,1,1,2}
  • (a,b,c1,1,2) = {a,b,c,1,2}
  • (a,2,2,1,1,2) = (a,a,a1,a,a) = {a,a,a,a,a}
  • (a,2,2.,1..1) :k = {a,2.,1..1} :k1 <!-->

Om voorbeelden uit te werken, klik op de <!--> borden. Blijkt dat expressies in Vogel met de aanpassing c+1 steeds exact gelijk zijn aan die van Bird over de eerste rij.

  • V(a,b,1R) = {a,b,R}

Uitwerking == van regel V.5. geeft derde teller c er 1 bij, zodat rechts opladen van b1 in Vogel de functie substitutie van Bird daar vervangt. Dit bewijst dat beide lineaire arrays gelijk op gaan.


Nu Bird's lineaire array naar de Vogel toprij is omgezet, vergelijken we deze met ons Wielewaal systeem.
Weliswaar startte Wiel in §3.0 sterk met verdubbeling in bel a, maar daarna viel de functie snelheid terug. Zonder subexpressie $ nesten kost het een hele rij om supermachten uit te drukken.
Hierna zal onze a tellerij meerdere dimensies gebruiken, om even grote getallen te maken als een $ telraam doet in zijn rij dimensie.

We positioneren tellers met behulp van indexen en itereren daarover in geneste arrays. Onze superradix indexering pakt natuurlijker uit dan Bird's herhaalde separatoren, hoewel onze structuur twee keer zo diep genest zal zijn, zie box 2.6.
Afgetelde iteraties herladen we met een kopie van bel a, maar anders dan in Bellenblazer blijft onze verdubbel bel op zijn plaats staan. Zo garanderen we, dat het getal a bij substitutie maximaal blijft. Dit is niet triviaal, gezien de bewerkelijke cascade van het herladen van Bellenblazer's index arrays.

De Buizerd varianten op bellenblazer, die we in box 3.0 zagen, zijn slechts insignificant trager dan Wielewaal. Met Buizerd schrijven we net als het Vogel trio *{c} supermachten.
De exacte supermacht getallen noemen we natuurlijk. In die zin is Wiel met verdubbelen al vanaf het begin onnatuurlijk, hoewel de functie definitie daardoor makkelijker is.

Onze scanner zoekt bij een regel A`=B vanaf links in de expressie een match voor woord A om dit te vervangen door woord B. Regels die de hele expressie = evalueren gaan voor. Bij equivalentie kan een woord overal in de expressie worden vervangen.
We hebben geen precedentie door volgorde van de regels nodig, zoals Bird. De meest linkse match in de expressie wordt verwerkt.

Definitie Wielewaal nest functie W.II.

  • W.0. [a] = a
  • W.1. ,[S]00
  • W.2. ,[]0
  • W.3. ,[1S]1 `= ,[S]a,[1S]

Bij regel W.3. staat variabele a voor het actuele subtotaal. Dit wordt binnen de array [a,R] verzameld, of erbuiten a[0,R] als hulpregel W.a. voorrang krijgt.

Hulpregels W.ii voor geneste arrays in Wielewaal.

  • W.a. a[1T] = a1[T]
  • W.b. [,{n}1[,[n]1
  • W.c. ,[m]p1,{n}1 ,[m]p1,[mn]1

Zo kunnen we de eerste rij van een subarray met gewone komma's vertalen naar complete indexering en := andersom.
Voeg aan het begin van array [p,T] met hulpregel W.b. een lege sep in [,[0]p,T] zodat hulpregel W.c. de komma kan bereiken [,[]p,[1]T] waarna regel W.2. de eerste stap terug := neemt voor het beoogde [p,[1]T] resultaat.

Uiteindelijk willen we onze arrays vergelijken met de geneste arrays van Bird4. Met de Wielewaal rij van W.I benaderden we drie Vogel tellers, dus eerst moeten we de toprij van Vogel V.I nog inhalen.

  • [a,[,1]1] = a[,{a}1] ≈> a*{a}a = V(a,a,a)
  • [a,[1,1]1] = a[,[a]a] ≈> a^{a}a = V(a,a,1,2)
  • [a,[2,1]1] = a[,[1,1]a] = a[,[a]a,["]a-] ≈> (a,a,1,2)[,["]a-] ≈> (a,..a..,1,2) :a: = V(a,a1,2,2)
  • [a,[3,1]1] = a[,[2,1]a] = a[,[']a,["]a-] ≈> (a,a1,2,2)[,["]a-] ≈> (a,..a..1,2,2) :a: ≈> V(a,a1,3,2)
  • [a,[,2]1] = a[,[a-,1]a] ≈> (a,a1,a-,2)[,["]a-] ≈> V(a,a1,a,2) aaaa <!-->

Klik op de dynamische <!--> borden om expressies te tonen met meerdere variabelen.
De vergelijking van geneste arrays met Conway's pijlen na de definitie in §2.6 toont meer detail.
De vier schakels breiden al snel uit naar de hele a..1 pijlketen en dan naar de extensie van Conway's notatie met {a} superpijlen.

Wielewaal maakt grote vooruitgang door het subtotaal a herhaald te substitueren in de dominante lengte teller. Dit is recursie over de eerste index van een rij parameters, wat die rij lengte expandeert.

  • [a,[1,2]1] = a[,[a,1]a] ≈> (a,a1,a1,2) ≈> V(a,a,1,3)
  • [a,[2,2]1] = a[,[1,2]a] = a[,[a,1]a,["]a-] ≈> (a,a,1,3)[,["]a-] ≈> (a,..a..,1,3) :a: ≈> V(a,a1,2,3)
  • [a,[,3]1] = a[,[a,2]1] ≈> V(a,a1,a,3)
  • [a,[1,3]1] = a[,[a,2]a] ≈> V(a,a,1,4)
  • [a,[2,3]1] = a[,[1,3]a] = a[,[a,2]a,["]a-] ≈> (a,a,1,4)[,["]a-] ≈> V(a,a1,2,4)
  • [a,[,,1]1] = a[,[,a]1] = a[,[a-,a-]a] ≈> V(a,a1,a,a) a..a :a1 <!-->

In ons systeem met indexen voor alle teller posities deelt de 2e index een matrix van twee dimensies in: het Wielewaal vlak. Terwijl Bird of Vogel pas de 4e parameter in de rij gebruiken.

Opent het tweede vlak in de derde dimensie. Overgang naar nieuwe recursies vraagt altijd extra aandacht, maar evaluatie van de verdere index array in Wiel zal voorspelbaar verlopen.
Klik het bord om vergelijkingen te tonen tot de 3e index in Wiel en de 5e parameter in Vogel. Aan de hand van vlak en nu dan Wielewaal kubus wordt de generalisatie tot matrix dimensies duidelijk.

  • [a,[1,,1]1] = a[,[,a]a] ≈> (a,a1,a1,a) ≈> V(a,a,1,1,2)
  • [a,[,1,1]1] = a[,[a,,1]1] ≈> V(a,a1,a,1,2)
  • [a,[1,1,1]1] = a[,[a,,1]a] ≈> V(a,a,1,2,2)
  • [a,[2,1,1]1] = a[,[1,1,1]a] ≈> V(a,a1,2,2,2)
  • [a,[,2,1]1] = a[,[a,1,1]1] ≈> V(a,a1,a,2,2)
  • [a,[,[2]2]1] = a[,[,a,1]1] ≈> V(a,a1,a,a,2)
  • [a,[,[3]1]1] = a[,[,,a]1] = a[,[a-,a-,a-]a] ≈> V(a,a1,a,a,a)
  • [a,[,[4]1]1] ≈> V(a,a1,a,a,a,a)
  • [a,[,[,1]1]1] = [a,[,[a]1]1] ≈> V(a,a1.,a..) :a a{a}2 <!-->

Per Wielewaal dimensie [n] komt er een superpijl bij, die de lengte van de voorgaande {n} opblaast. Zie de Bellenblazer matrix van §2.7 waar elke dimensie een nieuwe recursieve functie toevoegt. Van de dubbele recursie van Knuth's pijlen, over Conway's pijlketen, naar de verschillende superpijl recursies.

Blijkt dat de tellers op de Vogel rij stuk voor stuk hun gelijke vinden in de indexen van Wielewaal dimensies op het tweede array niveau.

  • [a,[c.,pi..]b] :n V(a,b1,c1.,pi1..) :n

Bird's recursie met subexpressies is aanvankelijk oppermachtig, maar in multidimensionale arrays rijdt Wiel gelijk met zijn lineaire array.
We zijn dan wel twee niveau's dieper genest:
1. Enkele index arrays door de langzame start met optellen versus subexpressies in de bel. Wiel rij Bird's drietal.
2. Een even index niveau (oneven array niveau) door de structuur van unieke seps versus sep herhaling in ruimtes. Wiel matrix Bird's rij.

Aasblazer in §2.4 breiden we met rijen komma's uit tot Aasgier geneste arrays. Omdat we de constante aas a opladen, wat bij benadering minimaal is, gelden deze expressies als maat voor de structuur van Wielewaal.
Aasgier arrays tot a[,[,[,1]1]1] schrijven in radix a=10 getallen tot 10^10^10. Astronomisch groot, maar ordes kleiner dan als we bellen b blazen. En toch, bedenk eens hoe weinig van deze getallen ooit fysiek onder ogen gezien (kunnen) worden…!

X

§3.2 Maxtrix

Een matrix is een dimensionale ruimte, waar op iedere gegeven punt positie een getal genoteerd staat. Maxtrix betitelt hier een maximale multi-dimensionale array, bijzonder die van Chris Bird.2
Dat een getal of teller zelf uit een rij enen 1.. bestaat, ter lengte :n van het getal, blijft buiten onze ruimtelijke beschouwing.

Zo vormt een rij tellers de eerste dimensie. Het snelste algoritme is daar Bird's lineaire array, die we in §3.1 in de Vogel toprij hebben omgezet.
Het is de substitutie van de $ expressie (dubbele recursie) in bel b en het daarmee opladen van afgetelde tellers, wat de grootste getallen oplevert. We noemen zulke maximale functie arrays telramen.

In een tellerij, groeit bel b, die we over de rij en verdere dimensies verschuiven, door unair ab optellen (primitieve recursie). Ons Wielewaal array systeem is zo'n tellerij. We vergeleken Wiel's output in meerdere dimensies met die van ons Vogel telraam:
Supermachten op de 1e rij in Wielewaal met de 3e teller van Vogel. Wiel rijen in het 2e dimensie vlak met Vogel's 4e teller, net hoe Bird de rij pijlketens van Conway benaderde.
Etcetera, Wiel's dimensie d met Vogel's teller d2 in de toprij.

In dit blog evenaren de verdere matrix dimensies in Vogel de multi-dimensionale arrays van Bird. Beide algoritmes evalueren de input matrix tot maximale output. Alleen in hogere structuren kunnen we significant grotere getallen produceren.
Om ondanks de langzaam groeiende bel in Wielewaal even grote getallen uit te drukken, reizen we door de hyperdimensie. In die geneste ruimte leven positie indexen, die zelf rijen en matrixen zijn.

Vogel's regels zijn simpel vergeleken met de massieve evaluatie bij Bird. Hij meet structuren exact af (met lengtes b) en vult ze compleet in (met tellers a). Vogel voegt de nodige elementen stap voor stap toe, soms eerst een lengte a en daarna pas een lengte die b bevat.
Bird's systeem lijkt krachtiger, maar door aan het begin van de meest rechtse rij een extra teller 2, in te voegen, doen Vogel expressies nooit voor die van Bird onder, zal straks blijken.

Vogel matrix definitie V.II.

  • V.0. (a) = a
  • V.1. (a,b1) = a(a,b)
  • V.a. ,p ≡ ,[1]p
  • V.2. ,[n]1) ≡ )
  • V.3. (a,1,[n]Z) = a
  • V.4. (a,b1,1Z) = (a,(a,b,1Z),Z)
  • V.5a. ,[] `= 0 => V.5b. (a,b, 1,1p `= (a,a, 1b,p
  • V.6. (a,b ,[1n]1p `= (a,a ,[n]b,[1n]p

Afgetelde elementen tussenin worden overgeslagen, zodat Vogel in de matrix steeds verder uitloopt op Bird, hoewel dit verschil insignificant blijft. Vogel's telraam presenteert een bruikbare benadering van Bird of de Uil array functie U.II.
De woorden Z en tellers p komen bij toepassing van deze regels nooit leeg te staan. Alleen als we regel V.5b. niet gebruiken zal de geneste index leeg [0] komen, zoals dat bij Bird's hoekketens ook gebeurt.

Matrix regel V.6. expandeert dimensie n2 met een reeks van p- dimensies n1 met in elk een reeks kleinere dimensies n, de rechter van bel lengte b- en naar links recursief groeiende bel lengtes.
We kunnen de komma , naar regel V.6. vertalen ,[1]1p en die toepassen. Dan moeten we de nulde sep ,[0]b met regel V.5a. elimineren, wat links van de komma bij 1 de b optelt. Die opgeladen 1b telt gaandeweg af tot 1, zodat er b iteraties plaatsvinden. Op de eerste rij zorgde dit ervoor, dat Vogel in de pas bleef lopen met Bird.

We werken de overgang naar de volgende rij, in de vergelijking van ons Vogel telraam met Bird's arrays, precies uit.
De evaluatie richting := keren we soms om. Om meer detail te tonen, klik op de gescripte borden 0'>!< of zoek die items op in de bron.

  • V(a,a,[2]2) = (a,a,a,[2]1) = (a,a,a) = (a,a-,1,2)
  • (a,a1.,1..,[2]2) :k0 = (a,a.,1..,a1) :k == (a,a,1a.,a..) :k = {a,k+3[2]2}
  • (a,2,2,[2]2) = (a,a,1,[2]2) = (a,a,1,a) := (a,a-,1,1,2)
  • (a,3,2,[2]2) = (a,(a,2,2,[2]2),1,[2]2) := (a,(a,a-,1,1,2)-,1,1,2) ≈> (a-,3,2,1,2)
  • (a,b1,2,[2]2) == (a,..a..,1,[2]2) :b: := (a,..a..-,1,1,2) :b: ≈> (a-,b1,2,1,2)
  • (a,b1,3,[2]2) == (a,..a..,2,[2]2) :b: ≈> (a-,..a..,2,1,2) :b: ≈> (a-,b1,3,1,2)
  • (a,b1,c1,[2]2) == (a,..a..,c,[2]2) :b: ≈> (a-,..a..,c,1,2) :b: ≈> (a-,b1,c1,1,2)
  • (a,b1,2,1,[2]2) == (a,..a..,1,1,[2]2) :b: ≈> (a,..a..-,1,1,1,2) :b: ≈> (a-,b1,2,1,1,2)
  • (a,b1,3,1,[2]2) == (a,..a..,2,1,[2]2) :b: ≈> (a-,..a..,2,1,1,2) :b: ≈> (a-,b1,3,1,1,2)
  • (a,b,1,2,[2]2) = (a,a,b1,1,[2]2) ≈> (a-,a,b1,1,1,2) ≈> (a-,b,1,2,1,2)
  • (a1,b,c,2,[2]2) ≈> (a,b,c,2,1,2)
  • (a1,b,c,d,[2]2) ≈> (a,b,c,d,1,2)
  • (a1.,pi..,[2]2) :k>0 ≈> (a.,pi..,1,2) :k > {a,k+2[2]2} {pia} 0'>!<

Staat er ,[2]2 na de eerste rij, dan is dat bijna hetzelfde als ,1,2 aan het eind. De tweede rij wordt immers pas actief, als de eerste rij is gereduceerd tot a,b met de resterende posities ,1.. afgeteld. Dan voegen we een hoogste teller ,b toe aan die rij.

Ook werkt lengte teller ,[2]1m over de eerste rij uit, alsof een serie tellers ,1.,2.. :m aan die rij zit vast geplakt.

  • (a,b,[2]3) = (a,a,b,[2]2) ≈> (a-,a,b,1,2) ≈> (a-,b-,1,2,2)
  • V(a1,b.,1..,[2]3) :k0 ≈> (a,a1.,1..,b,1,2) :k := (a,b-.,1..,2,2) :k1 > {a+b,k+4[2]2}
  • (a,b1,2,[2]3) == (a,..a..,1,[2]3) :b: ≈> (a,a,1,..a..,[2]2) :b: ≈> (a-,b1,2,1,2,2)
  • (a,b1,3,[2]3) == (a,..a..,2,[2]3) :b: ≈> (a-,..a..,2,1,2,2) :b: ≈> (a-,b1,3,1,2,2)
  • (a,b1,c1,[2]3) == (a,..a..,c,[2]3) :b: ≈> (a-,b1,c1,1,2,2)
  • (a,b1,2,1,[2]3) == (a,..a..,1,1,[2]3) :b: ≈> (a-,a,1,1,..a..,1,2) :b: ≈> (a-,b1,2,1,1,2,2)
  • (a1,b,c,d,[2]3) ≈> (a,b,c,d,1,2,2)
  • (a1,b,P,[2]3) ≈> (a,b,P,1,2,2)
  • (a1,b.,1..,[2]4) :k ≈> (a,a1.,1..,b,1,2,2) :k ≈> (a,b-.,1..,2,2,2) :k1
  • (a,b1,2,[2]4) == (a,..a..,1,[2]4) :b: ≈> (a,a,1,..a..,[2]3) :b: ≈> (a-,b1,2,1,2,2,2)
  • (a1,b,c,[2]4) ≈> (a,b,c,1,2,2,2)
  • (a1,b,P,[2]4) ≈> (a,b,P,1,2,2,2)
  • (a,b.,1..,[2]1m) :k0 = (a,a.,1..,b,[2]m) :k ≈> (a-,a.,1..,b :k ,1.,2..) :m- ≈> (a-,b-.,1..,2..) :k1 :m
  • (a1,b,1.pi,..[2]1m) :k>0 ≈> (a,b,1P,1.,2..) :m > {a+b,k+m+2[2]2} 0'>!<

Evaluatie van element ,[2]1m voegt aan de eerste rij een aantal van :m nieuwe tellers toe, gevuld met grote getallen.
Woord P, staat voor een deel pi,.. van een rij en R voor een hele rij. Daarin zijn de parameters pi>0 en te verwaarlozen ten opzichte van de rij lengte zelf (bij standaard input).

Bij Bird speelt bel b de rol van het opblazen van de lineaire array. Van element [2]2 kost dat slechts een enkele tel. Bird spaart bij elke overgang tussen dimensies de Vogel lengte teller uit.

  • (a,b,[2]1,2) = (a,a,[2]1b) ≈> (a-,a-,1.,2..) :b > {a,b+2[2]2}
  • V(a,b1,2,[2]1,2) == (a,..a..,1,[2]1,2) :b: == (a,a,1,[2]..a..1) :b: ≈> {a+3,b+1,2[2]2}
  • (a,2,3,[2]1,2) = (a,a,2,[2]1,2) ≈> {a,2,3[2]2}
  • (a,b1,3,[2]1,2) == (a,..a..,2,[2]1,2) :b: ≈> {a,b+1,3[2]2}
  • (a,b,c,[2]1,2) ≈> {a,b,c[2]2}
  • (a,b1,2,1,[2]1,2) == (a,a,1,1,[2]..a..1) :b: ≈> {a+4,b+1,2[2]2}
  • (a,2,3,1,[2]1,2) = (a,a,2,1,[2]1,2) ≈> {a,2,3[2]2}
  • (a,b1,2,2,[2]1,2) == (a,..a..,1,2,[2]1,2) :b: == (a,a,..a..1,1,[2]1,2) :b: ≈> {a,b+1,1,2[2]2}
  • (a,b,c1,d,[2]1,2) ≈> {a,b,c,d[2]2}
  • (a,b,1P,[2]1,2) ≈> {a,b,P[2]2}
  • (a,b1,2,[2]2,2) == (a,..a..,1,[2]2,2) :b: ≈> (a,a,a1,..a-
    ..,[2]1,2) :b:
    ≈> {a-1,b+1,1,1,2[2]2}
  • (a,2,3,[2]2,2) = (a,a,2,[2]2,2) ≈> {a-1,2,2,1,2[2]2}
  • (a1,b,c1,[2]2,2) ≈> {a,b,c,1,2[2]2}
  • (a1,b,1P,[2]2,2) ≈> {a,b,P,1,2[2]2}
  • (a,b1,2,[2]3,2) ≈> (a,a,1,..a..,[2]2,2) :b: ≈> {a-1,b+1,1,1,2,2[2]2}
  • (a1,b,1P,[2]3,2) ≈> {a,b,P,1,2,2[2]2}
  • (a1,b,1P,[2]1m,2) ≈> {a,b,P,1.,2..[2]2} :m 0'>!<

Matrix-regel V.6. bouwt de rijen tellers stap voor stap op. Vogel laat de lege elementen ,1 tussenin staan, want opruim-regel V.2. verwijdert deze niet. Met de recursieve substitutie van bellen b als volgende lengtes m domineert oplaad-regel V.5. steeds de voorgaande ,1.. aanwas.

Wat dominant uitpakt op de Vogel rij, zal sterker gelden in de volgende dimensies. Vogel's stapsgewijs groeiende ruimtes zijn wat onnatuurlijk, maar in Bird's systeem is het lastig om diep geneste arrays [S]1[T] te vergelijken in zijn regel die afgetelde tussenposities opruimt.

  • (a,b,[2]1,3) = (a,a,a,[2]b,2) > {a,b+2[2]3}
  • V(a,b1,2,[2]1,3) == (a,a,1,[2]..a..1,2) :b ≈> {a+3,b+1,2[2]3}
  • (a,b,c,[2]1,3) ≈> {a,b,c[2]3}
  • (a,b,1P,[2]1,3) ≈> {a,b,P,[2]3}
  • (a1,b,1P[2]2,3) ≈> {a,b,P,1,2[2]3}
  • (a1,b,1P[2]3,3) ≈> {a,b,P,1,2,2[2]3}
  • (a,b,[2]1,n) = (a,a,a,[2]b,n) > {a,b+2[2]n}
  • (a,b,1.pi,..[2]m,n) :k>0 > {a+b,k+m+1[2]n1}
  • (a,2,2,[2]1,1,2) == (a,a,1,[2]a1,a) ≈> {a+1,2[2]1,2}
  • (a,b1,2,[2]1,1,2) == (a,a,1,[2]a1,..a..) :b: ≈> {a+1,b+1[2]1,2}
  • (a,b,c1,[2]1,1,q) ≈> {a,b,c[2]1,q}
  • (a,b1,2,2,[2]1,1,q) == (a,a,..a..1,1
    ,[2]1,1,q) :b:
    ≈> {a,b+1,1,2[2]1,q}
  • (a1,b,1P,[2]2,1,q) ≈> {a,b,P,1,2[2]1,q}
  • (a,b1,2,[2]1,2,q) == (a,a,1,a,[2]..
    a..,1,q) :b:
    ≈> {a+3,b+1[2]2,q}
  • (a,b.,pi..,[2]m1,Q) :k>0 == (a,b.,pj.. :km
    ,[2]1,Q) {pj>pi>1}
    > {a+b,k+m+2[2]1+Q}
  • (a,b,[2]1,[2]n1) = (a,a,[2]1,b,[2]n == (a,a,P,[2]m.,qi..) :n > {a+b,n+1[2]1[2]2}
  • (a,b1,2,[2]1,[2]1,2) == (a,a,1,[2]1
    ,[2]1..a..) :b:
    ≈> {a+1,b+1,2[2]1[2]2} 0'>!<

Zo verlengen we de rijen in hogere dimensies met series van ,qi.. :r tellers, waarin de laatste qr dominant is.

Hoewel v>b kunnen we voor variabele v elk relatief klein getal invullen tot een bel b1 bijvoorbeeld, als dat helpt om Vogel te vergelijken met Bird. Het maakt weinig uit, de waarde van v is ondergeschikt aan de meest rechtse positie ervan.
In het volgende item zal v net wat groter zijn dan een expressie (a,a.,[s]b..,[s1]2) met lengte :b- en niet langer.

  • V(a,b,[s1]1,2) = (a,a,[s1]1b) > (a,a.,[s]1..v) :b > {a,b[s+1]2}
  • V(X,[s]m,Q) > {X[s]Q} Q = n.,qi.. :r

Ga ervan uit dat de delen X afgezien van het separator format gelijk zijn := of althans :≈ de belangrijke dimensies in deel X bij Vogel en Bird even lang zijn. Stel het rij deel Q van Vogel met 2e en verdere tellers gelijk aan de hele rechter rij bij Bird.
In elke Vogel rij, ook in Q, is oplaadregel V.5. dominant. Bird arrays (met teller c) komen door zijn regel 2.6. overeen met die van Vogel (en teller c1 om $ te laden).

Vogel's achterstand op de rij blijft beperkt tot een extra teller m, en de beste benadering geeft m=1. Zo pakt de expressie in Vogel soms groter ≈> uit, maar meestal minimaal <≈ kleiner dan die van Bird.
Voegen we m=2 in vooraan op de laatste rij, dan is die rij in Vogel gelijk groter en wordt de rest van het telraam dat zeker ook.

Bird's opladen van subexpressies $ kunnen we compenseren door bij de derde teller c in Vogel 1 op te tellen. Andere bonus constructies van Bird, zoals substitutie van a in eerdere tellers op rij en zijn ketens €n in vorige dimensies worden bij Vogel in de evaluatie ondervangen.
Met elke iteratie van naar positie m opgeladen bellen b' vagen we de ervoor opgebouwde lengte volledig weg. Die lengte draagt weer over en zo expanderen we alle voorliggende dimensies.

Bijvoorbeeld, stel dat n:=b1 zojuist is opgeladen naar een 2e teller in een hoge rij van Vogel. Eén tel eraf n:=b en de 1e teller m:=a1 is nog klein. Die vergroot de lengte van de voorgaande dimensie met a, wat ver achter blijft bij lengte b van Bird's hoekketen. Maar de tweede aftel n:=b- zal de waarde m:=b' die naar de lengte teller wordt opladen al veel groter zijn dan de originele bel b. Ga maar na hoe latere bellen b' via regel V.4. de originele b vele malen bevatten.

Lengtes in Vogel groeien eerst met a en daarna meteen voorbij de hoekketen lengte b, waarmee Bird al zijn ruimtes vult. Toch blijft Vogel's accumulatie van lengtes als optellen, wat inmiddels relatief weinig effect sorteert, ook al zullen al deze series meedoen met de recursie van de bel.
Als we dus een teller 2, inlassen aan het begin van Vogel's laatste of diepst geneste rij, dan geven zulke matrix of geneste getallen een goede (insignificant grotere) benadering voor die van Bird.


Met de eerste rij tellers in ons Wielewaal systeem bereikten we de supermachten. Daar hadden Vogel en Bird slechts drie tellers voor nodig met dubbele recursie in bel b.
Vanaf c corresponderen de tellers in Bird's lineaire array met de index rij in Wiel. Dit tweede array niveau vormt Wiel's matrix ruimte, waarmee we Vogel's toprij benaderden in blog §3.1.

De rij lengte of komma teller in Vogel is dus gelijk aan de 1e index op het 3e niveau in Wielewaal. Naar alle diepe tellers laadt Wiel bel b op. Dat opladen van de bel is maximaal en domineert alle structuren.
Rechts substitueren van $ subexpressies bij Bird staat gelijk aan b opladen onder aanpassing c1 in Vogel. Voor Wiel betekent dit een extra teller op de eerste rij ofwel 1 tel bij de laatste positie index.

We zullen expressies in Wielewaal nu uitwerken tot een dieper array niveau, volgens de regels voor geneste arrays W.II.
Het 1e niveau of de [top array] begint met verdubbeling, waarna een rij iteraties volgt. De posities in die rij tellen we met een 2e niveau index, ook gevolgd door een oplaadbare rij, de [index array]. Zo ver waren we. Op dezelfde wijze ligt hier het 3e niveau [index subarray] onder. Weer scheiden we indexen hetzij door komma's , hetzij met een 4e niveau [sub sub index].

Klik op de borden <!--> om meerdere variabelen te vergelijken.
De tilde ~ staat voor de gebruikelijke benadering: hier een expressie die minimaal groter is dan ≈> de volgende in die array vorm.

  • [a,[,[1,1]1]1] = a[,[,[a]a]1] ≈> (a,a1.,a..) :a1 > (v,v,[2]a1) := V(v,a,[2]1,2)
  • [a,[,[1,1]2]1] = a[,[,[a]a,["]1]1] == a[,[.a-,..["]1]a] :a1 ≈> (a,1.a,..[2]1,2) :a2 > (v,v,[2]a1,2) := V(v,a,[2]1,3)
  • [a,[,[2,1]1]1] = a[,[,[1,1]a]1] > (v,a,[2]1,a1) := V(a,a,[2]1,1,2)
  • [a,[,[1,1]1,[2,1]1]1] = a[,[,[a]a,["]1]1] > (v,v,[2]a1,1,2) := V(v,a,[2]1,2,2)
  • [a,[,[2,1]2]1] = a[,[,[']a,["]1]1] > (v,a,[2]1,a1,2) := V(a,a,[2]1,1,3)
  • [a,[,[,2]1]1] = a[,[,[a,1]1]1] ≈> (a,a,[2]1.,1..1) :a > V(v,v,[2]1,[2]a-) <!-->

Wezenlijk is het functie algoritme van Wielewaal hier even snel als dat van Vogel en Bird, alleen de structuur verschilt. Door alle posities apart te indexeren worden Wiel arrays dubbel genest.
Vogel en Bird herhalen dezelfde separatoren binnen hun array ruimte, zodat er lengte ontstaat. Dit aantal separatoren kunnen we noteren met een index. Alle tellers krijgen in de Wielewaal definitie een eigen index, maar het gebruik van gewone komma's op eerste rijen is optioneel (hier alleen in de binnenste arrays).

Hogere structuren worden dermate dominant, dat het precies passend maken van elke teller er weinig toe doet. Voor ons gemak laten we de groter > ordening verder achterwege.
Uitkomsten van Wielewaal [W] zijn hier ongeveer gelijk aan (iets groter of kleiner dan) Vogel V(X) waarmee we de multi-dimensionale en verder geneste arrays {Y} van Bird benaderen.

  • [a1,[,[,,1]1]1] = a1[,[,[a,a]a1]1] (v,v.,[2]1..,[2]a) :a V(v,a,[3]1,2)
  • [a,[,[,[,1]1]1]1] = a[,[,[,{a}1]1]1] V(v,a-,[a1]1,2) {a,a[a+1]2} <!-->

Nu blijkt dat de dimensie separator lengtes van Bird en Vogel hun gelijke vinden in de drie diep geneste array van Wielewaal. Vogel rij lengte met de teller aan dat array begin (index 0), aantal rijen in een vlak met de teller met index 1, het aantal vlakken met de teller met index 2, enzovoort.

De dimensie lengtes corresponderen met de tellers op het 3e niveau in Wiel. De dimensie zelf is dan de eerste index op het 4e niveau in Wiel, twee niveau's dieper dan Bird of Vogel.

  • [a,[,[q.,[si]ri..]p]1] :t V(a,a.,[si1]1.. :ri ,1..p) t :q {si1>si}

Algemeen is de lengte :r van Vogel dimensies gelijk aan teller r in Wielewaal. De dimensie s1 kunnen we in Wiel aangeven met komma's ,.. :s of door een index [s] dieper te nesten.
Geneste arrays [si+1] van Vogel dimensies zijn verticaal gestapeld. De dimensie lengte is de reeks ,[si+1]1.. van gelijke elementen, want de index keert in de rep :ri terug. We herhalen ze met de t rechts verticale rep, die index i van onder naar boven optelt.

We voegen witruimte en reps en variabelen toe om deze systemen te verklaren. Maar iedere expressie is een string, bestaande uit units 1, separator tekens en haakjes, die door regels l-r tot grote getallen in unair formaat 1.. worden herleid.
Met dieper geneste tellers maken we nog grotere getallen, zoals Bird noteert met hyper-dimensies. Meer daarover in het volgende blog.

Omdat in de formule gesteld is dat si1>si zijn de Vogel dimensies links dus groter dan rechts. Bij de corresponderende indexen in Wielewaal is dat andersom. Opeenvolging si1=si1 kan het geval zijn, maar is niet verplicht.
Of deze matrix formule ook geldt als de geneste separator indexen s niet in volgorde van grootte staan, laten we aan de lezer over…!

X

§3.3 Vernest

Bird's hyper-dimensionale arrays3 zijn functies, waar de separator index is uitgebreid tot een rij indexen. Qua structuur ligt binnen elk element van de top rij dan een index rij besloten. Vanwege reeksen met gelijke separatoren zijn de uitgedrukte getallen maximaal.

Het Vogel telraam waarmee we Bird vergelijken heeft ook zo'n rijen in rij structuur. De herhaalde indexen geven een maximaal aantal tellers in het raam erboven. Qua algoritme tellen beide systemen getallen af om voorgaande structuren te expanderen. Dominante regel daarbij is het opladen van afgetelde indexen met bel b, in Vogel direkt en bij Bird verpakt in een subexpressie.

Tijdens de constructie neemt, wat we het niveau van geneste arrays noemen, van buiten naar binnen toe:
Een scan zal l-r of r-l de functie haakjes als eerste tegenkomen. Dit telden we in §2.6 als het 1e niveau. Die top array omvat gelijke stucturen, die naar beneden toe worden opgebouwd en toenemen.5
Zoals <tag> tekst </tag> is opgemaakt in html [met tag type haakjes] en scripts dit element adresseren als ouder, waarin tekst en andere elementen zijn afgetakt als kinderen.
Of zoals een verhaal wordt vervolgd door zinnen eronder te kalken.

Maar geneste structuren kunnen we ook andersom scoren:
Bird0 telt het level van separator arrays: vanaf index [m] met level 0 die dimensies m scheidt, multi-dimensionale separatoren als level 1 tussen hyperruimtes. Enzovoort, zodat de grootste level n separator ergens in de top array {Y} wordt genest.
Een macht b in een dubbele recursie V.O bereikt bij teller b=1 de bodem subexpressie (a,..a..,c) in de evaluatie trein.
Bij sets is de element relatie fundamenteel en tellen we van de diepste subset naar de buitenste set de is in relaties. Zo worden ordinale sets opgebouwd, die natuurlijke getallen representeren. En dit is axiomatisch bij oneindige limieten ω, zie §1.4 ev.
Onze superradix structuur in §2.4 noteert met de onderste laag de getallen m, schrijft machten m^m met de array laag erboven, en stapelt laag na laag een toren van n machten, die tetratie m^^n is.

We geven hier geen aparte definitie voor hyper-dimensionale arrays in Vogel. Met een index rij is de expressie tot het 2e niveau genest.
Bij geneste arrays kunnen we rijen indexen arbitrair diep in andere rijen nesten.4 We betitelen zulke grote getallen als vernest, als hun array structuur ver genest is.

Vogel nesten definitie V.III.

  • V.0. (a) = a
  • V.1. (a,b1) = a(a,b)
  • V.a. ,1 ≡ ,[1]1
  • V.2a. ,[S]1) ≡ ) V.2b. ,[S]1] ≡ ]
  • V.3. (a,1,[S]Z) = a
  • V.4. (a,b1,1Z) = (a,(a,b,1Z),Z)
  • V.5a. ,[] `= 0 => V.5b. (a,b, ,2 `= (a,a, b,1
  • V.6. (a,b ,[1n]2 `= (a,a ,[n]b,[1n]1
  • V.7. (a,b ,[1S]2 `= (a,b ,[S]b,[1S]1

We passen deze regels ten eerste l-r toe (op een match die het meest links begint) in de expressie en ten tweede (bij twijfel) in de volgorde van definitie.
Dan matcht de laatste regel altijd de vorm ,[1n,S]1p waar als n=0 (bij lengte index 1) het nieuwe element ,[,S]b voor wordt gevoegd. En als ,[,[1n]1R] verschijnt, dan matcht vervolgens regel V.6. in de hyper-array. Zo kan bel b, omdat regel V.7. deze in de basis laat staan, ook in diepe geneste arrays elke vrije teller bereiken.

De Vogel definitie is simpeler dan Bird's geneste arrays U.III.
We zetten de vergelijkingen uit blog §3.2 voort om te bewijzen, dat de functies van Vogel en Bird vrijwel even snel zijn. Op dit klikbord voor het hyper-dimensionale niveau.

  • V(a,b,[1,2]2) = (a,b,[,2]b) = (a,a,[b]b) ≈ {a,b[b]2} ≈ {a,a.[b-]b..} :b-{a,b-1[1,2]2}
  • (a,b,[1,2]1c) = (a,a,[b]b,[1,2]c){a,b-1[1,2]c+1}
  • (a,b,2,[1,2]1,1Z) == (a,a,1,[1,2]1v,Z) = (a,a,1,[a]a,[1,2]v,Z) == (a,B,[1,2]v,Z) {B>>b}{a,b[1,2]1,1Z}
  • (a,b1,[2,2]1,2) == (a,B,[1,2]1,[2,2]b){a,b[2,2]2}
  • (a,b1,[c,2]1,Z){a,b[c,2]Z}
  • (a,b,[1,1d]1Z) = (a,a,[b,d]b,[1,1d]Z){a,b-1[1,d+1]1Z}
  • (a,b,2,[1,R]Z){a,b[1,R]Z}
  • (a,b,[R]1,Z){a,b[R]Z} 0'>!<

Het grootste verschil is dat Vogel's regels V.6. en V.7. een enkel element per stap plaatsen en dat Bird met zijn hoekketens elke reeks elementen meteen opbouwt. Dit ondervangen we door op de betreffende positie in Vogel een gewone teller 1, in te voegen.

Dit geldt voor elke ruimte in elke array, maar het diepst geneste niveau kmax is dominant. Wat daar groter is draagt over, zodat (afgezien van de komma array notatie ,[S] versus [S] bij Bird) de rest van de Vogel expressie gelijk kan blijven in deze algemene vergelijking.

  • V(a,B.,[Xi..,[n]1,Y..]Zi.) {a,B.[Xi..[n]Y..]Zi.}
  • :kmax: & Y=p0.,pj.. :r0

Met regels W.II werken geneste Wielewaal arrays simpeler dan die van Vogel. Om te testen of ons tellerij algoritme het allersimpelst is, zetten we in de box een experiment op met eerste posities.
Merk op, dat de aasbel a, die we zowel binnen als buiten de top array noteerden, in wezen een geheel vormt. Deze kan zelfs zonder functie opening [ haakje.

Elke Wielewaal subarray zal tot de vorm [p,[1]T] evalueren, met een eerste sep index 1. Vervolgens telt p- af totdat [,[1]1T] een dubbelbel a oplaadt [,[]a,[1]T] en de lege sep vervalt.
Ook in de basis staat een index 1 komma [a,[1]1X] die een kopie [a,[]a,[1]X] maakt en [aa,[1]X] de bel verdubbelt.

In de box geven we een radix systeem, met regels als van Wielewaal. Het enige echte verschil is dat de basis separator ,[1] na een inerte komma ,b komt. Dan zal de aas die we opladen een constante zijn [a,ba,[1]X] en in de bel groeit alleen de som.
Ook in alle superradix subarrays plakken we aan het begin een teller en komma zonder index. Voor de rest blijft de structuur gelijk.

# Superradix 3.3

De basis waar een getal aangroeit komt meteen links, want we lezen van links naar rechts. Ons nieuwe idee is om structuren consequent l-r van klein naar groot te ordenen.
Zo komen alle tellers meer naar rechts in hun rij, als ze dominanter uitwerken in hun systeem. Decimale getallen zouden we bijvoorbeeld liever andersom schrijven. Ook oneindiger series a.. kunnen we van rechts bijtellen (Cantor omgekeerd).

Aalscholver is net als Aasgier een superradix van het Aasblazer type. Maar nu zetten we de teller van het aantal, die minder significant is, links aan het begin van zijn index array, voor de machten.
De aparte status van iterator over index {Bird's [separator] entry} komt zodoende te vervallen. Het hele element wordt (in een rij) omvat. En we nesten louter rijen in rijen.
Anders gesteld, we breiden getallen binnen dit systeem uit tot arrays. Zo'n array getal staat los van zijn positie index en kan op meerdere plaatsen voorkomen, hoewel niet strikt in een radix expressie. Op de binnenste rij houden we gewone tellers en blijkt de positie uit de lengte van de voorgaande komma's.

Aalscholver Á.I een rij tellers, met vaste posities per komma.

  • Á.0. (a,b) = b
  • Á.1. ,))
  • Á.2. (a, ,1 `= a,

Door radix expressies strikt l-r te reduceren met `= blijven verdere tellers c beperkt tot cijfers van 0 tot en met a. Zou de laatste regel met overal gelden, dan is het output getal weliswaar gelijk, maar worden tellers soms groter dan radix a tijdens de evaluatie.

Druk de lineaire array uit met nesten en als vaste rij. Bereken die met de + * ^ operaties en een index i die telt van 1 tot en met k.

(a,b.,(ci,i)..) :k =
  (a,b.,ci..) :k =
    b.+ci*a^i.. :k

Zo'n systeem met a opladen en complete indexering heet vloeibaar. Omdat elk kind element ,(p,S) optelt binnen zijn ouder array (n,p0.,(pi,Si)..) en in die som vrij te verschuiven is.
Wat in een ruimte een teller op een vaste positie is, zal hier eerder links staan, of ook meer rechts of herhaald. Zo kunnen tussen kind rijen verstrooid uitgewerkte getallen voorkomen, die later pas bij de ouder ex-positie index p0 arriveren en optellen.
Hier zijn alleen de constante a en factor n direkt al getallen op een vaste plaats. De bulk van b en exponent p0 zijn hun duo met index i=0 ontstegen en buiten de radix gerekend dus vrij vloeibaar.

Aalscholver Á.II geneste arrays, in volgorde bij superradix.

  • Á.0. (a,b) = (b) = b
  • Á.1. ,(,S) ≡ 0
  • Á.2. ,(p,)p
  • Á.3. ,(1n,1S) `= ,(a,S),(n,1S)

Vanouds elimineert regel 1 de afgetelde elementen en regel 2 de lege array die ba optelt. Nul indexen (p,0, slaan we over tot regel 3 een subarray (p,,(a,) introduceert, die tot (p,a reduceert. Later in de evaluatie, links van ,(n,1, in de ouder rij keert ,(a,, terug en is de cyclus rond. Daarom hebben alleen tellers p=a een nul index.

Elke diepste rij zouden we ,(c.,di..) met komma separatoren kunnen noteren. En met alleen cijfers van 0 tot a- is in een l-r radix expressie +(c,.di..) :k alleen de eerste komma nodig. Dat wordt in decimale exponentiële notatie cE..di met k: cijfers andersom.

Meer in het algemeen tellen geneste rijen op als machten in de lagere exponent van de ouder rij.

,(c,d0.,(di,Si)..) :k
  = c*a^(d0.+
    di*a^(a,Si)..) :k

Zoals in §2.4 groeien er macht ^ torens met tetratie ^^ verdiepingen.

  • ,(1,,(1,,(1,1))) := ,(1,,(1,,1)) = ,(1,,(1,a)) = ,(1,a^a) = a^^3
  • (a,.,(1,..).) :m1: = a^..1 :m = a^^m

Aalscholver radix expressies drukken alle natuurlijke getallen uniek uit als elke variabele 0<p<a en de nest diepte onbegrensd is. Dat is tot onze diepen uitbreiding de nest grens bij m1=a legt.

Hoewel geneste arrays in Wielewaal W.II simpel zijn gedefinieerd, zullen we bij gelijke grootte dubbel zo diep moeten nesten. Want onze tellerij rolt over de oneven niveau's de indexen uit, die de unieke posities binnen Bird's array ruimtes representeren.

Na een langzame start evenaarde Wielewaal met het 2e nest rij pas de 1e rij van Vogel = Bird's lineaire array. Met de 3e nest rij rolde Wiel mooi over Vogel's dimensionale lengtes, zoals we in §3.2 zagen.
Geven we met Wiel's 4e nest rij een benadering van de indexen op Vogel's 2e nest rij Bird's hyper-dimensies. Dan representeert Wiel's 5e nest rij de herhaling daarvan: de maten van Bird's hyperruimtes.

Denkwerk in uitvoering

Tellerijen beginnen met fikse achterstand, omdat hun groeibel regel optelt in b, wat primitieve recursie is. Telramen winnen daar met dubbele recursie, die vanzelf verlengd wordt tot recursie over de hele $ expressie in b.
Zodra we de positie index array voor een nieuwe teller voorzien van een minus [S] kopie van de volgende [1S] sep, dan wordt onze Wielewaal tellerij even snel als met nesten van $ subexpressies in Vogel (allebei rij in rij).
Met het Wielewaal vlak wonnen we Conway's pijlketens. Met Vogel en Bird's arrays komen we in dit blog gelijk, als Wiel de nest diepte van index arrays laat belgroeien.

Als we array systemen vanuit hoger perspectief bezien, moet het direkt substitueren van expressies (grootste structuur) in tellers (kleinste structuur) wel even sterk zijn als één extra array niveau. Nooit meer dan dat, mits alle geneste arrays dezelfde structuur krijgen als de top array.
Want door de groeibel op te laden naar diepere niveau's, geldt dit verband niet alleen voor de eerste tellers, maar draagt dit over naar elk nest niveau. Toch is het opmerkelijk, aangezien index seps hele andere introductie regels W.3. hebben dan die V.4. voor subexpressie nesten.

Als we overgaan tot post-indexering na a en de bel beschouwen als de eerste index array, dan heeft een Vogelachtig systeem geen functie haakjes meer nodig. Dan worden subexpressies uitgedrukt met de eerste geneste array. Dus 1 nest niveau is gelijk aan 1 positie die recursief verdiept wordt.

Bird's array notatie kent twee hulpsystemen voor de introductie en eliminatie van elementen: hoekketen regels en array ordening. Bird's universum van expressie input en getal output zetten we exact om in een makkelijker systeem met de naam Uil. Ook Uil breiden we twee keer uit: met bank arrays en ruimte merken (en hun regels).
Volledige eliminatie van elementen is echt een luxe constructie.

Ons Vogel telraam V heeft minder regels en laat elementen tussenin met teller 1 gewoon staan. Het cumulatieve effect van oude reeksen op de uitkomst grootte is insignificant, maar de chaos neemt steeds verder toe.
In Bellenblazer en Wielewaal W vallen afgetelde elementen sowieso weg, omdat elke teller positie een eigen index heeft. Arrays moeten wel 2 keer zo diep zijn om even grote getallen te maken.
Regels in Bellenblazer worden moeilijker bij het nesten en tellerij W is dan makkelijk, hoewel deze chaotisch begint door af te wijken van normaal a*b herhalen.
Verschillende concepten zijn op wonderlijke wijze uitwisselbaar…!

X

§3.4 Diepen

Denkwerk


In onze Wielewaal tellerij groeit de bel door optellen, krijgen alle teller posities unieke indexen en tellen iteraties af tot 0.
Op de rij geeft de komma lengte dan wel seps met een enkele index de positie aan van de tellers. De indexen breiden we uit tot arrays, die rijen in rijen nesten. En nu tot Wielewaal diepen waarmee we over nest diepte itereren.

Bird's Universum

Hier zijn de input expressies en de ermee uitgedrukte getallen exact gelijk aan die van Chris Bird.0
Maar onze array herschrijf regels, die expressies evalueren door introductie en eliminatie van woorden, zijn bondiger dan in Bird's originele systemen. Sommige regels voegen we samen en de overbodige vervallen. De lijst volgorde bepaalt welke regel we toepassen, maar is anders dan van de hoofdregels van Bird.

Deze definities krijgen de letter U van Uil en een romeins nummer. Afkortingen en hulp regels maken de notatie leesbaarder.
Variabelen zijn unair, met optellen van buren, dus b1=b+1.

Bird gebruikt hoekketens <a[T]b> om vrije array ruimtes per reeks te vullen. Dezelfde expansie bouwen we hier per element op met een stel expressies {a[T]b,b} dat in zijn algoritme geen rol speelt.
Vanaf matrixen vervangen we Bird's subsysteem voor hoekketens door bank regels die deze dummy arrays reduceren.

Vanaf geneste arrays zijn onze ruim regels voor het opruimen van uitgetelde dimensies een stuk simpeler. Wij verwijderen het lagere element uit [S]1`[T] door het begin en einde van zijn `ruimte` eerder al te merken.
Bird's subsysteem om de grootte [S]<[T] van separator arrays te vergelijken wordt steeds ingewikkelder. Gelukkig is in de evaluatie alleen van belang om te weten waar hun ruimte is begrensd.


Supermacht functie U.O in drie tellers: constante a, macht b en supers c. Bird drukt met twee tellers meteen al machten a^b uit.

  • 0.0. {a} = a
  • 0.1. {a,b1} = {a,b}.. :a == a^b1
  • 0.2a. {a,1} = a 0.2b. {a,b,1} = {a,b}
  • 0.3. {a,1,c} = a
  • 0.4. {a,b1,c1} = {a,{a,b,c1},c} == a^{c1}b1

Voor de Main rules nummering van Bird: zie de muis_over titels.
Regels die hetzelfde blijven linken we naar hun eerdere definitie.


Rij functie U.I voor Bird's lineaire arrays.1

  • 0.0. 0.1.
  • 1.2. {Y,1} = {Y}
  • 1.3. {a,1,X} = a
  • 1.4. {a,b.,1..Z} :k>0 = {.a,..$,Z} :k

De subexpressie $ voor de volgende stap is gegeven door in de expressie bel b met 1 te verminderen (telt unit - op).
Gebruik komma's , als separator tussen tellers in rijen.

  • 1.$ {a,1Z} => $ = {a,Z}
  • 2., [1] ≡ ,
  • 2.€ €1a, & €n ≡ {a[n]b}[n]

De merktekens €n functioneren vanaf €2 hetzelfde als hoekketens bij Bird. Elke array dimensie n1 wordt gevuld met series van lengte b van steeds kleinere ruimtes n, totdat we de tellers a uitrollen in rijen met komma's (index 1 is dimensie 0) ertussen.


Matrix functie U.II voor Bird's multi-dimensionale arrays.2

  • 0.0. 0.1. 1.4.
  • 2.2. [m]1} ≡ }
  • 2.3. {a,1[n]Z} = a
  • 2.5a. ,1[n][n] {n>1} 2.5. [m]1[n][n] {m<n}
  • 2.6. {a,b.[ni]1..,1Z} :k = {.€ni..$,Z} :k
  • 2.7. {a,b.[ni]1..Z} :k>0 = {.€ni..Z} :k

Pas deze regels in volgorde toe. Dan komt regel 2.4 in de vorm 1.4 altijd voor regel 2.6, zodat k>0 en n1>1 daar gegeven zijn.
Lees in {Y,1} de laatste komma als index [1] die onder regel 2.2 valt. Omdat regel 2.5 van links de kleinere indexen elimineert, staat de volgorde van de dimensies nini+1 voor expressies 2.6 en 2.7 vast.

Deze bank regels vervangen Bird's hoekketens in de matrix.

  • 2.€ 1. {a[2]b1} €1{a[2]b} ≡≡ a,..a :b
  • 2.€ 2. {a[n1]b} ≡ {a[n]b,b}
  • 2.€ 3. {a[n]b,k1} €n{a[n]b,k} ≡≡ €n..{a[n]b} :k

Bird laat arrays zonder bel {a[n]Z} ongebruikt. Hij is verplicht om die tot a te reduceren, omdat hij onze regel 2.5a bij regel 2.2 voegt, voor regel 2.3 expressies {a,1[n]Z} kan bereiken.
Wij hergebruiken een stel van die dummy arrays of banken om array ruimtes stapsgewijs te vullen. Zo'n bank bestaat uit een constante a, een index array, een constante b en daarvan afgeleid een extra teller die van ,b tot ,1 aftelt en door regel 2.2 wegvalt.

Alle tellers zijn positieve getallen, die actief zijn in de lopende recursie, d.w.z. deel uitmaken van een significante reeks. Elementen die in ons Vogel telraam V onder een hogere recursie buiten spel staan, worden bij Bird met teller 1 en separator het veld uitgestuurd.


Nest functie U.III voor Bird's geneste arrays.4
Deze omvat ook zijn hyper-dimensionale arrays3 met separatoren die uit rijen indexen [n.,pj..] bestaan.

  • 0.0. 0.1. 1.4. 2.€ 1.
  • 3.2a. [S]1} ≡ } 3.2b. [S]1]]
  • 3.3. {a,1[S]Z} = a
  • 3.5a. ,1[S][S] {S>1} 3.5b. [S]1` ≡ ` 3.5c. `p` ≡ p {p>0}
  • 3.6. {a,b.[Ti]1..,1Z} :k = {.€Ti..$,Z} :k
  • 3.7. {a,b.[Ti]1..Z} :k>0 = {.€Ti..Z} :k

Tellers staan bij Bird nooit 0 leeg, daarom beginnen de woorden Z, R en X hier met een getal. Voor separatoren [S] geldt dat {S>0} en dat deze ook een [1] komma , kunnen zijn.

Als een woord ruimte accenten ` bevat, dan komen die net eender terug in de kopie ervan. Zo ook bij reeksen `.. die we ongeteld met aangeven. Zo'n niet-lege reeks blijft staan op zijn plek, in 3.6 en 3.7 rechts buiten de sep array [Ti] die we links expanderen.
De afkorting sluit een onbestemd aantal ruimtes uit (de input komt soms zonder). Om met minder accenten rekening te hoeven houden, zullen we die van links al vroeg elimineren.

Hulpregels voor het opschonen van ` ruimte merken aan a. begin en b. einde van de eerste rij van 1. top en 2. geneste arrays.

  • 3`1a. {` ≡ { 3`1b. {a,b` ≡ {a,b
  • 3`2a. [`[ 3`2b. [p`[p

Bird's hyper-hoekketens hebben aan de volgende regels genoeg. We gebruiken onze bank arrays, maar nu met ruimte merken.

  • 3.€ a. €1a, 3.€ b. €T ≡ {a[T]b}[T]
  • 3.€ 2. {a[1T]b} {T>1} ≡ `{a[T]b,b}`
  • 3.€ 3. {a[T]b,k1} €T{a[T]b,k} ≡≡ €T..{a[T]b} :k

De hyper-dimensionale regel verdiept zich, als Bird in zijn geneste hoekketens a door b vervangt. Door de bel diep te laden blijft zijn algoritme maximaal grote getallen maken.

  • 3.£ c. £1b, 3.£ d. £T {b[T]b}[T]
  • 3.£ 4a. {a[.,1..R]b} :n {a[.b,..R]b} :n
  • 3.£ 4. {a[.[Ti]1..X]b} :n ≡ {a[.£Ti..X]b} :n

Hangende tellers ,1 ruimen we op met de oude regel 3.5a, verder vergelijken we separator arrays niet qua grootte in Uil.
Het is alleen van belang te weten waar een reeks elementen ophoudt en waar die begint. Daarom begrenzen we meer-dimensionale ruimtes (vanaf het 2D vlak) per bank regel 3.€.2 met ` accenten.

Toon een evaluatie voorbeeld in drie klikken.

  • {a,2[4]2} = {€41} = {{a[4]2}[4]1} = {{a[4]2}} = {`{a[3]2,2}`} = {€3{a[3]2,1}`} = {€3{a[3]2}`} = {{a[3]2}[3]{a[3]2}`}
  • = {`{a[2]2,2}`[3]`{a[2]2,2}``} = {€2{a[2]2}`[3]`€2{a[2]2}``} = {{a[2]2}[2]{a[2]2}`[3] `{a[2]2}[2]{a[2]2}``} = {a,a[2]a,a`[3]`a,a[2]a,a``}
  • == {a,b[2]1,2`[3]D`} = {{a[2]b}[2]$`[3]D`} == {a,b`[3]D`} == {a,b[3]`p``} == {a,b[3]2`} == {a,b[2]2`} == {a,b,2`} = {a,$`} = {a,b} = a^b

Opruimregel 3.5b elimineert afgetelde elementen aan het einde van hun reeks. Als de evaluatie trein aankomt aan het begin ervan, dan heft regel 3.5c deze ruimte voorlopig op.
Maar het lijkt lastig om met ons bank systeem elke rij ruimte (een 1D reeks getallen) op natuurlijke wijze te markeren…

0. Een systeem voor snel groeiende recursieve functies, dat de functies van Jonathan Bowers en anderen ver te boven gaat, in Christopher M. Bird Super Huge Numbers, een serie van 9 PDFs over Bird's arrays + 3 bijlagen, 2017.

1. Chris Bird, Linear Array Notation, 2012.

2. Chris Bird, Multi-Dimensional Array Notation, 2012.

3. Chris Bird, Hyper-Dimensional Array Notation, 2017.
4. Chris Bird, Nested Array Notation, 2012.
5. Shàng betekent zowel boven als eerder, xià betekent onder en volgend, p.137 in James Gleick "Time Travel, a history" 2016.
(Hoewel men een I Tjing hexagram van onder naar boven werpt.)

Bouwwerken van de Lilliputters die Gulliver zijn maaltijd serveren
CALL App.show(UL, className[])
SET tC.App.Tags

Blogboek  index

  1. Tellen
  2. Rijen
  3. Dieper
    1. V supertrio = W rij
    2. V toprij = W matrix
    3. V maxtrix = W hyper
    4. V vernest = W nesten

© 2018
Giga Gerard