§0. Introductie van psi

Gegeven een systeem dat natuurlijke getallen 1.. uitdrukt, laat psi ψ het kleinste getal zijn dat groter is dan elke mogelijke expressie van het systeem. Deze bovengrens ψ kan vervolgens weer als constante dienen in hetzelfde aftelbare systeem of als virtuele iterator om nog grotere getallen te noteren.
In het algemeen, maakt een systeem een bepaald type output, dan is ψ ook van dit type maar geen output van het systeem, zolang ψ niet als input gegeven is.

Stel dat we alle natuurlijke getallen kunnen maken, door steeds 1 op te tellen, of door operaties met deze getallen, dan is psi ψ = ω het natuurlijke oneindige, de onderste limiet voorbij tellen dat ooit stopt.
Maar als dit axioma, dat omega ω het totale aantal van de natuurlijke getallen is, te ver gaat, neem dan aan dat ψ of ψ1 een minimaal groter getal is, voorbij de horizon van ons systeem, gegeven de fysiek geldende beperkingen voor input en expressie lengte.
Bovengrenzen aftellen of terugrekenen is onmogelijk of anders zinloos. Het getal ψ1 is bedoeld als hogere input voor het systeem, zoals de constante a of een herhaalbaar item ψ0 aanvankelijk input was, om mee verder te rekenen. Zo kunnen we nog vele grotere en virtuelere van zulke constructies maken.

§1. Systemen

Ter introductie zullen wat bekende operaties en functies om grote getallen te maken de revue passeren. Ook bouwen we zelf zulke systemen op, waarbij in dit hoofdstuk de input en berekeningen slechts één of twee rijen met variabelen in beslag nemen. We hechten belang aan eenvoud en natuurlijkheid.

§1.1. Tellen

In natuurlijke getallen tellen we een 1 op tot een aantal 1.. enen. Negatieve getallen krijgen de factor min - ervoor, of tel anders de -.. minnen.

Herhaal het teken 1 op zijn plaats .. volgens de rep repetitie een :n aantal maal, totdat het aantal enen gelijk is = aan het getal n zelf.
Of begin met niets   en stop zonder te tellen, voor het getal nul 0.

1.. :0 = 0
1.. :n = n

Vorm de getallen twee, drie, vier, etc. met cijfers 2,3,4,.. en met enen, of zet ze om => in binaire notatie, in radix twee.

  2 = 11 => 10
  3 = 111 => 11
  4 = 1111 => 100
  5 = 11111 => 101
  6 = 111111 => 110
  7 = 1111111 => 111
  8 = 11111111 => 1000
  9 = 111111111 => 1001
10. = 1111111111 => 1010

Natuurlijke getallen kunnen compacter geschreven worden in een radix systeem met extra cijfers. In elke radix 10 zijn alle natuurlijke getallen <10^k weer te geven met een lengte <k aan tekens.
Grote getallen drukken we liever uit in een wiskundige expressie, met speciale tekens voor operaties of functies, en voor de definitie daarvan. Maar hoe sneller de functie, hoe meer getallen tussenin gemist worden, zodat de expressie lengte van de meeste getallen groter is dan bij een even tekenrijke radix.
Doel is om met zo min mogelijk tekens zo groot mogelijke getallen te schrijven.

§1.2. Superster operaties

Zet var variabelen a en b met natuurlijke getallen naast elkaar, dan tellen de enen daarvan ab meteen op.

Met het plus + teken stellen we die operatie uit tot later. Maar als de optelling alleen staat, aangegeven met = in een regel, dan valt de plus weg.

  • a+b = 1.. :ab = ab
  • +a+b =` +ab

Werkend van rechts naar links =` heeft elke operatie rechts van een + teken voorrang en anders de hogere ster *.. operatie links ervan.

Vermenigvuldigen * is herhaald optellen van een getal.
Met twee regels waarbij de operatie tot 1 op elke plaats reduceert tot a, maar de stap operatie wordt gezocht =` vanaf rechts.
Werk al dergelijke stappen == uit tot natuurlijk getal.

  • a*1 a
  • a*b1 =` a*b+a == a*1+.a.. :b = a.. :b1

De rep :b herhaalt de tussen . of terzijde van de punten .. geselecteerde passage b maal. Schrijven we b1 denk dan b+1 en tel af.

Machtsverheffen ** of ^ is herhaald vermenigvuldigen. Via deze vier regels worden de lagere operaties eerst uitgewerkt.

  • a*+b = a*b
  • +a*+b =` +a*b
  • a**1 a
  • a**b1 =` a**b*+a

De pop plus + werkt als een enkel haakje, die de popster *+ operatie uitstelt.

Hoewel dit in de uitwerking van machten nooit zal voorkomen, volgt uit deze regels dat a^b+1 optelt bij een factor, maar 1+a^b gewoon bij het totaal.

Herhaald machtsverheffen *** of ^^ heet tetratie. Dat vormt een toren van machten, die van rechts naar links moet worden opgelost.

Operatie na operatie ontstaan zo de supersterren *{c1} = ^{c} en de caret superexponenten, waarbij teller {c} het aantal tekens in de operator geeft.


Definitie om SuperSter operaties te evalueren tot natuurlijk getal.
Voor de operanten geldt b>0 en in de operatoren c≥0.

  1. SS.1. a*{c}+b = a*{c}b
  2. SS.2. +a*{c}+b =` +a*{c}b
  3. SS.3. a*{c1}1 a
  4. SS.4. a*{c1}b1 =` a*{c1}b*{c}+a

De 4e regel geeft de operatie stap met introductie van de passieve + plus. De 2e regel elimineert die plus uit de rechter van twee popster operaties. Of activeer de popster met de 1e regel, indien deze alleen over blijft.

Supermachten zijn een dubbele recursie, met leeg *{0} optellen en operanten b=1 als basis. Zo krijgt de teller van ster operaties *{c} een natuurlijk begin. Moet bij aangetekend worden dat getallen en variabelen altijd begrensd zijn, en dat bij de 3e regel na die ene 1 er dus geen meer volgt.

Een frase als a^^b1+1 ontstaat niet in de uitwerking, maar volgens de definitie telt dit 1 op bij de hoogste macht a^..a1 :b in de toren.

