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

Dit blog beschrijft het Wielewaal telrad systeem, dat een groeiende variabele a substitueert in een superradix structuur als van Aasblazer. We spreken van een telrad, als we getallen in arrays alleen kopiëren en verschuiven.

We itereren in Wielewaal, totdat tellers of iteratoren leeg 0 komen te staan tussen hun ,, separatoren of komma's met index arrays. Afgetelde posities elimineren we.
Al op de eerste rij introduceren we separatoren met indexen voor nieuwe tellers. Deze breiden we uit tot geneste arrays en diepen.

Natuurlijke getallen schrijven we met het teken 1 als een serie enen 1.. en zulke variabelen a en b tellen direkt op als ab.
Als 1 de positieve eenheid is, is het minus teken - de negatieve eenheid. Zo is 1-=0 leeg en een getal n1 telt - af tot n.
Deze basis voor getallen heet unair. Daar staat 2 voor 11, een 3 voor 111 en zo voort. Getallen in het tientallig stelsel schrijven we liever 108. met decimale punt.

Reeksen binnen expressies noteren we eenvoudig zo:
In ^{n} herhalen we het ^ macht teken n keer. Dat is trouwens hetzelfde als *{n1} met repetitie van supersterren.
Met punten selecteren we een woord .groep.. en met de rep herhalen we deze :n aantal keer op die plaats.
Indexen i of j incrementeren we tijdens een repetitie vanaf 1. Ook zijn er dubbelzijdige :n: reps. Het wijst zichzelf.

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 nog hogere recursie of vormen van herhaling. En we schuiven de kopie van subtotalen a' door naar rechts om de lege tellers in dit telrad opnieuw op te laden.

Het kan veel sneller, met Knuth's pijl operaties a^{c}b bijvoorbeeld. Deze supermachten worden ook bij Bird met slechts drie parameters {a,b,c} genoteerd. Samen vormen de constante a, recursie teller b en super teller c het zogenaamde supertrio.
De beperkte functie input geeft super output, omdat elke superstap een subexpressie nest op de plaats van de recursie stappenteller. Deze subexpressie $ is een minimaal kleinere kopie van de expressie en bevat maar één stap b- minder.

Bird substitueert subexpressies bij elke hoge recursie in zijn arrays. Dat is overbodig. Het voldoet om in onze Vogel benadering alleen subexpressies te nesten in parameter b, aan de basis.
Het is jammer dat Bird, in navolging van Knuth en Conway, met machtsverheffen ^ begint. Natuurlijk is vermenigvuldiging * al de eerste herhaling, zodat drie tellers V(a,b,c) de supersterren a*{c}b weergeven.

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 natuurlijke getallen 1.. n>0 want in Vogel staan tellers in de top array nooit leeg. Deze voorwaarde maakt hier duidelijk welke regel(s) van toepassing zijn op de expressie.

Hieronder op het demonstratiebord herleiden we het Vogel trio precies tot supermacht operaties, waarmee ook Bird's array begint.
Klik op het 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} <!-->

Bird's arrays zijn omgeven door krulhaken {Y} en hij telt er schools in op +1 en af -1.

Hilbert dacht in 1925 misschien nog functie indexen nodig te hebben om hoger recursieve functies uit te drukken. In het bewijs uit 1928 van Ackermann werd de voorganger expressie zonder omweg genest.

# Blazers 3.0

Als we in deze structuur getal a constant houden en opladen, vormt zich over de top array een radix functie. In het laatste item, op de rij, blijven getallen dan onder de q1*a^r steken.
Uitgebreid tot superradix noemen we dit algoritme de Aasgier. Het verschilt in naam met de Aasblazer rij, omdat we in dit verband tellers in eerst geneste rijen scheiden met komma's.

De Aasgier rij regels À.I lijken op die van W.I.

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

Aas a is een constante: een radix 10 naar keuze.
Om dit als radix te laten werken, moeten ook alle lengtes en tellers 0p<a zijn, tenminste in de input. Dan krijgen alle natuurlijke getallen met deze rij een unieke expressie.
De rij expressie stopt omdat we gaan nesten na a[,{a}1]- wat in basis a=10 het getal 9999999999. geeft.

