Algoritminen matematiikka

Algoritminen matematiikka Luentomoniste Turun yliopisto Matematiikan laitos 20014 Turku 2016

i Alkusanat Kurssin tarkoituksena on algoritmisen ajattelun omaksuminen ja kehittäminen. Tavanomaisesti matematiikassa kysytään Onko jokin väittämä tosi? tai Onko jokin olemassa? mutta tällä kurssilla tarkastellaan lähinnä kysymystä Miten tämä jokin voidaan laskea ja kuinka nopeasti?. Tietotekniikan myötä algoritmisesta matematiikasta on tullut hyvin tärkeä osa matematiikkaa. Laskentaa, ja osin jopa todistamista, suoritetaan tietokoneilla. Monilla soveltavilla matematiikan aloilla, kuten esimerkiksi kryptografissa, algoritminen ajattelu on välttämätöntä. Kurssilla keskitytään tavanomaisten aritmeettisten ja lukuteoreettisten ongelmien laskennallisen kompleksisuuden arviointiin, ja erityisesti siihen miten nämä probleemat tulee nähdä algoritmisesta näkökulmasta ts. mitä voidaan laskea nopeasti, siis käytännössä, ja mitä ei voida (nykytiedon perusteella). Kurssin esitiedoiksi tarvitaan Algebran peruskurssi I:n tai Kryptografian matemaattiset perusteet kurssien antamia lukuteorian perustietoja. Tämä moniste perustuu suurelta osin Juhani Karhumäen luentomonisteeseen vuodelta 1997. Luentomonistetta ovat sen jälkeen muokanneet ja päivittäneet Ari Renvall (2006) ja Vesa Halava (2016). Lähteenä on lisäksi käytetty seuraavia kirjoja: 1. G. Brassard, P. Bratley: Fundamentals of Algorithmics, Prentice Hall, 1996. 2. T. Cormen, C. Leiserson, R. Rivest, C. Stein: Introduction to Algorithms, MIT Press, 2001 (2nd ed.). 3. J. von zur Gathen, J. Gerhard: Modern Computer Algebra, Cambridge University Press, 2003 (2nd ed.).

Sisältö ii Sisältö 1 Johdanto 1 1.1 Algoritmien tutkimus................................ 1 2 Algoritmien peruskäsitteitä 3 2.1 Esimerkki....................................... 3 2.2 Algoritmi ja algoritminen probleema...................... 4 2.3 Syöte ja alkeisoperaatiot.............................. 5 2.4 Algoritmin kompleksisuus............................. 5 2.5 Funktion kertaluku................................. 7 2.6 Algoritmien kuvauksesta.............................. 10 2.7 Esimerkkejä..................................... 11 3 Aritmeettisia peruslaskutoimituksia 16 3.1 Kahden luvun vertailu............................... 16 3.2 Yhteen- ja vähennyslasku............................. 17 3.3 Kertolasku...................................... 18 3.4 Jakolasku....................................... 19 3.5 Binääriesityksen laskeminen........................... 19 3.6 Potenssi........................................ 20 3.7 Suurin yhteinen tekijä............................... 21 3.8 Neliöjuuri...................................... 23 4 Aritmetiikkaa renkaassa Z m 26 4.1 Yhteen-, kerto- ja vähennyslasku......................... 26 4.2 Käänteisalkio ja jakolasku............................. 27 4.2.1 Lineaarinen kongruenssiyhtälö...................... 28 4.3 Modulaarinen potenssilasku........................... 28 4.3.1 RSA-salakirjoitusmenetelmä....................... 30 5 Algoritmien suunnittelusta 33 5.1 Hajoita-ja-hallitse -menetelmä.......................... 33 5.2 Rekursioyhtälöiden ratkaisemisesta....................... 34 5.3 Karatsuba-kertolasku................................ 36 5.3.1 Parannettu kertoalgoritmi......................... 37 5.4 Matriisien tulo.................................... 38 5.5 Dynaaminen suunnittelu............................. 39 5.6 Binomikerroin.................................... 40 5.7 Matriisiketjun kertolasku............................. 40 6 Polynomien aritmetiikkaa 42 6.1 Polynomien summa ja tulo............................ 42 6.2 Diskreetti Fourier muunnos........................... 43 6.3 Nopea Fourier muunnos............................. 46 6.4 Polynomien nopea kertolasku.......................... 47 6.4.1 Schönhage Strassen algoritmi...................... 48 6.5 Muita polynomiprobleemoja........................... 49

Sisältö iii 7 Alkulukutestaus ja todennäköisyysalgoritmit 58 7.1 AKS algoritmi.................................... 58 7.2 Todennäköisyysalgoritmit............................. 59 7.3 Numeeriset satunnaisalgoritmit......................... 61 7.4 Monte Carlo -algoritmit.............................. 61 7.4.1 Millerin-Rabinin alkulukutestaus.................... 62 7.5 Las Vegas -algoritmit................................ 64 7.5.1 Kokonaislukujen tekijöihinjako...................... 64 7.5.2 Neliöjuuri ryhmässä Z p.......................... 66 8 Epädeterministiset algoritmit 70 9 Liite 1: Kokonaisluvuista i 9.1 Jaollisuudesta.................................... i 9.2 Kongruenssi ja jäännösluokat modulo n.................... iv

1 1 Johdanto 1.1 Algoritmien tutkimus Algoritmi on konstruktiivisen ja diskreetin matematiikan keskeisimpiä käsitteitä. Implisiittisesti algoritmit ovat olleet osa matematiikkaa kautta sen koko historian. Vanhin ja ehkä tunnetuin algoritmi Eukleideen algoritmi on yli 2000 vuotta vanha. Sen laskennallisen kompleksisuuden arviointi vuodelta 1845 (Lame) puolestaan on yksi vanhimmista konkreettisista algoritmiteorian tuloksista. Varsinaisesti algoritmien tutkimus käynnistyi 1930 luvulla teoreettisena Laskettavuuden teorian (ala I, alla) tutkimuksella. Käytännön läheisempää tutkimus oli 1950 luvulla jolloin keskityttiin Algoritmien suunnitteluun ja analysointiin (ala II). Viime aikoina, 1970 luvulta lähtien Kompleksisuusteorian tutkimus (ala III) on ollut keskeisessä asemassa. Kompleksisuusteoriassa tutkitaan esimerkiksi, mitkä probleemat ovat käytännössä algoritmisesti ratkaistavissa polynomiajassa toimivalla algoritmilla tai onko probleemalle olemassa nopeaa todennäköisyysalgoritmilla. Yllä mainituista kolmesta algoritmitutkimuksen alasta käytetään yleensä alla esitetyn mukaisia nimityksiä, niinikään alla esitetään alojen tutkimusten tarjoama keskeinen anti. I: Laskettavuuden teoria; Algoritmisesti ratkeamattomat probleemat, Turingin koneet II: Algoritmien suunnittelu ja analysointi; Monet tärkeät nopeat käytännön algoritmit III: Kompleksisuusteoria; Käytännössä mahdottomat probleemat (nykytiedon mukaan); P? = NP -probleema; todennäköisyysalgoritmit Laskettavuuden teoria mullisti matemaattisen ajattelun, kun A. Turing ja A.

1.1 Algoritmien tutkimus 2 Church vuonna 1936 1 2 osoittivat, että on olemassa algoritmisesti ratkeamattomia probleemoja. Nimittäin vielä vuosisadan vaihteen matemaatikot, kuten D. Hilbert, ajattelivat, että kaikki mielekkäästi määritellyt probleemat ovat ainakin periaatteessa (vaikkakaan ei välttämättä käytännössä) algoritmisesti ratkaistavissa. Kompleksisuusteoria puolestaan on osoittanut, että monet käytännössä tärkeät probleemat, kuten esimerkiksi lukujärjestyksen laatiminen, ovat käytännössä mahdottomia ratkaista (ts. niiden ratkaiseminen vaatii liikaa resursseja), vaikkakin matemaattisesti niiden ratkaiseminen voi olla triviaalia (esim. käydään läpi kaikki vaihtoehdot). Tässä on syytä korostaa, että käytännössä mahdoton tarkoittaa: käytännössä mahdoton nykytiedon mukaan. Se, ovatko kyseessä olevat probleemat todella käytännössä mahdottomia, on yksi modernin matematiikan suurista avoimista kysymyksistä, ns. P? = NP -probleema. Tämän kurssin tarkoituksena on toimia johdatuksena algoritmiseen ajatteluun. Tähän pyritään tarkastelemalla konkreettisten, lähinnä aritmeettisten probleemojen laskennallista vaikeutta. Tarkasteltaviin ongelmiin pyritään etsimään tehokkaita algoritmeja. Siten yllä olevan luokittelun valossa kurssi kuuluu lähinnä alueelle III. Mainittakoon lopuksi, että termi algoritmi juontaa juurensa persialaisesen matemaatikon Mohammed al-khowârizmîn nimestä 800-luvulta. Hän kehitti algoritmiset säännöt lukujen aritmeettisten operaatioiden laskemiseksi: samat, jotka ovat yhä käytössä kouluopetuksessa. 1 Ajan säästämiseksi ohitetaan tässä K. Gödelin epätäydellisyyslauseen (v. 1931) merkitys Turingin ja Churchin tuloksiin. 2 Huomautettakoon kuitenkin täydellisyyden nimissä, että E. Post todisti ensimmäisen ratkeamattomuus tuloksensa jo v. 1924, mutta ei, syystä tai toisesta, tulostaan julkaissut ennen Turingia ja Churchia.

