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 de vorige serie blogs §2 ontwikkelden we een plan voor het maken van grote getallen. Onze nieuwe blogs bouwen we van de grond de diepte in, met geneste arrays en het diepen zelf, in Giga Gerard’s
„Reuzen Getallen Bouwerij”.
Iedere array kan uitgebreid worden tot een diep. Wat de bouwmeester diepen noemt is een serie van geneste arrays [Xi].. die elkaars nest diepte recursief expanderen.
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 ons 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.
Met punten selecteren we een .groep.. tekens en de rep herhaalt die groep :n aantal keer op zijn plaats. Tijdens deze repetitie nemen de indexen i of j naar rechts toe van 1 tot n. Ook zijn er tweezijdige reps :n: en reps n: die incrementeren naar links. Het wijst zichzelf.

In dit blog bouwen we een Wielewaal systeem, waar de variabele a substitueert in een Aasblazer superradix structuur. We verdubbelen onze aasbel en schuiven een kopie ervan naar rechts om lege ,0 tellers ,a op te laden. In ruil telt deze evaluatie - een hogere 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 *{0} operatie, groeit en tellers rechts in de rij substitueert, noemen we een tellerij [number array]. Getal bij 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 = (a)a = aa
  • V(a,wb) == (a,w).a.. :b == a..a.. :w :b = a.. :wb = a*wb
  • (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}
  • (a,wb,3) == (a,..(a,w,3)..,2) :b: == (a,..a^^w..,2) :b: = a^..a^^w :b = a^^wb
  • 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 dubbel 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 twee iteratoren over, omdat zij de constante a=2 impliciet maakte (en wat erbij rekende).

Het lijkt spectaculair dat zulke functies zo snel starten, maar vanuit het oogpunt van geneste arrays maakt het weinig uit (één nest niveau, zal later blijken). Als we over een rij tellers de supermachten opbouwen en bel b 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 kunnen samenvallen, zoals geneste arrays met subexpressie versus primitieve recursie dat zullen 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[b,1R] = a[ab,R]
  • À.2. a[R,] = a[R]
  • À.3. a[b,{n1}1R] = a[b,{n}a,R]

In de komma array is bij natuurlijke getallen regel À.1. voor optellen een geval {n=0} van regel À.3. voor opladen. Maar bij series van Cantor's oneindige getallen a=ω is omkeren ergens wel nodig.
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 (tellers nul) is Aasgier bij benadering een minimaal algoritme (zoals unaire notatie dat is) en geeft dus een maat voor pure structuur zonder vergrotende 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. Ook in Bellenblazer tellen we af tot 0.
Passen we in alternatieve Buizerd systemen de oplaadregel aan, van: groot, groter, grootst.

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

Blijft voor elke Buizerd variant het effect op de uitkomst insignificant, maar deze regels 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 hun significantie verliezen is nog lastig om uit te vogelen…!

We zullen Vogel en Bird nu vergelijken met een nieuwe array functie, die we noemen naar de illustere trekvogel uit een zomers lied. Deze 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) <!-->

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

Als a wat kleiner is maakt dat op deze schaal, waar het basis 2 logaritme van a optelt bij de hoogste exponent, bijkant niets uit.
We noteren Wiel nu in pure array vorm.

  • [a,b,c,1] ≈> 2^^c\^(a*2^b)[,,,1] ≈> 2^^2^^c\^(a*2^b) ≈> V(ab,(ab,c1,3),3)
  • [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) <!-->

Zo bestrijkt onze Wielewaal tellerij W.I in de hele eerste rij de supermachten. Terwijl het Vogel V.O telraam volstaat met drie parameters. Net als Bird en Conway's pijlketens trouwens.

  • [a.,pi..] :r ≈> 2..^{i}pi1\. +Log(a/2) r: ≈> V(a.pi..,pr1,r1) :r- > apprr

De supersnelle bel b van Vogel en Bird komt niet gratis. Die recursie nest subexpressies, wat telbare haakjes kost / kostbare haakjes telt. Extra tekens om expressies (.. in de bel ..) te openen en sluiten, naast haakjes voor de separator [ arrays ] dus.
Bij Wiel regels zijn geen ronde functie haakjes nodig. We hoeven er alleen te voorzien in arrays.

In de box zagen we wat 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 algoritme met de lineaire array van Chris Bird.1 In dezelfde rij structuur loopt Vogel volledig parallel aan Bird en produceert daarin maximale (ongeveer de grootst mogelijke) getallen. Daarom heet dit de toprij.
Bird's systeem is tamelijk uitgebreid, maar we hebben het in appendix U enigszins versimpeld. Ons 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 ons Vogel telraam deze expressie met 1 stap minder $ alleen nog in bel b nesten.

Vogel rij definitie V.I met rest R>0.

  • V.0. (a) = a
  • V.1. (a,1b) = a(a,b)
  • V.2. (R,1) = (R)
  • V.3. (a,1,R) = a
  • V.4. (a,1b,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. Door de voorwaarde, dat R begint of vervolgt met een getal, zijn de regels in elke volgorde toepasbaar.

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} :k+1 <!-->

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 expressie $ 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 met $ 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 het deel A om dit te vervangen door de term B. Regels die de hele expressie = evalueren gaan voor. Bij equivalentie kan een term 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[,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.
Voeg aan het begin van array [p,T] met hulpregel W.b. of door omkering =: van regel W.2. een lege sep [,[]p,T] in. Dan kan hulpregel W.c. de komma bereiken [,[]p,[1]T] en neemt regel W.2. de eerste stap terug 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.
We kunnen naar een gegeven array (of expressie) verwijzen met een dubbele quote ["] of voor de variatie ['] met een enkele quote. En tellen ze links [-"] of soms rechts ["-] af.

De vergelijking van geneste arrays met Conway's pijlen in §2.6 toont meer detail. Onder breiden we de vier schakels van Conway's notatie uit naar de hele a..1 pijlketen en later naar onze extensie {a} met superpijlen.

Wielewaal maakt voortgang door 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]1] = [a,[,[a]1]1] := a[,[.a-,..]a] :a ≈> 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.

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

  • [a,[c.,[i]di..]b] :n := a[,[c.,di..]b] :n V(a,1b,1c.,1di..) :n

