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 wezenlijk bij aan het maken van grotere ge­tallen, als die recursies 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
    === 2541865828329+*3**1
      = 3*2541865828329.
     == 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, want er spelen twee recursies: een grote met iter­ator c over een kleine met iter­ator b en een constante a>1.

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

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

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

# Demonstratie 2.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  • a*{c1}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 structuren voor algo­ritmes blijkbaar de enige natuur­lijke alter­natieven…

X

§2.3 Aasblazer

Aas [ace] is hoe we de linker operant a noemen, die constant blijft. In de primitief recur­sieve stap van onze blazer [blazer] functies telt a op bij varia­bele b, de bel [bubble]. Deze wordt gedurende de evaluatie steeds groter, tot de bel op het laatst de uit­komst [output] 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.
Variabelen a en b reserveren we voor aas en bel links buiten de top array en links erbinnen. Alle varia­belen in deze regels zijn natuur­lijke ge­tallen vanaf 0. Maar een cijfer 0 valt meteen weg tegen een getal ernaast of een lege array variabele 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 ,[0]p in het midden laten we met rust, tot voor­gaande indexen zijn ver­dwenen en de lege array bij [b aan­komt. Pas dan popt deze sep­arator weg, zodat de para­meter p rechts bij­telt.

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

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

# Googologie 2.3

Een array is een reeks variabele getallen, met een 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 af­korting van de eerste sep, links in arrays. Van de varia­bele ervoor, op positie [0] vervalt de sep. Andere array posities houden op de eerste rij index [n] en in verdere rijen [n,S] index arrays, die (afge­zien van oneigen­lijke input) uniek blijven.

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

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

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

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

Hulpregels a.II bij evaluatie in Aas­blazer.

  • a.0. !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.
Universele regel A.2. verwijdert de sep van een afgetelde iter 0 aan een array einde of middenin, op elk niveau in geneste arrays.

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

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

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

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

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

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

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

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

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

# Googologie 2.4

Als we telbare of meervoudige separatoren ,[S].. hadden gebruikt, dan zou zo'n systeem de begin positie van elke index rij uitsparen. Dit geldt voor meerdere gelijke seps (met dezelfde index array) die iter posities aan­geven, niet de vele mixe varianten die 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 het cijfer 0 kunnen in­lassen, of (zoals bij Bird) ite­raties af­tellen tot 1 en deze alleen aan het array einde ver­wijderen.

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

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

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

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

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

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

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

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

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

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

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

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

Dat Aas­blazer een minimaal systeem is, maakt het geschikt voor het op­meten van systemen voor grotere ge­tallen. Op een expo­nent na telt onze super radix de ele­menten in 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 b kopieert en de kopie op­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 0 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. [1b,[2n]1Z]a = [,[1n]1b,[2n]Z]a

Deze regels zijn in elke volgorde toe­pasbaar = op de hele expressie.
De lege sep ,[] is hierbij niet nodig. Deze 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 andere notaties := en samen­vatting van regels in Bellen­blazer.

  • b.0. !x ≡ 0
  • b.1. ,[1]1 := ,1
  • b.2. [b,Z]a := b,Z
  • b.3. [1b,[2S]1Z]a = [a,[1S]b,[2S]Z]a

In regels volgt na een uitroep­teken ! geen getal meer, maar bijv. in [X,[S]!Z] een komma , of array ] eind. Dit teken voor de rechter grens werkt als de woordgrens \b in Regex. Geen verdere enen dus, als we met unaire varia­belen 1.. werken.

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.
 ≈ Ongeveer gelijk, in deze expressie vorm.
≈> Is insignificant groter dan.
<≈ Is insignificant kleiner dan.

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. ,[T]0!0
  • B.3a. [,[1T]1Z]a = [a,[1T]Z]a
  • B.3b. ,[,1n]b! ,[b,n]a
  • B.4. [b,[1S]1Z]a {S>0} = [,[S]b,[1S]Z]a

De aas a rechts van de top array is een gegeven. Hier is de variabele b>0 en constante a>1. Door­gaans is bel b>a veel groter.
In regel B.4. is S een variabele 1n ofwel het deel ,1n met de index voor het vlak. Geval S=0 valt onder regel B.1. voor op­tellen ba uit de definitie van de eerste rij.
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.

Als regel B.4. de eerste index van ,[1,1n] af­telt, ver­schuift in deze stap de bel naar ,[,1n]b de nieuwe iter. Dan zal in tweede instantie regel B.3b. de oude bel inladen ,[b,n]a in die index array.
Voor deze bel intro­ductie in de sub­array hadden we ook een kopie van b kunnen gebruiken, zoals Bird zijn geneste arrays vult, maar wij laten grote bellen b liever stap voor stap groeien. Daarom ver­vangen we de iter weer door de kleine aas a.