3 2 Algoritmien peruskäsitteitä 2.1 Esimerkki Tarkastellaan kahden positiivisen kokonaisluvun tulon laskemista. Aikojen kuluessa on kehitetty useita erilaisia menetelmiä tämän ongelman ratkaisemiseksi. Mielivaltaisen suurten lukujen tulo opitaan laskemaan jo koulun alaluokilla. Klassinen koulualgoritmi palauttaa pidempien lukujen tulon laskemisen 1- numeroisten lukujen tuloihin, jotka puolestaan muistetaan ulkoa opituista kertotauluista. Ns. arabialaisessa kertoalgoritmissa käytetään apuna laatikkoa, jonka sivujen pituudet ovat samat kuin kerrottavien lukujen pituudet. Kerrottavat luvut asetetaan laatikon sivuille, ja laatikkoon kirjataan kaikkien luvuissa esiintyvien numeroiden tulot oheisen kuvan osoittamalla tavalla. Lukujen tulo saadaan puuttuville sivuille laskemalla diagonaalien summat. Kaksi edellä mainittua menetelmää muistuttavat kovasti toisiaan, mutta venäläisessä kertoalgoritmissa asia ratkaistaan toisin. Siinä toista kerrottavista luvuista toistuvasti puolitetaan (pyöristämällä alaspäin) ja toista tuplataan, kunnes puolitettava luku on ykkönen. Lukujen tulo saadaan ynnäämällä ne tuplatut luvut, joita vastaava puolitettu luku on pariton (venäläisen kertoalgoritmin oikeellisuus, ks. demonstraatiot.) Mikä yllä esitetyistä menetelmistä on paras? Jotta tähän voitaisiin vastata, tarvitaan jokin hyvyyden mittari. Tällä kurssilla eri laskentamenetelmiä vertaillaan niiden tehokkuuden, siis nopeuden, perusteella. Osoittautuu, että tässä mielessä kaikki edellä esitetyt algoritmit ovat asymptoottisesti yhtä hyviä. a) 1 2 3 4 5 6 1 5 4 9 2 5 5 3 5 b) 0 5 1 2 3 0 0 1 4 8 2 0 1 1 5 0 5 5 3 5 4 5 c) 45 22 11 5 2 1 123 246 492 984 1968 3936 123 615 1599 5535 Kuva 1: a) Klassinen, b) arabialainen ja c) venäläinen kertolaskualgoritmi. Esitetään vielä yksi kertolaskualgoritmi. Siinä kerrottavien lukujen a ja b pituus n pitää olla jokin kakkosen potenssi: n = 2 m (jos näin ei ole, lukujen eteen voidaan lisätä tarvittava määrä nollia). Olkoon a= a 1 10 n/2 +a 0 ja b= b 1 10 n/2 + b 0, missä 0 a 0, a 1,b 0,b 1 < 10 n/2. Nyt ab= a 1 b 1 10 n + (a 0 b 1 + a 1 b 0 ) 10 n/2 + a 0 b 0,

2.2 Algoritmi ja algoritminen probleema 4 joten kahden luvun tulo saadaan laskemalla neljä puolta lyhyempien lukujen tuloa (ja lisäksi muutamia yhteenlaskuja ja kymmenellä kertomisia). Nämä pienemmät tulot voidaan edelleen laskea samalla menetelmällä. Näin saadaan rekursiivinen kertolaskualgoritmi, jossa 2 i -numeroisten lukujen tulo saadaan laskemalla (2 i ) 2 1-numeroisten lukujen tuloa. Huomaa jo nyt, että kantaluvulla 10 kertominen vastaa bitttiensiirtoa eli nollan lisäämistä luvun loppun, joten se onnistuu erittäin nopeasti. Lisäksi on selvää, että yhteenlasku on kertolaskua nopeampaa (ks. luku 3). Osoittautuu kuitenkin, ettei edellä esitelty rekursiivinen algoritmi ole sen tehokkaampi kuin aiemmin mainitut menetelmät. Mutta kuten myöhemmin nähdään, ideaa voidaan parannella niin, että tulon laskeminen palautuukin kolmen (eikä neljän) puolta lyhyemmän luvun tuloon. Tuloksena on merkittävästi nopeampi algoritmi, etenkin jos tarkasteltavat luvut ovat suuria. 2.2 Algoritmi ja algoritminen probleema Algoritminen probleema koostuu syötteistä I ja kuhunkin syötteeseen liittyvästä (usein yksikäsitteisestä) tulosteesta. Probleema voidaan siis ajatella funktiona I O, missä O on kaikkien mahdollisten tulosteiden joukko. Algoritmi on puolestaan menetelmä, jolla tarkasteltava probleema voidaan mekaanisesti ratkaista. Voidaan siis sanoa, että algoritmi on metodi yllä mainitun funktion I O laskemiseksi. Jos tehtävänä on ratkaista probleema jollakin tietyllä syötteellä, puhutaan probleeman instanssista. Esimerkiksi kahden positiivisen kokonaisluvun kertolasku on algoritminen probleema, ja se voidaan ratkaista millä tahansa alun esimerkissä mainitulla algoritmilla. Ongelman syötteet ovat siis kokonaislukupareja ja parin (123, 45) tulon laskeminen on yksi tämän probleeman instansseista. Yleensä algoritmilta vaaditaan seuraavia ominaisuuksia. (i) Algoritmin suoritus koostuu joukosta peräkkäin suoritettavia yksinkertaisia operaatioita, ns. alkeisoperaatioita. (ii) Algoritmin ohjeita sovelletaan deterministisesti, ts. algoritmin suoritus etenee samalla syötteellä aina tarkalleen samalla tavalla. (iii) Algoritmin ohjeet ovat universaalisia; ts. algoritmi ratkaisee ongelman kaikilla mahdollisilla syötteillä. (iv) Algoritmin ohjeet ovat terminoivia; ts. kullakin syötteellä tarvitaan vain äärellinen määrä alkeisoperaatioita. Tosin käyttökelpoisia käytännön laskentamenetelmiä voidaan saada, vaikka kohdasta (ii) tingittäisiinkin, esim. myöhemmin käsiteltävät todennäköisyys algoritmit.

