Vermenigvuldigen is herhaald optellen.
We schrijven deze operatie met een ster a*b tussen twee ge­tallen en nemen b keer a. Natuur­lijke getallen 1.. zijn opge­bouwd^a uit units 1 en daarom is vermenig­vuldiging al een her­haling op her­haling.

• a*1 ?= a (init)
• a*2b ?= a+a*1b (stap) = a+a+a*b = aa+a*b == a..+a*1 :b1 = a..+a :b1 = a.. :b2

Bij voorwaardelijke evaluatie met prece­dentie ?= ver­andert een regel de ex­pressie alleen, als er geen opera­tie die voor­rang heeft op volgt. Hier doen we maal * voor plus + bijvoor­beeld.
Dus a*3 = a+a*2 = a+a+a*1 = aa+a*1 = aa+a = aaa is hoe we een ex­pressie uit­werken, waar­bij we een enkele op­telling a+b*c links laten liggen.

We scannen de expressie l-r (van links naar rechts), terwijl we een match voor een regel pro­beren te vinden, om die toe kunnen passen.
Varia­belen uit verschil­lende regels zijn onaf­hankelijk.
Na herhaalde toe­passing == van regels noteren we een later resul­taat. Soms schrij­ven we = om een be­kende uit­werking samen te vatten.

Een andere manier van optellen is, om getallen om te draaien en dan pas samen te voegen. Dit pop­tellen + kan ook staps­gewijs, per tel.

• b+1 ?= 1b
• b+a1 ?= 1b+a == a1b

In Cantor's oneindige valt 1ω = ω weg, maar telt ω1 gewoon op.^b Stel dat we, in dit niet commu­tatieve on­eindige, een serie a optellen bij een on­eindig grote b. Als deze serie on­eindig lang is, zal deze de uit­komst domineren en kan b alleen rechts nog wat bij­dragen.
Door op pop wijze b+a op te tellen tot ab, groeien on­eindige series ..a naar links ω: aan. Zelf zal in ..a1 het item niet zijn omgedraaid en reps zoals ω1: worden eerst van rechts bijgeteld.

G0.=Gi.. :u =>
   G0=1.. :Gi=Gu

In de voorrangsregels voor operatoren gaan machten ^ voor * sterren, en een plus + of pop komt in de evaluatie laatst.

• + ?< *{n} ?< ^ (operator volgorde)
• ^^.. :n ?< ^^.. :n1 (meer eerst)

Voor supermachten geschreven met dakjes of supers ^.. geldt de gebrui­keljke prece­dentie van de meer­derheid, en in gelijke gevallen zijn ze rechts asso­ciatief. Er is een teken minder nodig a^{n}b = a*{n1}b dan voor super­machten met sterren.

Onze supersterren *.. evalueren we l-r (links asso­ciatief) zonder dat verge­lijking nodig is. Hoewel prece­dentie van de minder­heid uit hun definitie zou moeten volgen. Immers a*{0}b = ab wordt van nature direkt opgeteld.

Om getallen met miljoenen cijfers te vermenig­vuldigen zijn er snellere methodes ontwikkeld. Voor twee getallen met d digits kost de oude school­methode d^2 reken­tijd, terwijl dit met de Karatsuba truc een kleine c*d^Log(3) is (logaritme basis 2).
Kampioen met c'*d*Log(d) is het FFT algoritme, dat snelle Fourier trans­formaties toepast.¹ Quantum computers kunnen in de toekomst een nog grotere tijd­winst geven.

Voor de grote getallen die wij maken haalt zulke reken­kunde weinig uit. Die liggen voorbij de horizon^c van het fysisch universum.
De macht ^ of ** kan met het prin­cipe van her­haling op her­haling tot tetratie ^^ of *** (toren van machten) en verder tot super­machten worden uitge­werkt. De opera­toren + * ^ helpen om moei­lijk te tellen getallen te schrijven, maar het kan ook zonder…

Radix systemen, zoals ons tien­tallig stelsel, repre­senteren expo­nenten van machten van 10 door een positie in een reeks cijfers. De cijfers zelf her­halen deze machten.

..ci.c0 n: & 0≤c<10
   = c0.+ci*10^i.. :n

Ieder cijfer ci vermenigvuldigt zijn macht van 10 en daarna wordt die serie opge­teld tot een getal, dat uniek is voor de cijfer­reeks. En dat is best knap, hoe kunnen kinderen zoiets ingewikkelds leren…?

Er zijn drie elementaire operaties tussen getallen. Optelling + wat getallen samen telt, vermenig­vuldiging * wat tellen herhaalt, en nu dan machts­verheffing met ^ of ** als operator. Zowel de operatie als het resultaat ervan noemen we een macht.

Machtsverheffen herhaalt vermenig­vuldigen met het­zelfde getal. Dat kan per stap worden gedaan. Onze macht operator is ^ een dakje, super­script notatie is onge­schikt voor de computer input lijn.

• a^1 ?= a
• a^b1 ?= a^b*a == a^1.*a.. :b = a*..a :b

De voorwaardelijke toewijzing ?= staat hier, omdat een macht rechts in een reeks elemen­taire operaties voor­rang krijgt. Bijv. de ex­pressie a^b^c betekent a^(b^c), waar de sub­expressie b^c eerst wordt uit­gewerkt (tot exponent).

Onze logaritme functie Log is een inverse van machts­verheffing, en nog wat weetjes over operaties met machten.

• m^p*m^q = m^pq (m^p)^q = m^(p*q) n^-*n = 1
• m^Log(m,n) = n Log(m,p*q) = Log(m,p)+Log(m,q) Log(m,n)*Log(k,m) = Log(k,n)

Ster operaties *.. evalueren we hier strikt `= vanaf links. Daar zijn geen haakjes bij nodig of verge­lijkende prece­dentie regels. Alleen een rechter operatie zonder plus, die volgt na een ope­ratie met pop plus, wordt met voor­rang geholpen.
Het aantal sterren tellen we in deze evaluatie af naar links, tot we op nul *{0} uitkomen en de operanten ac natuurlijk optellen.

Een l-r definitie voor machten met ** twee popsterren.

• a**b1 `= a+*a**b (popster)
• c+*a+* `= a*c+* (popschuif)
• c+*a**1 = a*c (ontpop)

We gebruiken een popster om een macht af te schermen van zijn uit­werking, die links plaats vindt. Het plus teken van +* fungeert als haakje, maar is tijdelijk en verdwijnt als deze als ster operatie op­schuift voor een nieuw pop­ster haakje.

a++b2 = a+a++b1
  = aa++b1 = aaaa++b
 == a.*2..++1 :b1
  = a*2^b1

Een serie gelijke operaties komt in de evaluatie van super pop­ster operaties nooit voor. We zien duo's van ster en pop­ster, met een naar links af­nemend aan­tal sterren.
Als we een pop operatie links vóór de macht plaatsen, dan zal deze ope­reren op de hoogste factor, die steeds naar rechts schuift. Eerst een simpel voorbeeld, dan de algemene formule.

• 1+2**3 = 1+2+*2**2 = 3+*2**2 = 3+*2+*2**1 = 2*3+*2**1 = 2+2*2+*2**1 = 4+2*1+*2**1 = 6+*2**1 = 2*6 == 12.
• p+*{q}a*{c1}b1 = a*{q}p+*{c}a*{c1}b = a^{c}b1\*{q}p

Bij rekenen met sterren, moeten we soms haakjes toe­passen. Maar hier gaat het erom één ster operatie in stappen uit te werken.
Een pop­ster +*{c} stelt zijn operatie niet alleen uit, maar draait de operanten daarna ook om. Dit pop­schuiven blijft gelijk in geval +* want vermenig­vuldigen is commu­tatief, maar bij super­machten maakt om­draaien groot verschil.

Pop­schuiven is nodig vanaf +** bij dubbele machten. Die ont­staan bij het uit­werken van tetraties *** in enkele stappen = zoals we dat hier­onder doen, tot de her­haling == ervan duidelijk is.

3***3 = 3+**3***2
      = 3+**3+**3***1
      = 3**3+**3***1
 3**3 = 3+*3**2
      = 3+*3+*3**1
      = 3*3+*3**1
  3*3 = 3+3*2
      = 3+3+3*1
      = 6+3*1
      = 9 (ontpopt)
 3**3 = 9+*3**1
      = 3*9 (ontpopt)
     == 27.
3***3 = 27+**3***1
      = 3**27 (ontpopt)
      = 3+*3**26
     == 9+*3**25
      = 9+*3+*3**24 (popster)
      = 3*9+*3**24 (popschuif)
     == 27+*3**24
    === 7625597484987.

Stel dat we de regel voor pop­schuiven vervangen door pop­ruimen, dus plus + elim­inatie zonder dat er operanten ver­wisseld worden. Dan blijven hek­machten #.. ver achter op *.. super­sterren.
Hierboven zou 27##3 omdat (3^3)^3 = 3^(3*3) = 3^9 al een factor 3^18 schelen. Hoe klein is dan 4####4 in vergelijking en hoe groot is 4****4 of gaat dat te ver voor telbare hekmachten…?

Nadat machtsverheffen lange tijd de hoogste operatie was, vond de algo­ritme kenner Donald Knuth³ in 1976 zijn telbare opera­toren ↑{c} uit, om ge­tallen in het gebied van super­machten te noteren. Alleen de aller­kleinste super­machten zijn nog precies uit te rekenen.

De elementaire operaties tot aan machten beschouwen we als vooraf gegeven. Eerst komt de enkele pijl ↑ van Knuth of de operator ^ van gewone machten. Knuth legt dit uit als her­haald vermenig­vuldigen, wat herhaald op­tellen is. Tetratie noteert hij met twee pijlen ↑↑ en werkt dit uit tot een rij machten, enzovoort.

Regels voor Knuth's pijlen, die wij altijd van rechts oplossen.

• a↑{c}1 = a {c>0}
• a↑{c1}b1 = a↑{c}a↑{c1}b =! a↑{c}a↑{c}a↑{c1}b- == a↑{c}..a :b

De operator voorrang voor supers ^{c} geldt niet voor Knuth's ↑{c} pijlen, die we strikt =! rechts asso­ciatief op­lossen binnen een reeks operaties. Dit past bij de r-l evaluatie van Conway's pijl­ketens C.I en bereidt onze extensie naar super­pijlen voor.

Het was de verbeelding van de wiskundige Ronald Graham, expert in de grafen­theorie, die popula­risator Martin Gardner⁴ aan­spoorde om een buite­nissig aantal van Knuth's pijlen te gebruiken om Graham's getal mee aan te duiden. Graham's getal is een boven­grens voor een reken­kundig probleem met bi­chromatische hyper­machten, zoals het Neder­landse Guinness record boek⁵ dat noemde. Hoewel Gardner de schatting, die Graham eerder publi­ceerde⁶, danig over­dreef.

Het mooie van het bewijs dat Graham gaf, is dat de oplossing zeker bestaat, hoewel dit getal wel eens onbe­rekenbaar ver weg zou kunnen liggen. Maar het is voor de hand liggend dat het klein is.
Zoals het 9e priemgetal p8+4 = 23 dichter­bij ligt, dan de boven­grens 1+1.*pi.. :8 die het bestaan ervan bewijst.
Tegenwoordig zoekt men de oplossing voor het probleem van Graham trouwens vanaf 13 en zijn boven­grens is tot 2↑↑↑6 terug­gebracht.

Graham's record getal is een hyper­macht, die we noteren als recursie over super­macht pijlen, van binnen naar buiten te tellen en van rechts af uit te werken.

• 3↑{..4..}3 :4↑3: = 3↑{..3↑↑↑↑3..}3 :63:
• 3↑↑↑↑3 = 3↑↑↑3↑↑↑3 =! 3↑↑↑3↑↑3↑27.

Knuth's operaties werden eerder al uitgedrukt in een functie, die we voor het eerst in 1925 bij David Hilbert⁷ tegen­komen. Hilbert begint om op­tellen, vermenig­vuldigen en machten te her­halen, om daarmee de operatie van tetratie aan te duiden.
De hogere supermachten pakt Hilbert in in zijn twee­ledige recur­sieve functies Hc die we aldus her­schreven.

• H₁(a,b) = a+b = ab
• H_c1(a,1) = (H_c,a,1) = a
• H_c1(a,b1) = (H_c,a,b1) = H_c(a,(H_c,a,b)) == H_c(a,..(H_c,a,1)..) :b: = H_c(a,..a..) :b:

Hilbert gaf zijn voorzet Ha(a,a) en Wilhelm Ackermann schoot die er in 1928 in, met een stroef bewijs⁸ dat deze functie niet primitief recursief is te formu­leren.
Ackermann functie G(a) = F(a,a,a) werkt met deze regels.

• F(a,b,0) = a+b = ab
• F(a,0,1) = a*0 = 0 F(a,0,2) = 1 F(a,0,c>2) = a (vervroegd)
• F(a,b1,c1) = F(a,F(a,b,c1),c) == F(a,..F(a,0,c1)..,c) :b1:

Het is mogelijk om in één regel, vanuit unair optellen, met Hilbert's en Knuth's repetitie van operaties in haakjes, een complete definitie te geven van super­machten.

a^{c}b1 = a*{c1}b1
  = (a*{c}..a..) :b:

Knuth's pijl operaties, onze super­sterren en de eerdere recursieve functies hebben allen het­zelfde bereik. Wij noemen het super­machten, of dubbele recursie. Daar spelen twee recursies: een grote met iter c over een kleine met iter b over een constante a>1.

De Hongaarse wiskundige Rozsa Péter had in haar boek⁹ uit 1950 slechts twee para­meters nodig in een dubbel recur­sieve functie.
Definieer Péter's P met naam en positie van variabelen omge­zet.^d De functie begint met op­tellen van een constante a=1.

• P(b,0) = b+1 = b1
• P(0,c1) = P(1,c)
• P(b1,c1) = P(P(b,c1),c) == P(..P(0,c1)..,c) :b1: = P(..1..,c) :b2:

Om systemen voor grote getallen te vergelijken, volstaan we met het uit­rekenen van de belang­rijke iteraties. Zodoende, als de voort­zetting inzich­telijk is, levert dit een bewijs door demonstratie.

Omzetting van Rozsa Péter's dubbel recursieve functie P() naar een links asso­ciatieve `= versie met oparator teken ¶ is een­voudig.

