Clausal Language (ver. 5.81.21, by P.J. Voda, J. Komara, J. Kluka)

10. CVIČENIE Z PREDMETU ÚVOD DO DEKLARATÍVNEHO PROGRAMOVANIA LS 2014/2015

http://dai.fmph.uniba.sk/courses/udp/ex/ex10.zip

Dátum: 6. 5. 2015

Odporúčaná verzia CL: 5.81.21

WWW stránka predmetu: http://dai.fmph.uniba.sk/courses/udp/

Kontakt: udp(zavináč)lists.dai.fmph.uniba.sk

Úvodná poznámka. Toto cvičenie je venované postfixovému stroju a kompilácii aritmetických výrazov.

Literatúra.

[1] J. Kľuka. Prednášky z Úvodu do deklaratívneho programovania LS 2014/2015.

http://dai.fmph.uniba.sk/courses/udp/udp-prednasky-2015.pdf

[2] D. Guller. Poznámky k prednáškam z CL.

[3] J. Komara and P. J. Voda. Metamathematics of Computer Programming. 2001.

Poznámka. Nadpisy sú číslované podľa [1].

Preskočte nasledujúce komponenty po nadpis „CVIČENIE“.

C V I Č E N I E

17. POSTFIXOVÝ STROJ A KOMPILÁCIA

17.1. Postfixový stroj

17.3. Podmienené výrazy

Na prednáške sme opísali postfixový stroj, ktorý vykonáva program (postupnosť inštrukcií) modifikáciou zásobníka čísel.

Inštrukcie postfixového stroja. Nasledujúce konštruktory kódujú inštrukcie postfixového stroja. Predikát $Instr$ platí pre kódy inštrukcií.

Všimnite si skutočné mená konštruktorov ( $Pushi$ , $Loadi$ , $Addi$ , $Muli$ , $Subi$ , $Jzi$ ).

PUSH (n) = 0, n

LOAD (i) = 1, i

ADD = 2, 0

MUL = 3, 0

SUB = 4, 0

JZ (n) = 5, n

Instr PUSH (n) \leftarrow N (n)

Instr LOAD (i) \leftarrow N (i)

Instr (ADD)

Instr (MUL)

Instr (SUB)

Instr JZ (n) \leftarrow N (n)

Programy postfixového stroja. Program postfixového stroja je postupnosť inštrukcií.

Úloha. Zadefinujte predikát $Program (is)$ , ktorý platí, ak $is$ je kódom programu, teda zoznamom kódov inštrukcií.

Program (is) \leftarrow ?

Zásobník postfixového stroja. Postfixový stroj má zásobník čísel, ktorý sa mení počas behu programu. Inštrukcie pridávajú čísla na vrch zásobníka, alebo čísla z vrchu zásobníka odoberajú.

Zásobník zakódujeme zoznamom prirodzených čísel, pričom hodnota na vrchu zásobníka je prvým prvkom zoznamu.

Beh postfixového stroja. Postfixový stroj postupne vykonáva inštrukcie v programe. Inštrukcie menia zásobník nasledovným spôsobom (viď tiež ilustráciu v prednáškach [1, §17.1, str. 119 a §17.3, str. 127]):

$PUSH (n)$ pridá číslo $n$ na vrch zásobníka.
$LOAD (i)$ pridá na vrch zásobníka kópiu čísla, ktoré sa nachádza v zásobníku na $i$ -tom mieste (počítajúc od 0).
$ADD$ odoberie zo zásobníka vrchnú hodnotu $a$ a hodnotu pod ňou $b$ a namiesto nich pridá na vrch zásobníka hodnotu $b + a$ .
$MUL$ odoberie zo zásobníka vrchnú hodnotu $a$ a hodnotu pod ňou $b$ a namiesto nich pridá na vrch zásobníka hodnotu $b \cdot a$ .
$SUB$ odoberie zo zásobníka vrchnú hodnotu $a$ a hodnotu pod ňou $b$ a namiesto nich pridá na vrch zásobníka hodnotu $b \dot{-} a$ (pozor na poradie argumentov).
$JZ (n)$ odoberie zo zásobníka vrchnú hodnotu $a$ . Ak $a = 0$ , stroj preskočí nasledujúcich $n$ inštrukcií programu a pokračuje vykonávaním $(n + 1)$ -ej inštrukcie. Ak $a \neq 0$ , stroj pokračuje vykonávaním nasledujúcej inštrukcie.

