ff

Dr. Željko Jurić: Matematička logika i teorija izračunljivosti Tutorijal 13. Zadaci predviđeni za rad sa tutorom (akademska godina 2014/15)

Tutorijal 13. Dolje navedeni zadaci po svom sadržaju prate Predavanje 13 i predviđeni su da se prerade sa tutorom.

1. Napravite program za univerzalnu registarsku mašinu koja poznaje instrukcije “CLR”, “INC”, “TR” i “JNE” koja u registar R2 smješta cijeli dio polovice vrijednosti koja je smještena u registar R1. Nema nikakvih ograničenja na sadržaj ostalih registara po završetku programa.

Rješenje: Razmotrimo prvo jednostavniji slučaj kada je u R1 sigurno paran broj, tako da u R2 treba smjestiti

tačno polovicu te vrijednosti. Ideja je da prvo obrišemo registre R2 i R3 koji će služiti kao pomoćni registar, a zatim da u petlji stalno uvećavamo R2 za 1 a R3 za 2, sve dok se vrijednosti R3 i R1 ne izjednače. Tada će u R2 biti tačno polovica vrijednosti koja je u R1 (a ujedno i u R3). To vodi ka sljedećem programu:

1. CLR(2)

2. CLR(3)

3. INC(2)

4. INC(3)

5. INC(3)

6. JNE(1,3,3)

Ovaj program međutim ne radi ukoliko je vrijednost u R1 neparna (program će se “zaglaviti” u beskonačnoj petlji jer se uvjet u naredbi 6. nikada neće ispuniti). Da bismo prilagodili program da radi i za parne i za neparne vrijednosti, moraćemo ubaciti test da li je R1 = R3 ubaciti i nakon prvog od dva uzastopna uvećavanja registra R3, i prekinuti petlju ukoliko jeste. Kako nemamo instrukciju skoka u slučaju jednakosti (nego samo nejednakosti), simuliraćemo je tako što ćemo u slučaju nejednakosti preskočiti narednu instrukciju koja vrši bezuvjetni skok na traženo mjesto. Bezuvjetni skok ćemo simulirati tako što ćemo porediti dvije vrijednosti koje znamo da nikada nisu jednake. Za tu svrhu, u registar R4 ćemo upisati nulu (koju nećemo dirati), i poredićemo njegov sadržaj sa sardžajem nekog registra koji sigurno nije nula. Tako dolazimo do sljedećeg programa:

1. CLR(2)

2. CLR(3)

3. CLR(4)

4. INC(2)

5. INC(3)

6. JNE(1,3,8)

7. JNE(2,4,10)

8. INC(3)

9. JNE(1,3,4)

NAPOMENA: Ovaj program radi ispravno za sve vrijednosti u R1 osim nule. Studentima treba postaviti problem da ustanove zašto program ne radi ako je R1 = 0, šta će se desiti ako se program pokrene za početnu vrijednost R1 = 0, i kako bi se mogao prepraviti program da ispravno radi i za ovu početnu vrijednost (uputa: razmotriti kako je sličan problem riješen u Zadatku 3.).

2. Napravite program za univerzalnu registarsku mašinu koja poznaje instrukcije “CLR”, “INC”, “TR” i “JNE” koja u registar R2 smješta rezultat izračunavanja izraza 1 + 2 +3 + ... + n, pri čemu je n vrijednost pohranjena u registru R1 (ne koristeći pri tome eksplicitnu formulu prema kojoj taj rezultat iznosi n (n + 1)/2). Nema nikakvih ograničenja na sadržaj ostalih registara po završetku programa.

Rješenje:

Ideja je da se registar R2 inicijalno postavi na nulu, a R3, koji će se koristiti kao brojač, na vrijednost 1, a zatim se u petlji izvodi akcija R2 + R3 R2, nakon čega se R3 uvećava za 1 i petlja se ponavlja sve dok vrijednost R3 ne dostigne n (čija vrijednost se čuva u R1). Kako se izvodi akcija R2 + R3 R2, demonstrirano je na predavanjima. Za tu svrhu je potrebna još jedna petlja,


za čiji će se brojač upotrijebiti registar R4 (tako da će program imati petlju unutar petlje). To nas vodi do sljedećeg programa:

1. CLR(2)

2. CLR(3)

3. INC(3)