Werk als voorbeeld de supermacht 2****3 stapsgewijs uit vanaf rechts.
Waarbij het handig is om carets te gebruiken, vanaf ^ machtsverheffen.

2^^^3 = 2^^^2^^+2
      = 2^^^1^^+2^^+2
          = 2^^+2^^2
          = 2^^+2^^1^+2
          = 2^^+2^2 = 2^^+4
          = 2^^4 = 2^^3^+2
     = 2^^2^+2^2 = 2^^2^+4
     = 2^^1^+2^+4 = 2^+2^4
     = 2^+2^3*+2 = 2^+2^2*+2*2
     = 2^+2^1*+2*4 = 2^+2*8
     = 2^16. = 2*32768. = 65536.

Essentieel voor supermacht expressies zijn twee tekens 1* en in de evaluatie functioneert de pop plus + als enkel haakje.
Gebruik carets ^ zo nodig. Cijfers en decimale getallen helpen ook.

Elke stap opnieuw scannend door de expressie, dient de eerst overeenkomende regel te worden uitgewerkt. De definitie geeft met = of of =` de positie van de geschikte operatie aan: enigste of op elke plek of als eerste rechts.


We kunnen supermachten ruwweg met elkaar vergelijken qua grootte. Hier neemt het verschil < tussen twee reeksen operaties in exacte zin toe, terwijl dit in de context van supermachten ^{c} bij grotere c almaar insignificant wordt.

2^{c}4 = 2*{j}..8 c:1  <
3^{c}3 = 3*{j}..9 c:1

De teller {c} geeft in krulhaakjes het aantal tekens in de operator aan. De repetitie c:1 plaatst een reeks waarin de indexen j naar rechts afnemen.

In de teller kan ook een expressie staan, die met voorrang wordt uitgewerkt, of een reeks geneste superexponenten, zoals bij Gardner's Getal van Graham.

3^{..3^^^^3..}3 :63:
   = 3^{..4..}3 :64:
      = 3*{..4..+1}3 :64:

De duorep :d: herhaalt beide selecties aan de kant van de expressie. Plaats deze in stappen op de punten .. links erna en rechts ervoor, van binnen naar buiten werkend, tot de rep tot :1: is uitgeteld en met de punten verdwijnt.

Toch kan de evaluatie van supermachten simpeler. Steeds de basis operant a bijschrijven is overbodig, want het is een constante. Alleen de macht b en het aantal sterren {c} is kenmerkend. En normaal wachten de hogere operaties in rangorde naar links aan de kant tot de lagere zijn gereduceerd tot getal; van elke aanwezige operator is er één in de tussen expressie, zie voorbeeld.
We kunnen onze popsterren vertalen naar een functie rij, die minder tekens gebruikt in zijn definitie en waar expressie lengtes in de evaluatie korter zijn.

Pas in 1976 zag de superoperator het licht, carets in de vorm van de pijlen {c} van Knuth, in zijn essay over "Omgaan met eindigheid".
Maar dezelfde dubbele recursie φc(a,b) inclusief Ackermann functie was al te vinden bij David Hilbert, in zijn artikel "Over het oneindige" uit 1925.

§1.3. Supermacht functie rij

Dubbele recursie wordt vaak gegeven als een functie met één constante en twee variabelen waarover die functie itereert. De functie substitutie regel introduceert minimaal afgetelde expressies, zodat de uitgedrukte getallen supergroot worden. Deze substitutie gebeurt vanaf links gezien (zoals bij Bird's array rij) in de tweede variabele b, of vanaf rechts gerekend (zoals bij Conway's pijlketens) in een voorlaatste variabele y.

Werk een reeks substituties in b uit, samen 1 stap in de iteratie van c.
Laat het functie teken en de buitenste haken weg.

a,b1,c1 = a,(a,b,c1),c
     == a,(..a,1,c1..),c :b:
      = a,(..a..),c :b:

De eerste functie a,b,1 kan verschillen, Hilbert begint φ1(a,b) met optellen en de pijlketens van Conway ab1 met machtsverheffen.
In den beginne wordt steeds de constante a opgeteld.

Stel dat c=1 vermenigvuldigt, en dat c=0 met a,b = ab optelt. Dan werkt deze functie hetzelfde als de linkse evaluatie van supersterren met haakjes.

a*{c1}b1 = a*{c}(a*{c1}b)
      == a*{c}(..a..) :b:

Hier is 3,3,3 ofwel 3***3 het getal 7625597484987 al boven de biljoen (VS trillion). En dan loopt door substitutie het aantal subexpressies wachtend tussen haakjes snel uit de hand.
We willen een functie die zuinig is met type tekens, en die in elke stap geen expressies substitueert maar getallen, zodat er zonder ronde haakjes te werken is. Maak dit mogelijk door een rij van iteratoren te gebruiken, die herleid worden tot optellen in de basis en van daar uit weer worden opgeladen.


Functie definitie NA rij, waar b>0 en de lengte van de deelrij ? mag 0 zijn.

  1. NA.1. a,b = b
  2. NA.2. ?, = ?
  3. NA.3. a,b,1? = a,ab,?
  4. NA.4. a,b,{k>1}1? = a,{k}b,?
  5. NA.5. a,,{k>0}1? = a,a,{k}?

Dit systeem heeft de beginletter N omdat het iteratoren en structuren aftelt tot 0 Null en omdat de constructie Natuurlijk is. De snelheid van de N-functies is bij benadering maximaal, hoewel na toevoeging van extra structuur niet meteen al.

Expressies NA in vergelijking met de popsterren uit het vorige hoofdstuk.

a,b,c1 = a,ab,c
      == a,a*c+b,1
       = a*c1+b
a,,,d2 = a,a,,d1 = a,,a,d
       = a,a*a,,d == a,,a^d1
       = a^d2
a,b,c,d1 = a,a*c+b,,d1
       = a,,a*c1,d {b=a}
       = a,a*+a*c1,,d
      == a,,a^d*+a*c1
       = a^d2*+c1
a,a,c,d,e1 = a,a^d1*+c1,,,e1
       = a,,,a^d2,e {c1=a}
      == a,,,a^^e^+a^d2
       = a^^e2^+d2

Elke iterator op de eerste rij vormt een supermacht a*{k}p die we hier afronden door bij de rechts volgende iterator 2 op te tellen.

Gemeten vanaf de basis a,0 drukt het aantal komma's ,{k} de supersterren direct uit, want optellen *{0} werkt hier niet zo.

a,{k2}z2 = a,{k1}a,z
      = a,a*{k}a,{k1}z
      = a*{k1}z2
a.,pi..,z :k1  waar pi~a
   ~ a*{k1}z2

In het algemeen kunnen we een rij makkelijk ~ afronden, want alleen als de voorlaatste parameter pk enorm groter is dan de laatste z klopt dat niet. We schrijven input variabelen die qua grootte of oneindigheid vergelijkbaar zijn.

Voor het opladen van a,,,d of erop volgende variabelen in de expressie maakt het niet uit of er b=0 dan wel b=1 staat, wat eigenaardig is. Dat blijkt door de oplaadregels niet alleen vooruit, maar ook achteruit =: toe te passen.

a,,,,3 = a,a,,,2
      =: a,,,1,2 =: a,1,,,3
a,,{k>1}1? = a,a,{k}?
      =: a,{k}1,? =: a,1,{k}1?

Wat lastig is aan systeem NA zijn de twee oplaadregels in serie: het laag opladen van waarde a naar cel b voordat hoog opladen van cellen weer mogelijk wordt.
Ook zou het zuiniger zijn om de tekenreeks ,{k>1} in te zetten als dimensie separatoren voor multidimensionale matrices. We doen ons best!


Functie definitie OA rij, die supermachten uitdrukt met 2 tekens en 4 regels.

  1. OA.1. a,b = ab
  2. OA.2. a,?,1 = a,?
  3. OA.3. a,b,11? = a,ab,1?
  4. OA.4. a,b.,1..1? :k2 = a,.,1..,ab,1? :k≥0

De letter O slaat op het aftellen van iteratoren en structuren tot 1 One. Dit systeem zal zo groot mogelijke getallen noteren met zo min mogelijk tekens.

Met de 4e regel wordt zowel de afgetelde iterator ,1 rechts opgeladen, als de andere wachtende ,1 links ervoor in de rij. Eerst verladen we vanuit volle basis a,b de som ab en vervolgens vanuit de lege basis a,0 de constante a.

Met dezelfde expressie noteert functie OA wat kleinere uitkomsten dan NA op de rij, maar dit is niet significant.

a,b,1 = a,b = ab
a,b,c1 = a,ab,c
      == a,a*c+b
       = a*c1+b
a,,1,d2 = a,,a,d1
       = a,,a*a,d
      == a,,a^d1
       = a^d2
a,b,c1,d1 = a,a*c+b,1,d1
       = a,,a*c1+b,d
      == a,,a^d*+c2 {b=a}
       = a^d1*+c2
a,,1,1,e2 = a,,1,a,e1
       = a,,1,a^a,e
      == a,,1,a^^e1
       = a^^e2
a,b,c,d,e1 {b=a c1=a}
       = a,,1,a^d1,e
      == a,,1,a^^e^+d1
       = a^^e1^+d1

De eerste rij in OA is uit te drukken als een reeks popster operaties, waarbij elke variabele cel een ster aan de operator toevoegt. Hier geldt k≥0.

a,.,1..,z :k = a*{k1}z
a.,pi..,z 0:k =
    a*{k1}z.*{j}+pj.. k:0
  ~ a*{k1}z*{k}+pk+1  met pj~a
  ~ a^{k>0}z1

Met indexen i die van 0 tot k toenemen door 0:k op variabelen in de functie, met indexen j die van k tot 0 afnemen door de k:0 rep van popsterren.
Deze volle rij kunnen we afronden ~ als hiervoor.

Een primitief supermacht algoritme kan ook in drie regels, maar opladen telt dan steeds 1 bij. Die uitkomsten nemen scheef toe ten opzichte van de klassieke supermachten, hoewel niet significant sneller.
Kies daarbij als derde regel:

  • a,b.,1..1? :k1 = a.,1..,ab,1? :k of
  • a,b.,1..1? :k>1 = a,..b,1? :k

Ons grote principe is om afgetelde hogere variabelen consequent met lagere op te laden. Ook bij Ackermann functies en in de grote getallen arrays van Bowers en Bird (B&B) wordt dit principe toegepast. Maar Ackermann verheft de constante a wat traag is. En B&B verpakken som b in een min expressie alvorens die naar hogere regionen op te laden, wat dan wel ingewikkelder is, maar even maximaal snel als onze functies.

Rij lengte in OA en NA loopt gelijk met de iterator c van een klassieke dubbele recursie met functie substitutie in b en een constante a.
Door rij lengte vanuit de basis op te blazen, verlaten we de primitieve recursie en komen op onze tweede rij al gelijk met Bird's lineaire array. Over het array vlak zullen we zo slechts 1 rij achterblijven.
Dit valt te bewijzen via de pijlketen van Conway, die op de supermachten volgt.

#1.4. Conway's pijlketens

John H. Conway is de schepper van de pijlketen notatie, die met twee pijlen in ayz al dezelfde supermachten als Knuth met zijn pijl operaties a{z}y uitdrukt. Conway's enkele pijlen zijn eigenlijk geen operatoren, maar werken als separatoren , tussen variabelen in een functie voorschrift.

Stapsgewijze definitie van Conway's pijlketens, met uitwerking == van 1 iteratie.

  1. CA.1. ab = a^b
  2. CA.2. X1 = X
  3. CA.3. X1z = X
  4. CA.4. Xy1z1 = X(Xyz1)z == X(..X..)z :y:

Text variabele X staat voor a.xi.. :k≥0 het linker deel van de keten, dat begint met constante a en vervolgt met een aantal variabelen xi.
Functie substitutie en aftelling vinden plaats binnen in de voorlaatste cel y, terwijl van buiten de laatste iterator z aftelt. Zo worden ketens diep genest, terwijl de recursie over yz naar links schuift en uiteindelijk reduceert tot machten.

Scherp een voorbeeld aan uit Conway en Guy's Getallenboek uit 1996.
Het 3^{..3^{4}3..}3 :63: Getal van Graham ligt boven de 33642 of 33(..3^3..) :63: in pijlketen notatie, maar onder de 23652 of 23(..247..) :63: zo te zien, omdat de top supermacht daarin het grotere 337 vrij dicht benadert (zie sectie 1.2.c).

Bird's lineaire array gebruikt vier parameters om even grote getallen te noteren als Conway met zijn pijlketen rij. Omdat we net als Bird de basis som opladen, wat maximaal is, komt er aan het begin van onze tweede rij een variabele, die de lengte van Conway's hele keten zal benaderen.


Systeem NA kan op verschillende manieren worden uitgebreid naar de tweede rij.
Neem als rij separator een komma met index ,[1] tussen haakjes, tot [1] af te korten. Een nieuwe regel kan met de eerstvolgende parameter m gewoon de eerste rij lengte k vervangen, of er bijvoorbeeld zo bij optellen.

  • a,b,{k}[1]m = a,,{km}b
  • a,b,{k}[1]m1 = a,,{k1}b[1]m

Direkt of in etappes, dat zal voor de grootte van de uitgedrukte getallen weinig verschil maken.
Pas door [1]m,1 af te tellen tot [1],1 en op te laden met [1]b zal de rij lengte ervoor met de som b worden opgeblazen.

Dat kan ook op een direkte manier, een parameter sneller, met andere regels.

  • a,b,{k}[1]c1 = a,,{b}a[1]c = a,a*{b}a[1]c == a*{..b..}a :c1:
  • a,b,{k}[1]m1 = a,,{kb}2[1]m = a,a*{kb}2,{kb}[1]m

De eerste regel werkt natuurlijker uit, ongeveer als abc12 en wordt hetzelfde genest als Graham's number.
Het bewaren van de lengte k van de bestaande rij en opsommen ervan in het tweede voorbeeld is minder relevant, omdat de totaal som b domineert.

Functie definitie NB vlak, waar b>0 en de lengte van de deelrij ? mag 0 zijn.

  1. NB.1. a,b = b
  2. NB.2.1. ?, = ?
  3. NB.2.2. ?,[X] = ?
  4. NB.3. a, ,1? `= a,a ,?
  5. NB.4. a,b, ,1? `= a,, b,?
  6. NB.5. ,,[X] `= ,[X]
  7. NB.6. a,b,[1]1? = a,,{b}a,[1]?
  8. MB.6. a,b1,[1]1? = a,b,,[1]1?

