Wednesday, 20 June 2018

Maxtrix

Link naar dit blog:
allergrootste.blogspot.nl/2018/06/maxtrix.html
edit jan.2019.

§3.2 Maxtrix

Een matrix is een dimensionale ruimte, waar op iedere gegeven punt positie een getal genoteerd staat. Maxtrix betitelt hier een maximale multi-dimensionale array, bijzonder die van Chris Bird.2
Dat een getal of teller zelf uit een rij enen 1.. bestaat, ter lengte :n van het getal, blijft buiten onze ruimtelijke beschouwing.

Zo vormt een rij tellers de eerste dimensie. Het snelste algoritme is daar Bird's lineaire array, die we in §3.1 in de Vogel toprij hebben omgezet.
De substitutie van $ subexpressies (dubbele recursie) in bel b en het daarmee opladen van afgetelde tellers levert de grootste getallen op. We noemen zulke maximale functie arrays telramen.

In een tellerij groeit bel b, die we over de rij en verdere dimensies schuiven, door unair ab optellen (primitieve recursie). Ons Wielewaal systeem is zo'n tellerij. En Wiel's output in meerdere dimensies vergeleken we met die van Vogel of Bird's telraam:
Supermachten op de 1e rij in Wielewaal met de 3e teller van Vogel. Wiel rijen in het 2e dimensie vlak met Vogel's 4e teller, net hoe Bird de rij pijlketens van Conway benaderde.
Etcetera, Wiel's dimensie d met Vogel's teller d2 in de toprij.

In dit blog evenaren de verdere matrix dimensies in Vogel de multi-dimensionale arrays van Bird. Beide algoritmes evalueren de input matrix tot maximale output. Alleen in hogere structuren kunnen we significant grotere getallen produceren.
Om ondanks de langzaam groeiende bel in Wielewaal even grote getallen uit te drukken, reizen we door de hyperdimensie. In die geneste ruimte leven positie indexen, die zelf arrays zijn.

