Kompleksisuuden kertaluokat

3.2.1. Kompleksisuuden kertaluokat
Tarvittavien operaatioiden tarkan lukumäärän sijasta riittää tarkastella lukumäärän suuruusluokkaa. Asymptoottinen kompleksisuustarkastelu kertoo, miten algoritmi käyttäytyy, kun syötteen koko kasvaa yhä suuremmaksi.

kompleksisuuden kertaluokat...
Esimerkki: eri suoritusaikalausekkeita: n log2n n2 n2+5n n ______________________________________________________________ 10 ~ 100 ~ ~1030 ~ ~ ~ ~

Tärkeintä on tarkastella korkeinta potenssia, sen kerroin ei muuta T(n):n asymptoottista käyttäytymistä, esim. 100n2 ~ n2, kun n on suuri luku. T(n) on suuruusluokkaa f(n), merkitään T(n) ~ f(n), jos on olemassa vakiot k ja K, joiden avulla f(n) voi rajoittaa rajoittaa T(n) ylhäältä ja alhaalta, ts. k * f(n) <= T(n) <= K * f(n), aina kun n>n0 - ”aina kun” osa sanoo, että f(n) pitää toimia tavalliselle tapaukselle, eikä triviaalille Moduuli x

Nimityksiä: Olkoon vakio c > 1. Algoritmi on eksponentiaalinen, jos T(n) ~ cn polynomiaalinen, jos T(n) ~ nc lineaarinen, jos T(n) ~ n logaritminen, jos T(n) ~ logc n vakioaikainen, jos T(n) ~ 1. Logaritmin kantaluvulla ei merkitystä, käytetään kantalukua 2. (log a n = logc n/log c a). Moduuli x

Esimerkki: hanoin tornien aikavaativuus: aikakompleksisuus: tarvittavien siirtojen määrä kiekkojen lukumäärän n funktiona T(n) n:n kiekon ongelma redusoituu kahteen (n-1):n kiekon ongelmaan ja yhden kiekon siirtoon. Algoritmin mukaan T(n) = T(n-1) +1 + T(n-1) = 2T(n-1) +1 , n > 1. Moduuli x

Miten T(n) ratkaistaan ? T(n) = 2T(n-1) +1 = 2(2T(n-2) +1) + 1 = 4T(n-2) , = 4(2T(n-3) + 1) = 8T(n-3) = 23T(n-3) = …n:stä vähennetään sama luku kuin mikä on 2:n ensimmäisen termin eksponentti, T:n parametria pienennetään 1:seen asti, koska T(1) muuttuu triviaaliksi kiekon siirroksi. Kysymys: mikä on suurin eksponentti, kun T:n parametri on 1? vastaus: 1 = n – (n – 1), eli suurin eksponentti on n-1 = 2n-1T(1) + 2n-2 + 2n-3 + … (T(1) = 1) = 2n n-2 + 2n-3 + … geom.sarja = 2n-1 , siis T(n) ~ 2n (eksponentiaalinen) ________________________________________ geom. sarjan summa s= a(qk-1)/(q-1), tässä a=1, k=n, q=2

jos yhden kiekon siirtoon kuluu 1 sekunti, aikavaatimus olisi 64 kiekon siirrolle luokkaa 264 sek ~ 600 miljardia vuotta ! ==> Kelvoton algoritmi (infeasible)

Eksponentiaaliset algoritmit ovat useimmiten käytännössä kelvottomia. Prosessorin nopeuden kasvattaminenkaan ei auta: esim. Hanoin torni, 1 milj. siirtoa/sek  tunnissa ratkeaisi 31 kiekon peli - jos nopeus olisi miljoonakertainen (1 THz taajuus)  tunnissa ratkeaisi 51 kiekon peli. Polynomiaaliset algoritmit enimmäkseen käyttökelpoisia.

Esimerkki (valintalajittelu s. 58). MODULE valintalajittelu (T, n) FOR i:=1 TO n-1 DO FOR j:= i+1 TO n DO IF T[i] > T[j] THEN vaihda (T[i], T[j]) ENDIF ENDFOR ENDMODULE

tehtävän koko = järjestettävien alkioiden lkm n keskeinen operaatio: parittaisten vertailujen määrä lajittelukierroksia on n-1 kullakin kierroksella i tehdään n-i vertailua Siis T(n) = (n-1) + (n-2) + … + 1 = n(n-1)/2 ~n2. Parhaimmissa lajittelualgoritmeissa T(n) ~n log n.

Hajota ja hallitse

hajota ja hallitse … Modulaarisuusperiaatteen mukaan alitehtävät (2 kpl) voidaan ratkaista millä tavalla tahansa. Jos ne ratkaistaan samalla tavalla kuin koko tehtäväkin, kyseessä on limityslajittelu. Paras tulos saavutetaan, kun listan jaetaan mahdollisimman tasan.

hajota ja hallitse … Kyseessä on siis rekursio.
Rekursio päättyy, kun lajiteltava listan osa sisältää vain yhden nimen. Moduuli x

Jussi Kati Fredi Bertta Sami Jaana Mari
Bertta Fredi Jaana Sami Mari Bertta Fredi Jussi Kati Jaana Mari Sami Bertta Fredi Jaana Jussi Kati Mari Sami

hajota ja hallitse … MODULE limilaj (lista)
IF listan pituus > 1 THEN Halkaise lista kahtia listoiksi lista1 ja lista2 limilaj (lista1) limilaj (lista2) lista := limitä (lista1, lista2) ENDIF ENDMODULE Moduuli x

