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.
Als een index array is uitgeteld [][1Xn] en in de volgende array tellen we de eerste index af, dan blazen we daarmee het aantal niveau's met diepen in de eerdere array recursief op.
Met diepen na de top array geven we een ander type indexen aan, met name voor groter eindige ψi limieten of hoger oneindige ωi.

Vogel arrays vormen onze simplistische benadering van de arrays van Chris Bird.0 Doordat dit Vogel systeem gelijk op gaat met Bird, en ons Wielewaal telraam te vergelijken is met Vogels, kunnen we uiteindelijk een elegant wereldrecord getal voorbij zien vliegen.
Al zulke arrays geven als uitkomst reusachtig grote getallen. Zo groot, dat de complete evaluatie van expressies alleen in theorie, maar in de praktijk niet uitvoerbaar is.

Lectori salutem Dudeldjo en anders niet.

X

§3.0 Supertrio

Dit blog introduceert een telraam of array systeem, dat een groeiende variabele a substitueert in de structuur van de radix Aasblazer.
We spreken hier van een telraam als we alleen getallen kopiëren en verschuiven. Voorbij de rij structuur kopiëren we indexen om posities aan te geven en die groeien uit tot geneste arrays en diepen.
Ook tellen we iteraties tot 0 stappen af, zodat tellers of iteratoren leeg komen te staan ,, tussen aangrenzende separatoren (komma's of index arrays).

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 telraam 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 natuurlijke getallen v>0, dus in Vogel expressies tellen we posities nooit leeg. Het is deze voorwaarde, die duidelijk maakt welke regel(s) van toepassing (kunnen) zijn.

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 {X} 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.
In ons Wielewaal telraam 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.

Ons telraam begint wat langzamer, omdat de herschrijf methode voor rijen zo eenvoudig is. Hogerop voorzien we posities van een kopie (minus 1) van de volgende index array. Dat is even sterk als het nesten van subexpressies (allebei rij in rij), maar dan overal tegelijk.
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 systeem parallel aan de lineaire array van Chris Bird.1 De Toprij is hier de eerste rij in de top array. Met 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 ons Wielewaal W.I systeem 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,..1R) :k1 = (a,a,1.,1..b,R) :k0 == (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 die met ons primitieve telraam zonder subexpressie substitutie: de Wielewaal.
Weliswaar startten we in §3.0 sterk met verdubbeling, maar daarna viel de functie snelheid terug. Het kostte de hele Wielewaal 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 onze telraam rij te generaliseren naar Wielewaal 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 Bird's herhaling binnen hun array ruimte. En één niveau door het langzamer startende algoritme: Wiel rij vs. Bird drietal, Wiel matrix vs. Bird rij.

Per Wiel 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) en het opladen ervan naar afgetelde iteratoren, wat maximaal grote getallen oplevert.

De grootte van die getallen is te vergelijken met de output van ons Wielewaal telraam 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 een hogere structuur kan significant grotere getallen produceren.
Om met de primitief recursieve tellers van Wielewaal net zo grote getallen uit te drukken, moeten 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.
Bird's systeem lijkt krachtiger, maar door aan het begin van de meest rechtse rij een enkele teller 1, in te voegen, doen Vogel expressies nooit voor Bird onder, zal nog blijken.

Vogel matrix definitie V.II.

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

Elimineren we de ,[0] initiële separator, dan volgt regel V.5b. uit regel V.6. waar ,[1] de enkele komma ,1p is. De opgeladen bel b neemt door verval van 1,[0]b toe tot de teller 1b. En deze telt af tot 1, zodat er b iteraties plaatsvinden over de teller ervoor.

In de rij zorgt dit ervoor dat Vogel gelijk loopt met Bird, maar omdat we geen afgetelde elementen opruimen, zal Vogel in de matrix steeds wat verder voor komen op Bird, hoewel dit verschil insignificant blijft. Vogel blijft een bruikbare benadering van Bird's arrays geven.

We keren := de richting van de evaluatie soms om.
Klik op de gescripte borden 0'>!< om meer detail te tonen of zoek die verborgen items op in de pagina bron.

  • V(a,b,[2]2) = (a,a,b,[2]1) = (a,a,b) = (a,b-,1,2)
  • (a,a1.,1..,[2]2) :k = (a,a.,1..,1a) :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,..a..) :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,b,1,[2]2) ≈> (a-,a,b,1,1,2) ≈> (a-,b,1,2,1,2)
  • (a,b,c,2,[2]2) ≈> (a-,b,c,2,1,2)
  • (a,b,c,d,[2]2) ≈> (a-,b,c,d,1,2)
  • (a.,pi..,[2]2) :k>0 ≈> (a-.,pi..,1,2) :k > {a,k+2[2]2} {pa} 0'>!<