2.3 Syöte ja alkeisoperaatiot 5 Algoritmiset probleemat, joiden vastaus on aina joko KYLLÄ tai EI (tai 1/0) ovat algoritmien teorian kannalta erityisen tärkeitä. Tällaisia probleemoja kutsutaan päätäntäongelmiksi tai vaihtoehtoisesti ratkeavuusongelmiksi. Esimerkiksi probleema, jossa kysytään, onko syötteenä saatu luku alkuluku vai ei, on päätäntäongelma. 2.3 Syöte ja alkeisoperaatiot Algoritmien tehokkuutta mitataan sen syötteen s koon, merk. s l, funktiona. Syötteen koko voidaan tapauksesta riippuen määritellä hieman eri tavoin, mutta intuitiivisesti se yleensä ilmoittaa sen, paljonko tilaa (tai tietokoneen muistia) tarvitaan syötteen esittämiseen. Esimerkiksi kokonaislukusyötteen kooksi on luonnollista määritellä luvun pituus. Kuitenkin esimerkiksi n n matriisin kooksi ajatellaan yleensä n (eikä n 2 ). Saatuaan syötteen s algoritmi suorittaa alkeisoperaatioita niin kauan, kunnes tuloste saadaan. Se, mitä alkeisoperaatioilla tarkoitetaan, vaihtelee tarkasteltavan probleeman mukaan. Esimerkiksi kertoalgoritmeissa 1-numeroisten lukujen tulon (ja summan) laskeminen ajatellaan alkeisoperaatioksi. Joissakin lajittelualgoritmeissa kahden luvun suuruuden vertailu katsotaan alkeisoperaatioksi. Sen sijaan algoritmin ohjauskäskyjä ei ole tapana laskea alkeisoperaatioiksi. Ideana on, että yhden alkeisoperaation suorittaminen onnistuu aina vakioajassa ja että algoritmin suoritusaika on suoraan verrannollinen suoritettujen alkeisoperaatioiden määrään. 2.4 Algoritmin kompleksisuus Tarkasteltava ongelma voidaan (ainakin useimmiten) ratkaista useilla erilaisilla algoritmeilla. Tällöin on luonnollista kysyä: Mikä ongelman ratkaisevisista algoritmeista on paras? Tällä kurssilla algoritmeja vertaillaan lähinnä niiden nopeuden perusteella. Nopeus puolestaan mitataan laskemalla, kuinka monta alkeisoperaatiota algoritmin suorittaminen vaatii. Olkoon T A,s algoritmin A suorittamien alkeioperaatioiden määrä syötteellä s. Syötteen s koko s on luonnollinen luku, ja algoritmin A kompleksisuus määritellään funktiona T A : N N, T A (n)= max s l =n {T A,s}. T A (n) siis kertoo, kuinka nopeasti tuloste varmasti saadaan kaikilla n-kokoisilla syötteillä. Toisinaan tätä kutsutaan pahimman tapauksen kompleksisuudeksi. Usein parempi mittari algoritmin tehokkuudelle olisi keskimääräinen kompleksisuus. Se on kuitenkin lähes aina paljon vaikeampi laskea.

2.4 Algoritmin kompleksisuus 6 Yllä tarkasteltiin algoritmissa tarvittavien laskuaskeleiden määrää, siis aikakompleksisuutta. Yhtä hyvin voitaisiin tarkastella vaikka algoritmin vaatimien muistipaikkojen määrää, eli tilakompleksisuutta. Tällä kurssilla kompleksisuudella tarkoitetaan aina aikakompleksisuutta. Yllä kompleksisuuskäsitteet määriteltiin algoritmeille. Käsitteet voidaan laajentaa koskemaan myös tarkasteltavaa algoritmista probleemaa. Probleeman AP kompleksisuus on sen parhaan ratkaisualgoritmin kompleksisuus. Tässä paras tarkoittaa asymptoottisesti nopeiten toimivaa algoritmia. Algoritmin kompleksisuuden analysointi tarkoittaa sen kompleksisuuden (tai oikeastaan sen kertaluvun, suuruusluokan) määräämistä. Tämä on useimmiten mahdollista suorittaa tekemällä esim. sopivia arviointeja. Sen sijaan algoritmisen probleeman AP kompleksisuuden (kertaluvun) määrääminen on usein ylivoimaisen vaikeaa. Mikä tahansa AP:n ratkaiseva algoritmi antaa ylärajan AP:n kompleksisuudelle, mutta hyvien alarajojen määrääminen on yleisesti algoritmien teorian vaikeimpia asioita. Pitäisi nimittäin osoittaa, että mikään algoritmi ei ratkaise AP:ta annettua funktiota nopeammin. Esimerkki 2.1. Tämän luvun alussa tarkasteltiin kokonaislukujen kertolaskun laskevia algoritmeja. Voidaan osoittaa, että esitetyt algoritmit toimivat ajassa O(n 2 ) (ordo-merkintä), mikä tarkoittaa, että on olemassa positiivinen luku α ja luonnollinen luku n 0 joille tiedetään, että kaikille n n 0 T A (n) αn 2. Tästä seuraa, että algoritmisen probleeman kompleksisuus on myös O(n 2 ). Toisaalta, myöhemmin tällä kurssilla osoittautuu, että kertolasku-probleeman algoritminen kompleksisuus on O(n(logn) 2+ε ), koska on olemassa algoritmi, joka toimii ajassa O(n(logn) 2+ε ). Todettakoon vielä, että paras tunnettu kertolaskualgoritmi käytännössä laskettavan kokoisille luvuille toimii O(n log n log(log n)) ajassa (Schönhage and Strassen 1971, Knuth 1998). Sitäkin asymptoottisesti nopeampia algoritmeja on löydetty (esim. ns Fürer-algortimi), mutta ne ovat Schönhage-Strassen algoritmia nopeampia vasta luvuilla, joita käytännön sovelluksissa ja laskuissa ei käytetä. Algoritmit ja algoritmiset probleemat jaetaan tavallisesti kahteen luokkaan, missä rajan määrää polynomiaikaisuus. Algoritmia A kutsutaan toteutettavaksi (feasible), jos on olemassa sellainen polynomi P(n), että T A (n) P(n) jostakin rajasta n n 0 lähtien. Muussa tapauksessa algoritmia sanotaan ei toteutettavaksi (infeasible). Algoritmista probleemaa AP kutsutaan ratkaistavaksi (tractable), jos AP:lle tunnetaan toteutettava ratkaisu; muuten AP:ta sanotaan ei ratkaistavaksi (intractable). Usein ajatellaan, että ratkaistavat probleemat ovat helppoja ja siten käytännössä ratkeavia. Kirjaimellisesti tämä ei tietysti pidä paikkaansa, mutta luo-

2.5 Funktion kertaluku 7 kittelu on teoreettisesti perusteltua, ja itse asiassa yleensä polynomiaikaiset algoritmit toimivat alhaista astetta olevassa polynomiajassa. Toisaalta ei ratkaistavien probleemien vähänkin suuremmat instanssit ovat varmasti käytännössä mahdottomia ratkaista ainakin tällä hetkellä. 2.5 Funktion kertaluku Esimerkki 2.2. Alla on taulukoitu algoritmin vaatima aika, kun oletetaan yhden alkeisoperaation suorittamisen kestävän yhden nanosekunnin (10 9 s) verran. n= 10 n= 20 n= 30 n= 50 n= 100 n= 1000 n 0,01 µs 0,02 µs 0,03 µs 0,05 µs 0,10 µs 1,00 µs n log 2 n 0,03 µs 0,09 µs 0,15 µs 0,28 µs 0,66 µs 9,97 µs n 2 0,10 µs 0,40 µs 0,90 µs 2,50 µs 10 µs 1000 µs n 5 0,10 ms 3,20 ms 24,3 ms 0,31 s 10,0 s 11,6 vrk 2 n 1,0 µs 1,0 ms 1,07 s 13,0 vrk 3000 mki 10 274 mki 3 n 59,0 µs 3,5 s 2,4 vrk 2 10 7 v 10 21 mki... Nähdään, että jos kompleksisuus on eksponentiaalinen (kaksi viimeistä riviä), kasvaa algoritmin suoritusaika vähänkin isommilla instasseilla käsittämättömän suureksi (yksikkö mki tarkoittaa maailmankaikkeuden ikää 3 ). Jos kompleksisuus on polynomiaalinen, ei vastaavaa ilmiötä esiinny. Tarkastellaan vielä teknologian kehittymisen tuomia mahdollisuuksia. Seuraavasta taulukosta nähdään tietokoneiden nopeutumisen vaikutukset suurimpaan ongelmakokoon, joka ratkeaa jossakin annetussa ajassa (esim yhdessä tunnissa). kompl. nykykoneet 100 nykykone 10 6 nykykone n N 1 100 N 1 1000000 N 1 n log 2 n N 2 = 100 53 N 2 270000 N 2 n 2 N 3 10 N 3 1000 N 3 n 5 N 4 2,5 N 4 16 N 4 2 n N 5 N 5 + 6,6 N 5 + 19,9 3 n N 6 N 6 + 4,2 N 6 + 12,6 Kahden viimeisen sarakkeen luvut kertovat sen ongelmakoon, joka ratkeaa samassa ajassa, kun käytössä on sata/miljoona kertaa tehokkaampi tietokone. Taas ero polynomiaikaisten ja eksponentiaalisten algoritmien välillä on räikeä. Eri algoritmeja verrattaessa olennaisinta on, kuinka kompleksisuus muuttuu, kun ongelmakoko kasvaa yhä suuremmaksi. Sitä varten otetaan käyttöön 3 Maailmankaikkeuden ikä on nykytietämyksen mukaan kuitenkin alle 14 miljardia vuotta.