(* loput harjoitustehtäväksi  *) l3ind
MODULE limitä (järjestetyt lista1 ja lista2) RETURNS lista3 ENDMODULE 1 4 7 8 11 2 3 5 6 11 13 l1ind l2ind jos lista1[l1ind]<lista2[l2ind], niin lista3[l3ind]:=lista1[l1ind], l3ind:= l3ind + 1, l1ind:=l1ind +1 endjos  (* loput harjoitustehtäväksi  *) l3ind

hajota ja hallitse … Limityslajittelun kompleksisuus:
Olkoon n kakkosen potenssi (n=2k) Halkaisu on vakioaikainen Limitys on lineaarinen Merkitään T(n) = n:n alkion lajittelussa tarvittavien vertailujen määrä. Silloin T(n) = T(n/2) + T(n/2) + n ts. alkuosan ja loppuosan lajittelu + limitys

hajota ja hallitse … Palautuskaavan ratkaisu: T(n) = 2T(n/2) + n
= 2[2T(n/4) + n/2] + n = 4T(n/4) +2n = 4[2T(n/8) + n/4] + 2n = 8T(n/2) + 3n = … = 2mT(n/2m) + mn. Moduuli x

hajota ja hallitse … Milloin n/2m = 1 ? Kun n = 2m. Ts. kun m = log2 n. Siis T(n) = 2log n T(1) + n log n = nT(1) + n log n = n log n, koska T(1) = 0. Siis T(n) ~ n log n Moduuli x

hajota ja hallitse … Kuinka paljon parempi limityslajittelu on verrattuna valintalajitteluun (s. 86), jolle T(n) = n(n-1)/2 ? Vastaus: n log n < n(n-1)/2, kun n > 7. Käytännössä raja on korkeampi. Siis jos n = , valintalajittelu kestää 1.5 h, limityslajittelu < 1 sek (oletetaan prosessorin nopeudeksi 1 miljoona vertailua/sek).

hajota ja hallitse … Esim. 1 200 000 000 nimen
aakkostaminen kestäisi valintalajittelulla vuotta, limityslajittelulla n. 10 tuntia.

Hajoita ja hallitse potenssejä
Esimerkki. exp(n) = 2n kahdella tavalla: perinteisesti ja ”hajota ja hallitse” -metodilla. Perustuu peräkkäisiin kertolaskuihin, 2n = 2 x 2 x … x 2 (n-1 kertolaskua).

hajota ja hallitse … Rekursiivinen ratkaisu: 2n = 2 * 2n-1
MODULE exp (n) RETURNS 2n IF n = 0 THEN RETURN 1 ELSE RETURN 2 * exp (n-1) ENDIF ENDMODULE (vrt Harj. 4, tehtävä 6)

hajota ja hallitse … MODULE exp (n) RETURNS 2n
IF n = 0 THEN RETURN 1 ELSE RETURN 2 * exp (n-1) ENDIF ENDMODULE Siis T(n) = T(n-1) + 1 = T(n-2) = T(n-3) = …T:n paramteri on muotoa n-m. Huom. että ykkösiä on T:n perässä on myös m kpl. Rekursion kanta tulee vastaan, kun n=0. milloin T:n parametri n-m = 0? silloin, kun m=n, eli T:n parametri on n-n: = T(n-n) + n = n.

MODULE exp_hh (n) RETURNS 2n IF n = 0 THEN RETURN 1 ELSE
Voidaan laskea myös toisin (oivallus): 2n=1, kun n = 0 2n=2n//2 *2n//2, kun n>=1 ja parillinen 2n=2*2n//2 *2n//2, kun n>=1 ja pariton MODULE exp_hh (n) RETURNS 2n IF n = 0 THEN RETURN 1 ELSE m = exp_hh (n//2) IF n on parillinen THEN RETURN m*m RETURN 2*m*m ENDIF ENDMODULE

