Laboration 3: Rekursiva definitioner, listor och ett olöst problem

Transkript

1 Laboration 3: Rekursiva definitioner, listor och ett olöst problem I detta arbetsblad finns ett antal exempel på hur man kan använda Mathematica för att få översikt över listor och dessutom ett antal exempel på algebraiska räkningar. Inledande om listor Mycket av det material som Mathematica producerar är listor, alltså ordnade mängder. Vi har sett att en matris t ex är en lista av sina rader, som i sin tur är listor av reella tal. Lösningarna till en ekvation är en lista av transformationsregler. Det finns må nga kommandon för att göra allt man kan vilja göra med listor. Här är nå gra exempel. En lista kan se ut så här: {15,5,35,45,55,65} In[1]:= För att sedan plocka ut i:te element ur en lista, skriver man [[i]] efter listan, t ex 15, 5, 35, 45, 55, 65 5 Out[1]= 55 In[]:= Out[]= Out[3]= 66 In[4]:= Out[4]= Har man en lista av listor, t ex följande lista roos av punkter i planet, kan man alltså plocka ut det :dra elementet ur den 3:de listan i roos så här. roos 11,, 33, 44, 55, 66, 77, 88 roos 3 11,, 33, 44, 55, 66, 77, 88 För att få första och sista elementet i en lista kan man använda First och Last First roos Last roos 11, Out[5]= 77, 88 In[6]:= Det finns kommandon för att ta snitt och komplement, och för att välja ut element som uppfyller ett visst kriterium, t ex vara jämna eller nå got annat. Se nästa exempel. INLEDANDE EXEMPEL: Hitta primtalstvillingar---ett exempel på att hantera listor Det finns oändligt må nga primtal, fast de ligger glesare och glesare bland heltalen. Vissa av dem som 11 och 13 eller och skiljer sig bara med och kallas för primtalstvillingar. Ingen vet om det finns oändligt må nga så dana eller inte. Här ska vi leka lite och se att det finns primtalstvillingar större än en miljard. Mathematica kan avgöra om ett tal är ett primtal: PrimeQ PrimeQ Out[6]= Out[7]= True False Vi kan få det 1000:de primtalet

2 Laboration3.nb In[8]:= Out[8]= 7919 In[9]:= Prime 1000 Och då kan vi använda Table för att göra en lista av de första hundra primtalen(som vanligt ger vi ett på hittat namn å t den) Amanda Table Prime i, i, 1, 100 Out[9]=, 3, 5, 7, 11, 13, 17, 19, 3, 9, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 17, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 11, 3, 7, 9, 33, 39, 41, 51, 57, 63, 69, 71, 77, 81, 83, 93, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 41, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 51, 53, 541 In[10]:= Out[10]= In[11]:= Nu vill vi veta vilka av dessa som är primtalstvillingar. Vi vill alltså gå igenom listan och konstruera dellistan av de x för vilka x+ också är ett primtal. Den vägledande insikten är att Mathematica har kommandon för allt som svarar mot sedvanliga matematiska operationer. Att ur en mängd välja ut de x som uppfyller ett visst kriterium är ju ett vanligt matematiskt tillvägagå ngssätt. Alltså ska det finnas ett lätt sätt att göra detta på. Variabeln som löper över mängden kallas #. Så här väljer vi ut de # i Amanda som är mindre än 10. Amandaännuintetio Select Amanda, 10 &, 3, 5, 7 För att få primtalstvillingar kan vi då göra så här: stagnelius Select Amanda, PrimeQ & Out[11]= 3, 5, 11, 17, 9, 41, 59, 71, 101, 107, 137, 149, 179, 191, 197, 7, 39, 69, 81, 311, 347, 419, 431, 461, 51 In[1]:= Select[lista,kriterium] väljer ut de element i listan som uppfyller kriteriet. Här är listan amanda, # är som tidigare namnet på variabeln som löper över elementen amanda och kriteriet är att # + ska vara ett primtal. D v s vi väljer ut det första primtalet i varje par av primtalstvillingar. Nu kan vi ställa och snabbt besvara frå gan om det finns nå gra primtalstvillingar bland primtalen frå n det hundra miljonte primtalet och uppå t. amandamiljon Table Prime i, i, , ; stagneliusmiljon Select amandamiljon, PrimeQ & Out[13]= , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , Vi har alltså flera primtalstvillingar större än miljarder. Det man framförallt ska imponeras av är med vilken lätthet vi kan hantera mängder eller listor. EXEMPEL 1: Faktorisera tal In[14]:= Out[14]= FactorInteger , 4, 37, 1, , 1