#2. Multidimensionale arrays

§3. Index rondes

Dezelfde structuren waarin we grote getallen uitdrukken, kunnen we gebruiken als systeem om grotere psi ψ indexen te noteren. Onze arrays en Bird's zijn daar bij uitstek voor geschikt. In dit hoofdstuk zullen we die vertaalslag maken.

§3.1. Psi index

In $0. introduceerden we het getal psi ψ, dat een virtuele bovengrens aangeeft voor ieder eindig systeem. En dat naar keuze, ofwel groter is dan fysisch uit te drukken in de gebruikte arrays voor grote getallen, ofwel gelijk aan omega ω oneindig. We schreven dit eerste grotere getal ψ met de index ψ1 een.

Opnieuw tellen van ψ1 tot ψn en virtueel voorbij het maximum systeem getal, is als optellen ψψ van psi. En herhaald psi optellen ψ.. is vermenigvuldigen ψ*ψ met een virtueel aantal psi. Omdat psi maar moeilijk of niet kan worden afgeteld, is dit slechts een notatie voor grotere getallen. De operaties en functies zelf zijn niet langer stapsgewijs reduceerbaar tot een eenvoudiger aantal psi.
Door ψ opnieuw in te zetten als systeem constante a = ψ kunnen we meer grotere getallen uitdrukken. In de evaluatie van array systemen verhuist die a (door substitutie in y bijvoorbeeld) weer naar hogere iteratoren.
Ga zo verder met ψ.ni.. in allerlei expanderende array systemen. Tot de grens van onze definitie met de maximale getallen structuur ψ,Z is bereikt.