• b¶1 `= b11
• 1¶c1 `= 1¶c¶c
• b1¶c1 `= b¶c1¶c == 1.¶c.. :b2

Zo vermijden we de 0 en subexpressie haakjes. En we werken b¶c1 stap na stap uit tot een reeks van b van zulke ¶c recursies.

Supersterren *.. regelen we ook liever met enkele stappen. Maar om deze l-r te evalueren, zonder haakjes of prece­dentie, is lastiger. We intro­duceren pop opera­toren om super­machten te scheiden.
In deze definitie van supersterren is c≥0 zodat *{0} unair optelt.

• a*{c1}b1 `= a+*{c}a*{c1}b
• p+*{c}a+ `= a*{c}p+
• p+*{c}a*{c1}1 `= a+*{c}p

Hogere superster operaties worden van de uitwerking van de lagere apart gehouden door er pop­sterren +*.. tussenin te plaatsen. Als een plus volgt, dan valt de linker pop + voor deze sterren weg, terwijl de operanten om­keren of pop­schuiven. Van dit pop­schuiven zagen we al een voorbeeld met tetratie in blog §2.1.

We zagen gewone plus elim­inatie als alter­natief en de opera­toren #.. daar­van noemden we hek­machten.
Vul de regel a#{c}+b+ = a#{c}b+ in in het super­sterren schema. Ver­vang daarin de ster * door een hekje # om hek­machten te maken. Ook hier telt #{0} een­voudig direkt op, zodat de initiële regel voor c=0 over­bodig is.

De regels voor een hek­macht functie.

• #(a,1,c1) = a
• #(a,b1,1) = #(a,b,1)a
• #(a,b1,c1) = #(#(a,b,c1),a,c) == #(..a..,a,c) :b:

Hek­machten lossen we steeds links associatief op.
Bereken de snelheid van onze #.. hek­macht operaties ten opzichte van Knuth's ^.. super­machten.

• a##a##a = (a^a)^a = a^(a*a)
• a###b1 = a###b^a = a^(1.*a..) :b = a^a^b
• a1###a###a ≈ a1^a1^a^a
• a####b ≈ a^^b^a^^b ≈ a^^b1
• a#{4}a#{4}a ≈ (a^^a1)^^a1 ≈ a^..a^^a1 :a = a^^aa1
• a#{5}b2 ≈ a#{5}b1^^a1 ≈ a^..a^^a{b}1 :a ≈ a^^(a*b1)
• a#{5}a1#{5}a ≈ a^^a^^(a*a)
• a#{6}b ≈ a^^^b\*a
• a#{cc1}b ≈ a^{c}(a*b)
• a#{cc}b ≈ a^{c}b

Vanaf c=2 machten wordt het aantal hekken #.. verdubbeld ten op­zichte van *.. sterren. Een halve super­macht tilt het grondtal a de super­exponent in (eerst als macht, dan als factor) en de andere helft ont­wikkelt de super­toren van expo­nenten.

In de Grzegorczyk hierarchie¹⁰ is er geen aparte klasse recur­sieve functies tussen de super­machten in. Toch slaagden we erin c op te delen: in functies die op halve super­snelheid gaan en op hele. Wie weet is zo rationele ver­deling van supers c mogelijk…?

Toch denken we dat een fijnere algoritmische verdeling buiten iteratie over operant b van super­machten niet bestaat. En dat alle algo­ritmen die primitieve recursie over­treffen dit doen door te itereren over c.
Dit is ons dubbele vermoeden. Dubbele recursie kan dus niet 3 keer of 1/3 keer zo snel gaan als super­sterren bijvoor­beeld.

In het vervolg speelt deze kwestie bij geneste arrays. Als we posities in array functies indexeren, moeten geneste arrays dubbel zo diep zijn om het­zelfde getal uit te drukken. We tonen aan, dat verdub­beling van de nest­diepte een geschikte uit­komst geeft. Enkel of dubbel zijn in deze structuren blijkbaar de enige natuur­lijke alter­natieven…∴

Aas [ace] is hoe we de linker operant a noemen, die constant blijft. In de primitief recur­sieve stap van onze blazer [blazer] functies telt a op bij varia­bele b, de bel [bubble]. Deze wordt gedurende de evaluatie steeds groter, tot de bel op het laatst de uit­komst [output] geeft als een lange reeks 1.. enen.

Initieer Aas­blazer met output selectie en optellen.

• a[1] = 1
• a[,1] = a[a,] = a[a] = a
• a[b,1] = a[ba,] = a[ba] = ab = a+b

Item 2 telt aas a bij niets. Item 3 telt b+a intern direkt op. Zo op­tellen classi­ficeren we met nul sterren *{0} hetzelfde als tellen.

Bij oneindige azen luistert de aflezing nauw. Getallen 1.. en ω tellen alleen aan de rechter kant op bij hoger on­eindige reeksen.
In Aas­blazer arrays zijn nieuwe reeksen a.. die van rechts de bel in komen, altijd groter dan eerdere, die links staan voor­gesorteerd in b. Dus moeten we de uitkomst omkeren, om Cantor's manier van tellen in het oneindige recht te doen.

Het is handig om het groeiende sub­totaal alvast rechts buiten de array te presen­teren, in reken­kundig format. Zet dan wel een plus teken + tussen de Aas­blazer array en de voor­lopige output bel.

In de eerste iteratie herhaalt c het optellen van a.

• a[b,2] = a[ba,1] = a[baa] = aab = a*2+b
• a[b,1c] = a[ba,c] := a[,c]+ab == a[,1]+a*c+b = a*1c+b
• a[,c] = a*c

Dit * is vermenigvuldigen en herhaalt de optel structuur *{0} en zo begint met factor c de klasse *{1} van para­meters of iter­atoren. In Aas­blazer fungeren alle variabelen buiten de optel bel als factoren.

Volgt de definitie van Aas­blazer's eerste rij, ofwel de lineaire array. De eerste rij wordt gevormd door de voorste serie para­meters, waar elke positie met een enkele index gegeven is, die zelf in de index array het eerst komt. De aan de geïndex­eerde positie gekop­pelde para­meter beschouwen we als nulde iter­ator van de geneste rij.

Regels met equivalentie ≡ zijn universeel (overal, altijd) toe­pasbaar. Dus zonder richting van evaluatie in de ex­pressie. Hoewel we normaal `= vanaf links l-r regels toe­passen op de ex­pressie tekst.
De tekens a en b reserveren we voor aas en bel links buiten de top array en links erbinnen. De andere vars in deze regels zijn natuur­lijke ge­tallen vanaf 0. Maar een teken 0 valt meteen weg (tegen een getal ernaast, maar ook op zich) en een lege iterator elimineert zijn element.

Aas­blazer A.I voor de klasse *{1} array rij.

• A.0. a[bw] = wb
• A.1. ,[] `= 0
• A.2a. ,[n]] ≡ ] A.2b. ,[n], ≡ ,
• A.3. ,[1n]1 ≡ ,[n]a,[1n]

De lege array ,[] die in regel A.1. wegvalt, telt ge­tallen direkt op in de bel. Die wordt bij de uit­lezing met A.0. omge­draaid. Dus op­tellen gaat zoals de pop plus in blog §2.0, maar dan achter­af.
Een verdwaald element ,[]p in het midden laten we met rust, tot de voor­gaande indexen zijn ver­dwenen en dit element bij [b arri­veert. Pas dan popt de lege sep weg, zodat waarde p rechts bij­telt.

Een eerste komma ,[1] zullen we vaak zo , noteren zonder index. Deze ver­taling be­hoort niet in de definitie, en komt daarom a.1. in de lijst met hulp­regels.

Overbodige separatoren worden met regel A.2b. opgeruimd. Wat wij blazen noemen, is dat het systeem de dode elementen weer nieuw leven inblaast. Dat gebeurt in regel A.3. door de index array te her­stellen en aas a op te laden naar de nieuwe para­meter.
Meestal volgt in een expressie achter de 1 nog een getal 1p, maar de regels ver­melden alleen tekens die nodig zijn voor de match.

Gebruikelijk is om de aftelling en verwijdering van iter 1 als geheel te zien en apart te definiëren. We lassen een getal stop ! teken in met regel a.0. om die routine ineens a.3. te kunnen besluiten.
Dan volgt na ! geen getal meer, maar in X,[S]!Z een komma , of array ] eind. Dit teken voor de getal­grens werkt als de woord­grens \b in regex. Verder geen 1 dus, als getallen unair zijn.
Losse variabelen v zijn altijd v! gretig [regex: greedy] naar enen.

Hulpregels a.II bij evaluatie in Aas­blazer.

