Grote Getallen Generatie

§1. Getallen

Tel op tot een getal en herhaal getallen en hun herhalingen en noteer dit in functies. Elk object van de wiskunde is telbaar, en zo ook de relaties tussen die objecten. Getal relaties of functies die zichzelf herhalen heten “recursief”.
Recursie is versneld tellen, maar de “googologie” of leer van de grote getallen, begint gewoon met tellen op je vingers.

§1.1. Tellen

Neem eerst het getal nul 0 dat in wezen niets is, en stop zonder te tellen.
Een tel erbij 01 geeft het getal 1 een.

Maak vervolgens de natuurlijke getallen, door units een 1 op te tellen tot een aantal 1.. enen is bereikt (dat gelijk is aan het getal) waar het tellen stopt.

Definieer dit met een repetitie of rep over de selectie 1, die op zijn .. plaats het aantal :n keer wordt herhaald tot de uitkomst = het getal n geeft.

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

Maak een getal negatief door links voor de positieve een factor - te plaatsen.
Of vorm gehele negatieve getallen door een aantal units min -.. van rechts op te tellen. Waarbij 1- nul 0 of leeg is.

Peano's primitieve opvolger functie σ maakt elk volgende natuurlijke getal.

σ(0) = 1
σ(n) = n1

Druk getallen n uit door functies σ(..) :n: herhaald te nesten, dan staat elke aanhaling van σ(.) gelijk aan een 1 tel.

Tellen dat nooit stopt drukt per definitie een oneindig getal uit.

1... = ω

Getal omega ω zou het eerste en kleinste oneindige getal boven de natuurlijke getallen zijn. Waarna het tellen σ(ω) = ω1 weer verder kan gaan.

Getallen zijn wiskundige constructies. Gehele en oneindige getallen bestaan uit eenheden of units en tellen dat stopt of niet. Operaties en functies en hun inversen drukken nog meer getallen uit: breuken en wortels, transcendente en complexe getallen; tussen de gehele getallen in en daaraan ontstegen.

Recursieve functies in dit deel blijven in het domein van de natuurlijke getallen.

§1.2. Basisnotatie

Lees getallen in unaire notatie door elke 1 erin een keer te tellen. Stop met enen tellen bij getal tien dat de decimale basis vormt.
Tel dan de tientallen. Stop na tien keer tien bij een honderd. Tel tien honderdtallen tot een duizend. Duizend duizendtallen maakt een miljoen. Tot zo ver zijn onze landen het wel met elkaar eens.

De eerste natuurlijke getallen na 1 in decimale notatie met cijfers 2,3,4,.. en unair gedefinieerd. Zet deze ook om => in binaire notatie in 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
 11 = 11111111111 => 1011
 12 = 111111111111 => 1100

Systemen voor grote getallen geven als output reeksen 1.. enen. Maar in de input en bij voorbeelden schrijven we getallen met cijfers en decimaal. Voor de duidelijkheid voegen we aan decimale getallen met meerdere cijfers een punt toe, zoals bij 10. onze tien.

In een basis notatie met radix r hebben de gehele getallen van 0 tot r- enkele cijfers. Dan volgt de basis r=10 en de volgende getallen met meerdere cijfers.
De notatie lengte is door de extra tekens bekort. Onder de r^k kunnen de natuurlijke getallen uniek worden becijferd op k of minder plaatsen.

Een getal in basis r met een k1 aantal cijfers d_i is te vertalen := naar een serie factoren di* van oplopende machten ^i van r die opgeteld + wordt.

di.. k:0  :=
  d0.+di*r^i.. :k≥0

Index i neemt elke volgende stap toe of af met 1 zoals dit van links : op rechts is aangeduid in de rep.

De waarde van cijfer plaatsen neemt l-r af, van links naar rechts, terwijl de constructie van getallen bij herhaalde vermenigvuldiging van 10 op moet lopen. Naast de historische herkomst van de cijfers is dus ook de opbouw van de decimale getallen r-l in de richting van het Arabische schrift. Voordeel is dat l-r lezers het belangrijkste cijfer van de grootste macht nu vooraan zien staan.

---

Vraag: In basis 6 is het getal 555 hetzelfde als 215. in basis tien. Maar als de bases onbekenden zijn, zijn die dan te berekenen..? Valt te bewijzen, dat geen enkel ander basis paar voldoet..? En als dit in het algemeen onmogelijk is, voor welk soort getallen kan het wel..?

§1.3. Getalgaten

Getallen kunnen bestaan uit eenheden of units, of verkort geschreven worden met operaties of functies in een wiskundige expressie.
Expressies voor natuurlijke getallen zijn met behulp van regels te evalueren tot een uitkomst bestaande uit een aantal enen.
Om structuur toe te voegen aan de expressie zetten we extra tekens in. En ook het algoritme, met de definitie van de regels voor evaluatie van expressies, zorgt voor een uitbreiding van ons wiskundig taalapparaat.

Doel van de googologie is om met een minimaal aantal tekens en zo beperkt mogelijke regels, zo groot mogelijke getallen te noteren. Om hogere wiskundige structuren te herkennen en daarover dan te itereren tot in het oneindige.

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 random zee van getallen eromheen onkenbaar is.
Vrij snel in dit 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 het 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 dit reisverhaal in de getallen zal bijgevolg volstrekt nutteloos zijn, hopelijk...

§1.4. Googols

Een beroemd groot getal is de “googol”, geschreven als 10^100 met exponent, of in 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 dit heelal te vinden 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. Met een hogere exponent erbij 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.

---

Vraag: Googol is 10^100. Vind een benadering voor de tetratie wortel t, zodat t^^t dicht in de buurt komt van googol. Stel t is een exact reëel getal, niet fundamenteel fuzzy of onkenbaar, hoort t thuis in een nieuwe klasse..? Sneller en dieper verzonken in de getallenlijn dan de eindeloze rij breuken, waarmee we algebraïsche en transcendente reëele getallen benaderen...?

Stel dat deze superwortels niet kunnen worden berekend. Dan bestaan ze wel door hun wiskundige definitie, maar blijven fundamenteel onbenaderbaar en vallen buiten het deelbare 2^ω continuüm. Er zijn oneindig veel hogere ^{c} operaties en functies met *[X] superarrays. Zijn de meeste inversen daarvan zo vaag, dat ook hun relatieve ordening onbekend moet blijven..?

§2. Supermachten

Donald Knuth noteerde supermacht operaties met hele reeksen. Wij beschrijven hoe dit in stappen kan, in plaats van Knuth's oppijlen met ^{c} carets en voor supersterren *{c1} die terugkeren tot de primitief recursieve basis van *{0} unair optellen.

De rest van dit hoofdstuk evalueert supermachten met onze nieuwe “popster” operaties. We bouwen het systeem van regels voor popsterren langzaam op, en beginnen met de elementaire operaties van het rekenen. De algemene uitwerking van popster supermachten zal nauw aansluiten bij onze primitief recursieve functie Adam voor supermachten over een rij parameters.

§2.1. Supermacht reeksen

Een supermacht operatie a^{c1}b is een reeks voorgaande operaties met als operatoren ^{c} tussen een b aantal variabelen a die we van rechts op links uitwerken. Hierin telt c>0 het aantal carets, met aan de basis het ^ machtsverheffen, wat zelf een reeks van * vermenigvuldigingen inhoudt.

Stapsgewijs kunnen we de supermachten zo definiëren en tot hun reeks == uitwerken, gegeven dat de grotere operatie ^{c1} voorrang heeft.

a^{c1}b1 = a^{c1}b^{c}a
        == a^{c1}1.^{c}a.. :b
         = a^{c}..a :b

De passage die aan de linker kant van de expressie of rechts van de enkele . punt begint, wordt op de enzovoort of ellips .. in totaal b keer herhaald, zoals door de rep :b aangegeven.
Onze repetitie notatie is als uitleg bedoeld en niet regelgevend. Voorbeeld hoe een rep ook in stappen precies te maken valt, met tekst variabele X.

X.. :3 = X..X :2
       = X..XX :1 = XXX

Zowel de supermacht operaties met carets ^{c} als die met sterren *{c} zijn rechts associatief. We tellen in een operator een ster meer dan bij carets, zodat ^{c} en *{c1} dezelfde supermacht betreft.
Zonder prioriteit worden deze operaties r-l van rechts naar links uitgewerkt.

Bij caret supermachten krijgen de operaties met de meeste carets prioriteit. Om de top operatie rechts in de reeks hierboven verder te evalueren, moeten de lagere operaties afgescheiden worden van de reeks a^{c}.. die links blijft staan. Dat kan door vooraf ronde haakjes te introduceren.

^{c}a^{c}a =` ^{c}(a^{c}a)

Dat de dominante top supermacht rechts eerst aan bod komt, geeft aanzienlijk grotere getallen. Toon dit aan voor machten.

(a^a)^a == (a^a)*..1 :a
        == (.a*..1)*..1 :a :a
         = a*..1 :a*a
         = a^a^2  <
a^^3 = a^a^a == a*..1 :a^a

Operator prioriteit bij ster supermachten wijkt af, omdat we de minste sterren voorrang geven. Dan zijn er meteen ook haakjes nodig bij de uitwerkingsstap in de definitie. Hier geldt c≥0 zodat vermenigvuldiging * tot een serie directe optellingen *{0} reduceert.

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

Laat de haakjes om het getal binnenin wegvallen, en werk dan de top operatie (a*{c}a) binnen de aanwezige haakjes uit. Of we zouden hier := de hele reeks van hun tijdelijke haakjes kunnen ontdoen, omdat vanwege de r-l minoriteit van sterren de operaties rechts vanzelf apart gaan in de evaluatie.

§2.2. Popster rekenen

Met de eerste supermachten *{k<3} is nog goed te rekenen. Dit zijn de operaties van optellen *{0} en vermenigvuldigen * en machtsverheffen ** waarvan er ook inversen en hun (oneindige) functie series bekend zijn: de breuken en de algebraïsche, transcendente en complexe getallen.

§2.2.1. Ster 0 optellen

Als variabelen met natuurlijke getallen a en b naast elkaar staan, is meteen de som ab gegeven, doordat alle enen 1.. bij elkaar optellen.
Plaatsen we dus een plus teken + tussen variabelen om optellen uit te stellen.

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

Het “is gelijk” teken = stelt dat de hele expressie of subexpressie (die binnen haakjes) aan beide kanten gelijk is. Vervang in de evaluatie de vorm links ervan door de vorm rechts.
Het “is rechts” teken =` selecteert zijn vorm aan of vanaf de rechter kant in de expressie (of subexpressie).
Door de • regels voor optellen consequent vanaf rechts toe te passen, komen wachtende operaties vrij en kan hun + wegvallen. Zo reduceren we alle popster operaties r-l met als uitkomst een getal.

Voorbeeld van optellen in stappen tot getal.

1+1+1+1 = 1+1+11
     = 1+111 = 1111 = 4

Operaties rechts van een willekeurig plus teken krijgen voorrang. Normaal komen ook alle operaties met hogere prioriteit eerder, zoals ^ en * als die links staan. Maar popsterren evalueren we strikt van rechts naar links.

Om duidelijk te maken dat steeds de popster regels r-l van toepassing zijn, kunnen we dat aangeven met een plus +X aan het begin van de expressie.
Dit verandert alleen de basisregel voor optellen.

• +a = a

De betekenis van de plus operator is het uitstellen van de optelling tot beide zijden klaar zijn: een mono-haakje dus. Maar links genoteerd zou een plus aangeven, dat hogere operaties in de expressie volgens de regels moeten wachten op de lagere rechts.

In het kader van popster operaties is optellen met de nulde superster *{0} leeg, waarmee unaire variabelen direct samenvallen.

§2.2.2. Ster 1 vermenigvuldigen

Herhaald optellen a.. van een getal heet vermenigvuldigen. We schrijven het keer of maal teken ervan met een * ster.

Definitie van vermenigvuldigen voor gehele getallen. Stel b>0 zodat de eerste regel in de laatste stap de iteratie overneemt van de tweede regel.

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

Selecteer vanaf rechts =` in de expressie de vorm links in de tweede regel en evalueer die passage naar de vorm rechts. Zo telt iedere iteratie stap een constant getal a op bij de som rechts.

Voorbeeld van vermenigvuldigen als optellen in stappen.

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

De iterator is hier het getal 3 of unair 111 en in het algemeen een variabele b. De operatie regel telt daar 1 stap vanaf en telt rechts een kopie van a op.

Herhaal in stappen == en tel op, tot in de laatste stap de eerste regel de ster * operator elimineert, waarna basis optellen de uitkomst levert.

+a*b2 = a*b1+a
     = a*b+a+a = a*b+aa
   == a*1+.a.. :b1
   = a+.a.. :b2
  = a.. :b2

Een rep :k herhaalt de tussen . of terzijde van de punten .. geselecteerde passage k maal.
De ster van vermenigvuldigen is *{1} de eerste superster operator.

§2.2.3. Ster 2 machtsverheffen

Machtsverheffen ** of ^ is herhaald vermenigvuldigen.

In de uitwerking van machten tot vermenigvuldigen en optellen komen de lagere operaties rechts aan bod, terwijl we de hogere links in de wacht zetten.
De pop plus in de popster *+ operator stelt vermenigvuldiging uit. Dit werkt alsof de ster operatie tussen haakjes staat tot deze kan worden “ontpopt”.

Evalueer machten met een popster volgens deze speciale regels, waarbij b>0 in de exponent.

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

Primitievere regels staan eerst vermeld in onze definities. Maar dat geeft niet meteen ook de volgorde van uitvoering. Voorrang in de evaluatie krijgt die regel, waarvan de vorm het eerst in de expressie overeenkomt. En bij regels met =` bepaalt de eerste positie rechts van de match de prioriteit. Selecteren twee regels dezelfde passage, gebruik dan de eerdere regel uit de definitie.
Als de vorm a**1 een match geeft, kunnen vaak meer enen volgen, en dan geldt de regel voor de iteratie stap, want die grijpt rechts het hele getal.

We kunnen ervan uitgaan dat voor elke popster expressie aan de linker kant een plus teken +X staat (ook al schrijven we die niet). Dan zijn onze drie regels voor machten voldoende.
Anders zou a*+b = a*b een hulpregel kunnen vormen, hier onder.

+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*4
  == 8 := 2*2*2

We gebruiken het toewijzingsteken := voor een stap in de evaluatie, die niet normaal volgens de regels is, maar wel een handige vertaling geeft. Zoals hier naar een reeks factoren, want normaal werken we factor na factor uit tot getal.

Hoewel dit geval niet vanzelf tijdens de evaluatie ontstaat, gegeven +a^b+1 dan telt het popster systeem die 1 op bij de eerste factor, maar in 1+a^b gewoon bij de machtsverheffing. Het eerste geval is dus groter.

De regels voor popsterren werken zonder precedentie en evalueren strikt r-l de meest rechtse selectie. Dit geeft vreemde resultaten, als we ster operaties na elkaar schrijven in de input expressie.

+5**3*2 = 5**3*1+3 = 5**3+3
       = 5**2*+5+3 = 5**2*+8
      = 5**1*+5*+8 = 5**1*+5*8
    == 5**1*+40. = 5*+40.
     = 5*40. == 200.

Volgt op de macht een ster *+ met pop plus, dan geeft dit gewoon een factor erbij. Zo komt 5**3*+2 via 5^2*+5*2 uit op 250.

Strikt rechts rekenen in de popster context geeft vaak ongebruikelijke resultaten. Terwijl we carets ^ oplossen met majoriteit precedentie (hogere operaties eerst), en daarna pas sterren * met minoriteit (lagere operaties eerst).

Zo wordt a^b*c groter als a>b1 geldt, maar is normaal a**b*c nog groter, in vergelijking met +a**b*c uitgewerkt als popsterren.

§2.3. Popsterren

Popster supermachten zijn primitief recursieve operaties, die we stapsgewijs uitwerken zonder haakjes te gebruiken, met een plus *+ of “pop” teken in de ster operator.
Hoe meer sterren in de operator *.. hoe groter de uitgedrukte getallen.

§2.3.1. Definitie

“Tetratie” is de eerste echte supermacht, aangegeven met drie *** sterren of twee ^^ carets in de operator. De tetratie operatie herhaalt de elementaire machten ** of ^ met als mogelijk resultaat een toren van exponenten, die r-l van de top macht naar beneden moet worden opgelost.
Zoals Knuth liet zien bij supermachten in reeksen, waar we een toren bouwden van voorgaande operaties met de constante a en b verdiepingen.

a***b1 = a**..a :b

In ons popster systeem nemen we de top operatie eerst apart en werken deze met voorrang uit. De reeksen of torens krijgen we dus niet in hun geheel te zien. De supermacht iteratie breekt elke stap op rechts een volgende verdieping af.

