Aasblazer

Link naar dit blog:
allergrootste.blogspot.nl/2017/10/aasblazer.html
edit 2019.

§2.3 Aasblazer

Aas [ace] is hoe we de linker operant a noemen, die constant blijft. In de primitief recur­sieve stap van onze blazer [blazer] functies telt a op bij varia­bele b, de bel [bubble]. Deze wordt gedurende de evaluatie steeds groter, tot de bel op het laatst de uit­komst [output] geeft als een lange reeks 1.. enen.

Initieer Aas­blazer met output selectie en optellen.

• a[1] = 1
• a[,1] = a[a,] = a[a] = a
• a[b,1] = a[ba,] = a[ba] = ab = a+b

Item 2 telt aas a bij niets. Item 3 telt b+a intern direkt op. Zo op­tellen classi­ficeren we met nul sterren *{0} hetzelfde als tellen.

Bij oneindige azen luistert de aflezing nauw. Getallen 1.. en ω tellen alleen aan de rechter kant op bij hoger on­eindige reeksen.
In Aas­blazer arrays zijn nieuwe reeksen a.. die van rechts de bel in komen, altijd groter dan eerdere, die links staan voor­gesorteerd in b. Dus moeten we de uitkomst omkeren, om Cantor's manier van tellen in het oneindige recht te doen.

Het is handig om het groeiende sub­totaal alvast rechts buiten de array te presen­teren, in reken­kundig format. Zet dan wel een plus teken + tussen de Aas­blazer array en de voor­lopige output bel.

In de eerste iteratie herhaalt c het optellen van a.

• a[b,2] = a[ba,1] = a[baa] = aab = a*2+b
• a[b,1c] = a[ba,c] := a[,c]+ab == a[,1]+a*c+b = a*1c+b
• a[,c] = a*c

Dit * is vermenigvuldigen en herhaalt de optel structuur *{0} en zo begint met factor c de klasse *{1} van para­meters of iter­atoren. In Aas­blazer fungeren alle variabelen buiten de optel bel als factoren.

Volgt de definitie van Aas­blazer's eerste rij, ofwel de lineaire array. De eerste rij wordt gevormd door de voorste serie para­meters, waar elke positie met een enkele index gegeven is, die zelf in de index array het eerst komt. De aan de geïndex­eerde positie gekop­pelde para­meter beschouwen we als nulde iter­ator van de geneste rij.

Regels met equivalentie ≡ zijn universeel (overal, altijd) toe­pasbaar. Dus zonder richting van evaluatie in de ex­pressie. Hoewel we normaal `= vanaf links l-r regels toe­passen op de ex­pressie tekst.
De tekens a en b reserveren we voor aas en bel links buiten de top array en links erbinnen. De andere vars in deze regels zijn natuur­lijke ge­tallen vanaf 0. Maar een teken 0 valt meteen weg (tegen een getal ernaast, maar ook op zich) en een lege iterator elimineert zijn element.

Aas­blazer A.I voor de klasse *{1} array rij.

• A.0. a[bw] = wb
• A.1. ,[] `= 0
• A.2a. ,[n]] ≡ ] A.2b. ,[n], ≡ ,
• A.3. ,[1n]1 ≡ ,[n]a,[1n]

De lege array ,[] die in regel A.1. wegvalt, telt ge­tallen direkt op in de bel. Die wordt bij de uit­lezing met A.0. omge­draaid. Dus op­tellen gaat zoals de pop plus in blog §2.0, maar dan achter­af.
Een verdwaald element ,[]p in het midden laten we met rust, tot de voor­gaande indexen zijn ver­dwenen en dit element bij [b arri­veert. Pas dan popt de lege sep weg, zodat waarde p rechts bij­telt.

Een eerste komma ,[1] zullen we vaak zo , noteren zonder index. Deze ver­taling be­hoort niet in de definitie, en komt daarom a.1. in de lijst met hulp­regels.

Overbodige separatoren worden met regel A.2b. opgeruimd. Wat wij blazen noemen, is dat het systeem de dode elementen weer nieuw leven inblaast. Dat gebeurt in regel A.3. door de index array te her­stellen en aas a op te laden naar de nieuwe para­meter.
Meestal volgt in een expressie achter de 1 nog een getal 1p, maar de regels ver­melden alleen tekens die nodig zijn voor de match.

# Googologie 2.3

Een array is een reeks variabele getallen, met een sep­arator of sep er­tussen. Aas­blazer arrays zijn omvat met vier­kante haken [T] en van links­buiten gekop­peld aan (de laatste 1 in) aas a. Deze array bevindt zich op het top niveau.
Het sep teken is een , komma, zoals in functies. Maar in onze blazer arrays hebben alle seps een ,[X] index array, die de positie van elke ite­ratie bepaalt en daar­mee ook hun functie.
Index arrays koppelen we hier links aan een komma. Arrays kunnen arrays met indexen bevatten tot elke diepte. Functies met indexen op meerdere niveau's zijn geneste arrays.

Een iterator of iter is een variabele in een recursieve functie. Die telt zijn iters af met een regel, die tegelijk een expansie toepast op een eerder deel van de ex­pressie (bij ons links van de iter).
Iters op rij zouden we net als in functies kunnen scheiden met enkele komma's. Blazer struc­turen slaan die tussen­stap in de notatie over. Onze solo komma , is een afkor­ting van de eerste sep, links in arrays. Van de varia­bele ervoor, op positie [0] vervalt de sep. Andere array posities houden op de eerste rij index [n] en in verdere rijen [n,S] index arrays, die (afge­zien van oneigen­lijke input) uniek blijven.

We vergelijken herhaalbare met unieke seps in googologie box 2.4. Googo­logie is de fenomeno­logie van feno­menaal grote ge­tallen.

Aas­blazer heeft vloeibare arrays, bestaande uit sub­operaties die vrij door elkaar kunnen bewegen, terwijl ze op evaluatie wachten. Zoals de elementen in een set, of zoals simpele eiwitten drijven in het medium van een bio­logische cel.
Ieder eindig iter getal met index array kan zich vrij ver­plaatsen binnen de array die dit paar nest. Staps­gewijs, door wisselen a.6. slim te her­halen, ver­schuiven we deze paren. Die vrijheid bestaat, omdat we elke serie elementen ook apart zouden kunnen uit­werken en op­tellen. En op­tellen van eindige ge­tallen is commu­tatief.

Daarentegen staan in vaste arrays de variabelen in volgorde op rij. Zoals de para­meters van een functie, of zoals genetische infor­matie om eiwitten te bouwen in een cel.
Het nadeel van variabelen die voor hun waarde afhankelijk zijn van de posities ervoor, is dat die structuur intact moet blijven, ook al is de iteratie afge­teld, tot 0 of 1. Maar in blazer systemen zijn alle posities gegeven door index arrays. We kunnen deze indexering samen met de afge­telde iters wegblazen, en deze later her­stellen, zonder effect op de waarde van de rest van de rij.

Gebruikelijk is om de aftelling en verwijdering van iter 1 als geheel te zien en apart te definiëren. We lassen een getal stop ! teken in met regel a.0. om die routine ineens a.3. te kunnen besluiten.
Dan volgt na ! geen getal meer, maar in X,[S]!Z een komma , of array ] eind. Dit teken voor de getal­grens werkt als de woord­grens \b in regex. Verder geen 1 dus, als getallen unair zijn.
Losse variabelen v zijn altijd v! gretig [regex: greedy] naar enen.