Bij deze lineaire array met komma's is regel À.1. een speciaal geval {n=0} van regel À.3. voor commutatief optellen. Met oneindige getallen als Cantor's a=ω is omkeren nog altijd nodig.

Om tellers compleet p=0 af te tellen in Bellenblazer en toch dezelfde input waardes te schrijven, zullen we de oplaadregel aanpassen.
Ook nu telt de primitieve recursie de aas a op bij een bel b. Over de lengte van de rij worden de gewone supermachten uitgedrukt.

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

Op opladen in Buizerd zijn allerlei variaties mogelijk: groot, groter, grootst en toch zo goed als gelijk…

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

Zo produceren de oplaadregels steeds minder natuurlijke output, die ondanks minieme versnellingen ongeveer een supermacht ^ achter blijft bij onze snelstarter Wielewaal. Waar precies de verschillen insignificant worden mag u zelf uitvogelen…!

We zullen Vogel en Bird nu vergelijken binnen een nieuw systeem, vernoemd naar de toverachtige trekvogel uit een zomerse canon.
Met ons Wielewaal telrad dupliceren we getallen en verschuiven ze. Aanvankelijk over een serie parameters of tellers. De lengte van die eerste rij geeft de superexponent ^{r} van de uitkomst ervan. Zo drukken we dezelfde functies en getallen als in de vorige sectie uit.

Telrad algoritmes beginnen met achterstand, omdat het herschrijven van de eerste rij zo eenvoudig is. Zodra we posities voorzien van een kopie (minus 1) van de volgende index array, dan is ons telrad even sterk als het nesten van subexpressies (allebei rij in rij). Maar dat de vele separatoren in de array allemaal worden genest leidt (net als bij meervoudige substiutie) niet tot significant grotere getallen.

Nadat we een vlak hebben gevuld, haalt onze 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.

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 posities van tellers of parameters pi0 geen index krijgen, moeten de komma's ,, voor de lege plek blijven staan.

Onderaan bij Buizerd zien we functies die bellen omhoog blazen. Die noteren vrijwel gelijke getallen als Wielewaal, omdat alleen hun beginregel verschilt. Door superoperatoren ^.. te tellen, krijgen we een glimp van de onvoorstelbare grootte ervan. Toch vordert Vogel functie V.I significant sneller in de top rij.

De Wielewaal functie gaat snel van start door ab (tegelijk aas en bel) te verdubbelen en op te laden. Daarna domineert de macht 2^c de uitkomst sterk. Maar zonder subexpressie nesten blijven we relatief achter lopen in de volgende tellers van de rij.
Klik op de borden <!--> voor uitwerkingen met 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^(c+ab*2^c) ≈> V(abc,2,3) <!-->

Een linker expressie is ongeveer groter ≈> dan de rechter expressie, als dit een vrij goede benadering is en de linker grotere output geeft voor niet te kleine input waarden.
Voor waardes a=b=c=1 in de vergelijking hierboven gaat dat al op, omdat 2^5 > 3^^2 ons over het kantelpunt heen brengt. Hieronder is dat 2^2^6 > 3^^3 minder nauw. Maar hoger in de machtstoren blijft 2^^d\^6 > 3^^d1 die verhouding in stand.

  • 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] ≈> abc^^d1[,,,1] ≈> abcd^^abc^^d1 <!-->

Met drie tellers bouwt Wielewaal een toren van d1 exponenten. Dit vormt na + * ^ de nieuwe operatie ^^ van tetratie.
Missen van een begin a of b maakt op deze schaal vrijwel niets uit.

  • [a,b,c,d] ≈> abc^^..ab^^c1 :d ≈> ab^^^d1\^^c ≈> V(abc,d1,4)
  • [a,,,,1] = a[,,a,a-] ≈> 2^^a1[,,,a-] ≈> 2^^^a\^^a {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)
  • [.pi,..q] :r ≈> pi..^{r}q1 :r > V(pr,q1,r1) > pqr <!-->

Zo drukt dit blazer systeem W.I over de hele eerste rij supermachten uit, waar bij Vogel en Bird drie parameters volstaan.

X

§3.1 Toprij

In dit blog loopt ons Vogel telraam parallel aan de lineaire array van Chris Bird.1 De Toprij is de eerste rij in de top array. In die top rij structuur produceren beide algoritmes maximale getallen.

