Vernest

Link naar dit blog:
allergrootste.blogspot.nl/2018/09/vernest.html
edit jan.2019.

§3.3 Vernest

Bird's hyper-dimensionale arrays³ zijn functies, waar de separator index is uitgebreid tot een rij. Qua structuur ligt in elk element van de top rij dan een index rij besloten. De lengtes van reeksen tellers met dezelfde separatoren geven de maten van Bird's array ruimtes.
Het Vogel telraam om Bird mee te vergelijken heeft ook zo'n rijen in rij structuur. En herhaalde seps geven een maximaal aantal teller posities in het raam erboven. Deze systemen tellen getallen gekoppeld aan een index structuur af, om voorgaande structuren te expanderen.

Qua algoritme levert Bird maximale output: door functie substitutie in de bel, het opladen van lege tellers en indexen met (een expressie met) die bel, en de herhaling van separatoren.
Maar de dominante regel is het opladen met de bel. In Vogel is dit direkt de variabele b en Bird verpakt zijn b- binnen een minimaal kleinere expressie $, wat niet significant groter uitpakt.
Met de dimensie index is de expressie op het 2e niveau genest. Dit niveau breiden we uit tot een rij indexen voor de hyperdimensionale array. Daarin kunnen we weer diepere indexen en rijen nesten. Maar we slaan de aparte definitie voor het hyper niveau in Vogel over.

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

Maar geneste structuren werken ook andersom:
• Bird⁰ telt het level van separator arrays: vanaf index [m] met level 0 die dimensies m scheidt, lineaire separatoren als level 1 tussen hyper-ruimtes. Enzovoort, zodat de grootste level n separator ergens in de top array {Y} zal worden genest.
• Een macht b in een dubbele recursie V.O bereikt bij waarde b=1 de bodem (a,..a..,c) in de subexpressie trein.
• Bij sets is de element relatie ∈ fundamenteel en tellen we van de diepste subset naar de buitenste set de is in relaties. Zo worden ordinale sets opgebouwd, die natuurlijke getallen representeren. Dit is axiomatisch bij oneindige limieten ω, zie §1.4 ev.
• Onze superradix structuur in §2.4 noteert in de diepste array de getallen m, machten m^m met de array laag erboven, en stapelt laag op laag een toren van m^(m^^n) machten, die tetratie m^^n1 is.

Bij geneste arrays zijn rijen indexen arbitrair diep in andere rijen genest.⁴ Zulke grote getallen noemen we vernest, als hun array niveau ver genest is.

Vogel nesten definitie V.III.

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

Pas deze regels ten eerste l-r toe in de expressie, op een match die het eerst links begint. En >> ten tweede (bij twijfel) in de volgorde van de definitie.
Zo matcht de laatste regel l-r het element ,[1n,T]2p en bij lengte index 1 (als n=0) komt het nieuwe element ,[,T]b ervoor. Als die index array [,[1n]2R] is, dan bouwen we == daarin van n rechts naar links 1 de index rij a.,[i]a-.. met :n hyper-indexen. Noem dit element ,[a,S]b en bouw daarmee een reeks ,[j,S]a af tot het element ,[1,S]a is bereikt.
Vervolgens bouwen elementen

Maar hoe komt bel b, als regel V.6. deze na het opladen van teller of index vervangt door a, ooit in dieper geneste arrays terecht?
In de Bellenblazer definitie was deze lege index een echt probleem. We losten dit op, door seps vanuit hun tellers op te laden, zodat de originele bel b de array niveau's als in een cascade afdaalt.
Ook Bird vervangt in zijn subsysteem voor geneste hoekketens uit voorzorg alle ruimtelijke waarden door b, lengtes zowel als indexen. Zo garandeert hij meteen de maximaliteit van alle structuren.

In Vogel wachten we rustig af. Hoe groot de opgeladen bel b ook is, de bel b' die erna op die plek komt, zal navenant groter zijn. Omdat regel V.4. de hele $ expressie inclusief de verre b- recursief nest.
In het voorbeeld kost de latere index array [,[n]b',[1n]R] de tel van 1R. Schreven we daarin de oude bel ,[n]b dan kostte dit minder dan die index tel. Dit is dus het kleine verschil tussen een permanente bel (een kopie van b opladen) of het vervangen van de verschoven b door (een kopie van) a in Vogel.

Dit verschil geldt onder het top niveau in alle subarrays. Want elke (geneste) index komt leeg, net op het moment dat bel b naar de teller (of index) erboven is opgeladen door regel V.6. en wordt vervolgens zelf opgeladen met a, wat een tel kost van de volgende index.
We hoeven evenwel niet alle hyper-indexen 1 extra te geven. Alleen de dominante index is genoeg, bij de teller p van het diepst geneste ,[1n]2p element met >> de grootste en >> rechtste n subindex. Noteren we daar 1 bij en evalueren we die, dan expanderen links van ,[n]a-- in de expressie alle tellers, met belgrote getallen.

Is het niet elegant om standaard met bel a te beginnen na opladen? Vogel 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.
Klik op dit bord voor meer detail op het hyper-dimensionale niveau.

• V(a,b,[1,2]2) = (a,a,[,2]b) = (a,a,[a]b) ≈ {a,b[a]2}
• (a,a,[1,2]1b) = (a,a,[a]a,[1,2]b) ≈ {a,b,2[a]2}
• Rekenwerk in uitvoering
• (a,a,[1,2]1b,c) ≈ {a,b,c+1[a]2}
• (a,b,[2,2]2) = (a,a,[1,2]b,[2,2]1) ≈ {a,a,{a,a,b[a]2}[a]2} ≈ {a,b,1,2[a]2} ≈ {a,{a,a-1,a[a]2}-1,{a,a-1,a[a]2}[a]2}
• (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,1+Z}
• (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]1+Z}
• (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.,[X_i..,[n]1,Y..]Z_i.) ≈ {a,B.[X_i..[n]Y..]Z_i.}
• :k_max: & Y=p₀.,p_j.. :r≥0

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

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

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

