Friday 29 September 2017

Machten

§2.1 Machten

Er zijn drie elementaire operaties tussen getallen. Optelling + wat getallen samen telt, vermenig­vuldiging * wat tellen herhaalt, en nu dan machts­verheffing met ^ of ** als operator. Zowel de operatie als het resultaat ervan noemen we een macht.

Machtsverheffen herhaalt vermenig­vuldigen met het­zelfde getal. Dat kan per stap worden gedaan. Onze macht operator is ^ een dakje, super­script notatie is onge­schikt voor de computer input lijn.

  • a^1 ?= a
  • a^b1 ?= a^b*a == a^1.*a.. :b = a*..a :b

De voorwaardelijke toewijzing ?= staat hier, omdat een macht rechts in een reeks elemen­taire operaties voor­rang krijgt. Bijv. de ex­pressie a^b^c betekent a^(b^c), waar de sub­expressie b^c eerst wordt uit­gewerkt (tot exponent).

Onze logaritme functie Log is een inverse van machts­verheffing, en nog wat weetjes over operaties met machten.

  • m^p*m^q = m^pq (m^p)^q = m^(p*q) n^-*n = 1
  • m^Log(m,n) = n Log(m,p*q) = Log(m,p)+Log(m,q) Log(m,n)*Log(k,m) = Log(k,n)