Definitie voor de evaluatie van PopSter supermachten.
Door de eerst aansluitende vorm van rechts =` te selecteren en die regel uit te voeren, geldt vanzelf steeds dat b>0 positief is. Maar de operator *{c≥0} kan leeg zijn.

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

Een operatie met popster *{c}+ wordt dus pas actief, als links ervan een plus geschreven wordt. Deze “pop plus” regel is ook nodig om op te tellen en staat daarom eerder in de lijst.
Variabelen zijn “gretig” naar enen, zodat elk getal a in de regels compleet is, zonder rest deel in de expressie.

Trap 0. elimineert de pop expressie plus voor de uitkomst.
Trap 1. elimineert de plus uit de tweede popster rechts.
Trap 2. elimineert de ster operatie bij basis exponent 1.
Stap 3. introduceert een mindere popster met exponent a.

Stapsgewijze evaluatie van popster supermachten kan toe met vier regels, zonder gebruik van haakjes. De definitie van popster supermachten in dit hoofdstuk lijkt de eenvoudigste.
Als we de optie plus +X aan het begin van de expressie zouden weglaten, dan wordt het toch nodig om uit expressies a*{c}+b die tijdens de evaluatie alleen komen te staan, de pop plus te elimineren. Of anders kunnen we dat voorkomen door een regel twee die a*{c1}1*{c}+b meteen tot a*{c}b reduceert.

We kunnen voor het gemak in de uitwerking van pop expressies ook carets gebruiken, waarbij de operaties *{c1} en ^{c} gelijk zijn en strikt rechts associatief r-l als popster supermachten worden uitgewerkt.

§2.3.2. Evaluatie

Om de supermacht 2^^^3 versneld uit te werken eerst twee tussenresultaten.
Deze “superkwadraten” gebruiken we als afgeleide regel 4a van popsterren.

a^{c}2 := +a*{c1}2
      =3 +a*{c1}1*{c}+a
     =2 +a*{c}+a
    =1 +a*{c}a := a*{c}a

Bij evaluatie van rechts schrijven we de toegepaste regel nummers aan de rechter kant van het is = teken als subscript, voor extra informatie.

De reductie van supermachten 2^{c}2 tot getal 4 gebruiken we als afgeleide regel 4b.

+2*{c1}2 =4a 2*{c}2
         == 2*2
        =3 2*1+2
       =2 2+2 =1 4

Omdat 2*{c1}2 tot 2*{c}2 uitwerkt, itereren we dit verder == tot 2*2 of zelfs tot 2*{0}2 wat de uitkomst 4 optelt.

De pop plus eliminatie van regel 1. volgt in de evaluatie na een superster regel en zo'n duo kan dan ook = ineens. Een complete iteratie van duo stappen met regel 3. eindigend met regel 2. geven we wel als reeks == aan.

+2^^^3 := 2****3
      =3 2^^^2^^+2
    =3,1 2^^^1^^+2^^2
     =4b 2^^^1^^+4
    =2,1 2^^4 =3 2^^3^+2
            =3,1 2^^2^+2^2
             =4b 2^^2^+4
            =3,1 2^^1^+2^4
      ≡2 2^+2^4
       = 2^+2*+2*4
       = 2^+2*+2+6
      =1 2^+2*8
      == 2^16. == 65536.

Als bij a^{c}1 de exponent een 1 is, kunnen we dit in elke positie ≡ in de expressie vervroegd tot a reduceren.

Op dezelfde wijze leiden we de hele reeks met afnemende operatoren af.

 2*{c1}3 = 2*{c}4
         = 2.*{i}+2..4 c:1

Bij deze supermachten nemen van rechts op links de exponenten toe.
Een ander voorbeeld, de evaluatie van 3^^^2 met popsterren.

+3****2 =4a 3***3
   =3 3***2**+3 = 3***1**+3**+3
    = 3**+3**3 = 3**+3*+3*3
    = 3**+3*+3+6 = 3**+3*9
    = 3**+27. = 3**27.
   == 7625597484987.

Losse supermachten zijn als input expressies met twee type tekens, de enen 1 en sterren * te noteren. Tijdens de evaluatie komt daar nog de plus + als solo haakje bij. Afgezien van de definitie, kan in het verloop van popster supermacht tot uitkomst elke expressie worden opgeslagen met slechts drie type tekens!
Dakjes ^ of carets en ^+ popcarets, cijfers en decimale getallen (met punt) zijn te beschouwen als substituut of afkorting.

§2.3.3. Toepassingen

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 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. Deze extra resolutie vormt een aanvulling op ons rekenapparaat, waarmee array functies nauwkeuriger zijn te schatten.
Zo helpen popsterren om de oceaan van de supermachten en hun naburige supermachtige getallen in kaart te brengen.

In de teller kan ook een subexpressie staan, die met voorrang wordt uitgewerkt. En dat in serie, zoals Gardner het Getal van Graham aangeeft, met geneste superexponenten en Knuth's pijlen.

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.

Pas in 1976 werden superoperaties uitgevonden door Donald Knuth met carets in de vorm van oppijlen ↑{c} in zijn essay “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.

§2.3.4. Functie vorm

Evaluatie van supermachten gaat makkelijker in een functie. Alle operaties a*{c}b die we uitwerken volgens de PopSter definitie krijgen deze vorm.

a*{ci+1}bi*{ci}+..b0 k:1
  waar  b>0  en  ci1>ci≥0

Elke superster telt daarin een ster * meer dan de erop volgende popster. Deze sterparen nemen naar rechts af, maar niet alle sterparen hoeven in die reeks voor te komen.

Stel nu, dat de ontbrekende supermachten in deze reeks een operant b=0 hebben, die een hard nul teken blijft, zolang deze tussen sterren staat. Maar dat in de evaluatie zijn hele sterpaar reduceert tot een nul, die zoals gewoonlijks wegvalt 01 = 1 tegen het erop volgende getal.
Dit zou een nulde regel kunnen zijn.

0. PS.0. a*{c>0}0*{d}+ =` 0

Daarmee kan de reeks van sterparen, die naar rechts toe aflopen, compleet worden weergegeven.

a*{i}bi*{i-}+..b0 k:1

En verloopt een uitwerking vanaf rechts bijvoorbeeld via:

2^^^^1^^^+2^^^0^^+2^^2^+2^0*+2*0+1
   = 2^^^^1^^^+2^^^0^^+2^^2^+1
  == 2^^^^1^^^+2^^^0^^+4
   = 2^^^^1^^^+4
   = 2^^^+4 = 2^^^4
  == 2^^65536. := 2^..1 :65536

Omdat alleen de operanten b en het aantal carets ^{c} of sterren *{c1} variabel zijn en kenmerkend, is het overbodig om de constante a voortdurend aan te halen. Ook komt er van ieder sterpaar nu één voor, in rangorde r-l oplopend, met de hogere supermachten links in de wacht.

Om tijdens de uitwerking een popster expressie op te slaan, hoeven we dus enkel de constante a en alle variabelen b_i in volgorde te noteren.

2^^^^2^^^+        2^^2
2^^^^2^^^+2^^^0^^+2^^2^+2^0*+2*0+1
2^^^^2     ^^^0    ^^2   ^0   *0+1
2    2        0      2    0   0  1
2,   1,0,0,2,0,2

Alle essentiële data is hier met zeven getallen gegeven. En we draaien de rij met zes variabelen ook om, zodat de evaluatie l-r in leesrichting kan verlopen.

De achterste pop +1 is eigenlijk alleen voor de vorm en kan in de functie door een andere regel worden ondervangen. Getal 0 schrijven we zonder enen.
Dan toont deze popfunctie, dat het aantal supermachten *{k}n steeds 1 verschilt met het corresponderende aantal komma's ,{k1}n links in de rij.

2*{6}3 = 2*****2****+2***2
11,{7}111 = 11,,,,11,,11

Zo zetten we supermacht expressies om naar een rij structuur, met nog maar twee tekens en een veel kortere expressie lengte.
De regels voor de evaluatie van een dergelijke functie zijn simpeler en zien we in het volgende hoofdstuk.

§3. Rij functies

De systemen in dit hoofdstuk beperken zich tot een enkele rij variabele getallen. We ontwerpen de primitief recursieve functies Adam en Eva, die een rij evalueren tot een getal 1.. in de orde van grootte van de a*{k}f supermachten.

§3.1. Systeem Adam

In systeem A voor “Adam” werken de iteratoren op de eerste rij als op de top gestapelde popsterren uit het vorige hoofdstuk.
Thema bij de constructie van Adam is natuurlijkheid, waarbij we iteraties aftellen tot 0 en cellen en hun structuren leeg kunnen staan.

§3.1.1. Primitieve recursie

Om zo zuinig mogelijk te zijn met type tekens, gebruikt systeem Adam geen ronde haakjes. We substitueren geen subexpressies (X) maar steeds dezelfde kopie van constante a die optelt in b en schuiven die subtotalen b door naar rechts. Er is dus geen “functie recursie”, waar functie variabelen worden overschreven door een afgetelde functie expressie.

Adam's expressies op de rij bestaan uit tekens 1 in getallen en ertussen enkele komma , separatoren. Als variabelen afgeteld zijn, kunnen we naar keuze een 0 teken schrijven of deze gewoon weglaten. Meerdere komma's ,.. stellen dus geen hoger dimensionale structuur voor, maar een serie lege cellen.

Over de structuur van de eerste rij zal de functie snelheid van Adam significant achterblijven bij die van Conway's pijlketens en Bird's lineaire array. Maar gezien de beperking van twee tekens valt de expressieve kracht van Adam reuze mee.

Wat we “primitief” noemen aan deze recursie is het herhaaldelijk optellen van de constante a en het opschuiven van subtotalen b naar de lege iteraties ,0 rechts, wat we “opladen” noemen. Zo bouwt Adam grote getallen op.
Beide regels tellen 1 af van een iterator (of schrijven min - bij), rechts van de in te vullen positie. Dit vormt Adam's expressie afbouw.
We herhalen de stap regels “recursief”, waarbij de uitkomst van een voorgaande reeks het aantal volgende herhalingen bepaalt, tot er uiteindelijk een natuurlijk getal n komt te staan als een serie enen 1.. :n met dezelfde lengte.

Adam noteert supermachten met maar twee tekens en we evalueren Adam expressies op de rij door drie primitieve regels toe te passen.

§3.1.2. Definitie A.I

De evaluatie van expressies A.I op de Adam rij verloopt congruent aan die van de popster supermachten. Maar Adam telt in de lage variabelen links op, terwijl popster operaties op de top worden gestapeld en rechts associatief uitgewerkt.
De rij structuur blijft bij Adam onveranderd, terwijl onze popster trein expandeert en pulseert (hoewel niet zo ongebreideld als in de gewone uitwerking van Knuth supermachten met hele grote reeksen). Een uitgetelde structuur met alleen nog lege ,0 rechts zou in Adam tot op het laatst kunnen blijven staan.

De regels voor popsterren wijken beduidend af van die voor Adam. Een totaal andere verbeelding van wat stap na stap hetzelfde recursieve patroon volgt; zoals we zullen zien in sectie $.3.2. over Popster Adam hieronder.

Definitie van Adam's systeem A. over rij structuur I. met een onbeperkt aantal variabelen, en drie regels voor selectie en evaluatie.
Variabele b≥0 en het aantal komma's ,{k≥0} kan nul zijn, zonder teken.

@
1. A.I.1. a,b,1R = a,ab,R
2. A.I.2. a,b1,,{k},1R = a,,1,{k}b,R ₁= a,a,,{k}b,R
3. A.I.3. a,b,{k} = b

Bij evaluatie regels met = staat aan beide zijden de hele expressie. Voor het deel wat in de evaluatie ongewijzigd blijft wordt een tekst variabele gebruikt, die ook leeg (zonder tekens) kan zijn. Zoals hier het expressie deel R rechts.

Gedurende de evaluatie is steeds precies één van de regels toepasbaar.
Regel 1. telt de constante a op in som variabele b.
Regel 2. verplaatst het som subtotaal uit b om verder naar rechts een afgetelde iterator op te laden. Daarbij laten we slim 1 achter in de eerste iteratie over c die een a optelt in de volgende stap.
Regel 3. neemt getal b als uitkomst en daarmee stopt de evaluatie.

Merk op dat expressies van de vorm a,,,{k>0}1R buiten deze regels voor systeem A. vallen en derhalve niet reduceerbaar zijn.
We kunnen daar een oplossing voor geven met de nu volgende Adam systeem varianten, waarmee ook de lege structuren rechts worden opgeruimd.

§3.1.3. Variant Aa.I

In de uitgebreidere definitie Aa.I van Adam vallen de resterende komma's van afgetelde variabelen meteen vanaf rechts weg.
Ons “scan” teken ` staat hier voor de passieve passage aan de rechter kant.

Stel b≥0 bij het subtotaal. Waar we een aantal :k>0 afgetelde variabelen ,0 tussenin herhalen, zou dat strikt een rij lege komma's ,{k} zijn.

@
0. Aa.I.0. a,`,0 = a,`
1. Aa.I.1. a,b,c1` = a,ab,c`
2. Aa.I.2a. a,b1.,0..,d1` :k>0 = a.,0..,b1,d` :k
2. Aa.I.2b. a.,0..,d1` :k>0 = a,a.,0..d` :k
3. Aa.I.3. a,b = b

De gesplitste regel verandert het systeem niet. Na elkaar toepassen van regel 2a. en 2b. in systeem Aa. werkt net zoals opladen en optellen in Adam A.

In systeem Aa. kiezen we om de expressie waarde met b=0 onder c=0 gelijk te houden aan die waar b=1 zou staan. In het strikte systeem A. viel dat niet onder de regels, maar hier kunnen we deze expressie vorm gebruiken om de parallel lopende supermachten uit te drukken.

a*{c>0}b = a,{c1}b

Dan blijkt dat een type +{c>1} superoperator die begint te tellen vanaf de plus, gelijk staat aan het aantal komma's of variabele plaatsen in Adam.

§3.1.4. Variant Ab.I

Een ander type definitie benoemt alleen die variabelen en tekens, die voor de selectie en wijziging nodig zijn. We scannen expressies steeds vanaf de linker kant a, naar rechts. Test daarbij de l-r scan regels `= in de definitie van boven naar onder, tot er een match voor de expressie vorm gevonden wordt.

Een spatie in een regel betekent het einde van het linker gedeelte van de vorm, waarna we apart doorzoeken naar een match voor het rechter gedeelte. Over de spatie slaat onze l-r scan dus een mogelijke passieve text passage over.

De definitie van systeem Ab.I past de regels strikt in volgorde toe. We ruimen komma's pas op als alle iteratoren op rij zijn afgeteld. Stel b≥0 vooraf.

@
1. Ab.I.1. a,b,1 `= a,ab,
2. Ab.I.2a. a,b1, ,1 `= a,,1 b,
2. Ab.I.2b. a,,, 1 `= a,1,,
3. Ab.I.3a. a,b, `= a,b
3. Ab.I.3b. a,b = b

De speciale expressie a,,{k>1}2d evalueert nu tot a,a,{k}d en telt dus een iteratie stap meer af dan in systeem Aa. Dit lijkt rekenkundig juister.

Dan moeten we een expressie van de standaard supermachten in Ab met een basiswaarde b=1 schrijven. Beginnend met de macht ** hier.

a*{c>1}b = a,1,{c}b

Dezelfde supermacht vergelijking geldt in Adam's compacte systeem A.

§3.2. Popster Adam

We vergelijken de evaluatie in functie A.I met de popster operaties. Na wat rekenen ermee volgt de algemene vorm van zulke vergelijkingen.

§3.2.1. Tetratie in rij van vijf

Expressies met drie tot vijf parameters in systeem A.I zijn equivalent aan de eerste popster supermachten * tot *** en zo komen we tot tetratie.
In volgende voorbeelden tonen we Adam's functie regel nummers links van het evaluatieteken en bij popster operaties staan de toegepaste regels rechts.

Hoe optellen en vermenigvuldigen verloopt, parallel in beide systemen.

      a,b,1c     =     a*c1+b
  1=  a,ab,c     =2,1  a*c+ab
 1==  a,a*c+b,1  ==    a*1+a{c}b
  1=  a,a*c1+b,  =3,1  a{c1}b
  3=  a*c1+b

Evaluatie van een macht met vier parameters in Adam en met popster operaties.
Bij het aanhalen van dezelfde regel of van een eerdere afleiding geven we het evaluatie teken = hier geen nummer.

      a,1,,2d    =     a**d2*+1
  2=  a,,1,1d    =2,1  a**d1*+a*1
  1=  a,a,,1d    =3    a**d1*+a
  2=  a,,a,d     =2,1  a**d*+a*a
 1==  a,a*a,,d   ==    a**d*+a^2
  ==  a,a^d1,,1  ==    a**1*+a^d1
  2=  a,,a^d1,   =3,1  a*a^d1
 1==  a,a^d2,,  3==    a^d2

Zet nu popster operaties in in Adam's variabelen om de evaluatie te volgen.

a,b,c,d == a,a*c+b,,d
    = a,,a*c+b,d-
    = a,a*+a*c+b,,d-
   == a,a^d*+a*c+b,,
   := a,a^d1*c1 {b=a}
    = a^d2 {c1=a}

De iterator e van tetratie domineert de kleinere operaties. Zolang met name d niet veel groter is dan a of triviaal klein, tellen deze variabelen ongeveer twee etages e2 bij de toren met machten op.

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

Precies gesteld zo. Of stel dat {d~a} dan rondt een rij van vijf in A.I zo af.

§3.2.2. Supermachten over de rij

Met een aantal lege komma's ,{k} op de Adam rij drukken we direct het aantal sterren *{k} van een supermacht uit.

a,1,{k1}f2
    = a,a,{k1}f1
    = a,a,{k}a-,f
   == a,a*{k}a,{k1}f
   == a,a.*{k}a.. :f1
    = a*{k1}f2

Elke voorliggende parameter in de functie rij is een kleinere supermacht en vormt een popster operatie op de hoogste exponent van de supermacht rechts.

Algemene vergelijking van expressies A.I met de reeks popsterren, beide in rep notatie. En afgerond tot supermacht, waar we de hele rij met insignificante p~a optellen bij de hoogste operant.

