# Herhaald tellen

We zullen een systeem bouwen om grote getallen te beschrijven. Daarbij is het geregeld nodig om af te leren wat je eerder hebt geleerd. We beginnen door de natuurlijke getallen N terug te brengen tot hun essentie:

0 =
1 = 1
2 = 11
3 = 111
n+1 = n1

Meteen blijkt dat Optellen het naast elkaar plaatsen van rijtjes enen is, wat in principe geen eigen operator karakter '+' nodig heeft.

a+b = ab
k1+...+kn = k1...kn

Vermenigvuldigen doe je door hetzelfde getal een aantal keer [#] op te tellen (naast elkaar te zetten).

a*b = aa...a [#b]
k1*...*kn*kn1 = k1*...*(kn...kn [#kn1])

We reserveren kleine letters als variabelen voor getallen en grote letters als variabelen voor expressies. Haakjes (X) bieden de mogelijkheid om een expressie (die evalueert tot een getal) te ‘nesten’ binnen een expressie. Haakjes heb je nodig om priemgetallen korter uit te drukken, bijvoorbeeld:
(1111*111)1 = 4*3+1 = 13

# Kolmogorov complexiteit

Een rekenkundig algoritme met twee karakters kan nooit zo kort ALLE getallen (onder een bovengrens) weergeven als binaire bits dat doen. 0 en 1 winnen het qua resolutie van * en 1. Een systeem met haakjes breidt zijn algoritme met twee karakters uit en zal nooit alle getallen zo economisch schrijven als het getalsysteem met radix 4 (in de computer: 00 01 10 11).

Hoe groter de getallen die we met een algoritme kunnen uitdrukken, hoe groter de gaten ertussen waar zich ‘random getallen’ ophouden die we gegeven onze fysieke resources nooit kunnen zien.
Het beeld wat dit oproept is dat van omhoog vliegende lichtende eilandenrijken in een uit de oneindigheid omlaag vallende duisternis.

We gaan verder met enkel de karakters '1' en '*' en definiëren machtsverheffen als herhaald vermenigvuldigen:

a**b = a*a*...*a [#b]
k1**...**kn1 = k1**...**(kn*...*kn [#kn1])

We zien vier mogelijke regels voor de precedentie van operatoren, en lezen ze van kleinere naar grotere resultaten:

1. School precedentie: Zonder haakjes grotere operatoren altijd eerst evalueren, bijv:
   11**11*11**11 = (2^2)*(2^2) = 16
2. Luie precedentie: De evaluatie loopt in één richting, en de operator heeft betrekking op een enkele operand. Als de operatie is uitgewerkt, hervatten vanaf zijn lege zijde.
   11**11*11**11 = 2^(2*(2^2)) = 256
3. Gretige precedentie: De operator heeft betrekking op de expressie totaan de eerstvolgende gelijke operator of anders totaan het begin. Dit betekent dat kleinere operatoren eerder tot getal geëvalueerd worden, of dat haakjes behouden blijven.
   11**11*11**11 = 2^((2*2)^2)) = 65536
4. Maximale precedentie: Operatoren hebben individueel betrekking op alle parameters totaan het begin en evalueren deze volledig op hun plek.
   11**11*11**11 = 1111**1111*1111 = 16^16 = 18446744073709551616

Wij gebruiken gretige operatoren. Uit het vervolg zal blijken dat deze consequent goed passen. De term “gretig” stamt trouwens van de greedy quantifiers in RegExp.
Al onze evaluaties lezen terug van rechts naar links, want rechts in elke expressie liggen de dominante plaatsen. Zodat a**b**c = a**(b**c) maar ook (a**b)**c = a**b*c.
Een voorbeeld:
111***111 = 111**111**111 = 111**111*111*111 = 3^27 = 7625597484987

Hiermee komen we op herhaald machtsverheffen (dubbelmachten) en definiëren dit:

a***b = a**a**...**a [#b]
k1***...***kn1 = k1***...***(kn**... [#kn1])

Zulke meermachten en hun inversen zijn een braakliggend terrein in de wiskunde, terwijl ze de uitbreiding zijn van exponenten en logaritmes. We zouden hier langer bij stil willen staan, maar het begint te dagen dat ons teken voor herhaling zèlf telbaar is geworden. In het algemeen:

a*..b = a*..a*..... [#b]
k1*.....*..kn1 = k1*.....*..(kn*.....*..kn [#kn1])

Tijd om ‘af te leren’ en de rijtjes *..* terug te brengen tot een getal.

# Operator functie bigO

Definieer een bigO operator functie O(a,b,c) als:

O(a) = a
O(a,b) = ab = a+b
O(a,b,1) = a*b
O(a,b,11) = a**b = a^b
O(a,b,111) = a***b = a^^b
O(a,b,c1) = a***...b [*#c1] = a^^...b [^#c]
          = O(a,O(a,...O(a,a,c)...,c),c) [a#b]

Bijvoorbeeld: O(11,111,1111) = O(11,1111,111) = 2^16 = 65536

De derde parameter c is het operator getal dat aangeeft hoeveel *.. tussen a en b staan. Zo sluiten de eerste drie parameters van bigO naadloos aan bij het recept van herhaald tellen.
Maar bigO is toch zelfvoorzienend, omdat het iedere operator c tot een vorige operator c-1 kan herleiden, zoals uit de onderste regel van het definitieblokje blijkt.
De komma is hier het karakter om variabelen te scheiden. Om expressies van bigO uit te drukken heb je eigenlijk alleen 1 en , nodig, maar om deze expressies (althans theoretisch) te kunnen herleiden tot een getal lijken haakjes onontbeerlijk.
Puzzelen wordt het als we negatieve waarden toelaten om bij bijv. breuken als operator getal passende algoritmes te vinden: niet te langzaam, niet te snel. Dit is nog onontgonnen gebied.
Een suggestie: O(a,b,O(111,O(11,-1,11),1)) = a*b#3/2 = a*2^b,
en misschien: O(a,b,O(11111,O(111,-1,11),1)) = a*b#5/3 = a*b!

Voor de vierde en volgende parameters van bigO moesten we zelf maar met een zinvolle invulling komen. John Horton Conway deed dat in zijn Book of Numbers met een chained arrow notatie, die de Ackermann getallen O(a,a,a1) ver achter zich laat en die qua snelheid vergelijkbaar is met het eenvoudiger algoritme dat we hier voorstellen:

O(a,b,c,1) = O(a,b, O(c,c,c))
O(a,b,c,d1) = O(a,b, O(c,c,c), d)
O(...,0) = O(...)
O(a,...,m,n,z1) = O(a,...,m, O(n,n,n), z)

Dit algoritme voldoet aan het axioma dat elke expressie evalueerbaar is tot een lagere vorm; wat voor bigO inhoudt dat de finale countdown variabele z vermindert met 1, zònder dat ervoor op hetzelfde nest-niveau ergens een kommaatje extra insluipt.

# Maximale algoritmes

Bestaan er maximale algoritmes? Is er een ‘snelste manier’ om getallen te laten groeien? Het antwoord is „ja”: als ieder volgend getal het maximale getal is dat gegeven de eerder beschikbaar gekomen getallen (en operatoren) gemaakt kan worden, is een algoritme maximaal.

Enen tellen is maximaal, wanneer je maar één 1 gebruiken kunt om aan een eerder getal toe te voegen.
Herhaald tellen via +,*,^,... is niet maximaal. Maximaal tellen zou ieder voorgaand getal verdubbelen. De maximale zus van bigO zou al beginnen met Ô(a,b)=a*2^b en met parameter c de recursies daarvan tellen.
Ook het algoritme dat we bij parameter d kozen is zachtzinnig. Harder gaan:

Ô(a1,..,am,z1) = Ô(Ô(a1,..,am,z),...,Ô(a1,..,am,z),z)

Om,2(a1,1,..,am,1,,1) = OP(P,...,P)  waar P = Om(a1,..,am)

Os1,..,sn(a1,..,1,.:.,ak1,..,sn,z1) = OP,..,P,sn(P,.:.,P,z)
waar P = Os1,..,sn(a1,..,1,.:.,ak1,..,sn,z)

In de multidimensionale formule mogen de lagere array-dimensies alle maten (de verschillende lengtes) gelijk trekken aan het parameter substituut P, behalve de finale parameter, rij, vierkant, etc. vanwege de eis van reduceerbaarheid.
Ook zouden (volgens bigO's eigen definitie) operator functies genest kunnen worden. Het bigÔ equivalent van een countdown z-1 zou mogelijk een tot op diepte Ô(a1,..,am,z-1) geneste totaal-substitutie toestaan. Deze geneste versie van bigÔ zou in de eerste rij al vele parameters sneller zijn dan haar zusje bigO en wellicht maximaal voor zo'n operator functie.

Met het invoeren van de dubbele komma ,, maken we een sprongetje in de tweede dimensie van de parameter array van bigO. Het finale getal dat de laatste rij oplevert expandeert zijn voorganger-rij volgens het countdown principe dat met parameter d geïntroduceerd werd.
De bigO expansie definiëren we met de volgende formules, waarbij de O-subscripts voor het gemak de grootste lengtes van de dimensies aanduiden:

Om,2(a1,1,..,am,1,, 1) = OP(P,...,P)  waar P = Om(a1,..,am)

Om,2(a1,1,..,am,1,, z1) = OP,2(P,...,P,, z)  waar P = Om(a1,1,..,am,1)

Om,n1(a1,1,..,aj,1,, .:.,, a1,n,..,ak,n,, z1) =
     OP,n1(a1,1,..,aj,1,, .:.,, P,...,P)
     waar P = Ok(a1,n,..,ak,n)

Met het bijtellen van een komma ,,, kunnen we vierkanten scheiden en bouwen we een parameter kubus voor nòg vettere getallen in dimensie 3 -> 2 -> 1 -> 0.

Os1,s2,s31(a1,1,1,..,, .:.,,, a1,1,s3,.:.,ak,m,s3,,, z1) =
     OP,P,s31(a1,1,1,..,, .:.,,, P,.:.,P,,, z)
     waar P = Or1,r2(a1,1,s3,.:.,ak,m,s3)

Het mag duidelijk zijn dat een top-dimensie met lengte sn=1 zal inklappen, omdat deze nog slechts één lagere array-dimensie sn-1 omvat.
Met dit in het achterhoofd heeft u nog de algemene formule voor bigO van ons tegoed, waarin het hoogste aantal opeenvolgende komma's ,.., de dimensie (hier n1 genoemd) van de parameter-array bepaalt.

Os1,..,sn11(a1,..,1, .:.,.., a1,..,1,sn1,.:.,ak1,..,sn1,.., z1) =
     OP,..,P,sn11(a1,..,1, .:.,.., P,.:.,P,.., z)
     waar P = Or1,..,rn(a1,..,1,sn1,.:.,ak1,..,sn1)

Tot zover was het amateur-onderzoek voor het maken van grote getallen al ongeveer gevorderd (met Jonathan Bowers’ idee van een exploderende array functie). Als we onze Mâxima bigÔ de scepter hadden laten zwaaien liepen we nu dik in de records!

# Separator cycli en virtualisatie

Tussen de enen in het getal n=11 is er al separatie. Maar met a**b = a*...*a worden hulpkarakters voor het eerst zèlf telbaar. Dit recursief tellen werd de basis voor operator functie bigO. Diens derde parameter telt eenvoudig het aantal * karakters, de diepte van de tel-recursie. bigO zelf gebruikt de komma , als separator tussen zijn getallen. Het komma karakter drukt er een overgang uit naar een hoger niveau van Acker-Mann substitutie, ook weer afhankelijk van aantal en context.
Langere series komma's openen steeds hogere dimensies, maar wat ligt er hoger dan dimensies?
We hoeven ons niet te laten verlammen door dit ruimtelijke aspect van bigO. Het wordt tijd om ‘af te leren’ en verder te tellen, beter en sneller.

Stel dat je het karakter ; gebruikt om komma's te tellen. En je staat toe dat de teller zelf een expressie is van een komma-teller versie van bigO. In plaats van een tot op grote diepte genest dimensieblok te bouwen schrijf je a;b of a;b;c of a;;;b.
Laten we eens kijken wat er gebeurt als je zo'n derde type karakter ; aan het parameter blok van bigO hangt en je past Acker-Mann substitutie toe op de dimensies zelf:

Os1,..,sn,,1(a1,..,1,.:.,..,.:.,ak1,..,sn; z1) =
     OP1,..,PP,,1(P,.:.,..,.:.,P; z)
     waar elke Pn = P = Os1,..,sn(a1,..,1,.:.,..,.:.,ak1,..,sn)

Zo vergroot je met PP=P direct de lengte van de series komma's en wordt de dimensionaliteit van bigO in alle richtingen ‘opgeblazen’. In het deel rechts kun je gebruik maken van twee types separators (of drie, voor wie * meetelt) en door ;;;... tot in den treure te herhalen zul je uiteindelijk wel aan het volgende type separator toekomen \, die ‘harder blaast’ dan de tweede, etc. Er is geen reden waarom Acker-Mann substitutie opeens zou falen.
Operator subscripts voor dimensie-lengte groeien navenant mee, zodat ze onhandig worden en we ze afschaffen. We hebben hypothetisch net zoveel separator-typen als ons toetsenbord toestaat. Maar omdat we grote getallen strikt binair willen uitdrukken, is het beter om meteen al over een separator-type-teller te beschikken.

Stel je een vervolg-functie bigO4 voor, die als vierde parameter d zo'n separator-type-teller in huis heeft. De derde parameter geeft het aantal c van die separator aan en operand b neemt de rol op zich van historische countdown z, wat toch eigenlijk het enige getal was in de expressie dat ertoe deed. (Operant a doet vanouds voor spek en een beetje resolutie mee ;0)
We laten bigO4 zich vanaf de vijfde parameter e volgens hetzelfde principe ontwikkelen als de vorige generatie (die eigenlijk bigO3 heet omdat ze de derde is! d=0 zou een pure * expressie worden, van de tweede generatie). Het enige verschil zit hem in de Acker-Mann substituties, die in de eerste rij van bigOn n parameters lang zijn, bij bigO4 zijn dat O(k,k,k,k) substituties.
De separator die we tussen de parameters zetten is gewoon weer de komma, die we tellen tot alle dimensies vol zijn en een tweede genus separators nodig is, te definiëren bij een volgende ronde bigO5 in de vijfde parameter e=1.

# De historie van bigO

We zijn er in de derde generatie ingesprongen maar we kunnen reconstrueren hoe bigO ‘vroeger’ gefunctioneerd moet hebben.

De eerste generatie bigO1 kent geen ander verband tussen de getallen dan dat ze naast-plaatsbaar zijn. Komma separators zijn telbaar, dus is er een array. Maar zonder dimensies, want bij evaluatie tellen de spaties waar deze in bigO1 voor staan terug tot één. Het Acker-1-Mann getal substitueert a met a1: O1(a,b1) = O1(a1,b), waarna ook nog die ene overgebleven separator oplost. Eentje voor eentje worden zo alle komma's verwijderd en hevel je alle rijen met enen over naar de eerste parameter (optellen).
Wiskundig gezien bestaan spaties niet, maar komt er achter een bigO1 expressie via O(a;b) de eerste telbaar-type separator * te staan, dan herhalen we de parameter som P=a met een P minder dan gebruikelijk PPP... b maal, met overal komma/spatie/niets tussenin (vermenigvuldigen).

In de tweede generatie bigO2 staat de komma separator voor de telbare operator * en deze telbaarheid is dimensionaliteit, wat betekent dat binnen hogere dimensies lagere liggen genest. Onze vermenigvuldiging a*b werkt mooi samen met het Acker-Mann countdown mechanisme, maar ook herhaalde verdubbeling a*2^b is voor * een optie (al aan het eind van bigO1).
Vanaf het begin van bigO2 groeien de dimensies van nature snel verder:

O(a,b,1,) = a*b = aa... [a#b]
O(a,b,3,) = a***b = aa**aa**... [a#b]
O(a,1,1,1) = a;1 = O(a,a,a) = Ma
O(a,3,1,1) = a;3 = Ma;2 = MMa;1 = MMMa
O(a,1,3,1) = a;;;1 = a;;a;;a;;... [a#a]
O(a,1,1,3) = a;31 = a;2;2;2...a [;2#a]

Wat heeft bigO3 meer te bieden dan dit?

Naschrift: Het lijkt sterk of hierin de juiste methode ligt en dat Mathmuis’ artikel op losse schroeven komt, een literaire curiositeit is meer niet.  Wordt vervolgd?!

Aldus en met groot enthousiasme vullen we ‘separator cyclus na cyclus’ de eerste rij van bigOn met geslachten separator-type-tellers. Een tweede virtuele rij in bigOm,2 biedt de mogelijkheid om deze cycli rechtstreeks te tellen en te expanderen om zodoende nòg grotere getallen aan te wuiven. Na de derde rij denken we aan de derde dimensie en daarna komt het einde van deze trio-cyclus van separator aantal/type/genus in zicht.
We verkeren dan in een vergelijkbare positie met deze bigOs₁,...,s_n methode als met de multidimensionale Os1,..,sn aan het einde van het vorige hoofdstuk.

En we hebben gezien hoe dat verder gaat. Virtualisatie is het bouwen van bigO cycli op vergelijkbare wijze als separator karakter cycli. Wat cycli betreft zijn er eerst de enen, ten tweede de seperatoren en ten derde virtuele methodes bigO die met wijd uiteenlopende snelheden rouleren. Wat ons betreft zou het daarbij mogen blijven, maar we vrezen dat er meer cycli telbaar zijn. Cycli van cycli zullen dat wel worden.
We hadden de hoop om met een originaliteits-criterium voor de inrichting van parameters op de eerste rij van bigO een serie te duiden die bewijsbaar niet ,, te expanderen is. Daarmee zou een 1-dimensionaal begrip van oneindigheid ontdekt zijn, kleiner dan Cantor's 0-dimensionale begrip van oneindigheid. Maar we laten het voorlopig bij deze filosofische bespiegelingen.

# Omega oneindigheid

Georg Cantor vond een getal uit dat verder ligt dan je kunt tellen, dit getal noemde hij omega ω. Je kunt niet naar dit oneindige getal toe tellen, maar wèl ervandaan: ω+1 enzovoort. Eigenlijk is ω dus voor de ene helft oneindig en voor de andere helft een getal. Getalsconcept numero 2.
Hoewel ω hoger ligt dan bigO ooit kan reiken, zijn Cantor's ordinale getallen fraai over te planten naar bigO. In plaats van 1 neem je als parameter ω. De bekende mijlpalen:

O(1,ω) = ω
O(ω,1) = ω+1
O(ω,ω,1) = ω^2
O(ω,ω,ω,1) = ε0

Uiteindelijk zal ook omega, samen met bigO met zijn vele generaties en geslachten, niet hoger kunnen reiken. Dat bevestigen we door een tweede keer Cantor's truc uithalen: we postuleren een oneindig onbereikbare oneindigheid ω11. Deze onbereikbaarheids-cultus kan zich ook weer eindeloos herhalen, maar blijft ‘gewoon’ nog omega-telbaar binnen een bigOmega functie zoals:

Ω(1) = ω
Ω(11) = ω11
Ω(a) = ωa
Ω(1,1) = Ω(ω) = ωω
Ω(11,1) = Ω(Ω(ω)) = ωωω
Ω(a1,1) = Ω(Ω(a,1)) = ωω...#a11
Ω(1,11) = Ω(ω,1)
Ω(1,b1) = Ω(ω,b)
Ω(11,11) = Ω(Ω(ω,1),1)
Ω(a,b1) = Ω(Ω(ω,...,Ω(ω,b),...,b),b) #a
Ω(1,1,1) = Ω(ω,ω)

# De toekomst van de wiskunde

Als een ècht groot aantal wiskundigen eindeloos lang door kan denken, hoe zal het paleis van de wiskunde (van de ‘essentie der dingen’) er dan uitzien?

En zouden er nog bezoekers kunnen komen? Of zou er permanent een bordje voor de Αναλφαβεταωeg 123456 te Soest staan met de tekst

Onder Constructie?!

Als de grenzen van een bigO-stijl oneindig-dimensionale bigOmega zijn bereikt, dan formuleer je een tweede bigOmega functie, enzovoorts. Maar ooit zul je aan het tweede type oneindigheid ψ toekomen. Getalsconcept numero 3 – twee delen oneindigheid, nog maar één deel getal.
Dit soort oneindige concepten in de proportionele reeks 0 > 1 > ω > ψ ... is zelf ook weer telbaar en blauwdrukken voor getalsconcept-functies liggen in dit artikel voor het oprapen.

Misschien zul je uitkomen bij een dusdanig oneindig concept, dat er geen getal meer over is, alleen oneindigheid…
Dit noemen we 1=0, tellen is onmogelijk, het axioma heeft gefaald.
Meteen daarop, nog voordat het hele gebouw is ingestort en de grond heeft bereikt, komt het tegendeel ~(1=0) aan het licht en wordt de logica betrokken in een oneindig proces van Reductio Ad Absurdum: A&~A >> B.

Dit is de terminale aard der dingen: een chaotisch set-universum dat dan weer maakbaar (telbaar) is en dan weer niet (oneindig), en een logica die dan weer lijkt te weten en dan weer niet. In Zen heet deze finale æon waar wiskunde wedergeboren wordt “Judi's vinger” (Mumonkan 3).
Terugredenerend naar de natuurlijke getallen: het random getal <01> “nul òf een” geeft de situatie wat betreft het tellen in de oneindigheid beter weer. Random getallen zijn het enige wat ons helpt om de zwarte gatenkaas—leegte die tussen de grote getallen gevallen is te overbruggen. En welk random getal is er beter dan een computerprogramma? Intelligent design is het levenswater van de getallenkosmos. Een onwaarschijnlijker God is een machtiger God <soms>.

ONDER CONSTRUCTIE!

# Onze records

Omdat Mathmuis zijn neefje en nichtje de “Kind getallen” heeft beloofd, gaan we onze recordgetallen (in violet) namen geven met vier letters.

14. Allereerst is daar, vanuit de Oer met een gigantische sprong, het Nerd getal 1.
13. Met in ons hoofd de Ackermann getallen, tellen wij herhaald op tot de Mann getallen:
    M1 = 1
M2 = 11*11 = 2*2 = 4
M3 = 111**111**111 = 3^(3^3) = 7625597484987
M4 = 1111***1111***1111***1111 = 4^^(4^^(4^^4)), etc.
    Vertaald naar bigO als: Mm = O(m,m,m)
12. De Lady getallen Ln zijn multidimensionale parameterblokken van operator functie bigO, met dimensie n en alle lengtes daarin n en alle parameterwaarden n.
    L1 = O(1) = 1
L2 = O(2,2,,2,2) = O(4,,4) = O(4,4,O(MMMM4),,3)
    Ons bigO record getal is de Lady kubus:
    L3 = O(O(M3,,M3,,M3),,,O(M3,,M3,,M3),,,O(M3,,M3,,M3))
11. De Kind getallen Kn zijn geneste parameter-n-blokken van bigOn, waarin totaan parameter n de separator-types worden geteld in de respectievelijke separator cycli van de versies bigO<n (?!). Dan zou na...
    K1 = O1(1) = 1
K2 = O2(2,2) = 4
K3 = O3(3,3,3) = M3 = 7625597484987
    (of zoiets?!) meteen al ons record komen:
    K4 = O4(4,4,4,4)