4. CLR(4)

5. INC(2)

6. INC(4)

7. JNE(4,3,5)

8. INC(3)

9. JNE(3,1,4)

3. Napravite program za univerzalnu registarsku mašinu koja poznaje instrukcije “CLR”, “INC”, “TR” i “JNE” koja u registar R3 smješta manju od dvije vrijednosti pohranjene u registrima R1 i R2.

Rješenje:

Ideja je da se inicijalizira R3 na nulu, a zatim se u petlji poredi da li je njegova vrijednost postala jednaka bilo vrijednosti R3, bilo vrijednosti R2. Ukoliko je makar jedna jednakost ispunjena, petlja se prekida, i R3 će sadržavati traženu vrijednost. U suprotnom, R3 se povećava za jedinicu petlja se nastavlja. Za skok izvan petlje trebaće nam bezuvjetni skok, koji možemo simulirati poređenjem dva registra čiji je sadržaj garantirano različit. Kako ne možemo nikada garantirati da su svi R1, R2 i R3 međusobno različiti, iskoristićemo registre R4 i R5 u kojima ćemo stalno čuvati nulu i jedinicu (što će garantirati njihovu različitost). To nas vodi do sljedećeg programa:

1. CLR(3)

2. CLR(4)

3. CLR(5)

4. INC(5)

5. JNE(1,3,7)

6. JNE(4,5,11)

7. JNE(2,3,9)

8. JNE(4,5,11)

9. INC(3)

10. JNE(4,5,5)

4. Napravite program za brojačku mašinu koja u registar R2 smješta cijeli dio polovice vrijednosti

koja je smještena u registar R1. Nema nikakvih ograničenja na sadržaj ostalih registara po završetku programa.

Rješenje: Formulacija ovog problema je identična kao u Zadatku 1. ali je model mašine drugačiji, tako da je

i logika rješavanja drugačija. Naime, brojačka mašina nema mogućnost poređenja proizvoljnih vrijednosti, nego samo mogućnost poređenja sa nulom (i to samo nakon umanjenja sadržaja registra), ali može i umanjivati registre za jedinicu, a ne samo uvećavati. Ideja je da se prvo R2 anulira (što se isto mora raditi malom petljom), a zatim se u novoj petlji R2 uvećava za 1, a R1 smanjuje za 2. Kada R1 dostigne nulu, R2 će sadržavati polovicu vrijednosti iz R1. Prvo ćemo riješiti problem uz pretpostavku da je vrijednost u R1 sigurno parna. To daje sljedeći program:

1. DJNZ(2,1)

2. INC(2)

3. DJNZ(1,4)

4. DJNZ(1,2)

Međutim, ukoliko je sadržaj R1 neparan, prije ili kasnije će instrukcija 3. oboriti vrijednost R1 na nulu, tako da će instrukcija 4. oboriti sadržaj R1 “ispod nule”. Šta se u tom slučaju dešava, ovisi od konkretne varijante brojačke mašine (neke verzije dopuštaju rad sa negativnim brojevima, druge obustavljaju rad, treće jednostavno ostavljaju vrijednost na nuli). Da bismo izbjegli dileme šta bi se desilo u slučaju da dođe do tog obaranja, nakon instrukcije 3. je potrebno testirati da li


je R1 dostigao nulu, i ako jeste, prekinuti dalje izvođenje programa. Za tu svrhu, potreban nam je bezuvjetan skok, a kako njega postići, može se vidjeti u sljedećem programu:

1. DJNZ(2,1)

2. INC(2)

3. DJNZ(1,6)

4. INC(1)

5. DJNZ(1,7)

6. DJNZ(1,2)

NAPOMENA: I ovaj program pravi probleme ukoliko je početna vrijednost u R1 nula. Razmisliti o načinu rješavanja ovog problema.

5. Napravite program za brojačku mašinu koji oduzima sadržaj registra R2 od registra R1 i smješta

rezultat u registar R3, bez ograničenja kakav će biti sadržaj ostalih registara po završetku programa. Zatim ponovo riješite isti problem uz ograničenje da po završetku rada sadržaj registara R1 i R2 treba da ostane nepromijenjen.

Rješenje: Pretpostavićemo da je R1 > R2. Ideja je prvo premjestiti R1 u R3, a zatim u petlji umanjivati R3 i R2