3 Laboration3.nb 3 Svaret är en lista av par, det första elementet i varje par är en primtalsfaktor och det andra talet talar om hur må nga gå nger det förekommer. Alltså : primtalsfaktoriseringen är =3^4 x 37 x Nu kan du äntligen få veta om ditt telefonnummer eller personnummer är ett primtal... EXEMPEL : Visualisera nollställen till en polynomekvation. /Transformationsregler In[15]:= Vi kan numeriskt lösa ekvationer, men vad är det för svar vi få r egentligen? Det kommer i likhet med vad vi sett tidigare som transformationsregler. nn NSolve x^ 1 ^ 17 x^5 43 x^ 3 0, x Out[15]= x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x , x Vill vi få ut den tredje lösningen för att t ex kunna räkna med den, så må ste vi först ta och välja ut den tredje av de ovanstå ende transformationsreglerna: In[16]:= Out[16]= nn 3 x och sedan använda ersättningsoperatorn på x: In[17]:= a3 x. nn 3 Out[17]= Nu först kan vi (utan fusk av typen att kopiera och klistra) använda detta a som ett reellt tal: In[18]:= a3^17 3 Out[18]= In[19]:= Out[19]= In[0]:= Out[0]= Out[1]= 3 Antag sedan att vi vill se hur dessa komplexa tal ligger i det komplexa talplanet. Mathematica skriver den imaginära enheten i som I, och kan förstå s räkna med komplexa tal. Så här 3 I 1 I 1 5 Re 3 I Im 3 I Conjugate 3 I Out[]= 3

4 4 Laboration3.nb Tillbaks till listan av nollställen nn ovan, som vi ville visualisera. In[3]:= Om x är ett komplext tal, så är dess koordinater i det komplexa talplanet {Re[x],Im[x]}. Det första nollstället i listan kan vi plocka fram som x/. nn[[1]], och dess koordinater är alltså {Re[x/.nn[[1]]],Im[x/.nn[[1]]]}. Nu kan vi använda Table för att göra en lista av punkter i planet, så att vi sedan kan plotta dem. nn Table Re x. nn i, Im x. nn i, i, 1, 34 Out[3]= In[4]:= , , , , , , , , , , , , , 1.476, , 1.476, , , , , , , , , 0.391, , 0.391, , , , , , , , , , , , , , , , , , , , , , , , , , , 1.414, , 1.414, , , , , , , , , , , , ListPlot nn Out[4]= In[5]:= EXEMPEL 3: Räkna med polynom---kvoter och rester Antag att vi vill räkna ut resten av ett polynom vid division med ett annat p x^ ^13 x 1 Out[5]= 1 x x 13 Vill vi se hur polynomets koefficienter ser ut kan vi göra så här: In[6]:= p1 Expand p Out[6]= In[7]:= 8193 x x x x x x x x x x x 0 31 x 6 x 4 x 6 Antag nu att vi vill ha resten av detta polynom vid division med x^3+3x+17. Vi vet att resten ska bli ett andragradspolynom PolynomialRemainder p1, x^3 3 x 17, x Out[7]= x x Vill vi också veta kvoten finns det lämpliga kommandon för detta, som man kan hitta i hjälpcentrat(leta till exempel på PolynomialRemainder).

