Grote Getallen systemen

Voorbij Conway's pijlketens!

door Giga Gerard

Dag / Nacht

Deel 1: Grote natuurlijke getallen, voor de sprong naar oneindig.
Deel 2: _ Grotere Getallen met ψ

§1. Getallen

De googologie of wiskunde van de grote getallen begint met eenvoudig tellen. Op de vingers van een hand en zo maar door.

§1.1. Tellen met 1 en basis 10

Voor natuurlijke getallen, tel een 1 op tot het aantal 1.. enen. Voor negatieve getallen, zet links een factor min - of tel de minnen -.. van rechts op.

Tel in een repetitie, die 1 selecteert en op zijn .. plaats een aantal :n keer herhaalt, tot al die enen gelijk = zijn aan getal n uit de rep en het tellen stopt.
Of begin met het getal nul 0 dat niets   is, en stop zonder te tellen.

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

Schrijf de getallen van twee tot tien met cijfers 2,3,4,.. en definieer ze met enen. Zet deze ook om => in binaire notatie met basis 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

In een basis systeem of radix r lopen de cijfers van 0 tot r- en hebben aparte tekens. Daarna komt 10 als de eigen basis en de verdere samenstellingen.
De lengte van getallen in een basis wordt door de extra tekens bekort. Zo is ieder natuurlijk getal <r^k op unieke wijze gegeven met maar <k cijfer plaatsen.

Schrijf een getal in basis r als een reeks digits d en vertaal deze terug als factoren * van oplopende machten ^ van r die in serie worden opgeteld.

di.. k:0  <=
  +di*r^i.. 0:k

De index i neemt elke volgende stap toe of af met 1 zoals l-r van links naar rechts aangeduid in de rep.
De waarde van de cijfer plaatsen loopt l-r af (het grootste cijfer getal vooraan), maar de constructie van getallen via herhaalde vermenigvuldiging van 10 moet wel oplopen. Derhalve is behalve de historische herkomst van de cijfers ook de r-l richting van decimale getallen Arabisch te noemen.

In basis zes is het getal 555 hetzelfde als 215. in basis tien. Maar als de bases onbekenden zijn, zou je die dan kunnen berekenen..?

§1.2. Fysieke getalgaten

Grote getallen zijn kort weer te geven in wiskundige expressies, die met behulp van regels te evalueren zijn tot een aantal enen. Expressies bestaan uit speciale tekens voor operaties of functies, en ook de definitie van regels in een algoritme vereist een zekere notatie. Ons reisplan is om wiskundige constructen en hun relaties te herkennen en te herhalen tot in het oneindige.

Doel van de googologie is om met een minimaal aantal tekens en zo beperkt mogelijke regels, zo groot mogelijke getallen te noteren.

Hoe sneller de functie, hoe meer getallen tussenin gemist worden in de notatie. Zulke grote gaten liggen dieper verborgen dan de grote getallen zelf, die als vuurtorens boven hun eiland van naburige kenbare getallen uitsteken, terwijl de zee van random getallen eromheen onkenbaar is.
Al vrij snel in ons verhaal zijn de meeste natuurlijke getallen door geen enkel praktisch getalsysteem meer te bevatten. Want de systemen die in ons fysisch heelal mogelijk zijn, zijn beperkt door het aantal te observeren quantum bits.
We kunnen stellen dat binaire getallen met een lengte van ongeveer 10^81 (Vopson 2019) tot wel 10^90 (Lloyd 2001) zich nog in ons zicht bewegen.
Daarboven wonen de goden.

In elk wiskundig systeem is de expressie lengte van de meeste gehele getallen groter dan in een radix met evenzoveel tekens. Hoewel dit verschil niet meer dan een luttele basismacht 10 kan bedragen in totaal, omdat al die expressies uiteindelijk tot 1.. evalueren in de systeem output.

Al de getallen die de mens kan gebruiken zijn relatief klein. Het vervolg van ons reisverhaal over de getallen is dus volstrekt nutteloos, hopelijk, duimen maar!

§1.3. Googol en googolplex

Kuiper Belt object, red double rock, photo by NASA