Wiel separator index c is het aantal tellers, dat in de rij direkt links van deze sep komt te staan. Zo geeft index d1 het aantal voorgaande rijen in de 2e dimensie, het vlak links. Index di telt in het algemeen de i dimensionale ruimtes links erboven in dimensie i+1.
In alle ruimtes krijgen tellers eerst de waarde a. Ook de rij lengtes en maten van dimensies verder naar links worden a tot aan de basis toe. Terwijl we deze voorgevoegde ruimtes evalueren, groeien de tellers en maten die we daarin opladen recursief. Zodat, wanneer b- opnieuw moet worden - afgeteld, de groeibel a' gigantisch is.

Substitutie met $ subexpressies is aanvankelijk oppermachtig, maar Wiel rijdt met multidimensionale arrays pal naast Bird's 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.

Wezenlijk is het functie algoritme van Wielewaal 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 separatoren binnen hun array ruimtes, zodat er lengte ontstaat. Dit aantal kunnen we noteren met een index. Tellers krijgen in de Wiel per definitie een eigen index, maar we mogen ook komma's op de eerste en binnenste rijen gebruiken.

Aasblazer in §2.4 breiden we met rijen komma's uit tot Aasgier geneste arrays. Omdat we de constante aas a opladen, wat ongeveer 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.
De substitutie van $ subexpressies (dubbele recursie) in bel b en het daarmee opladen van afgetelde tellers levert de grootste getallen op. We noemen zulke maximale functie arrays telramen.

Vogel matrix definitie V.II.

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

Woorden Z en tellers komen nooit leeg 0 te staan, als we de regels in volgorde toepassen. Door hulpregel V.5b. te gebruiken kan een array niet [0] worden uitgeteld, wat wel gebeurt bij Bird's hoekketens. Of vertaal een komma , met regel V.a. naar de sep ,[1] om daar met regel V.6. een bel voor te plakken, en elimineer de lege ,[0]b met regel V.5a. wat links 1 bij b optelt.
Daarna evalueert de nieuwe teller 1b gaandeweg tot 1, zodat daar b iteraties plaatsvinden. Op de eerste rij zorgde dit ervoor, dat Vogel V.I perfect in de pas bleef lopen met Bird.

Passen we matrix regel V.6. nogmaals toe dan vormt zich r-l een reeks (a,$,[i]a-.. :n- waar b pas in de $ subexpressie weer verschijnt. Na dubbele recursie tot ,[1]1 voegen we teller ,[1]b' toe aan het einde van de rij. Zo reduceren we ,[2]a om de eerste rij te expanderen. En de tweede expansie komt er een groeibel aantal elementen bij. Op deze wijze verovert b langzaam alle dimensies.
Zodat onder dimensie n1 een volle ruimte met p1 dimensies n zal ontstaan. Met in elk een reeks dimensies n- van rechts lengte b- (originele bel) en naar links toe recursief grotere bel lengtes.

Vogel's regels zijn simpel vergeleken met Bird's massieve evaluatie, waarbij hij structuren exact afmeet (met lengtes b) en ze compleet vult (met tellers a). Vogel voegt de nodige elementen stap voor stap toe, eerst een lengte a en later pas een lengte die b bevat. De afgetelde elementen tussenin worden overgeslagen en Vogel loopt met zijn lengtes steeds verder uit op Bird (hoewel dit insignificant is).
Het Vogel telraam blijft een bruikbare benadering van Bird's array functie U.II geven. Bird is iets krachtiger, maar als we aan het begin van de meest rechtse rij een extra teller 2, invoegen, hoeven Vogel expressies nooit voor die van Bird onder te doen, zal nog blijken.

In de vergelijking van Vogel met Bird's arrays werken we de overgang naar de tweede rij precies uit.
Soms keren we =: onze evaluatie richting om. Voor meer detail, 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)
  • (a,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} {pi~a} 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 ,1.. op de resterende posities. Pas dan voegen we de hoogste teller ,b toe aan die afgetelde rij.

Zo werkt ook de 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(a,b.,1..,[2]3) :k0 ≈> (a-,a.,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..,1,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-,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,1.pi,..[2]1m) :k>0 ≈> (a,P,1.,2..) :m ~> {a,k+m+1[2]2} {pi~a} 0'>!<

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

Bij Bird speelt bel b de rol van het opblazen van de lineaire array. Van zijn element [2]n kost dat slechts 1 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]1..a..) :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]1..a..) :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,1..a..,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,1,..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]m1,2) ≈> {a,b,P,1.,2..[2]2} :m 0'>!<

Matrix-regel V.6. bouwt de rijen tellers stap voor stap op. Lege elementen ,1 blijven tussenin staan, want opruim-regel V.2. geldt daar niet. Met de recursieve substitutie van rij lengte door een nieuwe bel b worden al de vorige series ,1.. gedomineerd.