• a.0. !x => x=0
• a.1. ,[1]c := ,c
• a.2. a[bw,Z] := a[,Z]+wb
• a.3. ,[1X]1! ≡ ,[X]a
• a.4. ,[X],[1X]1 ≡ ,[X]a,[1X]
• a.5. ,[X]p,[X]q ≡ ,[X]pq
• a.6. ,[X]p,[Y]q ≡ ,[Y]q,[X]p

We kunnen index arrays ook houden tot ze definitief onbruikbaar zijn. Vandaar de hulp­regel a.4. voor her­laden, om seps maar een­malig in te hoeven voegen en ze daarna herge­bruiken.
Afgetelde iters kunnen wachten tot we er opnieuw a in­voegen, zodat op­ruimen A.2b. over­bodig is. Dan hoeven we regel A.2a. alleen toe te passen op het einde van de top array.

Het herladen met a.4. van uit­gewerkte ex­pressies kan vanwege de diepe match van array [X] met array [1X] moeilijk worden. Maar in de praktijk mogen we ervan uit­gaan, dat een nieuw gevormde array sequentie X links en de array sequentie X rechts van de lege plaats gelijk zijn, zolang we geen elementen met a.6. ver­plaatst hebben.
Array functies die van grootschalige vergelijkingen afhangen ver­mijden we liever. Maar dat is van later zorg.

Er ontwikkelt zich een radix stelsel, zie §2.0, over de eerste rij met als basis aas a. Het aantal en de grootte van factoren c,d,e,f,.. is voor­alsnog onbe­perkt, maar we zouden ze ook naar gelang de basis 0<fi<a kunnen be­cijferen.

• a[b,[2]1] = a[b,[1]a,[2]] = a[b,a] = a*a+b = a^2+b
• a[,[2]1d] = a[,a,[2]d] := a[,[2]d]+a^2 == a^2*d1
• a[b,[1]c,[2]d] := a[,[2]d]+a*c+b = a^2*d+a*c+b
• a[,[3]1e] = a[,[2]a,[3]e] := a[,[3]e]+a^3 == a^3*e1
• a[,[m]f] = a^m*f
• a[b.,[m_i]f_i..] :n = a^m_i*f_i..+b :n

Een element ,[n]1 telt a^n bij de output op. Zodoende opent deze telbare index n de con­structie klasse *{2} voor array nesten.

De structuren van de functie klassen *{k} in Aas­blazer gebruiken we als sjablonen voor de con­structie van grote ge­tallen functies. Daar­mee zijn deze klassen *{k} con­structie types of con­structen.
In box 2.3 zagen we dat Aas­blazer bestaat uit vloeibare arrays met vrij te bewegen cijfers. Ook de recursies, vanaf regel A.3. verder, willen we universeel toe­pasbaar houden. Welke recur­sieve stap, in wat voor array, we wanneer zetten, het zou niet uit mogen maken.

Onze array functie Bellen­blazer krijgt vaste structuren, en blaast daar groei­bel b in omhoog, niet constante a, wat maximaal uit zal pakken. Hoewel Bellen­blazer's afge­telde elementen A.2. ver­wijderd worden, zijn indexen er niet zoals a.5. samen te voegen of a.6. vloeibaar. Recursies moeten we strikt l-r evalueren, anders wijkt de output af.
Lijkt of snelheid (A. laag, B. hoog) en vrijheid (A. hoog, B. laag) in array functies twee kanten zijn van dezelfde googo­logische munt…?!

We kunnen Aas­blazer gebruiken als super radix systeem, zodat ieder geheel getal een unieke input ex­pressie heeft. In radix ex­pressies zijn alle para­meters en indexen kleiner dan het basis getal a.
De Aas­blazer evaluatie trein rijdt met aas a ver naar rechts de array in, vult station na station de voor­gaande elementen, tot getal a bij bel b aan­komt en uit­eindelijk optelt tot een groot output getal.

Aas­blazer A.II klasse *{2} geneste arrays.

• A.0. a[bw] = wb
• A.1. ,[] `= 0
• A.2. ,[X]0 ≡ 0
• A.3. ,[1X]1 ≡ ,[X]a,[1X]

De laatste regel is de recursie stap, daarvoor de eliminatie regels.
We nesten rood in blauw ,[X] voor situaties die op elk array niveau voor­komen, groen in blauw ,[X] op top niveau.

Per regel A.1. valt de nulde komma ,[] weg, ook als er links geen getal staat: aan het begin van een sub­array. Nul sep elim is de enige `= aan l-r richting gebonden regel van Aas­blazer (hopelijk blijft dat zo). En dat komt alleen, omdat we zulke mis­plaatste nul seps rechts in de rij input toe­laten, en output zoals altijd uniek bepaald moet zijn.

De equivalentie A.2. verwijdert de seps van leeg­getelde iters 0 aan een array einde of middenin, op elk niveau in geneste arrays.
De meta-tekens 0 geven een leeg   getal aan op die positie in de expressie. Strikt genomen is het cijfer 0 niet aanwezig, aangezien alle getallen in ons systeem uit units 1.. bestaan.

Hulpregels a.II blijven bij aas­nesten van kracht.
Nu worden Aas­blazer's indexen dieper genest: met de tweede rij iters ,[d,1]c waarin de komma , het derde array niveau ,[1] opent.

Tel met de 2e index e het aantal azen a*e in de exponent, en daar met de 1e index d enen bij op.

• a[,[,[1]1]1] = a[,[,1]1] = a[,[a]1] = a^a
• a[b,[,1]c] = a[b,[a]c] = a^a*c+b
• a[,[1,1]1] = a[,[,1]a] = a^a*a = a^a1
• a[,[1,1]c] = a^a1*c
• a[,[2,1]1] = a^a2
• a[,[d,1]1] = a^ad
• a[,[,2]1] = a^(a*2)
• a[,[,e]1] = a^(a*e)
• a[b,[d,e]c] = a^(a*e+d)*c+b

Door deze super radix een index dieper te nesten, gebruiken we al een dubbele expo­nent, zoals in expo­nentiële notatie.
Zo is 10[,[3,1]2] = 2E13 een recent schulden­plafond van de Ameri­kaanse over­heid, namelijk twintig biljoen dollar [US$ 20 trillion].

In Aas­blazer is elk element een machts­factor: de index array vormt een macht van a met rechts zijn factor of cijfer.
Als we de machts­factoren binnen een geneste array met regel A.3. apart uit­werken, zetten we die index rij om naar een enkel getal. Dit index getal fungeert dan weer als expo­nent, ergens in de grote brede boom van machten van a.

Druk de dubbele exponent a^a^n uit met indexen op het 2e niveau in Aas­blazer, waar de dubbel geneste 1e index de posities aan­geeft.

• a[,[,[2]1]c] = a^a^2*c
• a[,[d,[2]1]1] = a^a^2*a^d = a^(a^2+d)
• a[,[,[1]e,[2]1]1] = a^(a^2+a*e)
• a[,[,[2]2]1] = a^(a^2*2)
• a[,[,[2]f]1] = a^(a^2*f)
• a[,[,[3]1]1] = a^a^3
• a[,[,[3]g]1] = a^(a^3*g)
• a[,[,[n]1]1] = a^a^n

Als we een groot getal in een radix noteren, verschilt de expressie lengte¹¹ niet signi­ficant van de unaire vorm. Zonder indexen, in een radix systeem waar machten gegeven zijn door hun plaats, scheelt dit slechts de eerste expo­nent in de machts­toren. Dus radix ex­pressie lengte is nauwe­lijks kleiner dan het grote getal zelf.
De recursie in regel A.3. definieert Aas­blazer als radix. De rest is index­ering. Daarom is Aas­blazer een mini­maal algo­ritme.∴

De input expressies van non-random grote getallen blijven in de Aas­blazer super radix goed leesbaar, omdat er geen reeks nullen hoeft te worden toe­gevoegd. Ons systeem doet het cijfer 0 in de ban. Ook lege plaatsen hoeven niet voor te komen, als we elementen na hun laatste iteratie meteen via regel a.3. op­ruimen.
Toch is de super radix structuur in de uitwerking van grote getallen niet bijster klein. Het aantal elementen dat Aas­blazer voor de evaluatie van a^a^n in gebruik neemt is a^n. Tijdens passages in Aas­blazer wordt de ex­pressie lengte iets groter dan bij een tradi­tionele radix, maar blijft bijna een exponent kleiner dan bij unaire notatie.

De overeenkomst tussen array niveau's en de uitgedrukte expo­nenten blijkt gaandeweg. Een ver­dieping van indexen voegt een expo­nent toe aan de machts­toren van de output.

Een array niveau dieper, voegen we de derde exponent toe aan onze super radix, met de eerste index op het 4e niveau.

• a[,[,[,[1]1]1]1] = a^a^a = a^^3
• a[,[,[,1]1]c] = a^^3*c
• a[,[,[,1]e]1] = a^^3^e = a^(a^a*e)
• a[,[d,[,1]e]1] = a^(a^a*e+d)
• a[,[,[1,1]1]1] = a^(a^a*a) = a^a^a1
• a[,[,[,2]1]1] = a^(a^a*a^a) = a^a^aa
• a[,[,[f,g]1]1] = a^a^(a*g+f)
• a[,[,[,[2]1]1]1] = a^a^a^2
• a[,[,[,[2]h]1]1] = a^a^(a^2*h)
• a[,[,[,[n]1]1]1] = a^a^a^n

In theorie zijn alle gehele getallen in dit domein uniek uit te drukken met cijfers 0<ci<a in deze super radix. Maar prak­tisch kunnen we slechts enkele markante grote ge­tallen schrijven.
De lengte van random getallen¹² input in Aas­blazer is vanaf tetratie vrijwel gelijk aan de lengte als enen output. Zelfs in het domein tot 10^^4 ont­snappen de meeste ge­tallen aan al onze fysisch moge­lijke notatie systemen, willen we wedden…?!

Geneste arrays in Aas­blazer werken we uit tot tetratie.

• a[,[,[,[,[1]1]1]1]1] = a[,[,[,[a]1]1]1] = a^a^a^a = a^^4
• a[.,[..1].1] :n: = a^..1 :n = a^^n
• a.[p_i,..q_i] :n>0: = a^(..1..)*q_i+p_i :n:

Neem een Aas­blazer expressie met geneste index tot array niveau 5, ongeveer gelijk aan een tetratie 2^^5. Tijdens de reductie daar­van tot een reeks enen, zullen in de top array een aantal van 2^^4 factoren voorbij­komen met elk hun eigen index array.
Voor de fysische uitwerking van zulke getallen zijn er in het hele heelal niet genoeg quantum bits. De quantum bit radix van de kosmos kan random ge­tallen schrijven tot 2^10^120 of kleiner eigenlijk, omdat de natuur­wetten alle infor­matie compri­meren.

Dat Aas­blazer een minimaal systeem is, maakt het geschikt voor het op­meten van systemen voor grotere ge­tallen. Op een expo­nent na telt onze super radix de ele­menten in ieder array systeem, dat zijn iteraties heeft inge­bed in dezelfde structuren.
We ontwikkelen Aas­blazer verder als super radix, terwijl we aas a blijven substi­tueren, en nieuwe regels afpassen op de super­machten. Zo zullen we auto­matische sjablonen vormen voor de struc­turen van Bellen­blazer, die bel b invoegt, maar geen rare andere regels toepast. En wat compu­teerbaar is, is in hogere zin weer recursief…!
Maar voorlopig gaan we met behulp van (de maximale structuren van) onze minimale functie een maximale getallen­blaas­machine ijken.