2.5 Funktion kertaluku 8 seuraavat merkinnät. Olkoot f, g : N R +. Määritellään 4 f (n)= O(g (n)), joss α>0,n 0 n n 0 : f (n) α g (n), f (n)=ω(g (n)), joss β>0,n 0 n n 0 : f (n) β g (n), f (n)=θ(g (n)), joss α,β>0,n 0 n n 0 : β g (n) f (n) α g (n), f (n)=o(g (n)), joss lim n f (n) g (n) = 0, f (n) g (n), joss lim n f (n) g (n) = 1. Tarkkaan ottaen esimerkiksi O ( g (n) ) on luokka funktioita, ja merkintä f (n)= O ( g (n) ) Tarkoittaa, että f (n) kuuluu luokkaan O ( g (n) ). Esimerkki 2.3. Seuraavat väitteet ovat suhteellisen helppoja todistaa: a 0 + a 1 n+...+ a k n k = Θ(n k ), missä a k > 0 n a = o(n b ), kun a,b R ja 0< a< b log c n= Θ(log d n) (c,d > 1) log c n= o(n a ) (c > 1, a> 0) Sopimus. Jos logaritmien kantalukua ei mainita, tarkoitetaan aina 2-kantaista logaritmia: logn= log 2 n. Näin ollen edellisestä esimerkin kolmannesta kohdasta seuraa, että log c n= Θ(logn) kaikilla kantaluvuilla c > 1. Esimerkki 2.4. Esitetään tyypillinen menetelmä summalausekkeen asymptoottisen kertaluvun määräämiseksi. Osoitetaan, että S(n)= n i k = Θ(n k+1 ). i=1 Tämä voidaan todistaa näyttämällä, että S(n)= O(n k+1 ) ja että S(n)=Ω(n k+1 ). Koska i k < n k, kun 1 i n, niin Siis S(n)= O(n k+1 ). S(n) n n k = n n k = n k+1. i=1 4 Monisteessa esiintyvä sana joss on lyhennys fraasista jos ja vain jos. Se taas on ekvivalentti (eli tarkoittaa samaa) fraasin silloin ja vain silloin kun kanssa.

2.5 Funktion kertaluku 9 Myös alaraja eli Ω-suuntaan todistus on lähes yhtä helppo. Nyt arvioimalla 0 i k kun i n 2 ja ( n 2 )k i k kun i n 2 saadaan S(n) n i= n 2 ( n 2 )k n 2 ( n 2 )k = 1 2 k+1 nk+1. Näin ollen siis S(n)=Ω(n k+1 ). Jos F on luokka funktioita N R +, niin luokka O(F ) on luonnollista määritellä ehdosta O(F )= O(f ). f F Vastaavasti funktioille määritellyt operaatiot voidaan laajentaa joukoille luonnollisella tavalla; esimerkiksi ja g +F = {g }+F = {g + f } g (F )= f F f F g f. Tällöin yhdistämällä asymptoottisia luokkia O, Ω ja Θ sekä funktioiden operaatioita, kuten+ja voidaan määritellä uusia funktioluokkia. Esimerkki 2.5. Voidaan osoittaa, että ( O f (n)+o ( g (n) )) = O ( f (n)+ g (n) ) = O ( max{f (n), g (n)} ) ; ( ) n 1+O(1) = 2 O(n) = O(α n ). α 1 Mainittakoon, että niiden päätösongelmien joukkoa, joiden kompleksisuuden ylärajana on luokkaan 2 O(n) kuuluva funktio, merkitään EXP, siis eksponentiaalisessa ajassa ratkeavat ongelmat. Polynomiajassa ratkeavien (kompleksisuuden ylärajana jokin polynomi) päätösongelmien joukkoa merkitään P:llä. Tällä kurssilla funktioluokkia O ( f (n) ) jne. ajatellaan algoritmisina kompleksisuusluokkina, joten f (n) on tavallisesti varsin siististi käyttäytyvä ; esimerkiksi muotoa n k, n logn, loglogn, a n, n logn. Tällä kurssilla käsitellään algoritmien kompleksisuuksia, joten yleensä tarkasteltavien funktioiden arvot kasvavat kun syötteen koko kasvaa. Siksi tarkasteltavat funktiot ovat ei vähenevä tai ainakin lopulta ei vähenevä, siis ei vähenevä jostakin luvun n arvosta alkaen. Määritelmä 2.1. Olkoon f : N R + lopulta ei vähenevä ja b 2 kokonaisluku. Sanotaan, että f on b-sileä, jos f (b n)= O ( f (n) ).

2.6 Algoritmien kuvauksesta 10 Usein algoritmien kompleksisuuden arviointi on helpompaa, jos syötteen pituus on jotakin sopivaa muotoa. Jos esimerkiksi rekursiivinen algoritmi jakaa n-pituisen syötteen aina n 2 - ja n 2 pituisiin osiin, ovat kompleksisuustarkastelut luultavasti helpompia, jos n on jokin kakkosen potenssi (silloinhan osat ovat aina yhtä suuret ja myös osien koot ovat kakkosen potensseja). Osoitetaan seuraavaksi, että yleensä voidaan olettaa, että syötteen pituus on sopivaa muotoa. Määritellään ensin ehdolliset kompleksisuusluokat. Määritelmä 2.2. Funktio f kuuluu luokkaan O ( g (n); P(n) ), jos n 0,α>0: ( P(n) on tosi n n 0 ) = f (n) α g (n). Lemma 2.1. Olkoon p 2 kokonaisluku ja g (n) p-sileä sekä f (n) lopulta ei vähenevä. Silloin f (n)= O ( g (n); n on p:n potenssi ) = f (n)= O ( g (n) ). Todistus. Olkoon p m n< p m+1 jollakin m N. Silloin f (n) a f (p m+1 ) b α 1 g (p m+1 ) c α 1 α 2 g (p m ) d α g (n). Kun oletetaan, että argumentti on riittävän suuri, seuraavat arviot a d siitä, että a) f on lopulta ei vähenevä; b) f (n)= O ( g (n) ), kun n on p:n potenssi; c) g on p-sileä; ja d) g on lopulta ei-vähenevä. Yllä olevissa tarkasteluissa, erikoisesti edellisessä lemmassa, O voidaan korvata symbolilla Ω tai Θ. 2.6 Algoritmien kuvauksesta Tässä monisteessa osa algoritmeista kuvataan pelkästään sanallisesti vain oleellisimat seikat mainiten. Joissakin tapauksissa taas annetaan tarkempi kuvaus, joka on helpompi muuntaa vaikka tietokoneohjelmaksi. Koska algoritmin tulee ratkaista ongelma kaiken kokoisilla syötteillä, tarvitaan joitakin lyhennysmerkintöjä. Alla on mainittu käytetyn pseudokoodin yleisimmät käskyt. Toistorakenteet: for i = 1 to n do... repeat... until lopetetaan while jatketaan do...

2.7 Esimerkkejä 11 Haaraumat: if... then (... else... ) Aliprosessien kutsut (mukaanlukien rekursiot) Lopetuskäskyt: return (vastaus) quit Käskyjen merkitykset lienevät ilmeisiä. Merkintä x α tarkoittaa, että muuttujan x arvoksi asetetaan α. Lisäksi yleensä ajatellaan, että syötteen pituus, jota merkitään useimmiten parametrillä n, on tiedossa. Esimerkiksi alla on alun esimerkissä mainitun venäläisen kertoalgoritmin kuvaus. Algoritmi 2.1. Venäläinen kertoalgoritmi. SYÖTE: kokonaisluvut a, b > 0 TULOSTE: tulo ab x 0 while a> 0 do if a on pariton then x x+ b a a 2, b 2b return x 2.7 Esimerkkejä Kerrataan vielä määritelmiä ja termejä muutaman esimerkin kautta. Esimerkki 2.6. Tarkastellaan probleemaa PRIME(a), joka päättää, onko syötteenä saatava positiivinen kokonaisluku a alkuluku vai ei. Tällä probleemalla on triviaali ratkaisu: for i = 2 to a do testaa jakaako i luvun a Jaollisuustestit voidaan tehdä tavallisella jakoalgoritmilla. Jos luvun a pituus binäärilukuna on n (siis 2 n 1 a< 2 n ), niin tavanomaisen jakoalgoritmin kompleksisuus on O(n 2 ). Testijakojen tekeminen on siis nopeaa. Testejä pitää kuitenkin tehdä O( a) = O(2 n/2 ) kertaa, joten algoritmin kompleksisuus on eksponentiaalinen. Mainittakoon, että PRIME probleema on yksi tutkituimpia matemaattisia ongelmia. Sille löydettiin polynomiaikainen algoritmi vasta vuonna 2002. PRIME probleemaa käsitellään tarkemmin myöhemmin tällä kurssilla.

