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. Diepen

In het vorige hoofdstuk §2 ontwikkelden we een plan voor het maken van grote getallen. De komende serie blogs bouwen we weer van de grond af op, tot we uitkomen bij de diepen, die voorbij geneste arrays liggen, in Giga Gerard's:
„Reuzen Getallen Bouwerij”.

Aan elkaar gebouwde arrays [Xi].. noemen we diepen. Iedere geneste array kan uitgebreid worden tot een diep.
Nadat een index array [][1Xn] is afgeteld, blazen we met de eerste index 1 van het volgende diep het aantal niveau's met diepen in de eerdere array recursief op.
Diepen na de top array geven een ander type indexen aan, met name voor groter eindige ψi limieten of hoger oneindige ωi.

Ons Vogel systeem is een simpele benadering van de array notaties van Chris Bird.0
Als we dit Vogel telraam gelijk op laten gaan met Bird en vergelijken met ons Wielewaal telrad, dan zal er uiteindelijk onvermijdelijk een nieuw wereldrecord voorbij komen vliegen.

Al zulke arrays geven als uitkomst reusachtig grote getallen. Wat wij groot noemen, is als de complete evaluatie van array expressies alleen in theorie, maar praktisch en fysisch niet uitvoerbaar is.

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, die maar één stap b- minder bevat.

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.


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.1. a[1R] = a1[R]
  • W.2. a[R,] = a[R]
  • W.3. 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 Beo laten we andere functies zien die bellen omhoog blazen. Deze telramen lezen vrijwel gelijke getallen uit, want alleen hun beginregel verschilt. Het aantal super ^.. operatoren toont wel een glimp van de onvoorstelbare grootte ervan, maar Vogel functie V.I vordert significant sneller op 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.

  • [b,c,d,e] ≈> bcd^^..bc^^d1 :e ≈> bc^^^e1\^^d ≈> V(bcd,e1,4)
  • a[,,,,1] = a[,,a,a-] ≈> 2^^a1[,,,a-] ≈> 2^^^a\^^a {a>1} ≈> V(a,a,4)
  • [b,c,d,e,f] ≈> bcd^^^^f1\^^^e ≈> V(bcde,f1,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.


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 onze Aasblazer en wat betreft het formaat, dat tellers in eerst geneste rijen kan inbedden in komma's.

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

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

Aas a is een constante: een radix 10 naar keuze.
Om dit als superradix te laten werken, moeten ook alle lengtes en tellers p<a zijn, tenminste in de input. Daarmee krijgen alle natuurlijke getallen een unieke expressie.
Het radix maximum is op de rij a[,{a}1]- en in basis a=10 het getal 9999999999.

Bij deze lineaire array met komma's is regel A.1. een speciaal geval {n=0} van regel A.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 Beo rij functie B.I met komma's.

Op opladen in Beo 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…!

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 vorig blog §3.0 bestreek de eerste drie parameters: het supertrio van U.O > V.O met de supermachten a^{c}b versus a*{c}b, waar Wielewaal W.I een hele rij voor nodig had.

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 de functie snelheid terug. Het kostte ons de hele eerste rij om alle 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 Beo 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.

Definitie Wielewaal nest functie W.II.

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

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.

Bij regel W.4. staat variabele a voor het actuele subtotaal, dat buiten de a[,R] array verzameld is. Waar b=0 leeg staat, omdat de regel W.1. voor verplaatsing ervan l-r eerder zal zijn toegepast.

Twee hulpregels om de eerste rij van een array van lineaire formaat te vertalen naar complete indexering en := andersom.

  • W.a. [,{n}1[,[n]1
  • W.b. ,[m]1p,{n}1 ,[m]1p,[mn]1

Aan het begin van array [p,T] voegt de eerste hulpregel = een nul separator [,[0]p,T] in, zodat de tweede hulpregel = de komma [,[]p,[1]T] bereikt, waarna we met regel W.3. de eerste stap terugnemen := 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 Beo 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 A.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 toch, bedenk 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 corresponderen met het 3e niveau in Wielewaal. Vogel rij lengte met de teller aan het 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. En die indexen nesten we op het 4e niveau in Wiel.

  • [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 zelf geven we aan met ,.. :s komma's of door index [s] 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… …

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 overbodige vervallen. Onze lijst volgorde (die bepaalt welke regel we toepassen op de expressie) is anders dan bij 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 door bank regels die dit hoek bank stel reduceren.

Bird's subsysteem om de grootte van separator arrays te vergelijken wordt al gauw erg lastig. Gelukkig is in de evaluatie alleen van belang om te weten waar hun ruimte is begrensd.
Vanaf geneste arrays merken we bij een `reeks elementen` het begin en het einde. Zo zijn er maar twee ruim regels nodig om tussendoor de afgetelde elementen te elimineren.

Supermacht functie U.O met 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 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 eerdere 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]

Onze afkortingen €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.

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.

Met deze bank regels vervangen we 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

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 systeem onder een hogere recursie buiten spel staan, worden bij Bird dus 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.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 sep arrays [S] geldt vanzelf dat {S>0} en deze ook gewoon een [1] komma , kunnen zijn.

We gaan separator arrays qua grootte verder niet vergelijken in Uil. Het is alleen van belang te weten waar een reeks elementen ophoudt en waar die begint. Die grenzen van meer-dimensionale ruimtes merken we met ` accenten in bank regel 3.€.2.
Dan kan opruimregel 3.3c.1 de afgetelde elementen aan het einde van zo'n reeks vinden om ze te elimineren. Tot het begin ervan is bereikt en regel 3.3c.2 die ruimte voorlopig opheft.
Rijen, onze initiële ruimtes, lijken moeilijk op een natuurlijke wijze te markeren binnen hun vlak… We verlaten ons op regel 3.3b voor het opruimen ervan.

Als een woord ruimte markeringen ` bevat, dan komen die net eender terug in de kopie ervan. Zo ook bij de regels, waar iedere mogelijke serie `.. ongeteld als is aangegeven, en we niet-lege series na evaluatie ieder op hun plek terugzien: links binnen de index array of rechts erbuiten.
Deze afkorting, die een onbestemd aantal ruimtes opent en zou kunnen markeren (want input kan soms zonder), maakt onze notatie helaas wat complexer.

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

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

Wij verwijderen afgetelde elementen [S]1`[T] door hun ruimte van te voren te merken. Bird doet hetzelfde door sep arrays [S]<[T] te ordenen. Maar eliminatie in tussenruimtes is een luxe regel.
Ons Vogel telraam laat zulke elementen met teller 1 gewoon staan. Het cumulatieve effect daarvan op de uitkomst is insignificant.

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.

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

Blogboek  index

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

© 2018
Giga Gerard