Olkoon n kakkosen potenssi Silloin
MODULE exp_hh (n) RETURNS 2n IF n = 0 THEN RETURN 1 ELSE m = exp_hh (n//2) IF n on parillinen THEN RETURN m*m ELSE RETURN 2*m*m ENDIF ENDMODULE Olkoon n kakkosen potenssi Silloin T(n) = 1 + T(n/2) + 1 = T(n/2) + 2, joten T(n) = T(n/2) +2 = T(n/4) + 4 = … = T(n/2m) + 2m Huom. ”n on parillinen” vertailua ei luentomonisteessa lasketa askeleeksi (vaikka pitäisi)

T(n) = T(n/2m) + 2m Milloin n/2m = 1 ?
Kun n = 2m, logaritmin määritelmän nojalla m = log2n, joten T(n) = T(1) + 2 log2n = log2n, koska T(1) = 3. Kun n ei ole kakkosen potenssi, tarvitaan aina välillä yksi kertolasku enemmän. Voidaan osoittaa, että T(n) <= 3 log2 n eli joka tapauksessa asymptoottisesti T(n) ~ log2 n.

Kun n = 50, exp_hh on noin kolme kertaa nopeampi kuin exp.
väärä ongelman ositus optimoitaessa voi johtaa jopa käänteiseen tulokseen: algoritmi hidastuu, kompleksisuus kasvaa esim. ositus exp3: 2n=1, kun n = 0 2n=2, kun n=1 2n=2n//2 *2(n+1)//2, kun n>1 nyt 23=2(3//2)*2(4//2)=21* 2(2//2)* 2(2//2)= 21* 21* 21* =8 tehdään 3 kertolaskua, 3 jakolaskua = 6 askelta vrt exp:hen, jossa tehdään vain 3 askelta kun n kasvaa, exp3 osoittautuu 3 kertaa exp:iä hitaammaksi! ja 9 kertaa exp_hh:tä hitaammaksi => hyvä tehtävän ymmärtäminen ja ositus on tärkeä

3.2.3 Kelvottomien ongelmien käsittely
Church-Turingin teesi: laskettavuus on tietokoneista riippumaton ominaisuus eli kaikki laskettavissa olevat ongelmat ovat ratkaistavissa tietokoneilla. Kelvollisia ongelmia ovat kuitenkin vain ne, joiden ratkaisu löytyy polynomiaalisessa ajassa. peräkkäislaskennan teesi: Kaikki kelvolliset ongelmat ovat ratkaistavissa kaikilla koneilla polynomiaalisessa ajassa tehtävän ratkaisevan parhaan algoritmin aikakompleksisuus on siis polynomiaalinen Ongelman kelvollisuus ei riipu tietokoneesta. Eksponentiaaliset ongelmat ovat yleensä kelvottomia. laskettavissa vain pienillä syötteillä

Kelvottomien ongelmien käsittely...
Esimerkkejä ongelmista, joille ei ole (vielä) löydetty polynomiaalista ratkaisua (eksponentiaalinen ratkaisu on): Shakin pelaaminen Pakkausongelma: voidaanko pakata n kpl kuorma-autoja, joiulla on tietty kantavuus siten, että k kpl eripainoisia komponentteja voidaan kuljettaa samanaikaisesti.

Kauppamatkustajan ongelma: voidaanko käydä n kaupungissa, kun ajomatkan pituus saa olla enintään k kilometriä siten, että jokaisessa kaupungissa käydään vain kerran ja lopuksi palataan lähtökaupunkiin. Usein tarkastellaan myös lyhimmän reitin löytämistä. Hamiltonin polku: sama kuin kauppa-matkustajan ongelma, mutta ajomatkan pituutta ei ole rajoitettu. Lukujärjestysongelma: on annettu joukko kursseja, joukko kursseille osallistuvia opiskelijoita sekä joukko mahdollisia kurssin pitoaikoja (kellonaikoja). Tehtävänä on ajoittaa kurssit niin, ettei kenenkään opiskelijan tarvitsisi olla kahdella kurssilla yhtä aikaa.

Edellä olevat ongelmat on kuitenkin ratkaistu. Mihin ratkaisut perustuvat ?

Vastaus: on tingitty algoritmin perus- vaatimuksista (s.16): Yleisyys: rajoitutaan nopeasti ratkeaviin erikoistapauksiin. Nopeus: algoritmi toimii useimmiten nopeasti, mutta joillakin harvoilla syötteillä kestää kauan. Oikeellisuus: algoritmi toimii useimmiten oikein, mutta joskus harvoin antaa väärän tuloksen.

Likimääräisalgoritmi: lasketaan vaatimustasoa ja pyritään likimäärin oikeaan tulokseen (esim. lukujärjestyksessä sallitaan muutama yhteentörmäys). Todennäköisyysalgoritmi: nopea, mutta ei aina toimi oikein. Virheen todennäköisyyden tulee kuitenkin olla hyvin pieni. Esim. alkulukutestiin ei ole olemassa polynomiaalista algoritmia. Jos virheen todennäköisyydeksi sallitaan 2-20, polynomiaalinen algoritmi voidaan esittää.

Epädeterministinen algoritmi: tiedetään keinot, joilla ratkaisu löytyy, mutta keinoja on erittäin runsaasti, eikä aina tiedetä mikä pitäisi milloinkin valita. Kaikkia keinoja ei ole mahdollista kokeilla. Käytetään ns. heuristisia algoritmeja, joissa kulloinkin suoritettavat toimenpiteet valitaan jonkinlaisilla peukalosäännöillä - eli hyvällä arvauksella. Esimerkiksi shakin peluu. 6. luvussa tutustutaan heuristisiin ongelmiin tarkemmin

Joukkooppia Olk. A ja B joukkoja
joukossa alkioilla ei järjestystä, vain alkion kuuluvuus/-mattomuus (,) joukkoon on tärkeää esim. A={1, 2, 3}, B={1,2,3,4}, C={1,2,3} A on B:n osajoukko ja C:n osajoukko AB, AC A on myös B:n aito osajoukko, AB, koska 4B,4A A ei ole C:n aito osajoukko, koska C:stä ei löydy sellaista alkiota, mitä ei löytyisi A:sta

P = siis kaikkien kelvollisten tehtävien joukko
P ja NP P = ongelmat, joille on olemassa deterministinen polynomiaalinen algoritmi. P = siis kaikkien kelvollisten tehtävien joukko NP = ongelmat, joille on olemassa deterministinen polynomiaalinen algoritmi, jolla voidaan tarkistaa ratkaisuehdokkaan oikeellisuus. Itse asiassa NP = ongelmat, jotka voidaan ratkaista polynomiaalisessa ajassa epädeterministisellä algoritmilla. P NP (P on NP:n osajoukko, mikä tarkoittaa sitä, että P voi olla =NP, muttei välttämättä pakko)

P ja NP ... vai onko PNP (onko P NP:n aito osajoukko)
Pakkausongelma, kauppamatkustajan ongelma, Hamiltonin polku -ongelma ja lukujärjestysongelma kuuluvat joukkoon NP. Ei (toistaiseksi) tiedetä kuuluvatko ne joukkoon P. Siis suuri kysymys tkt:ssä on, että onko P=NP ? vai onko PNP (onko P NP:n aito osajoukko)

P ja NP ... NP-täydelliset ongelmat = sellaiset NP-joukon ongelmat, joista yhdenkin ratkeaminen polynomiaalisessa ajassa aiheuttaisi sen, että kaikkiin NP-joukon ongelmiin löydettäisiin polynomiaalinen ratkaisu. Esim. edellä mainitut ongelmat on osoitettu NP-täydellisiksi.

P ja NP ... Yleinen käsitys: NP-täydellisiin ongelmiin ei ole olemassa polynomiaalista ratkaisua (ja ovat siis kelvottomia). NP-täydellisiä ongelmia ei kutenkaan ole todistettu kelvottomiksi Joihinkin NP-ongelmiin saatetaan löytää vielä joskus polynomiaalinen algoritmi (ns. NP-vaikeat ongelmat) NP-täydellisiin nopeaa algoritmia ei uskota koskaan löydettävän

3.3 Oikeellisuus Useimmissa ohjelmissa on virheitä (bugs), jopa vuosikausia käytössä olleissa. Suurin osa ohjelmoijan työajasta kuluukin ohjelmien ylläpitoon: korjailuun ja muutosten tekoon. debuggaus = virheiden etsintä ja korjaus Usein virheiden syynä ovat liian monimutkaiset algoritmit, joiden toimintaa ei täydellisesti ymmärretä. Abstrahointi ja modulaarinen toteutus ovat mahdollisimman vähävirheisten ohjelmien tuottamisen perusedellytyksiä.

Oikeellisuus ... Vähävirheisten ohjelmien aikaansaamiseksi on
olemassa kaksi perusmenetelmää: testaus testiaineisto, testiajot oikeaksitodistaminen induktio invarianssit peräkkäiset väitteet

3.3.1 Testaus laaditaan testiaineisto
jo ohjelmointivaiheessa, jolloin kaikki erilaiset tapaukset tulisivat huomioitua ohjelmaa kirjoitettaessa. testataan tietokoneessa tai pöytätestauksessa Testiaineiston tulee olla kattava (myös erikoistapaukset)

Virhetyyppejä: Käyttövirheet: ohjelmaa käytetään tapaukseen, joka on sen määrittelyalueen ulkopuolella. Käyttäjän pitää tietää mihin ohjelma on tarkoitettu. Testausvirheet: testaus ei ole riittävän kattava. Määrittelyvirheet: jotakin tapausta ei ole lainkaan otettu huomioon, jolloin ohjelman toiminta kyseisessä tapauksessa on tuntematon.

Testiaineistoesimerkki
testitapaukset algoritmille, jonka syötteen koko on n: Triviaali tapaus (n0=0 tai n0=1) n0+1 Tyypillinen syöte: nk Maksimisyöte – 1: nmax-1 Maksimisyöte: nmax Jos tarkoituksena myös käyttövirheiden käsittely, testataan ”suojausta” syöttämällä syöte sen määrittelyalueen ulkopuolelta esim. 0:n negatiivisista potensseista tulostetaan virheilmoitus: RETURN “ERROR” (* 0^y on määritelty vain kun y>0 *) (Harj4 Teht.6)

Testaus Testaus ei todista ohjelmaa oikeaksi.
virheitä saattaa löytyä jopa vuosia kestäneen käytön jälkeen Suurten järjestelmien (esim. käyttöjärjestelmä) täydellinen virheettömyys on käytännössä mahdotonta. virheen poistava korjaus aiheuttaa uusia virheitä ohjelmiston toisiin kohtiin saavutetaan dynaaminen tasapainotila jokainen virheiden vähentämiseksi tehty muutos aiheuttaa suunnilleen yhtä monta uutta virhettä entäs jos halutaan olla täysin varmoja ohjelman oikeellisuudesta?

3.3.2 Oikeaksi todistaminen
Tarkoitus on todistaa, että ohjelma toimii oikein kaikilla annetuilla syöttötiedoilla. Tämä edellyttää, että määrittely on mahdollisimman täsmällinen. Määrittelyssä kerrotaan, miten moduulia käytetään mitkä ovat sen parametrit rajoituksineen mitä moduuli tekee Määrittely kirjoitetaan ennen koodausta

Oikeaksi todistaminen ...
Määrittelyyn kuuluu: alkuehto (esiehto), jossa esitetään vaatimukset parametreille. Alkuehto kertoo kaikki kelvolliset alkutilat (muuttujien arvot), joilla ohjelma on suunniteltu toimivan oikein. loppuehto (jälkiehto), joka kertoo mitkä ehdot ovat voimassa lopuksi, jos alkuehto oli voimassa, kun moduulia lähdettiin suorittamaan.

Alku- ja loppuehto exp(h):lle
MODULE exp (n) RETURNS 2n IF n = 0 THEN RETURN 1 ELSE RETURN 2 * exp (n-1) ENDIF ENDMODULE alkuehto: n>=0, n on kokonaisluku loppuehto: palautusarvo on 2n

Alku- ja loppuehdon perimmäinen merkitys
Alkuehto on määritys syötteelle laskun tila ennen moduulin suoritusta Loppuehto on määritys tulosteelle laskun tila moduulin suorituksen jälkeen Tarkoituksena on todistaa loppuehdon paikkansapitävyys kun kun alkuehto oletetaan todeksi. Usein loppuehdon toteutuvuutta ei voida suoraan todeta, jolloin moduulin sisälle sijoitetaan 'kriittisiin kohtiin' väitteitä (assertions).

Ositus ja integrointi oikeaksitodistamisessa
Modulaarisuusperiaatteella tehtävä jaetaan osiin osat toteutetaan eri moduuleissa kullekin moduulille alku- ja loppuehdot muut toiminnalliset vaatimukset esim. tietty tehokkuustaso Oik.tod. suoritetaan paloittain kullekin moduulille Moduulien yhteenliittämiseen jälkeen saadaan oikeellisuus koko ohjelmalle Yleinen ongelmanratkaisumenetelmä: osita ratkaise osat erikseen yhdistä osat koko ongelman ratkaisuksi

Oikeaksitodistaminen on vaikeaa ja ei ole laskettavissa oleva ongelma, joten todistus-prosessia ei voida mekanisoida. menetelmät ovat varsin matemaattisia ja työläitä Käytännön merkitys Ennalta ehkäisy: alku- ja loppuehtojen laatiminen jo sinällään pakottaa perehtymään tarkemmin annettuun tehtävään. Kriittiset moduulit pyritään todistamaan oikeaksi, mikä ei kylläkään todista kokonaisuutta oikeaksi. potilaanseurantaohjelmistossa sykintää valvova moduuli

Ohjelmaa sanotaan osittain oikeelliseksi, jos se aina päättyessään tuottaa oikean tuloksen. jos pysähtyy, voi olla että ei aina totaalisen oikeelliseksi, jos se on osittain oikeellinen ja lisäksi pysähtyy (terminoituu) kaikilla syötteillä.

Oikeellisuustodistuksissa käytettyjä metodeja: täydellinen induktio invarianssit oikeaksi todistaminen peräkkäisten väitteiden avulla

Induktioperiaate Olkoon n0 kokonaisluku, P jokin kokonaisluvuilla parametrisoitu väite. Tarkastellaan väitteen P(n) voimassaoloa kokonaislukujen n >= n0 suhteen. Induktioperiaate yleinen todistusmenetelmä, jolla voidaan todistaa väitteen P(n) voimassaolo kaikilla kokonaisluvuilla n >= n0.

Induktioperiaate... Esimerkiksi voidaan todistaa
… + n = n(n+1)/2, kun n >= 1. Esim … + 7 = 7(7+1)/2 = 28. Algoritmin kompleksisuus (vaikkapa Hanoin tornit) Moduulin oikeellisuus (esim. tulostapuu).

Induktioperiaate: Jos seuraavat kaksi ehtoa (i) ja (ii)
(i) P(n0) on tosi (ii) Olkoon k >= n0. Kun oletetaan, että P(k) on tosi, niin sen nojalla voidaan, että myös P(k+1) on tosi toteutuvat, niin silloin (iii) P(n) on tosi kaikilla n:n arvoilla n >= n0. Usein n0 = 0, (siis yksinkertainen alkutilanne). HUOM: (ii):ssa ”P(k):n nojalla” tarkoittaa sitä, että P(k+1):ta todeksi todistettaessa pitää käyttää Induktio-oletusta P(k) hyväksi!

Induktioperiaate: miten todistus etenee ?
Formuloidaan väite P ja parametri n, jonka suhteen todistus suoritetaan. Mikä on n:n pienin arvo n0 ? n0=0 tai n0=1 riippuen väitteestä/tehtävästä

Induktioperiaate: miten todistus etenee ?
Lähtökohta: Ensin osoitetaan (i) on todeksi, mikä on yleensä helppo tehtävä. Induktio-oletus: Sitten osoitetaan (ii) todeksi tekemällä induktio-oletus ja todistamalla sen nojalla induktioväite todeksi. Induktio-oletus: P(k) on tosi, kun k >= n0. Induktioväite: P(k+1) on tosi. Johtopäätös: kohta (iii).

Induktioperiaate: Esimerkki: Osoitetaan, että
s= … + n = n(n+1)/2, kun n >= 1. Lähtökohta n0 = 1. Silloin toisaalta s=1 ja toisaalta s=1(1+1)/2 = 1, eli lähtökohta on todistettu. Induktio-oletus: s = k(k+1)/2, kun k >= 1. Induktioväite: s(k+1) = (k+1)(k+2)/2. Todistus: s(k+1) = … + k + k+1, ja induktio-oletuksen perusteella s(k+1) = s(k) + k+1 = k(k+1)/2 + k+1 = (k+1)[k/2 +1] = (k+1)(k+2)/2. Johtopäätös: s(n) = n(n+1)/2 kaikilla n >= 1.

Induktioperiaate: Esimerkki: Hanoin tornit. P(n) = T(n). Osoitetaan, että T(n) = 2n - 1, n >= 0. Lähtökohta n0 = 0. Algoritmin mukaan T(0) = 0. Myös = 0, joten kaava pätee tilanteessa n = 0. Induktio-oletus: T(k)= 2k - 1, kun k >= 0. Induktioväite: T(k+1) = 2k Todistus: Algoritmin mukaan T(k+1) = T(k) T(k) = 2k k -1 (induktio-olet. perust.) = 2k Johtopäätös: T(n) = 2n - 1, n >= 0

Induktioperiaate: Esimerkki: Välijärjestystä noudattava moduuli tulostaa lajitellun binääripuun solmut (nousevassa) järjestyksessä. MODULE tulostapuu (binääripuu p) IF p ei ole tyhjä THEN tulostapuu (p.vasen) tulostapuu (p.juuri) tulostapuu (p.oikea) ENDIF ENDMODULE

Induktioperiaate... MODULE tulostapuu (binääripuu p) IF p ei ole tyhjä THEN tulostapuu (p.vasen) tulostapuu (p.juuri) tulostapuu (p.oikea) ENDIF ENDMODULE P(n): algoritmi tulostapuu tulostaa lajitellun binääripuun solmut nousevassa järjestyksessä kaikilla n:n arvoilla n = 0, 1, 2, … , missä n = puun solmujen lkm. Lähtökohta: Jos n = 0, puu oh tyhjä, jolloin algoritmi toimii. Induktio-oletus: oletetaan, että algoritmi toimii, kun koko on enintään k. Induktioväite: Algoritmi toimii oikein, kun puun koko on k+1. Johtopäätös:

Induktioperiaate... MODULE tulostapuu (binääripuu p) IF p ei ole tyhjä THEN tulostapuu (p.vasen) tulostapuu (p.juuri) tulostapuu (p.oikea) ENDIF ENDMODULE Induktioväite: Algoritmi toimii oikein, kun puun koko on k+1. Todistus: olkoon lajitellussa binääri-puussa p k+1 solmua. Silloin puun p.vasen kaikkien solmujen arvot ovat < p.arvo. puun p.oikea kaikkien solmujen arvot ovat > p.arvo. puissa p.vasen ja p.oikea on enintään k solmua, joten tulostapuu(p.vasen) tulostaa induktio-oletuksen mukaan p:n vasemman alipuun solmut suuruusjärjestyksessä. Seuraavaksi tulostuu juuri, mikä on aivan oikein.

Induktioperiaate... MODULE tulostapuu (binääripuu p) IF p ei ole tyhjä THEN tulostapuu (p.vasen) tulostapuu (p.juuri) tulostapuu (p.oikea) ENDIF ENDMODULE Todistus: … Lopuksi algoritmi tulostaa oikean alipuun solmut suuruusjär-jestyksessä induktio-oletuksen perusteella. Siten koko puu tulostuu suuruusjärjestyksessä. Johtopäätös: Algoritmi tulostaa jokaisen lajitellun binääripuun alkiot suuruusjärjestyksessä. Selvästi algoritmi terminoituu ja on siis totaalisesti oikein.

3.3.2.2 Invarianttien käyttö oikeaksi-todistamisessa
Algoritmin keskeinen idea esitetään väitteenä, jonka muuttumattomuus eli invarianssi ohjelmansuorituksen aikana osoitetaan induktiolla tai jollain muulla tavalla. Tällaista muuttumatonta väitettä sanotaan invariantiksi, joka ilmaistaan ohjelman tilana suorituksen aikana tiettynä hetkenä. Alkutila: tila(nne) algoritmin alussa Lopputila: tila(nne) algoritmin lopussa. tämä menetelmä kelpaa yleensä vain rekursion ja toisto-osien, ei koko algoritmin todistamiseen

3.3.2.2 Invarianttien ... Menetelmä:
1. Muodostetaan väite, jolla ominaisuudet: väite pätee alkutilassa, jos väite pätee lopputilassa, niin algoritmin suoritus on virheetön. 2. Osoitetaan, että algoritmin suoritus ei vaikuta väitteen totuusarvoon (eli väite on invariantti algoritmin suorituksen suhteen) (esim. induktiolla). alkutila=>suorituksen aikana pätevä invariantti=>lopputila 3. Osoitetaan, että lopputila saavutetaan välttämättä, ts. algoritmi terminoituu. Haettu väite tulee siis laatia siten, että väite on invariantti algoritmin suorituksen suhteen ja että se takaa algoritmin oikeellisuuden. Vaatimuksen 2 mukaan väite pätee myös lopputilassa.

Valintalajittelun oikeellisuus invarianttien avulla
Esimerkki: valintalajittelun oikeellisuus. Olkoon muuttujassa pituus vektorin V alkioiden lkm. MODULE valintalajittelu (vektori V) FOR vasen:= 1,…, pituus-1 DO FOR oikea:=vasen+1,…, pituus DO IF V[vasen] > V[oikea] THEN vaihda (V[vasen, V[oikea]) ENDIF ENDFOR ENDMODULE Silmukkainvarianssi: P(vasen) = vektori on lajiteltu indeksiin vasen saakka ja että sen oikealla puolella oleva osa on lajittelematon ja sisältää alkioita, jotka ovat kaikki suurempia tai yhtä suuria kuin vasemmalla puolella olevat alkiot.

Valintalajittelun oikeellisuus (1/3)
lajiteltu osa lajittelematon osa vasen 1. Väite on triviaalisti voimassa alkutilassa (vasen = 0). Oletetaan, että väite pitää paikkansa lopputilassa. Tällöin vasen = pituus-1, joten vektorin alkiot 1,…, pituus-1 ovat järjestyksessä ja viimeinen alkio V[pituus] on vähintään kaikkien muiden alkioiden suuruinen. Täten vektori V on järjestetty ja algoritmi toimii oikein.

2. Osoitetaan väitteen voimassaolo induktiolla uloimman silmukan lopussa, kun vasen = 1,…,pituus-1. Kun sisempi silmukka suoritetaan arvolla vasen=1, sen jälkeen ensimmäisenä komponenttina on välttämättä pienin, joten P(1) pätee. Oletetaan nyt, että P(k) on tosi. Tällöin k ensimmäistä alkiota ovat järjestyksessä ja muut alkiot ovat >= V(k). Kun ulompi silmukka suoritetaan silmukkalaskurin arvolla k+1, tulee algoritmin nojalla paikkaa V[k+1] pienin alkioista V[k+1], …, V[pituus]. Koska V[k+1] >= V[k], k+1 ensimmäistä alkiota ovat järjestyksessä. Täten myös P(k+1) pätee. P(vasen) on tosi kaikilla arvoilla vasen

3. Kierroksia tehdään aina sama määrä: n-1, n-2, n-3, … 2, 1 = n(n+1)/2 – n = n(n-1)/2 Toisto päättyy siis tarkalleen n(n-1)/2 kierroksen jälkeen (ks. sivu 86) Selvästi algoritmi terminoituu eli lopputila saavutetaan.

syt(x,y):n oikeellisuus
Esimerkki. Lukujen suurin yhteinen tekijä. MODULE syt(x,y) RETURNS x:n ja y:n syt IF y = 0 THEN RETURN x ELSE RETURN syt (y, x mod y) ENDIF ENDMODULE

3.3.2.2 Invarianttien ... Olkoot alkuperäiset syötteet x0 ja y0 ja
merkitään syt(x0, y0) = z. Merkitään x:n ja y:n uusia arvoja xi:llä ja yi:llä i:nnen rekursiokutsun jälkeen. Olkoon tarkasteltava väite muotoa: syt(xi, yi) = z, i = 0, 1, 2, … , k (rekursiotasoja), missä xk ja yk ovat x:n ja y:n arvot lopputilassa.

syt(x,y):n oikeellisuus(1,2/3)
Alkutilassa x = x0 ja y = y0 ja väite on triviaalisti voimassa. Lopputilassa xk > 0 ja yk = 0. Jos oletetaan, että väite pitää paikkansa lopputilassa, niin silloin syt(xk, yk) = syt(xk, 0) = xk. Koska algoritmi palauttaa saman arvon, toimii algoritmi oikein, kun oletetaan väitteen toteutuvuus lopputilassa. Koska uudet (xi, yi) -parit määrätään algoritmissa edellä esitetyn rekursiokaavan mukaisesti (s. 98), riittää osoittaa kaavan oikeellisuus.

syt(x,y):n oikeellisuus(2/3)…
Jos y = 0, niin väite’ pitää paikkansa triviaalisti ( syt = x). Oletetaan, että y > 0. Jos alussa x <= y, niin ensimmäisen rekursiivisen kutsun jälkeen x ja y ovat vain vaihtaneet paikkaa (jakojäännöksen määritelmän nojalla), joten seuraavalle (x, y) -parille pätee, että x >= y. Tämä pätee myös kaikille muille (x,y)-pareille, koska x korvataan y:llä ja y jakolaskun x/Y jakojäännöksellä, joka on pienempi tai yhtä suuri kuin y.

Koska x >= y, niin voidaan kirjoittaa x = ny + j, missä n on jakolaskun x/y kokonaisosa ja j on jakojäännös. Merkitään u = syt(x,y), v = syt(y,j). Rekursiokaavan todistamiseksi tulee osoittaa, että u = v. Nyt u jakaa x:n ja y:n. Mutta silloin sen on pakko jakaa myös j, koska x = ny + j (jos kaksi lukua on jaettavissa u:lla, niin myös niiden erotus on u:lla jaettavissa). Siis u on y:n ja j:n yhteinen tekijä, ja koska v on y:n ja j:n suurin yhteinen tekijä, niin u < v (u on yhteinen tekijä, v on suurin yhteinen tekijä). Vastaavasti päätellään, että koska v jakaa y:n ja j:n, sen täytyy jakaa myös x, joten u >= v (v on yhteinen tekijä, u on suurin yhteinen tekijä). => Täten välttämättä u = v.

syt(x,y):n oikeellisuus(3/3)
3. Algoritmin terminoituminen: viimeistään 1. kierroksen jälkeen x >=y. Jos x = y, niin x mod y = 0, ja algoritmi terminoituu seuraavalla kierroksella. jos taas x > y, niin silloin y => x mod y, joten x ja y pienevät seuraavalla kierroksella. Näin ollen algoritmin suoritus päättyy.

3.3.2.3 Oikeaksi todistaminen peräkkäisten väitteiden avulla
Usein vaikea löytää invarianssia tai sen todistaminen induktiolla voi olla vaikeaa. Silloin voidaan käyttää peräkkäisiä väitteitä. 1. Muodostetaan alku- ja loppuehdot. 2. Ohjelmaan sijoitetaan väitteitä 'kriittisiin kohtiin' niin, että niiden avulla voidaan todistaa ohjelman toimivuus kulkemalla alkuehdosta väitteiden kautta loppuehtoon ohjelma kontrollin mukaisesti. toistorakenteen sisälle ja jälkeen rekursiokutsun jälkeen vertailujen rinnalle 3. Todistetaan: kun algoritmin jokaisesta kohdasta, jossa on väite, edetään ohjelman kontrollin mukaan kohtaan, jossa on seuraava väite, niin myös tämä väite pitää paikkansa. 4. Lopuksi osoitetaan, että ohjelma terminoituu.

Esim. peräkkäiset väitteet moduulille syt(x,y) (2/4)
Lisätään alkuehto A, loppuehto F sekä väitteet B-E: MODULE syt(x, y) RETURNS s.y.t. {A: merk. syt(x, y) = z} WHILE {B: syt(x, y) = z} x <> y DO {C: x <> y ja syt(x, y) = z} IF x > y THEN {D: x > y ja syt(x,y)=z} x := x-y ELSE {E: x < y ja syt(x, y) = z} y := y-x ENDIF ENDWHILE {F: x = y ja syt(x, y) = z} RETURN x ENDMODULE Todistetaan, että jos alkuehto A pitää paikkansa ja edetään ohjelman kontrollin mukaan, myös loppuehto F pitää paikkansa. Tällöin lopputilassa z = syt(x,y) =x. Väitteessä esiintyvä invariantti on siis z =syt(x,y), joka pätee koko algoritmin suorituksen ajan.

C => E: Kuten edellinen.
A => B: Selvä. B => F: oletetaan, että B on voimassa, ts. että syt(x,y) =z. Jos tästä edetään F:ään, ei WHILE-ehto x<>y ole voimassa. Tällöin x=y, jolloin myös F on voimassa. B => C: Jos B:stä edetään C:hen, While-ehto on voimassa eli x <> y. Siis C pätee. C => D: Ol., että C on voimassa (x<>y ja syt(x,y)=z). D:hen edetään vain mikäli x > y. Siis D voimassa. C => E: Kuten edellinen. D => B: Ol., että D on voimassa, ts. x > y ja syt(x,y)=z. Kun siirrytään B:hen, x saa uuden arvon x-y, y ei muutu. Koska syt(x,y)=syt(x-y,y), on B voimassa. E => B: Kuten edellä. Loppuehto F on voimassa, jos algoritmin suoritus etenee sinne. MODULE syt(x, y) RETURNS s.y.t. {A: merk. syt(x, y) = z} WHILE {B: syt(x, y) = z} x <> y DO {C: x <> y ja syt(x, y) = z} IF x > y THEN {D: x > y ja syt(x,y)=z} x := x-y ELSE {E: x < y ja syt(x, y) = z} y := y-x ENDIF ENDWHILE {F: x = y ja syt(x, y) = z} RETURN x ENDMODULE

syt(x,y) terminoituvuus (4/4)
Terminoituvuus: silmukoita B => C => D => B tai B => C => E => B tulisi suorittaa ikuisesti, jotta algoritmi ei pysähtyisi. Mutta x ja y eivät voi ikuisesti olla erisuuria x ja y ovat positiivisa ohjelman joka vaiheessa ja aina jompikumpi pienenee

3.3.2.4 Terminoituvuus Algoritmin voi todistaa päättyväksi:
tarkastelemalla toistorakenteita ja niiden ehtoja ehto tulee joskus epätodeksi/todeksi toisto päättyy peräkkäisyyden ja valintojen eteneminen loppuun on helppo todistaa toistorakenteet/rekursiot monimutkaisempia niiden on välttämättä edettävä kohti tulosta tai triviaalia tapausta

3.3.2.4 Terminoituvuus Algoritmin terminoituvuus ei ole aina ilmeistä.
Esimerkki: Ackermannin funktio. Monimutkaisen näköinen funktio, silti voidaan osoittaa sen terminoituvan. y+1 x = 0 A(x,y) = A(x-1,1) x <> 0, y = 0 A(x-1, A(x, y-1)) x > 0, y > 0

3.3.2.4 Terminoituvuus... MODULE Ack(x,y) RETURNS A(x,y)
IF x = 0 THEN RETURN y+1 ELSE IF y = 0 THEN RETURN Ack(x-1, 1) ELSE RETURN Ack(x-1, Ack(x, y-1)) ENDIF ENDMODULE Ack(2,1)=…

3.3.2.4 Terminoituvuus... Päätellään terminoituvuudesta:
Kaikki rekursiiviset kutsut johtavat siihen, että ensimmäinen parametri pienenee kohti arvoa nolla. Täten algoritmin suoritus päättyy. Algoritmi on käytännössä kelvoton, vaikka onkin periaatteessa laskettavissa oleva tehtävä.

Tricky(x) Esimerkki: Terminoituuko seuraava moduuli ?
MODULE tricky (x) WHILE x > 1 DO IF x on parillinen THEN x := x/2 ELSE x := 3x+1 ENDIF ENDWHILE ENDMODULE Algoritmi päättyy monilla x:n arvoilla, mutta ei tiedetä päättyykö se kaikilla x:n arvoilla. tricky syötteillä 0,1,6,12,20..

Kompleksisuuden kertaluokat

Samankaltaiset esitykset

Esitys aiheesta: "Kompleksisuuden kertaluokat"— Esityksen transkriptio:

Samankaltaiset esitykset

Projektista

Palaute

Kirjaudu sisään

Kirjaudu sisään sosiaaliverkostojen kautta:

Kompleksisuuden kertaluokat

Samankaltaiset esitykset

Esitys aiheesta: "Kompleksisuuden kertaluokat"— Esityksen transkriptio:

Samankaltaiset esitykset

Projektista

Palaute