za jedinicu, dok R2 ne dostigne nulu. Nakon dostizanja nule, R3 će sadržavati traženu razliku. Premještanje R1 u R3 izvodimo tako što u petlji uvećavamo R3 za 1, a umanjujemo R1 za 1, dok R1 ne dostigne nulu (prethodno smo R3 postavili na nulu). To daje sljedeći program:

1. DJNZ(3,1)

2. INC(3)

3. DJNZ(1,2)

4. DJNZ(3,5)

5. DJNZ(2,4)

Ovaj program djeluje destruktivno na R1 i R2. Da bismo izbjegli to, R1 ćemo nedestruktivno kopirati u R3 umjesto da vršimo destruktivo pomjeranje, a isto tako ćemo R2 kopirati u R4 i dalje raditi sa R4 ono što smo ranije radili sa R2. Kako obaviti nedestruktivno kopiranje, opisano je na predavanjima. Za oba kopiranja, koristićemo R5 kao pomoćni registar. To daje sljedeći program:

1. DJNZ(3,1)

2. DJNZ(5,2)

3. INC(5)

4. DJNZ(1,3)

5. INC(1)

6. INC(3)

7. DJNZ(5,5)

8. DJNZ(4,8)

9. INC(5)

10. DJNZ(2,9) 11. INC(2) 12. INC(4) 13. DJNZ(5,11) 14. DJNZ(3,15) 15. DJNZ(4,14)

6. Napravite program za brojačku mašinu koji množi sadržaje registara R1 i R2, i smješta rezultat u

registar R3. Nema nikakvih ograničenja kakav će biti sadržaj ostalih registara po završetku programa.

Rješenje: Ideja je da se R3 na početku postavi na nulu, a zatim u petlji R2 puta ponovi akcija R3 + R1 R3.

Petlju koja se izvodi R2 puta lako je realizirati umanjivajem R2 za 1 i testirajem da li je on dostigao nulu. Akcija R3 + R1 R3 izvodi se na isti način kao i nedestruktivno kopiranje R1 u R3, samo bez prethodnog brisanja R3. Konačno, sve zajedno daje sljedeći program:


1. DJNZ(3,1)

2. DJNZ(4,2)

3. INC(4)

4. DJNZ(1,3)

5. INC(1)

6. INC(3)

7. DJNZ(4,5)

8. DJNZ(2,3)

7. Pokažite da su sljedeće funkcije primitivno rekurzivne:

a) f (n) =

n

i

i0

2 b) f (m, n)= {1, ako je n , u suprotnom

c) f(n) = ⌊ √n ⌋

Rješenje:

a) Za funkciju f(n) očigledno vrijede relacije

f (0) = 0, f (n + 1) = f(n) + (n + 1)2

odnosno

f (0) = 0, f (n’) f(n) + (n’)2

Ovo podsjeća na formule kojima se neka funkcija izvodi iz druge dvije primitivnom rekurzijom. Naime, f je izvedena primitivnom rekurzijom iz funkcija g i h, f = Pr[ g, h], ukoliko vrijedi

f (0) = g(), f (n’) h(n, f(n))

Ovo možemo ispuniti ako uzmemo da je g() = 0, i h(n, f(n)) = f(n) + (n’)2. Druga relacija nakon smjene m = f(n) postaje h(n, m) = (n’)2 + m. Dakle, uz ovakve g i h imamo f = Pr[ g, h]. Funkcija g je očito primitivno rekurzivna (ona je članica osnovnog skupa). Pokažimo da je i h primitivno rekurzivna. Na predavanjima je pokazano da su funkcije add(n, m) = n + m i mul(n, m) = n m primitivno rekurzivne, a isto vrijedi i za funkciju succ(n) = n’. Imamo

h(n, m) = (n’)2 + m = add((n’)2, m) = add(mul(n’, n’), m) = add(mul(succ(n), succ(n)), m)

Odavde je očigledno da se funkcija h može dobiti kompozicijom iz funkcija add, mul i succ koje su primitivno rekurzivne, pa je i h primitivno rekurzivna. Na kraju slijedi da je i f primitivno rekurzivna. Želimo li da se formalno uklopimo u definiciju kompozicije, moraćemo upotrijebiti i projekcijske funkcije. Naime, možemo dalje pisati