a.,pi.. 0:k
  = a*{i}pi*{i-}+..p0 k:1
    ~ a*{k}(pk+1)*{k-}+pk-
    ~ a*{k}(pk+2)

Bij kleine expressies k<2 of bij relatief grote superfactoren pk- zal de bijtelling van pk+2 afwijken in de superexponent.

Lastig aan systeem A.I zijn de twee oplaadregels in serie: met de substitutie van constante a in de lege cel b na het opladen van hogere cellen.
Ook is het zuiniger om tekenreeksen ,{k>1} in te zetten als separatoren in multidimensionale arrays. Het volgende systeem Eva zal dit oplossen.

§3.3. Systeem Eva

Systeem E voor “Eva” noteert zo groot mogelijke getallen met zo weinig mogelijk tekens en regels. Typerend voor Eva is dat variabelen aftellen tot rest 1 en de separatoren ertussen dus apart blijven staan van andere separatoren.

§3.3.1. Definitie E.I

Eva's rij systeem E.I opereert net als Adam in het gebied van de supermachten. Uitgedrukte getallen wijken bij gelijke expressies iets af van Adam A.I en lopen er op achter, waarbij exacte vergelijking steeds ingewikkelder wordt.

Definitie van systeem E. met een rij I. van variabelen.

@
1. E.I.1. a,b.,1.. = ab
2. E.I.2. a,b1.,1..1R :k>0 = a.,1..ab,1R :k

Elke lineaire array expressie in Eva is op te lossen met deze twee regels.
Regel 1. geeft de uitkomst als er geen actieve iterator groter dan 1 rechts volgt. Regel 2. wordt herhaaldelijk toegepast tot de expressie klaar is voor de uitkomst. Precedentie van regels speelt bij de expressie vorm geen rol.

Rij oplaadregel 2. verhuist de som ab uit de basis naar de laatste afgetelde cel ,1 die rechts in de reeks wacht. In geval van de kortste lengte k=1 ontbreekt de afgetelde cel. Dan telt elke stap van de eerste iterator c1 een kopie van a op bij subtotaal b en de hele iteratie een a*c vermenigvuldiging.

Een lange reeks afgetelde iteratoren ,1.. wordt vanaf rechts naar links gevuld. Bij de eerste oplading schuift het subtotaal b mee, dan blijft ab over na aftelling. Van de volgende substituties == houden de cellen ,1 in de reeks alleen de constante ,a over, tot links met a1 het volgende subtotaal aanvangt.

a,1b,.1,..2R :k
  == a,1.a,..ab,1R :k

Om afgetelde variabelen van rechts op te ruimen, geven we de extra regel 0. die naar wens eerder of later kan worden toegepast. We kunnen dan toe met regel 1a. die uitkomst regel 1. uit de definitie versimpeld. Ook hiermee blijft de regel volgorde voor het resultaat van de evaluatie onbelangrijk.

0. E.I.0. a,R,1 = a,R
1. E.I.1a. a,b = ab

Eva telt iteraties nooit af tot nul, er blijft altijd een 1 tussen de komma's over. Daarom kunnen we een andere betekenis aan series komma's ,.. geven.
Wanneer we het Eva systeem E.II uitbreiden, zullen meervoudige komma's dienst doen als hogere separatoren om ruimtes tussen dimensies te onderscheiden. Daarmee zijn record grote getallen te noteren, voor de discipline die expressies in de evaluatie beperkt tot twee tekens.

§3.3.2. Rekenen in Eva

Over rekenen in systeem Eva en de verschillen van opzet met Adam. Zo blijkt een enkele vermenigvuldiging met een Eva expressie meteen al lastig te zijn.

Optellen werkte in systeem Adam van A(a,b,1) naar A(a,ab) naar ab met de uitkomst gegeven door een keuze regel.
Ondanks de gelijke input en output hiervan, loopt de evaluatie in Eva anders. Zowel met de kernregels uit haar definitie, als bij gebruik van de extra regels.

E(a,b,1) 1= E(ab) -= ab
a,b,1 0= a,b 1a= ab

We nummeren het apart verwijderen van de functie notatie hier de “minus” regel. Gewoonlijks gaan we hier wat achtelozer mee om, want die functie tekens E() zijn er slechts voor het aanhalen van de juiste definitie.

Speciaal is de som variabele b>0 in Eva, terwijl deze in Adam leeg 0 kan zijn. Vermenigvuldig in Eva door regel 2. te herhalen == over drie parameters.

a,b1,c1 2= a,ab1,c
    == a,a*c+b1,1
    1= a*c1+b1

Stel dat hier b1=0 dan kan a,0,c met een cijfer 0 in een expressie van Eva tot a*c vermenigvuldigen. De match voor b in de regelvorm zou dan een min - ofwel negatief een zijn.
Anders is bijvoorbeeld 3*4 beter als E(3,3,3) te noteren.

We moeten er maar vrede mee hebben, dat Eva andere soorten getallen makkelijker maakt. Het loopt al snel cummulatief scheef met de extra enen.

a,b1,c1,d2 = a,ab1,c,d2
    = a,a*c+b1,1,d2
    = a,1,a*c1+b1,d1
    = a,a*(a*c1+b)+1,1,d1
    = a,1,1+a*(a*c1+b1),d
   == a,1,.1+a*(..a*c1+b1..) :d:
    = a*(..a*c1+b1..)+1 :d1:
    = a*(..c2..)+1 :d2: {b=a}
     ~> a^d2*c2 = a^d3 {c2=a}

Vergelijk Eva met systeem Adam, waar expressies A(a,b,c,d) exact op popmacht a^d*+a*c+b uitkomen.

E(a,1,1,d1) = a,1,a1,d
    = a,a1,a,d  <~  a^d*+a2
   <  A(a,1,1,d1) = a^d1*+a1
        <~  A(a,a1,a,d)

Dit scheelt ongeveer een factor. Het valt te verwachten dat bij gelijke expressies de superexponent in de uitwerking bij Eva ongeveer 1 kleiner is als in systeem Adam. Erger is dat dit systeem dat ab optelt en rechts oplaadt, steeds verder uit de pas loopt bij de natuurlijke supermachten van Adam die rechts enkel b oplaadt.

Anders kunnen we het zo regelen dat Eva 1 iteratie minder substitueert in de parameter c voor optellen, dan zijn de twee systemen parallel aan elkaar. Haar algoritme zou dan complexer worden, om zijn getallen simpeler te benaderen, wat in ons verhaal een beetje onzinnig is.

§3.3.3. Eva is supermachtig

Verder met Eva systeem E.I met de hogere cellen op de rij, na E(a,a,a,d) dat ongeveer ~ tot a^d1 reduceert.
Eva's rij van vijf drukt een rommelige tetratie uit.

a,b,c,d,e {b~a c~a}
   ~ a,a^d1,1,1,e
   ~ a,,1,a^d1,e-
   ~ a,a^a^d1,1,1,e-
   ~ a,a^^e^+d1
   ~ a^^e1 {d~a}

Eva stapelt herhaaldelijk een exponent minder dan systeem Adam, waar dezelfde expressie tot a^^e1^+d2 uitwerkt.
Maar de minimale expressie met tetratie E(a,1,1,1,e) in Eva is vrijwel gelijk aan de exacte tetratie A(a,1,0,0,e) in Adam, iets groter zelfs.

a,1,1,1,e1 = a,1,1,a1,e
   = a,a1,a,a,e
   ~ a^^e^+a1 ~ a^^e1

Expressies in Eva zijn niet exact te vertalen naar popster supermachten. De complexiteit van een dergelijke vergelijking neemt op fractal-achtige wijze toe. Deze supermachtachtige getallen zouden we “supermachtig” kunnen noemen.
De dichtstbijzijnde supermachten voor onze supermachtige Eva expressies zijn zo ongeveer ~ of als ongeveer groter ~> wel te bepalen.

Druk systeem E.I bij benadering uit als een reeks popster supermachten, waar elke variabele meer op de rij een operator ster bijtelt.

a.,1..,f1 :k = a,1.a,..f :k
   ~> a*{k}f*{k-}+a1
   ~> a*{k}f1

Of in het algemeen voor een rij met lengte k2 wat in Eva begint door af0 op te tellen met een lege *{0} ster.

a.,fi.. 0:k
    ~ a*{k}(fk+1)

De hoogste superexponent f_k is dominant; alle voorgaande iteraties tellen daar in Eva maar 1 stap bij op, tegen ongeveer 2 in Adam. De positie ervan, dat is de rij lengte, te tellen met het aantal supermacht sterren, is het dominantst.

Van beide primitief recursieve functies A.I en E.I loopt rij lengte ongeveer gelijk met de tweede iterator van een dubbel recursieve functie.
We gaan de eerste rij recursief verlengen, lengte op lengte, om een hogere klasse van grote getallen te noteren. Door subtotaal b door te laden naar de tweede rij, kunnen de variabelen daar gelijk op lopen met die van Bird's lineaire array, die maximaal is. Dit zullen we bewijzen met behulp van Conway's pijlketen, die natuurlijk volgt op Knuth's supermacht pijlen.

§4. Pijlfuncties

We breiden de rechtse pijlen → van Conway uit met de oppijlen ↑ van Knuth in een nieuw systeem met →↑ superpijlen. De hiermee te noteren getallen zullen zeker zo groot worden als die van Bird's lineaire array.

§4.1. Knuth's oppijlen

Donald Knuth's pijloperaties stonden model voor Conway's pijlketen notatie. Gegeven de operator ↑ van machtsverheffen schreef Knuth de volgende operatie van tetratie ↑↑ met twee oppijlen. Die evalueert hij direct tot een toren van machten, van rechts op links verder uit te werken tot getal.

We reduceren tetratie in stappen door links ervan machten in te voegen.

a↑↑b1 = a↑a↑↑b
     == a↑..a↑↑1 :b
      = a↑..a :b

Door deze vergelijking operatie ↑{c1} na operatie ↑{c} te herhalen, kunnen de supermachten worden uitgedrukt als een reeks voorgaande pijloperaties.

Er zijn drie regels nodig voor de evaluatie vanaf rechts =` van Knuth's oppijlen. In meerdere stappen == volgt dan de hele reeks.

@
1. Kn.1. a↑{c}1 =` a
2. Kn.2. a↑b1 =` a*a↑b == a*..a :b
3. Kn.3. a↑{c1}b1 =` a↑{c}a↑{c1}b == a↑{c}..a :b

De operatie van tetratie wordt al gauw onbegrijpelijk groot, en de meeste supermacht operaties kunnen alleen algoritmisch nog worden vergeleken.

Neem een gelijk aantal oppijlen ↑.. of carets ^.. bij dezelfde operatie, maar voor supersterren *.. een ster extra.

Het getal in dit voorbeeld is fysiek niet decimaal weer te geven. Ook niet als elk kleinste deeltje in ons heelal een cijfer voor zou stellen. Toch kunnen we er een beetje mee rekenen.

4^^4 = 4^4^256
     = 2^2^513 ≈ 2^2^2^2^3.17
     ≈ 10^10^153.9
     ≈ 80.59^^3
        ≈ (79.8^^2)^^2
           ≈ 2.3279574277^^5
        = 4^^^2

Net als alle pijloperaties lossen Knuth's oppijlen ↑{c>0} strikt =` rechts associatief op. De gewone majoriteit precedentie passen we bij dakjes of carets ^{c>0} toe. Daarna volgt evaluatie van supersterren *{c1>0} met minoriteit precedentie, waar de operatie met minder sterren voorrang krijgt. Dit brengt variatie aan in het gebruik van supermacht operatoren. Het lege optellen *{0} gebeurt direct bij unaire getallen, maar plus + optellen komt als laatste.

§4.2. Conway's pijlketen

Conway bedacht zijn pijlketen functie om significant grotere getallen te maken dan met Knuth's oppijlen mogelijk is.

§4.2.1. Definitie

De pijlketen notatie van de Engelse wiskundige John H. Conway zag in 1996 het licht in zijn Book of Numbers.
Aanknopingspunt vormt de pijlketen a→b→c die met drie parameters dezelfde supermachten a↑{c}b uitdrukt als Donald Knuth met al zijn pijlen. Iteratie van de derde parameter →c telt als het ware het aantal oppijlen ↑{c} af.
Verschil is dat de rechtse pijl → geen operator is en hier niet telbaar, maar net als de separator komma , een plaats aanduidt voor een functie parameter.

Met a,b,1 kan de dubbel recursieve functie verschillend beginnen. Hilbert telt zijn φ1(a,b) op. De Ackermann functie φ(a,b,1) vermenigvuldigt. Beide opties komen in aanvang natuurlijk over. De initiële rechtse pijl van a→b waartoe a→b→1 reduceert, staat bij Conway voor ↑{c=1} machtsverheffen.

Stapsgewijze definitie van Conway's pijlketen.

@
1. Co.1. a→b = a↑b
2. Co.2. X→1 = X
3. Co.3. X→1→z = X
4. Co.4. X→y1→z1 = X→(X→y→z1)→z == X→(..X..)→z :y:

Hier stelt de tekst variabele X het linker deel a.→ni.. :k van de keten voor, met een k≥0 aantal variabelen n_i maar op zijn minst de constante a.

§4.2.2. Evaluatie

De systeem regels Co. evalueren expressies van Conway's pijlketen tot getal. In de voorlaatste variabele y vindt zowel substitutie plaats als het aftellen binnenin, terwijl de iterator z rechts buiten aftelt. Bij herhaling == van hoofdregel 4. telt de geneste y af tot 1 om te besluiten met de dubbele eliminatie van →1→z door regel 3. We werkten een hele - recursieve stap van z uit.

Reduceren we de overgebleven keten X op zijn beurt, dan zal bij herhaling van enkele recursies - en dubbele eliminaties de verst geneste expressie met a of via macht a→b een getal opleveren. Dit geeft in de keten van drie of vier de volgende recursie van z- over y. Na de hele dubbele recursie valt rechts een pijl →1 weg door regel 2. en reduceren die geneste ketens via machten en supermachten a→b→(..a↑b..) tot subtotaal getal.

Zo borrelen steeds grotere y op uit de diepte naar steeds verder naar rechts wachtende expressies. Tot ook de top expressie X→y→z weer uit getallen bestaat. Bij herhaling groeit het subtotaal in y en reduceert z. De geneste ketens rollen heen en weer, omlaag en omhoog, tot ook de top keten X→y→1 aan lengte verliest. Elke nieuwe y die dan z wordt, zal de eerdere z ver in grootte overtreffen. Tot uiteindelijk ook de laatste macht evalueert tot getal.

Er zijn ook triviale ketens. De eerste begint links met te kleine ≤2 getallen.

2→2→R = 2↑{r}2 = 4
L→1→R = L→1→r = L

En komt ergens een schakel →1 voor, dan kan de keten →R daar ter plekke worden afgekapt.

§4.2.3. Recreatie

Scherp de vergelijking aan uit het getallenboek van Conway en Guy, waarin een recursieve superexponent het beroemde recordgetal van Graham uitdrukt.

Gardner's getal 3↑{..3↑{4}3..}3 :63: van Graham ligt: boven de 3→3→64→2 is 3→3→(..3↑3..) :63: in pijlketen notatie en onder de 2→3→65→2 is 2→3→(..2→4→7..) :63: waar de diepe supermacht een prima benadering is van 3→3→7 (zie § 2.3.3), zodat de 64ste iteratie van oppijlen aan beide kanten drie ↑↑↑ verschilt.

Conway voegde aan de keten a.→xi.. de “dubbele recursie” →y→z1 toe, met als evaluatie stap om op plaats y de subexpressie met →z te substitueren, in de hele enkele “recursie” tot diepte y genest.
Over de gehele ketenlengte :k van (in de evaluatie afwisselend recursieve en) dubbel recursieve variabelen v_i noemen we zo'n functie “tripel recursief”.

X→y1→2  recursie
  = X→(X→y→2)
 == X→(..X..) :y:
X→y1→z1  dubbele recursie
  = X→(..X..)→z :y:
X.→vi.. :k>2  tripel recursie

Het linker deel X van de expressie wordt tegelijk met de recursie genest, maar verandert zelf niet. Het zou dus elk mogelijke tekst kunnen bevatten.
In Conway's pijlketen eindigt deel X altijd op een variabele, en voor niet-triviale recursie met een unair getal x>1 dat aftelbaar is. Maar deze recursies kunnen net zo goed werken als X#y→z eindigt op een oppijl of een hogere superpijl.

§4.2.4. Variatie

De eerste schakel in Conway's keten had ook een oppijl a↑b kunnen zijn, met daarbij deze alternatieve regel voor de pijloperatie →c die erop volgt.

• a↑b→c1 = a↑↑b→c == a↑↑{c}b→1 = a↑{c1}b

Dit geeft als resultaat exact dezelfde supermachten als a→b→c1 en ook als a↑ met daarop een b→c1 dubbele recursie.

a↑y1→z1 = a↑(..a..)→z :y:

Ook de pijlketen a*b→c die met vermenigvuldigen a*b begint, kan evalueren tot a*{c}b met een aangepaste regel voor de rechtse → pijl. Waar deze na bijvoegen van een oppijl ↑ de equivalentie *↑ ≡ ** in dezelfde stap toepast. Of waar deze elke ander kleiner (zoals * hier) operator teken ervoor herhaalt.

Simpeler kan dit weer met de rechts associatieve dubbele recursie.

a*y→z = a*(..1..)→z- :y:
      = a*{z}y