# 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 bouwde Conway verder in zijn hyper­functie, die met elke volgende pijl een dubbele recursie nest over de expressie in de voor­gaande eind para­meter.
Conway lost zijn keten van de rechter zijde op, zonder de voor­laatste y=1 opnieuw op 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:

Bij herhaling zet z in y een dubbele recursie in over de hele keten, tot de binnenste y is afge­teld. Over de hele lengte van de keten vormt dit een tripel recursie.
Voorbij supermachten betreden we het gebied van de hyper­machten of de snel groeiende hier­archie. Vage historische aan­duidingen, waar Conway's pijl­keten con­crete grenzen heeft.

Graham's getal uit §2.2 wordt hier 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 bewijs16 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 2D 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.
Maar door complete index­ering, zie box 2.6, blijven de oneven array niveau's achter op Bird's ruimtes, hier ons 1e of top niveau. Die factor 2 niveau verschil over geneste arrays is onze grootste achterstand.

Welke expressie Conway's pijl­keten het dichtste benadert…? Voor het vervolg is dit niet belang­rijk. Je zou onze demon­stratie over kunnen doen en Bird's functie uit­drukken 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.

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

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

Gebruik hulpregel b.0. voor getal b!0 einde en b.1. voor de ene komma ,1 := ,[1]1.
Sec in woorden zoals S kloppen alle haakjes.

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 Regex18 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. Zodat, als termen in de expressie over­lappen, het binnenste element de beurt krijgt.

Tot nog toe kwam het goed uit om `= de eerste term links te nemen, maar bij deze beperkt geneste arrays leidt dat al tot problemen…
Bijvoorbeeld in de expressie [,[1b,[2]1]a]a verliest regel B.3a. de match aan regels B.4a. en B.3b. die voorrang =` krijgen. Opdat de binnenste array eerst [,[a,b]a]a gevuld wordt en a in kan laden (en niet a- na aftelling).

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 de eerste pijl­regel schieten we tegelijk op X1Z = X en op X1 = X die beide met para­meter 1 matchen.
De tweede regel voegt vanaf rechts =? de schakel x in en laat de ope­ratie xy aan het einde staan. Her­haling ervan == smeedt die schakels aan elkaar tot Conway's pijlketen.

Hieronder is deel X alleen de eerste para­meter a. We bouwen verder met Conway pijlen zi die weer dubbele recursies uit­drukken, maar in aan­vang over de lengte van Conway's pijl­keten zelf.
In Bellen­blazer staat de eerste index voor de dubbele Knuth recur­sies en de tweede index voor de tripele Conway recur­sies. Ver­gelijk voor deze twee indexen de 2 dim 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

Met de 2e index in Bellen­blazer bouwen we steeds Conway ketens. De 3e index telt vervolgens tripel recursies a.. in serie. We zullen deze index ,[2]f verder laten toe­nemen en erover itereren .

De operatoren {n} geven dan recursie types aan. Deze bestaan uit een functie pijl en een aantal .. super­pijlen.
Dat aantal :n bepaalt de index n2 van het recursie type, die een rij expo­nenten van het vorige type n1 recursie stapelt. Steeds eva­lueren we operaties met pijlen strikt =? rechts associatief.

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