Staat er in Vogel ,[2]2 na de eerste rij, dan is dat op 1 na 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..1 afgeteld. We voegen in het eerste geval een extra teller ,[1]b toe, maar in de rij vervangt ,1b de op te laden teller.

Ook werkt lengte teller ,[2]1m over de eerste rij ongeveer zo 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(a,a.,1..,[2]3) :k0 ≈> (a-,a.,1..,a,1,2) :k ≈> (a-,a-.,1..,2,2) :k1 > {a,k+4[2]2}
  • (a,b1,2,[2]3) == (a,..a..,1,[2]3) :b: == (a,a,1,..a..,[2]2) :b: ≈> (a-,a,1,..a..,1,2) :b: ≈> (a-,b1,2,1,2,2)
  • (a,b1,3,[2]3) == (a,..a..,2,[2]3) :b: ≈> (a-,..a..,2,1,2,2) :b: ≈> (a-,b1,3,1,2,2)
  • (a,b1,c1,[2]3) == (a,..a..,c,[2]3) :b: ≈> (a-,b1,c1,1,2,2)
  • (a,b1,2,1,[2]3) == (a,..a..,1,1,[2]3) :b: ≈> (a-,a,1,1,..a..,1,2) :b: ≈> (a-,b1,2,1,1,2,2)
  • (a,b,c,d,[2]3) ≈> (a-,b,c,d,1,2,2)
  • (a1,b,P,[2]3) ≈> (a,b,P,1,2,2)
  • (a,b.,1..,[2]4) :k0 ≈> (a-,a.,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..,1,2,2) :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,[2]1m) = (a,a,b,[2]m) ≈> (a-,a,b,1.,2..) :m- ≈> (a-,b-,1.,2..) :m
  • (a,b1.,1..,[2]1m) :k0 = (a,a.,1..,b1,[2]m) :k ≈> (a-,b.,1..,2..) :k1 :m
  • (a1,b.,pi..,[2]1m) :k>0 ≈> (a,b,P,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 van een rij en R voor een hele rij. De waarde van parameters pi1 in rij deel P is 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 hogere tel. Dat spaart op elk schakelpunt tussen dimensies onze 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,b1,3,[2]1,2) == (a,..a..,2,[2]1,2) :b: ≈> {a+3,b+1,3[2]2}
  • (a,b,c,[2]1,2) ≈> {a+3,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,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}
  • (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,a1,..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'>!<

Matrixregel V.6. bouwt de rijen van tellers stap voor stap op. In Vogel blijven de lege elementen ,1 tussenin staan, omdat opruimregel V.2. deze niet verwijdert. Maar met de recursieve substitutie van bellen b in plaats van lengte tellers m domineert oplaadregel V.5. steeds de bestaande ,1.. aanwas.

Dat werkt zo in het kleinste geval op de tweede Vogel rij en zal nog sterker gelden voor latere dimensies. Vogel's stapsgewijs groeiende ruimtes lijken wat onnatuurlijk, maar in Bird's systeem is het lastig om geneste arrays [X]1[Y] te vergelijken voor zijn regel die afgetelde tussenposities opruimt.

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

Verlengen we ook de andere rijen met series ,qi.. :r tellers, waar de laatste qr dominant is.
Op de schaal van dimensies [s] verschillen de matrix expressies van getallen in Vogel en Bird niet significant.

  • (X,[s]m,Q) :≈> {X[s]Q}
  • Q = n.,qi.. :r

Ga ervan uit dat de voorgaande gedeeltes X kloppen, of althans de belangrijke dimensie lengtes in X gelijk zijn. Dan komen in de hoogste (meest rechtse) rij Vogel's 2e en verdere tellers Q overeen met de 1e en verdere tellers in Bird's hoogste rij.
Vogel's achterstand blijft beperkt tot één extra teller m, ingevoegd vooraan op de hoogste rij. De beste benadering geeft m=1, zodat de Vogel expressie meestal minimaal kleiner <≈ uitpakt dan : dezelfde expressie bij Bird. Voegen we m=2 in op de laatste rij, dan is onze array benadering altijd ≈> iets groter.
Na evaluatie en aftellen van n laden we de resulterende bel weer op naar lengte teller m. Elke volgende iteratie van een naar m opgeladen bel vaagt de ervoor opgebouwde rij lengte volledig weg. Die rij op zijn beurt draagt over en zo expanderen we alle voorgaande dimensies.

Na het openen van 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 is hun laatste rij deel Q hier gelijk.
Zo nodig compenseren we het opladen van subexpressies $ bij Bird, door bij de derde teller c in Vogel 1 op te tellen. Andere substituties van Bird, zoals a in eerdere tellers op rij en zijn ketens €n in vorige dimensies zijn nog minder significant.
Ga maar na, hoe de latere bellen b' in onze arrays steeds groter worden. Door regel V.4. bevatten die getallen tenminste de rechts geladen bel. Zo groeit elke lengte eerst met a en ten tweede voorbij Bird's lengte en dat kost Vogel hooguit die m=2 teller.


We zullen expressies in Wielewaal nu uitwerken tot op het derde array niveau, volgens de regels voor geneste arrays W.II.
Het 1e niveau of de [top array] begint met verdubbeling, gevolgd door een rij iteraties. Daarin tellen we de posities met een 2e niveau index, ook weer gevolgd door een rij iteraties, de [index array]. Op dezelfde wijze ligt hier een 3e niveau [index subarray] onder, waarin iteraties gescheiden zijn door komma's , of een 4e niveau [sub sub index].

Klik op de <!--> borden voor expressies met meerdere variabelen. Hier staat een tilde ~ voor de gebruikte benadering: de volgende expressie ≈> minimaal groter dan, in de onderhavige array vorm.
Variabele v is een normaal schrijfbaar niet te groot getal.

  • [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,..2) :a > V(v,v,[2]1,[2]a-) <!-->

Om slagkrachtig voorwaarts te stomen kunnen we de ≈> ordening achterwege laten. Hogere structuren worden zo dominant, dat het precies passend maken van elke teller er weinig toe doet. Vanaf nu lopen de uitkomsten van Wielewaal [W] ongeveer gelijk (iets groter of kleiner) met de Vogel matrix V(X) die dan weer Bird's multi-dimensionale array {Y} benadert.

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

Wezenlijk is het algoritme van Wielewaal even sterk als dat van Vogel en Bird, alleen de structuur is anders.
Alle tellers in Wielewaal hebben per definitie een lineaire index (met optioneel in de binnenste array het herhalen van komma's). Waar Vogel altijd separatoren herhaalt binnen een array dimensie, zodat we lengte zien, correspondeert dit in Wielewaal met een geneste index.

Supermachten werden bereikt over de Wielewaal rij, wat de primitieve recursie van subexpressies in b vervangt. De subexpressie substitutie naar rechts bij Bird staat gelijk aan het opladen van bel b onder een grotere c1 in Vogel. Vertaald naar Wielewaal vraagt dit om een extra teller op de eerste rij, maar die stond al aan het begin.

De rest van de elementen in Bird's lineaire array corresponderen met de indexen op het 2e niveau in Wielewaal, die met de rij lengte teller begint. Naar al deze geneste tellers laden we bel b immers ook op. En de oplaadregel is maximaal en dus dominant in beide systemen. Dit vormde de Wielewaal matrix waarmee we de Vogel toprij vatten, in het vorige blog.

Nu blijkt dat de matrix lengtes van Bird en Vogel corresponderen met het 3e array niveau in Wielewaal. Rij lengte met de teller aan het array begin (zonder index), de rijen in het vlak met de teller op positie 1, het aantal vlakken met de teller met positie index 2, enzovoort.
Algemeen is de lengte r van rechts gestapelde Vogel dimensies gelijk aan een teller r op het 3e array niveau in Wielewaal.

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

Een Vogel dimensie s1 kan worden gegeven met het aantal komma's in Wielewaal op het 3e niveau, als dat onze binnenste array is. Of hier lezen we die dimensie af uit indexen s op ons 4e niveau. Daarbij neemt de waarde si1>si van de posities van links naar rechts toe. Opeenvolging si1=si1 komt vaker voor, maar is niet verplicht.

De corresponderende reeks elementen ,[si1]1.. in Vogel geven we verticaal weer. Elke lengte reeks bestaat uit gelijke separatoren, want hun meta-index i keert in de horizontale rep :ri terug, tijdens de verticale herhaling van onder naar boven (de rechtse rep van reps). In die expressies lopen Vogel dimensies dus van groot naar klein af.

We voegen witruimte en reps en variabelen toe om deze systemen begrijpelijk te houden. Maar iedere expressie is een string, bestaande uit units 1, separator tekens en haakjes, die door de regels l-r tot grote getallen 1.. wordt herleid.
Dieper geneste tellers geven nog grotere getallen, zoals Bird noteerde in zijn hyper-dimensie. Meer daarover in het volgende blog.

Bird's Universum

In deze array systemen genoteerde getallen zijn dezelfde als die van Chris Bird, totdat zijn subsysteem voor de rangorde van separatoren ons te lastig wordt. Vanaf geneste arrays maken we de evaluatie wat simpeler en zijn orde van grootte regels optioneel.
Onze definities krijgen de letter U van Uil en een Romeins nummer. De nummering van de regels daarin is anders dan in Bird's systeem (zie de zijne met uw muis erover).

Machten zijn de opmaat voor de supermacht functie U.O, uitgedrukt met drie tellers (constante, machten en supers) in Bird's array rij.

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

Bird's lineaire array functie U.I voor de hele eerste rij. Met links naar regels die hetzelfde geschreven blijven.

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

De subexpressie $- wordt in een volgende stap gegeven door in de eerdere expressie $ van bel b1 de 1 af te trekken (telt unit - op).
De komma , is de separator tussen tellers in een rij.

  • 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. Zo wordt elke array dimensie n1 gevuld met series van lengte b van steeds kleinere ruimtes n, totdat we in rijen de tellers a uitrollen met komma's (van dimensie 0) ertussen.

Bird's multi-dimensionale array functie U.II.

  • 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 de regels in volgorde toe, zodat geval b=1 nooit met regels 2.3. wordt opgelost. Via komma omzetting valt array {a,b,1} onder de regel 2.3a. waar m=1.
Door Bird's originele regel 2.3c. is de volgorde nini+1 van dimensie separatoren in de expressie verzekerd. De versimpelde vergelijking in regel 2.3b. ruimt alleen de komma's van links op, maar dit zorgt er wel voor dat de laatste twee regels kloppen in het Uil systeem.
Regel 2.4. als 1.4. komt voor regel 2.5. zodat k>0 al zeker is.

Bird laat arrays zonder bel {a[n]Z} ongebruikt. Hij is verplicht deze tot a te reduceren, omdat zijn regels 2.2. en 2.3. verwisseld zijn.
Wij vervangen Bird's hoekketens met die dummy arrays. Het eerste beste bankstel vult zijn array ruimtes stapsgewijs op.

  • 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 unaire tellers zijn t>0 gevuld. En bij Bird doen deze onder de lopende recursie actief mee. Elementen die in ons Uil systeem (en bij Vogel) onder een hogere recursie voorlopig buiten spel staan, worden bij Bird met teller 1 en separator het veld uitgestuurd.

Bird's hyper-dimensionale functie U.III heeft dezelfde hoofdregels als zijn geneste arrays.

  • 0.0. 0.1. 1.4. 2.€ 1.
  • 3.2. {a,1[S]Z} = a
  • 3.3a. [S]1} ≡ } 3.3b. ,1[T][T] {T>1} 3.3c. [S]1[T][T] {S<T} 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

