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.

Hier in sectie §2.0 her­halen we getallen, wat vermenig­vuldigen is. Ook presen­teren we een meta notatie om groepen tekens te herhalen.
Blog §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 super­sterren, die we strikt l-r eva­lueren met behulp van pop­sterren. Een bijzonder systeem zijn de hek­machten, die op halve super­snelheid gaan.

Het thema hier in serie §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. Onze super radix werkt met substi­tutie van een constante a, de aas, wat in grotere arrays mini­maal wordt. Onze array functie verzamelt en verlaadt een sub­totaal b, de bel, wat 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.

Geleidelijk ontwikkelt zich een taal bij de wiskunde van grote getallen en een notatie in html ascii. Ook geven we een natuur­lijke ex­tensie van Knuth en Conway's pijlen, die de lezer verder uit mag werken…
Puntjes zijn hints voor over­denking of oefeningen.

Lectori salutem Welkom aan boord.

X

§2.0 Herhalen

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

# Metamatiek 2.0

We gebruiken twee meta notaties voor tekst herhaling, bedoeld om de uit­werking van ex­pressies inzich­telijk te maken.
Met de regex notatie herhalen we een enkel teken (karakter) door het aantal ervan {n} erna tussen krul­haken te plaatsen.

In onze repex notatie selec­teren we een rij tekens (groep) tussen punt . of grens van de expressie en twee .. punten. We kunnen deze groep naar links of naar rechts herhalen of we herhalen twee groepen van buiten naar binnen toe.

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

Het aantal herhalingen staat rechts van de expressie in de rep met de : dubbele punt. Een rep :n telt de groepen in de repetitie van links naar rechts bij, of n: van rechts naar links, of dubbel­zijdig :n: van buiten naar binnen.

Mogelijke index variabelen i of j incrementeren tijdens de repetitie. Vanaf begin waarde i=1 neemt die index per stap 1 toe, tot aan de laatste index i=n. Het aantal stappen en de richting ervan blijkt uit de rep, de groep en de plaatsing in de reeks uit de selectie op de punten.

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.
De evaluatie trein rijdt van vertrek expressie (de input) naar aankomst expressie (de output) en heeft vele tussen­stations (reducties).

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(3) is (logaritme basis 2).
Kampioen met c'*d*Log(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.
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: & 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 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.

# 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 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) die we later bespreken, 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)

Als we onze Griffioen functie uit­werken, dan neemt super­macht c 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 wezen­lijk bij aan het maken van grotere ge­tallen, als die recur­sies op zich al super­machten op­leveren.

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…?

X

§2.2 Supermachten

Nadat machtsverheffen lange tijd de hoogste operatie was, vond de algo­ritme kenner Donald Knuth3 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 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 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 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 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 :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. 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 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}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 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 deze structuren 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] 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.

# Googologie 2.3

Een array is een reeks variabele getallen, met een sep­arator 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 ite­ratie 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 afkor­ting 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 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.,[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 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 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 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.

# 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 moge­lijk zijn.
Hierboven in Aas­blazer representeert de eerste index d dat meer­voud. De index rij in S zou daarop met e beginnen, waar de meer­voudige e index moet ite­reren 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 ook cijfers 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 esthe­tiek, dat uniek index­eren de natuur­lijke 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 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…?

X

§2.5 Bellenblazer

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 b0 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­blazen13 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 Cantorf, 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 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 {aZ} := 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 gehele 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 ongeveer gelijk aan.
≈> 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
  • [f0.,[1ni]fi..]a :r {f>0} = f0.+*{ni}a*{1ni}fi.. :r = ..a^{ni}fi\*{ni}.f0 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…?

X

§2.6 Belnesten · vlak

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…i 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]00
  • 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.

# Googologie 2.6

De array functies van Bowers & Bird (B&B) rollen series van gelijke separa­toren uit. Dit schept een ruimtelijke structuur, waar de­zelfde index arrays in verschil­lende posities kunnen staan.
Zowel 1.) de B&B snellere start, als 2.) de B&B arrays met herhaalde indexen, zijn over­bodig voor het maken van grote getallen, zodra we de nest diepte direkt opblazen.

