§2.3 Aasblazer
Aas
[ace] is hoe we de linker operant
a
noemen, die constant blijft.
In de primitief recursieve stap van onze
blazer
[blazer] functies telt
a
op bij variabele
b
, de bel
[bubble].
Deze wordt gedurende de evaluatie steeds groter, tot de bel
op het laatst de uitkomst [output]
geeft als een lange reeks 1..
enen.
Initieer Aasblazer 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 optellen classificeren 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 oneindige reeksen.
In Aasblazer arrays zijn nieuwe reeksen a..
die van rechts de bel in komen, altijd groter dan eerdere,
die links staan voorgesorteerd 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 subtotaal alvast rechts buiten
de array te presenteren, in rekenkundig format.
Zet dan wel een plus teken +
tussen de Aasblazer array en de voorlopige 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 parameters of iteratoren.
In Aasblazer fungeren alle variabelen
buiten de optel bel
als factoren.
Volgt de definitie van Aasblazer's eerste rij,
ofwel de lineaire array
.
De eerste rij wordt gevormd door de voorste serie parameters,
waar elke positie met een enkele index gegeven is,
die zelf in de index array het eerst komt.
De aan de geïndexeerde positie gekoppelde parameter
beschouwen we als nulde iterator
van de geneste rij.
Regels met equivalentie ≡
zijn
universeel (overal, altijd) toepasbaar.
Dus zonder richting van evaluatie in de expressie.
Hoewel we normaal `=
vanaf links l-r
regels toepassen op de expressie 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 natuurlijke getallen vanaf
0
. Maar een teken 0
valt meteen weg (tegen een getal ernaast, maar ook op zich)
en een lege iterator elimineert zijn element.
Aasblazer
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 getallen direkt op in de bel.
Die wordt bij de uitlezing met
A.0.
omgedraaid. Dus optellen gaat zoals de
pop plus in blog
§2.0,
maar dan achteraf.
Een verdwaald element ,[]p
in het midden laten we met rust,
tot de voorgaande indexen zijn verdwenen
en dit element bij [b
arriveert.
Pas dan popt de lege sep weg, zodat waarde
p
rechts bijtelt.
Een eerste komma ,[1]
zullen we vaak zo ,
noteren zonder index.
Deze vertaling behoort niet in de definitie,
en komt daarom
a.1.
in de lijst met hulpregels.
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 herstellen
en aas a
op te laden naar de nieuwe parameter.
Meestal volgt in een expressie achter de
1
nog een getal 1p
,
maar de regels vermelden alleen tekens
die nodig zijn voor de match.
# Googologie 2.3
Een array is een reeks variabele getallen, met een
separator of sep
ertussen.
Aasblazer arrays zijn omvat met vierkante haken
[T]
en van linksbuiten gekoppeld 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 iteratie bepaalt
en daarmee 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 expressie (bij ons links van de iter).
Iters op rij zouden we net als in functies
kunnen scheiden met enkele komma's.
Blazer structuren slaan die tussenstap in de notatie over.
Onze solo komma ,
is een afkorting van de eerste sep, links in arrays.
Van de variabele 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 (afgezien van oneigenlijke input) uniek blijven.
We vergelijken herhaalbare met unieke seps in googologie box 2.4. Googologie is de fenomenologie van fenomenaal grote getallen.
Aasblazer heeft vloeibare arrays,
bestaande uit suboperaties 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 biologische cel.
Ieder eindig iter getal met index array
kan zich vrij verplaatsen binnen de array die dit paar nest.
Stapsgewijs, door wisselen
a.6.
slim te herhalen, verschuiven we deze paren.
Die vrijheid bestaat, omdat we elke serie elementen
ook apart zouden kunnen uitwerken en optellen.
En optellen van eindige getallen is commutatief.
Daarentegen staan in vaste arrays
de variabelen in volgorde op rij.
Zoals de parameters van een functie,
of zoals genetische informatie 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 afgeteld,
tot 0
of 1
.
Maar in blazer systemen zijn alle posities gegeven door index arrays.
We kunnen deze indexering samen met de afgetelde iters
wegblazen
, en deze later herstellen,
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 getalgrens werkt als de woordgrens
\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 Aasblazer.
- 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 hulpregel
a.4.
voor herladen,
om seps maar eenmalig in te hoeven voegen
en ze daarna hergebruiken.
Afgetelde iters kunnen wachten tot we er opnieuw
a
invoegen, zodat opruimen
A.2b.
overbodig is.
Dan hoeven we regel
A.2a.
alleen toe te passen op het einde van de top array.
Het herladen met
a.4.
van uitgewerkte expressies kan vanwege de
diepe match van array
[X]
met array
[1X]
moeilijk worden.
Maar in de praktijk mogen we ervan uitgaan,
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.
verplaatst hebben.
Array functies die van grootschalige vergelijkingen afhangen
vermijden 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 vooralsnog onbeperkt,
maar we zouden ze ook naar gelang de basis
0<fi<a
kunnen becijferen.
- 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.,[mi]fi..] :n = a^mi*fi..+b :n
Een element ,[n]1
telt a^n
bij de output op.
Zodoende opent deze telbare index n
de constructie klasse
*{2}
voor array nesten.
De structuren van de functie klassen
*{k}
in Aasblazer gebruiken we als sjablonen
voor de constructie van grote getallen functies.
Daarmee zijn deze klassen
*{k}
constructie types of constructen
.
In
box 2.3
zagen we dat Aasblazer
bestaat uit vloeibare arrays met vrij te bewegen cijfers.
Ook de recursies, vanaf regel
A.3.
verder, willen we universeel toepasbaar houden.
Welke recursieve stap, in wat voor array, we wanneer zetten,
het zou niet uit mogen maken.
Onze array functie Bellenblazer
krijgt vaste structuren, en blaast daar groeibel
b
in omhoog, niet constante a
,
wat maximaal uit zal pakken.
Hoewel Bellenblazer's afgetelde elementen
A.2.
verwijderd 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 googologische munt…?!