Úloha. Odkrokujte na papieri beh nasledujúcich dvoch programov, ak začiatočný stav zásobníka je $3, 5, 7, 0$ .

{Prog}_{1} = PUSH (4), PUSH (6), ADD, LOAD (3), MUL, 0

{Prog}_{2} = LOAD (0), LOAD (1), MUL, PUSH (2), LOAD (2), LOAD (4), MUL, MUL, ADD, LOAD (3), LOAD (4), MUL, ADD, 0

Úloha. Zjednodušte program ${Prog}_{1}$ na 3 inštrukcie, teda napíšte program ${Prog}_{11}$ , ktorý vypočíta na vrch zásobníka rovnaký výsledok ako ${Prog}_{1}$ , ale $L ({Prog}_{11}) = 3$ .

{Prog}_{11} = ?

Úloha. Napíšte program ${Prog}_{3}$ pre postfixový stroj, ktorý zmení zásobník zo stavu $n, vs$ do stavu $n \cdot (n + 1), n, vs$ .

{Prog}_{3} = ?

Úloha. Odkrokujte na papieri beh nasledujúceho programu ${Dprog}_{1}$ , pre tri začiatočné stavy zásobníka: ${vs}_{1} = 3, 5, 7, 0$ , ${vs}_{2} = 8, 4, 2, 0$ a ${vs}_{3} = 1, 1, 1, 0$ .

{Dprog}_{1} = LOAD (0), LOAD (2), SUB, JZ (3), LOAD (0), PUSH (0), JZ (1), LOAD (1), 0

Úloha. Napíšte program ${Dprog}_{2}$ pre postfixový stroj, ktorý zmení zásobník zo stavu $x, y, vs$ do stavu $∣ x - y ∣, x, y, vs$ , teda vypočíta na vrch zásobníka absolútnu hodnotu rozdielu dvoch čísel na vrchu zásobníka.

{Dprog}_{2} = ?

Úloha. Zadefinujte funkciu $Run (is, vs)$ , ktorá simuluje beh postfixového stroja s programom $is$ na zásobníku $vs$ .

Po skončení programu vráti funkcia $Run$ hodnotu z vrchu zásobníka.

Použite funkcie $xs [i]$ ( $Sub (xs, i)$ ) a $Drop (n, xs)$ z modulu ${Maux}_{11}$ .

Testovanie:

    Run_test = rs:Results_run

Run (is, vs) = ?

Testovač funkcie $Run$ .

Map_run (p, 0) = 0

Map_run (p, vs, vss) = Run (p, vs), Map_run (p, vss)

Check_run (0, 0, vss) = 0

Check_run ((p, ps), (rs, rss), vss) = {Testing on p : Map_run (p, vss) =^{?} rs}, Check_run (ps, rss, vss)

Simple_programs = (PUSH (55), 0), (LOAD (0), 0), (LOAD (5), 0), (LOAD (55), 0), (ADD, 0), (MUL, 0), (SUB, 0), (JZ (2), PUSH (2), PUSH (4), PUSH (8), 0), (JZ (3), PUSH (2), PUSH (4), PUSH (8), 0), 0

Complex_programs = {Prog}_{1}, {Prog}_{2}, {Dprog}_{1}, (LOAD (1), PUSH (7), ADD, LOAD (1), MUL, 0), (LOAD (0), LOAD (0), MUL, LOAD (0), PUSH (1), ADD, MUL, 0), (LOAD (0), PUSH (3), SUB, JZ (5), LOAD (0), PUSH (3), SUB, PUSH (0), JZ (1), LOAD (0), 0), (LOAD (0), LOAD (2), JZ (3), LOAD (2), PUSH (1), ADD, LOAD (2), MUL, 0), 0

