Reuzen Getallen Bouwerij

bij Giga Gerard

“Kom mee naar buiten allemaal,
Dan zoeken wij de wielewaal.
En horen wij die muzikant
Dan is zomer weer in 't land!”

Canon

X

§3. Diepen

In het vorige hoofdstuk §2 ontwikkelden we ons plan voor het maken van grote getallen. De komende serie blogs bouwen we van de grond af op, tot we uitkomen bij de diepe arrays die voorbij geneste arrays liggen. Eerste deel van:

Giga Gerard's:
„Reuzen Getallen Bouwerij”.

Diepen zijn aan elkaar gebouwde arrays [Xi]..
Van elke diepe index array wordt de nest diepte opnieuw bepaald, als deze [0][1Xn1] leeg staat. In de volgende array tellen we de eerste index af en in ruil daarvoor groeit in [Xn] het aantal geneste array niveau's recursief.
Met diepen na de top array geven we andere typen getallen aan. Een indexering voor hoger eindige ψi of oneindige getallen ωi bij uitstek.

Lectori salutem Dudeldjo en anders niet.

X

§3.0 Supertrio

Dit blog introduceert het Wielewaal array systeem, met substitutie van een groeibel b binnen een superradix structuur. Dit begint primitief met het verdubbelen van getallen, waarmee we hogere iteraties opnieuw opladen. We zullen demonstreren dat de eerste array rij dan ongeveer gelijk is aan supermachten.

