Friday, 6 April 2018

Supertrio

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

§3. Dieper

In de vorige serie blogs §2 ontwikkelden we een plan voor het maken van grote getallen. Onze nieuwe blogs bouwen we van de grond de diepte in, met geneste arrays en het diepen zelf, in Giga Gerard’s
„Reuzen Getallen Bouwerij”.
Iedere array kan uitgebreid worden tot een diep. Wat de bouwmeester diepen noemt is een serie van geneste arrays [Xi].. die elkaars nest diepte recursief expanderen.
Nadat een index array [][1X] is leeggeteld, blazen de tellers in de diepe array erna het aantal geneste niveau's ervoor recursief op.
Met diepen na de top array geven we een type index getallen aan, met name de groter eindige ψi limieten of hoger oneindige ωi.

Ons Vogel systeem is een simpele benadering van de array notaties van Chris Bird.0 Omdat dit Vogel telraam gelijk op gaat met Bird en goed vergelijkbaar is met de Wielewaal, zal er uiteindelijk een nieuw wereldrecord getal voorbij ons glas Guinness komen vliegen.
Als de evaluatie van een expressie wel in theorie uitvoerbaar is, maar fysiek gezien liever niet, dan heet de uitkomst ervan groot. Al deze arrays geven als uitkomst reusachtig grote getallen.

Lectori salutem Dudeldjo en anders niet.

§3.0 Supertrio

Natuurlijke getallen schrijven we met het teken 1 als een serie enen 1.. en variabelen a en b tellen direkt op als ab.
De unaire 1 is eenheid van getal en het minus teken - eenheid van aftelling. Zo komt 1-=0 leeg en getallen n1 nemen af - tot n.
Dit is onze unit notatie voor getallen. Dan staat 2 voor 11, teken 3 voor 111, de 4 voor 1111, enzovoort.
Grotere getallen in het tientallig stelsel schrijven we liever 108. met decimale punt. Bird's arrays zijn omgeven door krulhaken {Y} en we tellen er nog schools in op +1 en af -1.

Reeksen binnen expressies noteren we met repex zo:
Met ^{n} herhalen we het ^ macht teken n keer, wat trouwens gelijk is aan *{n1} bij supersterren.
Met punten selecteren we een .groep.. tekens en de rep herhaalt die groep :n aantal keer op zijn plaats. Tijdens deze repetitie nemen de indexen i of j naar rechts toe van 1 tot n. Ook zijn er tweezijdige reps :n: en reps n: die incrementeren naar links. Het wijst zichzelf.

In dit blog bouwen we een Wielewaal systeem, waar de variabele a substitueert in een Aasblazer superradix structuur. We verdubbelen onze aasbel en schuiven een kopie ervan naar rechts om lege ,0 tellers ,a op te laden. In ruil telt deze evaluatie - een hogere teller af. Zo lossen we de hele functie rij op, terwijl laatste ,] posities afvallen en de bel naar de uitkomst toe groeit.
Zo'n array systeem waar een basis variabele door primitief optellen, de lege *{0} operatie, groeit en tellers rechts in de rij substitueert, noemen we een tellerij [number array]. Getal bij getal.

Knuth's pijl operaties a^{c}b gingen sneller van start. Ook bij Bird en Vogel hebben supermachten maar drie {a,b,c} parameters. Samen zijn aas a, bel b en super c de tellers van het supertrio.
Deze compacte structuur heeft maximale output, omdat het systeem met elke superstap c-1 een subexpressie nest in plaats van de bel. Die $ is een kopie van de expressie met een stap b-1 minder.
Een array systeem waar een variabele door functie substitutie groeit en deze groeibel de lege tellers van alle hogere iteraties oplaadt, noemen we een telraam (function array). Raam $ in raam.

Vermenigvuldiging * is de eerste herhaling. Het is jammer dat Bird, net als Knuth en Conway trouwens, met machtsverheffen ^ begint. Natuurlijker is om met drie parameters V(a,b,c) de supersterren a*{c}b = a^{c-}b weer te geven, zoals we in Vogel doen.

Vogel trio definitie V.O.

  • V.0. (a) = a
  • V.1a. (a,1) = (a) V.1b. (a,b1) = (a,b)a
  • V.2. (a,b,1) = (a,b)
  • V.3. (a,1,c) = a
  • V.4. (a,b1,c1) = (a,(a,b,c),c1)

Alle variabelen zijn unaire getallen 1.. :n>0 want in Vogel staan tellers in de top array nooit leeg. Deze voorwaarde moet duidelijk maken, welke regel(s) van toepassing zijn op de expressie.

Op het demonstratiebord hieronder evalueren we het Vogel trio tot de supermachten, zoals van Knuth en Bird.
Klik op dit dynamische bord <!--> om extra voorbeelden te tonen, of toets Ctrl-U en bekijk deze in de pagina bron.

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