Lastig is nu nog om de overgang tussen types recursie te faci­literen. Een nieuwe hogere index n in Aas­blazer zal a^^n tellen bij het output getal. Con­struct *{2} bestaat uit geneste rijen. De nieuwe regel zal de nest­diepte dus ex­panderen, met één ver­dieping per stap, waar­mee we naar con­struct *{3} uit­breiden.
Is de vraag wat de simpelste regel in Aas­blazer is, waarvan de limiet naar de volgende super­macht a^^^ω gaat…?

We gaan een array functie ontwerpen voor grote ge­tallen met simpele, natuur­lijke regels. Dit Bellen­blazer systeem heeft een con­stante aas a>0 en een varia­bele bel b≥0 in de basis. Door de aas her­haald op te tellen bij de bel groeit daar een sub­totaal, waar­mee we afge­telde ite­raties keer op keer nieuw leven inblazen.
Het grote idee van bellen­blazen¹³ is, dat ook zonder substi­tutie van de hele functie (sub­expressies), maar enkel met optellen en substi­tutie van varia­belen (op­laden) een functie maxi­maal kan worden.

Het Bellen­blazer algo­ritme begint met het op­tellen van a.. azen.
Voor de eerste iter in de rij, de factor c van vermenig­vuldiging, staat sep­arator ,[1] die we ook wel := schrijven als , enkele komma.

• [,[1]1]a := [,1]a = [a,]a = [a]a = a
• [b,[1]2]a := [b,2]a = [ba,1]a = [baa]a = aab
• [b,[1]1c]a := [ba,c]a == [ba{1c}]a = a*c1+b

We schuiven b hogerop in de functie en zetten a er­voor in de plaats in de basis. Dit is niet signi­ficant kleiner dan een regel die een kopie van b ver­laadt. Dat kan ook, maar leidt tot verdub­belen, meteen al zonder vermenig­vuldiging. Dit zagen we met Super­plussen in box 2.1 en met Péter's functie en later weer met ons Wiele­waal systeem.

We zullen Bellen­blazer expressies op twee manieren schrijven. Onze uitgeklede array notatie helpt om bere­keningen op te bouwen:
• Strikt volgens de defi­nitie, de bel binnen de array [b,X]a en de aas rechts er­buiten. Bel b tellen we van rechts bij.
• Of zonder functie haken b,X maar met a erin genoemd. We keren een bel ba alvast om ab uit de array vorm.

Na index 2 komt iter d van machts­verheffen, wat vermenig­vuldiging a*.. her­haald. De 3e iter e stapelt machten a^.. als een toren van expo­nenten, te be­ginnen met de hoogste expo­nent. Dit is een bel b, die we met een pop operator \^ boven­op de reeks machten plaatsen.

• [,[2]2d]a := a,[2]1d = 0,[1]a,[2]d = a*a,[2]d == a*..a,[2]1 :d = a**d2 = a^(d+2)
• [b,[3]1e]a {b>0} = [,[2]b,[3]e]a := a**b,[3]e == a**..b,[3]1 :e = a**..b :e1 = a^^e1\^b

De Bellen­blazer rij is een lineaire array functie die Knuth's pijlen ^{n} weer­geeft. We willen dat de iteraties kloppen met deze super­machten, waarbij we iters en al hun indexen (niet alleen de eerste in sub­arrays) af­tellen tot ze leeg 0 zijn en dan opruimen.

Na dit stroeve begin verloopt de evaluatie van Bellen­blazer soms zelfs makke­lijker dan die van super­sterren. De regels van beide sys­temen ver­schillen enigs­zins, maar de­zelfde getallen kunnen we met super pop­sterren of met Bellen­blazer arrays uit­drukken.
Neem twee passages uit de eva­luatie naar een getal a****f3, waar varia­belen met dakjes ^^ staan voor in­middels uit­gewerkte getallen. Popster intro met pop­schuiven == vatten we in Bellen­blazer samen = met de regel voor op­laden van de bel van links.

• a*{4}3f = a+*{3}a*{4}2f == a*{3}a+*{3}a*{4}1f == a^^-a+*{2}a*{3}1+*{3}a*{4}1f = a*{2}a^^-a+*{3}a*{4}1f == a^^a+*{3}a*{4}1f == a*{3}a^^^2+*{3}a*{4}f == a^^^3+*{3}a*{4}f
• [,[4]3f]a := a,[4]2f = ,[3]a,[4]1f == a^^a-,[3]1,[4]1f = ,[2]a^^a-,[4]1f == a^a^^a-,[4]1f = ,[3]a^^a,[4]f == a^^a^^a,[4]f === a^^..a :f2 = a^^^f3

Array systemen voor grote ge­tallen starten we links met kleine ite­raties en bouwen de grotere struc­turen rechts aan. We redu­ceren iters in een expressie l-r van links naar rechts, de grotere later. Series af­komstig van de meest rechtse ite­raties zijn het langst, maar die komen dus pas later in de eva­luatie vol­ledig aan bij de bel.
Voor Bellen­blazer is bepalend dat we iter­atoren links 1Z willen af­tellen en daar­na recht­streeks op­laden met de bel. In de bel moeten we dus steeds aan de rechter kant erbij tellen, wat kortere series a.. alvast naar links duwt, want na opladen komen die het eerst aan de beurt.
Wat links staat is kleiner en evalueren we eerder en blijft links houden. Dit is onze array telvorm.

Maar als we commu­tatief optellen zoals Cantor^f, dan vallen kleinere getallen weg als er rechts een groter on­eindig ge­tal naast staat. Terwijl we ons algo­ritme willen af­stemmen op het blazen van on­eindige azen. Kleinere series ω.. moeten blijven bij­dragen aan het totaal.
Om de uitkomst af te lezen uit de array expressie draaien we een bel bω gewoon ωb om. Zo krijgen onze onein­dige getallen de wis­kundig gang­bare r-l tel­richting, de Cantor telvorm.
Mocht de wis­kunde over­stag gaan en de l-r richting van onze arrays over­nemen (eerst links klein dan rechts groot), dan kan regel B.0. de moge­lijk on­eindige output bw alsnog zo laten.

Definitie Bellen­blazer B.I van de construct *{1} array rij.

• B.0. [bw]a = wb
• B.1. [b,[1]1Z]a = [ba,[1]Z]a
• B.2a. [X,[n]]a = [X]a B.2b. [b,[n],Z]a = [b,Z]a
• B.3. [,[1n]1Z]a = [a,[1n]Z]a
• B.4. [b,[2n]1Z]a = [,[1n]b,[2n]Z]a

Deze regels matchen door = de hele expressie. Onder voor­behoud in B.4. dat {b>0} kunnen ze in elke volg­orde worden toe­gepast.
De lege sep ,[] is hierbij niet nodig, maar zou kunnen weg­vallen met poptellen, zodat a,[]b1 per unit 1 links bijtelt tot b1a.

De primitieve stap met optellen van aas en bel in regel B.1. is een klasse *{0} constructie. Hoofdregel B.3. itereert over elementen ,[n] in de *{1} rij structuur, waar­mee we super­machten uit­drukken. Echte functie recursie met nesten van sub­expressies is on­nodig, want in diep geneste arrays is het opladen van bel b vrijwel maxi­maal.

Hulpregels b.I voor notaties := en samen­vatting in Bellen­blazer.

• b.1. ,[1]1 := ,1
• b.2. [b,Z]a {a∈Z} := b,Z
• b.3. [1b,[2S]1Z]a = [a,[1S]b,[2S]Z]a

In een systeem met binaire code kan aan ge­tallen een 0 vooraf gaan. Andere tekens krijgen een dubbele nul prefix 001{n} met nummer. Leeg getelde elementen worden dan gevolgd door 000 tekens.

Tekens voor evaluatie, vervang de linker expressie door die rechts:

 = Evaluatie van de hele (binnen) expressie.

== Pas voorgaande evaluaties herhaald toe.

`= Herschrijf de eerste l-r match in expressie.

=` Evalueer de match die l-r het eerst eindigt.

 ≡ Is altijd equivalent, maar l-r met voorrang.

?= Werk operaties uit met voorrangsregels.

=! Werk operaties strikt rechts associatief uit.

:= Ga over naar een alternatieve notatie.

=: Keer de evaluatie richting tijdelijk om.

 ≈ Is ruwweg ongeveer gelijk aan.

 ~ Ongeveer gelijk en vars kunnen missen.

≈> Is insignificant groter dan.. ~>

<≈ Is insignificant kleiner dan.. <~

=| Waardes in volgorde van evaluatie.

Formuleren we de eerste rij van Bellen­blazer, de lineaire array, met super­macht operaties.

• [,[1n]1f]a := a,[1n]f = a,[n]a-,[1n]f- = a*{n}a,[1n]f- == a*{n}(..a..) :f: = a*{n1}f1
• [f₀.,[1n_i]f_i..]a :r {f>0} = f₀.+*{n_i}a*{1n_i}f_i.. :r = ..a^{n_i}f_i\*{n_i}.f₀ r:

Links in de array kan de bel vanaf f0=0 beginnen, als deze optelt + bij een element ,[1]f1 dat a her­haald optelt.
Of bel f0>0 vermenig­vuldigt * na her­haald vermenig­vuldigen, als eerst het element ,[2]f1 komt. Dit is nog commu­tatief.
Anders volgt eerst ,[1n1]f1 wat een super­exponent *{n1}b blaast op een toren van ope­raties *{n1}a die we van rechts uit­werken.
Uit de eva­luatie volgt dat elke vol­gende index op de rij ni1>ni een hogere super­macht is. Maar de bel die we op­laden onder een index kan daar­voor ni<ni- gevormd zijn uit hogere super­machten. Dat ligt dan aan de input expressie.

Iedere iteratie is de rechts bijge­telde serie 1.. in de bel weer langer dan daar­voor. Bellen worden naar iters en indexen ver­laden en van links weer afge­teld. Bij on­eindige :ω reeksen van a.. lezen we de output af ω: in Cantor's tel­richting.
Een samengestelde aas zouden we in aan­vang a=nω omkeren. En omega ω is in onze arrays van links oneindig af­telbaar. Omega keer min -{ω}ω afge­teld van omega telt de iter 0 leeg. Hoewel we min - tekens liever achter ge­tallen noteren.
In een successor functie Ω^g zullen we ω opvatten als oneindige unit. Zoals unit 1 de natuur­lijke ge­tallen vanaf 0 telt, zo stamt unit ω af van 1 op een hoger plan.^h

De Bellen­blazer rij geeft de elemen­taire ope­raties en super­machten mooi weer. Dit is onze natuur­lijke lineaire array functie.
Als sub­totaal b opgeladen wordt komt de bel leeg. Vanuit deze situatie moeten we diepere index posities opladen. Om zo'n functie natuurlijk en maximaal te maken voor geneste arrays, is dat mogelijk…?

Hoe dieper de arrays of rijen in een systeem genest zijn, hoe groter de ge­tallen die ermee ge­schreven kunnen worden.
Elke iterator of iter in de top array bevindt zich op het 1e niveau. Die begint met de eerste rij, waar elke sepa­rator of sep een enkel­voudige index heeft, zie §2.5. Steeds als we een iter in Bellen­blazer af­tellen, laden we een grotere bel b op naar de iter die ervoor komt.