Omdat Bird's systeem nogal gecompliceerd is, hebben we dit in de appendix U versimpeld en veranderd. Ons Uil systeem voor de lineaire array U.I voegt twee van Bird's dominante regels samen, maar exact dezelfde expressies en getallen blijven geldig.

We willen Bird via systeem U en dan V met W vergelijken. 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 een hele rij voor nodig was.

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 exact Bird's lineaire array, alleen teller c loopt steeds 1 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.


Na omzetting van Bird's lineaire array naar de Vogel toprij, vergelijken we deze met ons Wielewaal systeem zonder subexpressie substitutie.
Weliswaar startten we in §3.0 sterk met verdubbeling, maar daarna viel in Wiel de functie snelheid terug. Het kostte de hele eerste rij om supermachten uit te drukken.
We moeten dus meerdere dimensies inzetten om even grote getallen te maken als de subexpressie nesters doen in de rij dimensie.

Positioneren we tellers met behulp van indexen en itereren daarover in een geneste array. 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 de geneste arrays van Bellenblazer blijft onze verdubbel bel op zijn plaats. Zo garanderen we, dat het getal a wat we substitueren maximaal blijft. Dit is niet triviaal, gezien de nogal bewerkelijke cascade bij het herladen van Bellenblazer's index arrays.