Misschien kon Hilbert in 1925 nog niet zonder functie indexen voor zijn hoger recursieve functies; in het bewijs van Ackermann uit 1928 werd de voorganger expressie zonder omweg genest.
Van hun parameter trio bleven in Péter's functie de twee tellers over, waarbij de constante a=2 impliciet gegeven is (met wat extra).

Het lijkt spectaculair om functies zo'n snelle start te geven, maar vanuit het oogpunt van geneste arrays maakt het weinig uit (slechts één nest niveau, blijkt later). Als we over een rij tellers de supermachten bouwen en bel b naar rechts opladen (tellerij), dan hoeven we geen subexpressies te nesten (telraam).

In de box waarderen we met het opladen van aas a de array structuur en met het opladen van bel b de systeem regels. Of deze traagste structuur en dit snelste algoritme ooit bij benadering samenvallen (convergeren, zoals geneste arrays met óf zonder subexpressie recursie dat later doen) is nog onduidelijk…

# Blazers 3.0

Binnen een rij structuur (zonder lengte limiet) laden we lege tellers op met een constante a. Zulke expressies noteren elk getal in radix a.

Definitie À.I van de Aasgier rij.

  • À.0. a[b] = b
  • À.1. a[R,] = a[R]
  • À.2. a[b,1R] = a[ab,R]
  • À.3. a[b,{n1}1R] = a[b,{n}a,R]

In de komma array is bij natuurlijke getallen regel À.2. voor optellen een geval {n=0} van regel À.3. voor opladen. Maar bij series van Cantor's oneindige getallen a=ω is omkeren ergens wel nodig.
De rij expressie stopt, wanneer we gaan nesten na a[,{a}1]- wat decimaal het getal 9999999999. oplevert.

Dit Aasgier systeem kunnen we met geneste arrays uitbreiden tot een tetratie superradix, als bij Aasblazer nesten. De Aasgier notatie verschilt, als we indexen in onderste rijen scheiden met komma's.
Aas a is een radix 10 naar keuze. Dit systeem evalueert als een superradix, waarbij alle rij lengtes en tellers 0pa zijn. En als in de input 0<p<a geldt, dan geven geneste arrays (zonder diepte limiet) alle natuurlijke getallen uniek weer.

Met geneste superradix arrays drukken we een getal uit, dat niet eens een macht van a groter is dan de lengte van de tellers in de top array, mits alle lege tellers erbij staan. Min alle index arrays is de expressie lengte nog een factor kleiner en bovendien wordt die ene exponent steeds insignificanter.
Diep genest en met komma's (nullen) is Aasgier bij benadering een minimaal algoritme (net als unaire notatie) en geeft dus een maat voor pure structuur zonder de regels.


In Bellenblazer telt de primitieve stap aas a op bij bel b, maar over de lengte van de rij worden er supermachten uitgedrukt. We positioneren met unieke indexen en substitueren subtotalen b.
Stel dat we ook in Bellenblazer tellers tot p=0 aftellen, maar toch dezelfde input en output willen schrijven, dan moet de oplaadregel worden aangepast.

Definitie Buizerd rij functie B.I met komma's.

Opladen in Buizerd zouden we op allerlei manieren kunnen variëren: groot, groter, grootst. En toch is dit niet significant voor de uitkomst.

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

Deze oplaadregels produceren steeds minder natuurlijke output. En ondanks de minieme versnellingen blijven ze bijna een ^ supermacht achter lopen bij ons Wielewaal systeem. Waar precies de verschillen insignificant worden is lastig om uit te vogelen…!

We zullen Vogel en Bird nu vergelijken met een nieuwe array functie, die we noemen naar de illustere trekvogel uit een zomers lied. Onze Wielewaal tellerij dupliceert getallen en verschuift ze.
De primitieve functie van Wielewaal is kopiëren en optellen. Tel een kopie op en het getal a verdubbelt tot aa. Herhaal dit c keer en het totaal a*2^c groeit exponentieel.

Na deze machtige start noteren de tellers rechts in de rij nog hogere iteraties of vormen van herhaling. En we schuiven subtotaal a door naar rechts om lege tellers opnieuw op te laden.
Zo leest de lengte van de eerste rij als de superexponent ^{r} van de uitkomst van de expressie. We maken supergrote getallen, ongeveer (maar niet exact) die van Knuth's pijlen.

Definitie Wielewaal rij functie W.I.

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

Elke iteratie stap telt 1 af en we gaan door tot de teller 0 is. Zolang parameters geen positie index krijgen, moeten we de komma's ,, voor hun lege pi=0 plekken laten staan.