Dit voor de fijnafstemming van de eerste supermacht in een alternatieve pijlfunctie met drie parameters, voor de rest maakt dit weinig uit.

We nemen nu een voorschot op het volgende hoofdstuk, waar a→↑z tot een lange pijlketen van Conway a→..1 :z evalueert.

Stel dat de rechtse pijl →c1 een aantal ↑{c} oppijlen zou toevoegen aan elke andere voorstaande operator. Als we de nieuwe superatoren dan r-l uitwerken zonder ze van elkaar af te schermen, ontspringt er een onstopbare loop.

3→↑3→2 = 3→↑↑3  <
   3→↑3→↑3 = 3→↑3→3→3

Die variatie voor de → volgpijl is wel mogelijk, maar dan moet de evaluatie stap van oppijlen haakjes erbij noteren. De top van de toren wordt daarmee genest.

a→↑3→2 = a→↑↑3→1 = a→↑↑3
   = a→↑(a→↑↑2) = a→↑(a→↑a)
       = a→..1 :a→..1 :a

Dit zou een manier kunnen zijn om de lengte van Conway's keten met Conway's keten uit te drukken.

a→↑b1→2 = a→↑↑b1
     = a→↑(a→↑↑b)
     = a→↑(..a..) :b:

De oppijlen noterende volgpijl → lijkt zeer snel van start te gaan. Toch blijkt dit (door de bijkomstige haakjes) precies zo uit te werken als gewoon de volgende rij recursies beginnen.

We zetten graag de ketenvorming van a→↑b op een hoger plan door, door onze a→↑↑b1 via regel a→↑a→↑↑b een tweede dimensie rij a→↑..a :b te laten vormen. Zonder nieuwe haakjes, in het vervolg, dat groots wordt.

Eerdere verwarde pogingen om ketens met superpijlen te bouwen:
1. EN - Conway's row of chained arrows
2. EN - Arrows quarters (draft)
3. EN - Big Arrows Compass
4. EN - Growing Numbers in all Dimensions (draft)
5. EN - Big Arrows Compass I & II (draft)
6. EN - Conway's down arrows (draft)
7. EN - Birth of the Superdeep (arrays)
8. NL - Conway-Knuth hyper-recursieve pijlen

§4.3. Conway-Knuth superpijlketens

Om de volgende generatie grote getallen te maken krijgt Conway's systeem een nieuwe regel, met een variabele die de lengte van de pijlketen bepaalt. De drie typen recursies over deze variabele komen gewoon rechts daarna te staan.
De regel telt de lengte variabele af en voegt stapsgewijs schakels →a toe, links van de superpijl aan de op te bouwen keten. De operatie herhalende pijl van Knuth werkt precies zo, dus *tada*, dit →↑ is onze nieuwe superpijl operator.

Vanaf rechts =` voegt de →↑ stap na stap een y aantal parameters a toe. Niet gescheiden met haakjes (wat tot tetratie leidt), maar als een pijlketen.

a→↑y1 =` a→a→↑y
     == a→..a→↑1 :y
     = a→..a :y

Als we hier een →2 op laten volgen, wordt de ketenlengte recursief uitgedrukt.

3→↑3→2 = 3→↑(3→↑2→2)
       = 3→↑(3→↑3)
      = 3→↑(3→3→↑2)
     = 3→↑(3→3→3)
    = 3→↑3↑↑↑3
 p = 3→..1 :3^^7625597484986

En die recursie over de ketenlengte gaat al gauw pijlketens diep.

3→↑3→3 = 3→↑(3→↑2→3)→2
       = 3→↑(3→↑3→2)→2
      = 3→↑p→2
     = 3→↑(..1..) :p:

Dubbele recursie over de lengte van Conway's keten opent een nieuwe generatie van grote getallen.

a→↑y1→z1 = a→↑(a→↑y→z1)→z
         == a→↑(..a..)→z :y:

Nog “sneller” wordt de functie met meerdere superpijlen, maar evaluatie van de expressie duurt onvoorstelbaar lang.

3→↑↑↑2 = 3→↑↑3 = 3→↑3→↑3
       = 3→↑3→3→3
      = 3→↑3→(3→↑3→2→3)→2
     = 3→↑3→(3→↑3→(3→3→3)→2)→2
    = 3→↑3→(3→↑3→3^^^3→2)→2

Om de supermacht 3^^^3 staan geen haakjes, want de carets operatie heeft precedentie. Maar pas op met oppijlen in deze rechts associatieve context.

Formule voor superatoren bestaande uit een Conway pijl met Knuth's oppijlen.

a→↑{c1}b1 = a→↑{c}a→↑{c1}b
          = a→↑{c}..a :b

Daarboven volgt dan recursie over het aantal Knuth pijlen in de superator.

3→→3→→2→2 = 3→→3→→(3→→3)
           = 3→→3→→(3→↑3)
          = 3→→3→→3↑↑↑3
         = 3→↑3→→3↑↑↑3
        = 3→↑↑3→→(3↑↑↑3)-
       = 3→↑{3^^^3}3→→1
      = 3→↑{3^^^3}3

Later tonen we hoe groot de getallen van deze rechts gestapelde recursies zijn, vergeleken met Bird's links oplaadbare arrays.

Onze definitieve definitie van de Conway-Knuth superpijlketens.

@
0. CK.0. y↑z1 =` y*y↑z == y*..y :z
1. CK.1. y#↑z1 =` y#y#↑z == y#..y :z

2. CK.2a. a→b = a↑b
2. CK.2b. a#→b = a#↑b

3. CK.3. X#1 = X
4. CK.4. X#1→z = X
5. CK.5. X#y1→z1 = X#(X#y→z1)→z == X#(..X..)→z :y:

6. CK.6. ↑y#→z1 =` ↑↑y#→z
7. CK.7. →y#→z =` ↑y#→z == ↑{z}y

Hier is # een superator met elke mogelijke, maar niet-lege combinatie van pijlen. Teken X staat voor een deelketen met op het eind een variabele.

