Thursday 26 October 2017

Aasblazer

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

Gulliver redt de vloot van Lilliput

Friday 6 October 2017

Supermachten

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

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).
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.
Gulliver redt de vloot van Lilliput