5 Laboration3.nb 5 Vi kan också räkna med rationella funktioner och partialbrå ksuppdela dem. In[8]:= rat 1 z 1 z 1 z z^ 9 z^3 1 z^3 ^ 3 1 z^ z ^ Out[8]= In[9]:= Out[9]= In[30]:= Out[30]= 1 z 1 z 1 z z 9 z3 1 z 3 rat Simplify rat 9 1 z 3 Apart rat 1 1 z 1 z 3 1 z 1 z z z z 3 3 z 1 z z In[31]:= In[35]:= EXEMPEL 4: Finns det fler kaniner om tio å r än atomer i universum? Rekursionsföljder. Out[35]= 89 En idealiserad modell för kanintillväxt ser ut så här. Antalet kaninpar efter n må nader kallas f[n], och uppfyller rekursionsformeln f[n] = f[n - 1] + f[n - ]. Startvillkoren är f[0]=1 och f[1]=1. En rekursiv definition lämpar sig förstå s för att beräknas på dator. f 0 1; f 1 1; f n_ : f n f n 1 f n f 10 In[36]:= Table f n, n, 1, 0 Out[36]= In[37]:= 1,, 3, 5, 8, 13, 1, 34, 55, 89, 144, 33, 377, 610, 987, 1597, 584, 4181, 6765, f 10 Out[37]= In[38]:= Antalet atomer i universum är ca 10^80, som är ett mycket större tal, suck. För att få grepp om hur snabbt antalet kaninpar växer gör vi nu en tabell av (närmevärden) av kvoterna mellan ett värde och det nästa: Table N f n 1 f n, n, 1, 0 Out[38]= 1., 0.5, , 0.6, 0.65, , , , , , , , , , , , , , , Observera formen av definitionen f[n_] := f[n]=. Kolonet efter f[n_] talar om för matematica att skjuta upp beräkningarna tills den verkligen behöver göra det. Att det också stå r upprepat f[n_] := f[n]= garanterar att programmet visserligen skjuter upp beräkningen tills det behövs, men att den också kommer ihå g redan beräknade värden, och inte upprepar beräkningen för dessa. Vi kan jämföra gränsvärdet med det tal som kallas gyllene snittet, ett slags förment idealbmi för snygga rektanglar.

6 6 Laboration3.nb In[39]:= N Sqrt 5 1 Out[39]= In[40]:= EXEMPEL 5: Man kan inte lita på Mathematicas kaninberäkningar och vad betyder nu detta för ens utsikter på arbetsmarknaden Lå t oss ändra startvärdena f[0] och f[1]. Här ett exempel: f 0 13; f ; f n_ : f n f n 1 f n Table N f n 1 f n, n, 1, 0 Out[44]= 5.185, , , , , , , , , , , , , , , , , , , In[45]:= Out[49]= Det verkar som om gränsvärdet även här blir det gyllene snittet. Fler experiment ger samma resultat. Men om man försöker bevisa detta så misslyckas man, för det är inte sant. Om man nämligen har startvärden (f[0],f[1]) som är en multipel av 1, 1 1 f 0 1; f 1 1 Sqrt 5 ; f n_ : f n f n 1 f n Table N f n 1 f n, n, 1, 0 5 så få r man ett annat resultat , , , , , , , , , , , , , , , , , , , Detta illustrerar att man lätt kan luras av beräkningar och missa undantagsfall. Vad man kan bevisa är att så fort som startvärdena inte är en multipel av 1, så kommer kvoterna att konvergera mot gyllenen snittet Detta har också konsekvenser för exaktheten i räkningarna. Så fort som man stör startvärdena lite ifrå n 1, förändras resultatet. I ovanstå ende exempel räknade Mathematica exakt med startvärdena 1, 1 1 5, för att sedan avrunda kvoterna numeriskt. Om vi istället avrundar startvärdena först, så kommer resultatet att se annorlunda ut.