Als groot getal noemen we de googol, te schrijven als 10^100 met exponent, of in onze basis tien als een 1 gevolgd door 100 nullen.
De Babyloniërs zouden hier in basis 60 een reeks van 57 spijkerschrift tekens voor nodig hebben. In de digitale radix 256 neemt dit 42 bytes in beslag.
Voor de googoloog, die net als Google zijn naam dankt aan dit getal, geeft een basis notatie erge rompslomp. Cijfers zijn handig om getallen mee af te korten, maar googologen tellen net zo goed weer enen als onbenullen nullen.

Een googolplex is een 1 met googol nullen, ofwel 10^10^100 met dubbele exponent. Dit getal zou in de hypothetische basis googol met 10^98 nullen geschreven worden. Als elke 0 daarin de maat van een bacterie heeft vullen die de gehele ruimte van het heelal, een voorbeeld van de onmacht van radix systemen.
Om een random getal verborgen in de zee rondom het googolplex uit te drukken met quantum bits, hebben we tot wel 10^20 keer zoveel van die deeltjes nodig dan er in ons heelal zijn. Zelfs bij een vrije keuze om elke mogelijke wiskundige expressie te evalueren met elk mogelijk wiskundig systeem, weer te geven als input (uitrekenen hoeft niet) op onze ene universum quantum tablet, is het nog onzeker of elk getal opgevist zou kunnen worden. Een macht hoger de meeste random getallen zeker niet!

Googolplex is al een onbegrijpelijk groot getal. Het eerste vuurtoren eiland dat we aandeden op onze ontdekkingsreis naar het oneindige.

§2. Supermacht operaties

Met de eerste supermachten *{k} zijn we al gewend om te rekenen. Dit zijn de operaties van optellen *{0} en vermenigvuldigen *{1} en machtsverheffen *{2} waarvan ook de inversen, reële en complexe getallen bekend zijn.

§2.1. Rekenoperaties

Door var variabelen met natuurlijke getallen a en b naast elkaar te zetten, telt de som ab meteen op, omdat we enen 1.. tellen.
We plaatsen plus + tekens tussen getallen om optellen uit te stellen. En een extra plus links voor het algoritme.

+1+1+1 = +1+11 = +111
    = 111 = 3

Door deze regels voor optellen consequent vanaf rechts toe te passen, komen de wachtende operaties beschikbaar en kan hun + wegvallen.

  • +a = a
  • +a+b =` +ab

Het is gelijk teken = drukt gelijkwaardigheid uit en regelt de evaluatie van hele expressies of subexpressies (binnen haakjes).
Het ïs rechts teken =` selecteert het woord vanaf rechts in de expressie. We werken alle operaties r-l uit: van rechts naar links.

Operaties rechts van een plus teken krijgen voorrang, maar ook elke hogere operatie die links ervan staat.
De plus operator is te beschouwen als *{0} nulde superster, die leeg is.


Vermenigvuldigen is herhaald optellen van een constant a.. getal. Het keer of maal teken schrijven we met een * ster. Een voorbeeld in stappen.

 2*3 = 2*2+2 = 2*1+2+2
     = 2*1+4  2+4 = 6

De iterator is hier 3 en in het algemeen een variabele b waar elke stap 1 vanaf telt om een kopie van a op te sommen.

Definitie van vermenigvuldigen.
We gebruiken een nieuwe regel, die de vorm met iterator b=1 meteen uittelt.

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