Run_test = Check_run (Simple_programs \oplus Complex_programs, rss, Valuations) \leftarrow (55, 55, 55, 55, 0), (101, 0, 256, 256, 0), (127, 113, 113, 109, 0), 0 = {simplerss}_{1} \land (0, 0, 0, 0, 0), (204, 101, 357, 256, 0), (10403, 0, 25856, 0, 0), 0 = {simplerss}_{2} \land (2, 101, 0, 0, 0), (8, 8, 8, 8, 0), (8, 101, 8, 8, 0), 0 = {simplerss}_{3} \land (1070, 1030, 1030, 1010, 0), (42456, 10609, 127857, 75737, 0), (103, 101, 256, 256, 0), 0 = {complexrss}_{1} \land (11110, 0, 27648, 1792, 0), (104070602, 0, 65536 \cdot (65536 + 1), 65536 \cdot (65536 + 1), 0), 0 = {complexrss}_{2} \land (98, 0, 253, 253, 0), (10504, 0, 26112, 0, 0), 0 = {complexrss}_{3} \land {simplerss}_{1} \oplus {simplerss}_{2} \oplus {simplerss}_{3} \oplus {complexrss}_{1} \oplus {complexrss}_{2} \oplus {complexrss}_{3} = rss

Úloha. Spustite programy ${Prog}_{1}$ , ${Prog}_{2}$ a ${Dprog}_{1}$ funkciou $Run$ a overte, či ste ich správne odkrokovali.

Úloha. Otestujte svoje programy ${Prog}_{11}$ , ${Prog}_{3}$ a ${Dprog}_{2}$ dopytmi:

Pomocou funkcie $Run$ môžeme presnejšie vyjadriť požadované vlastnosti programov ${Prog}_{11}$ , ${Prog}_{3}$ a ${Dprog}_{2}$ :

Run ({Prog}_{11}, vs) = Run ({Prog}_{1}, vs)

Run ({Prog}_{3}, (n, vs)) = n \cdot (n + 1)

x ≧ y \to Run ({Dprog}_{2}, (x, y, vs)) = x \dot{-} y

x ≦ y \to Run ({Dprog}_{2}, (x, y, vs)) = y \dot{-} x

a tieto programy aj otestovať:

    Progs_test = rs:Results_run

Progs_test = Check_run (({Prog}_{11}, {Prog}_{3}, {Dprog}_{2}, 0), rss, vss) \leftarrow (7, 3, 0), (2, 7, 0), (0, 7, 0), (6, 0, 0), 0 = vss \land Map_run ({Prog}_{1}, vss), (7 \cdot (7 + 1), 2 \cdot (2 + 1), 0 \cdot (0 + 1), 6 \cdot (6 + 1), 0), (4, 5, 7, 6, 0), 0 = rss

16.1. Aritmetické výrazy

17.3. Podmienené výrazy

Aritmetické výrazy s premennými, rozdielom a podmienkami. Aritmetické výrazy z minulého cvičenia rozšírime na tomto cvičení o nasledujúce dva typy:

rozdielový výraz $x \dot{-} y$ , ktorý zakódujeme konštruktorom $St (x, y) \equiv x {\dot{-}}^{•} y$ ;
podmienený výraz $D (x, y, z)$ , ktorý zakódujeme konštruktorom $Dt (t_{1}, t_{2}, t_{3}) \equiv D^{•} (t_{1}, t_{2}, t_{3})$ .

Predikát $Term$ uvedený nižšie platí pre kódy aritmetických výrazov, ktoré môžu obsahovať aj rozdielové a podmienené výrazy.

Ďalej budeme kódy výrazov nazývať trocha nepresne iba výrazmi.

t_{1} {\dot{-}}^{•} t_{2} = 4, t_{1}, t_{2}

D^{•} (t_{1}, t_{2}, t_{3}) = 5, t_{1}, t_{2}, t_{3}

Term (n^{•}) \leftarrow N (n)

Term (x_{i}^{•}) \leftarrow N (i)

Term (t_{1} +^{•} t_{2}) \leftarrow Term (t_{1}) \land Term (t_{2})

Term (t_{1} \times^{•} t_{2}) \leftarrow Term (t_{1}) \land Term (t_{2})

Term (t_{1} {\dot{-}}^{•} t_{2}) \leftarrow Term (t_{1}) \land Term (t_{2})