Hulpregels a.II bij evaluatie in Aas­blazer.

• a.0. !x => x=0
• a.1. ,[1]c := ,c
• a.2. a[bw,Z] := a[,Z]+wb
• a.3. ,[1X]1! ≡ ,[X]a
• a.4. ,[X],[1X]1 ≡ ,[X]a,[1X]
• a.5. ,[X]p,[X]q ≡ ,[X]pq
• a.6. ,[X]p,[Y]q ≡ ,[Y]q,[X]p

We kunnen index arrays ook houden tot ze definitief onbruikbaar zijn. Vandaar de hulp­regel a.4. voor her­laden, om seps maar een­malig in te hoeven voegen en ze daarna herge­bruiken.
Afgetelde iters kunnen wachten tot we er opnieuw a in­voegen, zodat op­ruimen A.2b. over­bodig is. Dan hoeven we regel A.2a. alleen toe te passen op het einde van de top array.

Het herladen met a.4. van uit­gewerkte ex­pressies kan vanwege de diepe match van array [X] met array [1X] moeilijk worden. Maar in de praktijk mogen we ervan uit­gaan, dat een nieuw gevormde array sequentie X links en de array sequentie X rechts van de lege plaats gelijk zijn, zolang we geen elementen met a.6. ver­plaatst hebben.
Array functies die van grootschalige vergelijkingen afhangen ver­mijden we liever. Maar dat is van later zorg.

Er ontwikkelt zich een radix stelsel, zie §2.0, over de eerste rij met als basis aas a. Het aantal en de grootte van factoren c,d,e,f,.. is voor­alsnog onbe­perkt, maar we zouden ze ook naar gelang de basis 0<fi<a kunnen be­cijferen.

• a[b,[2]1] = a[b,[1]a,[2]] = a[b,a] = a*a+b = a^2+b
• a[,[2]1d] = a[,a,[2]d] := a[,[2]d]+a^2 == a^2*d1
• a[b,[1]c,[2]d] := a[,[2]d]+a*c+b = a^2*d+a*c+b
• a[,[3]1e] = a[,[2]a,[3]e] := a[,[3]e]+a^3 == a^3*e1
• a[,[m]f] = a^m*f
• a[b.,[m_i]f_i..] :n = a^m_i*f_i..+b :n

Een element ,[n]1 telt a^n bij de output op. Zodoende opent deze telbare index n de con­structie klasse *{2} voor array nesten.

De structuren van de functie klassen *{k} in Aas­blazer gebruiken we als sjablonen voor de con­structie van grote ge­tallen functies. Daar­mee zijn deze klassen *{k} con­structie types of con­structen.
In box 2.3 zagen we dat Aas­blazer bestaat uit vloeibare arrays met vrij te bewegen cijfers. Ook de recursies, vanaf regel A.3. verder, willen we universeel toe­pasbaar houden. Welke recur­sieve stap, in wat voor array, we wanneer zetten, het zou niet uit mogen maken.

Onze array functie Bellen­blazer krijgt vaste structuren, en blaast daar groei­bel b in omhoog, niet constante a, wat maximaal uit zal pakken. Hoewel Bellen­blazer's afge­telde elementen A.2. ver­wijderd worden, zijn indexen er niet zoals a.5. samen te voegen of a.6. vloeibaar. Recursies moeten we strikt l-r evalueren, anders wijkt de output af.
Lijkt of snelheid (A. laag, B. hoog) en vrijheid (A. hoog, B. laag) in array functies twee kanten zijn van dezelfde googo­logische munt…?!