2.7 Esimerkkejä 12 Huomautus. Jos syötteenä on n pituinen kokonaisluku a ja jotain operaatiota täytyy toistaa k a kertaa, on algoritmin kompleksisuus aina eksponentiaalinen: k a= 2 n/k. Luvun n suurilla arvoilla tällaiset algoritmit ovat käyttökelvottomia. Esimerkki 2.7. Tarkastellaan probleemaa FIBONACCI(n), jossa tehtävänä on laskea Fibonaccin luku F n. Fibonaccin luvuthan määritellään ehdoista F 0 = 0, F 1 = 1,. F n+2 = F n+1 + F n, kun n 0 Esitetään neljä menetelmää probleeman ratkaisemiseksi. A) Lasketaan F n kaavasta F n = a α n + b β n missä α= 1 2 (1+ 5) ja β= 1 2 (1 5) sekä a ja b R ovat vakioita (ja voidaan laskea rekursion alkuarvoista). Kaava voidaan todistaa vaikka induktiolla 5. B) Lasketaan F n rekursiivisesti algoritmilla Fibo(n): if n= 0 tai n= 1 then return F 0 = 0 tai F 1 = 1 else x Fibo(n 2), y Fibo(n 1) return F n = x+y C) Lasketaan F n seuraavasti: if n= 0 tai n= 1 then return F 0 = 0 tai F 1 = 1 else x 0 ja y 1 for i = 2 to n 1 do s x+y, x y, y s return F n = x+y D) Määritellään E = ( 0 1 1 1), lasketaan matriisi E n+1 ja tulostetaan sen paikassa (1,1) oleva alkio. Selvästi algoritmit B ja C toimivat oikein. Algoritmin D oikeellisuus seuraa kaavasta E n+1 = F n F n+1, F n+1 F n+2 mikä nähdään oikeaksi induktiolla. Arvioidaan seuraavaksi tarvittavien aritmeettisten operaatioiden määrää yllä olevissa algoritmeissa. Algoritmi A vaatii, ainakin tavanomaisesti toteutettuna, Θ(n) aritmeettista operaatiota reaaliluvuilla. Siis vaikka tulos on kokonaisluku, laskut suoritetaan 5 Tosiassa kaava saadaan ratkaisemalla Fibonaccin lukujen rekursio.

2.7 Esimerkkejä 13 reaaliluvuilla. Siksi laskun tulos on aina vain likiarvo ja vasta virhetarkastelun jälkeen voidaan olla varmoja tuloksen oikeellisuudesta. Algoritmi ei ole algoritmisesti selkeä. Algoritmista A saadaan kuitenkin algoritmisesti selkeä korvaamalla reaalilukujen laskut symbolisella laskennalla, ks. demonstraatiot. Merkitään algoritmin B kompleksisuutta T :llä. Silloin T (0)=T (1)=0 ja T (n)=t (n 1)+T (n 2)+1, joten T (n) F n 1 ( n 2). Näin ollen T (n)=ω(α n ), missä α= 1 2 ( 5+1)>1, ja algoritmin kompleksisuus on eksponentiaalinen. Algoritmi C puolestaan suorittaa kussakin for silmukassa vain yhden aritmeettisen operaation, joten sen kompleksisuus on Θ(n). On syytä huomata, että vaikka tässä laskettaisiin kaikki toiminnot, kuten esimerkiksi testaus n? = 0, asetukset x y, indeksimuuttujan i kasvattaminen jne., niin kompleksisuus säilyisi luokassa Θ(n). Algoritmissa D ongelma ratkeaa laskemalla matriisin E potensseja. Myöhemmin tullaan näyttämään, että luvun a potenssin a n laskeminen onnistuu Θ( n l ):lla kertolaskulla. 6 Aivan samoin matriisin n:s potenssi voidaan laskea käyttäen Θ( n l ) matriisien kertolaskua. Yksi 2 2 matriisien tulo vaatii vakiomäärän (12 kpl) aritmeettisia operaatioita, joten tämän algoritmin kompleksisuus on Θ( n l ) = Θ(logn) aritmeettista operaatiota. Yllä laskettiin eri algoritmien vaatimia aritmeettisia operaatioita n:n funktiona, missä on siis luku n, jota vastaava luku F n pitää laskea. Syötteen koko on siis tässä tapauksessa luvun n pituus, joka on siis logn. Algoritmi D oli niistä (asymptoottisesti) paras 7, se vaati vain lineaarisen määrän operaatioita syötteen n pituuden log n suhteen. Nämä ovat kuitenkin minkä tahansa pituisten lukujen aritmeettisia operaatioita. Nimittäin, ns. bittioperaatiota, eli 1 numeroisten lukujen aritmeettisia operaatioita, tarkastellessa huomataan, että itse asiassa mikään algoritmi ei voi toimia polynomiajassa. Tämä johtuu siitä, että Fibonaccin luvut ovat eksponentiaalisen pitkiä luvun n pituuden suhteen. Näin ollen jo pelkkä vastauksen tulostaminen vie eksponentiaalisen ajan. Esimerkki 2.8. Tarkastellaan niin sanottua Collatzin probleemaa. Kutakin luon- 6 Ns. peräkkäisten neliöiden menetelmällä. 7 Tosin Algoritmin A muunnelma, jossa irrationaalilukuja α ja β käsitellään symbolisesti kahden rationaalikertoimen parina eikä reaalilukuina toimii asymptoottisesti aivan yhtä nopeasti, ks. demonstraatiot.

2.7 Esimerkkejä 14 nollista lukua n kohden määritellään jono (a j ) j=0 ehdosta n jos j = 0 a j = a j 1 /2 jos a j 1 on parillinen. 3a j 1 + 1 Olkoon f funktio, joka määritellään ehdosta jos a j 1 on pariton f (n)=min{j a j = 1}. Onko f algoritmisesti laskettavissa, ts. onko olemassa algoritmia, joka syötteelle n tulostaa luvun f (n)? Jonon (a j ) määrittelyn perusteella on helppoa laatia ratkaisumenetelmä, joka saatuaan syötteen n laskee peräkkäin lukuja a j ja tulostaa ensimmäisen j :n, jolle a j = 1. Menetelmää voi kutsua algoritmiksi, jos kyseinen j on aina olemassa. Valitettavasti sitä onko kaikilla n:n arvoilla olemassa tällainen j, ei tiedetä. Algoritmin määritelmän kohdan (iv) nojalla ei tiedetä, onko f hyvin määritelty algoritminen probleema, tai sen laskeva algoritmi määritelmän mukainen algoritmi. Jos algoritmin määritelmästä unohdetaan kohta (iv), eli että kaikille syötteille algoritmi vaatii äärellisen määrän askeleita, saadaan ns. puolialgoritmi. Edellä siis kuvattiin puolialgoritmi funktion f laskemiseksi. Kysymys terminoiko annettu puolialgoritmi annetulla syötteellä on yleisesti erittäin vaikea kysymys 8. Esimerkki 2.9. Olkoon ρ [0, 1] reaaliluku. Liitetään lukuun ρ algoritminen probleema P ρ, missä tehtävänä on syötteellä n laskea luvun ρ n:s desimaali. Algoritmisena probleema P ρ on hyvin määritelty. Mutta onko sillä ratkaisua; ts. onko olemassa algoritmia, joka ratkaisee P ρ :n? Vastaus riippuu luvun ρ valinnasta. Esimerkiksi tapauksissa ρ = 1 2 tai ρ = 2 3 vaadittu algoritmi on helppo antaa. Näin on yleisemminkin aina, kun ρ Q, vaikka perustelu onkin hieman hankalampi. Mutta suurimmalle osalle ρ:n valintoja vastaus on kielteinen, sillä välin [0,1] reaalilukujen kardinaliteetti on ylinumeroituva; mutta algoritmeja on vain numeroituva määrä. Jälkimmäinen väite seuraa siitä, että algoritmi koostuu aina äärellisestä määrästä äärellisiä ohjeita. Siispä algoritmeilla on aina äärellinen deskriptio esimerkiksi suomen kielen lauseina. Kaikki äärelliset lauseet voidaan asettaa jonoon. 9 Yl- 8 Tämä on ns. pysähtymisongelma. 9 On kuitenkin huomattava että tämä järjestys ei ole triviaali, eteenkään kun sallitaan numeroituvasti ääretön määrä symboleja. Äärellisiä merkkijonoja yli numeroituvan aakkoston on kuitenkin numeroituva määrä (todistus löytyy esim. internethaulla Cantor s zigzag).