Vogel matrix definitie V.II.

  • V.0. (a) = a
  • V.1. (a,1b) = a(a,b)
  • V.a. ,p ≡ ,[1]p
  • V.2. ,[n]1) ≡ )
  • V.3. (a,1,[n]Z) = a
  • V.4. (a,1b,1Z) = (a,(a,b,1Z),Z)
  • V.5a. ,[] `= 0 => V.5b. (a,b, 1,1p {p>0} `= (a,a, 1b,p
  • V.6. (a,b ,[1n]1p {p>0} `= (a,a ,[n]b,[1n]p

Woorden Z en tellers komen bij toepassing van deze regels nooit leeg te staan. En door gebruik van hulpregel V.5b. zal er geen array leeg [0] worden geteld, wat wel gebeurt bij Bird's hoekketens.
Of vertaal een komma , met regel V.a. naar de sep ,[1] om daar met regel V.6. een bel voor te plakken. En elimineer de lege ,[0]b met regel V.5a. wat de afgetelde 1 links bij b optelt.
Evalueren we die nieuwe teller 1b gaandeweg tot 1, zodat b iteraties plaatsvinden. Op de eerste rij zorgde dit er al voor, dat Vogel V.I in de pas bleef lopen met Bird.

Passen we matrix regel V.6. nogmaals toe dan vormt zich r-l een reeks (a,$,[i]a-.. :n- waar b pas in de $ subexpressie weer verschijnt. Na dubbele recursie tot ,[1]1 voegen we teller ,[1]b' toe aan het einde van de rij. Zo reduceren we ,[2]a om de eerste rij te expanderen. En de tweede expansie komt er een groeibel aantal elementen bij. Op deze wijze verovert b langzaam alle dimensies.
Zodat onder dimensie n1 een volle ruimte met p1 dimensies n zal ontstaan. Met in elk een reeks dimensies n- van rechts lengte b- (originele bel) en naar links toe recursief grotere bel lengtes.

Vogel's regels zijn simpel vergeleken met Bird's massieve evaluatie, waarbij hij structuren exact afmeet (met lengtes b) en ze compleet vult (met tellers a). Vogel voegt de nodige elementen stap voor stap toe, eerst een lengte a en later pas een lengte die b bevat. De afgetelde elementen tussenin worden overgeslagen en Vogel loopt met zijn lengtes steeds verder uit op Bird (hoewel dit insignificant is).
Het Vogel telraam blijft een bruikbare benadering van Bird's array functie U.II geven. Bird is iets krachtiger, maar als we aan het begin van de meest rechtse rij een extra teller 2, invoegen, hoeven Vogel expressies nooit voor die van Bird onder te doen, zal nog blijken.

In de vergelijking van Vogel met Bird's arrays werken we de overgang naar de tweede rij precies uit.
Soms keren we =: onze evaluatie richting om. Voor meer detail, klik op de gescripte borden 0'>!< of zoek die items op in de bron.

  • V(a,a,[2]2) = (a,a,a,[2]1) = (a,a,a) = (a,a-,1,2)
  • (a,a1.,1..,[2]2) :k0 = (a,a.,1..,a1) :k == (a,a,1a.,a..) :k = {a,k+3[2]2}
  • (a,2,2,[2]2) = (a,a,1,[2]2) = (a,a,1,a) =: (a,a-,1,1,2)
  • (a,3,2,[2]2) = (a,(a,2,2,[2]2),1,[2]2) =: (a,(a,a-,1,1,2)-,1,1,2) ≈> (a-,3,2,1,2)
  • (a,b1,2,[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-,..a..,2,1,2) :b: ≈> (a-,b1,3,1,2)
  • (a,b1,c1,[2]2) == (a,..a..,c,[2]2) :b: ≈> (a-,..a..,c,1,2) :b: ≈> (a-,b1,c1,1,2)
  • (a,b1,2,1,[2]2) == (a,..a..,1,1,[2]2) :b: ≈> (a,..a..-,1,1,1,2) :b: ≈> (a-,b1,2,1,1,2)
  • (a,b1,3,1,[2]2) == (a,..a..,2,1,[2]2) :b: ≈> (a-,..a..,2,1,1,2) :b: ≈> (a-,b1,3,1,1,2)
  • (a,b,1,2,[2]2) = (a,a,b1,1,[2]2) ≈> (a-,a,b1,1,1,2) ≈> (a-,b,1,2,1,2)
  • (a1,b,c,2,[2]2) ≈> (a,b,c,2,1,2)
  • (a1,b,c,d,[2]2) ≈> (a,b,c,d,1,2)
  • (a1.,pi..,[2]2) :k>0 ≈> (a.,pi..,1,2) :k > {a,k+2[2]2} {pia} 0'>!<

Staat er ,[2]2 na de eerste rij, dan is dat bijna hetzelfde als ,1,2 aan het eind. De tweede rij wordt immers pas actief, als de eerste rij is gereduceerd tot a,b met de resterende posities ,1.. afgeteld. Dan voegen we een hoogste teller ,b toe aan die rij.

Ook werkt lengte teller ,[2]1m over de eerste rij uit, alsof een serie tellers ,1.,2.. :m aan die rij zit vast geplakt.

  • (a,b,[2]3) = (a,a,b,[2]2) ≈> (a-,a,b,1,2) ≈> (a-,b-,1,2,2)
  • V(a1,b.,1..,[2]3) :k0 ≈> (a,a1.,1..,b,1,2) :k =: (a,b-.,1..,2,2) :k1 > {a+b,k+4[2]2}
  • (a,b1,2,[2]3) == (a,..a..,1,[2]3) :b: ≈> (a,a,1,..a..,[2]2) :b: ≈> (a-,b1,2,1,2,2)
  • (a,b1,3,[2]3) == (a,..a..,2,[2]3) :b: ≈> (a-,..a..,2,1,2,2) :b: ≈> (a-,b1,3,1,2,2)
  • (a,b1,c1,[2]3) == (a,..a..,c,[2]3) :b: ≈> (a-,b1,c1,1,2,2)
  • (a,b1,2,1,[2]3) == (a,..a..,1,1,[2]3) :b: ≈> (a-,a,1,1,..a..,1,2) :b: ≈> (a-,b1,2,1,1,2,2)
  • (a1,b,c,d,[2]3) ≈> (a,b,c,d,1,2,2)
  • (a1,b,P,[2]3) ≈> (a,b,P,1,2,2)
  • (a1,b.,1..,[2]4) :k ≈> (a,a1.,1..,b,1,2,2) :k ≈> (a,b-.,1..,2,2,2) :k1
  • (a,b1,2,[2]4) == (a,..a..,1,[2]4) :b: ≈> (a,a,1,..a..,[2]3) :b: ≈> (a-,b1,2,1,2,2,2)
  • (a1,b,c,[2]4) ≈> (a,b,c,1,2,2,2)
  • (a1,b,P,[2]4) ≈> (a,b,P,1,2,2,2)
  • (a,b.,1..,[2]1m) :k0 = (a,a.,1..,b,[2]m) :k ≈> (a-,a.,1..,b :k ,1.,2..) :m- ≈> (a-,b-.,1..,2..) :k1 :m
  • (a1,b,1.pi,..[2]1m) :k>0 ≈> (a,b,1P,1.,2..) :m > {a+b,k+m+2[2]2} 0'>!<

Evaluatie van element ,[2]1m voegt aan de eerste rij een aantal van :m nieuwe tellers toe, gevuld met grote getallen.
Woord P, staat voor een deel pi,.. van een rij en R voor een hele rij. Daarin zijn de parameters pi>0 en te verwaarlozen ten opzichte van de rij lengte zelf (bij standaard input).

Bij Bird speelt bel b de rol van het opblazen van de lineaire array. Van element [2]2 kost dat slechts een enkele tel. Bird spaart bij elke overgang tussen dimensies de Vogel lengte teller uit.

  • (a,b,[2]1,2) = (a,a,[2]1b) ≈> (a-,a-,1.,2..) :b > {a,b+2[2]2}
  • V(a,b1,2,[2]1,2) == (a,..a..,1,[2]1,2) :b: == (a,a,1,[2]..a..1) :b: ≈> {a+3,b+1,2[2]2}
  • (a,2,3,[2]1,2) = (a,a,2,[2]1,2) ≈> {a,2,3[2]2}
  • (a,b1,3,[2]1,2) == (a,..a..,2,[2]1,2) :b: ≈> {a,b+1,3[2]2}
  • (a,b,c,[2]1,2) ≈> {a,b,c[2]2}
  • (a,b1,2,1,[2]1,2) == (a,a,1,1,[2]..a..1) :b: ≈> {a+4,b+1,2[2]2}
  • (a,2,3,1,[2]1,2) = (a,a,2,1,[2]1,2) ≈> {a,2,3[2]2}
  • (a,b1,2,2,[2]1,2) == (a,..a..,1,2,[2]1,2) :b: == (a,a,..a..1,1,[2]1,2) :b: ≈> {a,b+1,1,2[2]2}
  • (a,b,c1,d,[2]1,2) ≈> {a,b,c,d[2]2}
  • (a,b,1P,[2]1,2) ≈> {a,b,P[2]2}
  • (a,b1,2,[2]2,2) == (a,..a..,1,[2]2,2) :b: ≈> (a,a,a1,..a-
    ..,[2]1,2) :b:
    ≈> {a-1,b+1,1,1,2[2]2}
  • (a,2,3,[2]2,2) = (a,a,2,[2]2,2) ≈> {a-1,2,2,1,2[2]2}
  • (a1,b,c1,[2]2,2) ≈> {a,b,c,1,2[2]2}
  • (a1,b,1P,[2]2,2) ≈> {a,b,P,1,2[2]2}
  • (a,b1,2,[2]3,2) ≈> (a,a,1,..a..,[2]2,2) :b: ≈> {a-1,b+1,1,1,2,2[2]2}
  • (a1,b,1P,[2]3,2) ≈> {a,b,P,1,2,2[2]2}
  • (a1,b,1P,[2]1m,2) ≈> {a,b,P,1.,2..[2]2} :m 0'>!<

Matrix-regel V.6. bouwt de rijen tellers stap voor stap op. De lege elementen ,1 blijven tussenin staan, want opruim-regel V.2. verwijdert deze niet. Met de recursieve substitutie van rij lengtes b worden al de vorige series ,1.. gedomineerd.

Wat dominant uitpakt op de eerste rij, zal sterker gelden in de volgende dimensies. Vogel's stapsgewijs groeiende ruimtes zijn wat onnatuurlijk, maar in Bird's systeem is het lastig om diep geneste arrays [S]1[T] te vergelijken in zijn regel die afgetelde tussenposities opruimt.

  • (a,b,[2]1,3) = (a,a,a,[2]b,2) > {a,b+2[2]3}
  • V(a,b1,2,[2]1,3) == (a,a,1,[2]..a..1,2) :b ≈> {a+3,b+1,2[2]3}
  • (a,b,c,[2]1,3) ≈> {a,b,c[2]3}
  • (a,b,1P,[2]1,3) ≈> {a,b,P,[2]3}
  • (a1,b,1P[2]2,3) ≈> {a,b,P,1,2[2]3}
  • (a1,b,1P[2]3,3) ≈> {a,b,P,1,2,2[2]3}
  • (a,b,[2]1,n) = (a,a,a,[2]b,n) > {a,b+2[2]n}
  • (a,b,1.pi,..[2]m,n) :k>0 > {a+b,k+m+1[2]n+1}
  • (a,2,2,[2]1,1,2) == (a,a,1,[2]a1,a) ≈> {a+1,2[2]1,2}
  • (a,b1,2,[2]1,1,2) == (a,a,1,[2]a1,..a..) :b: ≈> {a+1,b+1[2]1,2}
  • (a,b,c1,[2]1,1,q) ≈> {a,b,c[2]1,q}
  • (a,b1,2,2,[2]1,1,q) == (a,a,..a..1,1
    ,[2]1,1,q) :b:
    ≈> {a,b+1,1,2[2]1,q}
  • (a1,b,1P,[2]2,1,q) ≈> {a,b,P,1,2[2]1,q}
  • (a,b1,2,[2]1,2,q) == (a,a,1,a,[2]..
    a..,1,q) :b:
    ≈> {a+3,b+1[2]2,q}
  • (a,b.,pi..,[2]m1,Q) :k>0 == (a,b.,pj.. :km
    ,[2]1,Q) {pj>pi>1}
    > {a+b,k+m+2[2]1+Q}
  • (a,b,[2]1,[2]n1) = (a,a,[2]1,b,[2]n == (a,a,P,[2]m.,qi..) :n > {a+b,n+1[2]1[2]2}
  • (a,b1,2,[2]1,[2]1,2) == (a,a,1,[2]1
    ,[2]1..a..) :b:
    ≈> {a+1,b+1,2[2]1[2]2} 0'>!<

Zo verlengen we de rijen in hogere dimensies met series van ,qi.. :r tellers, waarin de laatste qr dominant is.

Hoewel v>b kunnen we voor variabele v elk relatief klein getal invullen tot een bel b1 bijvoorbeeld, als dat helpt om Vogel te vergelijken met Bird. Het maakt weinig uit, de waarde van v is ondergeschikt aan de meest rechtse positie ervan.
In het volgende item zal v net wat groter zijn dan een expressie (a,a.,[s]b..,[s1]2) met lengte :b- en niet langer.

  • V(a,b,[s1]1,2) = (a,a,[s1]1b) > (a,a.,[s]1..v) :b > {a,b[s+1]2}
  • V(X,[s]m,Q) > {X[s]Q} Q = n.,qi.. :r

Ga ervan uit dat de delen X afgezien van het separator format gelijk zijn := of althans de belangrijke dimensies in deel X bij Vogel en Bird even lang zijn. Stel het rij deel Q van Vogel met 2e en verdere tellers gelijk aan de hele rechter rij bij Bird.
In elke Vogel rij, ook in Q, is oplaadregel V.5. dominant. Bird arrays (met teller c) komen door zijn regel 2.6. overeen met die van Vogel (en teller c1 om $ te laden).

Vogel's achterstand op de rij blijft beperkt tot een extra teller m, en de beste benadering geeft m=1. Zo pakt de expressie in Vogel soms groter ≈> uit, maar meestal minimaal <≈ kleiner dan die van Bird.
Voegen we m=2 in vooraan op de laatste rij, dan is die rij in Vogel gelijk groter en wordt de rest van het telraam dat zeker ook.

Bird's opladen van expressies $ kunnen we compenseren door bij de derde teller c in Vogel 1 op te tellen. Andere bonus constructies van Bird, zoals substitutie van a in eerdere tellers op rij en zijn ketens €n in vorige dimensies worden bij Vogel in de evaluatie ondervangen.
Met elke iteratie van naar positie m opgeladen bellen b' vagen we de ervoor opgebouwde lengte volledig weg. Die lengte draagt weer over en zo expanderen we alle voorliggende dimensies.

Stel dat n=b1 zojuist is opgeladen naar een 2e teller in een hoge rij van Vogel. Eén tel eraf n=b en de 1e teller m=a1 is nog klein. Die vergroot de lengte van de voorgaande dimensie met a, wat ver achter blijft bij lengte b van Bird's hoekketen. Maar de tweede aftel n=b- zal de waarde m=b' die naar de lengte teller wordt opladen al veel groter zijn dan de originele bel b. Ga maar na hoe latere bellen b' via regel V.4. de originele b vele malen bevatten.

Lengtes in Vogel groeien eerst met a en daarna meteen voorbij de hoekketen lengte b, waarmee Bird al zijn ruimtes vult. Toch blijft Vogel's accumulatie van lengtes als optellen, wat inmiddels relatief weinig effect sorteert, ook al zullen al deze series meedoen met de recursie van de bel.
Als we dus een teller 2, inlassen aan het begin van Vogel's laatste of diepst geneste rij, dan geven zulke matrix of geneste getallen een goede (insignificant grotere) benadering voor die van Bird.


Het 1e niveau of de [top array] in het Wielewaal systeem start met een variabele a die verdubbeld wordt. De volgende iteraties herhalen dit en elkaar een groeiende bel a keer. Zo drukte de eerste rij supermachtige getallen uit in blog §3.0.
Voor de echte supermachten gebruikten Vogel en Bird drie tellers, met dubbel recursieve subexpressies in b. Ons Wiel liep flink achter.

Posities in de Wielewaal rij tellen we met een index op het 2e niveau, ook weer gevolgd door een oplaadbare rij, in de [index array].
Vanaf c corresponderen de tellers in Bird's lineaire array met deze indexen in Wiel. Deze twee niveau's vormen Wiel's matrix, waarmee we Vogel's toprij benaderden in vorig blog §3.1.

De rij lengte of komma teller in Vogel staat dan gelijk aan de 1e index op het 3e niveau in Wielewaal. Naar alle diepe tellers laadt Wiel bel b op. Dat opladen van de bel is maximaal en domineert alle structuren, zodat het verschil in niveau's niet groter kan worden.
Het meer naar rechts substitueren van $ subexpressies met c bij Bird is gelijk aan b opladen in de Vogel expressie na uitwerking van c1. In Wiel betekent dit een extra teller op de eerste rij, ofwel 1 tel extra bij de eerste positie index. Dat was op de tweede rij al verwaarloosbaar.

We werken Wiel expressies nu uit tot een dieper array niveau, volgens regels W.II voor geneste arrays. Op dit 3e niveau [index subarray] scheiden we de indexen weer met komma's , en eventueel met een 4e niveau [sub sub index].
Het begin luistert nauw: hoe sturen we bel a de diepte in?

  • [a,[,[1,1]1]1] = a[,[,[a]a]1] ≈> (a,a1.,a..) :a1 > V(v,v,[2]a1)
  • [a,[1,[1,1]1]1] = a[,[,[a]a]a] == a[,[a.,a-..]a] :a ≈> (a,a1,a1.,a..) :a > V(v,a,[2]1,2)
  • [a,[1,[1,1]1]2] > (a,a-,1,[2]1,2)[,["]1] ≈> V(a-,3,2,[2]1,2)
  • [a,[1,1,[1,1]1]2] = a[,[a,[']1]a,["]1] ≈> (a,a,1,2,[2]1,2)[,["]1] ≈> V(a,3,2,2,[2]1,2)
  • [a,[,[,1]1,[1,1]1]1] = a[,[,[a]1,["]1]1] == a[,[.a-,..["]1]a] :a ≈> (a,1.a,..[2]1,2) :a1 > V(v,v,[2]a,2)
  • [a,[,[1,1]2]1] = a[,[,[a]a,["]1]1] > (v,v,[2]a1,2) =: V(v,a,[2]1,3) <!-->

Klik op de borden <!--> om meerdere variabelen te zien.
De tilde ~ staat voor de gebruikte benadering: de eerdere expressie is minimaal groter ≈> dan de volgende, in die array vorm.

De teller van element ,[,1]e is te verwaarlozen, omdat de daarin opgeladen waarde ,[a]e domineert. Dit is iets kleiner dan ,[1,1]1 een tel bij het volgende element, wat tot ,[a]a reduceert. Net zoals ,[a1]1 dat doet trouwens, waaruit blijkt dat die teller e nog geen 1 telt bij de bel.

Het lukt nu om met expressies in Wielewaal de tweede rij van Vogel binnen bereik te brengen. Een index verder ligt die van Bird.

  • [a,[,[2,1]1]1] = a[,[,[1,1]a]1] > (v,a,[2]1,a1) =: V(a,a,[2]1,1,2)
  • [a,[1,[1,1]1,[2,1]1]1] = a[,[,[a]a,["]1]a] > (v,v,[2]a1,1,2) =: V(v,a,[2]1,2,2)
  • [a,[,[2,1]2]1] = a[,[,[-"]a,["]1]1] > (v,a,[2]1,a1,2) =: V(a,a,[2]1,1,3)
  • [a,[,[,2]1]1] = a[,[,[a,1]1]1] ≈> (a,a,[2]1.,1..1) :a > V(v,v,[2]1,[2]a-) <!-->

Hogere structuren worden dermate dominant, dat het precies passend maken van elke teller er weinig toe doet. Voor ons gemak laten we de groter > ordening verder achterwege.
Uitkomsten van Wielewaal [W] zijn hier ongeveer gelijk aan (iets groter of kleiner dan) Vogel V(X) waarmee we de multi-dimensionale en verder geneste arrays {Y} van Bird benaderen.

  • [a1,[,[,,1]1]1] = a1[,[,[a,a]a1]1] (v,v.,[2]1..,[2]a) :a V(v,a,[3]1,2)
  • [a,[,[,[,1]1]1]1] = a[,[,[,{a}1]1]1] V(v,a-,[a1]1,2) {a,a[a+1]2} <!-->

Nu blijkt dat de dimensie separator lengtes van Bird en Vogel hun gelijke vinden in de drie diep geneste array van Wielewaal. Vogel rij lengte met de teller aan dat array begin (index 0), aantal rijen in een vlak met de teller met index 1, het aantal vlakken met de teller met index 2, enzovoort.

De dimensie lengtes corresponderen met de tellers op het 3e niveau in Wiel. De dimensie zelf is dan de eerste index op het 4e niveau in Wiel, twee niveau's dieper dan Bird of Vogel.

  • [a,[,[p.,[si]qi..]h]1] :r {si<si1} V(a,a.,[si1]1.. :qi ,1..h) r :p

Algemeen is de lengte :q van Vogel dimensies gelijk aan teller q in Wielewaal. De dimensie s1 kunnen we in Wiel aangeven met komma's ,.. :s of door een index [s] dieper te nesten.
Geneste arrays [si+1] van Vogel dimensies zijn verticaal gestapeld. De dimensie lengte is de reeks ,[si+1]1.. van gelijke elementen, want de index keert in de rep :qi terug. We herhalen ze met de r rechts verticale rep, die index i van onder naar boven optelt.

We voegen witruimte en reps en variabelen toe om deze systemen te verklaren. Maar iedere expressie is een string, bestaande uit units 1, separator tekens en haakjes, die door regels l-r tot grote getallen in unair formaat 1.. worden herleid.
Met dieper geneste tellers maken we nog grotere getallen, zoals Bird noteert met hyper-dimensies. Meer daarover in het volgende blog.

In de formule is gesteld dat si+1>si en dat de herhaling r onder begint. Daarom zijn de dimensie indexen links in de Vogel expressie groter dan rechts. Bij de index in Wiel's 4e nest loopt dat andersom. Opeenvolging si1=si1 kan, maar is niet verplicht.
Of deze maxtrix vergelijking ook geldt als de sep indexen s niet in volgorde van grootte staan, laten we aan de lezer over…!

Bird's Universum

De array notatie van Chris Bird heeft drie systemen voor de introductie en eliminatie van elementen: hoofdregels, hoekketen regels en een ordening van grootte voor separator arrays.
Bird's universum van expressies en getallen (input en output) zetten we in deze appendix om in een simpeler Uil systeem.
Ook Uil breiden we met twee hulpsystemen uit: de bank arrays en de nieuwe ruimte merken met hun regels.

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.

Onze definities krijgen de letter U van Uil en een romeins nummer. Variabelen zijn unair, met optellen van buren, dus b1=b+1.
Daarbij maken hulp regels en afkortingen de notatie leesbaarder.

Bird gebruikt hoekketens <a[T]b> om vrije array ruimtes in reeksen te vullen. Dezelfde expansie bouwen we hier per element op met het stel arrays {a[T]b,k} dat in zijn systeem geen rol speelt.
Vanaf dimensies komen onze bank regels, die deze dummy arrays reduceren, in plaats van Bird's subsysteem voor hoekketens.

De expressie voor de volgende stap $ is gegeven door bel b met 1 te verminderen (dit telt unit - op).
Gebruik komma's , als separator tussen tellers in rijen.

  • 1.$ {a,1Z} => $ = {a,Z}
  • 2., [1] ≡ ,
  • 2.€ €1a, & €n ≡ {a[n]b}[n]

De merktekens €n functioneren vanaf €2 hetzelfde als hoekketens bij Bird. Elke array dimensie n1 wordt gevuld met series van lengte b van steeds kleinere ruimtes n, totdat we de tellers a uitrollen in rijen met komma's (index 1 is dimensie 0) ertussen.

Matrix functie U.II voor Bird's multi-dimensionale arrays.2

  • 0.0. 0.1. 1.4.
  • 2.2. [m]1} ≡ }
  • 2.3. {a,1[n]Z} = a
  • 2.5a. ,1[n][n] {n>1} 2.5. [m]1[n][n] {m<n}
  • 2.6. {a,b.[ni]1..,1Z} :k = {.€ni..$,Z} :k
  • 2.7. {a,b.[ni]1..Z} :k>0 = {.€ni..Z} :k

Pas deze regels in volgorde toe. Dan komt regel 2.4 in de vorm 1.4 altijd voor regel 2.6, zodat k>0 en n1>1 daar gegeven zijn.
Lees in {Y,1} een laatste komma als index [1] die onder regel 2.2 valt. Omdat regel 2.5 van links de kleinere indexen elimineert, staat de volgorde van de dimensies nini+1 bij expressies 2.6 en 2.7 vast.

Deze bank regels vervangen Bird's hoekketens in de matrix.

  • 2.€ 1. {a[2]b1} €1{a[2]b} ≡≡ a,..a :b
  • 2.€ 2. {a[n1]b} ≡ {a[n]b,b}
  • 2.€ 3. {a[n]b,k1} €n{a[n]b,k} ≡≡ €n..{a[n]b} :k

Bird laat arrays zonder bel {a[n]Z} ongebruikt. Hij is verplicht om die tot a te reduceren, omdat hij onze regel 2.5a bij regel 2.2 voegt, voor regel 2.3 expressies {a,1[n]Z} kan bereiken.
Wij hergebruiken een stel van die dummy arrays of banken om array ruimtes stapsgewijs te vullen. Zo'n bank bestaat uit een constante a, een index array, een constante b en daarvan afgeleid een extra teller die van ,b tot ,1 aftelt en door regel 2.2 wegvalt.

Alle tellers zijn positieve getallen, die actief zijn in de lopende recursie, d.w.z. deel uitmaken van een significante reeks. Elementen die in ons Vogel telraam V onder een hogere recursie buiten spel staan, worden bij Bird met teller 1 en separator het veld uitgestuurd.

Bouwwerken van de Lilliputters die Gulliver zijn maaltijd serveren
CALL App.show(UL, className[])
SET tC.App.Tags

No comments:

Post a Comment