Regels met = gelden voor de hele expressie. Regels met =` zijn rechts associatief, toe te passen op het laatste deel van de expressie. Daarbij is variabele y compleet, want elke variabele in de scan is gretig naar enen.

Regels 6. en 7. offeren twee hogere pijlen →→y→→z op om de superator in →↑{z}y stapsgewijs te kwantificeren. Zo kan het aantal oppijlen recursief worden bepaald, rechts na de variabele z met de eerdere regels, terwijl de expressie reduceerbaar blijft. Reeksen van hoge pijlen zijn meest lang, dus het verlies van 1 schakel is insignificant.

In ons systeem hebben alle superatoren →{m}↑{n} hun rol in de constructie van getallen, waarbij elke superoperator een keten van vorige superator schakels achterlaat. Hoe groot die rol eigenlijk is zal moeten blijken uit onze vergelijking met de arrays van Bird in het volgende hoofdstuk.

Een afwisselende reeks operator tekens →{mi}↑{ni}.. zou extra informatie aan het systeem kunnen toevoegen. Hoewel dit een multidimensionale matrix mogelijk maakt, laten we deze uitbreiding ongebruikt. Rechts assocatieve evaluatie van regel 7. telt in ↑→y→→z is ↑↑y→→z de vreemde voorliggende oppijlen op.
Het aantal superketenpijlen →{m} is sowieso dominant. Om die met een recursieve variabele te kunnen herhalen, is er een nieuw pijlteken ↓ nodig.

§5. Lineaire arrays

Lineaire arrays zijn functie expressies bestaande uit een rij parameters: met de constante a en een subtotaal som b gevolgd door een aantal variabelen ,c,d,e,.. waarmee we stappen tellen van een recursie.
Door subexpressie substitutie in cel b en het opladen van afgetelde variabelen, noteert Bird's lineaire array maximaal grote getallen over de rij.

§5.1. Birdy rij

De Engelse wiskundige Christopher Bird publiceerde een systeem met arrays voor het maken van wereldrecord grote getallen. De regels voor de evaluatie van Bird's arrays worden bij uitbreiding steeds ingewikkelder, maar we zullen een bij benadering gelijk systeem “Birdy” eenvoudiger opzetten.

De eerste rij van Birdy gaat uit van de lineaire array notatie van Chris Bird. Uit zijn systeem verwijderen we de overbodige substituties, die aan de grootte van het uitkomst getal weinig bijdragen. Onze simpeler regel komt pas in het spel bij de vierde parameter en verder, na het supermacht trio.

§5.1.1. Basis paar

Bouw een systeem Birdy met regels B.I over de eerste rij parameters, dat met licht aangepaste expressies even grote getallen noteert als Bird's lineaire array. Sommige regels B. blijven ook in hogere Birdy array systemen geldig.

Eerst twee eliminatie regels: om de uitkomst op te leveren en om een afgetelde variabele aan het uiteinde rechts te verwijderen.
De expressie term X links bevat in de expressie B(a,1) alleen de a en bij uitbreiding een rij a.,pi.. met :k≥0 variabelen.

@
0. B.0. B(a) = a1 successor
1. B.1. B(X,1) = B(X) afval

Nu reduceert B(a,1) via B(a) tot uitkomst a1 wat 1 optelt. Deze successor functie past bij optellen met paar a,b en Birdy vangt hiermee hetzelfde aan als David Hilbert's functie reeks van primitieve recursies.
De selectie functie Bird(a) = a werkt ook, een voorsprong van 1 draagt niet veel bij.

Regel 1. om afgetelde uiteindes ,1 te verwijderen, zal in elke Birdy expressie gelden met een laatste rij deel.
En voor uitgebreide separatoren ,[X]1 in hogere arrays kan dit principe om afgetelde iteratoren op het array einde op te ruimen van kracht blijven. Maar we zien af van Bird's selectie apparaat om laatste variabelen of lege structuren ook uit de voorafgaande rijen of arrayruimtes te elimineren.

Bird neemt, in navolging van Conway's pijlketen, als basis operatie B(a,b) het machtsverheffen. Dit vooronderstelt een stap van vermenigvuldigen, die we kunnen herhalen buiten de array functie.

Bird(a,b1) = a*(a,b)
        == a*..(a,1) :b
       = a^b*(a) = a^b*a
     = a^b1   macht

Net als Hilbert begint Jonathan Bowers, die het oorspronkelijke idee voor Bird's arrays had, zijn array functie primitief door a+b op te tellen.
We gaan het parameter paar in Birdy direct optellen, door de enige komma te elimineren en de uitkomst uit de functie te tillen.

2. B.2. B(a,b) = ab

Dit maakt regel 0. van de successor uitkomst alsnog overbodig.
Een alternatieve regel telt het paar a,b op door enen stapsgewijs over te hevelen van b naar a ofwel door te tellen.

2. B.2a. B(a,b1) = B(a1,b) tellen == B(a1{b},1) = B(ab,1) = B(ab) = ab1

Of voer dit met een functie B(a,b1) = B(B(a),b) terug tot optellen, zoals Hilbert deed. Hier is b de iterator, die de successor functie recursief in cel a substitueert.

Optellen aan het begin kost ons Birdy systeem twee supermachten ** ten opzichte van Bird, in de nu volgende arrays a,b,c met drie parameters.

§5.1.2. Supermacht trio

De algoritmische motor in Bird's lineaire array is de recursieve functie substitutie. Deze regel telt de derde parameter c af en substitueert de tweede cel b voor een subexpressie die met b- vrijwel minimaal is afgeteld. Met herhaald aftellen van b tot 1 volgt de hele functie recursie. Samen met aftellen van c tot 1 vormt dit proces de “dubbele recursie” die de supermacht getallen genereert.

Drie parameters drukken bij Bird exact de supermacht operaties a^{c}b uit, maar de dubbele recursie begint in Birdy a,b,1 met optellen. We moeten hier dan 2 tellen bij input parameters c om dezelfde uitkomst te verkrijgen.

Als de laatste recursie stap met b=1 is bereikt, reduceert de subexpressie tot de constante a, mits daar geen parameter c=1 op volgt in de rij.

3. B.3. B(a,1,2X) = a bodem

Tekst variabele X omvat hier de rij rechts met een of meer variabelen. En bij uitbreiding naar hogere arrays staat X voor elk mogelijk vervolg rechts.

De regel voor substitutie, de functie recursie stap, is de werkmotor om getallen groot te maken op de eerste rij. Deze is essentieel voor arrays, die snel moeten starten. Bird nummert dit als Rule 5. in zijn lineaire array.

Voorwaarde bij deze substitutie regel is dat b>0 omdat cellen in Birdy nooit leeg komen te staan.

4. B.4. B(a,b1,2X) substitutie = B(a,(a,b,2X),1X)

De tekst variabele X≥0 begint hier met de rest 1.. van de waarde van derde parameter c en dan volgen eventueel meerdere parameters rechts. Later omvat deze X alle mogelijke hogere arrayruimtes, maar X kan ook leeg zijn.

Zo evalueert B(a,2,c1) tot B(a,a,c) door subexpressie substitutie en daarna de bodem regel. Als c=2 dan geeft dit een kwadraat. Hier geldt c>0 omdat anders regel 1. voor afval van ,1 wordt toegepast.

Een regel is toepasbaar, als zijn vorm links kan worden gevonden in de expressie. Dat is bij regel 4. in B(a,b,c) zolang parameter b>1 en c>1 aftelbaar zijn.
De vorm van de regels in deze definitie is zo, dat we precedentie van eerdere regels niet als voorwaarde hoeven stellen in Birdy.

Het trio, een rij met drie parameters, produceert aldus de supermachten.
Met 1 stap van c nest de recursie een reeks van b subexpressies tot aan de constante a op de bodem.

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

We mogen het functie voorschrift weglaten, bestaande uit de letter B. voor Birdy en de expressie haakjes, als het gebruikte systeem duidelijk genoeg is.

Na optellen ab met B(a,b), vermenigvuldigen a*b met B(a,b,2) en machtsverheffen a**b met B(a,b,3) drukt het Birdy trio B(a,b,c1) exact de getallen uit van de ster supermachten a*{c}b uit hoofdstuk $.2.

We willen grote getallen in systeem Birdy ongeveer parallel laten lopen met die van Bird's arrays, waarbij expressies met c2 in Birdy altijd gelijk of insignificant groter zijn dan die van dezelfde input met c in Bird, nooit kleiner.

§5.1.3. Opladen op de rij

Gegeven een aftelbare expressie (a,1Z) van een Bird type array functie, dan krijgt in de volgende evaluatiestap de subexpressie de vorm (a,Z) die we bij de substitutie regel al zagen en hier afkorten met een dollar $ teken.

Bird substitueert de subexpressie $ ook in zijn Rule 4. voor opladen van de rij, maar alleen in de hoogste, rechts afgetelde cel.

Bird(a,b1.,1..1R) :k>1
   = Bird(.a,..$,1R) :k

De rij lengte bij k=1 behandelde Bird als een apart geval met zijn Rule 5. voor functie substitutie, dat is bij Birdy regel 4.

We maken Bird's oplaadregel nu simpeler door niet de subexpressie maar het subtotaal uit b in de laatste cel ,1 van de afgetelde reeks te substitueren.
Tussenliggende variabelen laten we hierbij ongemoeid.
In ons Birdy systeem komt in cel b een kopie van constante a in de plaats.

Regel voor het opladen van afgetelde variabelen ,1 op de eerste rij. Stel k>0 voor het aantal lege cellen, zodat c=1 als eerste opgeladen wordt.

@
5. B.I.5. B(a,b1.,1..,2X) :k opladen = B(a,a1.,1..b,1X) :k

Herhaalde toepassing == van deze oplaadregel in Birdy vult het afgetelde deel van de expressie naar links. Het resultaat is ongeveer hetzelfde als Bird met zijn complete oplaadregel voor de rij bereikt: alle voorliggende variabelen ,1 zijn door ,a vervangen.

  B(a,b1.,1..1X) :k2
     = B(a,a1.,1..b,1X) :k1
    == B(a,a1,1.a,..b,1X) :k
     = B(a,$,.a,..b,1X) :k

We kunnen ook eerst het subtotaal uit b verschuiven en de lege cel b=1 pas daarna met een kopie van a aanvullen. Dit geeft een tweevoudige methode voor opladen, waar bij b>1 het hele subtotaal verkast.
De afleiding uit primitievere regels zal wiskundigen een plezier doen.

5. B.I.5a. B(a,1.,1..1Y) :k1 vul = B(a,a1.,1..Y) :k1
5. B.I.5b. B(a,b.,1..1X) :k1 schuif = B(a,1.,1..b,1X) :k>0

Maar bij hogere arrays werken we ons met die a kopie in de nesten, omdat het grote subtotaal uit b vervolgens niet meer beschikbaar is om op te laden binnen de afgetelde geneste arrays. Zo blijven de uitkomsten onbetamelijk klein.
Bij index array separatoren zullen we het subtotaal in b dus laten staan en laden er een kopie van op.

§5.2. Vergelijk rij systemen

Van Bird is bekend hoe zijn array met vier parameters ongeveer even grote getallen uitdrukt als Conway's pijlketen over zijn gehele lengte.
We vergelijken in dit hoofdstuk verschillende notatie systemen voor de eerste rij. Om met aanpassing van de input expressies even grote getallen uit te drukken.

§5.2.1. Bird tegen Birdy

Vergelijk expressies van Bird's lineaire array met die in ons Birdy systeem B. Bewijs dat, ondanks de afwijkende regels, de uitkomsten over de hele rij genomen niet significant van elkaar verschillen.

Birdy begint met optellen B(a,b,1) en ligt twee supermachten achter.

Bird(a,b,c) = a*{c1}b
 = B(a,b,c2)

In het vervolg stellen we Bird's arrays “minimaal groter” -> of “minimaal kleiner” <- dan expressies in Birdy. Rechts in de vergelijking met -> heeft de Birdy expressie een minimaal kleinere en na <- een minimaal grotere uitkomst. Na aanpassing van de input a zal dit verschil verdwijnen.

Bird(a,b1,1,2)
    = Bird(a,a,(a,b,1,2))
   == Bird(a,a,..a..) :b:

-> B(a1,b1,2,2)
      = (a1,(a1,b,2,2),1,2)
     := (a1,a2,(a1,b,2,2))
     == (a1,a2,..a1..) :b:

Hier is bij Bird de substitutie na = volgens de regels, terwijl bij Birdy met := de subexpressie wordt opgeladen nog voor deze tot subtotaal is uitgewerkt.

Na een b aantal substituties op dezelfde plaats, bepaalt de laatste subexpressie de vergelijking.

Bird(a,b1,2,2)
    = (a,(a,b,2,2),1,2)
   == (a,..a..,1,2) :b:   x

-> B(a,b1,3,2)
      = (a,(a,a,2,2),2,2)
     == (a,..a..,2,2) :b:

Hier is de “minimaal groter” vergelijking precieser, omdat de laatste subexpressie Bird(a,a,1,2) meer verschilt met B(a1,a1,2,2) in Birdy, vanwege de extra substitutie stap die er zou volgen.

In deze expressies met d1>2 compenseren we het andere opladen al minder.

Bird(a,b1,1,d1)
   == (a,a,..a..,d) :b:

<- B(a1,b1,2,d1)
     := (a1,a2,(a1,b,2,d1),d)
     == (a1,a2,..a1..,d) :b:

Blijf in de rij van vier parameters 1 bij c tellen voor iets kleinere Birdy.

Bird(a,b1,c1,d)
   == (a,..a..,c,d) :b:

-> B(a,b1,c2,d)
     == (a,..a..,c1,d) :b:

Bij het opladen naar vierde parameter d wordt Birdy minimaal groter door 1 bij de derde c te tellen, omdat a1 zowel de nieuwe b als de nieuwe c vult.

Bird(a,b1,1,1,e1)
   == (a,a,a,..a..,e) :b:

<- B(a,b1,2,1,e1)
     := (a,a1,a1,(a,b,2,e1),e)
     == (a,a1,a1,..a..,e) :b:

Maar voor opladen naar de derde parameter blijft 1 extra bij a nodig.

Bird(a,b1,1,d1,e)
   == (a,a,..a..,d,e) :b:

<- B(a1,b1,2,d1,e)
    :== (a1,a2,..a1..,d,e) :b:

Dit is voor vergelijkbare rijen vanaf de vijfde parameter algemeen geldig.

Bird(a,b,c,d,R) <~ B(a1,b,c1,d,R)

Elke rij expressie in Birdy is dus “iets kleiner” <~ dan dezelfde expressie in Bird. Het subexpressie opladende systeem van Bird en ons subtotaal opladende Birdy systeem zijn daarmee vergeleken.

---

Zowel Bird als Birdy drukken, gegeven een rij parameters waar functie substitutie is toegestaan, maximaal grote getallen uit. Daarvoor is, na de snelle start door substitutie in b, vooral het opladen van subtotalen uit b naar de hoogst afgetelde iteraties belangrijk.

Of die opgeladen b steeds verpakt wordt in een subexpressie $ zoals bij Bird, is van ondergeschikt belang. Tel 1 extra bij input parameter c in Birdy, dan geeft dit een substitutie $ stap extra, die het verschil al bijna compenseert.

Als we het ruim nemen, geldt over de hele rij van Birdy versus Bird dezelfde vergelijking, waar ~ ongeveer gelijk betekent en <≈ “iets kleiner of gelijk”.

 B(a,b,1R) ~ Bird(a,b,R)
      <≈ B(a,b,2R)

De systemen lopen door c+2 in Birdy gelijk bij de supermachten, maar daarna maakt dit Birdy een recursie van b groter. Het verschil blijft beperkt en wordt insignificant zodra de hogere recursies vanaf d de rij domineren.

We kunnen andere systemen voor grote getallen nu met de Birdy regels B.I. vergelijken, wat handig is, omdat die met Bird daarmee gegeven is.

§5.2.2. Conway tegen Birdy

Conway's pijlketen en Bird's lineaire array zijn notaties voor getallen die zo groot zijn, dat ze zelfs in de wiskunde vooralsnog geen ander doel dienen dan uit te drukken hoe groot wel niet, en zich met elkaar te meten.

We doen het bewijs van Bird, waar hij in vier parameters Conway's hele keten uitdrukt, dunnetjes over met de vergelijkbare Birdy array. Eerst noemen we nog de overeenkomsten en verschillen van beide algoritmes over de rij structuur.

Elke recursie stap telt een kopie van de expressie af en substitueert deze op de plek van de afgetelde variabele. Bij Conway gebeurt dat in de terugwijkende variabelen y rechts, bij Bird steeds in dezelfde variabele b links.
De geneste reeks subexpressies ziet er na een recursie zo uit. Letters L en R staan voor de rest, hetzij links of rechts in de keten of rij.

L→y1→z1 = L→(L→y→z1)→z
      == L→(..L..)→z :y:

B(a,b1,1R) = (a,(a,b,1R),R)
      == (a,..a..,R) :b:

Op de bodem reduceert Conway met regel L→1→z = L zijn pijlketen naar links. Maar bij Bird komt elke subexpressie recursie uit op de constante a die klein is.
In de expressie telt de dubbele recursie af en het subtotaal in b hetzij y groeit.

Conway elimineert het einde →1→z van de keten. Terwijl in de Birdy expressie B(a,b,1,R) het subtotaal uit b naar rechts schuift, uiteindelijk ook naar een hoge y=1 variabele.
Elke dubbele recursie →y→1 valt na aftellen bij Conway rechts af, maar vergelijkbare dubbele recursies worden bij c=1 in Bird of Birdy steeds opnieuw opgeladen. We zullen zien dat dit het grote verschil tussen de systemen maakt.

---

Birdy begint B(a,b,1) = (a,b) = ab met optellen. Conway's pijlketen springt net als Bird snel uit de startblokken met a^b machtsverheffen.
In deze systemen werkt elke stap van de dubbele recursie over c hetzelfde, namelijk als reeks subexpressie substituties in b. Met drie parameters loopt systeem B. van Birdy steeds 2 van die recursies achter.

a→b→1 = a→b = a↑b = B(a,b,3)
B(a,b,c) = a→b→c2

Vergelijk de vierde parameter in Conway's pijlketen met Birdy.
Eerst met recursie over de supermacht teller.

a→a→b1→2 = a→a→(a→a→b→2)
      == a→a→(..a↑a..) :b:

-> B(a,b1,2,2)
     = (a,(a,b,2,2),1,2)
    := (a,a1,(a,b,2,2))
    == (a,a1,..a..) :b:

Hou Conway's pijlketen -> minimaal groter, zodanig dat de Birdy expressie meer groter zou worden door 1 stap bij recursie parameter b op te tellen.
Hoewel algoritmisch “minimaal” zijn de verschillen hierbij natuurlijk enorm.

B(a,2,3,2) = (a,a,2,2)  <-
   a→a→2→3 = a→a→a↑a→2  <-
B(a^a,2,3,2) <- B(a,3,3,2)

De tweede recursie over de supermacht teller, met het verschil op de bodem.

a→a→b1→3 = a→a→(a→a→b→3)→2
  == a→a→(..a↑a..)→2 :b:

-> B(a,b1,3,2) = (a,(a,b,3,2),2,2)
     == (a,..a..,2,2) :b:

Zo gaat de hele dubbele recursie over de supermacht teller.

a→a→b1→c1
  == a→a→(..a↑a..)→c :b:

-> B(a,b1,c1,2)
     == (a,..a..,c,2) :b:

De vierde schakel in Conway's keten komt dus overeen met de derde parameter onder d=2 in Birdy.

---

Conway's vijfde schakel begint weer met recursie over de vorige.

a→a→a→b1→2
  == a→a→a→(..a↑{a}a..) :b:

-> B(a,b1,2,3)
    := (a,a1,(a,b,2,3),2)
    == (a,a1,..a..,2) :b:

Net zo werkt de volgende dubbele recursie uit.

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

-> B(a,b1,c1,3)
     == (a,..a..,c,3) :b:

De vijfde pijlketen parameter past precies onder d=3 in Birdy.

We zetten dit voort over de hele keten. Vanaf de eerste recursie over de vorige dubbel recursieve variabele, die wordt opgeladen in Birdy, wat een stap van d aftelt. Conway's keten L op de bodem tegen a in Birdy maakt het verschil.

L→b1→2  &  L = a→..a :d
      == L→(..L..) :b:

-> B(a,b1,2,d1)
      == (a,a1,..a..,d) :b:

Schakels a→ kunnen ook verschillende waarden hebben, als deze “normaal” zijn (niet al te groot of triviaal klein) blijft de pijlketen minimaal groter.

Steeds drukt de nieuwe variabele rechts in Conway's keten een hogere dubbele recursie uit. Terwijl Birdy onder de derde parameter c de subexpressies nest en de vierde parameter d de lengte van de pijlketen aangeeft.

L→b1→c1  &  L = a→..a :d
      == L→(..L..)→c :b:

-> B(a,b1,c1,d1)
      == (a,..a..,c,d1) :b:

Getallen die Birdy 's rij met vier parameters uitdrukt, zijn ongeveer zo groot als die met Conway's hele pijlketen.
Beiden substitueren afgetelde subexpressies, de algoritmes verschillen omdat Birdy subtotalen uit b oplaadt naar c=1 onder aftellen van d. Waarna c de volgende en grotere dubbele recursie oplevert.

Op twee manieren vindt er hier een herhaling van dubbele recursies plaats: over de van rechts af te wikkelen rij in Conway's pijlketen, en met de steeds opnieuw met subtotaal b op te laden dubbel recursieve variabele c in Birdy.
Dit volgende type recursie noemen we “tripel recursie”.

§5.3. Superpijlen tegen Birdy

Vergelijk de Conway-Knuth superpijlketens, die we definieerden in hoofdstuk $.4.3, met onze simpele Birdy versie van de array notatie van Bird.

§5.3.1. Tweede pijlketen bij e=2

Breng de tweede pijlketen bovenop de lengte van Conway's keten aan. In Birdy onder vijfde parameter e=2 valt ook die tweede rij samen met variabele d.

Begin met het opladen van de lengte variabele voor Conway's pijlketen met het subtotaal uit b in Birdy. Dat kan enorm worden!

a1→↑b2 ->
   a→..a1→a1 :b ->
B(a,b1,1,1,2) = (a,a1,a1,b)
   -> a→..a1 :b1
      -> a→↑b2 = a→..a :b1

Eerste recursie over pijlketen lengte, of in Birdy's variabele b en voortijdig := opgeladen naar de vierde parameter met een - aftel.

B(a,b1,2,1,2)
  := (a,a1,a1,..a..-) :b:
     -> a→↑b1→2
        = a→↑(..a..) :b:

Verdere stappen van c in de dubbele recursie over pijlketen lengte.

B(a,b1,c1,1,2)
   = (a,..a..,c,1,2) :b:
   -> a→↑b1→c1
      = a→↑(..a..)→c :b:

Volgt het opladen van de dubbele recursie in Birdy c voor de tweede pijlketen.

B(a,b,1,2,2) = (a,a1,b,1,2)
   -> a→↑a1→b

In de verdere recursies krijgt elke superpijlketen een grotere subexpressie op de bodem dan de a bij Birdy.
Nu is dit Conway's super-Ackermann keten met een a aantal parameters a, die de vergelijking bepaalt die hier met <- van richting wisselt.

B(a,b1,2,2,2)
  := (a,a1,..a..,1,2) :b:

   <- a→↑a→b1→2
      = a→↑a→(..a→↑a..) :b:

De tweede dubbele recursie in de tweede pijlketen, die door Birdy gewoon vanaf links in c wordt geteld.

B(a,b,c,2,2) <- a→↑a→b→c

De tweede pijlketen is in zijn geheel tripel recursief over de tripel recursieve pijlketen van Conway. Birdy gebruikt hier weer de vierde variabele d voor.

B(a,b,c,d1,2) <- a→↑.a→..b→c :d

Hierbij is d>0 omdat anders Birdy -> minimaal groter uitkomt; zie hierboven. En ook c>1 want in geval c=1 is de vergelijking anders na opladen.

B(a,b,1,d1,2) = (a,a1,b,d,2)
   -> a→↑.a→..b :d

Dat een enkele stap in e een tripel recursie hoger springt, toont de kracht van Bird's lineaire array voor het maken van grote getallen.

§5.3.2. Pijlketens onder e

Voeg hierna de volgende pijlketen rijen toe, wat op details in de vergelijking na hetzelfde werkt. Rij op rij vormt zich zo een pijlketen vlak.

Begin weer met opladen naar d in Birdy, nu voor de tweede pijlketen lengte.

B(a,b1,1,1,3) = (a,a1,a1,b,2)
   -> a→↑.a→..a1 :b
      -> a→↑a→↑b1

In de eerstvolgende recursie blijft de bodem a van Birdy meteen achter bij de bodem subexpressie voor de pijlketen lengte. Dat we het verschil tussen beide expressies aangeven als minimaal kleiner <- komt, omdat Birdy met 1 extra recursie stap in b consequent meer verschil biedt.

B(a,b1,2,1,3)
   = (a,..a..,1,1,3) :b:
   <- a→↑a→↑b1→2
      = a→↑a→↑(..a→↑a..) :b:
      <- (a,b2,2,1,3) =
  B(a,..a→↑a→↑a..,1,1,3) :b:

De rest van de vergelijkingen onder Birdy's e verlopen op dezelfde wijze. De subexpressie op de bodem van gelijke recursies blijft kleiner in Birdy.

Voor de verdere op voorgaande rijlengte gestapelde pijlketens geldt algemeen.

B(a,b,c,d1,e1)  <-
   a→↑..a→..b→c :e :d

Met een uitzondering bij opladen naar c of d in de richting van de vergelijking.

B(a,b,1,d1,e1) = (a,a1,b,d,e1)
   -> a→↑..a→..b :e :d

B(a,b1,1,1,e2) = (a,a1,a1,b,e1)
   -> a→↑..a→..a1 :e :b
      -> a→↑..b1 :e1

De vaststelling of expressies minimaal kleiner of groter zijn, is niet significant op deze schaal. Zelfs de waarde van de subexpressie recursie teller b in de input expressie doet er niet veel meer toe.

Waar Bird's vijfde variabele e een aantal tripel recursies stapelt over de lengte van de pijlketen rij, vormt dat een groot recursief vlak van pijlen. Een vierde type recursie in een tweede pijlketen array dimensie!

§5.3.3. In de pijlkubus met f

Als separator operator tussen de pijlketen rijen gebruikten we de eerste →↑ Conway-Knuth superpijl. De volgende “superator” tussen de pijlvlakken is de tweede superpijl →↑↑ en de variabele erna bepaalt in de evaluatie het aantal rijen in het vlak ervoor.

In Birdy vertaalt dit naar het opladen van de vijfde parameter e met subtotaal b over constante a.

B(a,b2,1,1,1,2) = (a,a1,a1,a,b1)
   -> a→↑..a→..a1 :b :a
      -> a→↑..a1 :b1
         -> a→↑↑b2

In de opbouw van de vergelijking tussen Birdy en Conway-Knuth superpijlen volgt nu het recursief uitdrukken van dit aantal pijlketen rijen met c=1 en verder als stap van c in een dubbele recursie.

B(a,b1,c1,1,1,2)
   = (a,..a..,c,1,1,2) :b:
     -> a→↑↑b1→c1
        = a→↑↑(..a..)→c :b:

We stapelen weer allerlei recursies bovenop deze superpijl variabele, zodat het aantal rijen in het eerste vlak en het zo uitgedrukte getal almaar toeneemt.
Parallel in Birdy bouwen we de hogere recursie variabelen d,e opnieuw op, apart gesteld onder f=2 van het tweede pijlketen vlak.

B(a,b,c,d1,e1,2)  <->
   a→↑↑.a→↑..a→..b→c :e :d

Het teken <-> geeft aan dat de vergelijking soms minimaal groter en soms minimaal kleiner uitpakt. Zoals we dat bij het eerste vlak aangaven, waar ook al bleek dat dit verschil op schaal insignificant is.

Voor elk volgend superpijl vlak in de recursieve ruimte onder Birdy f geldt dit, zodat we de sprong naar de derde superpijl dimensie al precies kunnen maken.

B(a,b2,1,1,1,1,2) = (a,a1,a1,a,a,b1)
  -> a→↑↑..a→↑..a→..a1 :b :a- :a
     -> a→↑↑..a→↑..a1 :b :a
        -> a→↑↑..a1 :b1
           -> a→↑↑↑b2

Wat het volgende en vijfde type recursie inhoudt over aantallen pijlketen vlakken over aantallen van pijlketens, onder de zevende parameter in Birdy over f over e of net zo in Bird.

§5.3.4. Pijldimensies over Birdy's rij

Elke volgende variabele in de lineaire array van Bird definieert weer een hoger type recursie, omdat het een reeks van het voorgaande type recursief herhaalt. Bij Conway-Knuth superpijlketens is dit duidelijker te zien, omdat diezelfde recursies rechts zijn gestapeld.

We kunnen zo een pijldimensie k1 compleet uitrollen met een reeks van k2 type recursies en kleiner, in Birdy en Bird met k4 parameters op de rij.

B(a,b1,.1,..2) :k2
  = (a,a1,1.a,..b) :k1
     -> a→↑{k}..a1 :b
        -> a→↑{k1}b1

In het algemeen volgen de tellers di+1 van voorliggende pijldimensie i+1 elkaar dan zo op. Herken de dubbele recursie b→c rechts in de keten.

B(a,b,c.,1di..) :k>1
   <-> Ti..b→c 1:k
    & Ti = a→↑{i-}.. :di

Hier is k>1 want bij k=0 geldt a→b→c voor de a↑{c}b supermachten en bij Conway's pijlketen k=1 geeft de vierde Birdy parameter d₁ een pijl meer aan, die onder een hogere parameter 1di>1 ontbreekt.

B(a,b,c,d) <- a→..b→c :d

Bird's lineaire array gaat hetzelfde, maar tel in c- een recursie minder, omdat ons Birdy systeem niet de subexpressie maar alleen het subtotaal b oplaadt.

In de multidimensionale arrayruimte die Knuth superpijlen →↑{c} bovenop de pijlketen rij van Conway afzetten, worden gewone recursies naar binnen toe genest en hogere recursies consequent van rechts naar links afgewikkeld.

Vereenvoudigde vergelijking van Conway-Knuth superpijlen met de Birdy rij, met uiterste iterator b en rij lengte c3 als dominante waarden. Eerst een voorbeeld.

a→↑↑b1 = a→↑..a :b
   <-  B(a,a,a,a,b)

a→↑{c>1}b1  <-
   B(.a,..b) :c2
      <-  a→↑{c>0}b2

Zo zijn de maximale getallen die in een lineaire array functie met een links oplaadbare rij parameters te maken zijn, vergelijkbaar met die van de eerste serie Conway-Knuth superpijlen. Ook bij andere waarden voor parameters a hier, mits niet op schaal te groot of triviaal klein, blijft de vergelijking geldig.

Iedere Conway-Knuth superpijl bouwt met het voorgaande type recursie een hogere reeks recursies. Recursie typen zijn hier telbaar geworden.
De enumeratie van recursies komt veel langzamer tot stand dan de natuurlijke getallen. Het valt te verwachten dat deze type getallen door hogere array structuren als het ware worden vermenigvuldigd, etc. en dat we ze uiteindelijk kunnen noteren met dezelfde soort arrays.

Elke nieuwe recursie is gebouwd op een reeks vorige recursies. Maar het hele concept van reeks of rij valt als insignificant weg te strepen tegen de diepte van geneste arrays. Misschien dat in de diepte de recursie typen samenvallen met de getallen uit de functie arrays die ermee worden geclassificeerd.
Zou dit niet zo zijn en blijven de typen arrays significant achter bij de natuurlijke functie arrays, dan zou door het rigoreus definieren van overgangen of cycli daartussen, de cycli gebruikt kunnen worden om record grote getallen functies mee aan te geven.

§6. Multidimensionale arrays

Een multidimensionale array is een structuur, onderverdeeld in repeterende reeksen van variabelen. De structuursom die alle variabelen optelt is triviaal en traag. We evaluaren multidimensionale expressies met verschillende algoritmes voor het maken van grote getallen.
Onze Adam en Eva systemen beginnen primitief met supermachten over de rij, maar lopen in meerdere dimensies parallel aan de Conway-Knuth ketens met superpijlen. Multidimensionale Birdy arrays, die we afleiden uit die van Bird, zijn maximaal snel, doordat we functie recursies opladen naar hogere iteratoren.

§6.1. Structuursom

Tussen variabelen in de functie rij staan komma's. Deze systeem structuur kan worden uitgebreid met nieuwe separatoren: een dimensie index, geneste index rijen, recursie over nest diepte, etcetera. We kunnen de capaciteit van de ontstane ruimtes in de array kwantificeren met een structuursom.
Bij de structuursom vormt elke volgende dimensie een vermenigvuldiging en de hele multidimensionale array een macht. Dit leggen we uit.

Reeksen enen 1.. maken de natuurlijke getallen, die de variabelen vormen in de expressie. De functie van variabelen in de array functie wordt bepaald door hun positie in de structuur en door het toegepaste algoritme.
Een rij met variabelen noemen we de eerste dimensie in een array, terwijl deze eigenlijk bestaat uit rijen van rijen van enen. Als we deze getallen alleen maar optellen, dan drukt de rij lengte een vermenigvuldiging uit.

Ook kunnen we gelijke variabelen in een dimensionele structuur plaatsen, die geen andere functie heeft dan optellen.
Vul een kubus van 3 bij 3 bij 3 met getallen 3 en tel deze op.

111 = 3 = 3*1 = 3^1  getal
+ 111 + 111 = 3*3 = 3^2  rij
+ 111 111 111 = 3*3*2
+ 111 111 111 = 3*3*3 = 3^3  vlak
+ 3^3 + 3^3 = 3^4 = 81.  kubus

Hier voegen we rij op rij toe in de tweede dimensie. De array structuur met een reeks rijen noemen we een vlak, hoewel naast getalwaarden ook de rij lengtes in de evaluatie ervan sterk variabel zijn.
We stapelen een aantal vlakken in de kubieke ruimte, de derde dimensie. Elke herhaling van de voorgaande dimensie structuur vormt de volgende dimensie.

Maar in de array notatie staat elke ruimte structuur op een lijn, waarin deze van elkaar gescheiden zijn met specifieke separatoren. Het simpelst is om een aantal komma's ,{m} na elkaar te gebruiken om de dimensie m onder te verdelen.

a,..,,..,,,.. :ki,j :ki :k3

Stellen we gelijke zijden k dan sommeert dit tot a*k^3 in een kubieke array.
Of tel met gelijke maten k een m aantal dimensies op tot a*k^m een macht.

a.Ti.. :m
Ti = ,{i}.. :k

Voor de structuursom stellen we alle aantallen gelijk aan a, zowel de variabele waarden als de rij lengtes, de dimensie maten en het aantal dimensies. Vervolgens laten we alle separatoren ertussen wegvallen.
Elke komma telt dus voor 0 en heeft geen functie, behalve optellen. Ook als we de komma teller ,{m} uitbreiden tot index arrays, met geneste index getallen, vervallen deze in hun geheel tot 0 en houden we de structuursom over.

Zouden we die index waarden meetellen in de som, dan blijft dat insignificant. Met index [1] erbij en lengte k komt de som op de rij ongeveer op a1*k. En met index [2] en k rijen in het vlak op a1*k^2+2*k wat al minder bijdraagt. Zo blijft de som inclusief indexen in a dimensies kleiner dan a1^a1.
De som van de variabelen in de gescheiden ruimte zal altijd significant groter zijn, dan de som van de indexen van hun scheiding, ook bij diep geneste arrays.

Voor de structuursom tellen we variabelen a op in alle ruimtes, allen met vaste maten a en gegeven a dimensies. Dan is de structuursom a^a1 voor de multidimensionale array, wat we tot een tetratie a^^2 kunnen afronden.

Array functies laden afgetelde iteratoren opnieuw op en via de lengte tellers ook de dimensie maten. Als we meerdere komma's gebruiken voor het scheiden van dimensies, moeten we iteraties niet aftellen tot 0 maar tot 1 om de structuur intact te houden. Of gebruik anders een komma index ,[m] in de stijl van Bird [m] voor de dimensie m van de ermee onderscheiden ruimte.

De structuursom kwantificeert de wiskundige informatie die de arrayruimte kan bevatten, ongeacht de tekens van de separatoren of operatoren die we op de variabelen erin toepassen.
Het is voorlopig nog de vraag of de structuursom primitief recursief blijft, of in een hogere array constructie de Ackermann supermachten a*{a}a te boven gaat.

§6.2. Adam's dimensies

Adam is een primitief recursief array systeem, waar iteraties worden afgeteld tot 0 en met een verzamelsom b weer opgeladen.
Met de eerste rij drukte Adam een reeks popster supermachten uit. Vanaf de vierde parameter k>1 of afgerond over de hele rij geldt deze vergelijking.

a,..f :k1 ~> a*{k}f2

Na de overgang ,[1] waarmee Adam de volgende rij opent, komt een “lengte teller” te staan, die de eerdere rij verlengt met extra cellen. Elke stap die de teller aftelt, voegt een komma met een maximale variabele ,b toe aan de rij ervoor. Daarna vult de rest van de lege rij zich opnieuw en levert na evaluatie een grotere som b' op, elke teller stap opnieuw.

Afgetelde iteratoren op de lege rij, of in welke dimensie dan ook, worden in Adam niet opgeruimd, zolang er nog variabelen rechts op volgen. Elke recursie over de lengte teller expandeert de vorige rij, steeds met een significant groter aantal parameters. De nieuw opgeladen dimensie teller ,[m]b is dermate dominant, dat het opruimen van uitgetelde array dimensies ervoor geen effect sorteert.

Bird staat het opladen van afgetelde cellen ,1 alleen toe als er nog aftelbare variabelen rechts in dezelfde rij volgen. Hij elimineert alle lagere lege structuren, onder een hogere dimensie separator.
De consequentie van dit esthetisch principe is, dat cellen niet stap voor stap kunnen worden toegevoegd. Bird moet de hele lege dimensie structuur tegelijk opladen, wanneer de basis a,b daaronder in de evaluatie is bereikt.
Via een tussennotatie met pijlhaken bewaakt hij de maximaliteit van zijn array functies. Bird kan daarmee zonder onze dimensie tellers, daar de rijen a,..1 binnen zijn dimensies a[m]..1 tegelijk door :b worden uitgespreid.

Het grote bezwaar tegen Bird's notatie is nu nog niet duidelijk, maar welke van twee index subarrays precies lager komt, wordt in zijn hogere systemen steeds moeilijker te bepalen. Ook Bird's pijlhaak substituties, om meerdere uitgetelde ruimtes in een aparte routine te vullen, zijn een drama. In de hier ontwikkelde systemen is dit niet nodig, het nieuwe groeit vanzelf aan op het oude.

---

We substitueren de tweede cel na opladen van b nu direct door de a kopie, wat in de eerdere rij definitie van Adam werd uitgesteld.

a,b1,{k>0},1R = a,a,{k}b,R

Voorwaarde is k>0 omdat eerste iteratie 1c de kopie en som als ab1 optelt.

Na het verlengen van Adam's eerste dimensie met ,[1] die cellen met ,[] en dan komma's , toevoegt aan de rij, generaliseren we dit uitbreiden naar meerdere dimensies, door ,[m] dimensionale separatoren in te voegen.

a,b1,{k≥0},[m1]1R
        = a,a,{k},[m]b,[m1]R

Bij k=0 staan ervoor op de rij geen afgetelde ,0 iteraties. En als m=0 dan valt de nieuwe index array [] weg en blijft er een komma , over.
Zo telt Adam zijn geneste arrays leeg, weer te geven met ,[0] of zonder ,[] nul teken, en elimineert daarna de array haken.

Tel steeds 1 af alvorens som b op te laden naar de ingevoegde dimensie teller. Ongeacht welke dimensies li≥0 links ervan zijn afgeteld.

a,b1.,[li]..,[m1]1R :k
    = a,a.,[li]..,[m]b,[m1]R :k

Dit werkt net zoals Adam met een dubbele recursie over de eerste rij, waar enkel li=0 komma's staan, de popster machten uitdrukte. Maar de eerste iteratie, die optelt en waar m=- en k=0 zijn, blijft een speciaal geval.

Daaruit volgt de separator eliminatie voor index arrays.

,[0] ≡ ,
,[-] ≡ 0

Equivalentie ≡ maakt introductie van een lege index array [0] bij een komma mogelijk, waarna we de regel voor dimensionaal opladen kunnen toepassen. Bij een iteratie stap van ,1p in een rij, telt de regel die af tot ,[]p en laadt in de schaduw dimensie ,[-]b de som op, te reduceren tot nieuwe variabele b in de gegeven voorstaande cel.

---

Rij dimensies blijven onderverdeeld met een komma , die vooraf gaat aan elke variabele. In de definitie komt een eigen regel 3. om die cellen weer op te laden, naast regel 5. voor het opladen onder de dimensie separator ,[m>0] vorm.

Definitie van Adam systeem A. voor de multidimensionale structuur II. met een enkele index voor de separator.

@
1. A.II.1. a,b `=? b
2. A.II.2. a,b,1 `= a,ab,
3. A.II.3. a,1b, ,1 `= a,a, b,
4. A.II.4. ,[] ≡ ,
5. A.II.5. a,1b ,[1m]1 `= a,a ,[m]b,[1m]

Het evaluatieteken = in de regels is opgetuigd met extra functionaliteit.
Een vraagteken =? geeft die regel een lagere prioriteit. En een tik links `= of rechts =` geeft aan waar de scan in de expressie begint, aan de linker of de rechter kant, en in welke richting l-r (of r-l anders) de match voor de tweede vorm (als die na de spatie voorkomt) gezocht wordt.

In de regelvormen aan beide zijden staan alleen de actieve tekens in de expressie. Deze bepalen links van het evaluatieteken de selectie passage(s), en geven rechts ervan aan hoe deze door de evaluatie zal veranderen.
Variabelen in een regelvorm zijn altijd gretig, zodat de selectie van b alle beschikbare enen in de expressie opeet.

De vorm met equivalentie ≡ wordt in de input expressie met voorrang overal vervangen (eventueel), maar is later alleen direct na regel 5. van toepassing, waar met m=0 een variabele werd aangeplakt op rij.

Evalueer die regel `= die vanaf links genomen in de expressie het eerst zijn vorm vindt of compleet maakt (minst rechts). Selectie begint aan de linker kant van de expressie tot aan de spatie of breek, waar een inactieve passage kan volgen met wachtende afgetelde iteraties. Voor de tweede vorm, scan l-r in de expressie tot ook dit actieve deel bij de regel past. Zo selecteert Adam steeds de eerste aftelbare iteratie vanaf links in de expressie.