Term D^{•} (t_{1}, t_{2}, t_{3}) \leftarrow Term (t_{1}) \land Term (t_{2}) \land Term (t_{3})

Príklady výrazov. V module ${Maux}_{11}$ sú zadefinované konštanty ${Term}_{1}$ až ${Term}_{7}$ kódujúce príklady aritmetických výrazov bez rozdielových a podmienených výrazov.

Ohodnotenie a hodnota premenných. Ohodnotenie a hodnota premenných sú definované rovnako ako v 10. cvičení [1, §16.1, def. 39].

Hodnota výrazov.

Hodnotou rozdielového výrazu $t_{1} {\dot{-}}^{•} t_{2}$ je modifikovaný rozdiel hodnôt výrazov $t_{1}$ a $t_{2}$ .

Hodnotou podmieneného výrazu $D^{•} (t_{1}, t_{2}, t_{3})$ je hodnota podvýrazu $t_{2}$ , ak je hodnota podvýrazu $t_{1}$ nenulová. Inak je hodnotou podmieneného výrazu hodnota podvýrazu $t_{3}$ .

Výraz $D^{•} (t_{1}, t_{2}, t_{3})$ teda interpretujeme ako if $t_{1} \neq 0$ then $t_{2}$ else $t_{3}$ . Podmienené výrazy sa vyskytujú vo viacerých programovacích jazykoch, napríklad v Pythone môžeme napísať

    t2 if t1 else t3

a v C, C++, PHP, Jave zase

    t1 ? t2 : t3

Úloha. Vypočítajte hodnotu výrazu s kódom ${Dterm}_{1}$ pre nasledujúce tri ohodnotenia: ${vs}_{1} = 3, 5, 7, 0$ , ${vs}_{2} = 8, 4, 2, 0$ , and ${vs}_{3} = 1, 1, 1, 0$ .

Hodnota tohto výrazu je všeobecne známou funkciou hodnôt premenných $x_{0}$ a $x_{1}$ ? Ktorou?

{Dterm}_{1} = D^{•} ((x_{0}^{•} {\dot{-}}^{•} x_{1}^{•}), x_{0}^{•}, x_{1}^{•})

Úloha. Zakódujte do nasledujúcej konštanty ${Dterm}_{2}$ aritmetický výraz, ktorého hodnotou je absolútna hodnota rozdielu hodnôt premenných $x_{0}$ a $x_{1}$ .

{Dterm}_{2} = ?

Ďalšie testovacie podmienené výrazy.

{Dterm}_{3} = D^{•} ((x_{0}^{•} {\dot{-}}^{•} x_{1}^{•}), D^{•} ((x_{0}^{•} {\dot{-}}^{•} x_{2}^{•}), x_{0}^{•}, x_{2}^{•}), D^{•} ((x_{1}^{•} {\dot{-}}^{•} x_{2}^{•}), x_{1}^{•}, x_{2}^{•}))

{Dterm}_{4} = D^{•} (D^{•} ((1^{•} {\dot{-}}^{•} x_{0}^{•}), (1^{•} {\dot{-}}^{•} x_{1}^{•}), x_{2}^{•}), (x_{3}^{•} +^{•} x_{4}^{•}), (x_{3}^{•} \times^{•} x_{4}^{•}))

{Simple_terms}_{1} = Simple_terms \oplus ((x_{0}^{•} {\dot{-}}^{•} x_{2}^{•}), D^{•} (x_{0}^{•}, x_{1}^{•}, x_{2}^{•}), 0)

{Complex_terms}_{1} = Complex_terms \oplus ({Dterm}_{1}, {Dterm}_{3}, {Dterm}_{4}, 0)

Úloha. Zadefinujte denotačnú funkciu $Den (t, vs) \equiv {⟦ t ⟧}^{vs}$ , ktorá vypočíta hodnotu aritmetického výrazu $t$ pri ohodnotení premenných $vs$ .

Testovanie:

    Den_test = rs:Results_den

{⟦ n^{•} ⟧}^{vs} = n

{⟦ x_{i}^{•} ⟧}^{vs} = vs [i]

{⟦ t_{1} +^{•} t_{2} ⟧}^{vs} = {⟦ t_{1} ⟧}^{vs} + {⟦ t_{2} ⟧}^{vs}