Zelfs als we een groter systeem Ψ veronderstellen dan we zelf gebruiken. Zelfs als we aannemen dat er een wiskundig systeem Ψ = Ω bestaat (met een ω oneindig alfabet misschien van nestbare dimensie separator index haken). Dan nog komt er een punt, waarop we enkel verder komen door te stellen, dat er een groter getal achter onze ψ,Z horizon ligt. Dit nog grotere getal zullen we ψ2 noemen, psi index 2.
Deze bovengrens kan ook ψ2 = ω1 het oneindigere zijn. Per definitie is ω1 in de wiskunde het ontelbare, dat volgt op alle telbaar oneindige verzamelingen, die via rekenen of recursie afgeleid kunnen worden van de ω0 natuurlijke getallen.

Koppel dit terug naar ons array systeem door a = ψ2 te substitueren voor het nieuwe maximale getal ψ2,Z en per vergelijking ψ3 het volgende grotere.
En zo, door de voorganger in het systeem te betrekken en dat te overtroeven worden alle ψn gedefinieerd, de psi index n, de grotere getallen met natuurlijke indexen. Zolang als we tellers kunnen noteren met ψa,Z en er een index maximum is bereikt, aan de laatste horizon van alle telbare horizonten.

Jumpen we vrolijk verder met psi index psi, het eerste grotere getal ψψ volgend op onze maximum index.
Neem aan dat, ongeacht de plaats in de expressie, elk teken ψ zeker groter is dan met maximale getallen m in maximale array structuren m,Z uitgedrukt kan worden. En ook dat, met God's hulp, psi ψ oneindig is, zodat in het hogere oneindige ωω die index op zich ω oneindig is.

Dit construct ωω wordt in de set theorie het ontoegankelijk oneindige genoemd, of de eerste Mahlo kardinaal. Nu is onze indexering juist bedoeld om aan dat ratjetoe van namen in het hoger oneindige een einde te maken. Omdat we op systematische wijze vanuit het omega axioma verder bouwen: bij ons volgt elk nieuw limiet axioma systematisch uit een eerder.


Vanaf het oneindige tellen wiskundigen verder, van limiet tot limiet, een parade langs Cantor's ordinalen, met voorbij hun verzameling de volgende index. Een steeds langere tocht, en zo lijkt het of ωω erg ver van omega ω verwijderd ligt.
Echter, vanuit omgekeerd systeem perspectief is dit maar een klein eindje. Om dit verfrissend vergezicht in te leiden, enige voorbeelden van beperkte systemen, hun bescheiden maximale getallen en de nog niet zo veel grotere psi's.