2.7 Esimerkkejä 15 lä oleva osoittaa, että valtaosa reaaliluvuista on algoritmisen matematiikan saavuttamattomissa. 10 10 Lukuja, joille algoritmi P ρ on olemassa kutsutaan englanniksi termillä computable numbers. Niiden tutkimuksen aloitti muuan A. Turing vuonna 1936.

16 3 Aritmeettisia peruslaskutoimituksia Tässä luvussa tarkasteltavat probleemat ovat hyvin tuttuja kokonaislukujen aritmeettisia laskutoimituksia ja niiden laskennallista kompleksisuuden määrääminen. Nähdään, että jotkut probleemat voidaan ratkaista ei triviaalilla metodilla yllättävän nopeasti. Pohditaan aluksi, missä muodossa algoritmit saavat kokonaislukusyötteensä. Tietokoneissa, joissa on l-bittinen prosessori, esitetään kokonaisluku a vektorina [b, a 0, a 1,..., a n 1 ], missä a= ( 1) s n 1 i=0 a i (2 l ) i, 0 a i < 2 l kaikille i = 0,...,n 1 ja a n 1 0, ja b ilmoittaa luvun merkin ja pituuden: b = s 2 l 1 + n (s {0,1}). Luvut siis esitetään 2 l -kantaisessa järjestelmässä, ja b kertoo luvun pituuden ja merkin. Lukuja b ja a i kutsutaan tällä kurssilla numeroiksi vaikka ne itse asiassa ovat lukuja. Luvut a i kuitenkin vastaavat 2 l -kantaisen esityksen bittejä eli 1-numeroisia lukuja. Huomaa, että kokonaislukujen esittämiseen on olemassa myös muita tapoja, esim. binäärikoodatuilla desimaaleilla tai kakkosen komplementti esityksellä. Algoritmien kannalta ei ole olennaista, missä kannassa luvut esitetään. Vaikka algoritmit onkin yleensä tarkoitus toteuttaa tietokoneilla ja siten 2 l kantainen esitys olisi luonnollinen, voi olla helpompi ajatella normaalia 10 kantaista esitystä. Merkitään luvun a esitystä kantaluvun k suhteen a= (a n 1,..., a 1, a 0 ) k. Nyt siis a = n 1 i=0 a i k i, missä siis 0 a i < k. Määritellään, että luvun a pituus a l = n. (Kuten yllä todettiin, a:n esittämiseen tarvitaan itse asiassa n+1 numeroa {0,1,...,k 1}.) Näin ollen a l = log k a +1. Algoritmien kompleksisuutta arvioitaessa riittää muistaa, että a l = O(log a). Alkeisoperaatioiksi on luonnollista määritellä 1-pituisilla luvuilla suoritettavat operaatiot: esim. yhteenlasku, kertolasku, vertailu ym. Näitä operaatioita kutsutaan usein bittioperaatioiksi riippumatta siitä, missä järjestelmässä luvut on annettu. Joskus algoritmien kompleksisuutta määrättäessä lasketaan aritmeettisten operaatioiden määrää. Tällä tarkoitetaan mielivaltaisen pitkien lukujen yhteen-, vähennys-, kerto- ja jakolaskujen määrää. 3.1 Kahden luvun vertailu Kahden luvun vertailu on hyvin määritelty algoritminen probleema. Syötteenä saadaan luvut a ja b, ja tuloste on joko 0 tai 1 sen mukaan, onko a b vai a> b. Merkitään tätä probleemaa C(a,b):llä.

3.2 Yhteen- ja vähennyslasku 17 C (a,b) on helppo ratkaista. Algoritmi 3.1. Algoritmi kahden luonnollisen luvun vertailemiseksi. SYÖTE: luvut a, b TULOSTE: 0 jos a b, muuten 1 if a l < b l tai a l > b l then return 0 tai 1 else for i = a l 1 downto 0 do if a i < b i tai a i > b i then return 0 tai 1 return 0 (sillä a= b) Algoritmin kompleksisuutta arvioitaessa on siis laskettava vertailujen x < y määrä, missä x ja y ovat 1 numeroisia lukuja. Jos a ja b ovat (korkeintaan) n pituisia lukuja, niin selvästi 2n vertailua riittää aina. Näin ollen algoritmi toimii ajassa O(n). Pahimmassa tapauksessa (jos a ja b poikkeavat vain vähiten merkitsevässä numerossa) algoritmi myös vaatii mainitut 2n+ 2 vertailua, joten se toimii ajassa Ω(n). Siis algoritmi toimii ajassa Θ(n). Yllä oleva algoritmi osoittaa, että probleema C(a, b) kuuluu luokkaan O(n). Mutta kuuluuko se luokkaan Θ(n); ts. vaatiiko jokainen sen ratkaiseva algoritmi ajan Ω(n)? Tämä on ilmeistä, sillä jos vertailuja tehdään vähemmän kuin n kappaletta (saati sitten vähemmän kuin O(n) kpl), jää väkisinkin jokin pari a i0,b i0 vertailematta. Tällaisella algoritmilla ei probleemaa voi ratkaista syötteellä, joissa a i = b i aina kun i i 0. Näin on perusteltu seuraava lause. Lause 3.1. Probleema C(a,b) on luokassa Θ(n). 3.2 Yhteen- ja vähennyslasku Olkoot a ja b ei negatiivisia kokonaislukuja, ja olkoon niistä suuremman pituus n (käytetyssä k kantaisessa järjestelmässä). Merkitään A(a, b):llä probleemaa, jossa pitää laskea summa a+ b, ja S(a,b):lla probleemaa, jossa pitää laskea erotus a b. Aivan kuten edellä vertailu-probleemassa on nytkin selvää, että probleemoja ei voida ratkaista alle lineaarisessa ajassa, joten ne ovat luokassa Ω(n) 11 11 Turingin kone tasolla tehdään kompleksisuuksisuusteoriassa yleensä oletus, että ongelman koko syöte pitää lukea joten ns. sublineaarisia kompleksisuuksia ei ole olemassa. Vaikka bitin lukeminen ei ole alkeisoperaatio tällä kurssilla, voidaan olettaa, että algoritmi käyttää laskuissaan jokaista syötteen bittiä. Näin ollen kaikki kurssilla käsiteltävät probleemat kuuluvat triviaalisti luokkaan Ω(n). Sublineaarisia kompleksisuuksia kuitenkin esiintyy kirjallisuudessa, esim. ns. puolitushakualgoritmi toimii O(logn) vertailulla. Huomaa kuitenkin, että puolitushaku-algoritmissa vertailut

3.3 Kertolasku 18 Toisaalta kumpikin probleema ratkeaa ajassa O(n) tutulla kouluaritmetiikalla. Yhteenlaskun suorittamiseen riittää 2n 1 alkeisoperaatiota, kun on otettu huomioon muistinumeroilla operointi. (Itse asiassa tietokoneen prosessorissa muistinumeroiden käsittely on yhdistetty alkeisyhteenlaskuun, jolloin voidaan sanoa, että n alkeisoperaatiota riittää.) Vähennyslaskun kompleksisuutta tarkasteltaessa muistinumerot aiheuttavat hiukan enemmän huolta, mutta siinäkin saadaan tarvittavien operaatioiden ylärajaksi cn, missä vakion c arvo riippuu alkeisvähennyslaskun tarkasta määritelmästä. Lause 3.2. Probleemat A(a,b) ja S(a,b) ovat luokassa Θ(n). 3.3 Kertolasku Merkitään kertolaskuprobleemaa M(a, b):llä. Oletetaan, että n-pituiset luvut a = (a n 1... a 1 a 0 ) k ja b = (b n 1...b 1 b 0 ) k ovat positiivisia. Koulussa opittu kertolaskualgoritmi toimii seuraavasti. Algoritmi 3.2. Koulualgoritmi kertolaskuun SYÖTE: TULOSTE: luvut a ja b tulo ab t 0 for i = 0 to n 1 do x b i a t t+ k i x return t Jokainen kertolasku b i a vaatii n alkeisoperaatiota (oletetaan, että muistinumeroilla operointi sisältyy alkeiskertolaskuun), ja summien t+k i x laskeminen vie korkeintaan 2n alkeisoperaatiota. Siis kullakin i :n arvolla suoritetaan maksimissaaan 3n operaatiota, joten algoritmin kompleksisuudelle saadaan yläraja 3n 2 = O(n 2 ). Taas on helppo nähdä, että kertolasku vaatii ainakin lineaarisen ajan, eli M(a, b) kuuluu luokkaan Ω(n). Edellinen algoritmi puolestaan osoitti, että M(a, b) kuuluu luokkaan O(n 2 ). Ongelman tarkkaa kompleksisuutta ei itse asiassa tiedetä, mutta myöhemmin näytetään, että koulualgoritmin antamaa ylärajaa voidaan parantaa. eivät ole bittien vertailuja vaan alkioiden (esim. lukujen) vertailuja ja lisäksi oletetaan, että syöte on järjestetty lista, jolloin jokaista alkiota ei tarvitse käsitellä.