De Wielewaal functie gaat snel van start door ab (tegelijk aas en bel) te verdubbelen. Door dat te herhalen domineert de macht 2^c de uitkomst, maar daarna vlakt dit voordeel af. Zonder subexpressie nesten blijft de hele rij achter bij die van Vogel.
Klik op de borden <!--> voor uitwerkingen met concrete getallen.

  • a[1b] = a1[b] == ab1[] = ab1
  • a[b,1] = ab[,1] = ab[ab] = ab*2 = V(ab,2)
  • a[b,1c] = ab*2[,c] = ab.*2.. :c1 = ab*2^c1
  • a[,,1] = a[,a] = a*2^a ≈> V(2,a1,2) {a>1}
  • a[b,c,1] = ab*2^c[,,1] ≈> 2^c1[,ab*2^c] = 2^(c1+ab*2^c) ≈> V(abc,2,3) <!-->

De linker expressie is ongeveer groter dan ≈> de rechter expressie, als de linker output een vrij goede benadering geeft en groter is voor niet te kleine input waarden.

Voor waardes a=b=c=1 in de vergelijking hierboven gaat dat al op, want 2^5 > 3^^2 brengt ons over het kantelpunt heen. Hier luistert de 2^2^6 > 3^^3 minder nauw, maar hoger in de machtstoren zal 2^^d\^6 > 3^^d1 die verhouding in stand houden.

  • a[b,c,2] ≈> 2^(c1+ab*2^c)[,,1] ≈> 2^2^(c1+ab*2^c) ≈> V(abc,3,3)
  • a[b,c,d] ≈> 2^^d\^(c1+ab*2^c) ≈> V(abc,d1,3)
  • a[,,,1] = a[,,a] = a*2^a[,,a-] ≈> 2^^a\^a1 {a>1} ≈> V(a1,a,3) <!-->

Met drie tellers bouwt Wielewaal een toren van exponenten. Dit vormt na + * ^ de nieuwe operatie ^^ van tetratie.

Als a wat kleiner is maakt dat op deze schaal, waar het basis 2 logaritme van a optelt bij de hoogste exponent, bijkant niets uit.
We noteren Wiel nu in pure array vorm.

  • [a,b,c,1] ≈> 2^^c\^(a*2^b)[,,,1] ≈> 2^^2^^c\^(a*2^b) ≈> V(ab,(ab,c1,3),3)
  • [a,b,c,d] ≈> 2^^^d1\^^c\^(a*2^b) ≈> 2^^^d1\^^c1\^b1 ≈> V(abc,d1,4)
  • [a,,,,1] = a[,,a,a-] ≈> 2^^a\^a[,,,a-] ≈> 2^^^a\^^a1 {a>1} > V(a,a,4)
  • [a,b,c,d,e] ≈> abc^^^^e1\^^^d ≈> V(abcd,e1,5)
  • [a,{r1}1] = a[,{r}a] ≈> 2^{r}a\*{r}a > V(a,a,r1) <!-->

Zo bestrijkt onze Wielewaal tellerij W.I in de hele eerste rij de supermachten. Terwijl het Vogel V.O telraam volstaat met drie parameters. Net als Bird en Conway's pijlketens trouwens.

  • [a.,pi..] :r ≈> 2..^{i}pi1\. +Log(a/2) r: ≈> V(a.pi..,pr1,r1) :r- > apprr

De supersnelle bel b van Vogel en Bird komt niet gratis. Die recursie nest subexpressies, wat telbare haakjes kost / kostbare haakjes telt. Extra tekens om expressies (.. in de bel ..) te openen en sluiten, naast haakjes voor de separator [ arrays ] dus.
Bij Wiel regels zijn geen ronde functie haakjes nodig. We hoeven er alleen te voorzien in arrays.

In de box zagen we Buizerd functies de bel omhoog blazen. Zo krijgen we vrijwel even grote getallen als Wielewaal, omdat alleen de basisregel verschilt. Door superoperatoren ^.. te tellen vangen we een glimp van de onvoorstelbare grootte ervan.
Zouden er nog andere methoden zijn dan bel b opladen om zulke supergrote getallen te bouwen over een rij…?

Bird's Universum

Input expressies en daarmee uitgedrukte getallen zijn exact gelijk aan die van Chris Bird.0 Maar onze array regels, die expressies stap na stap herschrijven, zijn bondiger dan in de originele systemen.
Sommige regels voegen we samen en de overbodige vervallen. De lijst volgorde bepaalt weer welke regel we toepassen, maar is anders dan bij de regels van Bird.

Supermacht functie U.O in drie tellers: constante a, macht b en supers c. Bird drukt met twee tellers meteen al machten a^b uit.

  • 0.0. {a} = a
  • 0.1. {a,b1} = {a,b}.. :a == a^b1
  • 0.2a. {a,1} = a 0.2b. {a,b,1} = {a,b}
  • 0.3. {a,1,c} = a
  • 0.4. {a,b1,c1} = {a,{a,b,c1},c} == a^{c1}b1

Voor de Main rules nummering van Bird: zie de muis_over titels.
Regels die hetzelfde blijven linken we naar hun eerdere definitie.

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.
Bouwwerken van de Lilliputters die Gulliver zijn maaltijd serveren
CALL App.show(UL, className[])
SET tC.App.Tags

No comments:

Post a Comment