Een kind dat tot hooguit tot 10 kan tellen, wordt door zus met psi 100 overbluft. Met die ψ1 als input tellen ze samen verder tot 110 en dan ψ2 = 200 zegt zus. Na tien keer tellen ψ10 = 1000 houdt broertje het niet meer bij, maar zus roept nog na ψψ = 10000 een myriade, wat oud Grieks is voor ontelbaar.

Grote getallen maken begon in het oude India met a = 100000 de lakh. Hun systeem was om een honderdtal keer het kwadraat te nemen. Daarbij kreeg elk nieuw groot getal een veelzeggende naam, tot asamkhyeya of ontelbaar was bereikt en ze chapati konden gaan eten.
Dit Indiase systeem maximum is 10^(5*2^108) ongeveer. Stappen we in de tijdmachine en om de bovengrens psi behapbaar te maken, leg het zo uit dat we met een miljard 10^9 beginnen, een duizendtal kubussen uitvouwen en daar gratis wat extra chutney bij doen.
Dat is 10^(9*3^1008) en is psi ψ = 10^3^2^10 zeker een groter getal.
Herhaal het systeem opnieuw met psi en rond 10^(9*(3^1021)^2) af op ψ2 = 10^3^2^11 de volgend grotere.
Doe dit asamkhyeya keer opnieuw en rond 10^3^2^10^2^111 verder af tot een psi ψm = 25^^6 met maximale index.
Stel dan dat ψψ = 5^^7 > 10^3^2^10^3^4^5 voor hen onbereikbaar is en ruil deze getalsnaam voor een samosa.
Ter vergelijk: iteratie tot Asamkhyeya en verder in de Bloemslinger Soetra van de mahayana boeddhisten is groter en van later datum.

Onze Amerikaanse computer (made in China) draait een 64 bit systeem en de harddrive heeft 8 Terabyte over. We reizen naar de toekomst (alle Menschen werden Brüder) en zetten deze vol met 2^40 adressen naar vrijwel oneindige variabelen in de Zion cloud, geschikt voor alle lineaire arrays, elke 4 byte een uniek adres voor een variabele op rij.
Voeg een nieuw adres toe voor een laatste variabele en schrijf daar het getal 2 naar toe (of 1 als dit itereert). Dan drukt de nieuwe rij de bovengrens ψ psi uit.
Nemen we a = ψ als input, dan is het uitgedrukte getal niet groter, dan wanneer we als laatste 3 hadden toegevoegd, wat dus ψ2 definieert.
Gezien de functie van lineaire arrays zal het substitueren van n2 in de laatste variabele op rij a,X,n2 altijd een groter getal ψn1 geven dan de voorgaande expressie ψn,X of zelfs ψn,X,n1 van die rij.
Om een bovengrens aan te geven voor alle eerdere rij expressies ψn,X of ψn,X,n of ook a,X,ψn kunnen we met ψψ = a,X,1,2 een variabele cel ,2 toevoegen (of ,1 als dit itereert).
Hoewel dat qua getalruimte nog verspilling is (psi index psi kan kleiner in zulke arrays), neemt dit qua adres ruimte in ons geheugen luttele bytes in.

Wat deze drie voorbeelden duidelijk maken is: hoe groter de maximalen van het systeem, hoe minder de psi en psi psi daarvan van elkaar lijken te verschillen.
Voeg een variabele toe aan het begin van Conway's pijlketen en het lijkt nog wat, want na tellen tot 10 ligt ψψ = 104 best verder.
Vertaald naar pijlketens ziet het Indiase maximum 2432 er al niet gek veel kleiner uit dan onze ruime bovengrens ψψ = 572 daarbij.
En als we in Zion de pijlketen a.xi.. met lengte :2^40 kunnen evalueren, dan zijn die extra 2 pijlen voor ψψ vrijwel insignificant.


Alle eindigende array functies werken qua bovengrens ψ tot ψm tot sprong ψψ zoals op de eerste rij. Zowel psi ψ als index psi ψψ vergroten we met met een iterator ,1 of ,2 aan het uiteinde van de array. Bouwend aan dimensionale en geneste arrays en zo verder, wordt het onderscheid van één variabele tussen de grotere psi ψ en de onbereikbare psi ψψ steeds verwaarloosbaarder.
En oneindig ligt veel verder dan de grote getallen van deze eindige superarrays, daarom moet de hoger oneindige ωω vrijwel samenvallen met ω omega.

Toch is dit nog beperkt gedacht en mist de essentie van het oneindige. Dezelfde analogie van ψ naar ω zou ook moeten gelden in een onbeperkt array systeem, waar de hoogste structuur in de definitie vanzelf een arbitraire maat heeft. Dan moeten we de systeem structuur dus uitbreiden of een nieuw concept toevoegen aan de bestaande definitie, voor hogere iteratie de grotere psi ψ kan bereiken.
Op de lineaire array van arbitraire lengte (wel bekend als functie met vararg), volgt hogerop de tweede rij in het vlak, al dan niet als tweede dimensie van een multidimensionale array.
Nieuwe concepten zijn cyclisch, zo zullen de elkaar dieper nestende separator arrays in nog hogere systemen fungeren als een variabel aantal units; als de enen van een volgende cyclus.

Maar steeds blijft dit verre perspectief geldig: hoe groter ons getallen systeem, hoe dichter ψ bij ψψ ligt. En in het verlengde daarvan, te zien vanaf het einde, dat het altijd weer grotere ω steeds dichter bij ωω komt te liggen.
Zodat de ω1 reële getallen (rekenkundig gedefinieerd immers met systemen), een niet veel grotere verzameling vormen dan de ω natuurlijke getallen.
Hoe dieper de onderverdelingen van de getallenlijn hoe dichter beide oneindigen naderen, tot een geheel. Nieuw is 2^^(1/2) en dan met p*{q}r*{s}-*t systematisch verder. Ook al blijft de radix expansie van de nieuwe reële getallen onbepaald, ze spreiden zich ver onder de gewone uit als vissen in scholen.