{⟦ t_{1} \times^{•} t_{2} ⟧}^{vs} = {⟦ t_{1} ⟧}^{vs} \cdot {⟦ t_{2} ⟧}^{vs}

{⟦ t_{1} {\dot{-}}^{•} t_{2} ⟧}^{vs} = ?

{⟦ D^{•} (t_{1}, t_{2}, t_{3}) ⟧}^{vs} = ? \leftarrow ?

Testovač funkcie $Den$ .

Map_den (t, 0) = 0

Map_den (t, vs, vss) = {⟦ t ⟧}^{vs}, Map_den (t, vss)

Check_den (0, 0, vss) = 0

Check_den ((t, ts), (rs, rss), vss) = {Testing on t : Map_den (t, vss) =^{?} rs}, Check_den (ts, rss, vss)

Den_test = Check_den ({Simple_terms}_{1} \oplus {Complex_terms}_{1}, rs, Valuations) \leftarrow (7, 7, 7, 7, 0), (107, 103, 103, 101, 0), (204, 101, 357, 256, 0), (10403, 0, 25856, 0, 0), 0 = simplers \land (0, 0, 153, 155, 0), (103, 103, 101, 0, 0), 0 = {simplers}_{1} \land (1070, 1030, 1030, 1010, 0), (42456, 10609, 127857, 75737, 0), (10302, 0, 65792, 65792, 0), 0 = {complexrs}_{1} \land (2050, 1515, 2795, 1280, 0), (42436, 808, 104232, 0, 0), (1725, 404, 3732, 3328, 0), 0 = {complexrs}_{2} \land (43680, 21218, 73954, 1428, 0), 0 = {complexrs}_{3} \land (103, 101, 256, 256, 0), (107, 103, 256, 256, 0), (222, 11663, 216, 210, 0), 0 = complexdrs \land simplers \oplus {simplers}_{1} \oplus {complexrs}_{1} \oplus {complexrs}_{2} \oplus {complexrs}_{3} \oplus complexdrs = rs

Úloha. Pomocou denotačnej funkcie môžeme špecifikovať a testovať výraz ${Dterm}_{2}$ , ktorý ste mali definovať v pred-predchádzajúcej úlohe.

x ≧ y \to {⟦ {Dterm}_{2} ⟧}^{x, y, vs} = x \dot{-} y

x < y \to {⟦ {Dterm}_{2} ⟧}^{x, y, vs} = y \dot{-} x

Testovanie:

    Dterm2_test = rs:Results_den

Dterm2_test = Check_den (({Dterm}_{2}, 0), ((4, 5, 7, 6, 0), 0), (7, 3, 0), (2, 7, 0), (0, 7, 0), (6, 0, 0), 0)

17.2. Kompilácia aritmetických výrazov

17.3. Podmienené výrazy

Programy počítajúce aritmetické výrazy. Všimnite si, že ak spustíme program ${Prog}_{1}$ so zásobníkom $vs$ , na vrch zásobníka sa vypočíta hodnota výrazu ${Term}_{1}$ (z modulu ${Maux}_{11}$ ) pri ohodnotení premenných $vs$ . Teda:

Run ({Prog}_{1}, vs) = {⟦ {Term}_{1} ⟧}^{vs}

Podobný vzťah je medzi ${Prog}_{2}$ a ${Term}_{2}$ , medzi ${Dprog}_{1}$ a ${Dterm}_{1}$ i medzi ${Dprog}_{2}$ a ${Dterm}_{2}$ .

Úloha. Zadefinujte funkciu $Comp (t)$ , ktorá skompiluje aritmetický výraz $t$ do programu pre postfixový stroj tak, aby platilo

Term (t) \to Program Comp (t)

Term (t) \to Run (Comp (t), vs) = {⟦ t ⟧}^{vs}

Ako sme ukázali na prednáške, musíme použiť pomocnú funkciu ${Comp}_{1} (t, j)$ , ktorá skompiluje výraz $t$ do programu, ktorý vypočíta hodnotu výrazu $t$ , keď sa na zásobníku nad ohodnotením $vs$ nachádza $j$ medzivýsledkov $ms$ :