De functie voor supermachten heeft bij Ackermann, Bird en Conway slechts drie parameters: het supertrio a,b,c. Omdat zij (in navolging van Hilbert's functie substitutie) hele expressies nesten.
Wij staan eerst alleen het dupliceren en verschuiven van getallen toe, maar later ook het indexeren van eerdere posities. We halen Bird pas in, als we over de diepte van geneste index arrays itereren.

Onze arrays hebben als uitkomst een reusachtig groot natuurlijk getal. Zo groot, dat de complete evaluatie ervan alleen in theorie, maar praktisch niet uitvoerbaar is.
Vogel arrays vormen onze simplistische benadering van de arrays van Chris Bird. 0 Als we deze Vogels gelijk op laten vliegen met Bird, en Wielewaal vergelijken met Vogel, dan vinden we uiteindelijk toch een elegant wereldrecord getal.

Natuurlijke getallen noteren we met het teken 1 als een serie enen 1.. en we tellen zulke variabelen a en b direkt op als ab.
Als 1 de positieve eenheid is, is het min teken - de negatieve eenheid. Zo wordt 1-=0 leeg en een getal n1 telt - af tot n.
In dit unaire systeem staat 2 voor 11, de 3 voor 111, enzovoort.

We gebruiken macro's om reeksen eenvoudig te noteren.
Bijvoorbeeld ^{n} herhaalt het macht teken links n keer.
Punten selecteren een woord .groep.. en de rep :n herhaalt deze dat aantal keer op die plaats in de expressie.
Indexen i of j incrementeren we tijdens een repetitie vanaf 1. Ook verschijnen er dubbelzijdige :n: reps. Dat wijst zichzelf.

Vogel rij definitie V.I voor de eerste rij, waarvan we de expressies zullen vergelijken met Bird's lineaire array 1.

  • V.0. (a) = a
  • V.1. (a,b1) = a(a,b)
  • V.2. (R,1) = (R)
  • V.3. (a,1,R) = a
  • V.4. (a,b,.1,..11R) :n1 = (a,a,.1,..b,1R) :n
  • V.5. (a,b1,1R) = (a,(a,b,1R),R)

Als een eerdere regel uit de lijst een match vormt met de expressie (of subexpressie), krijgt deze = voorrang in de evaluatie.
De R staat voor de rest van de array, hier een rij van recursies met tellers of parameters pi>0.

We vergelijken deze Vogels precies met Bird's lineaire array. In zijn krulhaak arrays {R} tellen we schools op +1 en af -1.

  • V(a,b) == a.. :b = a*b
  • (a,b1,2) = (a,(a,b,2)) == (a,..a..) :b: = a*..a :b = a^b1 = {a,b+1}
  • (a,b1,1c) = (a,(a,b,1c),c) == (a,..a..,c) :b: = a*{c}(..a..) :b: = a^{c}b {c>0} = {a,b,c}
  • (a,2,2,2) = (a,a,a) ≈> {a-1,2,1,2}
  • (a,3,2,2) = (a,a,(a,a,a)) ≈> {a-1,3,1,2}
  • (a,b1,2,2) = (a,a,(a,b,2,2)) ≈> {a-1,b+1,1,2} <!-->

Door bij superexponent de c een 1 op te tellen, ondervangt men in Vogel zowel de begin achterstand, als met regel V.5. het nesten van subexpressies in hogere parameters van Bird. Zo kunnen we b simpel opladen met regel V.4. en zijn bijna gelijk op de rij.
Omdat bij b=2 de begin a verhuist naar plek c hogen we a1 ook op. Dit geeft een array benadering ≈> waar Vogel net wat groter is.

  • V(a1,2,3,2) = (a1,a1,2,2) ≈> {a,2,2,2} = {a,a,1,2}
  • (a1,3,3,2) = (a1,(a1,2,3,2),2,2) ≈> {a,3,2,2}
  • (a1,b,3,2) ≈> {a,b,2,2}
  • (a1,2,2,3) = (a1,a1,a1,2) ≈> {a,2,1,3} = {a,a,a,2}
  • (a1,b,1c,d) ≈> {a,b,c,d}
  • (a1,2,2,1,2) ≈> {a,2,1,1,2}
  • (a1,3,2,1,1,2) ≈> {a,3,1,1,1,2}
  • (a1,b1,2.,1..,p) :n ≈> {a,b1.,1..,p} :n1 <!-->

Het Vogel systeem met zijn kleinere stappen geeft (na aanpassing van waarden a+1 en c+1) een verrassend goede benadering voor dat van Bird op de lineaire array.

  • V(a1,b,1R) ≈> {a,b,R}

We zullen Vogel en Bird hieronder vergelijken met een aangepaste bellenblazer array functie die we Wielewaal noemen, naar de vogel uit een bekende zomerse samenzang.
Dit systeem gaat snel van start door ab (aas en bel tegelijk) te verdubbelen, maar verder over de eerste rij blijft het (zonder functie substitutie) relatief achter.

Definitie Wielewaal rij functie W.I.

  • W.0. a[] = a
  • W.1. a[1R] = a1[R]
  • W.2. a[R,] = a[R]
  • W.3. a[,{n1}1R] = a[,{n}a,R]

Hier tellen iteraties enen af, maar we gaan door tot de teller 0 leeg is. Zolang posities van tellers of parameters pi0 geen index krijgen, moeten voorgaande komma's ,, op hun plek blijven staan.
Onderaan bij Beo laten we nog meer functies zien die bellen omhoog blazen. Maar omdat alleen de beginregel verschilt, leveren deze array functies gelijksoortige getallen. Via het aantal super ^.. operatoren krijgen we een glimp van de grootte van deze onvoorstelbaar grote getallen. Vogel functie V.I gaat nog veel sneller op de eerste rij.

Tel b op bij a buiten de array. Kopieer deze som met een stap van teller c en laadt de kopie in beller b. Dit geeft een recursie, waar de macht en factor 2^c de uitkomst domineert.

  • a[1b] = a1[b] == ab1[] = ab1
  • a[b,1] = ab[,1] = ab[ab] = abab = ab*2 = V(ab,2)
  • a[b,1c] = abab[,c] = ab.*2.. :c1 = ab*2^c1 = V(ab,(2,c1,2))
  • a[b,c,1] = ab*2^c[,,1] ≈> 2^c[,ab*2^c] ≈> 2^(ab*2^c) ≈> V(ab,(2,c,2),2)

In drie tellers drukt Wielewaal een toren van d exponenten uit. Dit vormt de vierde operatie na + * ^ en ^^d heet tetratie.

  • a[b,c,2] ≈> 2^(ab*2^c)[,,1] ≈> 2^(ab*2^(ab*2^c)) ≈> V(abc,(abc,abc,2),2)
  • a[b,c,3] ≈> ab*2^(..c..) :3: ≈> abc^^4 = V(abc,4,3)
  • a[b,c,d] ≈> abc^^d1 = V(abc,d1,3)
  • a[b,c,d,1] ≈> abc^^d1[,,,1] ≈> abc^^abc^^d1 ≈> V(abcd,2,4)

We passen onze standaard expressies in Wielewaal aan, door te stellen dat a=0 want de helft b is genoeg.

  • [b,c,d,e] ≈> bc^^..d1 :e1 = bc^^^e1\^^d1 ≈> V(bcd,e1,4)
  • [b,c,d,e,f] ≈> bcd^^^^f1\^^^e1 ≈> bcde^^^^f1 = V(bcde,f1,5)
  • [.pi,..q] :r ≈> pi..^{r}q1 :r > V(pr,q1,1r) > pqr ≈ {q,2,r+1}

Zo drukt deze bellenblazer met de hele eerste rij W.I supermachten uit, waar bij Vogel en Bird het supertrio al voldoet.
Als we in deze structuur a opladen en b alleen optellen vormt zich op de eerste rij een radix functie. Getallen van de laatste array hier blijven daar onder de q1*a^r steken.

We zetten de Aasblazer functie rij om naar komma format in Aasgier, maar het blijft dezelfde super radix. Van de lineaire arrays A.I verschillen alleen de eerste regels met W.I. Aas a die we substitueren is een constante: een radix 10 naar keuze.

Als super radix opgevat, waar alle lengtes en tellers p<a in de input expressie, vinden alle natuurlijke getallen in Aasgier uniek uitdrukking. Het maximum op rij is dan a[,{a}1]- of in radix a=10 decimalen 9999999999.

Om tellers helemaal p=0 af te tellen, en toch dezelfde getallen te houden als Bellenblazer, passen we de oplaad regel aan. Maar de primitieve recursie blijft het optellen van aas en bel.
Definitie Beo arrays B.I op de komma rij.

Op dit opladen in Beo zijn ook weer varianten mogelijk, als volgt: groot, groter, grootst en toch bijna gelijk…

  • a[b,{n1}1R] <≈ a[a,{n}b,R]
  • <≈ a[b,{n>0}b,R]
  • <≈ a[ab,{n>0}b,R]

De ene regel komt wat natuurlijker over dan de andere. Expressies in Beo blijven ook met dit soort subtiele verbeteringen ongeveer een supermacht teken ^ achter bij de Wielewaal. Dat deze verschillen steeds insignificanter worden mag u zelf uitvogelen…!

X

§3.1 Eerste Rij

Ons Wielewaal array systeem verdubbelt weliswaar de bel die tellers opnieuw oplaadt, maar we zijn nog niet op snelheid. Met een aantal dimensies in een matrix drukken we hetzelfde uit, als de maximale arrays van Chris Bird 0 over de lengte van zijn eerste rij.
In dit blog krijgen alle tellers indexen en itereren we daar over met een geneste array rij. Onze complete indexering is natuurlijker dan Bird's repeterende array ruimtes. Hoewel we arrays dubbel zo diep moeten nesten voor hetzelfde resultaat, zie box 2.6.

We herladen afgetelde iteraties met een kopie van b, maar anders dan in de geneste arrays van Bellenblazer blijft de originele bel staan. Zo kunnen we garanderen, dat het getal voor substitutie maximaal blijft. Wat niet triviaal is gezien de nogal bewerkelijke cascade bij het herladen van geneste arrays.
Bellenblazer en de Beo varianten, die we eind §3.0 zagen, zijn maar een beetje (insignificant) kleiner. De uitgedrukte getallen zijn daarbij in aanvang natuurlijker, maar we maken het formuleren van nieuwe regels liever wat makkelijker.

Definitie Wielewaal nest functie W.II.

  • W.0. a[] = a
  • W.1. a[1R] = a1[R]
  • W.2. ,[S]00
  • W.3. ,[]0
  • W.4. ,[1S]1 `= ,[S]a,[1S]

Regels met `= zoeken vanaf links in de expressie een match. Hier staat variabele a voor het buiten de array verzamelde subtotaal. Waarbij b=0, omdat regel W.3. eerder l-r van toepassing is.

Met twee hulpregels om de eerste rij in alle arrays ook in het lineaire format te kunnen noteren (geval n=0 werkt niet).

  • W.a. [,{n}1 := [,[n]1 {n>0} W.b. ,[m]1p,{n}1 := ,[m]1p,[mn]1

We willen deze arrays vergelijken met de geneste arrays van Bird 4 zoals versimpeld tot Vogel nesten V.II.
Drie Vogel parameters drukten de hele Wielewaal rij van W.I uit. Dus eerst moeten we de lineaire array van V.I nog inhalen.

  • [a,[,1]1] = a[,[a]1] := [a,{a}1] ≈> a^{a}2 = V(a,a,a)
  • [a,[1,1]1] = a[,[a]a] ≈> a^{a}a1 ≈> (a,a1,1,2)
  • [a,[2,1]1] = a[,[1,1]a] = a[,[a]a,[1,1]a-] ≈> a^{a}a1[,[1,1]a-] ≈> a^{..a..}a1 :a: ≈> (a,a,..a1..) :a: ≈> (a,a1,2,2)
  • [a,[3,1]1] = a[,[2,1]a] = a[,[']a,["]a-] ≈> (a,a1,2,2)[,["]a-] ≈> (a,..a1..,2,2) :a: ≈> (a,a1,3,2)
  • [a,[,2]1] = a[,[a,1]1] = a[,[']a,[a-,1]a-] ≈> (a,a1,a-,2)[,["]a-] ≈> V(a,a1,a,2) > {a,2,a,2} ≈ aaaa

De vergelijking van geneste arrays met Conway's pijlen, die na de definitie in §2.6 volgde, toont meer detail. Onder breiden we vier schakels vlug uit naar de hele a..1 pijlketen en dan naar de extensie van Conway's notatie met {a} Knuth superpijlen.
Soms := keren we de evaluatie richting even om.

  • [a,[1,2]1] = a[,[a,1]a] := [a,[a1,1]1] ≈> V(a,a1,a1,2) ≈> (a,a1,1,3)
  • [a,[2,2]1] = a[,[1,2]a] = a[,[a,1]a,["]a-] ≈> (a,a1,1,3)[,["]a-] ≈> (a,..a1..,1,3) :a: ≈> (a,a1,2,3)
  • [a,[,3]1] = a[,[a,2]1] ≈> (a,a1,a,3)
  • [a,[1,3]1] := [a,[a1,2]1] ≈> (a,a1,1,4)
  • [a,[2,3]1] = a[,[1,3]a] = a[,[']a,["]a-] ≈> (a,a1,1,4)[,["]a-] ≈> (a,a1,2,4)
  • [a,[,,1]1] = a[,[,a]1] ≈> V(a,a1,a,a) > {a,2,a,a} ≈ a..a :a1

De tweede index (in een systeem met indexen voor alle tellers) deelt een matrix van twee dimensies in. Hier is het Wielewaal vlak.
Vogel is pas bij de vierde parameter. Indexering speelt in dit systeem nog geen rol, want de recursie die afgetelde expressies nest is supermachtig. De rest van de Vogel rij komt nu om de hoek kijken.

  • [a,[1,,1]1] = a[,[,a]a] := [a,[1,a]1] ≈> V(a,a1,1,1,2)
  • [a,[,1,1]1] = a[,[a,,1]1] ≈> (a,a1,a,1,2)
  • [a,[1,1,1]1] = a[,[a,,1]a] ≈> (a,a1,1,2,2)
  • [a,[,2,1]1] = a[,[a,1,1]1] ≈> (a,a1,a,2,2)
  • [a,[,[2]2]1] = a[,[,a,1]1] ≈> (a,a1,a,a,2)
  • [a,[,[3]1]1] = a[,[,,a]1] ≈> (a,a1,a,a,a) > {a,2,a,a,a}
  • [a,[,[4]1]1] ≈> (a,a1,a,a,a,a)
  • [a,[,[,1]1]1] = [a,[,[a]1]1] ≈> V(a,a1.,a..) :a ≈ a{a}2

Dit is de multidimensionale Wielewaal matrix, waarvan de dimensies [d1] bij het Bellenblazer systeem werden bereikt in §2.7.
Daar zagen we hoe elke dimensie een nieuw type recursie toevoegt: van de dubbele recursie van Knuth's pijlen, naar de triple recursie van Conway's pijlketen en dan per dimensie een superpijl van Knuth om de vorige type recursieve functie rij mee te verlengen.

Ook Bellenblazer heeft compleet geïndexeerde arrays en substitueert subtotalen. Afgezien van de begin 1, zijn bij gelijke arrays de output getallen ongeveer gelijk, want de regel voor het herladen van tellers is dominant. Geef daar 1 tel van terug en bel b komt weer op peil. De verschillen, ook met de Beo varianten die tot 0 aftellen, worden almaar insignificanter.

De geneste arrays van Aasblazer ofwel Aasgier laden een constante op. Momenteel schrijft matrix niveau a[,[,[,1]1]1] als super radix tot de 10^10^10 in decimalen. Een astronomisch getal, maar ordes kleiner dan systemen die bellen blazen of expressies nesten. Bedenk eens, hoe weinig van zulke getallen ooit uniek geschreven worden…!

X

§3.2 Matrix

Vergeleken met de massieve evaluatie bij Bird, die alle voorgaande structuren exact verlengt (met b) en compleet invult (met a), is de stapsgewijze opbouw per element van Vogel aanzienlijk simpeler.
Bird's systeem is iets krachtiger, maar met een eerste teller 1, extra op de rechter rij doet een Vogel expressie er niet voor onder.

Definieer Vogel V.II voor Bird's multi-dimensionale array 2. Alle variabelen zijn positieve gehele getallen, dus n>0.

  • V.a. , ≡ ,[1]
  • V.0. (a) = a
  • V.1. (a,b1) = a(a,b)
  • V.2. ,[n]1) ≡ )
  • V.3. (a,1,R) = a
  • V.4. (a,b ,[n]1,2 `= (a,a ,[n]b,1
  • V.5. (a,b1,1R) = (a,(a,b,1R),R)
  • V.6. (a,b ,[1n]2 `= (a,a ,[n]b,[1n]1

Voor aankomst bij regel V.6. zijn expressies in de evaluatie trein %= uitgewerkt tot een serie elementen ,[n]1 met vele kleinere afgetelde elementen ertussen. Uitgaande van een hogere teller 2p zal die serie :p elementen tellen. De bel ,[n]b% die daarop volgt, overtreft de eerdere b. Toch is dit insignificant, minder dan 1 tel extra lengte.

  • (a,b,[1n]2p,R) %= (a,a,Sj=0.,[n]1,Sj.. ,[n]b%,[1n]1,R) :p Sj = ,[mi,j]1.. {mi,j<n}
  • < (a,a.,[n]1.. ,[n]b,[1n]1,R) :p1

Stel dat teller p2=b juist ervoor werd opgeladen. Laatste bel b% zal door regel V.5.

meteen over een serie ,[n]1.. naar rechts schuift. die weer 1 wordt. De hoge ,[n]a tellen we af tot 1, zodat de nieuwe dimensie n een lengte van b ruimtes overhoudt. Dezelfde verdeling als bij Bird. Maar ondergeschikte lengtes worden gevormd met bel a en zijn kleiner dan bij Bird.
Dus is b1 opladen naar de eerst hogere positie afdoende om Bird te overtreffen in dit kleinere Vogel algoritme. Maar de werkelijke Vogel bel b% komt tot stand via vele subexpressies, die zelf de verste teller bevatten, en is veel groter. Alle lagere lengtes van Bird worden ruim overtroffen.
Dat kost ons wel de eerste teller p, want Bird telt lengtes met b. Maar als we eenmaal opladen naar de eerste teller, is Vogel duidelijk groter. We geven de teller die rechts volgt op p gewoon 1 extra.

Regel V.6. vult de vorige dimensie n1 element na element aan, tot lengte p2 door de evaluatie trein wordt bereikt. Maar dat werkt alleen als regel V.2. de afgetelde ,[n]1 elementen op hun plek laat staan.
Omdat we geen elementen tussentijds opruimen, groeit het aantal indexen mi,j<n in kleinere dimensies, en zijn die lengtes niet meer praktisch te bepalen. Toch blijven deze cumulatieve lengtes slechts insignificant groter, omdat de laatst opgeladen bel b domineert.

Zo vallen alle problemen weg met de implementatie van regel V.2. voor afgetelde elementen bij Bird. Dit wordt lastiger, wanneer hij er de grootte van complexe index arrays voor moet vergelijken.

Merk op dat Vogel regel V.4. te herleiden is uit V.6. indien we aannemen dat index waarden n0 en: Ofwel woord 1,[0] vervalt en de juist opgeladen b blijft over, als in ons systeem. Ofwel de begin dimensie separator ,[0] is nul 0 en dan telt regel V.6. tot 1b op, zodat het systeem (al vanaf de lineaire array) wat groter uitpakt.
We doen dit nu niet. Het voldoet als Vogel een bruikbare versie van Bird's arrays is en beide systemen bewijsbaar gelijk op lopen.

We moeten dus tonen dat b% significant kleiner is dan het effect op b van een tel van p op dit punt bij Bird. Zodat zo'n stap groter is dan b opladen naar p in Vogel maar kleiner dan b% opladen.
Ook zullen we bewijzen, dat de lengtes van kleinere dimensies nooit groter worden dan bij een extra tel van p in Vogel het geval zou zijn, zonder dat het cumulatieve effect mee zou spelen.
Als dit uit de eerste vergelijkingen hieronder blijkt, dan zal dat voor latere expressies ook moeten gelden.

  • V(a,2,[2]2) = (a,a,2,[2]1) = (a,a,2) = a^a = {a,a}
  • (a,b,[2]2) = (a,a,b,[2]1) = (a,a,b) = (a,b,1,2)
  • (a,b.,1..,[2]2) :n = (a,a,.,1..,b) :n = (a,b,.,1..,2) :n1
  • (a,b1,2,[2]2) = (a,(a,b,2,[2]2),1,[2]2) == (a,..a..,1,[2]2) :b: == (a,..a..,1,1,2) :b: = (a,b1,2,1,2)
  • (a,b1,3,[2]2) == (a,..a..,2,[2]2) :b: = (a,b1,3,1,2)
  • (a,b,c,[2]2) = (a,b,c,1,2)
  • (a,b1,2,1,[2]2) == (a,..a..,1,1,[2]2) :b: = (a,b1,2,1,1,2)
  • (a,b1,3,1,[2]2) == (a,..a..,2,1,[2]2) :b: = (a,b1,3,1,1,2)
  • (a,b,1,2,[2]2) = (a,a,b,1,[2]2) = (a,b,1,2,1,2)
  • (a,b,c,2,[2]2) = (a,b,c,2,1,2)
  • (a,b,c,d,[2]2) = (a,b,c,d,1,2)
  • V(a.,pi..,[2]2) :n = (a,.,pi..,1,2) :n

  • V(a,b,[2]3) = (a,a,b,[2]2) = (a,a,b,1,2) = (a,b,1,2,2)
  • (a,b.,1..,[2]3) :n = (a,a,.,1..,b,[2]2) :n = (a,a,.,1..,b,1,2) :n = (a,b,.,1..,2,2) :n1
  • (a,b1,2,[2]3) == (a,..a..,1,[2]3) :b: == (a,a,1,..a..,[2]2) :b: == (a,a,1,..a..,1,2) :b: = (a,b1,2,1,2,2)
  • (a,b1,3,[2]3) == (a,..a..,2,[2]3) :b: = (a,b1,3,1,2,2)
  • (a,b,c,[2]3) = (a,b,c,1,2,2)
  • (a,b1,2,1,[2]3) == (a,..a..,1,1,[2]3) :b: == (a,..a..,1,1,1,2,2) :b: = (a,b1,2,1,1,2,2)
  • (a,b,c,d,[2]3) = (a,b,c,d,1,2,2)
  • (a,b,[2]4) = (a,a,b,[2]3) = (a,b,1,2,2,2)
  • (a,b.,1..,[2]4) :n = (a,a,.,1..,b,[2]3) :n = (a,b,.,1..,2,2,2) :n1
  • (a,b1,2,[2]4) == (a,..a..,1,[2]4) :b: == (a,a,1,..a..,[2]3) :b: == (a,a,1,..a..,1,2,2) :b: = (a,b1,2,1,2,2,2)
  • (a,b,c,[2]4) = (a,b,c,1,2,2,2)
  • V(a.,pi..,[2]q1) :n = (a,.,pi..,1.,2..) :n :q

  • V(a,b,[2]1,2) = (a,a,[2]b) = (a,a,1.,2..) :b- > {a,b+1[2]2}
  • (a,b1.,1..,[2]1,2) :n = (a,a,.,1..,[2]b1) :n = (a,a,.,1..,2..) :n1 :b ≈> (a,a,[2]bn)
  • (a,b1,2,[2]1,2) == (a,..a..,1,[2]1,2) :b: ≈> (a,a,[2]..a..) :b: > {a,b+1,2[2]2}
  • (a,b,c,[2]1,2) > {a,b,c[2]2}
  • (a,b1,[2]3,2) = (a,a,b1,[2]2,2) == (a,..1..,b,[2]1,2) :a: %= (a,a,1,[2]b%)
  • (a,b,[2]1,3) = (a,a,[2]b,2) ≈> (a.,2..,[2]1,2) :b > {a,b[2]3}
  • (a,b,[2]1,q) > {a,b[2]q}

V

  • ,[n]1,q < [n]q+1 < ,[n]1,1q

 

 

Onder Constructie

X

§3.3 Vogels => Hyper

Blog 3.3

 

Onder Constructie

X

§3.4 Vogels =>

Blog 3.4

 

Onder Constructie

X

§3.5

Blog 3.5

 

Onder Constructie

X

§3.6

Blog 3.6

 

Onder Constructie

0. Een systeem voor snel groeiende recursieve functies, dat de functies van Jonathan Bowers en anderen ver te boven gaat, in Christopher M. Bird Super Huge Numbers, een serie van 9 PDFs over Bird's arrays + 3 bijlagen, 2017.
1. Chris Bird, Linear Array Notation, 2012.
2. Chris Bird, Multi-Dimensional Array Notation, 2012.
3. Chris Bird, Hyper-Dimensional Array Notation, 2017.
4. Chris Bird, Nested Array Notation, 2012.

Bouwwerken van de Lilliputters die Gulliver zijn maaltijd serveren
CALL pubCom.app.show( UL, className[] )
SET tagCom.app.tags

Blogboek  index

  1. Tellen
  2. Rijen
  3. Diepen
    1. V. trio = W. rij
    2. V. rij = W. matrix
    3. V. matrix
    4. V. hyper
    5. 3.4
    6. 3.5
    7. 3.6

© 2018
Giga Gerard