Niettemin hoeven we verder niet te refereren aan ω terwijl we over ψ verder bomen, en de psi indexering uitbreiden in dezelfde array structuur als van het systeem dat die psi's overtreffen. In de tweede ronde van het systeem.

§3.2. Psi index rij

In de voorbeelden werden nieuwe psi gedefinieerd als -> minimaal groter getal, relatief aan ons array systeem a,Z met daarin eerst een maximaal getal m en vervolgens de steeds grotere psi getallen als som constante.
Indexen bij psi ψb noteren we vanaf nu als ψ[b] variabele in haakjes.

ψ[0] = 1 -> 0
ψ[1] = ψ -> m,Z
ψ[2] -> ψ,Z
ψ[b1] -> ψ[b],Z
   ->> (..m..),Z :b1:

We stellen psi vanaf ψ1 -> m,Z en index nul ψ0,Z is een vreemde n eend.

Een grotere index teller kan nu pas worden uitgedrukt, als we ook daarmee ons getallen systeem voorbij springen.
Een maximale expressie m,Z is al een vaag begrip, het optellen van een klein getal 1 daarbij is ook in index context onbetekenend.
Het heeft weinig zin om de getallen ψψ zelf te vergelijken met of opnieuw in te voeren in het systeem. Enkel de psi index kan hier een groter getal aangeven.

ψ[ψ] ~> ψ[(m,Z)],Z <- ψ[(m,Z)+1]
   -> ψ[(m,Z)] > ψ[n]

Naast gewoon > groter dan en -> minimaal groter dan de expressie rechts, gebruiken we >> voor een serie van zulke groteren. Of een psi expressie is praktisch ongeveer ~> minimaal groter.
Ook < kleiner dan, herhaald << en met limiet <- of ongeveer limiet <~ kleiner.
Bij benadering ~ volgt een vrijwel gelijk getal of ook vrijere expressie.

Merk op dat equivalentie = een expressie in de reducerende evaluatie richting := uitwerkt, dat is naar een getal zonder systeem structuur. Maar dat een regel ook even andersom =: in construerende richting kan worden toegepast.


In de tweede systeem ronde met index arrays ψ[X] werkt het psi teken ervoor als de constante a in de eerste ronde. Maar we substitueren een kopie ψ[] inclusief haakjes. Wat vroeger optellen ab was, is nu het nesten van de indexering of het omvatten ψ[b] van de basis variabele, wat het omtellen van psi heet.

ψ[0,1] = ψ[ψ[0]] = ψ[1] = ψ
ψ[1,1] = ψ[ψ[1]] = ψ[ψ] = ψψ
ψ[2,1] = ψ[ψ[2]] = ψ[ψ2] = ψψ2
ψ[b1,1] = ψ[ψ[b1]] -> ψ[(ψ[b],Z)]
   > ψ[ψ[b]+1] -> ψ[ψ[b]],Z ~ ψψb

De tweede index variabele telt de psi, om of boven de eerste.

ψ[0,2] = ψ[ψ[0],1] = ψ[1,1] = ψψ
ψ[1,2] = ψ[ψ,1] = ψ[ψ[ψ]] = ψψψ
  -> ψ[ψ[(m,Z)]] > ψ[ψ[n1]]
  -> ψ[(ψ[n],Z)] > ψ[n,1]

Nu verloopt de constructie in het oneindige door Cantor zeer precies:
Tel getal ωωω+n dan index ω[ωω+n],X en dan ω[ω[ω+n],X],X diep, verder ω[ω[ω,X],X],X en schrijf de volgende ωωω2 omega index als ω[2,2].

In array systemen als de onze is het maximum nogal fuzzy, de psi grens hangt af van een nieuwe variabele binnen een (nog te ontwerpen) extensie. De bovenste stappen in Cantor's opbouw vallen dan vanzelf weg tegen die eronder; we halen er het maximum niet mee. De hoger oneindige Mahlo sprong kan alleen vanuit de diepste index worden gemaakt, maar voor elke index de constructie van boven naar beneden herhalen is niet erg zinvol. Als geschiedenis van alle geneste psi maar valide is, dit hele verhaal dus.

ψ[b1,2] = ψ[ψ[ψ[b1]]] =: ψ[ψ[b1,1]]
  ~> ψ[(ψ[(ψ[b],Z)],Z)],Z  Cantor
  -> ψ[ψ[(ψ[b],Z)]] = ψ[(ψ[b],Z),1]
   > ψ[(ψ[b,1],Z)] ~ ψ[b,2],Z ~ ψψψb

De functie van de tweede index variabele c is het veromvuldigen van de eerste. Zoals vermenigvuldiging a*c een reeks a.. optelt, ontstaat hier na aftellen een trap van c1 psi indexen, met de eerste index variabele b op de begane grond.

ψ[b,c1] = ψ[ψ[b],c]
     == ψ[..b..] :c2:

Van al die index treden is de onderste ook de dominante. Er vlak boven de ψ om de minimaal grotere -> psi array in kwestie mee te vergelijken.

ψ[b1,cd1] = ψ[ψ[b1],cd]
    == ψ[..ψ[b1]..] :cd1:
     = ψ[..ψ[..b1..]..] :d1: :c1:
     = ψ[..ψ[b1,c]..] :d1:
     = ψ[ψ[b1,c],d] = ψ[ψ[b1,cd]]
  ~> ψ[(..b..)],Z :cd2:  Cantor
  -> ψ[..(ψ[b],Z)..] :cd1:
             = ψ[(ψ[b],Z),cd]
   > ψ[..(ψ[b,1],Z)..] :cd:
 ~>> ψ[..(ψ[b,c],Z)..] :d1:
             = ψ[(ψ[b,c],Z),d]
      ~>> ψ[(ψ[b,cd],Z)]
   ~ ψ[b,cd1],Z ~ ψ[b,cd1]

In elke opvolger definitie kan de diepst geneste ψ[b1] vergeleken worden -> met een maximale subexpressie ψ[b],Z op dat niveau. De psi met index ψb domineert daarin en systeem structuur Z speelt een ondergeschikte rol.