# Superradix 3.3

De basis waar een getal aangroeit komt meteen links, want we lezen van links naar rechts. Ons nieuwe idee is om structuren consequent l-r van klein naar groot te ordenen.
In zulke systemen staan dominantere variabelen meer naar rechts. Dominant is wat bij gelijke waarden groter uitwerkt.
Oneindiger series a.. tellen we nω van rechts bij (keert Cantor om). En eigenlijk zouden we decimale getallen liever andersom schrijven.

Aalscholver is net als Aasgier een superradix van het Aasblazer type. Maar hier zetten we de teller van het aantal, die minder significant is, links aan het begin van zijn index array, voor de machten.
De aparte status van iterator over index {Bird's [separator] entry} komt zodoende te vervallen. Het hele element wordt (in een rij) omvat. We nesten louter rijen in rijen.

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

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

Door radix expressies l-r te reduceren met `= blijven verdere tellers c beperkt tot cijfers van 0 tot en met a. Zou de laatste regel met ≡ overal gelden, dan is het output getal weliswaar gelijk, maar kunnen tellers c groter dan radix a worden tijdens de evaluatie.

Druk de lineaire array uit met nesten en als vaste rij. Bereken die met de + * ^ operaties en een index i die telt van 1 tot en met k.

(a,b.,(ci,i)..) :k =
  (a,b.,ci..) :k =
    b.+ci*a^i.. :k

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

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

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

• Á.0. (a,b) ≡ (b) = b
• Á.1. ,(,S) ≡ 0
• Á.2. ,(p,) ≡ p
• Á.3. (a, ,(1n,1S) `= ,(a,S),(n,1S)

Vanouds elimineert regel 1 de afgetelde elementen en regel 2 de lege array die ba optelt. Nul indexen (p,0, slaan we over tot regel 3 een subarray (p,,(a,) introduceert, die tot (p,a reduceert. Later in de evaluatie, links van ,(n,1, in de ouder rij keert ,(a,, terug en is de cyclus rond. Daarin hebben alleen tellers p=a een nul index.

Elke diepste rij zouden we ,(c.,di..) met komma separatoren kunnen noteren. En met alleen cijfers van 0 tot a- is in een l-r radix expressie +(c,.di..) :k alleen de eerste sep nodig. Dat wordt in exponentiële notatie cE..di met k: decimalen di andersom.

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

• ,(c,d₀.,(d_i,S_i)..) :k
• = c*a^(a,d₀. ,(d_i,S_i)..) :k
• = c*a^(d₀.+ d_i*a^(a,S_i)..) :k

Precies als in §2.4 groeien Aalscholver nesten uit tot macht ^ torens met tetratie ^^ verdiepingen.

• ,(1,,(1,,(1,1))) := ,(1,,(1,,1)) = ,(1,,(1,a)) = ,(1,a^a) = a^^3
• (a,.,(1,..).) :m1: = (a,.,(1,..1..).) :m: = a^..1 :m = a^^m

Deze superradix expressies drukken de natuurlijke getallen uniek uit, als elke variabele 0<p<a en de nest diepte onbegrensd is. Dat is tot onze diepen uitbreiding de nest grens bij m1=a legt.

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

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

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

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

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

Denkwerk in uitvoering

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

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

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

Bird's Universum

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

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

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

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

En in geneste arrays zijn onze ruim regels voor uitgetelde dimensies een stuk simpeler. We verwijderen het lagere element uit [S]1`[T] waar begin en einde van zijn `ruimte` eerder is gemerkt.
Terwijl Bird's subsysteem om de grootte [S]<[T] van sep arrays te vergelijken steeds ingewikkelder wordt. Gelukkig is voor de evaluatie alleen van belang om te weten waar hun ruimte is begrensd.

De expressie voor de volgende stap $ is gegeven door bel b met 1 te verminderen (dit telt unit - op).
Gebruik komma's , als separator tussen tellers in rijen.

• 1.$ {a,1Z} => $ = {a,Z}
• 2., [1] ≡ ,
• 2.€ €1 ≡ a, & €n ≡ {a[n]b}[n]

Nest functie U.III voor Bird's geneste arrays.⁴
Deze omvat ook zijn hyper-dimensionale arrays³ met separatoren die uit rijen indexen [n.,pj..] bestaan.

• 0.0. 0.1. 1.4. 2.€ 1.
• 3.2a. [S]1} ≡ } 3.2b. [S]1] ≡ ]
• 3.3. {a,1[S]Z} = a
• 3.5a. ,1[S] ≡ [S] {S>1} 3.5b. [S]1` ≡ ` 3.5c. `p` ≡ p {p>0}
• 3.6. {a,b.[T_i]“1..,1Z} :k = {.€T_i“..$,Z} :k
• 3.7. {a,b.[T_i]“1..Z} :k>0 = {.€T_i“..Z} :k

Tellers staan bij Bird nooit 0 leeg, daarom beginnen de woorden Z, R en X hier met een getal. Voor separatoren [S] geldt dat {S>0} en dat deze ook een [1] komma , kunnen zijn.

Als een woord ruimte accenten ` bevat, dan komen die net eender terug in de kopie ervan. Zo ook bij reeksen `.. die we ongeteld met “ aangeven. Zo'n niet-lege reeks blijft staan op zijn plek, in 3.6 en 3.7 rechts buiten de sep array [Ti] die we links expanderen.
De afkorting “ sluit een onbestemd aantal ruimtes uit (de input komt soms zonder). Om met minder accenten rekening te hoeven houden, zullen we die van links al vroeg elimineren.

Hulpregels voor het opschonen van ` ruimte merken aan a. begin en b. einde van de eerste rij van 1. top en 2. geneste arrays.

• 3`1a. {` ≡ { 3`1b. {a,b` ≡ {a,b
• 3`2a. [` ≡ [ 3`2b. [p` ≡ [p

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

• 3.€ a. €1 ≡ a, 3.€ b. €T ≡ {a[T]b}[T]
• 3.€ 2. {a[1T]b} {T>1} ≡ `{a[T]b,b}`
• 3.€ 3. {a[T]b,k1} ≡ €T{a[T]b,k} ≡≡ €T..{a[T]b} :k

De hyper-dimensionale regel verdiept zich, als Bird in zijn geneste hoekketens a door b vervangt. Door de bel diep te laden blijft zijn algoritme maximaal grote getallen maken.

• 3.£ c. £1 ≡ b, 3.£ d. £T ≡ {b[T]b}[T]
• 3.£ 4a. {a[.,1..R]b} :n ≡ {a[.b,..R]b} :n
• 3.£ 4. {a[.[T_i]“1..X]b} :n ≡ {a[.£T_i“..X]b} :n

Hangende tellers ,1 ruimen we op met de oude regel 3.5a, verder vergelijken we separator arrays niet qua grootte in Uil.
Het is alleen van belang te weten waar een reeks elementen ophoudt en waar die begint. Daarom begrenzen we meer-dimensionale ruimtes (vanaf het 2D vlak) per bank regel 3.€.2 met ` accenten.

Toon een evaluatie voorbeeld in drie klikken.

• {a,2[4]2} = {€4“1} = {{a[4]2}[4]1} = {{a[4]2}} = {`{a[3]2,2}`} = {€3{a[3]2,1}`} = {€3{a[3]2}`} = {{a[3]2}[3]{a[3]2}`}
• = {`{a[2]2,2}`[3]`{a[2]2,2}``} = {€2{a[2]2}`[3]`€2{a[2]2}``} = {{a[2]2}[2]{a[2]2}`[3] `{a[2]2}[2]{a[2]2}``} = {a,a[2]a,a`[3]`a,a[2]a,a``}
• == {a,b[2]1,2`[3]D`} = {{a[2]b}[2]$`[3]D`} == {a,b`[3]D`} == {a,b[3]`p``} == {a,b[3]2`} == {a,b[2]2`} == {a,b,2`} = {a,$`} = {a,b} = a^b

Opruimregel 3.5b elimineert afgetelde elementen aan het einde van hun reeks. Als de evaluatie trein aankomt aan het begin ervan, dan heft regel 3.5c deze ruimte voorlopig op.
Maar het lijkt lastig om met ons bank systeem elke rij ruimte (een 1D reeks getallen) op natuurlijke wijze te markeren…

^0. Een systeem voor snel groeiende recursieve functies, dat de functies van Jonathan Bowers en anderen ver te boven gaat, in Christopher M. Bird Super Huge Numbers, een serie van 9 PDFs over Bird's arrays + 3 bijlagen, 2017.
^3. Chris Bird, Hyper-Dimensional Array Notation, 2017.
^4. Chris Bird, Nested Array Notation, 2012.
^5. Shàng betekent zowel boven als eerder, xià betekent onder en volgend, p.137 in James Gleick "Time Travel, a history" 2016.
[Chinese etymologie, maar men werpt een I Tjing hexagram van onder naar boven, terug het verleden dan]