§2.8 Belnesten · hypers
Vorig blog
§2.7
werkten we de eerste geneste rij in Bellenblazer uit
en vulden de
n
-dimensionale array ruimte.
In deze dubbele array is elke iter
voorzien van een eigen unieke index.
Nu betreden we de hyperdimensie
met een dieper geneste rij van het derde niveau,
afgeteld over een vierde niveau lengte index.
Deze rij in matrix dimensie
verdiepen we later zelf tot een matrix.
Zo doorgaand vormt dit de geneste arrays,
die we hier alvast definiëren.
De regels, die arrays met indexen genest in indexen evalueren,
blijven hetzelfde. En in Bellenblazer
is elke kind array uniek lid
van zijn ouder array, herhaling is daar overbodig.
Deze structuur heet een complete indexering
.
Maar dan moeten Bellenblazer arrays voor gelijke output
twee keer zo diep worden genest als de array ruimtes van
Bird.14
Zie ook googologie
box 2.6.
Variabele a
is steeds de aas
constante,
die we van rechts buiten de array inladen.
Vars matchen werkt gretig,
zodat er direkt na p
in de expressie voor regel
B.3.
geen getal unit meer kan komen.
Tijdens de evaluatie krijgt variabele
p=#{b,a}
eerst bel b
op bezoek
en is vervolgens alleen nog a
in die regel.
Hoewel een input expressie kan verrassen met andere waardes voor
p
op die plek.
Bellenblazer
B.IV
construct *{2}
geneste arrays.
- B.0. [bw]a = wb (uitlaad)
- B.1. [b,[1]1Z]a := [b,1Z]a = [ba,Z]a (belaad)
- B.2. ,[S]0 ≡ 0 (ontlaad)
- B.3. [,[1S]1T]p =` [p,[1S]T]a (inlaad)
- B.4. [p,[1S]1 {S>0} =` [,[S]p,[1S] (oplaad)
Als we regel
B.4.
in de top array gebruiken, dan schuift bel b
naar rechts om een nieuwe iteratie op te laden.
Is de index array klaar, dan begint de lege bel per regel
B.3.
met een kopie van aas a
.
Maar soms kreeg de nieuwe sep array
,[,S]b
een positie index 0
.
Dan moet de geneste array eerst worden aangevuld.
De bel moet uit de iter
,[,[1S]1T]b
worden overgeladen
,[S]b
naar de hoogste lege index vanaf links, want dat is de enige manier
om de subarray te maximaliseren.
Eerst laden we de iter b
per regel
B.3.
in zijn eerste index en daarna schuiven we
b
eventueel door per regel
B.4.
naar de lege index die opgeladen moet worden.
De iter in regel
B.3.
wordt direkt vervangen door aas a
.
Soms zullen we steeds verder
afdalen: in een cascade
van azen, met onderaan de bel,
op weg naar de diepste indexloze array.
We passen deze regels toe vanaf de eerste match die
=`
links eindigt.
Zo klopt steeds, dat de originele bel
b
per regel
B.4.
als iter van de subarray is geladen, vlak voordat daar
de noodzaak ontstaat om een index op te laden.
De methode om de bel van de iter
naar de hoogste lege index over te laden,
beweegt in een cascade omlaag door geneste arrays.
Ofschoon het wel een eeuwigheid duurt om de vervangen iters
a
weer minstens op peil b
te krijgen,
toch kost dit minder dan 1
tel bij b
.
Want stel dat we de eerste index b1
maken en de aas iter 2
.
Tel die af tot 1
,
dan krijgen we links ervan ons eigen element.
Dit element zal compleet reduceren tot een nieuwe bel
b'
groter dan de oude bel.
Die is zeker groter,
omdat de uitgewerkte index array zelf b
bevat.
Tel de iter nog eens af en de hogere index array vervalt.
Een grotere b'
laadt dan op als iter
van het bedoelde element.
En dit volgt in het ongunstigste geval,
met eerste index b
en aas a=2
.
Bij elke andere index en/of grotere
a
groeit ons eigen element met iter
b'
navenant groter.
Wat bewijst, dat het opwaarderen van regel
B.3.
zodat die bel b
overal substitueert
(in de index laadt, maar ook in de iter laat), minder presteert dan
1
optellen bij b
.
Toch is ook die extra tel in ons geneste systeem
insignificant.∴
Door de lege bel en iters in de cascade van de regels
B.4.
en
B.3.
opnieuw te vullen met aas
a
, komen er natuurlijker
grote getallen tot stand,
dan door overal een kopie van b
te laden.
Dat goldt ook al voor machten en bij de supermachten
op de eerste rij van
§2.5.
Met de tweede index op het 3e niveau
nemen we de oplaad & inlaad cascade in gebruik.
Tegelijk komen bovenop de hyperpijl
→→
een serie Conway pijlen →
met parameters, om recursief het aantal dimensies weer te geven
van Bellenblazer.
- 4 2 3 2 4 2 3 2 §2.7 [b,[1,[1]1,[1,[1]1]1]1]a := [,[,1,[1,1]1]b]a := ,[b,[1,1]1]a =` ,[,[,1]b]a = ,[,[b]a]a ≈> a→↑{b}a = a→→a→b
- [1b,[2,1,[1,1]1]1]a := a,[1,1,[1,1]1]b ≈> a→→a→a,["]b- ≈> a→→a→(..a..) :b ≈> a→→a→b→2
- [1b,[1c,1,[1,1]1]1]a := a,[c,1,[1,1]1]b =: a,["]1,["]b- ≈> a→→a→a-→c,["]b- ≈> a→→a→(..a..)-→c :b ≈> a→→a→b→c1
Steeds voegt de 1e index
een rij toe, met lengte c
.
We vergelijken dit met de volgende Conway
→
schakel rechts,
zodat duidelijk wordt, dat dit een dubbele recursie blijft,
maar voortaan over hyper-dimensies.
Daarna vormt de 2e index
weer een vlak van rijen, net als in
§2.6.
Die vergelijken we met de hele pijlketen lengte,
de tripel recursie die een Conway-Knuth pijl
→↑
rechts laat noteren.
We voeren een aantal regels tegelijk uit, eerstens bijv.
4 2 3 3
uit de Bellenblazer definitie,
en vergelijken dan met een eerder resultaat.
- [b,[1,2,[1,1]1]1]a := ,[b,1,[1,1]1]a ≈> a→→a→a→b
- [1b,[2,2,[1,1]1]1]a := ,[a,1,[1,1]1]a,[-"]b- ≈> a→→a→a→a,[-"]b- ≈> a→→a→a→b→2
- [1b,[1c,2,[1,1]1]1]a := ,[--"]a,[-"]b- =: a,[-"]1,[-"]b- ≈> a→→a→a→a-→c,[-"]b- ≈> a→→a→a→b→c1
- [b,[1,d,[1,1]1]1]a ≈> a→→.a→..b :d
- [1b,[c,d,[1,1]1]1]a ≈> a→→.a→..b→c :d = a→→a→↑d2 {a=b=c}
In onze notatie kunnen we met quotes
["]
of [']
een eerdere array aanhalen.
Het origineel staat dan in de lijn erboven
of anders rechts in de expressie zelf.
Dit helpt ons schrijfruimte besparen.
We kunnen gequote index arrays
[-"]
aftellen met min tekens.
Om daarna de eerste index nog eens
[--"]
af te tellen.
De indexen ,[m]
noteren dimensies, hier van een dubbele matrix.
Het element ,[1,1]b
genereert bellachelijk veel
matrixen.
Waarbij elke super-matrix het aantal dimensies aangeeft
van de matrix ervoor.
Steeds herleiden we uit een eerder evaluatie patroon
de algemenere evaluaties.
Bijv. hier nemen we de uitwerking
in het tweede item over uit
§2.7
uit een conclusie. Verifieer dat dat patroon met
§2.7
in het eerste item niet precies klopt,
omdat na de hyper de eerste pijl
→a
als 1
extra telt bij →↑b
,
wat wel volgt uit de demonstratie…
- [b,[1,1,[2]1,[1,1]1]1]a := ,[a,b-,[1,1]1]a ≈> a→→a→↑b1
- [1b,[1,1,[3]1,[1,1]1]1]a ≈> a→→.a→↑..a :b = a→→a→↑↑b1
- [b,[1,1,[4]1,[1,1]1]1]a ≈> a→→a→↑↑↑b
- [b,[1,1,[1,1]2]1]a := ,[a,[b]a-,["]1]a =: a,[1,1,[1b]1,["]1]1 ≈> a→→a→↑{b}a = a→→a→→a→b
- [1b,[1,1,[2,1]1]1]a := ,[a,["]b]a =: a,[1,1,["]b]1 ≈> a→→..a→a :b ≈> a→→↑b1
Een index array
,[1,1,[1,1]1,2]
in het laatste item zou precies zo uitwerken.
Maar de evaluatie trein in Bellenblazer produceert
zo'n tweede rij met (binnen de ouder array) herhaalde
,[1]
nooit,
niet in de top array en niet in subarrays. Regel
B.4.
maakt elke index links kleiner.
Deze geordende structuur verschilt van Bird's ruimtes.
We hoeven dus alleen de tweede rij
,[i,1]pi..
in onze vergelijking te betrekken.
Bij subelement
,[1,2]1
bouwen we die straks aan, met een lengte
:b
van de bel.
Zowel index vorm
[a,[m]b
als de pijl operatie
→↑{m}b1
stapelen een rij van b
recursies van type m1
.
Met ,[1,1]2
geeft dat twee
→→
hyperpijlen
en bij ,[1,1]b
de herhaling
→→↑
ervan.
We verspillen zo een hoop operatoren helaas,
omdat getallen links in Bellenblazer arrays
na hyperpijlen →→
rechts komen te staan. Zonder herladen valt elke
1→Z
weg en dat maakt de pijlfuncties langzamer,
in Bellenblazer kan y=1
opnieuw meedoen met de geblazen bel.
We hebben nu genoeg voorbeelden gezien,
om de algemene definitie van dit soort
→{n}↑{m}
pijlfuncties te geven.
We noemen ze:
Conway-Knuth
hyper-recursieve pijlen
Zulke getallen zijn verschrikkelijk groot ja.
En we raken hier pas aan het begin van
Bellenblazer en Bird's hyper-dimensionale
arrays.16
In deze duale operator houden we de Conway hyperpijlen
→..
links en de Knuth superpijlen
↑..
rechts gescheiden. Alleen de tussenstap in de reductie
van hyperpijlen wijkt even van dit plan af.
Onze definitie gebruikt de volgende kaart symbolen.
Pas het formaat en de stijl ervan aan door op de box te klikken
[voor mobiel].
- ♥ ≡ →{n}↑{m} {m>0||n>0}
- ♠ ≡ →{n}↑{m} {n=1||m>0}
Conway's recursie wordt met ♠
beperkt, zodat de hypers
→{n>1}
zonder supers (uit ♥
)
niet onder zijn regel vallen.
En hoewel we er geen bezwaar in zien, komen superpijlen
x↑{m}y→z
vanzelf niet zo voor in de evaluatie trein.
Definitie C.II van recursie met Conway-Knuth Hyperpijlen.
- y*z ≡ y.. :z
- y♥1 =! y (init
z
) - y↑z1 =! y*y↑z (macht) == y*..y :z
- y♥↑z1 (Knuth pijlen) =! y♥y♥↑z == y♥..y :z
- ♥1♥z =! 0 (init
y
) - X♠y1→z1 (Conway pijlen) = X♠(X♠y→z1)→z == X♠(..X..)→z :y:
- x→y = x↑y
- ♥→z =! ♥↑z (pijl init)
- ♥→y→z1 (Hyper pijlen) =! ♥↑→y→z == ♥↑{z}→y→1 =! ♥↑{z1}y
De evaluatie links van subarray
,[2,1]
nemen we over van eerdere
,[1,1]
uitwerkingen.
Bellenblazer voegt met dimensie index
,[m]
eerst extra supers
↑{m}
toe, die samen hypers
→→
vormen.
Het inladen van bel b
naar diepere niveau's
,[b]
in Bellenblazer
zal de vaart erin houden bij het maken van grote getallen.
- [1b,[2,1,[2,1]1]1]a := a,[1,1,[2,1]1]b = a→→↑a,["]b- ≈> a→→↑(..a..) :b: = a→→↑b1→2
- [b,[1,2,[2,1]1]1]a := ,[b,1,[2,1]1]a ≈> a→→↑a→a→b
- [b,[1,1,[2]1,[2,1]1]1]a := ,[a,b-,[2,1]1]a ≈> a→→↑a→↑b
- [b,[1,1,[3]1,[2,1]1]1]a ≈> a→→↑a→↑↑b
- [b,[1,1,[1,1]1,[2,1]1]1]a := ,[,[b]a,["]1]a =: a,[1,1,[1b]1,["]1]1 ≈> a→→↑a→↑{b}a = a→→↑a→→a→b
- [b,[1,1,[2,1]2]1]a ≈> a→→↑a→→↑b
Uit element ,[2,1]c
komt links een rij indexen
p0.,[i]pi..
met lengte :b
die de lengte :b'
bepaalt voor de latere rij indexen.
Het evaluatie patroon is nu helder en
het einde van het stapelen met alleen
→
en ↑
pijlen komt in zicht, bij de 1e hyper index
in m,[1]n
op het
3e rij niveau in Bellenblazer.
- [b,[1,1,[3,1]1]1]a ≈> a→→↑↑b
- [b,[1,1,[1,2]1]1]a =: a,[1,1,[1b,1]1]1 ≈> a→→↑{b}a = a→→→a→b
- [1b,[1,1,[2,2]1]1]a =: a,[1,1,[1,2]b]1 ≈> a→→→..a→a :b ≈> a→→→↑b1
- [b,[1,1,[1,3]1]1]a =: a,[1,1,[1b,2]1]1 ≈> a→→→↑{b}a = a→→→→a→b
- [b,[1,1,[1,1,[2]1]1]1]a := ,[,[,b]a]a =: a,[1,1,[1,b]1]1 ≈> a→{b}↑{a}a = a→{b1}a→a
Uit deze patronen leiden we een formule met meerdere parameters af. Wat meer naar links in de expressie staat doet er relatief minder toe en een iter is minder significant dan zijn index array.
[b,[d,e,[m,n]f]c]a ≈> abcde→{n1}↑{m}f = abcde→{n2}f→m
Twee maten bepalen deze duale pijlen:
het aantal Conway
→{n}
hypers en het aantal Knuth
↑{m}
supers.
Wat overeen komt met de twee indexen
m,[1]n
van dimensie m
en de eerste hyperdimensie n
in Bellenblazer.
Voor hogere indexen zullen we de structuur en het algoritme
van deze hyperpijl functie verder moeten expanderen.
We hadden de Conway-Knuth definitie ook op kunnen zetten
als een gemengde ♦
pijlenmix
→↑{mi}..
met :n1
maten mi
in serie.
Dat is dan te vergelijken met de rij hyper-indexen
[m0.,[i]mi..]
:n
in Bellenblazer.
Zulke hyperpijlen stapelen al de vorige functies
weer bovenop de volgende operator.
Net zoals we in Bellenblazer bel b
afleiden van de linker subexpressie
en die uitkomst inladen in de diepste vrije index.
Maar geneste arrays noteren de grootste getallen
en we kunnen hier al rijen indexen of pijl arrays
→S↓
aan Conway's functie hechten.
Laat een geneste functie recursiepijlen
↑{k}
aftellen als index.
We scheiden die met seppijlen ←
die werken als komma en als het ware terug verwijzen naar de
functiepijl →
als openingshaakje. De pijl array loopt door tot de
vrije stoppijl ↓
die het sluitstuk is van de operator.
Verder nesten kan door seppijlen
←→S↓
te indexeren.
Of door op de even index niveau's een seppijl
←S↓
als opening te gebruiken met
→
als komma,
en op oneven niveau's
→S↓
met ←
als komma.
De eerste methode zouden we kunnen toepassen
bij herhaalde seps in de stijl van Bird.
De afwisseling van pijl operatoren per niveau past beter
bij de complete indexering in de stijl van blazer systemen.
Steeds komen pijl ↑..
indexen overeen met getal 1..
indexen in arrays.
Als de [m
index,
die dimensies van iterator posities telt in Bellenblazer,
na de eerste hyper index
,[1]n
verder wordt uitgebreid tot een hyper rij met lengte
,[p]
op het vierde niveau,
dan noteren we getallen met hyperdimensionale arrays.
Hoewel onze hyper-ruimte even groot is als die van Bird,
is de getallen output een orde van grootte kleiner.
Want wat bij Bird een Ackermann functie over
{a,b,c}
is, vergt in Bellenblazer de lengte
,[c]
van de eerste rij.
En Bird's lineaire array vergelijkt met matrix dimensies
,[m]
in Bellenblazer.
Zodat onze index [p]
van hyper-dimensies gelijk komt met Bird's multi-dimensies
en iter n
daarover
de lengte aangeeft van zijn dimensies.
Ons element ,[p]n
loopt dus twee niveau's achter.
Met het volgende geneste element
,[s]q
maken we van de dimensie index in Bellenblazer een matrix.
In gelijke ruimtes blijft het blazen van bellen b
ongeveer even sterk als Bird's oplaad systeem.
Daarom is de output van onze matrix in matrix
gelijk aan de geneste rij bij Bird, dat is zijn hyper-dimensionale array.
Onze index [s]
op het vijfde niveau
evenaart dus de lengte van Bird's hyper-index array.
Als we doorgaan met rij in rij
nesten,
dan kan elke index een matrix en elke matrix haar
hyper-matrix omvatten, zoals in een matroesjka pop.
De evaluatie regels gaven we in de algemene definitie
B.IV
voor geneste arrays.
Na een langzame start is het Bellenblazer algoritme
vrijwel maximaal, alleen onze index structuur rijdt 2 op 1.
Elk oneven niveau is gelijk aan een niveau van Bird.
Dat zullen we nog bewijzen door onze expressies te vergelijken
met de PDFs18
die Chris Bird bij MRob deponeerde,
in het volgende hoofdstuk.
Daar zullen we overal een groeibel a
substitueren, zoals de Aasblazer radix
A.II
overal constante a
oplaadt.
En we vergelijken deze blazer Wielewaal
met een systeem Vogel
, dat niet zo massief is als Bird
maar duidelijk gelijkwaardig.
Denkwerk in uitvoering
De syntax is
→S↓
met tag S
die uit diverse pijlen kan bestaan.
Als S=0
dan zijn dit gewone haakjes (X)
maar verder is de variatie aan haakjes indexen
voor woorden X
, die hogere pijltypes beschrijven,
bijna even groot als de ermee uitgedrukte getallen.
Al die woorden kunnen weer worden genest, door elkaar ook,
zolang hun begin tags ↓T
maar eenduidig te vinden zijn.
Het zijn net tags <T>
met X
tekst inhoud </T>
in html.
Om de natuurlijke ontwikkeling
van Aasblazer
te blijven monitoren, hebben we met onze Bellenblazer cascade
versus de Conway-Knuth hyper-recursie
voorlopig genoeg grote getallen op voorraad.
In het vervolg van Bellenblazer itereren we
over array nest diepte met diepen,
arrays in serie waarover gg eerder al
blogde.q
r
s
Een nieuw idee is om naast de functie array
ook meerdere arrays in serie te zetten.
Teneinde deze per definitie grotere getallen
ψ
uit te laten drukken (indexeren),
dan fysisch gezien met de functie alleen kunnen worden gemaakt.
Een berg van niet-standaard getallen ψ
,
een soort eindige ω
,
die buiten het huidige systeem vallen.
Dit zou een tweetraps raket met de aritmetisatie20 van onze (ongeveer) maximale systemen zelf kunnen vormen. Dat wil zeggen, mits de introductie van nieuwe operator tekens te automatiseren valt, dan zijn deze telbaar en kunnen we erover itereren in een hogere array functie. Zulke cycli van aritmetisatie kunnen we in theorie indexeren met een volgend hogere array functie. :-) Ad infinitum…
d*e[n[ *h[a[a[g]· ·[2]*]*]*][0][1]*][∞]*
Tenslotte deze opzet voor bellenblazerij
met een strikte l-r
notatie van kleine naar grote concepten in
RGB kleuren.
Hiermee eindigt mijn Reuzen Getallen Bootstrap
werk–versie
voor de expositie:
- “Naar Amritsar mijn vriend” een video installatie van Giga Gerard Maldoror, Wagenstraat 123, maart 2018
Een herschrijf algoritme voor diepe series arrays, gg: Serial deeps in "Deep attachments" voor Btrix matrix (concept 2014).
r.
We definiëren een systeem van diepe arrays of diepen, gg: Deep numbers in "Big number systems" voor Iteror (blog mei 2015).
s.
Los diepe ster operaties met arrays net zo op als superster operaties met getallen, gg: Birth of the Superdeep in "Big number systems" voor Iteror (blog mei 2015).
Bird's geneste arrays, behandelt recursieve functies
met limiet ordinaal ε0
,
Chris Bird,
Nested Array Notation,
2012.16.
Is een [a,b,c,...]
dimensionale array
,
Chris Bird, p.1 in
Hyper-Dimensional Array Notation, 2017.18.
Een systeem voor snel groeiende recursieve functies, dat de functies van Jonathan Bowers en anderen ver te boven gaat, in Christopher M. Bird's Super Huge Numbers, een serie van 9 PDFs over Bird's arrays + 3 bijlagen, 2017.
20.
Codeer tekens en termen als getallen, ch.5 in John Stillwell, "Reverse Mathematics", 2018.