7 Laboration3.nb 7 In[50]:= f 0 1; f 1 1 Sqrt 5 N; f n_ : f n f n 1 f n Table N f n 1 f n, n, 1, 100 Out[54]= , , , , , , , , , , , , , , , , , , , , , , , , , , , , , 1.618, , , , 1.669, , , ,.1758, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , De första talen här svarar alltså mot vad följden kommer att konvergera mot för det exakta startvärdet f[0]=1 och f[]= Men nu har vi stoppat in ett närmevärde på dessa startvärden (bara futtiga 30 decimalers noggrannhet...) och det slå r efter ett tag igenom i resultatet, och ger oss gamla tjatiga gyllene snittet. Osäkerheten i användningen av Mathematica är alltså av två slag : man kan inte gå igenom alla möjligheter, utan bara göra enstaka experiment och sedan kan man inte ens alltid lita på resultaten p g a att avrundningsfel kan ge kvalitativt annorlunda resultat. Empiri kan inte ersätta bevis och en matematikers analys av ett problem. EXEMPEL 6: Fler olösta problem---ett enkelt dynamiskt system In[55]:= Out[55]= Följande följd f[n] har ett startvärde f[1], och sedan är dess värden rekursivt definierade. Om ett värde x är jämnt ska det delas med, annars är nästa värde 3x+1. Vad händer när n gå r mot oändligheten? Först må ste vi definiera funktionen. Det är ju ett vanligt sätt att dela upp en definition av en funktion i olika fall-tänk på definitionen av absolutbelopp-så det finns förstå s möjlighet att göra så i mathematica. Först behöver vi ett kommando som talar om när ett tal är delbart med. Det finns ett kommando som heter Divisible[n,k] och som returnerar True/False beroende på om k delar n. Divisible 15, Divisible 16, False Out[56]= True Sedan finns det ett sätt att ge definitioner av den typ vi behöver. Det heter If och har formen If[kriterium, A, B]. Det returnerar A om kriteriet är sant och B om det är falskt. Alltså ger följande uttryck If[Divisible[x, ], x/, 3*x + 1] oss x/ respektive 3x+1 beroende på om x är delbart med eller inte. Då kan vi å tervända till vå rt problem

8 8 Laboration3.nb In[57]:= f 1 7; f n_ : f n If Divisible f n 1,, f n 1, 3 f n 1 1 ; Starta t ex med f[1]=7. Då blir nästa värde 3x7+1=, och sedan /=11, o s v. In[60]:= Table f n, n, 1, 100 Out[60]= 7,, 11, 34, 17, 5, 6, 13, 40, 0, 10, 5, 16, 8, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4, In[61]:= Vad händer på slutet här? Jo, 4 är delbart med, så om för ett visst n vi har f[n]=4, så är f[n+1]=. Av samma skäl är f[n+]=1. Men nu har vi ett tal som inte är delbart med och då ska vi multiplicera det med 3 och lägga till 1. Så f[n+3]=4. Men då är vi tillbaka där vi började och vi kommer igen att få 4,,1, som de nästa talen i följden. Försök med ett annat startvärde. f 1 318; f n_ : f n If Divisible f n 1,, f n 1, 3 f n 1 1 ; Table f n, n, 1, 100 Out[64]= 318, 1609, 488, 414, 107, 36, 1811, 5434, 717, 815, 4076, 038, 1019, 3058, 159, 4588, 94, 1147, 344, 171, 5164, 58, 191, 3874, 1937, 581, 906, 1453, 4360, 180, 1090, 545, 1636, 818, 409, 18, 614, 307, 9, 461, 1384, 69, 346, 173, 50, 60, 130, 65, 196, 98, 49, 148, 74, 37, 11, 56, 8, 14, 7,, 11, 34, 17, 5, 6, 13, 40, 0, 10, 5, 16, 8, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4 Collatz problem är att avgöra om f[n] alltid hamnar i cykeln 4,,1 när n blir tillräckligt stort, oavsett vad startvärdet är. Det är förstå s rätt ointressant i sig själv, annat än att det har en viss signifikans bortom det vi gör här. Det är ett exempel på enkla diskreta dynamiska system, ett slags enkla babymodeller av en typ som används för att modellera komplexa fenomen i naturen. Det faktum att redan detta enkla system är så pass eländigt komplicerat har alltså betydelse för vå ra förväntningar på hur naturen beter sig. Vi kan inte förvänta oss att klara alla problem, suck. In[65]:= Out[68]= 4 Nu ska vi se att gränsvärdet med de första säg 1000 talen som startvärden ger förr eller senare cykel 41. Då ska vi alltså ha olika startvärden, och det är fiffigast att lägga in detta i en funktion av två variabler, där startvärdet är första variabeln m och antalet iterationer n den andra. f m_, 1 m; f m_, n_ : f m, n If Divisible f m, n 1,, f m, n 1, 3 f m, n 1 1 f 318, 100 Vi vill nu titta på värdena f[m,n] för alla m mindre än 1000 och se om vi få r 4,,1 för n tillräckligt stort. Vi kan göra en tabell av funktionsvärden till f[m, n](den har element så med användning av ett semikolon skriver vi inte ut den...)(observera hur vi talar om att m ska gå frå n 1 till 1000, och m frå n 1 till 150): In[69]:= Dyn Table f m, n, m, 1, 1000, n, 1, 150 ;