Weer passen we dummy arrays toe als hoekketens. Onder de hyper-hoekketens liggen de geneste niveau's, waarvoor geldt dat a=b.

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

Bij geneste hoekketens verdiept die laatste regel zich. Matchen van een variabele is altijd gretig, zodat er na b in de expressie geen getal teken volgt. We passen deze regels voortijdig toe bij b, of later als er b} staat en dit geboden is. Tellers staan bij Bird nooit 0 leeg, daarom beginnen de woorden R en X met een getal.

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

Ordening [S]<[T] van hyper-separatoren bij Bird, zoals deze uit conforme expressies door evaluatie gevormd zijn.

  • S := si,..1 :p T := ti,..1 :q
  • als p<q of als si<ti en sj>i=tj dan S<T

Bird's ordening helpt om de in [S]1[T] afgetelde elementen te verwijderen. Maar dat is niet noodzakelijk. Ons Vogel systeem laat kleinere elementen gewoon staan. Het cumulatieve effect van het weglaten van regel 3.3c. op de uitkomst blijkt insignificant.
Als we de afgetelde ,1[T] opruimen van links, blijven alle regels eenduidig functioneren. Voor een complete ordening van geneste separatoren verwijzen we naar Bird. Dit derde algoritme wordt zo ingewikkeld, dat we er in Uil verder vanaf zien.

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