Vindt een match vanaf rechts =` in de expressie voor de vorm links in de 2e regel. Doe daar de iteratie stap die de constante a bijvoegt. Herhaal de reeks stappen == met optellen van a tot de iterator 1 is. Pas daarna de 1e regel toe die de iteratie elimineert en de uitkomst levert.

De rep :b herhaalt de tussen . of terzijde van de punten .. geselecteerde passage b maal. Reps zijn beschrijvend bedoeld en niet regelgevend.

De ster operaties die met vermenigvuldiging beginnen, zijn voor ons maar een manier om grote getallen te noteren. Er is geen behoefte om de operatie a*1 apart te evalueren.
In het algemeen zijn iteraties met b=1 in input expressies a*{c}b overbodig omdat a hetzelfde is, en anders is b>1 groot in deze vorm, zodat er geen aparte reductie regel voor nodig is.


Machtsverheffen ** of ^ is herhaald vermenigvuldigen.
Om machten stapsgewijs uit te werken, waarbij lagere operaties eerst evalueren, moeten we de hogere apart kunnen zetten.

2**3 = 2**2*+2 = 2**1*+2*+2
     = 2**1*+2*2 = 2**1*+4
     = 2*4 = 8

Onze pop plus + in de popster *+ operatie stelt die vermenigvuldiging uit met één teken (zonder haakjes), tot dit eruit popt.

Evalueer popster machten in stappen met drie regels.

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

Het equivalentie teken werkt de expressie uit in een vorm die niet via deze regels te bereiken is: als meerdere vermenigvuldigingen.

Hoewel dit in de uitwerking zelf niet kan gebeuren, telt in ons popster systeem a^b+1 één op bij een factor, maar 1+a^b gewoon bij het totaal.
Staat rechts na de ** macht een * vermenigvuldiging, werk die dan eerst uit tot exponent. Maar volgt een ster *+ met pop plus, dan komt die als extra factor op de reeks factoren.

Onze beperkte regels evalueren expressies strikt r-l vanaf de rechter kant. Maar we kunnen het ook zo regelen, om carets ^ met meerderheids-precedentie op te lossen (hogere operaties met meer tekens eerst), en daarna pas sterren * met minderheids-precedentie (wat juist minder tekens voorrang geeft).

Large plus sign in the sea waves, distant sphere

§2.2. Popster supermachten

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

a***b  a**..1 :b

Operatie na operatie bouwen we zo de supermachten *{c1} of ^{c} waarin de teller c het aantal operator tekens telt.
Een supermacht is een dubbele recursie van variabelen, met iterator b=1 en operator teller *{0} als initiële waarden.

Werk als voorbeeld de supermacht 2****3 uit in stappen van rechts.
Het helpt om carets ^.. te gebruiken.

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

We kunnen supermacht expressies met twee tekens 1 en * noteren. In de evaluatie komt daar de pop plus + als solo haakje bij; slechts drie tekens.
Het caret ^ teken, de cijfers en decimale getallen, werken als afkortingen.


Operaties met pop plus komen nooit alleen te staan. En optellen met *{0} is direct. Zo kan de evaluatie van supermachten *{k} toe met maar drie regels.

We zouden ervoor kunnen kiezen om optellingen, of misschien elke expressie +X in dit systeem, met een plus aan de linker kant te merken. Deze extra regel vooraf maakt dan het uitgestelde optellen van +a+b tot ab mogelijk.

  1. PS.0. +a = a

Definitie om PopSter supermachten te evalueren tot natuurlijk getal.
Bij de iterator geldt b>0 maar de operator vorm *{c≥0} kan ook leeg zijn.

  1. PS.1. +a*{c}+b =` +a*{c}b
  2. PS.2. a*{c1}1*{d}+ =` a*{d}
  3. PS.3. a*{c1}b1 =` a*{c1}b*{c}+a a*{c}..a :b