3.4 Jakolasku 19 Todetaan vielä, että koulualgoritmin kompleksisuus on luokkaa O(mn), jos kerrottavista luvuista toinen on m ja toinen n pituinen. Erityisesti, jos toinen luvuista on 1-numeroinen, on kompleksisuus luokkaa O(n). 3.4 Jakolasku Jakolaskuprobleemassa D(a, b) syötteenä on positiiviset kokonaisluvut a ja b ja tavoitteena on laskea pari (q,r ), joka määräytyy yksikäsitteisesti ehdosta a= q b+ r, missä 0 r < b. Oletetaan, että b on n pituinen ja a (korkeintaan) 2n pituinen luku. Tavanomainen koulussa opittu menetelmä johtaa jälleen kompleksisuutta O(n 2 ) olevaan algoritmiin: Jokainen q:n numero löytyy kokeilemalla (vakiomäärä kertolaskuja, joissa kerrottavat ovat 1- ja n pituisia) ja vaatii O(n) operaatiota. Väite seuraa, koska q:n pituus on kertalukua O(n). Jos jakaja b on 1-pituinen luku, niin q:n numeroidenn etsimisessä lasketaankin kahden 1-numeroisen tuloja, jolloin jokainen numero löytyy vakioajassa. Siksi, aivan kuten kertolaskukin, ratkeaa jakolasku tässä tapauksessa ajassa O(n). Jakolaskun nopeuttaminen on hivenen hankalampaa kuin kertolaskun, ja sitä ei tällä kurssilla käsitellä. Voidaan kuitenkin osoittaa, että (tietyin lievin luonnollisin ehdoin) jakolasku voidaan suorittaa kertaluvultaan samassa ajassa kuin kertolasku. Polynomien aritmetiikkaa käsittelevässä luvussa näytetään, että polynomien jakolasku onnistuu samassa ajassa kuin polynomien kertolasku. 3.5 Binääriesityksen laskeminen Joissakin algoritmeissa on hyödyllistä tuntea luvun binääriesitys. Oletetaan taas, että a on k-kantaisessa järjestelmässä annettu n pituinen luku. Probleemassa BIN(a) tehtävänä on laskea a:n binääriesitys; siis sellaiset bitit α i {0,1}, että a= α i 2 i. BIN(a) voidaan ratkaista seuraavalla algoritmilla. Algoritmi 3.3. Algoritmi luvun binääriesityksen laskemiseksi. SYÖTE: TULOSTE: luku a= (a n 1 a 1 a 0 ) k α=(α 0,α 1,... ) 2 : a= α i 2 i i 0 while a 0 do if a on pariton then α i 1 else α i 0 a a 2 i i + 1

3.6 Potenssi 20 return a= (α i 1 α 0 ) 2 Algoritmi laskee siis a:n bitit yhden kerrallaan vähiten merkitsevästä alkaen. Algoritmin kompleksisuus on helposti analysoitavissa. Kussakin silmukassa luvun a arvo pienenee ainakin puolella, joten kierrosten lukumäärä on korkeintaan log a +1 = O(n). Jokaisella kierroksella suoritetaan kaksi korkeintaan ajan O(n) vaativa operaatiota 12, joten algoritmin kompleksisuus on kertalukua O(n 2 ). Lause 3.3. Probleema BIN(a) on luokassa O(n 2 ). Huomautettakoon vielä, että tietokoneissa luvut luonnollisesti esitetään binäärisesti, joten tällaista konversiota ei käytännössä yleensä tarvitse tehdä. 3.6 Potenssi Merkitään potenssinlasku probleemaa P a (e):llä. Tässä siis tehtävänä on laskea luku a e, missä kantaluku a ajatellaan kiinteäksi ja eksponentti e ajatellaan probleeman syötteeksi. Olkoon n eksponentin e pituus. Arvioidaan aluksi tarvittavien aritmeettisten operaatioiden lukumäärää; siis tässä tapauksessa tarvittavien kertolaskujen määrää, kun kerrottavat luvut saavat olla mielivaltaisen pitkiä. Triviaalissa menetelmässä a kerrotaan e 1 kertaa itsellään tarvitaan e 1=2 O(n) kertolaskua. Kompleksisuus on siis eksponentiaalinen, vaikka tarkastellaan pelkästään aritmeettisia operaatioita. Suuria potensseja ei tällä tavalla voi laskea. Mutta kuten jo edellisen luvun Fibonaccin lukuja koskevan esimerkin yhteydessä todettiin on olemassa paljon tehokkaampikin metodi; ns. peräkkäisten neliöiden menetelmä. Algoritmi 3.4. Peräkkäisten neliöiden menetelmä potenssilaskuun. SYÖTE: kantaluku a, eksponentti e = (e n 1 e 1 e 0 ) 2 TULOSTE: a e x a, z 1 for i = 0 to n 1 do if e i = 1 then z zx x x 2 return z 12 Huomaa, että if-lauseessa vaadittava luvun a pariteetti voidaan tarkistaa vaikka silmukan jakolaskun a 2 avulla.

3.7 Suurin yhteinen tekijä 21 Algoritmin oikea toiminta seuraa alla olevasta laskusta: a e = a e 0+e 1 2+...+e n 1 2 n 1 = a e0 (a 2 ) e1 (a 2n 1 ) e n 1. Laskussa (ja yllä olevassa algoritmissa) tarvitaan n neliöintiä ja korkeintaan n tavallista kertolaskua, siis O(n) aritmeettista operaatiota. 13 On myös ilmeistä, että O(n) aritmeettista operaatiota myös aina tarvitaan. Lause 3.4. Probleema P a (e) ratkeaa lineaarisessa määrässä aritmeettisia operaatioita. On huomattava, että yllä laskettiin aritmeettisia operaatioita. Jos lasketaan 1 numeroisilla luvuilla tehtäviä operaatiota (bittioperaatioita), kompleksisuus muuttuu eksponentiaaliseksi. Näin käy välttämättä kaikilla ongelman ratkaisevilla algoritmeilla. Itse asiassa pelkästään vastauksen tulostaminen vie eksponentiaalisen ajan, sillä a e l e a l 2 n a l = 2 O(n). Huomautus 3.1. Peräkkäisten neliöiden menetelmää voidaan soveltaa myös tulon a a... a laskemiseen, missä on mikä tahansa assosiatiivinen binäärioperaatio. Menetelmä soveltuu siis vaikka neliömatriisien potenssin laskemiseen. 3.7 Suurin yhteinen tekijä Probleemassa GCD(a, b) tehtävänä on määrätä lukujen a ja b suurin yhteinen tekijä syt(a,b), missä a b 0. Olkoon n luvun a pituus. Ongelma ratkeaa jo antiikin ajoilta tunnetulla Eukleideen algoritmilla. Algoritmi perustuu yhtälöön syt(a,b)=syt(b,r ), missä a = qb + r ja 0 r < b. Olkoon Div jokin jakoalgoritmi: yllä olevin merkinnöin Div(a,b)=(q,r ). Algoritmi 3.5. Eukleideen algoritmi (rekursiivinen versio) SYÖTE: luvut a,b, a b> 0 TULOSTE: syt(a, b) KUTSU: Eucl(a, b) (q,r ) Div(a,b) if r = 0 then return b else return Eucl(b,r ) 13 Huomaa, että algoritmin kertaluku ei muutu miksikään, vaikka luvun e binääriesitys pitäisi myös laskea. Binääriesitys voidaan laskea O(n 2 ) bittioperaatiolla ja itse potenssiinkorotus vaatii O(n) aritmeettista operaatiota eli lukujen (ei bittien) operaatiota.