Ster operaties *.. evalueren we hier strikt `= vanaf links. Daar zijn geen haakjes bij nodig of verge­lijkende prece­dentie regels. Alleen een rechter operatie zonder plus, die volgt na een ope­ratie met pop plus, wordt met voor­rang geholpen.
Het aantal sterren tellen we in deze evaluatie af naar links, tot we op nul *{0} uitkomen en de operanten ac natuurlijk optellen.

Een l-r definitie voor machten met ** twee popsterren.

  • a**b1 `= a+*a**b (popster)
  • c+*a+* `= a*c+* (popschuif)
  • c+*a**1 = a*c (ontpop)

We gebruiken een popster om een macht af te schermen van zijn uit­werking, die links plaats vindt. Het plus teken van +* fungeert als haakje, maar is tijdelijk en verdwijnt als deze als ster operatie op­schuift voor een nieuw pop­ster haakje.

# Experiment 2.1

Ontwerp een Superplus systeem. Pas de regels in volgorde toe, zodat c>1 voor de eind iter­ator en b>0 en c>0 in de recursie.

  • a+b = ab
  • a+{c}1 = a
  • a+{c1}b1 = a+{c}a+{c1}b

Als we hierbij prioriteit tegelijk met subexpressies overboord gooien, en +.. opera­toren puur l-r evalueren, werkt dat dan?
Ja en snel, twee plussen ++ herhaalt de verdubbeling van a.

a++b2 = a+a++b1
  = aa++b1 = aaaa++b
 == a.*2..++1 :b1
  = a*2^b1

Een post operatie \^ plaatst na uitwerking van de vooraf­gaande operatie een extra expo­nent bovenop de hoogste sub­operant daarvan. Post operatie \* vermenig­vuldigt deze hoogste exponent dan wel super­exponent (met prio­riteit zodra deze er is).
We plaatsen de post backslash rechts en draaien de operanten niet om, zoals bij de pop plus links van de operatie.

We vergelijken superplussen met ^.. supermachten, die in §2.2 een histo­risch overzicht krijgen. De expressie links van ≈> is maar weinig (insignificant) groter dan die rechts.

  • a1+++b3 = a1++a1+++b2 = a1*2^a+++b2 ≈> 2^(a*2^a)+++b1 ≈> 2^2^2^a1+++b ≈≈ 2^..a1+++1 :b2 = 2^^b2\^a1 ≈ a^^b3
  • a1+{c2}b2 = a1+{c1}a1+{c2}b1 ≈ a^{c}a1+{c2}b1 ≈ a^{c}a^{c}a1+{c2}b ≈≈ a^{c}..a1 :b1 = a^{c1}b1\^{c}a1 ≈> a^{c1}b2

Door twee tekens, de 1 en + plus, te gebruiken krijgen we super­grote ge­tallen. Ook al laten we de enkele tekens domweg vallen, in de initiële regels.
Bijv. 11+++++111 2^^^^3 = 2^^65536.

Omdat a+{c}b <≈ a*{c}b zijn de recursies in de functies van super­plussen D(a,b1,c1) = D(D(a,a,c),b,c1) en van de super­machten F(a,b1,c1) = F(a,F(a,b,c1),c) die we later bespreken, onge­veer even snel.

Ontwerp nu een hybride functie met meervoudige recursie op twee posities. Noem dit de Excalibur functie: het twee­snijdend zwaard.

  • E(a,b,1) = E(a,b) = ab
  • E(a,1,c) = a
  • E(a,b1,c1) = E(E(a,a,c),E(a,b,c1),c)

Rozsa Péter stelt2 dat recursie in meerdere variabelen tegelijk niet signi­ficant sneller gaat, en dit willen we testen.

  • E(a,b1,2) = E(aa,E(a,b,2)) == E(aa,..a..) :b: = a*2*b+a
  • E(a1,b1,3) ≈> E(a^2*2,E(a,b,3),2) ≈> aa^2*E(a,b,3) ≈≈ aa^2*..a :b = aa^bb*a
  • E(a1,b1,4) ≈> E(aa^aa,E(a1,b,4),3) ≈> aa^(a*3*E(a1,b,4)) ≈≈ a1^..(a*a*3) :b>0 ≈> a1^^b1\^2
  • E(a,b1,5) ≈> E(a^^a,E(a,b,5),4) ≈> a^^(a+E(a,b,5)-) ≈≈ a^^..aa- :b>0 <≈ a^^^b1\*2
  • a^{c}b < E(a,b,c2) <≈ a^{c}b\*2 < aa^{c}b

We verwachten dat hogere expressies E als de bij c=5 berekende zullen ver­lopen, en niet verder zakken richting F.
In ieder geval voegt de extra recursie hier weinig toe, al is argument a onge­veer ver­dubbeld. Misschien als we de extra stap E in stap F nesten, dat dat hoger­op groter uitpakt?

  • G(a,b,1) = G(a,b) = ab
  • G(a,1,c) = a
  • G(a,b1,c1) = G(a,G(G(a,a,c),b,c1),c)

Als we onze Griffioen functie uit­werken, dan neemt super­macht c 1 toe, verge­leken met E of super­plussen. In het vervolg telt het tweede argument bijna als b*2, wat te ver­wachten viel door het dubbele nesten in de recursie stap.

  • G(a,b2,2) = a+G(aa,b1,2) = a*3+G(a*4,b,2) == a*(2^b2)- ≈ 2^b2
  • G(a,b2,3) ≈ 2^G(2^a,b1,3) = 2^2^G(2^2^a,b,3) == 2^^b1\^2^^b1\^a = 2^^bb2\^a ≈ 2^^bb4
  • G(a,b1,4) ≈ 2^^G(2^^aa,b,4) == 2^^..2^^..aa :b :b = 2^^^bb\^^aa ≈ 2^^^bb2
  • G(a,b1,c1) ≈ 2^{c}bb\^{c-}aa ≈ a^{c}bb1 ≈ 2^{c}bb2

Omdat argument c ongemoeid blijft, draagt het nesten van meerdere sub­expressies niet wezen­lijk bij aan het maken van grotere ge­tallen, als die recur­sies op zich al super­machten op­leveren.

Een serie gelijke operaties komt in de evaluatie van super pop­ster operaties nooit voor. We zien duo's van ster en pop­ster, met een naar links af­nemend aan­tal sterren.
Als we een pop operatie links vóór de macht plaatsen, dan zal deze ope­reren op de hoogste factor, die steeds naar rechts schuift. Eerst een simpel voorbeeld, dan de algemene formule.

  • 1+2**3 = 1+2+*2**2 = 3+*2**2 = 3+*2+*2**1 = 2*3+*2**1 = 2+2*2+*2**1 = 4+2*1+*2**1 = 6+*2**1 = 2*6 == 12.
  • p+*{q}a*{c1}b1 = a*{q}p+*{c}a*{c1}b = a^{c}b1\*{q}p

Bij rekenen met sterren, moeten we soms haakjes toe­passen. Maar hier gaat het erom één ster operatie in stappen uit te werken.
Een pop­ster +*{c} stelt zijn operatie niet alleen uit, maar draait de operanten daarna ook om. Dit pop­schuiven blijft gelijk in geval +* want vermenig­vuldigen is commu­tatief, maar bij super­machten maakt om­draaien groot verschil.

Pop­schuiven is nodig vanaf +** bij dubbele machten. Die ont­staan bij het uit­werken van tetraties *** in enkele stappen = zoals we dat hier­onder doen, tot de her­haling == ervan duidelijk is.

3***3 = 3+**3***2
      = 3+**3+**3***1
      = 3**3+**3***1
 3**3 = 3+*3**2
      = 3+*3+*3**1
      = 3*3+*3**1
  3*3 = 3+3*2
      = 3+3+3*1
      = 6+3*1
      = 9 (ontpopt)
 3**3 = 9+*3**1
      = 3*9 (ontpopt)
     == 27.
3***3 = 27+**3***1
      = 3**27 (ontpopt)
      = 3+*3**26
     == 9+*3**25
      = 9+*3+*3**24 (popster)
      = 3*9+*3**24 (popschuif)
     == 27+*3**24
    === 7625597484987.

Stel dat we de regel voor pop­schuiven vervangen door pop­ruimen, dus plus + elim­inatie zonder dat er operanten ver­wisseld worden. Dan blijven hek­machten #.. ver achter op *.. super­sterren.
Hierboven zou 27##3 omdat (3^3)^3 = 3^(3*3) = 3^9 al een factor 3^18 schelen. Hoe klein is dan 4####4 in vergelijking en hoe groot is 4****4 of gaat dat te ver voor telbare hekmachten…?

2. Recursie met k variabelen leidt niet buiten de klasse van de primitief recursieve functies, p.75 in Rozsa Péter "Recursive Functions" 1967, 1950.
Gulliver redt de vloot van Lilliput

Saturday 23 September 2017

Herhalen

Reuzen Getallen Bootstrap

van Giga Gerard

“Row, row, row your boat,
Gently down the stream.
Merrily, merrily, merrily, merrily,

Life is but a dream

§2. Rijen

Vandaag vertrekken we voor een lange reis naar het grootste getal. Monster aan en wandel over Giga Gerard’s
„Reuzen Getallen Bootstrap”.
G of giga is het voor­voegsel voor miljard 109, wat we liever schrijven als een macht 10^9 of met units 1 en tel­bare sterren.
1111111111**111111111
Een bootstrap is een opstart [boot] pro­gramma voor computers, dus deze opera­ties leggen we zo dadelijk uit. Unaire notatie met enen voor natuur­lijke ge­tallen bespraken we in §1.1.

Hier in sectie §2.0 her­halen we getallen, wat vermenig­vuldigen is. Ook presen­teren we een meta notatie om groepen tekens te herhalen.
Blog §2.1 gaat over machten en hun vervolg. We experi­menteren met opera­toren en functies en testen meer­voudige recursie.
In §2.2 geven we een histo­risch over­zicht van de super­machten van Knuth, Hilbert, Ackermann en Péter. En super­sterren, die we strikt l-r eva­lueren met behulp van pop­sterren. Een bijzonder systeem zijn de hek­machten, die op halve super­snelheid gaan.

Het thema hier in serie §2 is rijen. Van een rij getallen of lineaire array kunnen we de index ge­tallen uit­breiden tot een index rij, die zelf ook weer index rijen bevat. Dit zijn geneste arrays tot elk niveau.
In deze structuren passen we twee soorten regels toe. Onze super radix werkt met substi­tutie van een constante a, de aas, wat in grotere arrays mini­maal wordt. Onze array functie verzamelt en verlaadt een sub­totaal b, de bel, wat maximaal is.

Systemen voor de evaluatie van expressies, waar afge­telde iter­atoren opnieuw worden opge­laden, noemen we blazers. We blazen azen op rij §2.3 en in nesten §2.4 en ont­wikkelen zo een natuur­lijk ver­volg op het radix systeem, waarin elk groot getal kan worden uitgedrukt. En we blazen bellen op rij §2.5 en in een vlak §2.6 en alle dimensies §2.7 en in hyper-dimensies §2.8 van geneste arrays. Op deze manier steken we de array functies van Chris Bird naar de kroon.

Geleidelijk ontwikkelt zich een taal bij de wiskunde van grote getallen en een notatie in html ascii. Ook geven we een natuur­lijke ex­tensie van Knuth en Conway's pijlen, die de lezer verder uit mag werken…
Puntjes zijn hints voor over­denking of oefeningen.

Lectori salutem Welkom aan boord.

§2.0 Herhalen

Vermenigvuldigen is herhaald optellen.
We schrijven deze operatie met een ster a*b tussen twee ge­tallen en nemen b keer a. Natuur­lijke getallen 1.. zijn opge­bouwda uit units 1 en daarom is vermenig­vuldiging al een her­haling op her­haling.

  • a*1 ?= a (init)
  • a*2b ?= a+a*1b (stap) = a+a+a*b = aa+a*b == a..+a*1 :b1 = a..+a :b1 = a.. :b2

Bij voorwaardelijke evaluatie met prece­dentie ?= ver­andert een regel de ex­pressie alleen, als er geen opera­tie die voor­rang heeft op volgt. Hier doen we maal * voor plus + bijvoor­beeld.
Dus a*3 = a+a*2 = a+a+a*1 = aa+a*1 = aa+a = aaa is hoe we een ex­pressie uit­werken, waar­bij we een enkele op­telling a+b*c links laten liggen.

We scannen de expressie l-r (van links naar rechts), terwijl we een match voor een regel pro­beren te vinden, om die toe kunnen passen.
Varia­belen uit verschil­lende regels zijn onaf­hankelijk.
Na herhaalde toe­passing == van regels noteren we een later resul­taat. Soms schrij­ven we = om een be­kende uit­werking samen te vatten.

Een andere manier van optellen is, om getallen om te draaien en dan pas samen te voegen. Dit pop­tellen + kan ook staps­gewijs, per tel.

  • b+1 ?= 1b
  • b+a1 ?= 1b+a == a1b

In Cantor's oneindige valt 1ω = ω weg, maar telt ω1 gewoon op.b Stel dat we, in dit niet commu­tatieve on­eindige, een serie a optellen bij een on­eindig grote b. Als deze serie on­eindig lang is, zal deze de uit­komst domineren en kan b alleen rechts nog wat bij­dragen.
Door op pop wijze b+a op te tellen tot ab, groeien on­eindige series ..a naar links ω: aan. Zelf zal in ..a1 het item niet zijn omgedraaid en reps zoals ω1: worden eerst van rechts bijgeteld.

# Metamatiek 2.0

We gebruiken twee meta notaties voor tekst herhaling, bedoeld om de uit­werking van ex­pressies inzich­telijk te maken.
Met de regex notatie herhalen we een enkel teken (karakter) door het aantal ervan {n} erna tussen krul­haken te plaatsen.

In onze repex notatie selec­teren we een rij tekens (groep) tussen punt . of grens van de expressie en twee .. punten. We kunnen deze groep naar links of naar rechts herhalen of we herhalen twee groepen van buiten naar binnen toe.

  • W.. :5 = WWWWW
  • Wi..X..Yi :3: = W1W2W3XY3Y2Y1
  • V.W..X..Y.Z :2: = VWWXYYZ
  • i..Xj :3 5: = 6X5X4X3X2X1

Het aantal herhalingen staat rechts van de expressie in de rep met de : dubbele punt. Een rep :n telt de groepen in de repetitie van links naar rechts bij, of n: van rechts naar links, of dubbel­zijdig :n: van buiten naar binnen.

Mogelijke index variabelen i of j incrementeren tijdens de repetitie. Vanaf begin waarde i=1 neemt die index per stap 1 toe, tot aan de laatste index i=n. Het aantal stappen en de richting ervan blijkt uit de rep, de groep en de plaatsing in de reeks uit de selectie op de punten.

We willen maximale algoritmes niet op reps baseren, maar op simpele regels die we staps­gewijs toe­passen: met een eerste en steeds een volgende stap.
De evaluatie trein rijdt van vertrek expressie (de input) naar aankomst expressie (de output) en heeft vele tussen­stations (reducties).

G0.=Gi.. :u =>
   G0=1.. :Gi=Gu

Omdat gelijkheid = van expressies transitief is, blijven de resul­taten kloppen. Al deze ex­pressies zijn slechts andere vormen van de output Gu die na complete evaluatie wordt bereikt.

In de voorrangsregels voor operatoren gaan machten ^ voor * sterren, en een plus + of pop komt in de evaluatie laatst.

  • + ?< *{n} ?< ^ (operator volgorde)
  • ^.. :n ?< ^.. :n1 (meer eerst)

Voor supermachten geschreven met dakjes of supers ^.. geldt de gebrui­keljke prece­dentie van de meer­derheid, en in gelijke gevallen zijn ze rechts asso­ciatief. Er is een teken minder nodig a^{n}b = a*{n1}b dan voor super­machten met sterren.

Onze supersterren *.. evalueren we l-r (links asso­ciatief) zonder dat verge­lijking nodig is. Hoewel prece­dentie van de minder­heid uit hun definitie zou moeten volgen. Immers a*{0}b = ab wordt van nature direkt opgeteld.

Om getallen met miljoenen cijfers te vermenig­vuldigen zijn er snellere methodes ontwikkeld. Voor twee getallen met d digits kost de oude school­methode d^2 reken­tijd, terwijl dit met de Karatsuba truc een kleine c*d^Log(3) is (logaritme basis 2).
Kampioen met c'*d*Log(d) is het FFT algoritme, dat snelle Fourier trans­formaties toepast.1 Quantum computers kunnen in de toekomst een nog grotere tijd­winst geven.

Voor de grote getallen die wij maken haalt zulke reken­kunde weinig uit. Die liggen voorbij de horizonc van het fysisch universum.
De macht ^ of ** kan met het prin­cipe van her­haling op her­haling tot tetratie ^^ of *** (toren van machten) en verder tot super­machten worden uitge­werkt. De opera­toren + * ^ helpen om moei­lijk te tellen getallen te schrijven, maar het kan ook zonder…

Radix systemen, zoals ons tien­tallig stelsel, repre­senteren expo­nenten van machten van 10 door een positie in een reeks cijfers. De cijfers zelf her­halen deze machten.

..ci.c0 n: & 0c<10
   = c0.+ci*10^i.. :n

Ieder cijfer ci vermenigvuldigt zijn macht van 10 en daarna wordt die serie opge­teld tot een getal, dat uniek is voor de cijfer­reeks. En dat is best knap, hoe kunnen kinderen zoiets ingewikkelds leren…?

a. De natuurlijke getallen kunnen we met louter cijfers 1 uitdrukken in wat ik noem: hun eenvoudige vorm. gg: Enen en operatoren in "Constructie van Grote getallen" (novaloka.nl 2009) met links naar gg's oude weblogs.
b. Open een volgend tel-register. Zo telt Cantor rechts op in het oneindige., gg: Countable infinity voor weblog (concept 2016).
c. Laat me je horizon wat verder weg duwen, gg: Beyond the Abacus in "On the number horizon" (novaloka maths blogs 2007).
1. Er zijn snellere manieren om getallen te vermenigvuldigen, ch.11 in Arndt & Haenel "Pi – Unleashed", 2001.
Gulliver redt de vloot van Lilliput

Friday 8 September 2017

Waarden

§1.6 Waarden

Door 1 op te tellen bij een ordinaal, neemt de set rij met 1 element toe en wordt de set 1 niveau genest. Lengte en diepte groeien parallel aan het ordinaal getal. We kunnen stellen dat de maten van beide dimensies in sets even belangrijk zijn.
Om de set structuur te waarderen nemen we nu de som van diepte en lengte. Dat werkt ook bij ordinale sets. Deze waardering vormt geen welordening, want de som kan groter worden dan de rij lengte alleen, en is dus ongeschikt om de elementen in een set te indexeren.

De rijen structuur van arrays is dezelfde als die van sets, zonder dat de set regel, dat elk rij element uniek moet zijn, daarbij is opgelegd.
Naast lengte en diepte speelt ook de getalswaarde van elementen mee. Getallen zijn immers uit te drukken als ordinalen en vice versa.

Zo waarderen we arrays en sets net als ordinalen:

  • {0,{0},{0,{0}},{0,{0},{0,{0}}}}{0,1,{0,1},{0,1,{0,1}}}{0,1,2,{0,1,2}}{0,1,2,3} ≡ 4
  • {{{0},1},{2,3},4} = {{1},{2,3},4} = {2,{2,3},4} = {2,4} = 5
  • [[[0,0,0,0],1],[2,3],4] = [[4,1],[2,3],4] = [5,[2,3],4] = [5,4,4] = 6

Door geneste sets vanuit de diepte l-r te vervangen door een getal, determineren we elke set. Zo worden ordinale sets iteratief tot hun ordinaal getal herleid16 en soortgelijke structuren, andere sets en arrays, tot hun ordinale waarde.

Stel nu dat we een getal of parameter koppelen aan elke geneste array. Dan verandert de set structuur in een geneste functie array, waar de sets de parameters indexeren. Maar de output van zo'n array hoeft geen groot getal te zijn. We kunnen de waarde van deze structuur ook weer met optellen determineren.

Ordinale evaluatie van items, lengte, diepte in sets:
Loop in een rij S langs de items. Als een item een rij is, loop daar dan in verder als in S.
Als S de lege set is, zet er waarde 0 voor in de plaats.
Als de rij lengte r>ei groter is dan de waarde van elk item, vervang dan S door waarde r.
Zoek anders het grootste item emei en vervang S door em1.
Ordinale evaluatie van parameter en set in arrays:
Zodra een index array zijn waarde heeft, telt de gekoppelde eipi parameter erbij op.

In geneste functie arrays bepalen parameters op diepte d1 de index array waarde voor een gekoppelde parameter op diepte d. Voor de totale array volgt de waarde pi.. :d door herhaaldelijk optellen. Ofwel w*w als we parameters en diepte de waarde w geven.

Dit in contrast met de hogere array functies, die met dezelfde geneste structuur razend snel groeien en enorm grote getallen produceren.
Dit bewijst dat er een geneste functie is, waarin elke variabele en elke dimensie significant kan zijn, die even langzaam of weinig expressief is als vermenigvuldiging.

De virtuele parameter die we rechts aan sets kunnen koppelen is {X}0 nul. Dan blijken sets nog relatief expressief te zijn, want in functie arrays negeren of elimineren we zulke separatoren bij de tot 0 of 1 afgetelde parameters.

Welke setwaarde natuurlijk is is moeilijk te bepalen.
Gewoon tellen van een verzameling objecten geeft de rij lengte of de kardinale waarde w.
Een set met een genest element of rij lengte w op diepte w kreeg ordinaal de waarde w*2.
Een verzameling getallen die we optellen, heeft een orde van grootte van waarde w*w.
Tellen we alle waarden in geneste sets op vanaf diepte w, dan is het totaal ongeveer w^w.

De structuur van sets en arrays sommeert tot de waarde w^w, wanneer we in elke rij steeds w rijen nesten tot maximaal een diepte w vanaf de basis. Dit vormt een matrix met gelijke dimensies, waar in de diepste rij elk element 1 is.

[[[1,1,1],[1,1,1],[1,1,1]],
 [[1,1,1],[1,1,1],[1,1,1]],
 [[1,1,1],[1,1,1],[1,1,1]]] =
[[3,3,3],[3,3,3],[3,3,3]] =
  [9,9,9] = 27.

Zoals in een volgend blog §2.3 de geneste structuur van index array en getal in functie arrays de waarde w^^w krijgt door het optellen en opladen van een constante w. Deze geneste radix functie noemen we Aasblazer. De waarde ervan is natuurlijk voor deze structuur.
Vandaar dat we de structuur van sets, als voorganger van de geneste functie arrays, het best de waarde w^w toekennen. Met de introductie van index arrays wordt de komma , separator overbodig.

Cantor telde elementen van sets met behulp van ordinalen.17 Toch lijken de ordinalen de drie set tekens {,} te verspillen door er enkel natuurlijke getallen mee weer te geven. We zagen in §1.4 al, dat de expressieve kracht van holle bolle sets, waar eenvoudige nestgetallen in plaats nemen, snel explosief wordt.
Tellen is het zuinigst te funderen met units 1. Ordinale sets zijn erg verkwistend. Tenzij… iemand de extra faciliteiten voor op en aftellen, die Von Neumann ordinalen in §1.5 boden, elegant weet te benutten?

16. Elke welgeordende set is isomorf aan een uniek ordinaal getal, Ordinal Numbers, theorem 2.12 in Jech "Set Theory" 2006.
17. Ordinalen uitgedrukt als polynomen met machten van ω, 11.7 Ordinal Notations + exercises, in Rogers "Theory of Recursive Functions and Effective Computability" 1967.
Gulliver meegevoerd door de Lilliputters op een groot bed