---

De vorm van de uitkomst waarmee evaluatie stopt, is een natuurlijk getal 1.. dat bestaat uit een groot aantal enen.
Maar rechts volgen nog de resterende separatoren van de afgetelde iteraties. Zonder opruimregels daarvoor kunnen we de uitkomst b alleen uitkiezen, door met =? aan te merken dat de andere regels in Adam voorrang krijgen, anders zou regel 1. meteen kiezen.

Pas de definitie aan, zodat de regels niet in volgorde, maar steeds als eerste van links in de expressie worden toegepast.
De vorm met = in regel 1a. betreft de hele expressie en kiest de output b in de laatste evaluatie stap. Opruimen vooraf met regels 0. maakt dit mogelijk.

0. A.II.0a. , =` 0
0. A.II.0b. ,[m] =` 0
1. A.II.1a. a,b = b

Als we regels met selectie =` aan de rechter kant met prioriteit evalueren, dan worden de rest cellen van de hoogst afgetelde iteraties meteen opgeruimd. Of wacht tot de andere regels niet meer van toegepassing zijn en het totaal in b klaar is, en verwijder dan pas r-l de reeks resterende separatoren.
Merk op dat het teken nul 0 in unaire regels een leeggekomen plek aangeeft, en dus niet bij het getal links ervan hoeft te worden opgeteld.

Maak een speciaal geval van regel 5. en 4. die rij dimensies apart expandeert.

4. A.II.4a. a,1b ,[1]1 `= a,a ,b,[1]

We kunnen regel 5. nu ook aanpassen, met m>0 in regel 5a. als voorwaarde. Anders speelt regel volgorde in de definitie weer een rol. De selectie positie zou nog altijd precederen over die volgorde, maar als twee regelvormen op dezelfde positie in de expressie beginnen en eindigen, is het de regel die in de definitie eerder staat die moet worden toegepast.
In ieder geval gaat de primitievere regel 4a. dan voor en komen index arrays niet meer ,[] leeg te staan.

Voeg naar keuze een speciale regel toe voor expressies, die in de evaluatie van standaard a,b,R nooit ontstaan. Met m≥0 in de dimensie index.

a,[m1]1R = a,a,[m1]R

a,[m1]1R = a,[m]a,[m1]R

Die laatste variant maakt iets grotere getallen, maar significant is dat niet. Deze optionele regels hebben weinig toegevoegde waarde, winst is dat hiermee ook de multidimensionale expressies a,[m]R binnen het systeem vallen.

§6.3. Eva's dimensies

Op de eerste rij in Eva zagen we een primitief recursieve functie, die parameters aftelt tot ,1 en de som ab oplaadt. Met maar twee regels in dit systeem benaderden we de supermacht getallen.

a,..f :k1 ~> a*{k>0}f1

In Eva gebruiken we reeksen van komma's ,{m} als dimensie separator, wat net zo werkt als de dimensie index ,[m] in Adam. Het gaat ons er nu om met twee type tekens zo groot mogelijke getallen te noteren. De eerste komma in de basis a,b van de expressie staat steeds alleen.