Bij gelijke para­meters a..a kunnen we de hele serie precies naar de volgende recursie a↑↑ om­zetten. Anders is de meest rechtse expo­nent domi­nant (onder is dat b) en kan bij bena­dering de eerdere para­meters repre­senteren.

  • [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 := ,[b,1,[2]2]a =: a,[1b,1,[2]2]1 ≈> 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 een super­schakel ↑↑ de 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!

Daaraan maken we eerst weer een keten Xyz vast, die we met definitie C.I van Conway's pijlen eva­lueren. En ver­volgens de vele super­schakels… Dit blijkt alle­maal 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↑↑a.a..a :b = a↑↑aab1
  • [1b,[1,1,[3]2]1]a := ,[1b,[3]2]a =: a,[1a,a-,[2]b-,[3]1]1 ≈> a↑↑a..a :b = a↑↑a↑↑b1
  • [1b,[1,1,[4]1]1]a := ,[1b,[4]1]a = ,[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

Onze eerste rij op het 2e niveau van Bellen­blazer arrays, loopt met de recur­sieve pijlen gelijk op.
Dit besluit de multi­dimensionale ruimte van Bellen­blazer arrays, waar elke positie een unieke index heeft. De grootte van de getallen die we nu kunnen schrijven, is gelijk aan die van Bird's lineaire arrays.17
Dat concludeerden we uit de matrix van Btrix in box 2.6 en zullen we later in hoofd­stuk §3.1 nog eens demon­streren met het verge­lijkbare systeem Vogel.

In dim n1 van Bellen­blazer werken we rij type n2 recursies uit, waar de para­meter rechts een rij van vorig type n1 recursies bouwt.
Hogere recursies blazen het aantal dimensies recht­streeks op, wat het huidige plafond over­stijgt: met vlak type recursies, etcetera.
Dan loopt onze typering van recursies nog maar weinig achter bij die van arrays. En dit verschil zal bij dieper nesten insigni­ficanter worden. We houden er mee op om hogere recursies te indexeren en laten de geneste Bellen­blazer arrays voor zich spreken.

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

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

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

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

En wie X→→y→→z van rechts tot X{z}y terug­brengt, die noteert twee hyper operaties voor de prijs van één.
Maar hoe zouden we de eerste hyper­pijl →→ formuleren…?

X

§2.8 Belnesten · hypers

Na een langzame start is het Bellen­blazer algo­ritme bijna al maxi­maal. Vanaf nu zal elk volgend on­even niveau gelijk zijn aan Bird's volgende array niveau. Dat kunnen we be­wijzen door onze output te verge­lijken met de PDFs17 die Chris Bird bij MRob deponeerde.

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

Hier werken we geneste arrays in Bellen­blazer uit, vanaf de expressie [b,[,[d]2]c]a van dimensie d multi­dimensionale arrays, waar­mee we blog §2.7 eindigden. Hierna komen we in de hyper-dimensie van deze com­pleet geïndex­eerde arrays.

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

  • B.0. [bw]a = wb
  • B.1. [b,1Z]a = [ba,Z]a
  • B.2. ,[S]0!0
  • B.3. [,[1S]1T]b! =` [b,[1S]T]a
  • B.4. [b,[2S]1 =` [,[1S]b,[2S]

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

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

De methode om de bel van iter naar index over te laden, beweegt als een cascade omlaag door geneste arrays. Het duurt even om de oude iter weer op peil b te krijgen. Toch kost dit minder dan 1 tel bij b.
Want stel dat de bel b1 was en de aas iter 2, dan zouden we na iter 1 het oude element krijgen en uitwerken tot een nieuwe bel b' die zeker groter is dan de oude bel. Na iter 0 (eliminatie) zouden we die opladen als iter b' bij de oude sub­array.
Deze aas voor bel cascade levert wel­licht natuur­lijkere grote getallen op, dan wan­neer we steeds een bel kopie zouden substi­tueren.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Nee, want uit het voorbeeld blijkt, dat dit nog geen Conway para­meter zou schelen. In hyper-dimensies is dat futiel.

De demonstratie gaat verder met de 2e hyper rij in Bellen­blazer.
In de notatie kunnen we arrays quoten [-"] en aftellen. Het origineel vinden we in de lijn erboven of anders rechts in de expressie zelf. Op de volgende lijn kunnen we deze array [--"] nog eens aftellen.

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

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

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

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

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

Vanwege het succes van index arrays zouden we woorden in haakjes ook aan Conway-Knuth pijlen kunnen hechten. We stellen ons een wijzer­pijl voor, die fungeert als sluit­haakje en terug ver­wijst naar een stop­pijl op de plaats van het openings­haakje. Om hun verband te tonen, dragen beide pijlen dezelfde identi­ficatie tag T.
De syntax is TXT met tag T die uit diverse pijlen kan bestaan. Als T=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.

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

Om de natuurlijke ontwikkeling van Aas­blazer te blijven monitoren, hebben we met onze Bellen­blazer cascade versus de Conway-Knuth hyper-recursie pijlen voor­lopig genoeg grote getallen op voor­raad.
In het vervolg van Bellen­blazer itereren we over array nest diepte met diepen, arrays in serie waar­over gg eerder al blogde.q r s

Een nieuw idee is om naast de functie array ook meerdere arrays in serie te zetten. Ten­einde deze per definitie grotere getallen ψ uit te laten drukken (indexeren), dan fysisch gezien met de functie alleen kunnen worden gemaakt. Een berg van niet-standaard getallen ψ, een soort eindige ω, die buiten het huidige systeem vallen.

Dit zou een twee­traps raket met de aritmetisatie19 van onze (ongeveer) maximale systemen zelf kunnen vormen. Dat wil zeggen, mits de introductie van nieuwe operator tekens te automa­tiseren valt, dan zijn deze telbaar en kunnen we erover itereren in een hogere array functie. Zulke cycli van aritmetisatie kunnen we in theorie indexeren met een volgend hogere array functie. Ad infinitum…

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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