h(n, m) = add(mul(succ(n), succ(n)), m) = = add(mul(succ(1,2(n, m)), succ(1,2(n, m))), 2,2(n, m))

odakle je

h = Cn[add, Cn[mul, Cn[succ, 1,2], Cn[succ, 1,2]], 2,2]

te je, konačno,

f = Pr[0, Cn[add, Cn[mul, Cn[succ, 1,2], Cn[succ, 1,2]], 2,2]]

b) Ideja je da se uoči da je m = n ako i samo ako je m ∸ n = 0 i n ∸ m = 0. Prema definiciji funkcije ̅ sa predavanja, imamo ̅(m ∸ n) = 1 ako i samo ako je m ∸ n = , inače je ̅(m ∸ n) = 0. Isto tako, ̅(n ∸ m) = 1 ako i samo ako je n ∸ m, inače je ̅(n ∸ m) = 0. Slijedi da je produkt ̅(m ∸ n) ̅(n ∸ m) jednak jedinici ako i samo ako je m ∸ n = 0 i n ∸ m = 0 (tj. za m = n), inače je jednak nuli. Odavde neposredno slijedi da se funkcija f može prikazati kao

f(m, n) = ̅(m ∸ n) ̅(n ∸ m)


odnosno

f(m, n) = mul( ̅(bdif(m, n)), ̅(bdif(n, m)))

gdje je bdif(m, n) = m ∸ n. Kako je na predavanjima pokazano da su funkcije mul, ̅ i bdif primitivno rekurzivne, primitivno je rekurzivna i funkcija f koja se iz njih očito može dobiti kompozicija. Želimo li se precizno uklopiti u definiciju kompozicije, morali bismo pisati

f(m, n) = mul( ̅(bdif(m, n)), ̅(bdif(n, m))) = = mul( ̅(bdif(m, n)), ̅(bdif(2,2(m, n), 1,2(m, n))))

tako da je

f = Cn[mul, Cn[ ̅, bdif], Cn[ ̅, Cn[bdif, 2,2, 1,2]]]

c) Prema definiciji kvadratnog korijena i cijelog dijela broja, f (n) je očigledno najveći cijeli broj čiji je kvadrat manji ili jednak od n, odnosno f (n) je za 1 manji od najmanjeg cijelog broja q takvog da je q2 > n. Uvjet q2 > n može se zapisati i kao sg(q2 ∸ n) = 0. Stoga se takav q može odrediti minimizacijom odnosno -rekurzijom:

f (n) = q [sg(q2 ∸ n) = 0] – 1 = pred(q [sg(q2 ∸ n) = 0])

gdje je pred funkcija “prethodnik”, za koju je na predavanjima pokazano da je primitivno rekurzivna. Funkcija h(n, q) = sg(q2 ∸ n) je očito primitivno rekurzivna, jer se može dobiti kompozicijom iz primitivno rekurzivnih funkcija sg, mul i bdif. Međutim, operacija minimizacije primijenjena na primitivno rekurzivnu funkciju ne mora dati primitivno rekurzivnu funkciju. Ipak, na predavanjima je pokazano da je rezultat operacije minimizacije primijenjene na primitivno rekurzivnu funkciju i sam primitivno rekurzivna funkcija kadgod imamo garanciju da je rezultat te minimizacije manji ili jednak od neke funkcije za koju znamo da je primitivno rekurzivna. Ovdje imamo da očigledno vrijedi

q [sg(q2 ∸ n) = 0] n = 1,1(n) pa je ovaj uvjet ispunjen. Štaviše, prema formuli izvedenoj na predavanju imamo da je tada

q [sg(q2 ∸ n) = 0] =

n

i 0

sg

i

j 0

sg( j2 ∸ n))

a pokazano je na predavanjima da se sve operacije sa desne strane jednakosti mogu se izraziti kombinirajući primitivnu rekurziju i kompoziciju. Konačno, f je primitivno rekurzivna kao kompozicija funkcije pred (koja je primitivno rekurzivna) i funkcije dobijene kao rezultat minimizacije q [sg(q2 ∸ n) = 0] (koja je također primitivno rekurzivna).

8. Sastavite Markovljev algoritam koji rade sljedeće:

a) Briše sve pojave znakova “a”, “b” i “c” unutar stringa zadanog kao ulaz; b) Briše prvi znak stringa zadanog kao ulaz, pri čemu je poznato da se string sastoji samo od

znakova “a”, “b” i “c”; c) Dodaje znak “c” na kraj stringa koji se sastoji samo od znakova “a” i “b”; d) Uvećava broj zapisan u unarnoj notaciji za 1, tako da ukoliko se on primijeni npr. na string “ | | | ” kao rezultat treba da se dobije string “ | | | | ”;

e) Sabira dva broja u unarnoj notaciji, pri čemu ulazni string sadrži dva unarna broja razdvojena znakom “+” (npr. “ | | | | + | | ”), a kao rezultat se dobija unarna reprezentacija njihovog zbira (“ | | | | | | ” u navedenom primjeru).

Rješenje: a) Ovdje je samo potrebno zamijeniti prvu pojavu bilo znaka “a”, bilo “b” bilo “c” sa praznim

stringom . Algoritam će se tada primjenjivati sve dok se ma koja zamjena može izvršiti. Drugim riječima, algoritam će izgledati ovako:


1. a 2. b 3. c

Na primjer, primijenjeno na string “dcaefbeacdce”, dobićemo sljedeći niz stringova prije nego što algoritam završi:

“dcaefbeacdce”, “daefbeacdce”, “defbeacdce”, “defeacdce”, “defecdce”, “defedce”, “defede”

b) Ovdje ima “caka” što se mora koristiti dodatni znak koji se ne nalazi u ulaznom stringu kao “pomoćni” (recimo, znak “∗”). Prvo na početak stringa dodamo taj znak, što se može uraditi pravilom ∗. Nakon te modifikacije, string sigurno počinje sa sekvencom “∗a”, “∗b” ili “∗c”, a pored toga, takva sekvenca se ne može pojaviti nigdje drugdje. Sada je sve što je potrebno zamijeniti takvu sekvencu praznim stringom, i algoritam se završava. Stoga će algoritam izgledati ovako:

1. ∗a . 2. ∗b . 3. ∗c . 4. *

Ovdje je važno uočiti dvije stvari. Prvo, redoslijed pravila mora biti baš ovakav, jer se uvijek primjenjuje prvo pravilo koje se može primijeniti. Da je slučajno pravilo 4. bilo prvo, ono se uvijek može primijeniti, tako da bi se na početak stringa stalno dodavao znak “*” i algoritam nikada ne bi terminirao. Drugo, pravila 1., 2. i 3. moraju biti završna pravila (tačka iza strelice). U suprotnom, nakon obavljenog brisanja, pravilo 4. bi se ponovo moglo primijeniti, i algoritam bi nastavio sa brisanjem narednih znakova.

c) U prethodnom primjeru smo vidjeli da je sasvim lako dodati neki znak na početak stringa. Znatno je teže dodati nešto na kraj stringa, jer se pravila u Markovljevim algoritmima uvijek primjenjuju na prvo mjesto gdje se mogu primijeniti. Zbog toga se koristi sljedeći trik. Uvede se neki specijalni simbol (marker), recimo “∗”, koji se prvo doda na početak stringa, a onda se on “izguruje” do kraja stringa (ili, općenitije, do mjesta koje nam treba). Nakon toga, marker se prosto zamjenjuje onim što želimo ubaciti. To daje sljedeći algoritam (obratite pažnju na redoslijed pravila):

1. ∗a a∗ 2. ∗b b∗ 3. ∗ . c 4. ∗

Pravila 1. i 2. obavljaju “guranje” markera na kraj stringa. Kada se ova pravila više ne mogu primijeniti, marker je došao na kraj, pravilo 3. ga zamjenjuje sa “c”, i algoritam se završava.

d) Rješenje je vrlo jednostavno, samo na početak stringa treba dodati jedan znak “|” i prekinuti algoritam:

1. . |

Moguće je i sljedeće interesantno rješenje u kojem se ne koristi zamjena praznog stringa nečim, ali se umjesto toga koristi marker:

1. ∗ . | 2. | ∗ |

e) Rješenje je neočekivano jednostavno, samo treba izbaciti znak “+” između dvije sekvence znakova “|”, tako da se čitav algoritam samo svodi na jedno pravilo:

1. +

ff

Documents

Transcript of ff