Definitie van Eva systeem E. met multidimensionale structuur II. en telbare komma's als dimensie separatoren.
De regels selecteren hun vormen vanaf links `= in de expressie. Eerst passen we regel 2. zo mogelijk toe steeds, omdat =? uitstel aangeeft.

@
1. E.II.1. a,b `=? ab
2. E.II.2. a,b1 ,{m1}2 `= a,1 ,{m}ab,{m1}1

Een variabele vorm zoals b is gretig naar enen, zodat er in de expressie een separator op moet volgen. Zo ook met m≥0 in de kwantificatie van de dimensie, die het teken , gretig herhaalt, zodat er zeker een getal voor komt.
Na opladen is de vorm b in de basis tijdelijk leeg en telt als 0 bij de volgende evaluatie stap.
De l-r scan pakt na de op de spatie overgeslagen vorm de eerste actieve iteratie rechts. De passieve passage kan leeg zijn, zodat de match links op de match rechts aansluit, of die kan bestaan uit een reeks ,{ki}1.. afgetelde iteraties. Iedere cel 1 wacht daarin om via 1,{0}a te worden gevuld met 1a en af te tellen tot waarde a in de volgende stap. De onder dimensie tellers ,{m>1} nieuw in te voegen elementen in die reeks krijgen waarde a- na de aftel stap.

---

Regel 1. levert de uitkomst als de hele expressie door toepassing van de eerste regel is uitgewerkt. Alternatief is om met extra regel 0. onderweg van rechts =` op te ruimen, zodat exacte regel 1a. op het laatst optelt.
Regel volgorde speelt zo geen rol in het systeem.

0. E.II.0. ,{m>0}1 =` 0
1. E.II.1a. a,b = ab

Door voorbeelden uit te werken en te schuiven met tekens in regel 2. werd me duidelijk, hoe systeem Eva simpel en kloppend is te maken: met de methode om ab op te laden.
Elke iteratie houdt een rest van 1 in de evaluatie, zodat het aantal komma's ,{m1} te gebruiken is om de dimensie m aan te duiden van de tussenliggende ruimtes. Zo staat een element ,,p1 vlak na een rij variabelen, die door iteratie van de teller p keer met een cel met toenemende som ,b wordt uitgebreid.

3,1,,3 2= 3,1,3,,2
   2= 3,1,{0}3,2,,2 = 3,4,2,,2
   2= 3,7,1,,2 2= 3,1,1,9,,1
   0= 3,1,1,9 2= 3,1,4,8
   2= 3,4,3,8 == 3,10,1,8
   2= 3,1,13,7 == 3,37,1,7
   2= 3,1,40,6 == 3,1,121,5
   == 3,1,364,4 == 3,1,9841,1
   0= 3,1,9841 2== 3,29521,1
   0= 3,29521 1= 29524

Elke stap van d itereert 1,c naar 1,c*3+1 en dat == herhalen we hier. Maar we kunnen d ook itereren van b,1 naar b*3+7,1 dat werkt ook.

De som b die naar rechts oplaadt op de rij zal groot worden, maar deze waarde is structureel minder significant dan de rij lengte.
De eerste rij in de evaluatie van 3,1,,3,2 neemt toe tot 29527 parameters bijvoorbeeld (per 3,1,1,1,,29524 teller), wat tot enorm grote getallen leidt, ongeacht de hoogst opgeladen som ,b die al bijna even enorm is.

---

Standaard dimensionale expressies in Eva hebben de vorm a,1R die tijdens de evaluatie gehandhaafd blijft. We kunnen ons systeem uitbreiden met speciale regels voor expressies a,{k>1}R die significant grotere getallen noteren.

Bijvoorbeeld door de hogere teller a,,p om te zetten in a,1,{p}a een aantal komma's. Dit kan er geforceerd uitzien, omdat we de komma's in ,{p} er niet stapsgewijs overhevelen.

a,{q1}p = a,{q}1,{p}a

Adam's eerste index is ,[p] equivalent aan Eva's aantal van p1 komma's. En Adam's tweede index ,[1,q] laadt de eerste index een q aantal keer op met het subtotaal b van diens recursie.
Dezelfde soort recursie kan hier rechts volgen, door regel 2. te generaliseren.

a,{q>0}b1  ,{m1}2  `=
    a,{q}1  ,{m}ab,{m1}1

Systeem Eva kan door deze speciale regels toe te voegen, de tweede index in de separator array van Adam evenaren (beperkt wel tot een enkele subarray).

Normaler is om een regel als deze op die speciale dimensie separator waar m>0 toe te passen.

a,{m1}2 `= a,{m}a,{m1}1

Dit stemt overeen met onze expressie standaard, waar een construct ,{n} dat ergens rechts van een construct ,{m} komt en gelijk of groter n≥m is, altijd dominant is en een significant groter getal zal uitdrukken.

De getallen van Eva vergelijken we later Conway's pijlketens en Bird's arrays. Maar met twee primitieve evaluatie regels (uit te breiden tot drie regels) en twee tekens in de expressie (in de input en tijdens de evaluatie), is Eva ongetwijfeld het meest minimale systeem dat record grote getallen kan produceren.

§6.4. Vergelijk met A en E

In de functies Adam A en Eva E passen we op dezelfde structuren verschillende regels toe, maar de uitkomsten zijn ongeveer even groot.
Hier vergelijken we multidimensionale expressies in A en E eerst met Conway's pijlketens en vervolgens met onze Birdy versie van Bird's lineaire array.

§6.4.1. Adam's rij 2 is Conway's →d

We beginnen met de eerste cel in de tweede rij, die nog te vergelijken is met de supermachten. Het is vaak genoeg om te weten dat een expressie ongeveer groter dan ~> een eerdere bekende is, want als we met dit resultaat verder bouwen zouden de details toch verdwijnen.

Tijdens de evaluatie zien we in de variabelen supersterren met minoriteit precedentie. Dit werkt a*{c2}a*{c1}b uit als a^{c1}(a^{c}b) omdat de lagere supermacht operatie voorrang krijgt.

 A(a,b,[1]c3) = a,a,b-,[1]c2
    = a,a*b,,[1]c2
    = a,,,a*b,[1]c1
    = a,a**a*b,,,[1]c1
    = a,a***a**a*b,,,,[1]c
   == a*{i}..b c3:1
   ~> a*{c3}a*{c2}b ~> a*{c3}b

Onthoudt dat in Adam reeksen ,.. de lege cellen ,0.. van iteraties zijn, die in de rij wachten om opgeladen te worden. En dat Eva met komma's ,{m1} een dimensie separator aanduidt, dezelfde die Adam met een index ,[m] noteert.

 E(a,b2,,c3) = a,1,ab1,,c2
    = a,1+a*ab,1,,c2
    = a,1,1,a*ab,,c1
    = a,1,1,1,a**a*ab,,c
   ~> a,a***a**a*ab,1,1,1,,c
   ~> a*{i}..b c2:0
   ~> a*{c2}a*{c1}b ~> ab*{c3}2

Zowel Adam als Eva drukken met de eerste parameter op de tweede rij, die de lengte teller van de eerste rij is, ongeveer een supermacht uit. Bij Adam krijgen we 1 superster meer, omdat Eva niet tot 0 maar overal tot 1 terugtelt.

Die eerste teller wordt nu recursief opgeladen door de tweede parameter op de tweede rij. De lengte van de uitgetelde rij die resteert, is daarbij insignificant, omdat die slechts *{0} optelt. En elk volgende rij subtotaal dat we opladen naar cel c van de teller, maakt die rij consequent een *{b} supermacht groter.

 A(a,b1,[1],d1) = a,a,[1]b,d
   ~> a,a*{b}a,{b},[1],d
   ~> a*{..b..}a :d1:
      -> a→bo→d1→2
       ~ a→b→(..a^bo..) :d:

Variabele o staat voor een relatief klein natuurlijk getal: elk getal dat we decimaal kunnen noteren zou voldoen. Hier in de vergelijking met de pijlketen van Conway geven we met de toegevoegde o aan, dat de waarde van b ook wat groter kan zijn, de pijlketen expressie blijft dan toch kleiner.

Recursie van superexponenten is het gebied van de “Getallen van Graham”.
Vergelijk hier Eva met expressies in de van Bird afgeleide array functie Birdy.

 E(a,b,,1,d1) = a,1,,ab1,d
   ~> a,a*{ab1}2,,1,d
   ~> a*{..ab1..}2 :d:
    = B(a,2,..ab1..) :d:
     -> B(ab,d1,2,2)
       ~> B(a,..ab..,1,2) :d:
        ~ Bird(ab,d1,1,2)

Op de tweede lijn in Eva lieten we het restant ,1.. op de eerste rij gelijk al weg, alsof het werd opgeruimd, omdat de expressie ongeveer wel gelijk blijft.
De functie B. is onze Birdy array functie die verschilt van Bird in de manier van herladen van cellen ,1 die op zijn. Bird nest daar rechts de subexpressies in, terwijl Birdy simpel de waarde van de tweede cel oplaadt, die we vooraf nesten met 1 extra in de derde cel.

 A(a,b1,[1],,e1) = a,a,[1],b,e
   ~> a,a→a→b→2,[1],,e
   ~> a→a→(..b..)→2 :e1:
      -> a→bo→e1→3

 E(a,b,,1,1,e1) = a,1,,1,ab1,e
   ~> a,B(a,ab1,2,2),,1,1,e
   ~> B(a,..ab1..,2,2) :e:
      -> B(ab,e1,3,2)
         ~ Bird(ab,e1,2,2)

Het verdere verloop over de tweede rij is daarmee duidelijk. Het algoritme van Adam en Eva blijft even traag als voorheen, waarbij elke volgende variabele op de rij een enkele recursie uitdrukt.

 A(a,b1,[1],{d1}c1)
   = a,a,[1],{d}b,c
   ~> a,a→a→b→d1,[1],{d},c
   ~> a→a→(..b..)→d1 :c1:
      -> a→b1→c1→d2

 E(a,b1,,.1,..c2) :d1
   = a,1,,.1,..ab1,c1 :d
   ~> a,B(a,ab,d1,2),,.1,..c :d1
   ~> B(a,..ab..,d1,2) :c:
      ~ B(ab,c1,d2,2)
        ~ Bird(ab,c1,d1,2)

Wie verwachtte dat de tweede rij gelijk ging lopen met Bird's lineaire array, zodra we de rij teller met subtotalen van de eerste rij uitdrukken, komt bedrogen uit. Adam en Eva's oplaadregel is bijna zo krachtig en de oplaadsom is aanvankelijk supergroot, maar bij Conway en Birdy vindt dit opladen herhaaldelijk plaats, in een onafzienbare trein met geneste subexpressies. En dat maakt het verschil.

§6.4.2. Adam's vlak is Conway's pijlketen

De verschillen tussen Adam en Eva zijn in de vergelijking met snellere systemen eigenlijk onbelangrijk. Hier werken we alleen de voorbeelden voor Adam uit.

De eerste parameter op de rij in Adam en Eva is de lengte teller van de rij ervoor. De teller die de tweede rij expandeert, loopt zoals we zagen gelijk met de vierde parameter d in Conway's pijlketen, die de tweede dubbele recursie uitdrukt.

A(a,b1,[1],[1]d3) = a,a,[1],b,[1]d2
   ~ a,a→a→b→2,[1],,[1]d2
   ~ a,a→a→(a→a→b→2)→3,[1],,,[1]d1
   ~ a,a→a→b!→4,[1],,,,[1]d
   ~ a,a→a→b!→d3,[1],{d2},[1]1
   ~ a,a,[1],{d3}a→a→b!→d3
   ~ a→a→(..a..)→d3 :a→a→b!→d3:
   ~ a→a→(a→a→b!→d3)→d4
  ~> a→a→b!→d4

We voegen een uitroepteken toe aan de variabele b! om een groot getal aan te geven dat daarmee is gemaakt, maar dat toch niet significant groter wordt dan een normale input waarde binnen de gegeven context.
Zoals een faculteit n! = 1.*i.. :n dat zou kunnen zijn.

A(a,b1,[1],[1],d1) = a,a,[1],[1]b,d
  ~> a,a→a→a!→b1,[1],[1],d
  ~> a→a→a!→(..b1..) :d1
  ~> a→a→b!→d1→2

Vervolg deze vergelijking over de hele derde rij van Adam. Deze werkt hetzelfde als op de tweede rij, maar nu met de vijfde parameter in Conway's pijlketen.

A(a,b1,[1],[1],{e1}d1)
  = a,a,[1],[1],{e}b,d
  ~> a,a→a→a!→b→e1,[1],[1],{e1}d
   ~> a→a→a!→(..b..)→e1 :d1
    ~> a→a→b!→d1→e2

Elke volgende rij in het vlak van Adam drukt een dubbele recursie over de vorige rij uit. Dit houdt in dat we steeds een schakel toevoegen aan Conway's pijlketen in de vergelijking. In zijn geheel geeft dit een tripel recursie.

A(a,b.,[1]..,{z}y) :k
   ~> a→..b!→y→z1 :k

Merk op dat systeem Eva hetzelfde presteert met als tekens enen 1.. en twee separatoren, namelijk , tussen variabelen en ,, tussen de rijen. Verschil is dat de afgetelden in Eva ,1.. en ,,1.. niet nul zijn, maar het aantal herhalingen ervan blijft gelijk aan die in Adam. De variabele rechts moet y1 zijn, maar telt dus hetzelfde aantal stappen van opladen.

§6.4.3. Eva's dimensies is de Birdy rij

Ga uit van een d aantal rijen in het Eva vlak, waarbij de laatste rij op dezelfde manier is verlengd als in de vergelijking van de tweede rij hierboven.
Die tweede dimensie teller in Eva is te vergelijken met de vierde parameter in Birdy, die zoals we van Bird weten de lengte van Conway's pijlketen geeft.

E(a,b,,,d2) = a,1,,ab,,,d1
        ~> a,1.,,ab!.. :d1
     ~> a,a.,,a..,a..b :d :b!
  ~> B(a,a,b!,d1) ~> B(a,b,1,d2)
     ~ ab→↑d3

Eva's tweede dimensie teller wordt recursief opgeladen met subtotalen b.

E(a,b,,,1,c1) = a,1,,,ab,c
   ~> a,B(a,b,1,ab),,,1,c
   ~> B(a,b,1,..ab..) :c:
      ~ B(ab,c1,2,1,2)

Zo correspondeert de tweede cel in Birdy met de laatste variabele in Eva, want beide tellen de functie recursie af over de hele expressie.
Zo drukt de derde cel in Birdy de lengte uit van de laatste rij in Eva, die (net als haar eerste rij) een dubbele recursie toevoegt.
Zo staat de vierde cel in Birdy gelijk aan het aantal rijen in het laatste vlak van Eva, die als een tripel recursie of pijlketen van Conway is aangeplakt.

En zo telt de vijfde cel e in Birdy het aantal vlakken in de derde dimensie van Eva. Bij uitbreiding die in de laatste (meest rechtse) drie dimensionale array.

E(a,b,,,,e1) = a,1,,,ab,,,,e
         ~> a,1.,,,ab!.. :e
      ~> B(a,b,1,1,e1)

Zo krijgt in het algemeen in de vergelijking elke rechts gesorteerde Eva dimensie een corresponderende parameter op de rij van Bird of Birdy, die in Eva het aantal van die dimensies telt en in Birdy een type recursie toevoegt.

Het aantal separator tekens k voor de hoogste Eva dimensie is dominant en dan het aantal :f van die te vullen ruimtes.

E(a,b,{k1}f1)
   ~> a,1.,{k}ab!.. :f
      ~> B(a,b.,1..f) :k
         ~ ab→↑{k-}f1

De dimensionale structuur van Conway-Knuth →↑ superpijlen werd in sectie $.5.3.4. al precies vergeleken met de lineaire array van Birdy.
De rij van Eva begint bij de supermacht parameter c van Conway en Bird. Het vlak met rijen ,, van Eva vormt Conway's pijlketen → of parameter d bij Bird. Elke volgende ruimte ,{k2} in Eva loopt een dimensie achter bij die van de Conway-Knuth →↑{k} superpijlen en opent een parameter op de rij van Bird.

§6.5. Multidimensionale Birdy

In multidimensionale expressies van systeem Birdy noteren we vrijwel even grote getallen als met Bird's multidimensionale arrays, maar Birdy's definitie is simpeler en de evaluatie van expressies verloopt stapsgewijs.

Tot de functie recursie regel 4. is de definitie van Birdy dezelfde als voor de rij, maar de tekst vorm X kan elke toegestane multidimensionale passage bevatten.

@
0. B.II.0. B(a) = a1
1. B.II.1. B(X,[m]1) = B(X)
2. B.II.2. B(a,b1) = B(a1,b) == ab1
3. B.II.3. B(a,1,2X) = a
4. B.II.4. B(a,b1,2X) = B(a,(a,b,2X),1X)
5. B.II.5. B(a,b1,`,2X) = B(a,a1,`b,1X)
6. B.II.6a. ,[0] ≡ 0
6. B.II.6b. ,[1] ≡ ,
7. B.II.7b. B(a,b`,[2m]2X) = B(a,b`,[1m]b,[2m]1X)

Omdat eerdere regels voorrang krijgen, zijn er op de scan tic ` hier alleen nog reeksen ,[mi]1.. afgetelde cellen te verwachten in meerdere dimensies, met separator indices mi>0 en als eerste index ,[1] de gewone , komma.

Opladen met regel 5b. onder separatoren met index in Birdy is vergelijkbaar met oplaadregel 2b. voor dimensies in systeem Adam. Maar de in Birdy uitgedrukte getallen worden door subexpressie recursie dimensionaal groter.
Separator eliminatie met regel 6a. is alleen nodig, als we de vorm van opladen op de rij 5a. overslaan en daar de dimensionale vorm 5b. toepassen.

Afgetelde cellen in tussenliggende dimensies laten we in Birdy net als in Adam gewoon staan. Lengtes en maten nemen zodoende cummulatief toe en worden steeds allemaal opnieuw opgeladen. Maar al deze extra ruimte blijft insignificant vergeleken met elke daarboven opgeladen teller, die stapsgewijs een dominant grote ruimte toevoegt. Wel of niet opruimen verandert de uitkomst vrijwel niet.

§7. Geneste arrays

De dimensie index ,[m] van de separator komma kan worden verlengd tot een rij ,[m.,ni..] van index variabelen. Een structuur of getalruimte met deze hierarchie van separatoren noemt Bird de hyperdimensionale array.

Op hun beurt kunnen separatoren in index arrays weer met een volgende index of rij worden uitgebreid. Zo nesten we rijen in eerdere rijen tot elke mogelijke diepte. Zo'n systeem voor grote getallen noemt Bird “geneste arrays”.

§7.1. Geneste som

Bouw een structuursom van geneste arrays op door nieuwe separatoren toe te voegen en rond daarbij alle maten gelijk af tot n, dat wil zeggen de variabele waarden en rij lengtes, die op dat niveau ondergeschikt zijn.

Begin door op de rij met alleen komma , separatoren een som => van een n aantal variabelen n op te tellen.

, => n*n
,[2] => n^3
,[m] => n^n

De structuursom van de multidimensionale array is aldus een macht.
Elke volgende separator schept ruimte voor n keer de vorige som.

,[1,1] => n^n1
,[m,1] => n^nn
,[m,n] => n^(n*n)

De eerste index doet de som n^n keer. Met elke volgende index wordt de vorige index vermenigvuldiging n keer herhaald.

,[m,1,1] => n^(n*n1)
,[m,n,1] => n^(n*n*2)
,[m,n,n2] => n^n^3

Volgt de structuursom met de eerste geneste rij in hyperdimensionale arrays.

,[m.,ni..] = ,[,[2]1] => n^n^n
,[m,[2]1] => n^(n^n+n)
,[m.,ni..,[2]1] => n^(n^n*2)

Elke index stap rechts op een voorgaande index structuur herhaalt dus de toegevoegde exponent van de vorige som.

,[,[2]3] => n^(n^n*3)
,[,[2]m] => n^n^n1
,[,[2]m,1] => n^(n^n1*2)

Zodat elke rechtse index variabele 1 telt bij de dubbele exponent en elke extra index rij dus n daarbij optelt, wat de som geeft van het index vlak.

,[,[2]m,n] => n^n^n2
,[,[2],[2]1] => n^n^nn
,[,[2],[2],[2]1] => n^n^(n*3)

Vervolg de derde index dimensie door rechts lagere structuren te plaatsen.

,[,[3]1] => n^n^n^2
,[,[3]m] => n^n^(n^2+1)
,[,[3],[2]1] => n^n^(n^2+n)

Dezelfde index dimensie opbouwen herhaalt de hoge exponent in de som.

,[,[3],[3]1] => n^n^(n^2*2)
,[,[4]1] => n^n^n^3
,[,[m]1] => n^n^n^n

De tweede niveau index telt dus de tetratie n^^4 als som. Vergelijk de eerste index ,[m] met som n^^2 en de eerste index rij ,[,[2]1] daartussen met n^^3 als som.
Als dat zo doorgaat dan telt de tweede geneste index rij de tetratie n^^5 op.

,[,[m,1]1] => n^n^n^nn
,[,[m,n]1] => n^n^n^n^2
,[,[,[2]1]1] => n^n^n^n^n

Als de structuur rechts op het eerste index niveau een index [L,n] extra krijgt, dan telt dat 1 bij de derde exponent. Gebeurt dit op het tweede geneste niveau, dan telt dat 1 bij de vijfde exponent.

,[,[,[m]1]1]1 => n^^6
,[..2..]1 :t: => n^^tt-
,[..m..]1 :t: => n^tt

De som van de hele ruimte van rij in rij geneste arrays volgt dan als tetratie. Met een even toren (van exponenten) bij een enkele index binnenin en een oneven toren bij een rij met een aantal indexen binnenin.

§7.2. Meervoudige separatoren

Om variabelen te ordenen in meerdimensionale arrays gebruikten we in Adam een index ,[m] bij de komma en in Eva reeksen ,{m} komma's. Zo kon Eva met maar twee tekens getallen uitdrukken ter grootte van Bird's lineaire array.

Vergelijk meervoudige separatoren met telbare elementen, zoals voorgesteld voor Eva, versus <=> de gebruikte indexering in systeem Adam.

Bij de hyperdimensionale arrays wordt op het eerste geneste array niveau in Adam aan de komma een rij van indexen gehecht. Dezelfde hyperruimte kan worden onderverdeeld door seperatoren bestaande uit telbare komma's met een tweede type separator ,[2] ertussen, hier links in Eva.

,{m} <=> ,[m]
,{m},[2],{n} <=> ,[m,n]
,{m}.,[2],{ni}.. <=> ,[m.,ni..]

Om deze opbouw te vervolgen maken we in dit hoofdstuk alle komma met index elementen ,[2] ook telbaar in Eva. Aan de dubbel geneste indexen in Adam ontspruit een even grote verzameling separatoren. De ruimte van deze arrays zouden we multidimensionale hyperdimensies kunnen noemen.

L,[2],[2]R <=> ,[L,[2]R]
,[2],[2],[2] <=> ,[,[3]]
,[2].. :m <=> ,[,[m]]

Deze groeiende elementen verdelen steeds links L en rechts R de voorgaande subruimte in de separator. Bij Eva is dat in de komma elementen serie, versus in de vooronder geneste index array bij Adam.

L,[3]R <=> ,[L,[,1]R]
,[3].. :m1 <=> ,[,[m,1]]
,[n2].. :m1 <=> ,[,[m,n]]

Eva's eerste telbare index vormt dezelfde ruimtes als de tweede enkele index in de dubbel geneste array van Adam. Dan volgt de tweede telbare index in Eva, eerste nest, versus de derde index in Adam, tweede nest.

L,[1,2]R <=> ,[L,[,0,1]R]
,[1n,2].. :m1 <=> ,[,[m,n,1]]
,[1n1,1n2].. :m1 <=> ,[,[m,n1,n2]]

Volgende komma indexen lopen parallel in Eva telbaar in het eerste nest, versus Adam enkel in het tweede nest. Adam's index dimensie teller m is de laagste variabele en deze ontbreekt bij Eva, zodat de index rij in Eva 1 korter uitvalt.

,[.1,..2] :p <=>
        ,[,[.,0..,1]] :p

,[.1ni,..1].. :p :m1 <=>
        ,[,[m.,ni..]] :p

De eerste index rij van meervoudige separatoren blijkt equivalent te zijn aan de tweede geneste index rij met enkelvoudige separatoren.

Elke geneste array kan op dezelfde manier in ruimtes worden onderverdeeld. Eén index niveau in Eva met telbare separatoren valt steeds gelijk uit met twee niveau's in Adam met enkelvoudige.
Dus geldt voor alle geneste index rijen in Eva versus Adam.

,[..Q1..].. :q: :m
   &  Q = ni,.. :p  <=>
       ,[..m,Q..] :qq:

Een geneste arrays met telbare separatoren zal met een soortgelijk algoritme even grote getallen maken als een geneste arrays met enkelvoudige separatoren. Maar het aantal nest niveau's is de helft als separatoren op alle niveau's telbaar zijn.
Helaas is dit geen belangrijke verbetering, het verschil bedraagt slechts een factor 2 qua nest diepte. Met in het systeem vervolg een diepte teller die oplaadbaar is, wordt dit verschil insignificant.

Conclusie is dat telbare tekens aanvankelijk belangrijk zijn, te beginnen met de 1.. natuurlijke getallen en eventueel met ,.. komma's voor array dimensies. Maar dat array functies met enkelvoudige separatoren, enkelvoudige haakjes, etcetera, “oneven” zo snel over de geneste niveau's gaan, en na uitbreiding in de diepte ongeveer net zo snel.

Als meervoudige tekens geen voordeel dienen, houden we regels voor recursies en structuur elementen liever simpel, door alleen te tellen met variabelen. Zulke systemen groeien door grotere structuur concepten te herkennen, en deze als voorheen recursief te herhalen vanuit de basis som.

§7.3. Inladen

Het opladen van indexen in een geneste array noemen we “inladen”. Daar zijn wat problemen mee, zodat we de regels ervoor secuur moeten bepalen.

Het eerste probleem is, dat het inladen van een subtotaal niet in een passieve index array met een lege teller erboven mag gebeuren. Want dan zou de opgebouwde som, de q in dit voorbeeld, verloren gaan.

a,b1,[1,1]1 = a,a,[,1]b,[1,1]
          = a,a,[a-,]b,[1,1]
        == a,q,`,[1,1]
        ≠ a,a,`,[q,]

Om dit te voorkomen moeten we separator index arrays opruimen, als de iterator ervan is afgeteld en die separator de laatste is binnen zijn ouder array of rechts in de expressie.
Dit geldt eigenlijk alleen als die index arrays een actief separator-iterator element bevatten, zoals de ,1 in de subarray ,[1,1] rechts in het voorbeeld. Maar het is mooier en makkelijker om ook de afgetelde dimensionale separatoren ,[m] en enkele komma's , te verwijderen, die op het eind van de ouder array komen.

Zolang er in de ouder array nog een actief element volgt, worden lege iteratoren vanzelf opnieuw opgeladen, dus hoeven we deze niet op te ruimen.
Merk op dat Bird ervoor kiest om afgetelde separatoren te verwijderen, als deze links voor een grotere staan. Maar we vinden het te bewerkelijk om alle soorten index arrays qua grootte te moeten kunnen vergelijken.

Het tweede probleem

§7.4. Adam genest

Definitie Adam systeem A. met geneste structuur III. voor het nesten van rijen separator indexen.
De regels gelden in volgorde: de eerste vorm van links die past, evalueert de expressie naar rechts.

@
1. A.III.1. a,b = b
2. A.III.2. a,b,1 `= a,ab,
3. A.III.3a. ,[1] ≡ ,
3. A.III.3b. ,[] ≡ 0
4. A.III.4a. , =` 0
4. A.III.4b. ,] ≡ ]
4. A.III.4c. ,[S] =` 0
4. A.III.4d. ,[S]] ≡ ]
5. A.III.5a. a,b1, ,1 `= a,a, b,
5. A.III.5b. a,b1 ,[1S]1 `= a,a ,[S]b,[1S]

Een l-r scan `= selecteert de eerste vorm vanaf de linker kant in de expressie, en kan op de spatie een fragment overslaan. Als een tweede vorm in de regel volgt, selecteren we de eerste match ervan (na de eerste vorm) in de expressie, mogelijk te vinden in een geneste array. In het overgeslagen passieve tekst fragment bevindt zich dus zeker geen match.