Wat dominant uitpakt op de eerste rij, zal sterker gelden in volgende dimensies. Vogel's cumulatief groeiende ruimtes doen onnatuurlijk aan, maar bij Bird's regel die afgetelde tussenposities opruimt wordt het nog lastig om de diep geneste arrays in [S]1[T] te vergelijken.
We schrijven nu unaire variabelen in onze Uil expressies van Bird.

  • (a,b,[2]1,3) = (a,a,a,[2]b,2) ~> {a,b2[2]3}
  • V(a,b1,2,[2]1,3) == (a,a,1,[2]1..a..,2) :b ≈> {a3,b1,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,b2[2]n}
  • (a.,pi..,[2]m,n) :k>0 ~> {a,km[2]n1} {pi~a}
  • (a,2,2,[2]1,1,2) == (a,a,1,a,[2]a,a) ≈> {a,a3[2]a1} {a1,2[2]1,2}
  • (a,b1,2,[2]1,1,2) == (a,a,1,[2]1a,..a..) :b: ≈> {a1,b1[2]1,2}
  • (a,b1,2,2,[2]1,1,2) == (a,a,1..a..,1
    ,[2]1,1,2) :b:
    ≈> {a,b1,1,2[2]1,2}
  • (a,b,1P,[2]1,1,q) ≈> {a,b,P[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:
    ≈> {a3,b1,2[2]2,q}
  • (a.,pi..,[2]m,Q) :k>0 == (a.,pj.. :km-
    ,[2]1,Q) {pj>pi>1}
    ~> {a,km[2]1Q}
  • (a,b,[2]1,[2]n1) = (a,a,[2]1,b,[2]n == (a,P,[2]m.,qi..) :n ~> {a,n1[2]1[2]2}
  • (a,b1,2,[2]1,[2]1,2) == (a,a,1,[2]1
    ,[2]1..a..) :b:
    ≈> {a1,b1,2[2]1[2]2}
  • (a.Pi,[2].. :n>0
    vj,..[2]m1,Q) :k>0
    ~> {a,km.[2]1..Q} :n1 0'>!<

Evaluatie verlengt de rijen in de tweede dimensie door teller na teller toe te voegen. Zo krijgt de rechtse rij vj,.. een lengte :km en de laatst toegevoegde teller vkm ontvangt de grootste bel.

Hoewel de toegevoegde vars v>b kunnen we voor v elk standaard getal invullen. Het maakt weinig uit, de waarde van v is ondergeschikt aan de meest rechtse positie ervan. Door reeksen van v=a te kiezen werd het Vogel systeem hier vergelijkbaar met Bird.

In hogere dimensies blijft de Vogel matrix op dezelfde manier te vergelijken met Bird's multi-dimensionale array. Het Vogel systeem heeft steeds een extra teller aan het begin van elke dimensie nodig, om de lengte van de dimensie ervoor te bepalen.
De hoogste dimensie is dominant en pakt groot uit in de voorliggende dimensies, dus is er maar één extra teller nodig. Die ondervangt al de expansies van Bird zijn hoekketens. En als we in de meest rechtse rij de lege lengte teller 1, toevoegen, dan werkt dat altijd zo uit, dat die dominante dimensie teller wordt opgeblazen.

In het eerste item wordt de laatst te substitueren bel groter dan een expressie 1v = (a,a.,[s]b..,[s1]2) met lengte :b- maar niet langer dan dat. Terwijl 1b al voldoende is om Bird te overtreffen, want dit voegt de serie ,[s-]a.. :b links in, een sep langer dan bij Bird's hoekketens.
Toch is dit enorme verschil van de ingevoegde lengte v in deze ~ opzet insignificant en ook de waarde van a doet er niet toe.

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

In het tweede item gaan we ervan uit dat, afgezien van het Vogel sep array , komma format, de delen X precies gelijk := zijn of althans ~ de belangrijkste dimensie sep in deel X bij Vogel en Bird dezelfde is en even vaak herhaald. En ook dat het rij deel Q van Vogel met de 2e en verdere tellers rechts exact gelijk is aan de hele rechter rij bij Bird.

In elke Vogel rij, ook in Q, is opladen met regel V.5. dominant. Bird's arrays (met teller c) komen door zijn regel 2.6. overeen met die van Vogel (met teller c1 om de voorganger $ voor te laden).
Vogel's achterstand blijft beperkt tot een extra teller m, en de beste benadering geeft m=1. Maar voegen we m=2 na de rechter sep toe, dan wordt de Vogel expressie altijd groter ~> dan die van Bird.
Zowel opladen van subexpressies $ bij Bird als zijn totale expansie door substitutie van a in eerdere tellers en ketens €n voor dimensies worden in Vogel door de uitwerking van die ene extra teller ,[s]2 ondervangen.

Toch is m=1 soms niet genoeg. Stel dat we bel b opladen naar de 2e teller in de hoogste rij ,[s]1,1b van Vogel. Eén tel eraf en lengte teller m=a1 is nog klein. Die vergroot de lengte van de voorgaande dimensie met a en blijft ver achter bij lengte b van Bird's hoekketen. Maar de aftel b- daarna zal de waarde m=b' die als dimensie lengte uitwerkt al veel groter zijn dan de originele bel. Ga maar na hoe latere bellen b' via regel V.4. alle eerdere bellen vele malen bevatten.
Om bij m=1 onze extra aftel en subexpressie $ opladen van Bird te compenseren is a1 en c1 ophogen in Vogel voldoende. Maar als de rest gelijk blijft voegen we gewoon de teller m=2 rechts toe.

Lengtes in Vogel groeien eerst met a en daarna meteen voorbij de hoekketen lengte b, waarmee Bird al zijn ruimtes vult. Daarna vaagt elke iteratie van een naar positie m opgeladen bel b' de ervoor opgebouwde lengtes in de Vogel matrix volledig weg. Deze lengtes dragen over en expanderen alle vorige dimensie maten recursief.
Maar ook dat verschil met het systeem van Bird is insignificant. Want de accumulatie van lengtes in Vogel blijft als optellen (als 1 oude tel van c dus), wat op dit niveau vrijwel geen effect sorteert.

In het algemeen, zolang de structuur van Bird en Vogel vergelijkbaar blijft, kunnen we een enkele teller 2, inlassen aan het begin van de meest (diep geneste en) rechtse rij in Vogel, zodat onze getallen een insignificant grotere benadering geven voor de multi-dimensionale (of geneste) arrays van Bird.


In een tellerij groeit bel b, die we over de rij en verdere dimensies schuiven, door unair ab optellen (primitieve recursie). Ons Wielewaal of Wiel systeem is zo'n tellerij. Het 1e niveau of de [top array] in Wielewaal start met een variabele a die verdubbeld wordt. De volgende iteraties herhalen dit en elkaar. Na opladen van bel a itereren we steeds meer keer. Deze rij tellers drukte supermachtige getallen uit in blog §3.0.
Maar het telraam van Vogel en Bird gebruiken slechts drie tellers voor supermachten, door de dubbel recursieve subexpressies in b. Wiel liep gelijk al flink achter.

Posities op de Wiel rij tellen we met een index op het 2e niveau, ook weer gevolgd door een oplaadbare rij, de [index array].
Vanaf c corresponderen de tellers in Bird's lineaire array met deze indexen in Wiel. Wiel's twee niveau's vormen een matrix, die Vogel's toprij benaderde in vorig blog §3.1. Wiel's meerdere dimensies zijn als volgt te vergelijken met de tellers in Vogel en Bird's telraam:
Supermachten op de 1e rij in Wielewaal met de 3e teller van Vogel. de rijen van de 2e dim in Wiel met Vogel's 4e teller, die waarmee Bird de rij van Conway's pijlketen benaderde. Enzovoort, de dimensie d van Wiel met teller d2 in de eerste Vogel rij.
Het meer naar rechts substitueren van $ subexpressies met c bij Bird is gelijk aan b opladen in de Vogel expressie na uitwerking van c1. In Wiel betekent dit een extra teller op de eerste rij, ofwel 1 tel extra bij de eerste positie index. Dat is vanaf de tweede rij verwaarloosbaar.

Boven evenaarde de Vogel matrix de multi-dimensionale arrays van Bird. Allebei de systemen evalueren hun input dimensies bijna tot maximale output. Alleen als we de structuur uitbreiden kunnen we significant grotere getallen produceren.
Om ondanks de langzamer groeiende bel in Wiel even grote getallen uit te drukken, reizen we door de hyperdimensie. In die geneste ruimte leven positie indexen, die zelf een rij zijn.
De rij lengte of komma teller in Vogel komt nu gelijk met 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, zodat het verschil in niveau's niet groter wordt.

We werken Wiel expressies nu uit tot het hyper array niveau, volgens regels W.II voor geneste arrays. Op dit 3e niveau [index subarray] scheiden we de indexen weer met komma's , en eventueel met een 4e niveau [sub sub index].
Het begin luistert nauw: hoe sturen we bel a de diepte in?

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

Klik op de borden <!--> om vergelijkingen met meer variabelen te tonen. Daar staat de enkele tilde ~ voor de gebruikte benadering, waar de expressie links ≈> insignificant groter is dan die rechts (en minimaal groter, gegeven de array vorm).

De teller van Wiel element ,[,1]e is te verwaarlozen, omdat de in te laden bel ,[a]e domineert. Dit is kleiner dan ,[1,1]1 een tel van het volgende element, die tot ,[a]a reduceert. Net als ,[a1]1 trouwens, waaruit blijkt dat teller e nauwelijks 1 telt bij zijn index.

Nu werken we Wiel expressies uit tot de tweede rij van Vogel. In Vogel geeft de eerste teller een extra lengte aan de rij ervoor. En pas bij de tweede teller begint dezelfde array rij van Bird.

  • [a,[,[1,1]2]1] = a[,[,[a]a,["]1]1] ~> (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]1,[2,1]1]1] = a[,[,[a]a,["]1]a] ~> (v,v,[2]a1,1,2) =: V(v,a,[2]1,2,2)
  • [a,[,[2,1]2]1] = a[,[,[-"]a,["]1]1] ~> (a,a,[2]a1,a,2) =: V(a,a,[2]1,1,3)
  • [a,[,[,2]1]1] = a[,[,[a,1]1]1] ≈> (a,a,[2].1,..2) :a ~> V(v,v,[2]1,[2]a-) <!-->

Hogerop wordt de array structuur dermate dominant, dat het precies passend krijgen van tellers er weinig toe doet. Voor het gemak kunnen we de groter > ordening achterwege laten.

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

Deze met Wielewaal hyperdimensies [W] uitgedrukte getallen zijn ongeveer gelijk (vaak groter, soms kleiner) aan die van de Vogel V(X) matrix, die op hun beurt de multi-dimensionale arrays {Y} van Bird benaderen.
Met dieper geneste indexen maken we grotere getallen, zoals Bird noteert in hyper-dimensies. Daarover in het volgende blog.

Blijkt dat de dimensie lengtes van Bird en Vogel hun gelijke vinden op het 3e niveau in Wiel. Vogel rij lengte met de dim-index [p aan het begin van die subarray in Wiel, aantal rijen in een Vogel vlak met subindex element ,[1]q in Wiel, aantal Vogel vlakken met subindex ,[2]r in Wiel, enzovoort.
De dimensie zelf bij Bird en Vogel vergelijkt dan met de begin index op het 4e niveau in Wiel. En dat ligt twee array niveau's dieper.

  • [a,[,[p.,[si]qi..]h]1] :r {si<si1} V(a,a.,[si1]1.. :qi ,1..h) r :p

Vogel dimensies si+1 zijn in dit item verticaal gestapeld. Elementen ,[si+1]1.. krijgen ieder een eigen lengte met de :qi reps. Dat herhalen we weer met een r rechts verticale rep, zodat hun naam index i van onder naar boven toeneemt.
De lengte :q van Vogel dims is gelijk aan subindex q op het derde niveau in Wiel. De dimensie s1 zelf kunnen we in Wiel aangeven met komma plaatsen ,.. :s of hier door subsub [s] te nesten.

Iedere expressie is een string van tekens. Units 1, een separator merkteken , en haakjes. Haakjes voor sep arrays nesten in wezen strings van getallen in strings van getallen, zonder er een hele string van te maken.
Expressies wordt door de regels van het systeem van l-r tot grote getallen in unair formaat 1.. herleid. Maar we kunnen witruimte en reps en variabelen toevoegen om deze systemen te verklaren.

In de formule is gesteld dat si1>si en dat bij Vogel de herhaling r onder begint, zodat de dimensies links in de expressie groter zijn dan rechts. Bij Wiel met het 4e nest loopt dat andersom. Opeenvolging si1=si1 kan, maar is niet verplicht.
Of deze maxtrix vergelijking ook geldt als de sep indexen si niet in volgorde van grootte staan, laten we aan de lezer over…!

X

§3.3 Vernest

Bird's hyper-dimensionale arrays3 is een structuur met dermate veel tellers of argumenten (en rijen van tellers en ruimtes daar weer van), dat de indexering ertussen (bij herhaalde separatoren) zelf tot een rij is uitgebreid. Zowel de tellers in de top rij als de indexen in de sep arrays zijn iteratoren en hebben de functie om de iteratie links ervan te herladen als deze is afgeteld. De te laden bel is steeds (ongeveer) maximaal en daarmee is Bird's array functie maximaal.

Ons Vogel telraam waarmee we Bird vergelijken heeft ook de rij in rij structuur. Door sep arrays te herhalen krijgen we een maximum aantal posities in de array erboven. En door sep indexen te herladen met de bel, expanderen we alle voorliggende ruimtes maximaal.
Aan de basis substitueren zowel Vogel als Bird de (minimaal kleinere) subexpressie $ in de bel. Bel b is de enige geneste variabele, want meervoudige functie substitutie wordt niet significant groter.

Bird of Uil substitueert subexpressies $ ook rechts in arrays. Dat is overbodig, het volstaat om in onze Vogel benadering van Bird die $ alleen te nesten in de basis.
Kenmerkend voor de Main arrays van Bird is het herladen van de rechtse lege teller met subexpressie $, de tellers ervoor met constante a en sep arrays overal met de maximale bel b.
Dominant is hierbij het opladen van tellers en inladen van index arrays met de groeibel. Vogel doet dit direkt met de b uit de basis, maar Bird verpakt b- in een subexpressie $ alvorens deze op te laden. Uit de vorige blogs bleek al, dat dit verschil (met Bird c tegen c1 in Vogel) niet veel anders uitpakt.

De eerste index noteert de matrix dimensies. De hyperdimensionale arrays breiden dit uit tot een rij indexen op het tweede niveau. Ook daarin kunnen we de indexen en rijen nesten, wat precies eender werkt. Grote getallen zijn ver genest of vernest als hun arrays dieper gaan dan de hyperrij.
We slaan een aparte definitie voor dit niveau over en geven de regels voor alle geneste arrays in Vogel. Zo kunnen we rijen indexen arbitrair diep in andere rijen nesten.

Tijdens de constructie neemt het niveau van geneste arrays 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 structuren, die naar beneden toe worden opgebouwd en toenemen.5
Zoals <tag> tekst </tag> is opgemaakt in html. De tag naam kun je zien als type haakje of als index voor een geneste rij. Met een script adresseren we eerst het ouder element en dan de kind elementen die daarin zijn genest of vertakt.
Of een verhaal dat wordt vervolgd door zinnen eronder te plaatsen.

Maar geneste structuren werken ook andersom:
Bird4 telt het level van separator arrays: vanaf index [m] met level 0 die dimensies m scheidt, lineaire separatoren als level 1 tussen hyper-ruimtes. Enzovoort, zodat de grootste level n separator ergens in de top array {Y} zal worden genest.
Een macht b in een dubbele recursie V.O bereikt bij waarde b=1 de bodem (a,..a..,c) in de subexpressie 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. Dit is axiomatisch bij oneindige limieten ω, zie §1.4 ev.
Onze superradix structuur in §2.4 noteert in de diepste array de getallen m, machten m^m met de array laag erboven, en stapelt laag op laag een toren van m^(m^^n) machten, die tetratie m^^n1 is.

Vogel nesten definitie V.III met {S>0}.

  • V.0. (a) = a
  • V.1. (a,1b) = 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,1b,1Z) {Z>0} = (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 {S>n} `= (a,b ,[S]b,[1S]1

Probeer de regels = en `= van l-r toe te passen op de (binnenste) expressie, dat wil zeggen, vindt een match die (daarin) links start. De eerste match van links dient met prioriteit te worden uitgevoerd. Waar een match eindigt is ondubbelzinnig, elk links startpunt blijft uniek.

Zo matchen we een element ,[1,[1n]1T]p met regel V.7. die een nieuw element ,[,[1n]1T]b ervoor zet. Deze is opgeladen met een kopie van bel b, waarbij de basis bel blijft staan.
Dan laden we die bel met regel V.6. over ,[n]b in de index array en vervangen de bel zelf door aas a. Bij n=0 vervalt de lege sep en in dit geval blijft dimensie index [b over.
Door regel V.6. van [n-] rechts naar [1] links te herhalen, laden we een rij ,[i]a-.. met :n- hyper-indexen in. Met V.5. is ook de dimensie [a en het nieuwe element klaar.
Noem dit element ,[a,S]b en plaats links ervoor afstapsgewijs de reeks van ,[j,S]a tot element ,[1,S]a is bereikt. Dit schept :a nieuwe elementen op het top niveau. De hier beschreven subroutine komt daarmee terug op het beginpunt.

Zolang als S>1 herhalen we deze subroutine eerst met ,[,1Tk]a en elementen ,[1,Sk]a op het eind. Nadat woord S leeg is geteld, wordt ook element ,[1]a bereikt.
Dit kan bij input raken (a,a,a aan de basis, maar zal later na vele lege ruimtes rechts ,a aansluiten. Toch komt elke evaluatie trein uiteindelijk bij de basis aan.
En dan zal basis regel V.4. de expressie $ met de oorspronkelijk op en ingeladen bel b substitueren. Wat bewijst dat we voortdurend niet slechts a (of subexpressies met a), maar vele grotere bellen b' de hoogte in blazen.

Wanneer de eerdere index ,[n-]a- is afgeteld, kunnen we rechts van ,[n-]1 zo'n nieuwe bel ,[n-]bn inladen. En na afdaling tot sep eliminatie regel V.5. wordt ook de eerdere ,[n-]1a opnieuw actief.
Belangrijk is niet de duur van dit hele evaluatie traject, of de grootte van de nieuwe bellen bi (dat is insignificant), of de lange reeks van extra elementen die met die bellen Bi zijn ingevoegd en afgedaald. Belangrijk (en significant) is alleen dat de oorspronkelijke waarde b daarin op zeker moment op al die n1 posities [B0.,[i]Bi.. :n is ingeladen. Want zo worden Vogel index arrays vergelijkbaar met de betreffende regels van Bird, die dominant (significant) zijn.

Elke (geneste) index in array systemen komt leeg, net op het moment dat bel b naar de teller (of index) erboven is opgeladen.
Zonder b kopie, in de Bellenblazer definitie, zijn afgetelde indexen een probleem. We losten we dit op, door sep arrays vanuit hun teller op te laden, zodat de originele bel b de array niveau's als in een cascade afdaalt. Dat is het zuinigst.
Bird vervangt met zijn subsysteem voor hoekketens uit voorzorg alle waarden door b, lengtes zowel als indexen. Zo garandeert hij dat zijn ruimtes volledig (maximaal) gevuld zijn, maar helaas geeft het een overdaad aan extra regels.
Vogel's definitie V.III is simpeler dan Bird's geneste arrays U.III.
Bij ons komt b, doordat regel V.7. deze voor het opladen van teller dan wel index kopieert, ook in diepere geneste arrays terecht. Hoewel we grotere b' gestaag naar voorliggende tellers, indexen en lengtes verhuizen, maakt dit traject de expressie niet significant groter dan direkte substitutie van b zou doen. Dit mag u bewijzen…!

We zetten de vergelijkingen uit blog §3.2 voort. De geneste arrays van Vogel en Bird zijn vrijwel even snel. Voegen we aan de meest diepe rechtse ruimte in Vogel een teller of index 2, aan het begin toe, dan wordt Vogel al ≈> groter dan een gelijke expressie bij Bird.
Aan de vars v gaat een evaluatie traject vooraf, waarin v veel groter werd dan b. De waardes van v en a zijn niet van belang in deze ~> Vogel expressies en we hebben de array structuur vereenvoudigd.
Klik op dit hyper-dimensionale bord voor meer detail.

  • V(a,1b,[1,2]2) = (a,1b,[,2]1b) = (a,a,[1b]1b) = (a,a,[b]a,[1b]b) ~> (a,v.,[b]v..) :b ~> {a,b[1,2]2} = {{a[1,2]b}} = {a<0,2>b} = {a<b>b} == {a<b-1>b[b]..1} :b = {{a[b]b}[b]..1`} :b =: {{a[b1]b}} =: {a,b[b1]2}
  • (a,1b,[1,2]1,2) = (a,a,[2b]1a) ~> (a,v,[1b]v) ~> {a,b[1,2]2}
  • (a,1b,[1,2]3) ~> (a,v.,[b]v..,[1,2]2) :b ~> {a,b[1,2]3}
  • (a,1b,[1,2]m) ~> {a,b[1,2]m}
  • (a,1b,[1,2]2,2) ~> (a,v,[1b]b,[1,2]1,2) ~> {a,b[1,2]3}
  • (a,1b,[1,2]m,2) ~> {a,b[1,2]m1}
  • (a,b,[1,2]1,3) = (a,a,[1b]1a,2) ~> (a,v,[1b]v) ~> {a,b[1,2]2}
  • (a,b,[1,2]m,n) {n>1} ~> {a,b[1,2]m1}
  • (a,b,[1,2]m,[p]1,2) ~> {a,b[1,2]m1}
  • (a,1b,[1,2]m,[1,2]n) ~> {a,b[1,2]mn}
  • (a,b.,[1,2]m1..) :n ~> {a,b[1,2]m*n}
  • (a,b,2,[2,2]2) ~> {a,b[1,2]1,2}
  • (a,b,2,[2,2]m) ~> {a,b[1,2]1,m}
  • (a,b,2,[2,2]R) ~> {a,b[1,2]1,R}
  • (a,b,2,[3,2]2) ~> {a,b[1,2]1,1,2}
  • (a,b,2,[3,2]R) ~> {a,b[1,2]1,1,R}
  • (a,b,2,[p1,2]R) {p>0} ~> {a,b[1,2].1,..R} :p
  • (a,b,[1,3]2) = (a,a,[b,2]b) ~> {a,b[1,2]1[2]2}
  • Rekenwerk in uitvoering
  • (a,b,2,[p1,3]R) ~> {a,b[1,2].1[2]..R} :p
  • (a,b,[1,q1]2) = (a,a,[b,q]b) ~> {a,b[1,2]1[q]2}
  • (a,b,[p1,S]R) ~ {a,b[S].1,..R} :p 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

De regels W.II voor geneste Wielewaal arrays werken simpeler dan die van Vogel. Merk op dat we de aasbel a zowel binnen als buiten de functie array noteren. In beginsel vormt dit een geheel en de top array kan dus zonder opening [ haakje.

Wiel subarrays evalueren tot de vorm [p,[1]S] met een eerste index 1. Vervolgens tellen we p- af, tot [,[1]1S] de dubbelbel a oplaadt [,[]a,[1]S] waar de lege sep vervalt.
Ook in de basis staat de index 1 komma a,[1]1X die een kopie a,[]a,[1]X maakt en de bel aa,X verdubbelt.

Om te testen welk primitief (tellerij) algoritme het simpelst is, zetten we een experiment op met eerste posities.
De superradix in de box krijgt een nieuwe structuur, met een algoritme dat lijkt op Wielewaal. Het nieuwe, ook ten opzichte van Aasblazer, is dat eerste seps ,[1] na een inerte komma n,p komen.
De a die we opladen is dan een constante en de bel a,ba,X groeit alleen de som voor de uitkomst. De rest kan gelijk blijven.

# 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.
In zulke systemen staan dominantere variabelen meer naar rechts. Dominant is wat bij gelijke waarden groter uitwerkt.
Oneindiger series a.. tellen we van rechts bij (keert Cantor om). En eigenlijk zouden we decimale getallen liever andersom schrijven.

Aalscholver is net als Aasgier een superradix van het Aasblazer type. Maar hier 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. We nesten louter rijen in rijen.

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

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

Door radix expressies 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 kunnen tellers c groter dan radix a worden 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

We breiden getallen uit tot arrays. Zo'n subarray staat in Aalscholver los van zijn positie. Dezelfde array zou op meerdere plaatsen kunnen voorkomen, hoewel niet binnen een strikte radix expressie.
In de binnenste arrays houden we gewone tellers. Zetten we die op rij, dan blijkt de positie (anders de tweede index) uit het aantal ervoor staande komma's (de eerste telt als index 0).

Dit systeem met opladen van constante a en complete indexering noemen we vloeibaar. Want elk kind element ,(p,S) telt op in zijn ouder array (n,p0.,(pi,Si)..) en kan in die som natuurlijk vrij worden verschoven.
Array variabelen kunnen eerder links komen of meer rechts staan of herhaald worden. Tussen de kind arrays in een rij kunnen verstrooid getallen pi voorkomen, eerder uitgewerkt, die later pas bij de positie index p0 van de ouder array arriveren en optellen.
Alleen de constante a en factoren n hebben direkt een vaste plaats. De bulk b en exponenten p0 zijn hun duo met index i=0 alvast ontstegen en buiten de radix gerekend dus vloeibare getallen.

Aalscholver Á.II geneste arrays, in volgorde voor radix.

  • Á.0. (a,b) ≡ (b) = b
  • Á.1. ,(,S) ≡ 0
  • Á.2. ,(p,)p
  • Á.3. (a, ,(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. Daarin 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 sep nodig. Dat wordt in exponentiële notatie cE..di met k: decimalen di andersom.

In het algemeen tellen geneste rijen op als dubbele exponenten in de exponent van de ouder array.

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

Precies als in §2.4 groeien Aalscholver nesten uit tot 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,..1..).) :m: = a^..1 :m = a^^m

Deze superradix expressies drukken de 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.

Als we de inerte komma uit de basis (a verwijderen, dan verandert de Aalscholver superradix in een andere vorm van Wielewaal. Of dat simpeler is laten we aan de lezer over…
Gaan we verder met onze vergelijking van Vogel en Wiel.

Na een langzame start evenaarde de 2e nest rij van Wiel de 1e rij van Vogel = Bird's lineaire array, zie §3.1. Daarna kwam Wiel's 3e nest rij overeen met de lengtes (herhaling van sep dimensies) van de Vogel matrix Bird's multi-dimensionale arrays, bewezen in §3.2.
De regels voor geneste arrays in Wiel W.II zijn zo simpel mogelijk, maar voor gelijke output moeten we dubbel zo diep nesten als Vogel.

We denken dat de nieuwe array niveau's zich net zo verhouden als deze eerdere niveau's. Dan rolt Wielewaal over oneven niveau's de indexen uit, die posities in Bird's ruimtes representeren. En volgt daaruit de algemene vergelijking van geneste arrays in Wielewaal versus Vogel en Bird.
Wiel begon twee niveau's dieper met Vogel's eerste index. De verdere tellers op de Wiel's 4e nest rij benaderen nu Vogel's 2e niveau Bird's hyper-dimensies. En op Wiel's 5e nest rij zullen we de herhalingen van die separator arrays vinden: de maten van Bird's subruimtes.

  • [a,[,[,[,1]1]1]1] = a[,[,[,[a-]a]1]1] ~> v[,[1,[1,[a-]a-]v]v] (v,v.,[a]1..,2) :a V(v,a,[a1]a)
  • [a,[1,[1,[1,1]1]1]1] = a[,[,[,[1,1]1]a]a] = a[,[,[,[a]a]a]a] (v,a,[a2]a) V(a,a,[1,2]1,2)
  • [a,[,[,[1,1]2]1]1] = a[,[,[,[a]a,["]1]1]1] V(a,a,[1,2]1,[1,2]1,2)
  • [a,[,[,[2,1]1]1]1] = a[,[,[,[1,1]a]1]1] V(a,a,[2,2]1,2)
  • [a,[,[1,[1,2]1]1]1] = a[,[,[,[a,1]a]a]1] =: a[,[,[1,[a1,1]1]1]1] V(a,a,[,3]1,2)
  • [a,[,[k,[p,1]n]e]1] V(a,a.,[p,2]1.. :n ,1..e) :k <!-->

In het algemeen kunnen we elementen ,[,[S]T]e vervangen <≈ door ,[1,[S]T]1 of een tel bij zo'n volgende element. Daarbij wordt de teller e insignificant door de groeibel op te laden.

Denkwerk in uitvoering

Op de eerste rij in Wielewaal staan seps met een index voor de teller positie. Deze breiden we uit tot index arrays die rijen in rijen nesten, en daarna tot diepen die over hun nest diepte itereren.
In een tellerij groeit de bel door optellen. Ook krijgen alle teller posities unieke indexen en tellen we iteraties af tot 0.
Vanuit hoger perspectief bezien kan het direkt substitueren van een top array (grootste structuur) in een getal (kleinste structuur) nooit meer opleveren dan een extra index array niveau. Dat komt omdat de separator indexering in tellerij en telraam systemen dezelfde array vorm krijgt als de hele expressie.

Tellerijen beginnen met achterstand, omdat hun regel voor de basis bel zo primitief is. Zodra we tellers voorzien van een minus - kopie van de volgende aftelbare subarray, dan wordt de expressie even snel als met nesten van $ subexpressies (allebei rij in rij).
Met het vullen van een vlak haalt Wielewaal's derde index Conway's pijlketens in. Met Vogel en Bird's arrays komen we later gelijk, door over de diepte van geneste index arrays te itereren.

Als we overgaan tot post-indexering na a en de bel beschouwen als de eerste index array, dan hebben we voor een Vogel-achtig algoritme geen functie haakjes meer nodig. Dan worden subexpressies uitgedrukt met de eerste geneste array. Dus 1 nest niveau is gelijk aan 1 positie die in rijen genest wordt.

Vanuit hoger perspectief bezien moet het direkt substitueren van expressies (grootste structuur) in tellers (kleinste structuur) wel even sterk zijn als één niveau van geneste arrays. Omdat eigenlijk alleen het top niveau wordt toegevoegd.
Nooit meer dan 1 niveau, mits de expressie en subarrays dezelfde capaciteit hebben. Door de groeibel te substitueren op alle niveau's, geldt dit verband niet alleen voor de eerste rij, maar draagt over naar elk niveau.
Toch is dit vreemd, aangezien voor subarrays hele andere introductie regels W.3. gelden (links toevoegen), dan hoe regel V.4. in Vogel subexpressies nest (binnen vervangen).

Om dit te verhelderen, stel dat we Vogel vertalen naar een structuur, met post-indexering na a en waar de eerste index array bel b bevat. Hierin worden subexpressies genest als arrays met een eigen basis. Functie haakjes () zijn in dit systeem overbodig.
Hoe het algoritme precies werkt doet er nu niet toe, duidelijk is dat we Vogel expressies naar deze post-index vorm kunnen omzetten.
Nesten van $ subexpressies (functie substitutie) is 1 niveau waard, want Vogel rij en Wielewaal index rij liepen gelijk. Dan heeft ook elk rij element, dat we recursief verdiepen (matroesjka poppenspel), de waarde van 1 nest niveau.
Array lengte en rij in rij diepte worden vergelijkbare grootheden.

Bird's volledige eliminatie van elementen is een luxe constructie. Vogel V heeft minder regels en laat elementen tussenin met teller 1 gewoon staan. Het cumulatieve effect van de oude reeksen op de uitkomst is insignificant, maar de chaos in Vogel expressies neemt toe.
In Bellenblazer en Wielewaal W heeft elke teller een positie index en vallen de afgetelde elementen weg. Geneste arrays zijn twee keer zo diep om even grote getallen te maken als Vogel. Bellenblazer regels worden moeilijker bij dieper nesten. Wielewaal blijft makkelijk van opzet, hoewel deze chaotisch begint met dubbelen, wat afwijkt van natuurlijk a*b herhalen.
Zulke concepten zijn op wonderlijke wijze uitwisselbaar…!

X

§3.4 Diepen

Denkwerk in uitvoering

Het Wielewaal systeem heeft in de basis een bel a die groeit door bij zichzelf op te tellen. Een tellerij die verdubbelt.
Verdere tellers staan op unieke posities en verminderen stap na stap tot 0. Vanuit de volgende positie kan zo'n afgetelde iteratie opnieuw worden opgeladen met een grotere bel.
De positie index staat in een separator array of is het aantal vorige komma's op rij. De sep arrays breiden we uit met rijen van indexen. Daarin worden rijen in rijen genest, zoals sets in een set structuur.

Tellerijen beginnen met fikse achterstand, omdat hun groeibel regel optelt, wat primitieve recursie is. Telramen winnen het met dubbele recursie, die vanzelf expandeert tot recursie over de hele expressie.
Zodra we de positie index array voor een nieuwe teller voorzien van een minus [S] kopie van de volgende [1S] sep, wordt Wielewaal even snel als Vogel met $ subexpressies (allebei rij in rij). Maar de unieke indexen voor elke positie (noch lengte, noch ruimte) kost Wiel een extra niveau per geneste Vogel array.

Met het Wiel vlak haalden we Conway's pijlketens in. Nu wint Wiel het van Bird's geneste arrays, als we nest diepte laten belgroeien.
Deze functie sprong maken Wielewaal diepen, eenvoudig door index arrays te herhalen. Waarbij de eerste index in de volgende array de diepte van de voorgaande array recursief vergroot.
Arrays in reeksen [Xi].. vormen net als enen 1.. met elkaar een getal. Maar units 1 zijn inert en arrays expanderen elkaar.

Bird's Universum

De array notatie van Chris Bird heeft drie systemen voor de introductie en eliminatie van elementen: hoofdregels, hoekketen regels en een ordening van grootte voor separator arrays.
Bird's universum van expressies en getallen (input en output) zetten we in deze appendix om in een simpeler Uil systeem.
Ook Uil breiden we met twee hulpsystemen uit: de bank arrays en de nieuwe ruimte merken met hun regels.

Input expressies en daarmee uitgedrukte getallen zijn exact gelijk aan die van Chris Bird.0 Maar onze array regels, die expressies stap na stap herschrijven, zijn bondiger dan in de originele systemen.
Sommige regels voegen we samen en de overbodige vervallen. De lijst volgorde bepaalt weer welke regel we toepassen, maar is anders dan bij de regels van Bird.

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

Bird gebruikt hoekketens <a[T]b> om vrije array ruimtes in reeksen te vullen. Dezelfde expansie bouwen we hier per element op met het stel arrays {a[T]b,k} dat in zijn systeem geen rol speelt.
Vanaf dimensies komen onze bank regels, die deze dummy arrays reduceren, in plaats van Bird's subsysteem voor hoekketens.

En in geneste arrays zijn onze ruim regels voor uitgetelde dimensies een stuk simpeler. We verwijderen het lagere element uit [S]1`[T] waar begin en einde van zijn `ruimte` eerder is gemerkt.
Terwijl Bird's subsysteem om de grootte [S]<[T] van sep arrays te vergelijken steeds ingewikkelder wordt. Gelukkig is voor 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 expressie voor de volgende stap $ is gegeven door bel b met 1 te verminderen (dit 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} een 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 bij 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 zijn bij Bird nooit 0, daarom beginnen woorden Z,S,Ti hier met een getal. Separatoren [S] kunnen ook een [1] komma , zijn.

Een woord komt net eender terug na evaluatie, compleet met ` ruimte accenten. Zo ook bij reeksen `.. :n0 die we ongeteld met de afkorting aangeven. Zo'n reeks blijft op zijn plek, in de regels 3.6 en 3.7 rechts van de sep array [Ti] die we links expanderen.
De afkorting sluit een onbestemd aantal ruimtes uit (input kan soms zonder). Om minder accenten te noteren, verwijderen we die links.

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.
[Chinese etymologie, maar men werpt een I Tjing hexagram van onder naar boven, terug het verleden dan]

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
    5. V diepen = W diepen

© 2019
Giga Gerard