Wednesday, 26 September 2018

Vernest

§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…!

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.

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]

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

Wednesday, 20 June 2018

Maxtrix

§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…!

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.

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.

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