Het 1e) bleek uit ons Btrix systeem, dat langzaam op gang komt, maar net als B&B sub­arrays her­haalt. Met het begin trio drukt Btrix dubbele recursie uit, net als de eerste rij in Bellen­blazer. Met de index voor dimensies benadert Btrixj de lineaire array van B&B. Ondanks de voor­sprong van B&B lopen zij met hun geneste arrays niet verder uit op Btrix, qua niveau.k
Ten 2e), door herhaling van seps ver­dubbelt bij B&B per genest array niveau de ex­pressieve kracht, ten op­zichte van onze bel­nesten die elke sep apart indexeren. We geven hier twee argu­menten voor:

2a.) Uit de 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.

2b.) Beide geneste structuren hebben we al eens afgelopen met onze Alexal super radix. Toen bleek de structuur van unieke indexen op genest niveau :kk: en :kk1: gelijk aan herhaalde indexen op :k: niveau. We werkten de vloei­bare arrays van Alexa uit tot tetratie. En net als bij Aas­blazer kwam per nest een expo­nent op de machts­toren.
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 ver­laadde 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 bel op/inlaad recursie, in de wed­loop tussen Bellen­blazer en Bird's arrays. Door hierna de diepte op te blazen met de bel valt die factor 2 ver­schil in het niet.

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 pijlketen15 [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. Zijn enkele pijlen spelen dezelfde rol als komma's in een array functie.

Vanaf super­machten a{c}b = abc 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 1z 0 vallen weg, zodra z of y zijn afge­teld.

Stapsgewijze definitie C.I van Conway's pijlen.

  • ab = ab
  • X1z = X
  • X1 = X
  • Xy1z1 = X(Xyz1)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 Bird16. 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 = aab- = a2b
  • [,[2]b,[1,1]1]a := a**b,[1,1]1 = a*{a^b}a ≈ ab22 {ab}
  • [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: ≈> ab(..ab..) :c: = abc12
  • [1b,[2,1]1c]a := a,[1,1]b,[2,1]c = a*{..a..}a.,[2,1]c :b: ≈> aab2,[2,1]c ≈> aa(..b..)2 :c1: ≈> ab1c13
  • [1b,[1d,1]1c]a := a,[d,1]b,[1d,1]c ≈> aabd1,[1d,1]c ≈> aa(..b..)d1 :c1: ≈> ab1c1d2

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- ≈> aaa-b1
  • [b,[1,2]1c]a := ,[b,1]a,[1,2]c ≈> aaab,[1,2]c ≈> aab22,[1,2]c- ≈> aabc12
  • [1b,[1d,2]1c]a := a,[d,2]b,[1d,2]c ≈> aaabd1,[1d,2]c ≈> aab1c1d2
  • [b,[1,3]1c]a := a,[b,2]a-,[1,3]c ≈> aaaab,[1,3]c ≈> aaabc12
  • [b,[d,3]c]a ≈> aaabcd1
  • [b,[1,e]1]a ≈> a..b :e1>2
  • [b,[d,e]c]a ≈> a..bcd1 :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 bewijs17 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..bc1 :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…!

X

§2.7 Belnesten · dims

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 regex19 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 ergo in de soepp 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.

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

Met 1! in de eerste regel schieten we op X1Z = X en tegelijk op X1 = X die beide met para­meters 1 matchen.
De tweede regel voegt vanaf rechts =! de Conway schakel x in en laat de ope­ratie xy 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 ≈> ab2
  • [b,[1,1,[2]1]1c]a := ,[b,[2]1]a,["]c ≈> ab2,["]c ≈> a(..b2..) :c1: ≈> ac22 {a=b}
  • [b,[2,1,[2]1]1c]a := a,[1,1,[2]1]b-,["]c ≈> ab2,["]c ≈> a(..b..)2 :c1: = ac23 {a=b}
  • [b,[d,1,[2]1]1c]a := a,[-"]b-,["]c ≈> abd,["]c ≈> ac2d1 {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 ≈> aab1,["]c ≈> aa(..b1..) :c1: ≈> abc12
  • [1b,[d,2,[2]1]1c]a := a,[-"]b,["]c ≈> aabd,["]c ≈> aa(..b..)d :c1: ≈> ab1c1d1
  • [b,[1,3,[2]1]1c]a := ,[,3,[2]1]b,["]c = a,[b,2,[2]1]a-,["]c ≈> aaa-b1,["]c ≈> aaa(..b..) :c1: ≈> aabc12
  • [b,[d,3,[2]1]1c]a := ,[-"]b,["]c ≈> aaab-d,["]c ≈> aabc1d1
  • [b,[1,1e,[2]1]c]a ≈> a.ab..c2 :e
  • [b,[d,1e,[2]1]c]a ≈> a.ab..cd1 :e ≈> aae2 {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 = aab1
  • [1b,[2,1,[2]2]1]a := a,[1,1,[2]2]b ≈> aaa,["]b- ≈> aa(..a..) :b: ≈> aab2
  • [b,[1,2,[2]2]1]a := a,[b,1,[2]2]a- ≈> aaa-b1
  • [1b,[1,1,[2]3]1]a := ,[a,b,[2]2]a =: a,[1a,b,[2]2]1 ≈> aa.a..a :b = aaab1
  • [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 Xyz 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↑↑ab1
  • [1b,[1,1,[2]2,[3]1]1]a := ,[a,b,[2]1,[3]1]a ≈> a↑↑aa.a.. :b = a↑↑aab1
  • [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.18
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→→b1 = a→→b = ab == a..1 :b
  • a→→1c = a
  • a→→22 = a→→a = aa =: aa↑↑1 =: a↑↑2

Stel dat X→→22 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→→32 reduceert tot a→→(a→→a) en a(aa) dan is dat kleiner dan de aaa 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…

  • ab12 = aab2 == a..a12 :b = a..a :b = a↑↑b1
  • ab12 = aab11 = aab1 = a(aab) == a(..aa1..) :b = a(..a..) :b1 = a↑↑b1
  • ab2 = ab1 = ab = 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→→b2 =! 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…?

X

§2.8 Belnesten · hypers

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.14 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]00 (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→→ab
  • [1b,[2,1,[1,1]1]1]a := a,[1,1,[1,1]1]b ≈> a→→aa,["]b- ≈> a→→a(..a..) :b ≈> a→→ab2
  • [1b,[1c,1,[1,1]1]1]a := a,[c,1,[1,1]1]b =: a,["]1,["]b- ≈> a→→aa-c,["]b- ≈> a→→a(..a..)-c :b ≈> a→→abc1

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→→aab
  • [1b,[2,2,[1,1]1]1]a := ,[a,1,[1,1]1]a,[-"]b- ≈> a→→aaa,[-"]b- ≈> a→→aab2
  • [1b,[1c,2,[1,1]1]1]a := ,[--"]a,[-"]b- =: a,[-"]1,[-"]b- ≈> a→→aaa-c,[-"]b- ≈> a→→aabc1
  • [b,[1,d,[1,1]1]1]a ≈> a→→.a..b :d
  • [1b,[c,d,[1,1]1]1]a ≈> a→→.a..bc :d = a→→ad2 {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→→ab1
  • [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→→ab
  • [1b,[1,1,[2,1]1]1]a := ,[a,["]b]a =: a,[1,1,["]b]1 ≈> a→→..aa :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 1Z 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.16

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}yz vanzelf niet zo voor in de evaluatie trein.

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

  • y*z ≡ y.. :z
  • y1 =! y (init z)
  • yz1 =! y*yz (macht) == y*..y :z
  • yz1 (Knuth pijlen) =! yyz == y..y :z
  • 1z =! 0 (init y)
  • Xy1z1 (Conway pijlen) = X(Xyz1)z == X(..X..)z :y:
  • xy = xy
  • z =! z (pijl init)
  • yz1 (Hyper pijlen) =! yz == {z}y1 =! {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→→b12
  • [b,[1,2,[2,1]1]1]a := ,[b,1,[2,1]1]a ≈> a→→aab
  • [b,[1,1,[2]1,[2,1]1]1]a := ,[a,b-,[2,1]1]a ≈> a→→ab
  • [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→→ab
  • [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→→→ab
  • [1b,[1,1,[2,2]1]1]a =: a,[1,1,[1,2]b]1 ≈> a→→→..aa :b ≈> a→→→b1
  • [b,[1,1,[1,3]1]1]a =: a,[1,1,[1b,2]1]1 ≈> a→→→{b}a = a→→→→ab
  • [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}aa

Uit deze patro­nen leiden we een formule met meer­dere para­meters af. Wat meer 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}fm

Twee maten bepalen deze duale pijlen: het aan­tal Conway {n} hypers en het aan­tal Knuth {m} supers. Wat over­een komt met de twee indexen m,[1]n van dimensie m en de eerste hyper­dimensie n in Bellen­blazer.
Voor hogere indexen zullen we de struc­tuur en het algo­ritme van deze hyper­pijl functie verder moeten expanderen.

We hadden de Conway-Knuth definitie ook op kunnen zetten als een gemengde pijlen­mix {mi}.. met :n1 maten mi in serie. Dat is dan te verge­lijken met de rij hyper-indexen [m0.,[i]mi..] :n in Bellen­blazer.
Zulke hyper­pijlen stapelen al de vorige functies weer 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 kunnen hier al rijen indexen of pijl arrays S aan Conway's functie hechten.
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 in de stijl van blazer sys­temen. Steeds komen 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 verge­lijkt met matrix dimensies ,[m] in Bellen­blazer. Zodat onze index [p] van hyper-dimensies gelijk komt met Bird's multi-dimensies en iter n daar­over de lengte aan­geeft van zijn dimensies. Ons element ,[p]n loopt dus twee niveau's achter.

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. Onze index [s] op het vijfde niveau eve­naart dus 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 PDFs18 die Chris Bird bij MRob deponeerde, in het volgende hoofdstuk.
Daar zullen we overal een groei­bel a substi­tueren, zoals de Aas­blazer radix A.II overal constante a oplaadt. En we verge­lijken deze blazer Wielewaal met een systeem Vogel, dat niet zo mas­sief is als Bird maar dui­delijk gelijk­waardig.

Denkwerk in uitvoering

De syntax is S met tag S die uit diverse pijlen kan bestaan. Als S=0 dan zijn dit gewone haakjes (X) maar verder is de variatie aan haakjes indexen voor woorden X, die hogere pijl­types be­schrijven, bijna even groot als de ermee uitge­drukte getallen. Al die woorden kunnen weer worden genest, door elkaar ook, zolang hun begin tags T maar een­duidig te vinden zijn.
Het zijn net tags <T> met X tekst inhoud </T> in html.

Om de natuurlijke ontwikkeling van Aas­blazer te blijven monitoren, hebben we met onze Bellen­blazer cascade versus de Conway-Knuth hyper-recursie 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 aritmetisatie20 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, behandelt recursieve functies met limiet ordinaal ε0, Chris 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. Is een [a,b,c,...] dimensionale array, Chris Bird, p.1 in Hyper-Dimensional Array Notation, 2017.
17. Bewijs dat Bird's lineaire array met 5 of meer elementen voorbij Conway's pijl­keten gaat, Chris Bird, Proof, 2006.

18. Een systeem voor snel groeiende recursieve functies, dat de functies van Jonathan Bowers en anderen ver te boven gaat, in Christopher M. Bird's Super Huge Numbers, een serie van 9 PDFs over Bird's arrays + 3 bijlagen, 2017.
19. Vindt de eerste positie in de string waar een match mogelijk is, §11.1.3.1 Nongreedy repetition, in David Flanagan "JavaScript" 2006. [bijv. ook lui patroon a*?b matst aaab geheel].

20. Codeer tekens en termen 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 · vlak
    8. Belnesten · dims
    9. Belnesten · hypers
  3. Dieper

© 1968,2018
Giga Gerard