Bird's
hyper-dimensionale arrays3
is een structuur met dermate veel tellers of argumenten
(en rijen van tellers en ruimtes daar weer van),
dat de indexering ertussen (bij herhaalde separatoren)
zelf tot een rij is uitgebreid.
Zowel de tellers in de top rij als de indexen in de sep arrays
zijn iteratoren en hebben de functie
om de iteratie links ervan te herladen als deze is afgeteld.
De te laden bel
is steeds (ongeveer) maximaal
en daarmee is Bird's array functie maximaal.
Ons Vogel
telraam waarmee we Bird vergelijken heeft ook de
rij in rij structuur. Door sep arrays te herhalen krijgen we
een maximum aantal posities in de array erboven.
En door sep indexen te herladen met de bel,
expanderen we alle voorliggende ruimtes maximaal.
Aan de basis substitueren zowel Vogel als Bird de
(minimaal kleinere) subexpressie $
in de bel. Bel b is de enige geneste variabele,
want meervoudige functie substitutie wordt niet significant groter.
Bird of
Uil
substitueert subexpressies $
ook rechts in arrays. Dat is overbodig,
het volstaat om in onze Vogel benadering van Bird die
$
alleen te nesten in de basis.
Kenmerkend voor de Main arrays
van Bird is het herladen van de rechtse lege teller met
subexpressie $,
de tellers ervoor met constante a
en sep arrays overal met de maximale bel b.
Dominant is hierbij het opladen van tellers
en inladen van index arrays met de groeibel.
Vogel doet dit direkt met de b uit de basis,
maar Bird verpakt b- in een subexpressie
$ alvorens deze op te laden.
Uit de vorige blogs bleek al, dat dit verschil
(met Bird c tegen c1
in Vogel) niet veel anders uitpakt.
De eerste index noteert de matrix dimensies. De hyperdimensionale arrays
breiden dit uit tot een rij indexen op het tweede niveau.
Ook daarin kunnen we de indexen en rijen nesten,
wat precies eender werkt.
Grote getallen zijn ver genest of vernest
als hun arrays dieper gaan dan de hyperrij.
We slaan een aparte definitie voor dit
niveau over en geven de regels voor alle geneste arrays in Vogel.
Zo kunnen we rijen indexen arbitrair diep in andere rijen nesten.
Tijdens de constructie neemt het niveau
van geneste arrays van buiten naar binnen
toe:
•
Een scan zal l-r of r-l
de functie haakjes als eerste tegenkomen.
Dit telden we in
§2.6
als het 1e niveau.
Die top array
omvat gelijke structuren,
die naar beneden toe worden opgebouwd en toenemen.5
•
Zoals <tag> tekst </tag>
is opgemaakt in html.
De tag naam kun je zien als type haakje of als index voor een geneste rij.
Met een script adresseren we eerst het ouder element
en dan de kind elementen die daarin zijn genest of vertakt.
•
Of een verhaal dat wordt vervolgd door zinnen eronder te plaatsen.
Maar geneste structuren werken ook andersom:
•
Bird4
telt het level van separator arrays:
vanaf index [m]
met level 0 die dimensies m scheidt,
lineaire separatoren als level 1
tussen hyper-ruimtes.
Enzovoort, zodat de grootste level n
separator ergens in de top array {Y}
zal worden genest.
•
Een macht b in een dubbele recursie
V.O
bereikt bij waarde
b=1
de bodem
(a,..a..,c)
in de subexpressie trein.
•
Bij sets is de element relatie ∈
fundamenteel en tellen we van de diepste subset naar de buitenste set de
is in
relaties.
Zo worden ordinale sets opgebouwd,
die natuurlijke getallen representeren.
Dit is axiomatisch bij oneindige limieten
ω, zie
§1.4 ev.
•
Onze superradix structuur in
§2.4
noteert in de diepste array de getallen m,
machten m^m met de array laag erboven,
en stapelt laag op laag een toren van m^(m^^n) machten,
die tetratie m^^n1 is.
Vogel nesten definitie
V.III
met {S>0}.
- V.0. (a) = a
- V.1. (a,1b) = a(a,b)
- V.a. ,1 ≡ ,[1]1
- V.2a. ,[S]1) ≡ )
V.2b. ,[S]1] ≡ ]
- V.3. (a,1,[S]Z) = a
- V.4. (a,1b,1Z) {Z>0}
= (a,(a,b,1Z),Z)
- V.5a. ,[] `= 0 =>
V.5b. (a,b, ,2
`= (a,a, b,1
- V.6. (a,b ,[1n]2
`= (a,a ,[n]b,[1n]1
- V.7. (a,b ,[1S]2 {S>n}
`= (a,b ,[S]b,[1S]1
Probeer de regels =
en `= van l-r
toe te passen op de (binnenste) expressie,
dat wil zeggen, vindt een match die (daarin) links start.
De eerste match van links dient met prioriteit te worden uitgevoerd.
Waar een match eindigt is ondubbelzinnig,
elk links startpunt blijft uniek.
Zo matchen we een element
,[1,[1n]1T]p
met regel
V.7.
die een nieuw element
,[,[1n]1T]b
ervoor zet. Deze is opgeladen met een kopie van bel
b, waarbij de basis bel blijft staan.
Dan laden we die bel met regel
V.6.
over ,[n]b
in de index array
en vervangen de bel zelf door aas a.
Bij n=0
vervalt de lege sep en in dit geval blijft dimensie index
[b over.
Door regel
V.6.
van [n-] rechts naar
[1] links te herhalen, laden we een rij
,[i]a-..
met :n- hyper-indexen in.
Met V.5.
is ook de dimensie [a
en het nieuwe element klaar.
Noem dit element
,[a,S]b
en plaats links ervoor afstapsgewijs de reeks van
,[j,S]a
tot element
,[1,S]a
is bereikt. Dit schept :a
nieuwe elementen op het top niveau.
De hier beschreven subroutine
komt daarmee terug op het beginpunt.
Zolang als
S>1
herhalen we deze subroutine eerst met
,[,1Tk]a
en elementen
,[1,Sk]a
op het eind. Nadat woord S
leeg is geteld, wordt ook element
,[1]a bereikt.
Dit kan bij input raken
(a,a,a aan de basis,
maar zal later na vele lege ruimtes rechts ,a
aansluiten.
Toch komt elke evaluatie trein
uiteindelijk bij de basis aan.
En dan zal basis regel
V.4.
de expressie $
met de oorspronkelijk op en ingeladen bel
b substitueren.
Wat bewijst dat we voortdurend niet slechts a
(of subexpressies met a), maar vele grotere bellen
b' de hoogte in blazen.
Wanneer de eerdere index
,[n-]a-
is afgeteld, kunnen we rechts van
,[n-]1
zo'n nieuwe bel
,[n-]bn
inladen. En na afdaling tot sep eliminatie regel
V.5.
wordt ook de eerdere
,[n-]1a
opnieuw actief.
Belangrijk is niet de duur van dit hele evaluatie
traject, of de grootte van de nieuwe bellen
bi
(dat is insignificant),
of de lange reeks van extra elementen
die met die bellen Bi
zijn ingevoegd en afgedaald.
Belangrijk (en significant) is alleen dat de oorspronkelijke waarde
b
daarin op zeker moment op al die n1 posities
[B0.,[i]Bi..
:n is ingeladen.
Want zo worden Vogel index arrays vergelijkbaar
met de betreffende regels van Bird,
die dominant (significant) zijn.∴
Elke (geneste) index in array systemen komt leeg,
net op het moment dat bel b
naar de teller (of index) erboven is opgeladen.
Zonder b kopie, in de
Bellenblazer
definitie, zijn afgetelde indexen een probleem.
We losten we dit op, door sep arrays vanuit hun teller op te laden,
zodat de originele bel b
de array niveau's als in een cascade afdaalt. Dat is het zuinigst.
Bird vervangt met zijn subsysteem voor
hoekketens
uit voorzorg alle waarden door b,
lengtes zowel als indexen.
Zo garandeert hij dat zijn ruimtes volledig (maximaal) gevuld zijn,
maar helaas geeft het een overdaad aan extra regels.
Vogel's definitie
V.III
is simpeler dan Bird's geneste arrays
U.III.
Bij ons komt b, doordat regel
V.7.
deze voor het opladen van teller dan wel index kopieert,
ook in diepere geneste arrays terecht.
Hoewel we grotere b'
gestaag naar voorliggende tellers, indexen en lengtes verhuizen,
maakt dit traject de expressie niet significant groter
dan direkte substitutie van b zou doen.
Dit mag u bewijzen…!
We zetten de vergelijkingen uit blog
§3.2
voort. De geneste arrays van Vogel en Bird zijn vrijwel
≈ even snel.
Voegen we aan de meest diepe rechtse ruimte in Vogel
een teller of index 2, aan het begin toe,
dan wordt Vogel al ~>
groter dan een gelijke expressie bij Bird.
Aan vars v
gaat een lang evaluatie traject vooraf,
zodat v veel groter is dan b.
Na evaluatie met ~:
zijn de waardes van v en a
niet van belang en hebben we de structuur vereenvoudigd.
Klik op dit hyper-dimensionale bord voor meer detail.
- V(a,b1,[1,2]2) = (a,b1,[,2]b1)
= (a,a,[b1]b1) = (a,a,[b]a,[b1]b)
~: (a,v.,[b]v..) :b
~> {a,b[1,2]2} = {{a[1,2]b}}
= {a<0,2>b} = {a<b>b}
== {a<b-1>b[b]..1} :b
=: {{a[b1]b}} =: {a,b[b1]2}
== {{a[b]b}[b]..1`} :b
- (a,b,[1,2]1,2) = (a,a,[1b]a)
= (a,a,[a]a,[1,2]b)
~: (a,v,[a-]v,[1,2]b)
~: (a,v,[v]v,[1,2]b-)
≈> {a,b,2[a]2}
Rekenwerk in uitvoering
- (a,a,[1,2]1b,c)
≈ {a,b,c+1[a]2}
- (a,b,[2,2]2)
= (a,a,[1,2]b,[2,2]1)
≈ {a,a,{a,a,b[a]2}[a]2}
≈ {a,b,1,2[a]2}
≈ {a,{a,a-1,a[a]2}-1,
{a,a-1,a[a]2}[a]2}
- (a,b,2,[1,2]1,1Z)
== (a,a,1,[1,2]1v,Z)
= (a,a,1,[a]a,[1,2]v,Z)
== (a,B,[1,2]v,Z) {B>>b}
≈ {a,b[1,2]1,1+Z}
- (a,b1,[2,2]1,2)
== (a,B,[1,2]1,[2,2]b)
≈ {a,b[2,2]2}
- (a,b1,[c,2]1,Z)
≈ {a,b[c,2]Z}
- (a,b,[1,1d]1Z)
= (a,a,[b,d]b,[1,1d]Z)
≈ {a,b-1[1,d+1]1+Z}
- (a,b,2,[1,R]Z)
≈ {a,b[1,R]Z}
- (a,b,[R]1,Z)
≈ {a,b[R]Z}
0'>!<
Het grootste verschil is dat Vogel's regels
V.6. en
V.7.
een enkel element per stap plaatsen
en dat Bird met zijn hoekketens elke reeks elementen meteen opbouwt.
Dit ondervangen we door op de betreffende positie in Vogel
een gewone teller 1, in te voegen.
Dit geldt voor elke ruimte in elke array,
maar het diepst geneste niveau
kmax
is dominant. Wat daar groter is draagt over,
zodat (afgezien van de komma array notatie
,[S]
versus [S] bij Bird)
de rest van de Vogel expressie gelijk kan blijven
in deze algemene vergelijking.
- V(a,B.,[Xi..,[n]1,Y..]Zi.)
≈ {a,B.[Xi..[n]Y..]Zi.}
:kmax: & Y=p0.,pj.. :r≥0
De regels
W.II
voor geneste Wielewaal arrays werken simpeler dan die van Vogel.
Merk op dat we de aasbel a
zowel binnen als buiten de functie array noteren.
In beginsel vormt dit een geheel en de top array
kan dus zonder opening [ haakje.
Wiel subarrays evalueren tot de vorm
[p,[1]S]
met een eerste index 1.
Vervolgens tellen we p- af, tot
[,[1]1S]
de dubbelbel a oplaadt
[,[]a,[1]S]
waar de lege sep vervalt.
Ook in de basis staat de index 1 komma
a,[1]1X
die een kopie a,[]a,[1]X
maakt en de bel aa,X
verdubbelt.
Om te testen welk primitief (tellerij) algoritme het simpelst
is,
zetten we een experiment op met eerste posities.
De superradix in de box krijgt een nieuwe structuur,
met een algoritme dat lijkt op Wielewaal.
Het nieuwe, ook ten opzichte van Aasblazer, is dat eerste seps
,[1]
na een inerte komma n,p komen.
De a die we opladen
is dan een constante en de bel
a,ba,X
groeit alleen de som voor de uitkomst. De rest kan gelijk blijven.
#
Superradix 3.3
De basis waar een getal aangroeit komt meteen links,
want we lezen van links naar rechts.
Ons nieuwe idee is om structuren consequent
l-r van klein naar groot te ordenen.
In zulke systemen staan dominantere variabelen meer naar rechts.
Dominant is wat bij gelijke waarden groter uitwerkt.
Oneindiger series a.. tellen we
nω van rechts bij (keert Cantor om).
En eigenlijk zouden we decimale getallen liever andersom schrijven.
Aalscholver is net als
Aasgier
een superradix van het
Aasblazer type.
Maar hier zetten we de teller van het aantal,
die minder significant is,
links aan het begin van zijn index array, voor de machten.
De aparte status van iterator over index
{Bird's [separator]
entry} komt zodoende te vervallen.
Het hele element wordt (in een rij)
omvat. We nesten louter rijen in rijen.
Aalscholver
Á.I
een rij tellers, met vaste posities per komma.
- Á.0. (a,b) = b
- Á.1. ,) ≡ )
- Á.2. (a, ,1 `= a,
Door radix expressies l-r
te reduceren met `=
blijven verdere tellers c
beperkt tot cijfers van 0
tot en met a.
Zou de laatste regel met ≡
overal gelden, dan is het output getal weliswaar gelijk,
maar kunnen tellers c
groter dan radix a
worden tijdens de evaluatie.
Druk de lineaire array uit met nesten en als vaste rij.
Bereken die met de
+ * ^
operaties en een index i die telt van
1 tot en met k.
(a,b.,(ci,i)..) :k =
(a,b.,ci..) :k =
b.+ci*a^i.. :k
We breiden getallen uit tot arrays.
Zo'n subarray staat in Aalscholver los van zijn positie.
Dezelfde array zou op meerdere plaatsen kunnen voorkomen,
hoewel niet binnen een strikte radix expressie.
In de binnenste arrays houden we gewone tellers.
Zetten we die op rij, dan blijkt de positie
(anders de tweede index) uit het aantal ervoor staande komma's
(de eerste telt als index 0).
Dit systeem met opladen van constante a
en complete indexering noemen we
vloeibaar
. Want elk kind element
,(p,S)
telt op in zijn ouder array
(n,p0.,(pi,Si)..)
en kan in die som natuurlijk vrij worden verschoven.
Array variabelen kunnen eerder links komen
of meer rechts staan of herhaald worden.
Tussen de kind arrays in een rij kunnen verstrooid getallen
pi voorkomen,
eerder uitgewerkt, die later pas bij de positie index
p0
van de ouder array arriveren en optellen.
Alleen de constante a en factoren
n hebben direkt een vaste plaats.
De bulk b en exponenten
p0 zijn hun duo met index
i=0 alvast ontstegen
en buiten de radix gerekend dus vloeibare getallen.
Aalscholver
Á.II
geneste arrays, in volgorde voor radix.
- Á.0. (a,b) ≡ (b) = b
- Á.1. ,(,S) ≡ 0
- Á.2. ,(p,) ≡ p
- Á.3. (a, ,(1n,1S)
`= ,(a,S),(n,1S)
Vanouds elimineert regel 1
de afgetelde elementen en regel 2
de lege array die ba optelt.
Nul indexen (p,0,
slaan we over tot regel 3
een subarray (p,,(a,)
introduceert, die tot (p,a reduceert.
Later in de evaluatie, links van
,(n,1, in de ouder rij
keert ,(a,,
terug en is de cyclus rond. Daarin hebben alleen tellers
p=a
een nul index.
Elke diepste rij zouden we
,(c.,di..)
met komma separatoren kunnen noteren.
En met alleen cijfers van 0 tot a-
is in een l-r radix expressie
+(c,.di..)
:k
alleen de eerste sep nodig.
Dat wordt in exponentiële notatie
cE..di
met k: decimalen
di andersom.
In het algemeen tellen geneste rijen op als dubbele exponenten
in de exponent van de ouder array.
- ,(c,d0.,(di,Si)..) :k
- = c*a^(a,d0.
,(di,Si)..) :k
- = c*a^(d0.+
di*a^(a,Si)..) :k
Precies als in
§2.4
groeien Aalscholver nesten uit tot macht ^
torens met tetratie ^^ verdiepingen.
- ,(1,,(1,,(1,1))) :=
,(1,,(1,,1)) = ,(1,,(1,a))
= ,(1,a^a) = a^^3
- (a,.,(1,..).) :m1:
= (a,.,(1,..1..).) :m:
= a^..1 :m = a^^m
Deze superradix expressies drukken de natuurlijke getallen uniek uit,
als elke variabele
0<p<a
en de nest diepte onbegrensd is.
Dat is tot onze diepen
uitbreiding de nest grens bij
m1=a legt.
Als we de inerte komma uit de basis
(a
verwijderen, dan verandert de Aalscholver superradix
in een andere vorm van Wielewaal.
Of dat simpeler is laten we aan de lezer over…
Gaan we verder met onze vergelijking van Vogel en Wiel.
Na een langzame start evenaarde de 2e nest rij van Wiel
de 1e rij van Vogel = Bird's lineaire array,
zie
§3.1.
Daarna kwam Wiel's 3e nest rij overeen met de lengtes
(herhaling van sep dimensies) van de Vogel matrix
≈ Bird's multi-dimensionale arrays,
bewezen in
§3.2.
De regels voor geneste arrays in Wiel
W.II
zijn zo simpel mogelijk,
maar voor gelijke output moeten we dubbel zo diep nesten als Vogel.
We denken dat de nieuwe array niveau's zich net zo verhouden
als deze eerdere niveau's. Dan rolt Wielewaal over oneven niveau's
de indexen uit, die posities in Bird's ruimtes representeren.
En volgt daaruit de algemene vergelijking van geneste arrays
in Wielewaal versus Vogel en Bird.
Wiel begon twee niveau's dieper met Vogel's eerste index.
De verdere tellers op de Wiel's 4e nest rij benaderen nu
Vogel's 2e niveau ≈ Bird's hyper-dimensies.
En op Wiel's 5e nest rij zullen we de herhalingen
van die separator arrays vinden:
de maten van Bird's subruimtes.
- [a,[,[,[,1]1]1]1]
= a[,[,[,[a-]a]1]1]
~> v[,[1,[1,[a-]a-]v]v]
≈ (v,v.,[a]1..,2) :a
≈ V(v,a,[a1]a)
- [a,[1,[1,[1,1]1]1]1]
= a[,[,[,[1,1]1]a]a]
= a[,[,[,[a]a]a]a]
≈ (v,a,[a2]a)
≈ V(a,a,[1,2]1,2)
- [a,[,[,[1,1]2]1]1]
= a[,[,[,[a]a,["]1]1]1]
≈ V(a,a,[1,2]1,[1,2]1,2)
- [a,[,[,[2,1]1]1]1]
= a[,[,[,[1,1]a]1]1]
≈ V(a,a,[2,2]1,2)
- [a,[,[1,[1,2]1]1]1]
= a[,[,[,[a,1]a]a]1]
=: a[,[,[1,[a1,1]1]1]1]
≈ V(a,a,[,3]1,2)
- [a,[,[k,[p,1]n]e]1]
≈ V(a,a.,[p,2]1.. :n
,1..e) :k
<!-->
In het algemeen kunnen we elementen
,[,[S]T]e
vervangen <≈ door
,[1,[S]T]1
of een tel bij zo'n volgende element.
Daarbij wordt de teller e
insignificant door de groeibel op te laden.
Denkwerk in uitvoering
Op de eerste rij in Wielewaal staan seps met een index
voor de teller positie.
Deze breiden we uit tot index arrays die rijen in rijen nesten,
en daarna tot diepen die over hun nest diepte itereren.
In een tellerij groeit de bel door optellen.
Ook krijgen alle teller posities unieke indexen
en tellen we iteraties af tot 0.
Vanuit hoger perspectief bezien kan
het direkt substitueren van een top array (grootste structuur)
in een getal (kleinste structuur)
nooit meer opleveren dan een extra index array niveau.
Dat komt omdat de separator indexering
in tellerij en telraam systemen
dezelfde array vorm krijgt als de hele expressie.
Tellerijen beginnen met achterstand,
omdat hun regel voor de basis bel zo primitief
is.
Zodra we tellers voorzien van een minus -
kopie van de volgende aftelbare subarray,
dan wordt de expressie even snel als met nesten van
$ subexpressies
(allebei rij in rij
).
Met het vullen van een vlak
haalt Wielewaal's derde index Conway's pijlketens in.
Met Vogel en Bird's arrays komen we later gelijk,
door over de diepte van geneste index arrays te itereren.
Als we overgaan tot post-indexering na a
en de bel beschouwen als de eerste index array,
dan hebben we voor een Vogel-achtig algoritme
geen functie haakjes meer nodig.
Dan worden subexpressies uitgedrukt met de eerste geneste array.
Dus 1 nest niveau is gelijk aan
1 positie die in rijen genest wordt.
Vanuit hoger perspectief bezien moet het direkt substitueren
van expressies (grootste structuur) in tellers (kleinste structuur)
wel even sterk zijn als één niveau van geneste arrays.
Omdat eigenlijk alleen het top niveau wordt toegevoegd.
Nooit meer dan 1 niveau,
mits de expressie en subarrays dezelfde capaciteit hebben.
Door de groeibel te substitueren op alle niveau's,
geldt dit verband niet alleen voor de eerste rij,
maar draagt over naar elk niveau.
Toch is dit vreemd,
aangezien voor subarrays hele andere introductie regels
W.3.
gelden (links toevoegen), dan hoe regel
V.4.
in Vogel subexpressies nest (binnen vervangen).
Om dit te verhelderen, stel dat we Vogel vertalen naar een structuur,
met post-indexering na a
en waar de eerste index array bel b bevat.
Hierin worden subexpressies genest als arrays met een eigen basis.
Functie haakjes () zijn in dit systeem overbodig.
Hoe het algoritme precies werkt doet er nu niet toe,
duidelijk is dat we Vogel expressies
naar deze post-index vorm kunnen omzetten.
Nesten van $
subexpressies (functie substitutie) is 1 niveau waard,
want Vogel rij en Wielewaal index rij liepen gelijk.
Dan heeft ook elk rij element,
dat we recursief verdiepen (matroesjka poppenspel),
de waarde van 1 nest niveau.
Array lengte en rij in rij
diepte worden vergelijkbare grootheden.
Bird's volledige eliminatie van elementen is een luxe constructie.
Vogel V
heeft minder regels en laat elementen tussenin met teller
1 gewoon staan.
Het cumulatieve effect van de oude reeksen op de uitkomst
is insignificant, maar de chaos
in Vogel expressies neemt toe.
In
Bellenblazer
en Wielewaal W
heeft elke teller een positie index
en vallen de afgetelde elementen weg.
Geneste arrays zijn twee keer zo diep
om even grote getallen te maken als Vogel.
Bellenblazer regels worden moeilijker bij dieper nesten.
Wielewaal blijft makkelijk van opzet,
hoewel deze chaotisch
begint met dubbelen,
wat afwijkt van natuurlijk a*b herhalen.
Zulke concepten zijn op wonderlijke wijze uitwisselbaar…!