9 Laboration3.nb 9 In[70]:= Dyn 13 Out[70]= 13, 40, 0, 10, 5, 16, 8, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4, Vad är resultatet av kommandot table här? Vad är elementen i listan Dyn? Jo 13: e elementet Dyn[[13]] är listan av alla funktionsvärden {f[13,1],f[13,],...,f[13,150]}, d v s effekten av att iterera med startvärdet 13 högst hundrafemtio gå nger. Nu gäller det att hå lla tungan rätt i mun...vi vill välja ut element i Dyn, alltså listor av typen {f[m,1],f[m,],...,f[m,150]}, så att det sista elementen inte är 4,,1. Sista elementet f[m,150] i en så dan lista kan vi få fram med Last[#], där # är variabeln som löper över elementen i listan. Följande kommando plockar alltså ut de {f[m,1],f[m,],...,f[m,150]}, så att det sista elementen inte är 4,,1. In[71]:= ( skrivs som!=, och && är mathematicas symbol för det logiska "och") dd Select Dyn, Last 4 && Last && Last 1 & ; För att nu få fram det första elementet här så använder vi First In[7]:= First dd Out[7]= 703, 110, 1055, 3166, 1583, 4750, 375, 716, 3563, , 5345, , 8018, 4009, 1 08, 6014, 3007, 90, 4511, , 6767, 0 30, , , 15 7, 45 68, 841, 68 54, 34 6, , , 5 697, 77 09, , 19 73, 57 80, 8 910, , , 1 683, , 3 55, , , 4 394, 1 197, 36 59, 18 96, 9148, 4574, 87, 686, 3431, 10 94, 5147, 15 44, 771, 3 164, 11 58, 5791, , 8687, 6 06, , , , 58 64, 9 31, , 43 98, 1 991, , 3 987, 98 96, , , 74, , , , , , , 15 5, 6 66, , , , 3 485, , 35 8, , 8807, 6 4, 13 11, , , 59 45, 9 76, , , 95, , , , , , 75 48, 37 64, 18 81, 9406, 4703, , 7055, 1 166, , , , 47 66, 3 813, , 35 70, , 8930, 4465, , 6698, 3349, , 504, 51, 156, 68, 314, 157, 47, 36, 118, 59, 178, 89, 68, 134, 67, 0, 101, 304, 15, 76, 38 In[73]:= In[74]:= Vi ser alltså att för m=703 räcker inte 150 iterationer av vå r funktion. Men 00 räcker: Table f 703, i, i, 1, 00 Out[74]= 703, 110, 1055, 3166, 1583, 4750, 375, 716, 3563, , 5345, , 8018, 4009, 1 08, 6014, 3007, 90, 4511, , 6767, 0 30, , , 15 7, 45 68, 841, 68 54, 34 6, , , 5 697, 77 09, , 19 73, 57 80, 8 910, , , 1 683, , 3 55, , , 4 394, 1 197, 36 59, 18 96, 9148, 4574, 87, 686, 3431, 10 94, 5147, 15 44, 771, 3 164, 11 58, 5791, , 8687, 6 06, , , , 58 64, 9 31, , 43 98, 1 991, , 3 987, 98 96, , , 74, , , , , , , 15 5, 6 66, , , , 3 485, , 35 8, , 8807, 6 4, 13 11, , , 59 45, 9 76, , , 95, , , , , , 75 48, 37 64, 18 81, 9406, 4703, , 7055, 1 166, , , , 47 66, 3 813, , 35 70, , 8930, 4465, , 6698, 3349, , 504, 51, 156, 68, 314, 157, 47, 36, 118, 59, 178, 89, 68, 134, 67, 0, 101, 304, 15, 76, 38, 19, 58, 9, 88, 44,, 11, 34, 17, 5, 6, 13, 40, 0, 10, 5, 16, 8, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,, 1, 4,