Gelukkig hoeft de introductie van eerdere psi functie maxima niet helemaal op het diepst geneste niveau plaats te vinden en kunnen we dit, na aftel van de tweede, in de eerste index variabele aangeven.
Met basis indexen b>0 en c>0 geldt dit voor alle psi index arrays.

  • ψ[1,1X] = ψ[ψ,X] -> ψ[(m,Z),X]
  • ψ[b1,1X] = ψ[ψ[b1],X] -> ψ[(ψ[b],Z),X] > ψ[b,1X]

Door psi expressie substitutie ψ[b1,1X] = ψ[ψ[b,1X],X] zou de index functie veel sneller kunnen groeien, meteen al dubbel recursief zoals bij supermachten. Maar we hebben geen haast, elementaire psi index substitutie is genoeg. Onze oplaadregel zal het algoritmische verschil weer inhalen op de tweede index rij, waar we met de eerste variabele de rij ervoor opmeten.

ψ[1,1,1] = ψ[ψ,0,1]
       = ψ[1,ψ] = ψ[..ψ..] :ψ:
     ~> ψ[ψ,(m,Z)]
ψ[1,2,1] = ψ[ψ,1,1] = ψ[ψψ,0,1]
       = ψ[1,ψψ] = ψ[..ψ..] :ψψ:
     -> ψ[(m,Z),1,1]

Psi als bovengrens is niet aftelbaar, alleen de natuurlijke getallen waarmee we rekenen zijn dat, dus als we een iterator verder op de index rij met ψ opladen, moeten we deze eerst -> vergelijken met m,Z voor die iteratie op gang komt.
Ook voor het opladen kunnen we dat in de eerste index aangeven.

ψ[0,0,2X] = ψ[1,0,1X] = ψ[1,1,X]
     = ψ[ψ,0,X] -> ψ[(m,Z),0,X]
ψ[b1,0,1X] = ψ[1,b1,X] = ψ[ψ,b,X]
     -> ψ[(m,Z),b,X]

Omdat natuurlijk getallen bestaan uit louter enen 1.. zijn de afgetelde index variabelen ,0 in feite leeg, zonder nul teken.

ψ[,,,2X] = ψ[1,,,1X]
    = ψ[1,,1,X] =  ψ[1,1,,X]
    = ψ[ψ,,,X] -> ψ[(m,Z),,,X]
ψ[b2,,,1X] = ψ[1,,b2,X]
    = ψ[ψ,,b1,X] -> ψ[(m,Z),,b1,X]
    ~ ψ[ψ,(m,Z),b,X]

Evaluatie van de eerste rij van psi indexen werkt met deze ene oplaadregel. Waarbij k>0 dus er is links tenminste een lege ,c variabele op te laden.

  • ψ[b,{k1}1X] = ψ[1,{k}b,X]

Ook in geval b=0 lukt het om zo tot een vergelijk -> te komen en een aftelbare hoogste iteratie.

ψ[,{k>1}1X] = ψ[1,{k}X]
ψ[1,{k1}1X] = ψ[1,{k}1,X]
   == ψ[1,1,{k}X] = ψ[ψ,{k1}X]
   -> ψ[(m,Z),{k1}X]
ψ[b2,{k1}1X] = ψ[1,{k}b2,X]
        == ψ[ψ,{k}b1,X]
        ψ[.ψ,..b,X] :k

Zo hebben we met een paar regels een hele rij van psi index variabelen in kaart gebracht. Het doet er niet zoveel toe, wat die regels precies zijn. We zouden onze twee systemen, die voor gewone getallen en die voor psi indexen, aan elkaar kunnen aanpassen, zodat hun iteratie tellers precies gelijk lopen.
Belangrijk is dat we hier, met primitief nesten van de index en recursief opladen van variabelen vanuit de basis, door de eerste rij lengte k te variëren, in zijn geheel een dubbele recursie over die indexering uitdrukken.

§3.3. Psi index array

Begin nu de tweede index rij en druk met de eerste variabele daarop, die we de meter noemen, een aantal plaatsen voor parameters uit op de eerste rij.
Rijen scheiden we met een separator met index ,[2] en de meter herschrijft de rij ervoor met een lengte van komma separatoren , zonder index.

,[0] = ,[] = 0
,[1] = ,

Dat kunnen extra parameters zijn of een vervangend aantal. Dat kan direct voor de hele rij of stapsgewijs of druppelsgewijs.
Zo hevelen we een meter op de tweede rij druppelsgewijs over naar de lengte op de eerste rij, waarbij de hoogst geplaatste index ,bi langzaam opschuift en de waarde ervan telkens toeneemt.

ψ[b,{k},[2]n1] = ψ[1,{k},b,[2]n]
  == ψ[bn,{kn},[2]1]
   = ψ[1,{kn1}bn]

Het valt te bewijzen dat de toename in druppels van b0 naar bn in het grotere geheel insignificant blijft ten opzichte van de extra lengte n1 uit de meter.

Bij een definitie in stappen kan tijdelijk een extra teken $ nodig zijn. Welke regels we dan en dan toepassen volgt uit de expressie context rond de eerstvolgende aftelbare variabele.

ψ[b,{k1},[2]n1,X]
   = ψ[b,{k1}$,[2]n1,X]  $ intro
   = ψ[b,{k}$,[2]n1,X]  sep elim
  == ψ[b$,[2]n1,X]
   = ψ[b,[2]$n1,X]  $ move
   = ψ[b,[1],[2]$n,X]  sep intro
   = ψ[b,,[2]$n,X]  array elim
  == ψ[b,{n},[2]$1,X]
   = ψ[1,{n}b,[2]$,X]  b move
   = ψ[1,{n}b,[2],X]  $ elim

Onze tussenregel voor separator eliminatie om lege cellen aan het einde van de rij op te ruimen ,,[2] = ,[2] kan ook eerder worden ingezet, zodra elke iteratie rechts is afgeteld. Rekenkundig paste dit mooi bij arrays voor getallen, maar qua grootte veranderde dat al weinig aan het resultaat. En nu, als psi met acccumulatie van indexen vanuit b op is geladen naar de rij meter n wordt de voorliggende lengte in de index array volkomen insignificant.
We kunnen dit principe, om de kleinere ondergeschikte ruimtes leeg te tellen, en gelijke of grotere ruimtes of bovengeschikte variabelen te bewaren, nou wel bij alle mogelijke separatoren willen doorvoeren, maar het bepalen van de relatieve separator array grootte wordt almaar moeizamer. Zie bij Bird, hoe hij dit rigoreus tracht vol te houden: bij geneste arrays en zijn voorbij en verder.
Regels om afgetelde meters ,[R],[S] = ,[S] te verwijderen mits die aan de vergelijking R<S voldoen, zijn voor een groeiende structuur veel te complex en dragen niets bij. We zien daarom maar af van separator eliminatie, en ook van de tijdelijke tekens $ die een stapsgewijze uitbreiding van de ruimte mogelijk maken. Elke nieuwe lengte voegen we meteen toe aan de bestaande.