Term (t) \to Program {Comp}_{1} (t, j)

Term (t) \land L (ms) = j \to Run ({Comp}_{1} (t, j) \oplus p, ms \oplus vs) = Run (p, ({⟦ t ⟧}^{vs}, ms \oplus vs))

Testovanie:

    Comp1_test = rs:Results_comp

    Comp_test = rs:Results_comp

{Comp}_{1} (n^{•}, j) = PUSH (n), 0

{Comp}_{1} (x_{i}^{•}, j) = ?

{Comp}_{1} ((t_{1} +^{•} t_{2}), j) = ?

{Comp}_{1} ((t_{1} \times^{•} t_{2}), j) = ?

{Comp}_{1} ((t_{1} {\dot{-}}^{•} t_{2}), j) = ?

{Comp}_{1} (D^{•} (t_{1}, t_{2}, t_{3}), j) = ?

Comp (t) = ?

Testovače funkcií ${Comp}_{1}$ a $Comp$ .

{Check_comp}_{1} (0, vss) = 0

{Check_comp}_{1} ((t, ts), vss) = {Testing on t : p; (Map_run (p, Map_conc ((2, 4, 8, 0), vss)) =^{?} Map_den (t, vss))}, {Check_comp}_{1} (ts, vss) \leftarrow {Comp}_{1} (t, 3) = p

Comp1_test = {Check_comp}_{1} ({Simple_terms}_{1} \oplus {Complex_terms}_{1}, Valuations)

Check_comp (0, vss) = 0

Check_comp ((t, ts), vss) = {Testing on t : p; (Map_run (p, vss) =^{?} Map_den (t, vss))}, Check_comp (ts, vss) \leftarrow Comp (t) = p

Comp_test = Check_comp ({Simple_terms}_{1} \oplus {Complex_terms}_{1}, Valuations)

Úloha. Nájdite výrazy, ktorých hodnoty počítajú nasledujúce programy, teda pre daný $p$ nájdite taký $t$ , že platí

\forall vs {⟦ t ⟧}^{vs} = Run (p, vs)

Táto úloha je opakom kompilácie, nazýva sa dekompilácia.

Programy ${Prog}_{8}$ a ${Dprog}_{5}$ sa dajú dekompilovať do výrazov ${Term}_{8}$ a ${Dterm}_{5}$ tak, aby platilo $Comp ({Term}_{8}) = {Prog}_{8}$ a $Comp ({Dterm}_{5}) = {Dprog}_{5}$ . Pre programy ${Prog}_{9}$ a ${Dprog}_{6}$ to ale neplatí. Výrazy ${Term}_{9}$ a ${Dterm}_{6}$ , ktoré nájdete, budú počítať rovnaké hodnoty, ale ich kompiláciou dostanete iné programy ako ${Prog}_{9}$ a ${Dprog}_{6}$ .

Testovanie:

    Decomp_test = rs:Results_decomp

{Prog}_{8} = LOAD (1), PUSH (7), ADD, LOAD (1), MUL, 0

{Term}_{8} = ?

{Prog}_{9} = LOAD (0), LOAD (0), MUL, LOAD (0), PUSH (1), ADD, MUL, 0

{Term}_{9} = ?

{Dprog}_{5} = LOAD (0), PUSH (3), SUB, JZ (5), LOAD (0), PUSH (3), SUB, PUSH (0), JZ (1), LOAD (0), 0

{Dterm}_{5} = ?

{Dprog}_{6} = LOAD (0), LOAD (2), JZ (3), LOAD (2), PUSH (1), ADD, LOAD (2), MUL, 0

{Dterm}_{6} = ?

Testovač dekompilácie.

Check_decomp (0, vss) = 0

Check_decomp (((p, t), pts), vss) = {Testing on (p, t) : Map_den (t, vss) =^{?} Map_run (p, vss)}, Check_decomp (pts, vss)

Decomp_test = Check_decomp (pts, Valuations) \leftarrow ({Prog}_{8}, {Term}_{8}), ({Prog}_{9}, {Term}_{9}), ({Dprog}_{5}, {Dterm}_{5}), ({Dprog}_{6}, {Dterm}_{6}), 0 = pts