De regel die een match geeft met de meest rechtse =` positie (start index) in de expressie, moet worden uitgevoerd.
Variabelen zijn gretig naar enen, zodat elke getal vorm uit de regels compleet is, zonder rest deel in de expressie.

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

In de expressie a^{c}b1*{d}+e ontpopt de iteratie van rechts als hoogste exponent in de toren a*{c}..a*{d}e :b wat significant kan zijn en een aanvulling op ons rekenapparaat voor de inschatting van array functies.


We kunnen sommige supermacht operaties alleen ruwweg met elkaar vergelijken qua grootte. In dit voorbeeld neemt het absolute verschil < tussen twee ster supermachten bij grotere c toe. Terwijl dit verschil in de context van de hierdoor groeiende reeksen klein begint met 1 en niet significanter zal worden.

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 noteert een reeks waarin de indexen j naar rechts afnemen.

In de teller kan ook een expressie staan, die dan 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 selecties aan beide kanten van de expressie. Plaats elke selectie op zijn punten .. links erna en rechts ervoor in de expressie. En werk in stappen van binnen naar buiten, tot de rep tot :1: is uitgeteld en deze met de punten uit de expressie verdwijnt.

De evaluatie van supermachten kan simpeler! Steeds de constante a aanhalen is overbodig, omdat de macht b en het aantal sterren *{c} variabel zijn en kenmerkend. Ook komt er tijdens uitwerking van rechts van elke kleinere operator hooguit één te staan, en wachten de hogere in rangorde links tot de lagere zijn gereduceerd tot getal.
Vandaar dat we de supermachten kunnen vertalen naar een functie rij, die minder tekens gebruikt en waarvan de text lengte tijdens evaluatie korter is.

Pas in 1976 zag de superoperator het licht, met 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.

§3. Lineaire systemen

Uit de supermachten komen de bekende functies voor grote getallen voort, zoals Conway's pijlketen en Bird's lineaire array notatie. In dit hoofdstuk zijn deze systemen beperkt tot de eerste rij van variabelen.
Onze eigen functies beginnen langzamer: met primitieve recursie over de rij, waar we (geen subexpressies nesten, maar) alleen optellen, aftellen en schuiven. Zo eenvoudig en natuurlijk mogelijk, terug tot 1 of tot 0 leeg.

§3.1. Primitieve 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 variabele b in de oorsprong en van daar uit 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 oorsprong 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 oorsprong a,b de som ab en vervolgens vanuit de lege oorsprong 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 oorsprong 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.

#3.2. 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 het som totaal vanuit de oorsprong 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?

#4. Multidimensionale arrays

Een rij variabelen met natuurlijke getallen noemen we de eerste dimensie, terwijl deze eigenlijk bestaat uit rijen van rijen van enen. Een reeks van rijen variabelen vormt dan een vlak of tweede dimensie, hoewel de rij lengtes daarin variabel zijn. Herhaling van het vlak vindt plaats in een kubieke ruimte, de derde dimensie.

We noteren al zulke array ruimtes op een lijn in de expressie, waar ze van elkaar gescheiden worden met specifieke separatoren. We zouden door een aantal komma's na elkaar te zetten simpel de dimensies kunnen aangeven.

a,b ,ci..,,..,,,.. :d :e :f

Dit veronderstelt wel dat we variabelen niet aftellen tot 0 maar tot 1, anders zou de betekenis van opeenvolgende komma's al vergeven worden op de eerste rij. Alle ruimtes van een multidimensionale array kunnen we door een aantal ,{k} komma's laten scheiden, maar zou dat niet zonde zijn?

Het teken 1 hebben we gereserveerd voor variabelen. Elk opeenvolgend aantal enen 1.. drukt een natuurlijk getal uit in de expressie, waarin de functie van dat getal nader bepaald is door zijn positie en het algoritme.
Stel nu dat de andere tekens die we toepassen, zoals separatoren en haakjes paren, substituut staan voor diverse aantallen van een ander wiskundig quantum, ons type teken in abstracto, de nul 0 in concreto.
Bij de samenstelling van array elementen zullen we steeds rekening houden met deze achterliggende array bit notatie. Die moet onze oplossing vormen voor het Busy Beaver probleem, althans ongeveer een maximaal getal schrijven met twee (of meer) mogelijke tekens. Vanuit de constructie van een evoluerend systeem, zonder Gödelachtige alfabetisering, maar gestaag groeiend.

Laat de komma , om getallen te scheiden als variabelen, het ene 0 type zijn.
Er zijn verschillende manieren om ons systeem economischer uit te breiden dan hierboven met ,.. multipele komma's. Maar welke is natuurlijker?


Door op dubbele variabelen over te stappen .,ci,qi.. is het mogelijk om na elke even komma rechts van de variabele ci de dimensie overgang qi aan te geven, zonder extra 00 type teken. Er links voor kan ook.
Om deze duo variabelen in de rij te herkennen, geeft dit bij de expressie scan in het algoritme helaas telproblemen. Ook groeit zo'n systeem niet natuurlijk. Het hinkt: eerst op één poot en dan op twee poten, en later eventueel op duizend.
Door bij elke variabele een vast aantal extra tellers te zetten, behalen we de hyperdimensies in een rij. Dit kennen we als de index rij bij de separator.

Of spreek net als Bird af, dat een getal tussen haakjes de dimensie van de ruimte rechts ervan kenmerkt. Door enkele komma's binnen de subarray te halen, breiden Bird's multidimensionale uit tot hyperdimensionale arrays.
Zolang onze subarrays niet genest worden en de scanner van eerste tot tweede teken kan tellen, mag het beginhaakje dezelfde zijn als het sluithaakje. Het bit type is dan 00 aan beide einden, ook al gebruiken we in de expressie [ en ]. En afgetelde subarrays [1]=, evalueren meteen tot type 0 komma.
Bezwaar is hier, dat de tel bijhouden niet echt een taak is voor de tekst scanner. Een woord moet zonder de helft van de expressie te doorlopen op elke plek herkend kunnen worden. Lijkt op het voorbeeld hiervoor, maar extra tellen kan hier niet, omdat in elkaar nesten van gelijke haakjes verwarring geeft.

Juist is om twee typen haakje te gebruiken, of hetzelfde type maar bij de opening gebonden aan een separator teken. Bird gebruikt krulhaken { en } en breekt met het gebruik van enkele komma's , door te stellen dat deze in staan voor index 1 subarrays. Zijn variabelen worden altijd tot 1 en niet tot 0 afgeteld, zodat separator haakjes elkaar nooit zullen raken.
Zo bezien zijn Bird's haken van het type 0 en 00 en hij kan daar alle geneste arrays mee vormen. Zijn afgetelde indexen worden steeds opgeladen vanuit de oorsprong met subtotaal b wat optimaal is. We mogen stellen dat gegeven deze beperkte tekens de door Bird geneste getallen maximaal groot zijn.

De overgang van de komma uit Bird's lineaire arrays naar zijn dimensie haakjes verloopt niet zo soepel. We gaan liever van , naar ,[n] met behoud van het separator teken, waar het openingshaakje van de index array aan gekoppeld is, ook al kan Bird ons een type voor blijven.
Onze opening ,[ telt als type 000 en sluit af ] met type 00. Schrijf eventueel de multidimensionale arrays met een enkel haakje ,n] om provisorisch even een type te besparen.

Na het vrije haakje ] dat de geneste array afsluit, volgt de variabele die meter is van de ruimte ervoor. We expanderen dit systeem door binnen het separator construct nieuwe en grotere array types te plaatsen. Voor het type tellen we simpel 0.. de teken types na elkaar.
Vorm diepe arrays met overgangen ][ die als type 0000 scoren. Het volgende diep [X][1Y] zal op die overgang de afgetelde array ervoor tot grotere diepte nesten. We maken dat ook staps-of druppelsgewijs mogelijk.

a,b1 ,[1][3]
   `= a,a ,[1,[b1][2]2]
       `= ,[1,[b][2]a,[b1][2]1]
      `== ,[1,[1][2]a`]
       `= ,[1,[1,[a][1]2]a`]
        = ,[1,[1,[a]2]a`]
      `== ,[1,[1,a`]a`]
       `= ,[1,[a`]a`]
      `== ,[a`]
  `== a,a,a

Tussen reeksen [Xi].. plaatsen we het teken ; als diepen separator. We scoren deze als type 0 omdat ook de komma , kan worden hergebruikt.; mits in een optimaal systeem dat strikt tot 1 aftelt. Maar we introduceren een nieuw teken, om systemen die tot 0 itereren in dezelfde structuur mogelijk te maken.
Deze overgang ];[ is van type 00000 en vermenigvoudigt de lege diepen links. Zoek een gewoon haakje ] of 00 om te eindigen.
Onze opzet lijkt op de eerste rij variabelen 1.. waar het systeem mee begon.

a,b1 ,[1];[c1]
   `= a,a ,[1][b1];[c]
       `= ,[1,[a][b];[c]2]
      `== ,[1,[1][b];[c]a`]
       `= ,[1,[1,[a][b-];[c]2]`]
      `== ,[1..,[1][1];[c]..`] :b:
      `=` ,[1][1][a];[c-]
       `= ,[1][1,[1][a][a-];[c-]2]
     `==` ,[a][a-][a-];[c-]
      `== ,.[a-]..;[1] :c1
        = ,.[a-].. :c1

Maak diepe dimensies met de overgang ];[[ van het type 0{7} ertussen (dus niet [[ bij de komma al), lopend tot aan ]][ type 0{6} die het dubbel diepe construct afsluit, zodat het enkel diepe weer begint.
Reduceer ;[[1]] tot ; en noteer de diepe dimensies met ;[[n]] naar analogie van de multidimensionale arrays.

a,b1 ,[1];[[2]][3]
   `= a,a ,[1];[[1]][b1];[[2]][2]
    = ,[1];[b1];[[2]][2]

#5. Geneste arrays