Bellenblazer en zijn Buizerd varianten, die we eind §3.0 zagen, zijn een beetje (insignificant) trager dan Wielewaal. Hun standaard expressies geven de *{c} supermachten, net als de Vogel rij.
Exacte supermachten zijn natuurlijk in dit gebied. Maar voor onze recordpoging wijken we in Wielewaal daarvan af en maken het formuleren van nieuwe regels liever wat makkelijker.

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.
Er is dus geen precedentie door volgorde van de regels, zoals bij Bird. Hier verwerken we de meest linkse match in de expressie het eerst.

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, dat buiten de a[,R] array verzameld is. Waar b=0 leeg staat, want hulpregel W.a. voor verplaatsing ervan l-r zal eerder zijn toegepast.

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.b. 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. Drie Vogel tellers benaderen de rij van Wielewaal W.I, dus eerst moeten we de lineaire array van Vogel V.I nog inhalen. Die nieuwe vergelijkingen werken we hieronder uit.

  • [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 zich het tweede vlak in de derde dimensie. Een overgang naar nieuwe recursies vraagt altijd extra aandacht, maar de evaluatie van de rest van de index array zal voorspelbaar te verlopen.
We tonen de vergelijkingen tot de 3e index en de 5e parameter in Vogel. Deze Wielewaal kubus structuur wijst ons de weg.

  • [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 <!-->

Dubbele recursie die subexpressies nest is in aanvang oppermachtig, maar door de Wielewaal rij te generaliseren naar dimensies komen we gelijk met de hele Vogel rij.
Wielewaal is dan 2 niveau's dieper genest. Eén niveau vanwege het verschil in structuur: unieke indexen versus de herhaling binnen hun array ruimte van Bird. En één niveau door het langzamer startende algoritme: Wiel rij vs. Bird's drietal, Wiel matrix vs. Bird's rij.

Per Wielewaal dimensie [n] komt er een superpijl erbij, die de lengte van de voorgaande {n} opblaast.
Zie de multidimensionale array van het Bellenblazer systeem uit §2.7, waar elke dimensie een nieuwe functie recursie toevoegt. Van de dubbele recursie van Knuth's pijlen, naar de triple recursie over Conway's pijlketen, naar de n-type recursie van superpijlen.

Ook Bellenblazer heeft zo'n langzame start, positioneert met unieke indexen en substitueert subtotalen. Dezelfde methode van hernieuwd opladen is dominant en bij gelijke expressies zal de output ongeveer gelijk zijn aan Wielewaal.
Alle aanvankelijke verschillen worden almaar insignificanter. Ook met de Buizerd matrix na B.I en varianten, die tot 0 aftellen maar verder gelijk blijven, zodat we deze systemen niet verder uit zullen werken.

Daarentegen wordt in de superradix structuur van Aasblazer in §2.4 en de (alleen qua notatie afwijkende) Aasgier matrix na À.I steeds een constante opgeladen: aas a die als radix fungeert.
Met geneste arrays tot a[,[,[,1]1]1] schrijven we dan een getal tot 10^10^10 in decimalen. Astronomisch groot, maar ordes kleiner dan systemen die bellen blazen. En bedenkt u toch hoe weinig van zulke getallen ooit fysiek onder ogen gezien kunnen worden…!

X

§3.2 Maxtrix

Een matrix is een multidimensionale ruimte, met op iedere punt positie een getal. Maxtrix betitelt hier een maximale matrix.
Zo vormt een rij tellers de eerste dimensie. Het sterkste algoritme daar is Bird's lineaire array, die we in §3.1 in de Vogel rij omzetten. Het is de substitutie van de hele expressie (dubbele recursie) in bel b en het opladen van deze groeibellen naar afgetelde iteratoren, wat maximaal grote getallen oplevert.

De grootte van die telraam getallen vergeleken we met de output van ons Wielewaal telrad, in meerdere dimensies:
Supermachten op de 1e rij in Wielewaal met de 3e teller bij Vogel. Meerdere rijen in onze 2e dimensie met Vogel's 4e teller, waarmee Bird de rij van Conway's pijlketens benadert. Etcetera…
Dimensie d in Wielewaal met teller d2 op de eerste rij van Vogel.

In dit blog evenaren we met het vlak en de verdere dimensies in Vogel de multi-dimensionale arrays van Chris Bird.2 De algoritmes van beide systemen evalueren de input matrix tot maximale output. Alleen hogere structuren produceren significant grotere getallen.
Om met de primitief recursieve tellers van Wielewaal net zo grote getallen uit te drukken, gaan we de hyperdimensie in. Die geneste ruimte delen we in met 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 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 door V.2. overgeslagen, zodat Vogel steeds verder uitloopt in de matrix op Bird, hoewel dit verschil insignificant blijft. Vogel's telraam blijft een bruikbare benadering van Bird's arrays U.II geven.
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 begin index tijdelijk 0 worden, zoals dat bij Bird's hoekketens ook gebeurt.

Door regel V.6. toe te passen ,[1]1p op de komma , en daarna de nulde sep ,[0] te elimineren, wordt links bij 1 de b opgeteld.
Die met regel V.5. opgeladen 1b telt gaandeweg af tot 1 zodat er b iteraties plaatsvinden. Op de eerste rij zorgde dit er al voor, dat Vogel precies gelijk bleef lopen met Bird. In de matrix expandeert dit de rechtse dimensie n2 met een lengte van b kleinere dimensies n1.

We zullen de richting := van de evaluatie soms omkeren.
Om meer detail te tonen, klik op de gescripte borden 0'>!< of zoek die verborgen items op in de pagina 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 er 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. Maar met de recursieve substitutie van bellen b als volgende lengtes m domineert oplaad-regel V.5. steeds de voorgaande ,1.. aanwas.

Die dominantie werkt zo voor elke Vogel rij en zal sterker gelden voor dimensies. Vogel's stapsgewijs groeiende ruimtes lijken onnatuurlijk, maar in Bird's systeem is het lastig om geneste arrays [S]1[T] te vergelijken, bij 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 verdere rijen in hogere dimensies met series ,qi.. :r tellers, waarvan de laatste qr dominant is.

Neem voor variabele v de constante a of een ander fysiek schrijfbaar getal, dan wel de gegeven bel b. Het maakt voor de vergelijking weinig uit, de waarde van v is ondergeschikt aan de positie ervan.
Bijvoorbeeld, in het volgende item zal de laatst op te laden v net wat groter zijn dan dezelfde array maar met b in plaats van v en een serie elementen ,[s]1 met vorige lengte :b- en zeker niet langer. Nu mogen we dit enorme getal afronden tot b (vaak ook groot) of b1, zodat we Vogel's expressie met die van Bird kunnen vergelijken.

  • V(a,b,[s1]1,2) = (a,a,[s1]1b) > (v,v.,[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 eerste delen X afgezien van het separator format gelijk zijn := of althans :≈ de belangrijke dimensies in X bij Vogel en Bird even lang zijn. Ook zijn in de hoogste (meest rechtse) rij de 2e en verdere tellers Q van Vogel gelijk aan de 1e en verdere tellers bij Bird.
Op de rij is Vogel's regel V.5. voor opladen dominant. Die komt praktisch overeen met Bird's multi-dimensionale regel 2.5. en daarom rekenen we hun laatste rij deel Q gelijkwaardig.

Vogel's achterstand blijft beperkt tot extra teller m, ingevoegd aan het begin van de hoogste rij. De beste benadering geeft m=1 en daarmee zal de expressie in Vogel soms iets ≈> groter, maar meestal minimaal <≈ kleiner uit te pakken dan Bird's array. Maar voegen we m=2 in op de laatste rij, dan is Vogel's telraam zeker groter.

Altijd compenseren we het opladen van subexpressies $ bij Bird, 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' vaagt Vogel 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' steeds groter worden. Want door regel V.4. bevatten die bellen de rechts geladen b vele malen. Zo groeien lengtes in Vogel eerst met a en daarna meteen voorbij de keten lengte b waarmee Bird alle ruimtes vult. Die accumulatie van lengtes is als optellen, wat in alle dimensies insignificant blijft, ook al maakt dit onderdeel uit van de recursie van de bel.

Als we dus een teller 2, inlassen aan het begin van Vogel's laatste rij, dan is er op de schaal [s] van dimensies geen echt verschil tussen de matrix expressies van even grote getallen in Vogel en Bird.


Met een rij tellers in ons Wielewaal systeem (kortweg Wiel) werden de supermachten bereikt, waarvoor Vogel en Bird slechts drie tellers nodig hadden door dubbele recursie in bel b.
Verder is substitutie van subexpressies bij Bird gelijk aan het opladen van b onder een grotere c1 in Vogel. In ons Wiel geeft dit een extra teller op de eerste rij, met 1 bij de positie index.

Vanaf teller c corresponderen de elementen in Bird's lineaire array met de indexen op het 2e niveau in Wielewaal. Dit vormde de Wielewaal matrix waarmee we Vogel's toprij vatten, in het vorige blog.
De rij lengte teller in Vogel staat dan gelijk aan de 1e index op het 3e niveau in Wielewaal. Naar alle geneste tellers laadt Wiel bel b op. Dat opladen van de bel is maximaal en domineert alle structuren.

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 een 3e niveau [index subarray] onder. Daarin scheiden we indexen hetzij door komma's , hetzij met een 4e niveau [sub sub index].

Klik op de borden <!--> om meerdere variabelen te vergelijken.
Een tilde ~ staat voor de gebruikte 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 algoritme van Wielewaal hier even sterk als dat van Vogel en Bird, alleen de structuur verschilt. Door alle posities apart te indexeren in ons Wiel telrad zijn expressies dubbel genest.
Vogel en Bird herhalen dezelfde separatoren binnen hun array ruimte, zodat er lengte ontstaat. Het aantal vaste separatoren wordt in Wiel verklaard met een index. Alle tellers in Wiel hebben per definitie een index, maar het herhalen van komma's op de eerste rij is optioneel (hier alleen gebruikt 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 multidimensionale en verder geneste arrays {Y} van Bird benaderen.

  • [a1,[,[,,1]1]1] = a1[,[,[a,a]a1]1] (v,v.,[2]1..,[2]a) :aV(v,a,[3]1,2)
  • [a,[,[,[,1]1]1]1] = a[,[,[,{a}1]1]1] V(v,a-,[a1]1,2) {a,a[a1]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.
Binnen dimensies corresponderen al die ongeschreven posities met de rij 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

In Wiel W.II werken geneste arrays nog simpeler dan Vogel. Om te testen of ons Wielewaal algoritme inderdaad het simpelst is, zetten we een experiment op met eerste posities.
De aasbel a, die we zowel binnen als buiten de top array noteerden, vormt in wezen een geheel. Deze kan dus zonder 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 [aa,[1]X] en de bel verdubbelt.

In de box geven we een radix systeem, dat lijkt op Wielewaal, met als enige verschil dat die separator ,[1] na een inerte komma ,b komt. Dan zal de aas die we opladen een constante zijn [a,ba,[1]X] en de volgende teller, de bel, verzamelt alleen de som.
Ook in alle geneste superradix arrays 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 kan beter meteen links staan, want we lezen van links naar rechts. Ons nieuwe idee is om alle volgende structuren consequent l-r van klein naar groot te ordenen.
In arrays komen iteratoren en rijen meer rechts te staan, als deze ook dominanter uitwerken in het systeem. Een decimaal getal zouden we dus liever andersom schrijven. Ook oneindige series a.. kunnen we van rechts bijtellen (Cantor omgekeerd).

Aalscholver is net als Aasgier een superradix van het Aasblazer type. Maar we zetten de oude teller van het aantal, die minder significant is, links aan het begin van zijn index array.
De aparte positie van tellers {Bird's [separator] entry} komt zo te vervallen. Het hele element wordt (in een rij) omvat. We nesten nu louter rijen in rijen.
Anders gesteld, we breiden getallen binnen dit systeem uit tot arrays. De separator staat zo bezien los van zijn positie index en kan (buiten radix verband) op meerdere plaatsen voorkomen.
Op de eerste rij lezen we deze index nog impliciet in de lengte van de voorafgaande reeks 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 ons telwiel 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

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 telwiel W is dan makkelijk, maar begint chaotisch door af te wijken van normaal herhalen a*b.
Verschillende concepten zijn op wonderlijke wijze uitwisselbaar…!

X

§3.4 Diepen

Blog 3.4

Denkwerk

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 ruimte regels voor het opruimen van afgetelde elementen een stuk simpeler. Wij verwijderen het lagere element uit [S]1`[T] door het begin en einde van zijn `dimensie` van te voren 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.2. {a,1,c} = a
  • 0.3a. {a,1} = a 0.3b. {a,b,1} = {a,b}
  • 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 array.1

  • 0.0. 0.1.
  • 1.2. {a,1,X} = a
  • 1.3. {Y,1} = {Y}
  • 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 array.2

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

Pas deze regels in volgorde toe. Dan kan geval b=1 regel 2.3b nooit bereiken. En regel 2.4 in de vorm 1.4 komt voor regel 2.5, zodat k>0 daar al zeker is gesteld.
Geef in {Y,1} de laatste komma de vorm [1] die onder regel 2.3a valt. Door precedentie van regel 2.3c staat de volgorde nini+1 van dimensie indexen in de expressie 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 ze tot a te reduceren, omdat hij regels 2.2 en 2.3 heeft verwisseld.
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.3a weer 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.2. {a,1[S]Z} = a
  • 3.3a. [S]1} ≡ } 3.3b. ,1[S][S] {S>1} 3.3c.0. {a,b` ≡ {a,b 3.3c.1. [S]1` ≡ ` 3.3c.2. `p` ≡ p {p>0} 3.3c.3. [p`[p 3.3d. [S]1]]
  • 3.5. {a,b.[Ti]1..,1Z} :k = {.€Ti..$,Z} :k
  • 3.6. {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 regels met een sep array [S] geldt vanzelf dat {S>0} zodat deze ook een [1] komma , zou kunnen zijn.

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

  • 3.€ a. €1a, 3.€ b. €T ≡ {a[T]b}[T]
  • 3.€ 0a. {` ≡ { 3.€ 0b. [`[
  • 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
  • 3.€ 4a. {a[.,1..R]b} :n {a[.b,..R]b} :n

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.£ a. £1b, 3.£ b. £T {b[T]b}[T]
  • 3.£ 4. {a[.[Ti]1..X]b} :n ≡ {a[.£Ti..X]b} :n

Voor opruimen van tellers ,1 gebruiken we regel 2.3b weer. 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 vlak) in bank regel 3.€.2 met accent ` merken.

Stel dat een woord ruimte merken ` bevat, dan komen die net eender terug in de kopie ervan. Zo ook bij mogelijke series `.. die ongeteld als staan aangegeven, waar niet-nul series na evaluatie elk op hun plek terugkeren, rechts buiten hun sep array. De afkorting sluit een onbestemd aantal ruimtes uit (want input kan soms zonder).

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.3c.1 elimineert afgetelde elementen aan het einde van hun reeks. Als de evaluatie trein aankomt aan het begin ervan, dan heft regel 3.3c.2 deze ruimte voorlopig op.
Maar rijen, onze initiële ruimtes, lijken moeilijk op natuurlijke wijze binnen hun vlak 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