3.7 Suurin yhteinen tekijä 22 Eukleideen algoritmi laskee siis suurimman yhteisen tekijän suorittamalla joukon jakolaskuja, joista kukin voidaan tehdä ajassa O(n 2 ). Koko algoritmin kompleksisuuden määräämiseksi pitäisi saada arvio jakolaskujen määrälle; olkoon se k+ 1. Merkitään algoritmin aikana laskettuja jakojäännöksiä järjestyksessä r k, r k 1,..., r 0, joten esimerkiksi r k = a mod b ja r 0 = 0. Näytetään, että luvut r i toteuttavat epäyhtälön r i F i kun i = 0,...,k, missä F i on i :s Fibonaccin luku 14. Tämä onnistuu kätevästi induktiolla. Asia on selvä, kun i = 0 ja i = 1. Toisaalta, koska r i 1 saadaan algoritmilla jakolaskulla (q,r i 1 ) Div(r i+1,r i ), joten r i+1 = qr i + r i 1 r i + r i 1 i.o. F i + F i 1 = F i+1, mikä todistaa induktioaskelen. Voidaan osoittaa, että Fibonaccin luvut toteuttavat epäyhtälön 15 F i A α i sopivasti valituilla vakioilla A> 0 ja α>1. On siis saatu a> r k F k A α k. Ottamalla logaritmit molemmin puolin tästä seuraa n log A k < logα = O(n), koska n log a. Siispä seuraava lause on todistettu. Lause 3.5. Probleema GCD(a,b) kuuluu luokkaan O(n 3 ). Huomautettakoon, että yllä oleva Eukleideen algoritmin kompleksisuuden analysointi on historiallisesti merkittävää, sillä sitä pidetään ensimmäisenä epätriviaalina algoritmin analysointina (Lame, 1845 16 ). Mainittakoon myös, että saatu yläraja tarvittavien jakolaskujen määrälle on siinä mielessä tarkka, että joissakin tapauksissa todella tarvitaan O(n) jakolaskua. Näin käy esimerkiksi laskettaessa kahden peräkkäisen Fibonaccin luvun suurinta yhteistä tekijää. Huomaa, etä arvioimme jakolaskun kompleksisuudeksi O(n 2 ), joten käyttämällä koulualgoritmia nopeampaa jakoalgoritmia saadaan Eukleideen algoritmia nopeutettua. 14 Muistanet jo että F 0 = 0, F 1 = 1, F i+2 = F i+1 + F i kaikille i 0. 15 Muistanet myös, että α=(1+ 5)/2 eli ns. kultainen leikkaus. 16 Suorita internethaku haluamallasi hakukoneella hakusanoilla Lame s Theorem ja huomaat, että Lame n todistus on historiallisesti merkittävä myös siksi, että sitä pidetään Fibonaccin lukujen ensimmäinä sovelluksena.

3.8 Neliöjuuri 23 Yksinkertaisuudestaan huolimatta Eukleideen algoritmi on varsin hyödyllinen. Esimerkiksi käänteisalkion laskeminen jäännösluokkarenkaassa onnistuu mukavasti ns. laajennetulla Eukleideen algoritmilla, kuten myöhemmin nähdään. Suurimman yhteisen tekijän laskemiselle tunnetaan muitakin algoritmeja. Ne perustuvat Eukleideen algoritmin ns. matriisiversioon, joka esitettään monisteen seuraavassa luvussa. Matriisiversiossa keskeisessä osassa on kertolaskualgoritmin valinta. Valitsemalla asymptoottisesti tehokkain kertolaskualgoritmi saadaan suurin yhteinen tekijä laskettu alle kuutiollisessa ajassa. Esimerkiksi ns. Stehlé-Zimmermann algoritmi ja Schönhagen algoritmi toimivat ajassa O(lognM(n)), missä M(n) on kertolaskualgoritmin kompleksisuus. Esimerkki 3.1. Lasketaan lukujen 1175 ja 359 suurin yhteinen tekijä Eukleideen algoritmilla. 3.8 Neliöjuuri Tehokkaimmat menetelmät neliöjuuren laskemiseen ovat likimääräisalgoritmeja (esim. numeerisesta analyysistä tuttu Newtonin menetelmä). Nämä metodit eivät ole algoritmisesti selkeitä, sillä ne vaativat mm. virhetarkastelun. Ensimmäinen tunnettu likimääräisalgoritmi luvun a likiarvon laskemiseksi tunnetaan nimellä Babylonialaisten metodi tai Heronin metodi. Se perustuu nimenomaan Newtonin metodiin, joskin algoritmi löydettiin jo ennen Newtonin metodia. Voidaan osoittaa, että oikeiden numeroiden lukumäärä likiarvossa lähes tuplaantuu jokaisella iteraatiokierroksella. Babylonialaisten metodin idea voidaan esittää lyhyesti seuraavasti: Algoritmi 3.6. Babylonialaisten metodi luvun a likiarvolle Aseta luvuksi x 0 jokin luku for n= 0 to k do ) x n+1 1 2 (x n + axn return x k+1 Tietysti on hyvä valita luku x 0 mahdollisimman läheltä a:ta. Babylonialaisten menetelmä ei täytä algoritmille asetettuja ehtoja vaan on likimääräisalgoritmi kuten jo mainittiin. Neliöjuuren laskemiseen on kuitenkin olemassa oikea algortimikin, jota tarkastellaan seuraavaksi. Merkitään SQRT(a):lla probleemaa, jossa syöte a on n pituinen kokonaisluku ja tehtävänä on laskea a. Lause 3.6. Probleema SQRT(a) kuuluu luokkaan O(n 3 ).

3.8 Neliöjuuri 24 Todistus. Perustellaan lause kuvailemalla vaaditussa ajassa toimiva ratkaisualgoritmi. 17. Merkitään m 1 a= i=0 a i (k 2 ) i m 1 ja b= i=0 b i k i, missä b= a, m= n 2, 0 a i < k 2 ja 0 b i < k. Huomaa, että a= (a m 1 a 0 ) k 2 ja b= (b m 1 b 0 ) k, missä a on esitetty kannassa k 2 ja b kannassa k. Osoitetaan, että kaikilla i :n arvoilla ((b m 1 b m i ) k ) 2 (a m 1 a m i ) k 2 < ((b m 1 b m i ) k + 1) 2. (1) Tästä seuraa, että bitit b m i voidaan laskea yksi kerrallaan kun i käy läpi luvut yhdestä m:n, nimittäin, jos bitit b m 1,...,b m i+1 tunnetaan, niin b m i on se arvo, joka toteuttaa epäyhtälöt (1). 18 Tehdään vastaoletus, että epäyhtälöt (1) eivät pidä paikkaansa kaikille luvuille i = 1,...,m. Olkoon j pienin indeksi, jolle 1) ((b m 1 b m j ) k ) 2 > (a m 1 a m j ) k 2, tai 2) (a m 1 a m j ) k 2 ((b m 1 b m j ) k + 1) 2. Oletetaan tapaus 1) ja merkitään ((b m 1 b m j ) k ) 2 = (c m 1 c m 2 c m j ) k 2 > (a m 1 a m j ) k 2 joten c m j > a m j. ((b m 1 b 0 ) k ) 2 (c m 1 c m 2 c m j 0 0) k 2 > (a m 1 a m j a m j 1 a 0 ) k 2 koska k 2 kannan esityksessä c m j > a m j. Näin ollen b 2 > a, joten b a, mikä on ristiriidassa oletuksen kanssa. Tapauksessa 2) ((b m 1 b m j ) k + 1) 2 (a m 1 a m j ) k 2. Merkitään ((b m 1 b m j ) k + 1) 2 = (c m 1 c m 2 c m j ) k 2, missä k 2 -kantaesityksen pituus seuraa ylärajasta a ja sen k 2 -kannan esityksestä. Nyt ((b m 1 b 0 ) k ) 2 = ((b m 1 b m j ) k k m j + (b m j 1 b 0 ) k ) 2 < (((b m 1 b m j ) k + 1) k m j + (0 0) k ) 2 = (c m 1 c m 2 c m j 0 0) k 2 (a m 1 a m j a m j 1 a 0 ) k 2, joten on olemassa luku c = ((b m 1...b m i ) k + 1) k m i N, jolle b 2 < c 2 a, joten b a, mikä on ristiriidassa oletuksen kanssa. 17 Varsinaista pseudokoodia algoritmille ei siis esitetä. Parhaiten algoritmin toiminta selviää internethaulla Square root by long division löydettyjä esimerkkejä tarkastelemalla. 18 Epäyhtälöille (1) tässä esitetty todistus perustuu FM Markus Viljasen vuonna 2015 demonstraatioissa esittämään todistukseen.