De regel voor opladen, die direct op de hele rij of voorliggende ruimte uitwerkt. Scan de expressie van links naar rechts `= tot de eerste aftelbare variabele gevonden is.
Elke variabele is gretig, dus hier stelt n een heel getal voor, dat meteen tot 0 reduceert en even zoveel mindere separatoren in de ruimte ervoor aanlegt.

  • ψ[b, ,[1T]n {n>0} `= ψ[1, ,[T]..b,[1T] :n == ψ[ψ, ,[T]..b-,[1T] :n -> ψ[(m,Z), ,[T]..b-,[1T] :n

Merk op dat de eerste aftelbare variabele van links ook een index kan zijn in een geneste separator array. En ook dat na aanvang elke b een getal psi voorstelt, dat niet wezenlijk van b- te onderscheiden is.
We kunnen de tussenzetten voor psi per vergelijking -> gevoegelijk overslaan en ons richten op de structuur, die tenslotte dominant is.

Definieer de verschillende ruimtes binnen de psi array met separator indexen.
Rijen variabelen ,ni.. met separatoren ,[2] ertussen vormen een vlak. Een aantal vlakken gescheiden door komma ,[3] vormt de derde dimensie. Ruimtes met separator indexen ,[p] vormen een p-dimensionale array.

Na de multidimensionale volgen de hyperdimensionale arrays, waar bij de komma ,[p0.,pi..] een hele rij van indexen hoort. En zo nesten we separator array ,[T] in separator array, op dezelfde manier bij deze psi functies als in de definitie van grote getallen.
Met de directe oplaadregel hierboven evalueert elke geneste array ruimte uiteindelijk tot een hogere psi.

Eigenlijk is alleen de definitie van hogere overgangen nog interessant in de expansie van deze structuur. Voor aftelbare variabelen blijven op elk niveau dezelfde oplaadregels gelden, van links naar rechts.

ψ[0, 1n `= ψ[1, n
ψ[b, ,1 `= ψ[1, b,

Gegeven een psi index functie basis met waarde b>0 zal de lege structuur links van de eerste aftelbare variabele opnieuw worden opgeladen. Zo geven de verschillende oplaadregels voor hogere meters uitdrukking aan de expansie van dimensies, nestdiepte, haakjesparen, etcetera. En geeft de structuur zelf een ordening aan van systemisch grotere index getallen psi.


Terug naar onze druppelsgewijze methode, waar het opladen van gewone parameters onder dezelfde definitie blijkt te vallen als de hogere meters binnen geneste arrays.

  • ψ[b, ,[1T]1 `= ψ[1, ,[T]b,[1T]

Omdat we het zo hebben geregeld dat ,[0] wegvalt, volgt uit T=0 in de formule het simpele opladen van variabelen als c=0 tot c=b op de eerste rij. Waarna het omtellen van psi indexen b tot ψ[b] weer kan beginnen.
Omdat dit qua definitie het meest economisch is, lijkt onze methode van het bijdruppelen van cellen en dimensies en hypergeneste separatoren de beste.

Waar het ons om gaat is, dat index array functies zoals die voor psi, dezelfde structuur en regels voor het reduceren of evalueren van elementen van die structuur kunnen hebben als natuurlijke grote getallen functies. Naar keuze.

§3.4. Psi systeem

In onze getal systemen expandeerden we de structuur voor geneste separator arrays ,[X] door deze achter elkaar ,.[Xi].. te zetten. Met daarbij de regel dat de meter rechts in het begin de nestdiepte van de array links vergroot. We noemen deze array reeksen diepen.
Binnen psi index arrays stapelen we de separator arrays net zo, met dezelfde evaluatie regels. Ertussen kan dan het volgende type operator separator gezet worden, die vanuit de diepen rechts de reeksen diepen links bij laat tellen. En zo voort. Elk nieuwe element kan op dezelfde manier in de psi array uitwerken, als in de getalsystemen waar psi ψ oorspronkelijk de bovengrens van is.

Maar ook kunnen we psi index arrays als reeksen schrijven. Alleen werkt de overgang in deze opeenvolging wat anders. Hier in de index array is Y weer een maximale structuur, precies als Z bij gewone functies.
Zo ver gekomen voegt de functie ψ[Y],Z niets zinnigs toe aan ψ[Y] en ook een extra variabele op de eerste rij ψ[ψ,Y] maakt de maximale Y niet groter. Eigenlijk verandert er niet gelijk zo veel.

ψ[0][1] = ψ[1] = ψ
ψ[1][1] -> ψ[ψ,Y]
ψ[b1][1] -> ψ[ψ[b][1],Y]
    ->> ψ[..ψ..,Y] :b1:
ψ[ψ][1] -> ψ[ψ[(m,Z)][1],Y]

De eerste index wordt in deze context weer als bovengrens gedefinieerd. Er staat in de vergelijking -> dat geen enkele standaard psi index array groot genoeg is om met de voorganger psi daarin de volgende psi uit te drukken.

De vergelijkingen -> laten we snel varen nu.

ψ[0,1][1] = ψ[1][1]
ψ[1,1][1] = ψ[ψ[1][1]][1]
ψ[b1,1][1] = ψ[ψ[b,1][1]][1]
     == ψ[..1..][1] :b2:
ψ[0,c1][d] = ψ[1,c][d]
ψ[b1,c1][d] = ψ[ψ[b,c1][d],c][d]
     == ψ[..1..,c][d] :b2:
ψ[b1,1V][X] = ψ[ψ[b,1V][X],V][X]
     == ψ[..1..,V][X] :b2:

Deze [X] kan het tweede diep zijn, of een reeks [Vi].. diepen omvatten.