Om hogere iteraties in de top array te kunnen noteren, breiden we de sep index uit tot een rij op het 2e niveau. Deze sep array krijgt zelf ook weer hogere indexen, genest op het 3e niveau.
Indexen op elk array niveau kunnen tot rijen ver­lengd worden. Iters en hun indexen tellen we af tot 0 en dan ruimen we een blazer element tijde­lijk weg. Aan de uit­einden van arrays komt een getal, geen sep.

Arrays zijn lexi­caal begrensd: ieder opener haakje [ links heeft een eigen sluiter haakje ] rechts, zie box 1.0. Om bij het begin van een geneste array het einde te vinden is in com­plexe ex­pressies verre van triviaal. Tijdens een scan moeten we het nest niveau op en af­tellen tot we weer een haakje van het ori­ginele niveau tegen­komen.
Ook onder­scheiden we Bird's dimen­sionale ruimtes, zie box 2.4. Wat vereist dat we gelijke arrays her­kennen, omdat we de ruimte er­tussen in blazers niet apart merken.

Bellen­blazer is qua array structuur een tellerij. In de evaluatie van een tellerij komt elke iter op een positie met een eigen index te staan.
Wát de huidige array is en wàt de index array, is relatief en ligt aan de match die de regel maakt. Bij verschillende soorten geneste arrays, de een in de ander, kunnen we het niveau van haakjes wel­licht expliciet aan­geven, zoals posities in blazers altijd hun eigen index krijgen.

We breiden nu de regels voor de eerste rij B.I uit en her­laden de eerste index. Als die index leeg komt, hebben we sub­totaal b zojuist ver­plaatst naar de iter rechts buiten de index array. Het sub­stituut getal zal dus van die iter moeten komen, niet van de nieuwe bel a, omdat de functie anders stokt…ⁱ Echt grotere getallen zouden dan niet snel van de grond komen.

De eerste index geeft de iter positie aan in de meest rechtse rij. De tweede index telt de rijen af in de twee-dimensionale ruimte. Binnen een matrix geeft die index het aantal rijen in het rechtse vlak.
De hele index rij beslaat de multi-dimensionale ruimte of matrix. In de eerste sub­index ,[d]p op het derde niveau lezen we het getal van de dimensie. Index p is het aantal dim d ruimtes, dat onder­deel is van de meest rechtse dim d1 ruimte.

De twee-dimensionale ruimte begint dus na de sub­index ,[1] die we hier af zullen korten tot , enkele komma.
We werken recursies over de twee indexen van het array vlak onder uit. De regels zijn: sep­arator elim­inatie (sep elim), bel en begin index intro­ductie (bel intro) en element intro­ductie (elem intro).

Definitie Bellen­blazer B.II specifiek voor het array vlak.

• B.0. B.1.
• B.2. ,[S]0 ≡ 0
• B.3a. [,[1S]1Z]a = [a,[1S]Z]a
• B.3b. ,[,1n]b ≡ ,[b,n]a
• B.4a. [b,[1n]1Z]a {n>0} = [,[n]b,[1n]Z]a
• B.4b. [b,[1,n]1Z]a {n>0} = [,[,n]b,[1,n]Z]a

De aas a staat steeds rechts van de top array. Hier is variabele b>0 en constante a>1, maar door­gaans is bel b>a veel groter.
Equi­valentie ≡ werkt overal in de expressie, met voor­rang op andere regels. Voor­alsnog kan na elke eva­luatie een­duidig worden bepaald, welke regel daarna komt.

Bij het overladen van de bel had anders een kopie gebruikt kunnen worden, terwijl de origi­nele b in de array er­boven of in de basis al zou blijven staan. Maar we vinden het mooi als grote bellen b stap voor stap groeien, zolang het kan. Daarom ver­vangt regel B.3b. hier de zojuist opge­laden iter b door aas a.
Regel B.4b. telt de eerste index in ,[1,1n] af en ver­schuift een bel naar ,[,1n]b de nieuwe iter. Daarna kan regel B.3b. de oude bel inladen ,[b,n]a in de index array. Dan pas laadt B.3a. de nieuwe basis bel a, om ver­volgens in tandem met regel B.4a. de array van rechts naar links met een nieuwe rij elementen ,[i,n]a op te vullen.

Hier ontwikkelen we Bellen­blazer over de tweede dimensie, met rijen in het array vlak. Net zo lang als er verge­lijkbare expressies zijn in het systeem voor grote getallen van de wis­kundige John H. Conway.
Conway's pijlketen¹⁵ [Conway's chained arrows] is een recur­sieve functie, die getallen ver voorbij de Ackermann functie noteert.
Conway bedacht zijn pijl­keten als vervolg op Knuth's pijlen ↑.. ofwel ^.. super­machten. Conway's pijlen → spelen de rol van komma's in een array functie.

Vanaf super­machten a↑{c}b = a→b→c bouwt Conway verder aan zijn hyper­macht functie, waar met elke vol­gende pijl →z een dubbele re­cursie (over de hele ex­pressie) wordt genest in y.
Conway lost zijn keten van de rechter zijde op, zonder de voor­laatste para­meter y=1 opnieuw te laden. De laatste para­meter →1 ≡ 0 of de laatste twee →1→z ≡ 0 vallen weg, zodra z of y zijn afge­teld.

Stapsgewijze definitie C.I van Conway's pijlen.

• a→b = a↑b
• X→1→z = X
• X→1 = X
• X→y1→z1 = X→(X→y→z1)→z == X→(..X..)→z :y:

Een getal herhalen a.. is vermenigvuldigen, primi­tieve recursie. Die operatie herhalen geeft ↑ een macht. En zo, door operaties meerdere keren te herhalen ↑.. krijgen we supermachten: dubbele recursie.
Bij herhaling zet z in y nu een dubbele recursie in over de hele keten, tot de binnenste y is afge­teld. Over de hele lengte van de pijl­keten vormt dit de volgende hogere functie, een tripel recursie.

Voorbij supermachten liggen de gebieden van de hyper­machten en de snel groeiende hier­archie. Dit zijn vage historische aan­duidingen voor functies, waar Conway's pijl­functie con­crete grenzen heeft.
We zullen het begrip hyper invullen zoals Bird¹⁶. In het verlengde van zijn ene multi-dimensionale index drukt hij de hyper-dimensies uit met een rij indexen. Zo volgt bij Conway na de super­machten c een rij para­meters, die elk dezelfde re­cursie toe­passen op de hele expressie. Conway's pijl­keten is dus de hyper­macht functie bij uitstek.

Graham's getal uit §2.2 wordt met [6,[1,1]64]3 bena­derd ≈> via het nesten van super­sterren in het derde item. Want de dominante super­macht 3*{6}2 = 3↑↑↑↑3 vormt de top van een toren van 63 dubbele recursies.
Ook is [6,[1,1]64]2 mini­maal kleiner <≈ dan Graham's getal. En met a=4 is die ex­pressie al veel > groter. Maar meestal nemen we het niet zo aas nauw met onze mini­maal groter ≈> bena­deringen.

De vergelijkingen beginnen met dubbele recursie, het trio in Conway's pijl­keten. We refereren naar de eerste rij formule van Bellen­blazer.

• [b,[1,[1]1]1]a := [,[,1]b]a = [,[b]a]a = a*{b}a = a→a→b- = a→2→b
• [,[2]b,[1,1]1]a := a**b,[1,1]1 = a*{a^b}a ≈ a→b→2→2 {a≈b}
• [b,[1,1]1c]a = [,[,1]b,[1,1]c]a := a*{b}a,[1,1]c = a*{a*{b}a}a,[1,1]c- = a*{..a*{b}a..}a :c: ≈> a→b→(..a↑b..) :c: = a→b→c1→2
• [1b,[2,1]1c]a := a,[1,1]b,[2,1]c = a*{..a..}a.,[2,1]c :b: ≈> a→a→b→2,[2,1]c ≈> a→a→(..b..)→2 :c1: ≈> a→b1→c1→3
• [1b,[1d,1]1c]a := a,[d,1]b,[1d,1]c ≈> a→a→b→d1,[1d,1]c ≈> a→a→(..b..)→d1 :c1: ≈> a→b1→c1→d2

Op zich drukte de Bellen­blazer rij met zijn 1e index super­machten uit, ongeveer ≈ als een pijl­keten met 3 para­meters.
Op de tweede rij met seps ,[d,1] houdt die index d- gelijke tred met Conway's 4e para­meter, als die de laatste in de keten is.

Evalueer Bellen­blazer's 2e index in verge­lijking met de hele pijl­keten van Conway. Met e rijen in het vlak is iter index d ongeveer gelijk aan a→..d1 :e2 Conway's laatste para­meter z (en gelijker nog met een pijl­keten variant, die z zou af­tellen tot 0 in plaats van 1).

• [b,[1,[1]2]1]a := [,[,2]b]a := ,[b,1]a = a,[b,1]a- ≈> a→a→a-→b1
• [b,[1,2]1c]a := ,[b,1]a,[1,2]c ≈> a→a→a→b,[1,2]c ≈> a→a→b→2→2,[1,2]c- ≈> a→a→b→c1→2
• [1b,[1d,2]1c]a := a,[d,2]b,[1d,2]c ≈> a→a→a→b→d1,[1d,2]c ≈> a→a→b1→c1→d2
• [b,[1,3]1c]a := a,[b,2]a-,[1,3]c ≈> a→a→a→a→b,[1,3]c ≈> a→a→a→b→c1→2
• [b,[d,3]c]a ≈> a→a→a→b→c→d1
• [b,[1,e]1]a ≈> a→..b :e1>2
• [b,[d,e]c]a ≈> a→..b→c→d1 :e>0

Met index e maken we in Bellen­blazer de sprong over de hele keten van Conway. Die tweede index is even krachtig als Bird's 4e element [entry]. Check zelf het bewijs¹⁷ van Chris Bird, dat dit getallen in de orde van Conway's pijl­keten functie betreft…!

Bird's formule voor Conway's pijl­keten versus de Bellen­blazer formule met twee indexen, die onze dim 2 array ruimte met rijen van iters vult.

{a,b+1,c,d+1} {a>2,b>0,d>0}
   ≈> a→..b→c1 :d1 <≈
[1b,[1c,d]1]a := a,[c,d]b

Doordat we indexen in Bellen­blazer aftellen tot 0 loopt onze d hier 1 voor op Bird's para­meter waarde. De Bellen­blazer rij was trager, dus begint deze index array 2 posities verder.
In box 2.6 zagen we, dat door complete index­ering de oneven array niveau's in Bellen­blazer functio­neren als sepa­rator her­haling in Bird's array ruimtes. Dat begint op ons 1e of top niveau. De factor 2 niveau verschil van geneste arrays blijft onze grootste achterstand op Bird.

Welke formule Conway's pijl­keten het dichtste benadert…? Voor het ver­volg is dit onbelang­rijk. Maar doe onze demon­stratie over en druk Bird's functie uit in Bellen­blazer…!

De matrix of multi­dimensionale array van Bellen­blazer bestaat uit twee rij niveau's met iteraties. Sub­indexen op het derde niveau geven dimensies of dims aan, die het onder­scheid maken tussen indexen.
Vorig blog beperkte zich tot B.II het array vlak, de 2e dimensie. De volledige definitie van geneste arrays B.IV komt in volgend blog. En hier geven we de speci­fieke regels om Bellen­blazer expressies uit te werken tot het tweede niveau van geneste arrays.

De linker term bij evaluaties `= en =` in de lijst zoeken we l-r in de expressie. We ver­vangen dat deel door de rechter term. Bij teken `= voeren we de regel uit, die het eerste links in de expressie een match geeft: als in een regex¹⁹ scan.
Met onze rij regex [rowex™] scan selecteren we =` een term die het eerst eindigt in de tekst. Van de match met de meest linkse eind positie voeren we de regel met voorrang uit. Wanneer de match arrays over­lappen, krijgt het binnenste element dus de beurt.

Definitie Bellen­blazer B.III voor multi­dimensionale arrays.

• B.0. B.1. B.2.
• B.3a. [,[1S]1Z]a =` [a,[1S]Z]a
• B.3b. [,[1n]1S]b ≡ [b,[1n]S]a
• B.4a. [b,[2m]1 =` [,[1m]b,[2m]
• B.4b. [b,[1n,1S]1 `= [,[n,1S]b,[1n,1S]

Variabelen zijn altijd gretig naar enen, zodat rechts van een geslaagde match Yp geen getal meer voor­komt in de expressie XYpZ. Sec in woorden in regels kloppen alle haakjes, met name in S hier.
Vertaal de eerste index sep ,[1]1S := ,1S met hulpregel b.1.
In regel B.3a. staat S>0 òf voor de rij lengte 1n óf voor een deel 1n,1R met de rechter lengtes van de dimensies. Het geval S=0 valt onder optel­regel B.1. uit de definitie van de eerste rij.

Regel B.4a. ver­plaatst b in de top array of over de index rij.
In een expressie [,[1b,[2]1]a]a ver­liest regel B.3a. zijn match aan regels B.4a. en B.3b. die voorrang =` krijgen. Zo vullen we de binnenste array eerst [,[a,b]a]a en wordt a inge­laden (en niet a- na aftelling).
Tot nog toe kwam het goed uit door bij elke regel `= de eerste term links te nemen. Bij de dimen­sionale arrays begint dat al te wringen, maar bij geneste arrays is een definitie zonder linkse =` eind match proble­matisch, om­dat een getal (zo groot als) bel b niet (zo makkelijk) genest kan worden in diepere sub­arrays.

Tegelijk bouwen we een natuurlijk ver­volg voor Conway's en Knuth's pijlen. Dat kan erg^o in de soep^p draaien, dus voor­zichtig!
Hier herhaalt de extra super­pijl ↑ de voor­gaande operatie net als bij Knuth rechts associa­tief. Op deze super­operator volgt weer een rij met → para­meters, die we eva­lueren als in Conway's pijl­functie.

• x→↑1! ≡ x
• x→↑y1 =! x→x→↑y == x→..x :y
• X→↑y1→z1 = X→↑(X→↑y→z1)→z == X→↑(..X..)→z :y:

Met 1! in de eerste regel schieten we op X→↑1→Z = X en tegelijk op X→↑1 = X die beide met para­meters 1 matchen.
De tweede regel voegt vanaf rechts =! de Conway schakel x→ in en laat de ope­ratie x→↑y aan het einde staan. Her­haling ervan == smeedt die schakels aan elkaar tot een nieuwe pijlketen.

Hier is deel X nog alleen de para­meter a, terwijl we Conway schakels →zi toevoegen. Elke zi voert een nieuwe dubbele recursie uit, eerst →z1 dus over de lengte van Conway's pijl­keten zelf.
De eerste Bellen­blazer index staat voor de laatste dubbele recur­sie van Knuth en de tweede index voor de tripele recur­sie van Conway. Refereer voor deze twee indexen naar de dim 2 formule.

• [b,[1,[1]1,[2]1]1]a 4b 2 := [,[,1,[2]1]b]a 3b 2 = [,[b,[2]1]a]a 4a 2 =` [,[,b]a]a 3b 3a := a,[a,b-]a- ≈> a→..a-→a1 :b ≈> a→↑b2
• [b,[1,1,[2]1]1c]a := ,[b,[2]1]a,["]c ≈> a→↑b2,["]c ≈> a→↑(..b2..) :c1: ≈> a→↑c2→2 {a=b}
• [b,[2,1,[2]1]1c]a := a,[1,1,[2]1]b-,["]c ≈> a→↑b→2,["]c ≈> a→↑(..b..)→2 :c1: = a→↑c2→3 {a=b}
• [b,[d,1,[2]1]1c]a := a,[-"]b-,["]c ≈> a→↑b→d,["]c ≈> a→↑c2→d1 {a=b}

Het is handig om eerder genoemde sub­arrays niet te hoeven noteren in de verdere uit­werking. We kunnen index arrays aangeven met een quote ["] om een array [1X] uit de vorige lijn aan te halen. En een minus [-"] links om die [X] af te tellen. Zoals altijd moet ook zonder kleuring duidelijk zijn welke array is bedoeld.

Bouw een nieuwe Conway keten met → dubbele recursies (type 2). Tel daar de lengte van met →↑ de volgende tripel recursie (type 3).

• [b,[1,[1]2,[2]1]1c]a := [,[,2,[2]1]b,["]c]a := a,[b,1,[2]1]a-,["]c ≈> a→↑a→b1,["]c ≈> a→↑a→(..b1..) :c1: ≈> a→↑b→c1→2
• [1b,[d,2,[2]1]1c]a := a,[-"]b,["]c ≈> a→↑a→b→d,["]c ≈> a→↑a→(..b..)→d :c1: ≈> a→↑b1→c1→d1
• [b,[1,3,[2]1]1c]a := ,[,3,[2]1]b,["]c = a,[b,2,[2]1]a-,["]c ≈> a→↑a→a-→b1,["]c ≈> a→↑a→a→(..b..) :c1: ≈> a→↑a→b→c1→2
• [b,[d,3,[2]1]1c]a := ,[-"]b,["]c ≈> a→↑a→a→b-→d,["]c ≈> a→↑a→b→c1→d1
• [b,[1,1e,[2]1]c]a ≈> a→↑.ab→..c→2 :e
• [b,[d,1e,[2]1]c]a ≈> a→↑.ab→..c→d1 :e ≈> a→↑a→↑e2 {a=b=c=d1}

Bij gelijke para­meters a→..a zetten we de hele serie precies naar de volgende recursie a→↑ om. Anders is de Conway super­exponent rechts domi­nant en kan die de eerdere para­meters ≈ repre­senteren.

Met de 2e index in Bellen­blazer bouwden we een Conway keten. Dan zal de 3e index een serie tripel recursies a→↑.. vormen. Laat deze index ,[2]f verder toe­nemen, functie rij na functie rij. Tot we ook daar weer over kunnen →↑↑ itereren.

• [1b,[1,[1]1,[2]2]1]a := ,[1b,[2]2]a = a,[a,b,[2]1]a- ≈> a→↑.a→..a :b = a→↑a→↑b1
• [1b,[2,1,[2]2]1]a := a,[1,1,[2]2]b ≈> a→↑a→↑a,["]b- ≈> a→↑a→↑(..a..) :b: ≈> a→↑a→↑b→2
• [b,[1,2,[2]2]1]a := a,[b,1,[2]2]a- ≈> a→↑a→↑a-→b1
• [1b,[1,1,[2]3]1]a := ,[a,b,[2]2]a =: a,[1a,b,[2]2]1 ≈> a→↑a→↑.a→..a :b = a→↑a→↑a→↑b1
• [1b,[1,1,[3]1]1]a := ,[1b,[3]1]a = ,[a,[2]b]a =: a,[1a,a-,[2]b-]1 ≈> a→↑..a :b = a→↑↑b1

Zo definieert de super­schakel →↑↑ een type 4 recursie. Dit verhoudt zich tot Conway's pijl­keten, zoals diens lengte staat tot super­machten. Of zoals de Acker­mann functie staat tot vermenig­vuldigen. Kortom, zulke getallen zijn ver!

In het algemeen geven operaties →↑{n} het recursie type aan, van een functie die bestaat uit een rij vorige re­cursies. De ope­rator heeft een Conway schakel → met een aantal ↑.. Knuth pijlen erop.
Dat aantal :n bepaalt het type n2 van de recursie, waar­mee we een rij groot­machten van het type n1 stapelen.

Evalueer de Conway-Knuth super­pijlen strikt =! rechts associatief.

• x→↑{n}1 =! x
• x→↑{n1}y1 =! x→↑{n}x→↑{n1}y == x→↑{n}..x :y

We maken hieraan steeds ketens X→y→z vast, die we gewoon met de definitie C.I van Conway's pijlen eva­lueren. Ver­volgens drukken we ketens uit met super­schakels… Dit alles blijkt wonder­lijk precies te passen bij de matrix expansie van Bellen­blazer…!

• [1b,[1,[1]1,[2]1,[3]1]1]a := ,[1b,[2]1,[3]1]a =: a,[1a,b,[3]1]1 ≈> a→↑↑.a→..a :b = a→↑↑a→↑b1
• [1b,[1,1,[2]2,[3]1]1]a := ,[a,b,[2]1,[3]1]a ≈> a→↑↑a→↑a.→a.. :b = a→↑↑a→↑a→↑b1
• [1b,[1,1,[3]2]1]a := ,[1b,[3]2]a = ,[a,[2]b,[3]1]a ≈> a→↑↑a.→↑a.. :b = a→↑↑a→↑↑b1
• [1b,[1,1,[4]1]1]a := ,[1b,[4]1]a = ,[a,[2]a-,[3]b-]a ≈> a→↑↑..a :b = a→↑↑↑b1
• [b,[1,1,[1n]1]1]a := ,[,[n]b]a ≈> a→↑{n-}..1 :b = a→↑{n}b

De eerste rij op het 2e niveau van Bellen­blazer arrays, loopt gelijk met de recur­sieve super­pijlen. Dit vol­tooit de multi­dimensionale ruimte van Bellen­blazer arrays, waarin elke positie een unieke index heeft. De grootte van de getallen die we hier­mee schrijven, is gelijk aan die van Bird's lineaire arrays.¹⁸
Dat concludeerden we uit de matrix van Btrix in box 2.6 en zullen we later in blog §3.1 nog eens demon­streren door onze Wielewaal tel­lerij (denk Bellen­blazer) met het Vogel tel­raam (denk Bird) te vergelijken.

Bellen­blazer expressie [,[,[n]b]a]a met dim n1 is een type n2 recursie. Net als de →↑{n} super­pijlen, die we uit­werken tot een rij van type n1 recursies met b parameters.
Hogere functies blazen het aantal dimensies direkt op en over­stijgen het huidige recursie plafond. Een tweede recursie type index is nodig, daarna een 3e index, index rij type recursies, vlak type, etcetera.
Uiteindelijk loopt zo'n typering van recursies nog maar weinig achter bij die van arrays. Want dit verschil zal bij dieper nesten insigni­ficanter worden. We houden op om hogere recursies of dimensies te index­eren en laten geneste Bellen­blazer arrays verder voor zich spreken.

Conway's recursie → voegt de in y afge­telde expressie steeds op de voor­laatste positie in. We kunnen een hyper­pijl a→→b tot de super­pijl →↑ reduceren die Conway's pijl­keten is.
Maar kunnen we zo ook super­pijlen a→↑{c}b maken…?

• a→→b→1 = a→→b = a→↑b == a→..1 :b
• a→→1→c = a
• a→→2→2 = a→→a = a→↑a =: a→↑a→↑↑1 =: a→↑↑2

Stel dat X→→2→2 gelijk is aan X→↑(X) dan is dat voor ketens X>x groter dan X→↑↑2 en loopt dit voorstel in de soep.
Conway's substitutie in de voor­laatste para­meter, die na onze extensie met Knuth pijlen →↑{m} zo goed werkt, laat het hier afweten. Want stel dat a→→3→2 reduceert tot a→→(a→→a) en a→↑(a→↑a) dan is dat kleiner dan de a→↑a→↑a die we uit a→↑↑3 herleiden.

Nog wat frutsels in dit verband, die de lezer een idee moeten geven, hoe dit soort natuurlijke systemen na rijp beraad tot stand komen…

• a→b1→2 = a↑a→b→2 == a↑..a→1→2 :b = a↑..a :b = a↑↑b1
• a→b1→2 = a↑a→b1→1 = a↑a→b1 = a↑(a↑a→b) == a↑(..a↑a→1..) :b = a↑(..a..) :b1 = a↑↑b1
• a→b→2 = a↑→b→1 = a↑→b = a↑↑b

En wie X→→y→→z tot X→↑{z}y reduceert, die gebruikt twee hyper operaties in plaats van één.
Dus hoe krijgen we a→→b→2 =! a→↑↑b wèl voor elkaar, mooi zuinig en staps­gewijs, met een regel voor hyper­pijlen…? Of zal deze formule in de (rechts associa­tieve) context van Conway-Knuth pijlen altijd ergens mis lopen en moeten we hyper opera­toren indexeren…?

Vorig blog §2.7 werkten we de eerste geneste rij in Bellen­blazer uit en vulden de n-dimensionale array ruimte. In deze dubbele array is elke iter voor­zien van een eigen unieke index.
Nu betreden we de hyper­dimensie met een dieper geneste rij van het derde niveau, afge­teld over een vierde niveau lengte index. Deze rij in matrix dimensie ver­diepen we later zelf tot een matrix. Zo door­gaand vormt dit de geneste arrays, die we hier alvast definiëren.

De regels, die arrays met indexen genest in indexen eva­lueren, blijven het­zelfde. En in Bellen­blazer is elke kind array uniek lid van zijn ouder array, her­haling is daar over­bodig. Deze structuur heet een com­plete index­ering. Maar dan moeten Bellen­blazer arrays voor gelijke out­put twee keer zo diep worden genest als de array ruimtes van Bird.¹⁴ Zie ook googo­logie box 2.6.

Variabele a is steeds de aas constante, die we van rechts buiten de array in­laden. Vars matchen werkt gretig, zodat er direkt na p in de expressie voor regel B.3. geen getal unit meer kan komen.
Tijdens de evaluatie krijgt variabele p=|b,a eerst bel b op bezoek en is ver­volgens alleen nog a in die regel. Hoewel een input expressie kan verrassen met andere waardes voor p op die plek.

Bellen­blazer B.IV con­struct *{2} geneste arrays.

• B.0. [bw]a = wb (uitlaad)
• B.1. [b,[1]1Z]a := [b,1Z]a = [ba,Z]a (belaad)
• B.2. ,[S]0 ≡ 0 (ontlaad)
• B.3. [,[1S]1T]p =` [p,[1S]T]a (inlaad)
• B.4. [p,[1S]1 {S>0} =` [,[S]p,[1S] (oplaad)

Als we regel B.4. in de top array gebruiken, dan schuift bel b naar rechts om een nieuwe iteratie op te laden. Is de index array klaar, dan begint de lege bel per regel B.3. met een kopie van aas a.
Maar soms kreeg de nieuwe sep array ,[,S]b een positie index 0. Dan moet de geneste array eerst worden aan­gevuld. De bel moet uit de iter ,[,[1S]1T]b worden over­geladen ,[S]b naar de hoogste lege index vanaf links, want dat is de enige manier om de sub­array te maxima­liseren. Eerst laden we de iter b per regel B.3. in zijn eerste index en daarna schuiven we b even­tueel door per regel B.4. naar de lege index die opge­laden moet worden.
De iter in regel B.3. wordt direkt vervangen door aas a. Soms zullen we steeds verder af­dalen: in een cascade van azen, met onderaan de bel, op weg naar de diepste index­loze array. We passen deze regels toe vanaf de eerste match die =` links eindigt. Zo klopt steeds, dat de origi­nele bel b per regel B.4. als iter van de sub­array is ge­laden, vlak voor­dat daar de nood­zaak ont­staat om een index op te laden.

De methode om de bel van de iter naar de hoogste lege index over te laden, beweegt in een cascade omlaag door geneste arrays. Of­schoon het wel een eeuwigheid duurt om de ver­vangen iters a weer minstens op peil b te krijgen, toch kost dit minder dan 1 tel bij b.
Want stel dat we de eerste index b1 maken en de aas iter 2. Tel die af tot 1, dan krijgen we links ervan ons eigen element. Dit element zal compleet reduceren tot een nieuwe bel b' groter dan de oude bel. Die is zeker groter, omdat de uitge­werkte index array zelf b bevat. Tel de iter nog eens af en de hogere index array vervalt. Een grotere b' laadt dan op als iter van het bedoelde element.
En dit volgt in het ongun­stigste geval, met eerste index b en aas a=2. Bij elke andere index en/of grotere a groeit ons eigen ele­ment met iter b' nave­nant groter. Wat bewijst, dat het opwaar­deren van regel B.3. zodat die bel b overal substi­tueert (in de index laadt, maar ook in de iter laat), minder pre­steert dan 1 op­tellen bij b. Toch is ook die extra tel in ons geneste systeem insigni­ficant.∴

Door de lege bel en iters in de cascade van de regels B.4. en B.3. op­nieuw te vullen met aas a, komen er natuurlijker grote getallen tot stand, dan door overal een kopie van b te laden. Dat goldt ook al voor machten en bij de super­machten op de eerste rij van §2.5.
Met de tweede index op het 3e niveau nemen we de oplaad & inlaad cascade in gebruik. Tegelijk komen boven­op de hyper­pijl →→ een serie Conway pijlen → met para­meters, om recursief het aantal dimensies weer te geven van Bellen­blazer.

• 4 2 3 2 4 2 3 2 §2.7 [b,[1,[1]1,[1,[1]1]1]1]a := [,[,1,[1,1]1]b]a := ,[b,[1,1]1]a =` ,[,[,1]b]a = ,[,[b]a]a ≈> a→↑{b}a = a→→a→b
• [1b,[2,1,[1,1]1]1]a := a,[1,1,[1,1]1]b ≈> a→→a→a,["]b- ≈> a→→a→(..a..) :b ≈> a→→a→b→2
• [1b,[1c,1,[1,1]1]1]a := a,[c,1,[1,1]1]b =: a,["]1,["]b- ≈> a→→a→a-→c,["]b- ≈> a→→a→(..a..)-→c :b ≈> a→→a→b→c1

Steeds voegt de 1e index een rij toe, met lengte c. We verge­lijken dit met de vol­gende Conway → schakel rechts, zodat duide­lijk wordt, dat dit een dubbele recursie blijft, maar voor­taan over hyper-dimensies.

Daarna vormt de 2e index weer een vlak van rijen, net als in §2.6. Die verge­lijken we met de hele pijl­keten lengte, de tripel recursie die een Conway-Knuth pijl →↑ rechts laat noteren.
We voeren een aantal regels tege­lijk uit, eerstens bijv. 4 2 3 3 uit de Bellen­blazer defi­nitie, en verge­lijken dan met een eerder resultaat.

• [b,[1,2,[1,1]1]1]a := ,[b,1,[1,1]1]a ≈> a→→a→a→b
• [1b,[2,2,[1,1]1]1]a := ,[a,1,[1,1]1]a,[-"]b- ≈> a→→a→a→a,[-"]b- ≈> a→→a→a→b→2
• [1b,[1c,2,[1,1]1]1]a := ,[--"]a,[-"]b- =: a,[-"]1,[-"]b- ≈> a→→a→a→a-→c,[-"]b- ≈> a→→a→a→b→c1
• [b,[1,d,[1,1]1]1]a ≈> a→→.a→..b :d
• [1b,[c,d,[1,1]1]1]a ≈> a→→.a→..b→c :d = a→→a→↑d2 {a=b=c}

In onze notatie kunnen we met quotes ["] of ['] een eerdere array aan­halen. Het origineel staat dan in de lijn erboven of anders rechts in de expressie zelf. Dit helpt ons schrijf­ruimte besparen.
We kunnen gequote index arrays [-"] af­tellen met min tekens. Om daarna de eerste index nog eens [--"] af te tellen.

De indexen ,[m] noteren dimensies, hier van een dubbele matrix. Het element ,[1,1]b gene­reert bel­lachelijk veel matrixen. Waar­bij elke super-matrix het aantal dimensies aan­geeft van de matrix ervoor.

Steeds herleiden we uit een eerder eva­luatie patroon de alge­menere evaluaties. Bijv. hier nemen we de uit­werking in het tweede item over uit §2.7 uit een con­clusie. Veri­fieer dat dat patroon met §2.7 in het eerste item niet precies klopt, omdat na de hyper de eerste pijl →a als 1 extra telt bij →↑b, wat wel volgt uit de demonstratie…

• [b,[1,1,[2]1,[1,1]1]1]a := ,[a,b-,[1,1]1]a ≈> a→→a→↑b1
• [1b,[1,1,[3]1,[1,1]1]1]a ≈> a→→.a→↑..a :b = a→→a→↑↑b1
• [b,[1,1,[4]1,[1,1]1]1]a ≈> a→→a→↑↑↑b
• [b,[1,1,[1,1]2]1]a := ,[a,[b]a-,["]1]a =: a,[1,1,[1b]1,["]1]1 ≈> a→→a→↑{b}a = a→→a→→a→b
• [1b,[1,1,[2,1]1]1]a := ,[a,["]b]a =: a,[1,1,["]b]1 ≈> a→→..a→a :b ≈> a→→↑b1

Een index array ,[1,1,[1,1]1,2] in het laatste item zou precies zo uit­werken. Maar de evaluatie trein in Bellen­blazer produ­ceert zo'n tweede rij met (binnen de ouder array) her­haalde ,[1] nooit, niet in de top array en niet in sub­arrays. Regel B.4. maakt elke index links kleiner. Deze geordende structuur verschilt van Bird's ruimtes.
We hoeven dus alleen de tweede rij ,[i,1]pi.. in onze verge­lijking te be­trekken. Bij sub­element ,[1,2]1 bouwen we die straks aan, met een lengte :b van de bel.

Zowel index vorm [a,[m]b als de pijl operatie →↑{m}b1 stapelen een rij van b recursies van type m1. Met ,[1,1]2 geeft dat twee →→ hyper­pijlen en bij ,[1,1]b de herhaling →→↑ ervan.
We verspillen zo een hoop opera­toren helaas, omdat getallen links in Bellen­blazer arrays na hyper­pijlen →→ rechts komen te staan. Zonder her­laden valt elke 1→Z weg en dat maakt de pijl­functies lang­zamer, in Bellen­blazer kan y=1 op­nieuw mee­doen met de ge­blazen bel.

We hebben nu genoeg voor­beelden gezien, om de alge­mene defi­nitie van dit soort →{n}↑{m} pijl­functies te geven. We noemen ze:
Conway-Knuth hyper-recursieve pijlen
Zulke getallen zijn verschrik­kelijk groot ja. En we raken hier pas aan het begin van Bellen­blazer en Bird's hyper-dimensionale arrays.¹⁶

In deze duale operator houden we de Conway hyper­pijlen →.. links en de Knuth super­pijlen ↑.. rechts gescheiden. Alleen de tussen­stap in de reductie van hyper­pijlen wijkt even van dit plan af.
Onze definitie gebruikt de volgende kaart sym­bolen. Pas het formaat en de stijl ervan aan door op de box te klikken [voor mobiel].

• ♥ ≡ →{n}↑{m} {m>0||n>0}
• ♠ ≡ →{n}↑{m} {n=1||m>0}

Conway's recursie wordt met ♠ beperkt, zodat de hypers →{n>1} zonder supers (uit ♥) niet onder zijn regel vallen. En hoewel we er geen bezwaar in zien, komen super­pijlen x↑{m}y→z vanzelf niet zo voor in de evaluatie trein.

Definitie C.II van recursie met Conway-Knuth Hyperpijlen.

• y*z ≡ y.. :z
• y♥1 =! y (init z)
• y↑z1 =! y*y↑z (macht) == y*..y :z
• y♥↑z1 (Knuth pijlen) =! y♥y♥↑z == y♥..y :z
• ♥1♥z =! 0 (init y)
• X♠y1→z1 (Conway pijlen) = X♠(X♠y→z1)→z == X♠(..X..)→z :y:
• x→y = x↑y
• ♥→z =! ♥↑z (pijl init)
• ♥→y→z1 (Hyper pijlen) =! ♥↑→y→z == ♥↑{z}→y→1 =! ♥↑{z1}y

De evaluatie links van sub­array ,[2,1] nemen we over van eerdere ,[1,1] uit­werkingen. Bellen­blazer voegt met dimensie index ,[m] eerst extra supers ↑{m} toe, die samen hypers →→ vormen.
Het inladen van bel b naar diepere niveau's ,[b] in Bellen­blazer zal de vaart erin houden bij het maken van grote getallen.

• [1b,[2,1,[2,1]1]1]a := a,[1,1,[2,1]1]b = a→→↑a,["]b- ≈> a→→↑(..a..) :b: = a→→↑b1→2
• [b,[1,2,[2,1]1]1]a := ,[b,1,[2,1]1]a ≈> a→→↑a→a→b
• [b,[1,1,[2]1,[2,1]1]1]a := ,[a,b-,[2,1]1]a ≈> a→→↑a→↑b
• [b,[1,1,[3]1,[2,1]1]1]a ≈> a→→↑a→↑↑b
• [b,[1,1,[1,1]1,[2,1]1]1]a := ,[,[b]a,["]1]a =: a,[1,1,[1b]1,["]1]1 ≈> a→→↑a→↑{b}a = a→→↑a→→a→b
• [b,[1,1,[2,1]2]1]a ≈> a→→↑a→→↑b

Uit element ,[2,1]c komt links een rij indexen p0.,[i]pi.. met lengte :b die de lengte :b' bepaalt voor de latere rij indexen.
Het evaluatie patroon is nu helder en het einde van het stapelen met alleen → en ↑ pijlen komt in zicht, bij de 1e hyper index in m,[1]n op het 3e rij niveau in Bellen­blazer.

• [b,[1,1,[3,1]1]1]a ≈> a→→↑↑b
• [b,[1,1,[1,2]1]1]a =: a,[1,1,[1b,1]1]1 ≈> a→→↑{b}a = a→→→a→b
• [1b,[1,1,[2,2]1]1]a =: a,[1,1,[1,2]b]1 ≈> a→→→..a→a :b ≈> a→→→↑b1
• [b,[1,1,[1,3]1]1]a =: a,[1,1,[1b,2]1]1 ≈> a→→→↑{b}a = a→→→→a→b
• [b,[1,1,[1,1,[2]1]1]1]a := ,[,[,b]a]a =: a,[1,1,[1,b]1]1 ≈> a→{b}↑{a}a = a→{b1}a→a

Uit deze patro­nen leiden we een formule met meer­dere para­meters af. Wat naar links in de expressie staat doet er rela­tief min­der toe en een iter is minder signi­ficant dan zijn index array.

[b,[d,e,[m,n]f]c]a
 ≈> abcde→{n1}↑{m}f
  = abcde→{n2}f→m

Twee maten bepalen de duale pijlen: het aan­tal van Conway →{n} hypers en Knuth ↑{m} supers. Deze komen over­een met de twee indexen m,[1]n van de dimensie m en de eerste hyper­dimensie n in Bellen­blazer.
Om hogere Bellen­blazer indexen weer te geven zal de struc­tuur en het algo­ritme van de hyper­pijl functie verder moeten expanderen. Het draait er toch op uit, waarom niet meteen de overgang maken om Knuth indexen op Conway pijlen te noteren als arrays?

We zouden de Conway-Knuth definitie ook op kunnen zetten als een gemengde ♦ pijlen­mix →↑{mi}.. met :n1 maten mi in serie. Dat verge­lijkt met de hyper-indexen [m0.,[i]mi..] :n in Bellen­blazer.
Zulke hyper­pijlen stapelen al de vorige functies boven­op de volgende operator. Net zoals we in Bellen­blazer bel b af­leiden van de linker sub­expressie en die uit­komst in­laden in de diepste vrije index.

Maar geneste arrays noteren de grootste getallen en we hechten hier rijen indexen in pijl arrays →S↓ aan Conway's komma operator.
Laat een geneste functie recursie­pijlen ↑{k} af­tellen als index. We scheiden die met sep­pijlen ← die werken als komma en als het ware terug ver­wijzen naar de functie­pijl → als openings­haakje. De pijl array loopt door tot de vrije stop­pijl ↓ die het sluit­stuk is van de operator.

Verder nesten kan door sep­pijlen ←→S↓ te indexeren. Of door op de even index niveau's een sep­pijl ←S↓ als opening te ge­bruiken met → als komma, en op on­even niveau's →S↓ met ← als komma.
De eerste methode zouden we kunnen toe­passen bij her­haalde seps in de stijl van Bird. De afwis­seling van pijl opera­toren per niveau past beter bij de comp­lete index­ering van blazer sys­temen. Steeds komen de pijl ↑.. indexen over­een met getal 1.. indexen in arrays.

Als de [m index, die dimensies van iter­ator posities telt in Bellen­blazer, na de eerste hyper index ,[1]n verder wordt uitge­breid tot een hyper rij met lengte ,[p] op het vierde niveau, dan noteren we getallen met hyper­dimensionale arrays.
Hoewel onze hyper-ruimte even groot is als die van Bird, is de getallen output een orde van grootte kleiner. Want wat bij Bird een Ackermann functie over {a,b,c} is, vergt in Bellen­blazer de lengte ,[c] van de eerste rij. En Bird's lineaire array ver­taalt als matrix dimensies ,[m] in Bellen­blazer. Zodat index [p] van hyper-dimensies gelijk komt met zijn multi-dimensies en iter n de lengte aan­geeft van zijn dimensies. Ons element ,[p]n loopt dus twee niveau's achter bij Bird.

Met het vol­gende ge­neste ele­ment ,[s]q maken we van de dimensie index in Bellen­blazer een matrix. In gelijke ruimtes blijft het blazen van bellen b onge­veer even sterk als Bird's op­laad systeem. Daar­om is de output van onze matrix in matrix gelijk aan de geneste rij bij Bird, dat is zijn hyper-dimensionale array. En de index [s] op het vijfde niveau eve­naart de lengte van Bird's hyper-index array.
Als we doorgaan met rij in rij nesten, dan kan elke index een matrix en elke matrix haar hyper-matrix omvatten, zo­als in een ma­troesjka pop. De eva­luatie regels gaven we in de alge­mene defi­nitie B.IV voor geneste arrays.

Na een langzame start is het Bellen­blazer algo­ritme vrij­wel maxi­maal, alleen onze index struc­tuur rijdt 2 op 1. Elk on­even niveau is gelijk aan een niveau van Bird. Dat zullen we nog be­wijzen door onze expressies te verge­lijken met de PDFs¹⁸ die Chris Bird bij MRob deponeerde, in het volgende hoofdstuk.
Daar zullen we overal een groei­bel substi­tueren, zoals Aas­blazer radix A.II overal een constante a oplaadt. En we verge­lijken deze blazer Wielewaal met het array systeem Vogel, dat niet zo mas­sief is als Bird maar dui­delijk eraan gelijk­waardig.

Nog verder in Bellen­blazer itereren we over nest niveau's met diepen, dat zijn arrays in serie waar­over gg eerder al blogde.^{q r s}
Een nieuw idee is om naast de functie array ook meerdere arrays in serie te zetten. Ten­einde deze per definitie grotere getallen ψ uit te laten drukken (indexeren), dan fysisch gezien met de functie alleen kunnen worden gemaakt. Een berg van niet-standaard getallen ψ, een soort eindige ω, die buiten het huidige systeem vallen.

Dit zou een twee­traps raket met de aritmetisatie²⁰ van onze array sys­temen zelf kunnen vormen. Dat wil zeggen, mits de intro­ductie van nieuwe ope­rator tekens te automa­tiseren valt, dan zijn deze tel­baar en kunnen we er­over ite­reren in een hogere array functie. Zulke cycli van aritme­tisatie kunnen we in theorie index­eren met een volgend hogere array functie. :-) Ad infinitum…

d*e[n[ *h[a[a[g]·
·[2]*]*]*][0][1]*][∞]*

Opzet voor een bellen­blazerij met een strikte l-r notatie van kleine naar grote concepten in RGB kleuren.
Hiermee eindigt mijn Reuzen Getallen Bootstrap werk–versie voor de expositie:

Om de natuurlijke ontwikkeling van de Aas­blazer structuur te blijven volgen, hebben we zowel met de Bellen­blazer nest cas­cade als de pijl arrays voor­lopig genoeg grote getallen op voor­raad.
Voor elke Conway-Knuth pijl kan het aantal opera­toren arbi­trair groot worden, onge­veer even groot als de ermee uitge­drukte getallen. Want elk pijl is recursief tel­baar, zoals met een bel b. En elk pijl is stapel­baar op alle vorige typen pijlen. Dat geldt nu ook voor geneste pijlen →S↓ met index arrays en recursief voor de seps erin met hun sub­arrays.

Laat elke pijl operator met → beginnen en met ↓ afsluiten. Dan kunnen we Conway-Knuth pijlen →↑{m≥0} herfor­muleren als →↑{m}↓ en de duale pijlen →{n}↑{m} nu als →↑{m}←↑{n}↓ met de komma pijl ← in het midden en rechts de groot­sere index.
Dan zijn de indexen [m0.,[i]mi..] :n op het derde niveau van de hyper­dimensionale Bellen­blazer arrays te verge­lijken met de eerste rij →↑{m0}.←↑{mi}..↓ :n van pijl arrays. Als we aan elke komma pijl ← een volgende pijl index array hangen, dan zal naar ver­wachting index niveau p bij geneste pijl arrays gelijk lopen met array niveau p2 in Bellen­blazer. De pijl evaluatie regels moeten dit mogelijk maken…!

Ook geneste pijlen kunnen we uitbreiden tot diepen door deze in serie te zetten. Stel start →1 en 1↓ stop, met enen erin, gelijk aan open (1 en 1) dicht. Dit co­deert haakjes in en om ex­pressies (een voor­lopige aritme­tisatie), zodat ons pijl­array alfa­bet nog maar uit de vijf tekens 1→↑←↓ bestaat.
De diepen buiten de functie vinden we bij hun over­gang in 1↓→1 en sep diepen er­binnen tussen de pijl arrays ↓→ geflan­keerd door index pijlen ↑ of even­tueel een komma pijl ← na af­telling.

• “Naar Amritsar mijn vriend”   een video installatie van Giga Gerard    Maldoror, Wagenstraat 123, maart 2018