Zo komt de selectie van een r-l regel met =` direct rechts in expressies.
Bij een regel met gelijk teken = selecteert de vorm een hele expressie.
Met substitutie equivalentie ≡ kan de vorm overal te vinden zijn.

Teken 0 staat voor een evaluatie waar de selectie vorm geheel vervalt.
Een expressie in Adam kan eventueel tussen ronde A() haakjes staan.

De tekst variabelen S zijn gesloten, zodat elk open haakje erin van een geneste index array [Si] gepaard is aan een sluit haakje.

Ons “rechts binnen” criterium is simpel te constateren. En we slagen er goed in, om alle inactief blijvende elementen te elimineren. Waarna regel 1. de uitkomst geeft. Opruimen met regels 4. moet wel tijdens de evaluatie plaatsvinden, met voorrang boven regels 5. dus.

§7.5. Eva genest

Eva moet een systeem worden, dat met zo weinig mogelijk tekens en eenvoudige regels zo groot mogelijke getallen uitdrukt. Eerst nog bouwen we Eva's telbare komma's voor dimensies uit naar een rij hyperdimensionale indexen. Bij dieper geneste arrays zetten we het systeem over naar de bekende index variabelen.

#7.5.1. Eva's hyperdimensionale arrays

Bird noteerde zijn hyperdimensionale arrays met separatoren bestaande uit een rij index variabelen, de eerste van zijn geneste arrays.
We zagen in $.7.3.1 al hoe de rij indexen van Adam ook met aantallen komma's kan worden weergegeven en dan dezelfde ruimtes voor variabelen schept. Hier vervolgen we het dimensionale systeem II. van Eva en introduceren de enkele punt komma ; als separator tussen de reeksen van komma's.

Definitie systeem Eva E. voor de eerste geneste rij IIIa. met telbare komma's als hyperindexen. Pas die `= regel toe, die een vorm selecteert die het meest links in de expressie begint.

@
1. E.IIIa.1. a,b = b
2. E.IIIa.2a. ,;,1 ≡ ,1
2. E.IIIa.2b. ,,1 =` ,1
2. E.IIIa.2c. 1,1 =` 1
3. E.IIIa.3. a,1b ,;,, `= a,1 ,{1ba};,
3. E.IIIa.3a. 1m; ≡ ,m;
3. E.IIIa.3b. a,1b ,;,, `= a,1 ,ba;,
4. E.IIIa.4. a,b1 ,S2 `= a,1 Sba,S1 & S = ,{1m}.;,{1n_i}.. :k≥0

De reductie van expressies verloopt dan zo.

a,b1,`,,;,,;,,2
  4,2= a,1,`,;,,;,,ab
    3= a,1,`,{a1};,;,,ab
    == a,c1,`,{a1};,;,,2
  4,2= a,1,`,{a};,;,,ac
    == a,d1,`,,;,;,,2
  4,2= a,1,`,;,;,,ad
 3,2a= a,1,`,;,{a1}ad
    3= a,1,`,{a1};,{a}ad

Er ontstaat een probleem. De komma reeksen in de separator worden steeds met de constante a opgeladen en niet met de groeiende subtotalen, hier met b<c<d in de evaluatie trein aangegeven.
Want op het moment dat een komma index of aantal tot 1 wordt afgeteld, schuift het subtotaal naar de variabele erboven. De uitkomst blijft zodoende klein.

Het algoritme van Adam of Eva kopieert alleen de constante en nergens het subtotaal. Dit kan alleen werken, als een geneste array wordt opgeladen door de iterator of index, die rechts in de array erboven staat. De regel daarvoor moet duidelijk maken waar de separator structuur precies eindigt, wat niet triviaal is.
Bij meerdere niveau's van arrays zal de subtotaal waarde zich trapsgewijs naar binnen toe verplaatsen. Het geeft geen pas daar in Eva steeds de constante a bij op te tellen.

#7.5.3. Eva's geneste arrays

Voor geneste arrays in het algemeen in Eva stappen we over op het komma index systeem van Adam. Definitie Eva systeem E. voor geneste rijen IIIb. met regels in volgorde.

@
1. E.IIIb.1. a,b = b
2. E.IIIb.2a. ,[1] ≡ ,
2. E.IIIb.2b. ,[] ≡ 0
3. E.IIIb.3a. ,1 =` 0
3. E.IIIb.3b. ,1] ≡ ]
3. E.IIIb.3c. ,[S]1 =` 0
3. E.IIIb.3d. ,[S]1] ≡ ]
4. E.IIIb.4. a,b1 ,[1S]2 `= a,1 ,[S]ab,[1S]1
4. E.IIIb.4a. a,b1 ,2 `= a,1 ab,1
4. E.IIIb.4b. a,b1,2 `= a,ab1,1

..

#7.6. Birdy's geneste arrays

#7.7. Bodhi's geneste arrays

We kiezen er bij het opladen in Bodhi systeem Bo. voor om subtotaal b te laten staan, om daarna de eventueel afgetelde indexen voor zijn rekening te nemen. Dit lijkt het simpelst, maar betekent dat er een kopie van b moet worden gemaakt om in te voegen.
De voorafgaande reeks afgetelde iteraties wordt daarna ook met het grote subtotaal b gevuld. Maar toch zijn Bodhi's uitkomsten niet significant groter dan die bij Bird of Birdy, waar de ruimte links met de kleine a wordt gevuld.

Regel voor het opladen van afgetelde variabelen ,1 op de eerste rij. Stel k>0 voor het aantal lege cellen, zodat c=1 als eerste kan opladen.

@
5. Bo.I.5. B(a,1b.,1..,2X) :k opladen = B(a,1b.,1..b,1X) :k

Herhaalde toepassing == van deze regel vult het hele afgetelde deel links in de rij stapsgewijs met kopies b>0 van het subtotaal.

    == Bo(a,1b,1.b,..1X) :k
     = Bo(a,$.,b..,1X) :k

---

We kunnen in evaluatie voorbeelden de gebruikte regelnummers aangeven.
Ook expressies B(a,1,1) en B(a,1,1,R) waar regel 3. geen match voor vormt, kunnen onder regel 5. vallen.

B(a,1,1,2,3) 5= B(a,1,1,1,3)
       5== B(a,1,1,1,1)
   1== B(a) 2= a

Zulke expressies ontstaan nooit in de evaluatietrein en hebben als input weinig zin. Altijd is die expressie triviaal te herleiden tot a.

---

Vergelijk Birdy B. met Bodhi Bo.

 B(a,b1,2,2)
    ~> Bo(a,b1,2,2)
    <- (a,3,..a..1) :b:

Omdat:

B(a,b1,2,2) = (a,(a,b,2,2),1,2)
     := (a,(a,b,2,2),(a,b,2,2))
<- (a,(a,a,(a,b,2,2)),(a,b,2,2))
     =: (a,3,(a,b,2,2)1)
     == (a,3,..a..1) :b: