Reuzen Getallen Bootstrap

van Giga Gerard

“Row, row, row your boat,
Gently down the stream.
Merrily, merrily, merrily, merrily,

Life is but a dream

X

§2. Rijen

Vandaag vertrekken we voor een lange reis naar het grootste getal. Monster aan en wandel over Giga Gerard’s:
„Reuzen Getallen Bootstrap”
G of giga is het voor­voegsel voor miljard 109, wat we liever schrijven als een macht 10^9 of met units 1 en tel­bare sterren.
1111111111**111111111
Een bootstrap is een opstart [boot] pro­gramma voor computers, dus deze opera­ties leggen we zo dadelijk uit. Unaire notatie met enen voor natuur­lijke ge­tallen bespraken we in §1.1.

Straks in §2.0 her­halen we getallen, wat vermenig­vuldigen is. Ook presen­teren we een meta notatie voor de her­haling van woorden.
Sectie §2.1 gaat over machten en hun vervolg. We experi­menteren met opera­toren en functies en testen meer­voudige recursie.
In §2.2 geven we een histo­risch over­zicht van de super­machten van Knuth, Hilbert, Ackermann en Péter. En natuur­lijke super­sterren, die we l-r evalueren met behulp van pop­sterren. Bijzonder zijn de hek­machten, die op halve super­snelheid gaan.

Het thema van hoofdstuk §2 is rijen. Van een rij getallen of lineaire array kunnen we de index ge­tallen uit­breiden tot een index rij, die zelf ook weer index rijen bevat. Dit zijn geneste arrays tot elk niveau.
In deze structuren passen we twee soorten regels toe. De super radix gebaseerd op het op­laden met de constante a, de aas, wat op termijn mini­maal is. En onze array functie gebaseerd op het op­laden vanuit sub­totaal b, de bel, wat op termijn maximaal is.
Systemen voor de evaluatie van expressies, waar afge­telde iter­atoren opnieuw worden opge­laden, noemen we blazers. We blazen azen op rij §2.3 en in nesten §2.4 en ont­wikkelen zo een natuur­lijk ver­volg op het radix systeem, waarin elk groot getal kan worden uitgedrukt. En we blazen bellen op rij §2.5 en in een vlak §2.6 en alle dimensies §2.7 en in hyper-dimensies §2.8 van geneste arrays. Op deze manier steken we de array functies van Chris Bird naar de kroon.

Ondertussen ontwikkelen we een jargon bij het produceren van grote getallen en een notatie systeem in html ascii. In de laatste secties proberen we een vervolg op Knuth's en Conway's pijlen te definiëren, wat warempel bijna nog slaagt…!
Let op de puntjes … want dat zijn hints om uzelf (oef ;o) te oefenen.

Lectori salutem Welkom aan boord.

X

§2.0 Herhalen

Vermenigvuldigen is herhaald optellen. We schrijven deze opera­tie met een ster a*b tussen twee ge­tallen, om b keer a te nemen. Getallen 1.. zijn opge­bouwda uit units 1 en zo bezien is vermenig­vuldiging al een her­haling op her­haling.

  • a*1 ?= a (een keer)
  • a*1b ?= a+a*b (meer keer) == a..+a*1 :b = a.. :b1

Scan expressies l-r (links naar rechts) en probeer deze regels toe te passen. Varia­belen uit verschil­lende regels zijn onaf­hankelijk.

Bij voorwaardelijke toewijzing ?= kan een regel de expressie alleen ver­anderen, als er geen opera­tie die voor­rang heeft op volgt.
Dus a*3 = a+a*2 = a+a+a*1 = aa+a*1 = aa+a = aaa is hoe we een ex­pressie uit­werken, waarbij vermenig­vuldiging * voor­rang krijgt en we een enkele op­telling + links laten liggen.

Bij herhaalde toepassing == van regels volgt een resultaat meteen. Soms korten we dit af tot enkele gelijk­heid = om een makke­lijke uit­werking samen te vatten.

Een andere manier van optellen is, om getallen om te draaien en dan 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 de serie on­eindig lang is, kan deze de uit­komst domineren en b draagt alleen rechts nog wat bij.
Door op pop wijze b+a op te tellen tot ba, groeien ω: on­eindige ..a naar links aan. Zelf zal a1 niet zijn omgedraaid, en reps zoals ω1: worden van rechts afgeteld.

Metamatiek 2.0

We gebruiken twee meta notaties voor tekst herhaling, bedoeld om de uit­werking van ex­pressies inzich­telijk te maken.
In regex notatie wordt een karakter herhaald door het aantal {n} erna tussen krul­haken te zetten.
In onze repex notatie wordt een woord geselecteerd tussen punten, en repeteert deze achter de dubbele punt, rechts van de expressie.

  • W.. :5 = WWWWW
  • Wi..X..Yi :3: = W1W2W3XY3Y2Y1
  • V.W..X..Y.Z :2: = VWWXYYZ
  • i..Xj :3 5: = 6X5X4X3X2X1

Woord selectie begint bij de grens van de expressie (witruimte) of anders links van een . punt. Deze selectie eindigt rechts met twee punten, waarop het geselec­teerde woord her­haald wordt.
De rep of repetitie :n telt de herhalingen van links naar rechts, of twee­zijdig :n: van buiten naar binnen, of n: van rechts naar links.

Index variabelen i en j incrementeren in een reeks. Vanaf 1 in het begin (meestal links) neemt de index per stap 1 toe, van index i=1 tot eind index i=n. Het aantal stappen en het begin blijkt uit de rep.

We willen maximale algoritmes niet op reps baseren, maar op simpele regels die we staps­gewijs toe­passen: met een eerste en steeds een volgende stap.
Onze reductie trein beweegt van vertrek expressie, onze input, naar aankomst expressie, de output, en arriveert op vele tussen­stations.

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

Omdat gelijkheid = van expressies transitief is, blijven de resul­taten kloppen. Al deze ex­pressies zijn slechts andere vormen van de output Gu die na complete evaluatie wordt bereikt.

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(2,3) is. Kampioen met c'*d*Log(2,d) is het FFT algoritme, dat snelle Fourier trans­formaties toepast.1 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 horizonc van het fysisch universum.
Machten ^ of ** (herhaald vermenig­vuldigen) zal in dit hoofdstuk tot tetratie ^^ of *** (toren van machten) en verder tot super­machten worden uit­gewerkt. De opera­toren + * ^ helpen om moeilijk 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: & 0c<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…?

X

§2.1 Machten

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 strikt `= van links. Daarbij zijn geen haakjes nodig, noch verge­lijkende prece­dentie regels.
Alleen een rechter operatie zónder plus die direkt volgt ?= op een type operatie mét plus wordt met voor­rang geholpen. En naast­gelegen ge­tallen ab tellen we natuurlijk op.

Onze l-r definitie voor machten met ** twee sterren.

  • a**1 `= a (eliminatie)
  • a**b1 `= a*+a**b (stap)
  • c*+a ?= a*c (popschuiven)

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

Experiment 2.1

Ontwerp een Superplus systeem. Pas de regels in volgorde toe, zodat c>1 voor de eind iter­ator en b>0 en c>0 in de recursie.

  • a+b = ab
  • a+{c}1 = a
  • a+{c1}b1 = a+{c}a+{c1}b

Als we hierbij prioriteit tegelijk met subexpressies overboord gooien, en +.. opera­toren puur l-r evalueren, werkt dat dan?
Ja en snel, twee plussen ++ herhaalt de verdubbeling van a.

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

Een post operatie \^ plaatst na uitwerking van de vooraf­gaande operatie een extra expo­nent bovenop de hoogste sub­operant daarvan. Post operatie \* vermenig­vuldigt deze hoogste exponent dan wel super­exponent (met prio­riteit zodra deze er is).
We plaatsen de post backslash rechts en draaien de operanten niet om, zoals bij de pop plus links van de operatie.

We vergelijken superplussen met ^.. supermachten, die in §2.2 een histo­risch overzicht krijgen. De expressie links van ≈> is maar weinig (insignificant) groter dan die rechts.

  • a1+++b3 = a1++a1+++b2 = a1*2^a+++b2 ≈> 2^(a*2^a)+++b1 ≈> 2^2^2^a1+++b ≈≈ 2^..a1+++1 :b2 = 2^^b2\^a1 ≈ a^^b3
  • a1+{c2}b2 = a1+{c1}a1+{c2}b1 ≈ a^{c}a1+{c2}b1 ≈ a^{c}a^{c}a1+{c2}b ≈≈ a^{c}..a1 :b1 = a^{c1}b1\^{c}a1 ≈> a^{c1}b2

Door twee tekens, de 1 en + plus, te gebruiken krijgen we al super­grote ge­tallen. Ook al laten we de enkele tekens domweg vallen, in de initiële regels.
Bijv. 11+++++111 2^^^^3 = 2^^65536.

Omdat a+{c}b <≈ a*{c}b zijn de recursies in de functies van super­plussen D(a,b1,c1) = D(D(a,a,c),b,c1) en van de super­machten F(a,b1,c1) = F(a,F(a,b,c1),c) van de volgende sectie, onge­veer even snel.

Ontwerp nu een hybride functie met meervoudige recursie op twee posities. Noem dit de Excalibur functie: het twee­snijdend zwaard.

  • E(a,b,1) = E(a,b) = ab
  • E(a,1,c) = a
  • E(a,b1,c1) = E(E(a,a,c),E(a,b,c1),c)

Rozsa Péter stelt2 dat recursie in meerdere variabelen tegelijk niet signi­ficant sneller gaat, en dit willen we testen.

  • E(a,b1,2) = E(aa,E(a,b,2)) == E(aa,..a..) :b: = a*2*b+a
  • E(a1,b1,3) ≈> E(a^2*2,E(a,b,3),2) ≈> aa^2*E(a,b,3) ≈≈ aa^2*..a :b = aa^bb*a
  • E(a1,b1,4) ≈> E(aa^aa,E(a1,b,4),3) ≈> aa^(a*3*E(a1,b,4)) ≈≈ a1^..(a*a*3) :b>0 ≈> a1^^b1\^2
  • E(a,b1,5) ≈> E(a^^a,E(a,b,5),4) ≈> a^^(a+E(a,b,5)-) ≈≈ a^^..aa- :b>0 <≈ a^^^b1\*2
  • a^{c}b < E(a,b,c2) <≈ a^{c}b\*2 < aa^{c}b

We verwachten dat hogere expressies E als de bij c=5 berekende zullen ver­lopen, en niet verder zakken richting F.
In ieder geval voegt de extra recursie hier weinig toe, al is argument a onge­veer ver­dubbeld. Misschien als we de extra stap E in stap F nesten, dat dat hoger­op groter uitpakt?

  • G(a,b,1) = G(a,b) = ab
  • G(a,1,c) = a
  • G(a,b1,c1) = G(a,G(G(a,a,c),b,c1),c)

Werken we onze dubbele Griffioen functie uit. Dan neemt super­macht c meteen 1 toe, verge­leken met E of super­plussen. In het vervolg telt het tweede argument bijna als b*2, wat te ver­wachten viel door het dubbele nesten in de recursie stap.

  • G(a,b2,2) = a+G(aa,b1,2) = a*3+G(a*4,b,2) == a*(2^b2)- ≈ 2^b2
  • G(a,b2,3) ≈ 2^G(2^a,b1,3) = 2^2^G(2^2^a,b,3) == 2^^b1\^2^^b1\^a = 2^^bb2\^a ≈ 2^^bb4
  • G(a,b1,4) ≈ 2^^G(2^^aa,b,4) == 2^^..2^^..aa :b :b = 2^^^bb\^^aa ≈ 2^^^bb2
  • G(a,b1,c1) ≈ 2^{c}bb\^{c-}aa ≈ a^{c}bb1 ≈ 2^{c}bb2

Omdat argument c ongemoeid blijft, draagt het nesten van meerdere sub­expressies niet wezenlijk bij aan het maken van grotere ge­tallen, als die recursies op zich al super­machten op­leveren.

Een serie dezelfde operaties komt in de reductie­trein van een ster operatie nooit voor. Dat geldt voor enkele operaties. Zet een tweede pop links vóór de macht en deze zal opereren op de eerste factor.

  • 1+2**3 = 1+2*+2**2 = 3*+2**2 = 3*+2*+2**1 = 2*3*+2**1 == 6*+2**1 = 6*+2 = 2*6 == 12.
  • 2**3*2 == 6*+2**1*2 = 6*+2*2 = 6*+2+2*1 = 2*6+2*1 == 12+2*1 = 12+2 = 14.

Een operatie die volgt geeft nog vreemdere resultaten, omdat deze voor­tijdig in stelling wordt gebracht. Wie wil rekenen met sterren, zal haakjes moeten toe­passen. Maar hier gaat het erom één ster operatie met één hulp­teken, de pop + plus, in stappen uit te werken.

Pop­sterren *{c}+ stellen die operatie niet alleen uit, maar draait de operanten daarna ook om. Dit is pop­schuiven. Dit blijft gelijk met *+ want vermenig­vuldigen is commu­tatief, maar bij super­machten maakt het 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
      = 6+3
 3**3 = 6+3*+3**1
      = 9*+3**1
      = 9*+3
3***3 = 9*+3**+3***1
      = 3*9**+3***1
     == 24+3**+3***1
      = 27**+3***1
      = 27**+3
      = 3**27 (popschuiven)
      = 3*+3**26
     == 9*+3**25
     == 27*+3**24
    === 7625597484987.

Stel dat u de regel voor pop­schuiven vervangt door pop­ruimen, dat is plus + elim­inatie zonder dat er operanten ver­wisseld worden. Dan blijven uw hek­machten #.. ver achter op onze *.. 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 uw 4####4 en hoe laat evenaart u de onze…?

X

§2.2 Supermachten

Nadat machtsverheffen lange tijd de hoogste operatie was, vond algo­ritme kenner Donald Knuth3 in 1976 zijn telbare opera­toren {c} uit, om ge­tallen in het gebied van de 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 die bij Knuth de operator ^ is van gewone machten. Hij legt dit uit als her­haald vermenig­vuldigen, wat herhaald op­tellen is. Tetratie noteert Knuth met twee pijlen ↑↑ en hij werkt dit uit tot een rij machten, enzovoort.

Regels voor Knuth's pijlen, die we vanaf rechts oplossen.

  • a{c}1 =` a {c>0}
  • a{c1}b1 =` 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 Gardner4 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 boek5 dat noemde. Hoewel Gardner de schatting, die Graham eerder publi­ceerde6, 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 ook het 9e priemgetal dichterbij ligt p8+4 = 23 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 :43: = 3{..3↑↑↑↑3..}3 :63:
  • 3↑↑↑↑3 = 3↑↑↑3↑↑↑3 = 3↑↑↑3↑↑327

Knuth's operaties werden eerder al uitgedrukt in een functie, die we voor het eerst in 1925 bij David Hilbert7 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.

  • H1(a,b) = a+b = ab
  • Hc1(a,1) = (Hc,a,1) = a
  • Hc1(a,b1) = (Hc,a,b1) = Hc(a,(Hc,a,b)) == Hc(a,..(Hc,a,1)..) :b: = Hc(a,..a..) :b:

Hilbert gaf zijn voorzet Ha(a,a) en Wilhelm Ackermann schoot die er in 1928 in, met een stroef bewijs8 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, want er spelen twee recursies: een grote met iter­ator c over een kleine met iter­ator b en een constante a>1.

De Hongaarse wiskundige Rozsa Péter had in haar boek9 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.

Demonstratie 2.2

Péter's P(b,c1)+3 = 2*{c}b3 uitgedrukt in super­machten.

  • P(b,1) = P(..2..,0) :b: == 2.+1.. :b = b+2
  • P(b,2) = P(..3..,1) :b: == 3.+2.. :b = b*2+3
  • P(b,3) = P(..5..,2) :b: == (..5..*2+3) :b: = 2^(b+3)-3.
  • P(b,4) = P(..13..,3) :b: == 2^(..16..).-3 :b: = 2^^(b+3)-3.
  • P(b,5) = P(..2^^4-3..,4) :b: == 2^^(..2^^^3..).-3 :b: = 2^^^(b+3)-3.
  • P(b,c+3) = P(P(b,c3),c2) == P(..P(1,c2)..,c2) :b: = P(..2^{c}4-3..,c2) :b: == 2^{c}..2^{c1}3-3 :b = 2^{c+1}(b+3)-3.

Péter's P is een speciaal geval van functies Pa waar a=1.
In algemene functie Pa telt de initiële regel a een­kennig op.

  • Pa(b,0) = a+b = ab
  • Pa(0,c1) = Pa(1,c)
  • Pa(b,c1) = Pa(Pa(b-,c1),c) = Pa(..1..,c) :b1:

Het is interessant om de uitkomsten bij waardes van a te vergelijken.
Na P0(b,0) = b reduceert P0 steevast tot 1.

  • P0(b,1) = P0(..1..,0) :b: == 1
  • P0(b,2) = P0(..1..,1) :b: == 1
  • P0(b,c2) = P0(b,c1) = 1

Dat P2(b,c)+3 = 2*{c}b3 volgt uit P2(1,0) = 3 en eerdere demon­stratie van Péter's P1 omdat ook P1(1,1) = 3 en daarna is P2 op dezelfde wijze recursief bepaald.

  • P2(b,0) = b2 = P1(b,1) = 2+b3-3.
  • P2(b,1) = P2(..3..,0) :b: == 3.+2.. :b = b*2+3 = 2*b3-3.
  • P2(b,c) = P1(b,c1) = 2*{c}b3-3.

Ook de vergelijking van P3 met super­sterren is merkwaardig exact.

  • P3(b,0) = b3 = 3+b2-2.
  • P3(b,1) = P3(..4..,0) :b: == 4.+3.. :b = b*3+4 = 3*b2-2.
  • P3(b,2) = P3(..7..,1) :b: == (..1..*3+4) :b1: = 3.*3..-2. :b1 = 3^b2-2.
  • P3(b,3) = P3(..25..,2) :b: == 3.^3..-2. :b1 = 3^^b2-2.
  • P3(b,c2) = P3(..3^{c}3-2..,2) :b: == 3^{c}..3^{c1}2-2 :b = 3^{c1}b2-2.

Hierna komen de details bij supermachten niet meer overeen. Er is geen vast getal q voor de optel aftel routine en dit is niet te repa­reren.

  • P4(b,1) = P4(..5..,0) :b: == 5.+4.. :b = b*4+5 = 4*(b+q)-q. & q=5/3
  • P4(b,2) = P4(..9..,1) :b: == (..1..*4+5) :b1: = 4^b1*(1+q)-q.4^(b+qr)-qr. r.041
  • P4(b,3) = P4(..41..,2) :b: ≈≈ 4^..(1+qr)-qr. :b1 ≈ 4^^bqrs-qrs. s<.001
  • P4(b,c) ≈ 4*{c}(b+qr)

De twee systemen zijn aleen bij benadering te vergelijken. In feite zijn er geen op­lossingen voor varia­belen qr, qrs, etc. We noemen dit surro­gaat varia­belen.

  • P5(b,1) = P5(..6..,0) :b: == 6.+5.. :b = b1*5+1 = 5*bq-q. & q=3/2
  • P5(b,2) = P5(..1..,1) :b1: = 5^b1*q1-q. = 5^bqr-q.5^bqr-qr. & qr = Log(5,q1)+1 ≈ 1.569
  • P5(b,c) ≈ 5*{c}bqr

Voltooi de benadering van de dubbele recursie Pa met super­macht opera­toren. Voor grote a dalen de optel aftel surro­gaten tot limiet 1.

  • Pa(b,1) = Pa(..1..,0) :b1: == a1.+a.. :b = b1*a+1 = a*bq-q. & q=a1/a-
  • Pa(b,2) = Pa(..1..,1) :b1: = a^b1*q1-q. = a^bqr-q. qr ≈ 1+Log(a,2) ≈ 1
  • Pa(b,c) ≈ a*{c}b1

Het is aardig om te weten dat de limiet van Pa een stap in b verder is dan bij super­sterren, maar het zet geen zoden aan de dijk. Geteld vanaf c produ­ceren beide systemen onge­veer even grote ge­tallen.

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

  • b1 `= b11
  • 1c1 `= 1cc
  • b1c1 `= bc1c == 1.c.. :b2

Zo vermijden we de 0 en subexpressie haakjes. En we werken bc1 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 c0 zodat *{0} unair optelt.

  • a*{c1}1 `= a
  • a*{c1}b1 `= a*{c}+a*{c1}b
  • b*{c}+a ?= a*{c}b (popschuiven)

Hogere superster operaties worden van de uitwerking van de lagere apart gehouden door er tijdelijk pop­sterren *..+ tussenin te plaatsen. Als er ?= een pop­ster volgt, dan valt de linker pop + van de sterren weg, terwijl de operanten om­keren of pop­schuiven.

Van dit pop­schuiven zagen we al een voorbeeld bij dubbele machten in sectie §2.1. We gaven plus elim­inatie als alter­natief, en de opera­toren #.. noemden we hek­machten.

Vul de regel a#{c}+b ?= a#{c}b in in het super­sterren schema. En ver­vang in dat schema de ster * door een hekje # om hek­machten te definiëren. 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 hierarchie10 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 structuren voor algo­ritmes blijkbaar de enige natuur­lijke alter­natieven…

X

§2.3 Aasblazer

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] produ­ceert, als een lange reeks 1.. enen.

Initieer Aas­blazer, met uitkomst 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 l-r vanaf links regels toe­passen in tekst.
De variabelen a en b reserveren we voor aas en bel links buiten de top array en links erbinnen. Alle varia­belen zijn natuur­lijke ge­tallen, meest vanaf 1, niet leeg, maar cijfer 0 kan ook (en valt weg).

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

  • A.0. a[bp] = pb
  • A.1. a[b,[]1 ≡ a[b1
  • 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 sectie §2.0, maar dan achter­af.
Een verdwaald element ,[0]p in het midden laten we met rust, tot voor­gaande indexen zijn ver­dwenen en de lege array bij [b aan­komt. Pas dan popt deze sepa­rator weg, zodat de para­meter 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.

Googologie 2.3

Een array is een reeks variabele getallen, met een sepa­rator of sep er­tussen. Aas­blazer arrays zijn omvat met vier­kante haken [T] en van links­buiten gekop­peld aan (de laatste 1 in) aas a. Deze array bevindt zich op het top niveau.
Het sep teken is een , komma, zoals in functies. Maar in onze blazer arrays hebben alle seps een ,[X] index array, die de positie van elke iter­atie bepaalt en daar­mee ook hun functie.
Index arrays koppelen we hier links aan een komma. Arrays kunnen arrays met indexen bevatten tot elke diepte. Functies met indexen op meerdere niveau's zijn geneste arrays.

Een iterator of iter is een variabele in een recursieve functie. Die telt zijn iters af met een regel, die tegelijk een expansie toepast op een eerder deel van de ex­pressie (bij ons links van de iter).
Iters op rij zouden we net als in functies kunnen scheiden met enkele komma's. Blazer struc­turen slaan die tussen­stap in de notatie over. Onze solo komma , is een af­korting van de eerste sep, links in arrays. Van de varia­bele ervoor, op positie [0] vervalt de sep. Andere array posities houden op de eerste rij index [n] en in verdere rijen [n,S] index arrays, die (afge­zien van oneigen­lijke input) uniek blijven.

We vergelijken herhaalbare met unieke seps in googologie box 2.4. Googo­logie is de fenomeno­logie van feno­menaal grote ge­tallen.

Aas­blazer heeft vloeibare arrays, bestaande uit sub­operaties die vrij door elkaar kunnen bewegen, terwijl ze op evaluatie wachten. Zoals de elementen in een set, of zoals simpele eiwitten drijven in het medium van een bio­logische cel.
Ieder eindig iter getal met index array kan zich vrij ver­plaatsen binnen de array die dit paar nest. Staps­gewijs, door wisselen a.6. slim te her­halen, ver­schuiven we deze paren. Die vrijheid bestaat, omdat we elke serie elementen ook apart zouden kunnen uit­werken en op­tellen. En op­tellen van eindige ge­tallen is commu­tatief.

Daarentegen staan in vaste arrays de variabelen in volgorde op rij. Zoals de para­meters van een functie, of zoals genetische infor­matie om eiwitten te bouwen in een cel.
Het nadeel van variabelen die voor hun waarde afhankelijk zijn van de posities ervoor, is dat die structuur intact moet blijven, ook al is de iteratie afge­teld, tot 0 of 1. Maar in blazer systemen zijn alle posities gegeven door index arrays. We kunnen deze indexering samen met de afge­telde iters wegblazen, en deze later her­stellen, zonder effect op de waarde van de rest van de rij.

Gebruikelijk is om de aftelling en verwijdering van iter 1 als geheel te zien en apart te definiëren. We lassen een einde getal ! lees­teken in met regel a.0. om die routine ineens a.3. te kunnen be­sluiten.
Losse variabelen v zijn altijd v! gretig [regex: greedy] naar enen.

Hulpregels a.II bij evaluatie in Aas­blazer.

  • a.0. vv!x
  • a.1. ,[1]c := ,c
  • a.2. a[bp,Z] := a[,Z]+pb
  • 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.,[mi]fi..] :n = a^mi*fi..+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…?!

X

§2.4 Aasnesten

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 reductie­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[bp] = pb
  • A.1. ,[]1 `= 1
  • A.2. ,[X]!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.
Universele regel A.2. verwijdert de sep van een afgetelde iter 0 aan een array einde of middenin, op elk niveau in geneste arrays.

Hulpregels a.II blijven verder bij aas­nesten van kracht.
We gaan Aas­blazer's indexen nu dieper nesten, 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 lengte11 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 heeft het cijfer 0 niet nodig. 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 vanzelf groter dan bij een tradi­tionele radix, maar blijft toch kleiner dan bij unaire notatie.

Googologie 2.4

Als we telbare of meervoudige separatoren ,[S].. hadden gebruikt, dan zou zo'n systeem de begin positie van elke index rij uitsparen. Dit geldt voor meerdere gelijke seps (met dezelfde index array) die iter posities aan­geven, niet de vele mixe varianten die mogelijk zijn.
Hierboven in Aas­blazer representeert de eerste index d dat meervoud. De index rij in S zou daarop met e beginnen, waar de meer­voudige e index moet itereren over aan­tallen {d} via een aparte regel.

Om meer expansie uit onze seps te halen, kunnen we deze beter met iter en al her­halen. Zo'n array systeem (dat o.a. Bird toepast) heeft ook andere regels nodig, om de maten van dimensies te ver­groten.
Een element is een sep-iter paar, dat in een rijen in rij struc­tuur op een bepaald array niveau is genest.
Doordat de exacte positie, die een iter betekenis geeft, afhangt van voor­gaande index arrays, staan alle elementen vast in een file, binnen lagen van array dimensies. Afge­telde elementen tussen­in mogen niet ver­vallen. We zouden het cijfer 0 kunnen in­lassen, of (zoals bij Bird) ite­raties af­tellen tot 1, en deze alleen aan het array einde ver­wijderen.

Vergelijk de Aas­blazer indexering met een systeem dat meer­voudige komma's her­haalt. We schetsten met opeen­volgende separa­toren het multi­dimensionale aspect van onze dubbel geneste [n] index.

  • ,[d] = , (sep in rij 1)
  • ,[,1] = ,, (open rij 2)
  • ,[d,1] = , (sep in rij 2)
  • ,[,e] = ,, (rij sep in vlak 1)
  • ,[,[2]1] = ,,, (open vlak 2)
  • ,[,e,[2]1] = ,, (rij in vlak 2)
  • ,[,[2]f] = ,,, (vlak in kubus)
  • ,[,[3]g] = ,{4} (3e in 4e dim)
  • ,[,[n]m] = ,{n1} (dim seps)

Als dezelfde index arrays herhaald worden binnen hun dimensie, lijkt zo'n structuur op een matrix. Deze matrix notatie loopt per nest een niveau op onze notatie uit. Het meer­voudige aspect scheelt daarbij maar één index, dat laten we vanaf nu achter­wege.

Dan blijkt het tweede sub­array niveau [n] bij unieke seps overeen te komen met de eerste sub­array [n1] van her­haalde seps. Binnen dieper geneste arrays zal het­zelfde structuur ver­schil gelden.
De vertaling tussen beide systemen is daarmee gegeven. Met unieke index posities zijn onze blazers twee keer zo diep genest, als we met her­haalde indexen hoeven doen.

In Aas­blazer kan elke array tot een getal herleid worden, dat voor de array erboven een nieuwe expo­nent uit­drukt. Een her­haalbare matrix zal per geneste array twee expo­nenten aan zijn toren toe­voegen.
Als we dieper nesten, blijkt dat de super­exponent a^^n van tetratie precies bereikt wordt met nest niveau n in Aas­blazer. Als we dus onze super radix zouden matrix her­halen tot diepte n, dan zou de super­exponent a^^nn ver­dubbeld worden.
Dat is niet zo fraai… Daarom gebiedt de esthetiek, dat uniek indexeren de natuurlijke notatie voor array functies is.

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 getallen12 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.[pi,..qi] :n>0: = a^(..1..)*qi+pi :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 array systemen, die hun iteraties in­bedden 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…?

X

§2.5 Bellenblazer

We bouwen een grote getallen functie met simpele, natuurlijke regels. Door azen a herhaald op te tellen groeit de variabele bel b, waarmee we afge­telde itera­ties nieuw leven in­blazen.
Dit is het idee achter bellen­blazen13, dat in een recursieve functie, maar zonder sub­expressies, het sub­stitueren van sub­totalen maxi­maal kan zijn.

De Bellen­blazer functie a[X]b zet de bel met het sub­totaal buiten de array, als tweede operant. Aas a links, bel b rechts, en de array [X] met de rijen itera­toren of iters en hun indexen in het midden.
We verplaatsen b en hervullen deze met a. Dit pakt niet signi­ficant kleiner uit dan een regel die b kopieert en de kopie sub­stitueert. Dat laatste kan ook, al leidt dat niet tot op­tellen of vermenig­vuldigen, maar tot einde­loze verdub­belingen. Zoals we met Superplussen in box 2.1 en met Péter's functie al zagen.

Beginnen we met algoritmisch verantwoord aas­tellen in Bellen­blazer.
Voor het gemak := staat de enkele komma , voor de sep ,[1] op de eerste positie in de iterator rij.

  • a[,[1]2]b := a[b,1]a = a[,1]ba = a[]ba = ab
  • a[,[1]3]b := a[,2]ba = a[ba,1]a = a[]baa = aab

Net als in Aas­blazer A.I valt de lege array of nulde sep weg. Zodat ge­tallen aan het begin van de top array b+a op­tellen tot de bel.
Ex­pressies worden steeds l-r vanaf links opgelost.

Elementaire iteraties: iter c met index [1] telt aas a her­haald op, iter d op positie 2 repeteert *a deze fac­toren, en de 3e iter e stapelt dit weer als ^a machten, te rekenen vanaf de hoogste exponent.

  • a[,[1]1c]b := a[,c]ba == a[,1]b+a{c} = a*c+b
  • a[,[2]1d]b = a[,[1]b,[2]d]a = a[,[2]d](a*b) == a[](.a*..b) :d = a^d*b
  • a[,[3]1e]b = a[,[2]b,[3]e]a = a[,[3]e](a^b) == a[](..a^.b) e: = a^^e\^b

De Bellen­blazer rij is opgebouwd als array functie voor super­machten. Om hier op de eerste rij de iteraties kloppend te maken, tellen we deze af tot 1 en ruimen hun positie dan op. Alleen de index aan het begin van geneste arrays laten we bij waarde 0 weg­vallen.

Na dit stroeve begin verloopt de evaluatie van Bellen­blazer expressies soms zelfs makkelijker dan die van super­sterren, omdat de regels van beide systemen enigs­zins ver­schillen.
Neem twee passages uit de evaluatie naar a^^^f3. Wat super­pop­sterren doen in stap 2 en 3, vat Bellen­blazer samen in de 3e stap.

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

Steeds grotere series a.. tellen van rechts bij de bel. Die sub­totalen laden de iters weer op, wat nieuwe bellen produ­ceert. Hoewel series af­komstig van de meest rechtse iters het langst zijn, moet de links al aan­wezige som toch bij blijven dragen aan het totaal.

Als we zoals Cantor tellenf, dan valt elk kleiner getal in het niet door er rechts een groter on­eindig ge­tal bij te voegen. Ons algo­ritme dienen we dus af te stemmen op het blazen van on­eindige azen.
Dat kan zo:

  • Iteratoren van rechts aftellen, steeds omdraaien bij optellen (poptellen over de nulde sep), zodat alle variabelen de wiskundig gang­bare r-l tel­richting houden.
  • Iters van links aftellen, de nulde sep laten weg­vallen, oneindige getallen in arrays l-r lezen, en pas bij de uitkomst omkeren (links groot, rechts klein).

We kiezen de laatste aanpak, want systemen voor grote ge­tallen starten links met kleinere iteraties en bouwen grotere struc­turen rechts aan. Noch de gewone schrijf­wijze van ge­tallen, noch Cantor's on­eindig tellen stroken hier­mee. Dus tot de wis­kunde over­stag gaat, keren we mogelijk on­eindige output om buiten de array.

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

  • B.0. a[]bp = pb
  • B.1. a[,[]b,X]p = a[,X]bp
  • B.2. ,[1n]1!0
  • B.3. a[,[1n]2X]b {b>0} = a[,[n]b,[1n]1X]a

De primitieve stap van de lege sep die wegvalt in regel B.1. telt de aas op bij de bel, een klasse *{0} construct.
Hoofdregel B.3. itereert over de genummerde separa­toren ,[n] van de *{1} rij structuur, die in Bellen­blazer super­machten uit­drukt. Echte functie recursie met nesten van subexpressies is on­nodig, want in diep geneste arrays is het opladen van bel b al bijna maxi­maal.

In regels volgt na een uitroepteken ! geen getal meer, maar bijv. een komma , of array ] eind. Nul verdere enen dus, aan­gezien we met unaire ge­tallen 1.. werken.
In een systeem met binaire code kan aan ge­tallen een 0 vooraf gaan. Andere tekens krijgen een lange nul prefix 001{n} en een nummer.

Hulpregels b.I voor Bellen­blazer.

  • b.0. vv!x
  • b.1. ,[1]1 := ,1
  • b.2. a[,Z]a := a,Z
  • b.3. a[,2Z]b = a[,1Z]ba
Evaluatie tekens om de linker (sub)expressie door de rechter (sub)expressie te vervangen:
 = Pas een evaluatie toe op de hele expressie.
== Pas voorgaande evaluaties herhaal­delijk toe.
 ≈ Is ongeveer gelijk aan, in verge­lijking.
≈> Is insignificant groter dan.
<≈ Is insignificant kleiner dan.
`= Herschrijf de eerste match l-r vanaf links in de expressie.
=` Herschrijf r-l een woord aan de rechter kant.
 ≡ Pas equivalentie willekeurig toe, maar l-r met voorrang.
:= Ga over naar simpel expressie format.
=: Afkorting voor regels.

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

  • a[,[2n]2f]1 := a,[2n]1f = a,[1n]a,[2n]f = a^{n}a,[2n]f == ..a^{n}.a f: = a^{n1}f1 = a*{n2}f1
  • a[.,[1ni]1fi..]b :r {b>0} = ..a^{ni}fi\*{ni}.b r: = b.*{ni}+a*{1ni}fi.. :r

Doordat we de bel in Bellen­blazer vanaf b=1 laten beginnen, staat er rechts buiten de top array altijd een operant. Elke volgende index op de eerste rij noteert een hogere super­macht, waarbij de iter steeds 1 minder telt dan de exponent.
Zodra de bel met de aas a is hervuld, komt door de ver­taling := per hulp­regel b.2. de super­exponent precies overeen.

Iedere iteratie is de rechts bijge­telde serie 1.. in de bel langer dan daar­voor. Bellen worden naar iters en indexen verladen en van de links weer afgeteld. Bij oneindige :ω reeksen van a.. is de expansie omge­keerd oneindig tot de output, die Cantor's tel­richting krijgt.
Een samengestelde aas zouden we in beginsel a=nω omkeren. Maar omega ω zelf blijft alleen van links oneindig af­telbaar (omega keer min -{ω} omega ω kan 0 of 1 zijn, hoewel we min - tekens liever achter ge­tallen noteren).
We kunnen ω opvatten als unit van een oneindige successie Ω.g Zoals unit 1 de natuur­lijke ge­tallen vanaf 0 telt, zo stamt unit ω af van 1 op een hoger plan.h

De eerste rij van Bellen­blazer geeft de elementaire operaties en dan de super­machten mooi weer. Daarom noemen we dit een natuur­lijke array functie.
Een natuurlijke methodes die opnieuw itereert met sub­totaal b moet die positie wel door­geven aan een constante a. Maar om zo'n functie maximaal te houden voor geneste arrays, wordt dat niet moeilijk…?

X

§2.6 Belnesten · rijen

Hoe dieper geneste rijen van indexen een ex­pressie heeft, hoe groter de ge­tallen die ermee be­schreven worden.
Iteraties in de top array bevinden zich op het 1e niveau. Daar begint links de eerste rij met de enkele indexen, waar­door we de iters kunnen aftellen en opladen zoals in Bellen­blazer definitie B.I.
Om de verdere posities in de top array te noteren, gebruiken we een rij van indexen op het 2e niveau. Deze geneste array is zelf weer uit te breiden met verdere rijen, die we indexeren op het 3e niveau.
Arrays van elk niveau kunnen met rijen iters verlengd worden en door diepere indexen genest. De begin index in sub­arrays tellen we af tot 0 en de erop volgende geneste iters tot 1. Alleen aan de uiteinden van arrays plaatsen we geen separator met sub­array.

Subarrays in woorden W zijn lexi­caal begrensd (elk opener haakje [ heeft er een eigen sluiter haakje ] en vice versa), zie box 1.0.
Om bij een array [1V een einde ] te passen in com­plexe ex­pressies is verre van triviaal. Tijdens de l-r scan tellen we het nest niveau op en neer in sub­arrays tot het juiste niveau sluit­haakje is ge­vonden.
Er is ook de onder­verdeling in rijen binnen de dimensionale ruimte, zie box 2.4. In ons systeem noteren we elke positie in de array expliciet met indexen. Maar wát een index array is en wàt de para­meter array, is relatief en ligt aan de gemaakte match van de regel.
Bij verschillende typen arrays, de een in de ander, kunnen we haakjes wellicht hun eigen niveau laten aan­geven, onge­veer zo als para­meter posities een eigen index krijgen.

We zullen de oude regel B.3. aanpassen, om indexen in geneste arrays opnieuw op te laden. Voordat er een geneste index leeg komt, wordt sub­totaal b opge­laden naar de iter rechts van de index array. Het sub­stituut getal zal daarna van de array iter moeten komen, niet van de bel, omdat de functie anders stokti Echt grotere getallen komen dan niet meer van de grond.
Stel een voorlopige regel, die de sep-iter herhaalt tot het tweede array niveau. Dit zijn de recursies over rijen van rijen (de vlakke ruimte) tot aan de multi­dimensionale array in Bellen­blazer. We lezen dimensie getal d1 bij de eerste index ,[d] op het derde niveau.

  • B.2. ,[V1]1!0 (iter elim)
  • B.3. [,[1V]2X]2c (iter intro) `= [,[V]2c,[1V]1X]b && a[,Z]b = a[,Z]a

Bij toepassing op index arrays is juist in de stap ervoor 2c opge­laden met de bel, terwijl deze werd vervangen door a. Zo transporteert het sub­totaal b in tweede instantie naar de geneste array. De vraag is, zou het principe van iter naar index over­laden verder als in een cascade omlaag gaan…?
Definitie B.II past zo'n cascade regel toe op geneste arrays. Hoewel dit algo­ritme natuur­lijker grote getallen lijkt op te leveren, wordt het wel minder simpel om uit te voeren.

Googologie 2.6

De array functies van Bowers & Bird (afgekort B&B) rollen series van gelijke separa­toren uit. Dit schept een ruimtelijke structuur, waar B&B de­zelfde index arrays op verschil­lende plaatsen invoegen.
Zowel de snellere start, als hun arrays met herhaalde indexen, worden over­bodig, zodra wij de geneste diepte direkt opblazen.

Het eerste bleek uit ons Btrix systeem, dat langzaam op gang komt, maar net als B&B index arrays her­haalt. In het begin drukt een rij in Btrix dubbele recursie uit, gelijk de eerste rij in Bellen­blazer. Met de index van dimensies komt Btrixj bij de lineaire array van B&B.
Daarna lukt het B&B geneste arrays ondanks die voor­sprong niet, om qua niveau op Btrix uit te lopen.k

Ten tweede, door herhaling van separatoren ver­dubbelt bij B&B de ex­pressieve kracht van hun geneste arrays, ten op­zichte van onze bel­nesten die elke sep positie apart indexeren.
We geven twee argumenten dat dit zo is:

Uit eerdere vergelijking in box 2.4 bleek, dat een structuur met unieke seps met index [n] op het 3e array niveau, dezelfde ge­tallen maakt als her­haalde seps met index [n1] op het 2e niveau.
Aas­blazer is een super radix, waar elke array apart reduceer­baar is, en dus blijft de gevonden pro­portie op ieder niveau van kracht. Maar omdat het puur om de data capa­citeit van struc­turen gaat, ver­wachten we dat ook in Bellen­blazer de unieke index arrays dubbel genest zijn ten opzichte van de her­halende, bij even grote uitkomsten.

Beide geneste structuren hebben we al eens compleet afgelopen met onze Alexal super radix. Toen bleek de structuur van unieke indexen op nest niveau's :kk: en :kk1: gelijk aan herhalingen in rijen op nest :k: niveau. En werkten we de vloei­bare arrays van Alexa uit tot tetratie, net als bij Aas­blazer: per nest een expo­nent erop.
Ook zochten we een natuurlijk algoritme, om de unieke index struc­tuur opnieuw te laden met sub­totalen. De eerste poging was Blixam die bel b oplaadde en verving door aas a. De tweede opzet heette half geneste arraysn en daar hielden we bel b en stuurden een kopie.

Chris Bird herhaalt14 elke separator, zodat zijn array niveau's twee keer zo­veel indexen bevatten dan bij unieke seps. Maar halvering van nest­diepte stelt weinig voor, verge­leken bij de array functies zelf.
Door de diepte op te blazen met een oplaad­bare index valt de factor 2 ver­schil in het niet. De wed­loop tussen Bellen­blazer nesten en Bird's geneste arrays gaan we in een volgend hoofdstuk nog eens na.

In deze sectie ontwikkelen we Bellen­blazer over de tweede dimensie, van rijen in een array vlak, ofwel matrix. Dat is net zo lang als we ons systeem kunnen vergelijken met het systeem voor grote getallen van de be­roemde wis­kundige Conway.

Conway's pijlketen15 [Conway's chained arrows] is een recur­sieve functie, die getallen ver voorbij de Ackermann functie noteert.
John H. Conway bedacht zijn pijl­keten als vervolg op Knuth's pijlen ofwel ^ super­machten. De enkele pijlen spelen hier dezelfde rol als komma's in een functie.

Vanaf de super­machten a{c}b = abc bouwde Conway verder aan zijn hyper­functie, die met elke volgende pijl een dubbele recursie nest in de voor­gaande eind para­meter.
Conway's expressie wordt van de rechter zijde opge­lost, waar­bij zowel de laatste zi als de voor­laatste para­meter yj weg­valt, zodra deze zijn afge­teld. Zonder deze posities opnieuw op te laden, wat ook niet kan, omdat in y het sub­totaal oprijst, door het uit­werken van de geneste sub­expressies.

Stapsgewijze definitie C.I van Conway's pijlen.

  • ab = ab
  • X1z = X
  • X1 = X
  • Xy1z1 = X(Xyz1)z == X(..X..)z :y:

Voorbij supermachten betreden we het domein van de hyper­machten en de snel groeiende hier­archie. Nogal vage aan­duidingen, waar Conway's pijl­keten con­crete grenzen stelt.
Bij herhaling zet z in y een dubbele recursie in over de keten. Is in de binnenste keten de positie y afge­teld, dan valt 1z daar rechts af. Over de hele lengte van de keten vormt dit een tripel recursie.

Graham's getal uit §2.2 kan hier met 3[,[1,2]65]5 bena­derd worden, via het nesten van super­sterren in het tweede item.
Dit Bellen­blazer getal is minimaal kleiner <≈ dan Graham's getal, de­zelfde ex­pressie met a=4 is al veel groter. Meestal nemen we het niet zo aas nauw met onze mini­maal groter ≈> bena­deringen.

  • a[,[,[1]2]c]b = a[,[,[]c,[1]1]b]a = a[,[c]b]a := a,[c]b = a*{c}b = ab(c-1)
  • a[,[1,2]2c]b := a,[,2]b,[1,2]1c = a,[b]a,[1,2]1c = a*{b}a,[1,2]1c = a*{a*{b}a}a,[1,2]c == a*{..b..}a :c1: ≈> ab(..ab..) :c: = abc12
  • a[,[2,2]1c]1b := a,[1,2]1b,[2,2]c = a*{..a..}a.,[2,2]c :b: ≈> aab2,[2,2]c ≈> aa(..b..)2 :c: ≈> abc3
  • a[,[1d,2]1c]1b := a,[d,2]1b,[1d,2]c ≈> aabd1,[1d,2]c ≈> aa(..b..)d1 :c: ≈> abcd2

Op zichzelf drukt Bellen­blazer's 1e index super­machten uit, net als een pijl­keten met 3 para­meters. Op de volgende rij houdt d gelijke tred met Conway's 4e para­meter.

Nu evalueren we Bellen­blazer's 2e index in verge­lijking met de hele pijl­keten van Conway. Over onze rijen e loopt index d ongeveer gelijk met Conway's de.. para­meters. En gelijker nog met een pijl­keten variant, die de laatste para­meter zou af­tellen tot 0 in plaats van 1.

  • a[,[,[1]3]c]1b := a,[c,2]1b ≈> aabc1
  • a[,[1,3]2c]b := a,[,3]b,[1,3]1c = a,[b,2]a,[1,3]1c ≈> aaab,[1,3]1c ≈> aab22,[1,3]c ≈> aabc12
  • a[,[1d,3]1c]1b := a,[d,3]1b,[1d,3]c ≈> aaabd1,[1d,3]c ≈> aabcd2
  • a[,[1,4]1c]b := a,[b,3]a,[1,4]c ≈> aaaab,[1,4]c ≈> aaabc2
  • a[,[d,4]1c]b ≈> aaabcd1
  • a[,[d,1e]1c]b ≈> a..bcd1 :e>0

Deze index e maakt in Bellen­blazer de sprong van super­machten over de hele lengte van Conway's pijl­keten. Onze tweede index is dus even snel als Bird's 4e element [entry]. Zie Bird's bewijs16 dat dit getallen in de orde van Conway's pijl­keten geeft.

{a,b,c,d} 
  a..bc1 :d
  ≈ a[,[c,d]b]a := a,[c,d]b

Na een langzame start produceert Bellen­blazer ge­tallen van maximale grootte. Vanaf hier zal elke (on­even geneste) array onge­veer gelijk aan Bird's arrays zijn. Dat zullen we steeds moeten be­wijzen, door onze output te verge­lijken met de systemen in de PDFs17 die Chris Bird bij MRob de­poneerde.
Wie er precies voorloopt nu? Misschien wil iemand onze demon­stratie over­doen, ten op­zichte van Bird's lineaire array functie…?

X

§2.7 Belnesten · dimensies

We werken de multi­dimensionale array van Bellenblazer uit, volgens de voor­lopige definitie voor twee geneste arrays en een derde niveau index uit sectie §2.6. Het belnesten van arrays is daar besproken.

Ook zoeken we het natuurlijke vervolg op Conway's en Knuth's pijlen. Dat kan behoor­lijko in de soep draaienp, dus voorzichtig aan!
Hier her­haalt extra super­pijl de voor­gaande operatie, net als bij Knuth, rechts associa­tief. Na deze super­operator kan weer een rij met para­meters volgen, te eva­lueren zoals Conway's pijl­functie.

  • x1! `= x
  • xy1 =` xxy == x..x :y
  • Xy1z1 = X(Xyz1)z == X(..X..)z :y:

Let in deze pijl­regels op het selectie accent ` voor de evaluatie:
Bij de linkse `= kan zowel X1Z = X als X1 = X een match zijn, waar­bij getal 1 door ! begrensd is.
De regel die met =` rechts aan het expressie einde de schakel x invoegt, laat de operatie zelf rechts staan. Her­haling ervan == smeedt de scha­kels dan tot een keten.

In de items hieronder is woord X slechts de eerste para­meter x. We bouwen verder met een functie­pijl z die een dubbele recursie nest in de lengte van Conway's pijl­keten, boven­op de tripel recursie.
Bellen­blazer stelt dat gelijk aan de eerste index, toege­voegd onder de tweede index, beiden op te laden uit de bel.

  • a[,[,[2]2]1c]b = a[,[,[1]1c]b]a := a,[b,c]a ≈> a..b :c1 ≈ bc2
  • a[,[1,[2]2]1c]b := a,[,[2]2]b,[1,[2]2]c ≈> ab1,[1,[2]2]c ≈> a(..b1..) :c: ≈ bc12
  • a[,[2,[2]2]1c]b := a,[1,[2]2]b,[2,[2]2]c ≈> ab2,[2,[2]2]c ≈> a(..b..)2 :c: ≈ bc13
  • a[,[,[1]2,[2]2]c]1b := a,[c,[2]2]1b = a,[']a,["]b ≈> aac,["]b ≈> a(..a..)c :b: = ab1c1

Het kan handig zijn om eerder genoemde sub­arrays niet te hoeven noteren in de verdere uit­werking. We kunnen index arrays quoten:
Een dubbele quote ["] om een index array [1X] uit de vorige regel te herhalen, en een enkele quote ['] voor de afge­telde versie [X] van deze array. Zoals altijd moet ook zonder kleuring van het niveau duidelijk zijn welke array er gequote is.

Van volgende ketens met dubbele recursies (type 2) telt de lengte met als de volgende tripel recursies (type 3).

  • a[,[1,[1]2,[2]2]1c]b := a,[']b,["]c ≈> aab1,["]c ≈> aa(..b..) :c: ≈> abc2
  • a[,[2,[1]2,[2]2]1c]1b := a,[']1b,["]c ≈> aab2,["]c ≈> aa(..b..)2 :c: ≈> ab1c3
  • a[,[,[1]3,[2]2]c]1b := a,[c,2,[2]2]1b = a,[']a,["]b ≈> aaac,["]b ≈> aa(..a..)c :b: ≈> aabc1
  • a[,[,[1]4,[2]2]c]b ≈> aaabc1
  • a[,[,[2]3]1c]b := a,[,1c,[2]2]b ≈> a.a..b1 :c ≈ abc1
  • a[,[,[2]4]c]b ≈> aabc

De 3e index in Bellen­blazer telt dus tripel recursies a.. op rij. Over de geneste index ,[2] groeit deze.

Operatoren {n} geven recursie types weer. Ze bestaan uit een functie­pijl met super­pijlen .. voor een recursie van type n2, die de exponenten van het vorige type n1 stapelt, para­meter op para­meter.

  • x{n}1 =` x
  • x{n1}y1 =` x{n}x{n1}y == x{n}..x :y

Bij gelijke para­meters a.. kunnen we de rij precies naar a↑↑ om­zetten. Anders is de meest rechtse expo­nent domi­nant (onder is dat b) en laten we deze bij bena­dering de eerdere repre­senteren.
Zo krijgen we een type 4 recursie, best ver!

  • a[,[,[3]2]1c]b := a,[,[2]1c]b ≈> a..b :c ≈ b↑↑c1
  • a[,[1,[3]2]1c]b := a,[']b,["]c ≈> a↑↑b,["]c ≈> a↑↑(..b..) :c: ≈ b↑↑c12
  • a[,[,[1]2,[3]2]c]1b := a,[c,[3]2]1b = a,[']a,["]b ≈> a↑↑ac,["]b ≈> a↑↑(..a..)c :b: = a↑↑b1c1
  • a[,[,[1]3,[3]2]c]1b := a,[c,2,[3]2]1b = a,[']a,["]b ≈> a↑↑aac,["]b ≈> a↑↑abc1

En daarop volgt weer een keten Xyz te evalueren met de C.I definitie van Conway's pijlen.
Onze eerste rij op het 2e niveau van Bellen­blazer arrays, loopt met de recur­sieve pijlen gelijk op.

  • a[,[,[2]2,[3]2]1c]b := a,[,1c,[3]2]b ≈> a↑↑.a..b1 :c ≈ a↑↑bc1
  • a[,[,[2]3,[3]2]c]b := a,[,c,[2]2,[3]2]b ≈> a↑↑abc
  • a[,[,[3]3]c]b ≈> a↑↑b↑↑c
  • a[,[,[4]2]1c]b := a,[,[3]1c]b ≈> a↑↑..b :c ≈ b↑↑↑c1
  • a[,[,[1d]2]c]b := a,[,[d]c]b ≈ b{d}c

Dit besluit de multi­dimensionale ruimte van Bellen­blazer arrays, waar elke positie een unieke index heeft. De grootte van de getallen die we hier kunnen schrijven, is ongeveer gelijk aan die van Bird's lineaire arrays18. Dat concluderen we uit de multi­dimensionale matrix Btrix in box 2.6 en demon­streren we in hoofd­stuk §3.1 nog eens met een direkt verge­lijkbaar systeem.

In dimensie d1 van Bellen­blazer werken we een rij type d2 recursie uit, waar elke para­meter op rij een vorig type d1 recursie plaatst.
Hogere recursies blazen het aantal dimensies recht­streeks op, wat het huidige plafond over­stijgt: met vlak type recursies en dubbele index.
Nu loopt onze kwalificatie van recursies nog achter bij die van array structuren, maar dit verschil zal bij dieper nesten insigni­ficant worden. We houden er dan ook mee op om recursies te indexeren en laten geneste arrays voor zich spreken.

Steeds zal Conway's recursie de in y afge­telde hele expressie (als sub­expressie) op de voor­laatste positie (van y) invoegen.
Stel dat we in de sub­expressie diepte een hyper­pijl a→→b tot een super­pijl herleiden en dan tot Conway's pijl­keten. Kunnen we zo'n hyper­pijl gebruiken om super­pijlen a{c}b te maken?

  • a→→b1 = a→→b = ab == a..1 :b
  • a→→1c = a
  • a→→22 = a→→a = aa = aa↑↑1 = a↑↑2

Nu is Xa→→22 = Xa(Xa) groter dan Xa↑↑2 en dus mag er links geen keten X vooraf gaan.
Al snel loopt het nog erger mis. Tot een formule van de vorm abc = a{c}b komen we hier niet mee.

  • a→→32 = a→→(aa) = a(aa) < a↑↑3 = aaa
  • a→→b2 << a↑↑b

En wie X→→y→→z van rechts tot X{z}y terug­brengt, die noteert twee hyper operaties voor de prijs van één.
Hoe zou u het doen, de eerste hyper­pijl →→ formuleren…?

X

§2.8 Belnesten · hypers

In Bellen­blazer arrays is elke iterator voor­zien van een eigen index. Er staan recursieve indexen op elke nest diepte. Daarom dienen onze arrays twee keer zo diep genest te worden als de array ruimtes van Chris Bird15 voor even grote getallen. Zie googo­logie box 2.6.

Hier werken we geneste arrays in Bellen­blazer uit, vanaf de expressie a[,[,[d]2]c]b van dimensie d multi­dimensionale arrays, waar­mee we de vorige sectie §2.7 eindigden. En opent zich de hyper-dimensie van onze compleet geïndexeerde arrays.

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

  • B.0. a[]bp = pb
  • B.1a. a[b,Z]p = a[,Z]bp B.1b. ,[]1 `= 1
  • B.2. ,[V1]1!0
  • B.3a. [,[1V]2 `= [,[V],[1V]1 B.3b. ],W]2p `= ]2p,W] B.3c. a[X]! `= a[X]a

Als we regel B.3a. in de top array toepassen, is het de bel b=2p die een lege para­meter oplaadt per B.3b. en wordt per B.3c. de lege bel door a vervangen. Maar daar­door kan de index in de nieuwe array [,V] tot nul zijn afge­teld, zodat ook dit eerste niveau moet worden aan­gevuld. Als dat zo door­gaat dalen we steeds verder af: in een cascade van azen en bel naar de diepste array.
De cascade werkt evaluatief precies zo, dat sub­totaal b tot boven een array wordt getrans­porteerd, vlak vóór­dat daar de nood­zaak ont­staat om een diepe iter op te laden.

Doordat we elementen opruimen bij iter 1 kan de lege iter 0 gebruikt worden als tijdelijke waarde binnen de samen­gestelde regel.
Merk op dat een situatie ]]2p daarbij niet ont­staan kan, zolang we strikt l-r met regels B.3. bezet blijven en niet voor­tijdig per B.2. de afge­telde [V]1] van rechts laten weg­vallen.
De regel met de match die het meest links in de expressie begint krijgt voor­rang in de evaluatie, niet de match die als eerste rechts eindigt.

Door de hogere lege iters in de cascade opnieuw te vullen met aas a, komen er natuurlijker grote getallen tot stand, dan door simpel­weg b overal te substi­tueren. Dat toonden we met machten aan in §2.5 op de eerste Bellen­blazer rij.
Of de afdaling van bel b, die maxima­liteit garan­deert, alleen werkt met cascades a, waar­van de definitie steeds uitge­breider (en strikter) zal worden, valt te bezien…!?

Met het opladen van de eerste index op het 3e niveau nemen we de cascade van de regels B.3. pas hele­maal in gebruik.
Analoog daaraan komt er boven­op de hyper­pijl →→ een functie­pijl met para­meter, die om te beginnen dimensies nummert.

  • a[,[,[3,2]2]2]2 := a,[,[2,2]2]2 = a,[,[1,2]2]a = a,[,[,2]a]a = a,[,[a]a]a ≈> a{a}a = a→→aa
  • a[,[2,[1,2]2]2]1b := a,[1,["]2]1b = a,[,["]2]a,[1,["]2]b = a,[,[']a]a,[1,["]2]b = a,[,[a]a]a,[1,["]2]b ≈> a→→aa,[1,["]2]b ≈> a→→a(..a..) :b: ≈> a→→ab2
  • a[,[3,[1,2]2]2]1b := a,[1,["]2]a,[2,["]2]b ≈ a→→aa2,[2,["]2]b ≈> a→→ab3
  • a[,[c,[1,2]2]2]1b ≈> a→→abc
  • a[,[d,[1,2]2]1c]b := a,[']b,["]c ≈ a→→abd,["]c ≈> a→→bcd1

Het is even zoeken om bel b naar de diepste index te trans­porteren, wat de vaart erin moet houden bij het maken van grote getallen.
Blijkt dat de eerste Bellen­blazer index een dubbele recursie bij doet. En de tweede index de operatie stapelt, ofwel een pijl­keten lengte, oftewel een extra tripel recursie.

  • a[,[1,[1]2,[1,2]2]1c]b := a,[']b,["]c = a,[b,[1,2]2]a,["]c ≈> a→→aab,["]c ≈> a→→aa(..b..) :c: ≈> a→→abc2
  • a[,[2,[1]2,[1,2]2]1c]b := a,[']b,["]c ≈ a→→aab2,["]c ≈> a→→abc3
  • a[,[,[1]3,[1,2]2]c]1b := a,[c,2,[1,2]2]1b ≈> a→→aabc1
  • a[,[,[2]2,[1,2]2]1c]b := a,[b,c,[1,2]2]a ≈> a→→.a..b :c1 ≈> a→→bc1
  • a[,[,[2]3,[1,2]2]c]b ≈> a→→abc

Algemeen stapelt zowel de index ,[n]1p als de pijl {n}p1 een rij van p recursies van type n+1. Dat vormt de tweede →→ hyper­pijl. En over index ,[1,2]1r de hele 1e hyper rij met :r pijlen.
Dit verspilt een hoop tekens, maar kan niet anders, omdat getallen die de Bellen­blazer index links noteert, na elke hyper →→ rechts komen te staan. Pijl­functies zijn langzamer, omdat elke 1Z weg­valt. Her­laden vanuit de bel is duidelijk superieur.

  • a[,[,[3]2,[1,2]2]c]b := a,[,[2]c,[1,2]2]b ≈> a→→.a..b :c ≈> a→→b↑↑c
  • a[,[,[3]3,[1,2]2]c]b ≈> a→→a↑↑b↑↑c ≈ a→→c↑↑↑3
  • a[,[,[1,2]3]c]b := a,[,[']c,["]2]b = a,[,[c]b,["]2]a ≈ a→→a{c}b = a→→a→→bc
  • a[,[,[1,2]1d]c]b := a,[,[']c,["]d]b = a,[,[c]b,["]d]a ≈ a→→..bc :d ≈> abc→→d1

En ja, zulke getallen zijn verschrikkelijk :-( groot.
We hebben nu genoeg voor­beelden gezien, om de algemene definitie van dit soort {m}{n} pijl­functies te geven. We noemen ze:
Conway-Knuth hyper-recursieve pijlen
Dat klinkt best :-) tof. We staan hier overigens pas aan het begin van Bird's hyper-dimensionale arrays.18

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

  • =: {m}{n} {mn>0} =: {p}{q} {p=1||q>0}
  • y*z ==` y.. :z
  • y1 =` y (init z)
  • !1z =` 1 (init y)
  • yz1 =` y*yz == y*..y :z
  • yz1 (Knuth recursie) =` yyz == y..y :z
  • ab = ab
  • X1y1z1 (Conway recursie) = X1(X1yz1)z == X1(..X1..)z :y:
  • z =` z
  • yz1 (hyper recursie) =` yz == {z1}y

Conway's recursie wordt met 1 beperkt, hetzij tot opera­toren met een enkele functie­pijl {q0} en nul of meer super­pijlen (voor het multi­dimensionale gebied), hetzij tot hyper­pijlen {p2}{q1} en één of meer super­pijlen (in het hyper­dimensionale). Gevallen van met alleen super­pijlen komen vanzelf niet voor in de evaluatie trein.

Hyper-recursie heeft een staps­gewijze definitie voor pure hyper­pijlen {p2} zonder super­pijl, waar die rare mix alleen in de tussen­stappen staat. We gebruiken verder geen gemixte pijlen.
Ook deze regels zullen nooit een match van vinden zonder hyper­pijl, tijdens de evaluatie van propere pijl­expressies.

Stel dat we een wat snellere regel in de stijl Conway hyper-recursie ver­zinnen. Zet dat zoden aan de dijk…?

  • Xy1z1 (hyper Conway test) = X(Xyz1)z
  • x→→y12 (test voorbeeld) = x(x→→y2) == x↑↑(..x..) :y: = x↑↑y12

Nee, want uit het voorbeeld blijkt, dat dit nog geen Conway para­meter zou schelen. In hyper-dimensies is dat futiel.
Gaan we verder met de 2e hyper rij in Bellen­blazer.

  • a[,[2,[2,2]2]2]1b := a,[1,["]2]1b = a,[,[']a]a,[1,["]2]b ≈> a→→a,[1,["]2]b ≈> a→→(..a..) :b: = a→→b12
  • a[,[3,[2,2]2]2]1b := a,[1,["]2]a,[2,["]2]b ≈> a→→a2,[2,["]2]b ≈> a→→b13
  • a[,[c,[2,2]2]2]b ≈> a→→bc
  • a[,[1,[1]2,[2,2]2]1c]b := a,[b,[2,2]2]a,["]c ≈> a→→ab,["]c ≈> a→→a(..b..) :c: ≈> a→→bc2
  • a[,[,[2]2,[2,2]2]1c]b := a,[b,c,[2,2]2]a ≈> a→→.a..b :c ≈> a→→bc

Evaluaties voor index separator ,[2,2] nemen we over van eerdere uit­werkingen waar ,[1,2] de verste sub­array is. Daarin zagen we index ,[c] die supers {c} telt om hypers →→ te vormen.

  • a[,[,[']2,[2,2]2]c]b := a,[,[,2]c,["]2]b = a,[,[c]b,["]2]a ≈> a→→a{c}b = a→→a→→bc
  • a[,[,[2,2]3]c]b := a,[,[']c,["]2]b ≈> a→→b→→c
  • a[,[,[3,2]2]1c]b := a,[,[2,2]1c]b ≈> a→→..b :c ≈> ab→→↑↑c
  • a[,[,[2d,2]2]1c]b := a,[,[1d,2]1c]b ≈> a→→{d}..b :c ≈> ab→→{d1}c = ab→→→cd1
  • a[,[,[1d,2]3]1c]b := a,[,[']1c,["]2]b ≈> a→→→b→→{d}c = a→→→b→→→cd

Het einde van het stapelen van en pijlen komt in zicht. En ,[,e] gebruikt nog maar de eerste ,[1] hyper-index in Bellen­blazer.

  • a[,[,[1d,e]2]1c]b ≈> ab{e}{d}c = ab{e1}cd
  • HERSENWERK IN UITVOERING
  • a[,[,[1e,f]2d]1c]b ≈> a{f1}..b{f}{e}c :d ≈ ab{f1}..ce :d1 ≈> abc{f1}d1e ≈> abcd{f2}e

Vanwege het succes van index arrays zouden woorden in haakjes ook aan Conway-Knuth pijlen kunnen hechten. We stellen ons een wijzer­pijl voor, die fungeert als sluit­haakje en terug ver­wijst naar een stop­pijl op de plaats van een openings­haakje. Beide pijlen dragen dezelfde identi­ficatie tag T die hun verband aan­geeft.
De syntax is TXT met tag T die uit diverse pijlen kan bestaan. Als T=0 dan zijn dit gewone haakjes (X) en verder is de variatie aan haakjes indexen voor woorden X, die hogere pijl­typen be­schrijven, haast even groot als de ermee uitge­drukte getallen. Al die woorden kunnen ook weer worden genest, door elkaar ook, zolang hun begin tags T maar een­duidig vind­baar blijven.
Het zijn net tags <T> met X tekst inhoud </T> in html.

We verwachten dat diepe cascades van azen niet gemak­kelijk van een definitie kunnen worden voorzien. Simpeler is om groei­bel b uniform te substi­tueren, analoog aan ons Aas­blazer radix systeem A.II dat de constante a overal oplaadt. Zo durven we de vergelijking met Bird's systemen wel aan.

Om de natuurlijke ontwikkeling van Aas­blazer te blijven monitoren, hebben we met onze Bellen­blazer cascade versus de Conway-Knuth hyper-recursie pijlen voor­lopig genoeg grote getallen op voor­raad.
In het vervolg van Bellen­blazer itereren we over array nest diepte met diepen, 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 aritmetisatie18 van onze (ongeveer) maximale systemen zelf kunnen vormen. Dat wil zeggen, mits de introductie van nieuwe operator tekens te automa­tiseren valt, dan zijn deze telbaar en kunnen we erover itereren in een hogere array functie. Zulke cycli van aritmetisatie kunnen we in theorie indexeren met een volgend hogere array functie. Ad infinitum…

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

Tenslotte deze opzet voor bellen­blazerij met een strikte l-r notatie van kleine naar grote concepten in RGB kleuren.
Hiermee eindigt mijn Reuzen Getallen Bootstrap werkversie voor de expositie:

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

a. De natuurlijke getallen kunnen we met louter cijfers 1 uitdrukken in wat ik noem: hun eenvoudige vorm. gg: Enen en operatoren in "Constructie van Grote getallen" (novaloka.nl 2009) met links naar gg's oude weblogs.
b. Open een volgend tel-register. Zo telt Cantor rechts op in het oneindige., gg: Countable infinity voor weblog (concept 2016).
c. Laat me je horizon wat verder weg duwen, gg: Beyond the Abacus in "On the number horizon" (novaloka maths blogs 2007).

d. Keer de richting van de para­meters om, zodat de laatste para­meters de grotere ge­tallen maken, gg: Péter's recursion in "Number operations" voor bigPsi (concept 2011).

e. Een combinatie van gemixte ster indexen, gg: Mixed minority stars in "Number operations" voor bigPsi (concept 2011).

f. Sommige verzamelingen getallen kunnen niet oneindig worden afgeteld, gg: Count from omega in "Bigger" voor Btrix matrix (iteror 2014).
g. Omega-telbaar binnen een bigOmega functie, gg: Omega oneindigheid in "Mathmuis... plaatst een Record Getal" voor NAW (concept 2010).
h. Een volgende grotere oneindigheid in Omega Ω, gg: Higher omega in "Omega jumps" voor Btrix matrix (iteror 2014).

i. Hoe heten de grote getallen?, gg: Nummer namen App in "Ogen op Stokjes!" voor de jeugd (iteror 2014).
j. Bird's lineaire array lengte is gelijk aan Btrix' multi­dimensionale index, gg: Cubic and Dimensional in "Bea's dimensions" voor Btrix matrix (iteror 2014).
k. Btrix dim-rij wisseling is even snel als Bird's rij-dim wisseling, verder nesten ver­andert deze struc­turele afstand niet, gg: Nesting depth in "Beat nested arrays" voor Btrix matrix (web 2014).
l. Als alle sub­structuren uniek zijn, ver­dubbelt dit het aantal geneste niveau's, gg: Sentry to row format in "Alexa 2nd - Fluid Structures" voor Brobding­nagians (blog feb 2015).
m. Hoofdregels: opladen, subladen, gg: Blixa system in "Blixa Nested Arrays" voor Brobdingnagians blog (concept apr 2015).
n. Onze arrays zijn half genest, gg: Half nested arrays in "Big number systems" voor Iteror (blog okt 2015).

o. Extensie van Knuth-Conway stijl pijlen, om array functies mee te vergelijken, gg: Big Arrows Compass voor Brobdingnagians (blog dec 2012).
p. Pijlen naar het noordwesten schieten, gg: Big Arrows Compass I en II met een anekdote van prof. Gill, hoe prof. Conway het schoolbord van ωω naar εε draaide, op xs4all en Brobdingnagians blog (concept jan 2013).

q. Een herschrijf algoritme voor diepe series arrays, gg: Serial deeps in "Deep attachments" voor Btrix matrix (concept 2014).
r. We definiëren een systeem van diepe arrays of diepen, gg: Deep numbers in "Big number systems" voor Iteror (blog mei 2015).
s. Los diepe ster operaties met arrays net zo op als superster operaties met getallen, gg: Birth of the Superdeep in "Big number systems" voor Iteror (blog mei 2015).

1. Er zijn snellere manieren om getallen te vermenigvuldigen, ch.11 in Arndt & Haenel "Pi – Unleashed", 2001.

2. Recursie met k variabelen leidt niet buiten de klasse van de primitief recursieve functies, p.75 in Rozsa Péter "Recursive Functions" 1967, 1950.

3. Het is belangrijk om te begrijpen dat eindige getallen extreem groot kunnen zijn, in Donald Knuth "Coping with Finiteness" 1976.
4. Een vergaande generalisatie van Ramsey theorie [grafen theorie], Martin Gardner over Graham's number, in "Mathe­matical Games" Scientific American, Nov. 1977.
5. Het hoogste getal dat ooit in een rekenkundige proef werd gebruikt, Guinness over Graham's number, p.59 in "Het groot Guinness record boek" 1989.
6. Deze bovengrenzen zijn meestal enorm, Ron Graham over Graham's number, in R.L. Graham & B.L. Rothschild "Ramsey's theorem for n-parameter sets" 1971.
7. Deze recursies [over c] zijn geen normale, staps­gewijze, in David Hilbert "On the infinite" 1925, p.388 in "From Frege to Gödel" 1967.
8. De functie F(a,a,a) neemt sneller toe dan elke type 1 functie in Wilhelm Ackermann "On Hilbert's con­struction of the reals" 1928, p.495 in "From Frege to Gödel".
9. Het is voldoende om een tweetallige 'majorant' ψ(m,n) te definiëren, p.106 in Rozsa Péter "Recursive Functions" 1967.
10. Elke klasse En van recursieve functies is gesloten onder de operaties van substi­tutie en beperkte recursie, in Andrzej Grzegorczyk "Some classes of recursive functions" 1953.

11. Hoe codeer­systemen, codes en unieke descripties relateren aan waarschijn­lijkheid, ch.4 in Peter D. Grünwald "The minimum description length principle" 2007.
12. Het begrip random bij getallen heeft vele lagen, p.124 in Gregory Chaitlin "Meta maths, the quest for omega" 2005.

13. Zolang de Bel leefde was de Bellen­blazer buiten zichzelf geweest, uit Peter Sloterdijk "Sferen" 2005, p.219 in Joke Hermsen "Stil de tijd" 2009.

14. Bird's geneste arrays zijn recursieve functies met limiet ordinaal ε0, Christopher M. Bird, Nested Array Notation, 2012.
15. Onze eigen pijl­keten notatie benoemt nog veel grotere ge­tallen, p.61 in Conway & Guy "The Book of Numbers" 1996.
16. Bewijs dat Bird's lineaire array met 5 of meer elementen voorbij Conway's pijl­keten gaat, Christopher M. Bird, Proof, 2006.
17. Een systeem voor snel groeiende recursieve functies, dat de functies van Jonathan Bowers en anderen ver te boven gaat, in Chris Bird's Super Huge Numbers, een serie van 9 PDFs over Bird's arrays + 3 bijlagen, 2017.

18. Codeer tekens en woorden als getallen, ch.5 in John Stillwell, "Reverse Mathematics", 2018.

Gulliver redt de vloot van Lilliput

Blogboek  index

  1. Tellen
  2. Rijen
    1. Herhalen
    2. Machten
    3. Supermachten
    4. Aasblazer
    5. Aasnesten
    6. Bellenblazer
    7. Belnesten · rijen
    8. Belnesten · dimensies
    9. Belnesten · hypers
  3. Diepen

© 1968,2018
Giga Gerard