IB013 Logické programování Hana Rudová jaro 2013 Hodnocení předmětu JS> Průběžná písemná přáce: až 30 bodů (základy programování v Prologu) ± pro každého jediný termín: 26.března .0 alternativní termín pouze v prípadech závažných důvodů pro neúčast i> vzor písemky na webu predmetu & ZáveřeCná písemná přáce: až 150 bodů -fc vzor písemky na webu predmetu -i- opravný termín možný jako ústní zkouška & ZápoCtový projekt: celkem až 40 bodu C- Hodnocení: součet bodu za projekt a za obe písemky J* známka A za cca 175 bodu, známka F za cca 110 bodu -i- známka bude zapsána pouze tem, kterí dostanou zápocet za projekt -i* Ukoncení predmetu zápoctem: zápocet udelen za zápoctový projekt Hana Rudová, Logické programování I, 15. kvetna 2013 2 Organizace predmetu Základní informace & Prednáška: úcast není povinná, nicméně ... -í* CviCení: úCast povinná individuální dopinující príklady za zmeškaná cviCení nelze při vysoké neúCasti na cviCení A skupina 01, sudá středa, první cvicení 6.brezna, Hana Rudová J> skupina 02, lichá středa, první cvicení 27.února, Adriana Strejcková M Predpoklad: znalost základů výrokové a predikátové logiky, napr. z IB101 Web predmetu: interaktivní osnova v ISu -i- průsvitky dostupné postupne v pmbehu semestru sbírka príkladu vcetne rešení (zverejnena cca do 8.3.) a harmonogram výuky, predbežný obsah výuky behem semestru -4» elektronicky dostupné materiály a informace o zápoctových projektech Hana Rudová, Logické programování I, 15. kvetna 2013 3 Organizace predmetu Rámcový obsah předmětu Obsah přednášky & základy programování v jazyce Prolog JS> teorie logického programováni logické programování s omezujícími podmínkami -í* DC gramatiky Obsah cviCení -í* zaměřeno na praktické aspekty, u pocítacu programování v Prologu & logické programování a logické programování s omezujícími podmínkami Hana Rudová, Logické programování I, 15. kvetna 2013 4 Organizace predmetu Literatura ü> Bratko, I. Prolog Programming for Artificial Intelligence. Addison-Wesley, 2001. it prezenčne v knihovne ü> Clocksin, W. F. - Mellish, Ch. S. Programming in Prolog. Springer, 1994. JS> Sterling, L. - Shapiro, E. Y. The art of Prolog : advanced programming techniques. MIT Press, 1987. ü> Merode, A. - Shore, R. A. Logic for applications. Springer-Verlag, 1993. it prezencne v knihovne JS> Dechter, R. Constraint Processing. Morgan Kaufmann Publishers, 2003. -i. prezencne v knihovne + Elektronicky dostupné materiály (viz web predmetu) Hana Rudová, Logické programování I, 15. kvetna 2013 s Organizace predmetu Průběžná písemná práce M Pro každého jediný termín 26. brezna ii> Alternativní termín pouze v závažných důvodech pro neúčast JS> Celkem až 30 bodů (150 záverečná písemka, 40 projekt) Hana Rudová, Logické programování I, 15. kvetna 2013 6 Organizace predmetu Průběžná písemná práce Pro každého jediný termín 26. brezna Alternativní termín pouze v závažných důvodech pro neúčast Celkem až 30 bodů (150 záverečná písemka, 40 projekt) 3 príklady, 40 minut Napsat zadaný predikát, porovnat chování programů Obsah: první čtyri prednášky a první dve cvičení Oblasti, kterých se budou príklady zejména týkat s* unifikace seznamy backtracking & optimalizace posledního volání & rez aritmetika iS> Ukázka průběžné písemné práce na webu Hana Rudová, Logické programování I, 15. května 2013 6 Organizace předmětu Zápočtové projekty & Zadání, dotazy, odevzdávání: Adriana Strejčkova -í* Týmová práce na projektech, až 3 řešitelé Jť zápoCtové projekty dostupné přes web predmetu -í* Podrobné pokyny k zápočtovým projektům na webu predmetu -fc bodování, obsah predbežné zprávy a projektu a typ projektu: LP, CLP & Predbežná zpráva -i- podrobné zadání J* v jakém rozsahu chcete úlohu rešit -i- které vstupní informace bude program používat a co bude výstupem programu S> scénáre použití programu (tj. ukázky dvojic konkrétních vstupu a výstupu) Hana Rudová, Logické programování I, 15. kvetna 2013 7 Organizace predmetu Casový harmonogram k projektům -í* Zverejnení zadání (vetšiny) projektů: 26. února Zahájení registrace rešitelU projektu: 13. brezna, 19:00 & Predbežná analýza řešeného problému: 12. dubna & Odevzdání projektů: 17. kvetna & Predvádení projektu (po registraci): 23.kvetna - 20.Cervna Hana Rudová, Logické programování I, 15. kvetna 2013 8 Organizace p redmetu Software: SICStus Prolog C Doporučovaná implementace Prologu & Dokumentace: http://www.fi.muni.cz/~hanka/sicstus/doc/html JS> Komerční produkt it licence pro instalace na domácí počítače studentu C Používané IDE pro SICStus Prolog SPIDER Jt dostupné od verze SICStus 4.1.3 http://www.sics.se/sicstus/spider it používá Eclipse SDK $ Podrobné informace dostupné pres web predmetu it stažení SICStus Prologu (sw + licencní klíce) it pokyny k instalaci (SICStus Prolog, Eclipse, Spider) Hana Rudová, Logické programování I, 15. kvetna 2013 9 Organizace predmetu SICStus IDE SPIDER Hana Rudová, Logické programování I, 15. kvetna 2013 10 prevzato z http://www.sics.se/sicstus/spider Organizace p redmetu Úvod do Prologu Prolog -í* PROgramming in LOGic a Část predikátové logiky prvního rádu ii> Deklarativní programování -i- specifikační jazyk, jasná sémantika, nevhodné pro procedurální postupy & Co delat namísto Jak delat JS> Základní mechanismy J* unifikace, stromové datové struktury, automatický backtracking Hana Rudová, Logické programování I, 15. kvetna 2013 12 Úvod do Prologu Logické programování Historie C- Rozvoj začíná po roce 1970 & Robert Kowalski - teoretické základy & Alain Colmerauer, David Warren (Warren Abstract Machine) - implementace & SICStus Prolog vyvíjen od roku 1985 -í* Logické programování s omezujícími podmínkami - od poloviny 80. let Aplikace & rozpoznávání reci, telekomunikace, biotechnologie, logistika, plánování, data mining, business rules, ... SICStus Prolog — the first 25 years, Mats Carlsson, Per Mildner. Theory and Practice of Logic Programming, 12 (1-2): 35-66, 2012. http://arxiv.org/abs/1011.5640. Hana Rudová, Logické programování I, 15. kvetna 2013 13 Úvod do Prologu Přogřam = fakta + pravidla (Přologovský) přogřam je seznam programových klauzulí i> programové klauzule: fakt, pravidlo Fakt: deklaruje vždy pravdivé veci -fc clovek( novak, 18, student ). Přavidlo: deklaruje veci, jejichž pravdivost závisí na daných podmínkách J* studuje( X ) :- clovek( X, _Vek, student ). A alteřnativní (obousmeřný) význam přavidel pro každé X, pro každé X, X studuje, jestliže Xje student, potom X je student X studuje -4» pracuje( X ) :- clovek( X, _Vek, CoDela ), prace( CoDela ). Hana Rudová, Logické programování I, 15. kvetna 2013 14 Úvod do Prologu Program = fakta + pravidla JS> (Prologovský) program je seznam programových klauzulí i> programové klauzule: fakt, pravidlo & Fakt: deklaruje vždy pravdivé veci Jt clovek( novak, 18, student ). & Pravidlo: deklaruje veci, jejichž pravdivost závisí na daných podmínkách J* studuje( X ) clovek( X, _Vek, student ). A alternativní (obousměrný) význam pravidel pro každé X, pro každé X, X studuje, jestliže Xje student, potom X je student X studuje Jt pracuje( X ) clovek( X, _Vek, CoDela ), prace( CoDela ). JS> Predikát: seznam pravidel a faktu se stejným funktorem a aritou S> znacíme: clovek/3, student/1; analogie procedury v procedurálních jazycích, Hana Rudová, Logické programování I, 15. kvetna 2013 14 Úvod do Prologu Komentáře k syntaxi C Klauzule ukonCeny teCkou & Základní príklady argumentu -i- konstanty: (tomas, anna) ... zaCínají malým písmenem i* promenné X, Y ... zaCínají velkým písmenem _, _A, _B ... zaCínají podtržítkem (nezajímá nás vracená hodnota) £ Psaní komentárů clovek( novak, 18, student ). % komentár na konCi rádku clovek( novotny, 30, ucitel ). /* komentár */ Hana Rudová, LogiCké programování I, 15. kvetna 2013 15 Úvod do Prologu Dotaz Dotaz: uživatel se ptá programu, zda jsou veci pravdivé ?- studuje( novak ). % yes splnitelný dotaz ?- studuje( novotny ). % no nesplnitelný dotaz Odpoved' na dotaz a positivní - dotaz je splnitelný a uspel ± negativní - dotaz je nesplnitelný a neuspel Hana Rudová, Logické programování I, 15. kvetna 2013 16 Úvod do Prologu Dotaz Dotaz: uživatel se ptá programu, zda jsou veci pravdivé ?- studuje( novak ). ?- studuje( novotny ). Odpověď na dotaz % yes % no positivní - dotaz je splnitelný a uspěl negativní - dotaz je nesplnitelný a neuspěl splnitelný dotaz nesplnitelný dotaz Proměnné jsou behem výpoCtu instanciovány (= nahrazeny objekty) ?- clovek( novak, 18, Prace ). Prace = student -í* výsledkem dotazu je instanciace proměnných v dotazu A dosud nenainstanciovaná promenná: volná promenná Hana Rudová, Logické programování I, 15. kvetna 2013 16 Úvod do Prologu Dotaz Dotaz: uživatel se ptá programu, zda jsou veci pravdivé ?- studuje( novak ). % yes splnitelný dotaz ?- studuje( novotny ). % no nesplnitelný dotaz Odpověď na dotaz A positivní - dotaz je splnitelný a uspel ± negativní - dotaz je nesplnitelný a neuspel Promenné jsou behem výpoctu instanciovány (= nahrazeny objekty) ?- clovek( novak, 18, Prace ). Prace = student -í* výsledkem dotazu je instanciace přomenných v dotazu A dosud nenainstanciovaná promenná: volná přomenná & Prolog umí generovat více odpovedí, pokud existují ?- clovek( novak, Vek, Prace ). % všechna rešení p res ";" Hana Rudová, Logické programování I, 15. kvetna 2013 16 Úvod do Prologu Klauzule = fakt, pravidlo, dotaz Klauzule se skláda z hlavy a tela & Telo je seznam cílů oddelených cárkami, cárka = konjunkce & Fakt: pouze hlava, prázdné telo Jť rodic( pavla, robert ). -í* Pravidlo: hlava i telo upracovany_clovek( X ) clovek( X, _Vek, Prace ), prace( Prace, tezka ). & Dotaz: prázdná hlava, pouze telo J* ?- clovek( novak, Vek, Prace ). ?- rodic( pavla, Dite ), rodic( Dite, Vnuk ). Hana Rudová, Logické programování I, 15. kvetna 2013 17 Úvod do Prologu Rekurzivní pravidla predek( X, Z ) rodic( X, Z). % (1) predek( X, Z ) rodic( X, Y ), % (2) rodic( Y, Z). Hana Rudová, Logické programování I, 15. kvetna 2013 18 Úvod do Prologu Rekurzivní pravidla predek( X, Z ) :- rodic( X, Z). % (1) predek( X, Z ) :- rodic( X, Y ), % (2) rodic( Y, Z). predek( X, Z ) :- rodic( X, Y ), % (2') predek( Y, Z). Hana Rudová, LogiCké programování I, 15. kvetna 2013 18 Úvod do Prologu Príklad: rodokmen rodic( pavla, robert ). rodic( tomas, robert ). rodic( tomas, eliska ). rodic( robert, anna ). rodic( robert, petr ). rodic( petr, jirka ). pavla \ tomas Rodice \ / robert / \ \ eliska / anna \ petr / jirka Deti predek( X, Z ) :- rodic( X, Z). % (1) predek( X, Z ) :- rodic( X, Y ), % (2') predek( Y, Z ). Hana Rudová, Logické programování I, 15. kvetna 2013 19 Úvod do Prologu VýpoCet odpovedi na dotaz ľ- predek(tomas,robert) rodic( pavla, robert ). rodic( tomas, robert ). rodic( tomas, eliska ). rodic( robert, anna ). rodic( robert, petr ). rodic( petr, jirka ). predek(tomas,robert) dle (1) yes rodic(tomas,robert) predek( X, Z ) i- rodic( X, Z ). % (1) predek( X, Z ) i- rodic( X, Y ), % (2') predek( Y, Z ). Hana Rudová, Logické programování I, 1S. kvetna 2013 20 Úvod do Prologu VýpoCet odpovedi na dotaz ?- predek(tomas, petr) predek(tomas, petr) dle (1) t dle (2') no rodic( tomas, petr) rodic(tomas, Y) predek( Y, petr) rodic( tomas, robert ). rodic( tomas, eliska ). rodic( robert, petr ). Y=robert dle rodic(tomas, robert) predek( robert, petr) predek( X, Z ) rodic( X, Z). % (1) predek( X, Z ) rodic( X, Y ), % (2') predek( Y, Z). t dle (1) rodic(robert, petr) yes Hana Rudová, Logické programování I, 15. kvetna 2013 21 Úvod do Prologu Odpoved' na dotaz s promennou rodic( pavla, robert ). rodic( tomas, robert ). rodic( tomas, eliska ). rodic( robert, anna ). rodic( robert, petr ). rodic( petr, jirka ). pavla \ tomas Rodice \/ robert / \ \ eliska / anna \ petr / / jirka Deti predek( X, Z ) rodic( X, Z). % (1) predek( X, Z ) rodic( X, Y ), % (2') predek( Y, Z ). predek(petr,Potomek) --> ??? Hana Rudová, Logické programování I, 15. kvetna 2013 22 Úvod do Prologu Odpoved' na dotaz s promennou rodic( pavla, robert ). rodic( tomas, robert ). rodic( tomas, eliska ). rodic( robert, anna ). rodic( robert, petr ). rodic( petr, jirka ). pavla \ tomas Rodice \/ robert / \ \ eliska / anna \ petr / / jirka Deti predek( X, Z ) rodic( X, Z). % (1) predek( X, Z ) rodic( X, Y ), % (2') predek( Y, Z). predek(petr,Potomek) --> ??? Potomek=jirka Hana Rudová, Logické programování I, 15. kvetna 2013 22 Úvod do Prologu Odpoved' na dotaz s promennou rodic( pavla, robert ). rodic( tomas, robert ). rodic( tomas, eliska ). rodic( robert, anna ). rodic( robert, petr ). rodic( petr, jirka ). pavla \ tomas Rodice \/ robert / \ \ eIiska / anna \ petr / / jirka Deti predek( X, Z ) i- rodic( X, Z ). % (1) predek( X, Z ) i- rodic( X, Y ), % (2') predek( Y, Z ). predek(petr,Potomek) --> ??? predek(robert,P) --> ??? Hana Rudová, Logické programování I, 1S. kvetna 2013 22 Potomek=jirka Úvod do Prologu Odpoved' na dotaz s přomennou rodic( pavla, robert ). rodic( tomas, robert ). rodic( tomas, eliska ). rodic( robert, anna ). rodic( robert, petr ). rodic( petr, jirka ). pavla \ tomas Rodice \/ robert / \ \ eliska / anna \ petr / / jirka Deti predek( X, Z ) :- rodic( X, Z). % (1) predek( X, Z ) :- rodic( X, Y ), % (2') predek( Y, Z ). predek(petr,Potomek) --> ??? predek(robert,P) --> ??? Hana Rudová, Logické programování I, 15. kvetna 2013 22 Potomek=jirka 1. P=anna, 2. P=petr, 3. P=jirka Úvod do Prologu Syntaxe a význam Prologovských programů Syntaxe Prologovských programů Typy objektů jsou rozpoznávány podle syntaxe Atom 3 retezce písmen, císel, „_" zacínající malým písmenem: pavel, pavel_novak, x25 a r etezce speciálních znaků: <-->, ====> -i- r etezce v apostrofech: 'Pavel', 'Pavel Novák' JS> Celá a reálná císla: 0, -1056, 0.35 & Promenná -k r etezce písmen, císel, „_" zacínající velkým písmenem nebo „_" 3 anonymní promenná: ma_dite(X) :- rodic( X, _ ). 3 hodnotu anonymní promenné Prolog na dotaz nevrací: ?- rodic( X, _ ) š» lexikální rozsah promenné je pouze jedna klauzule: prvni(X,X,X). prvni(X,X,_). Hana Rudová, Logické programování I, 15. kvetna 2013 24 Syntaxe a význam Prologovských programu Termy M Term - datové objekty v Prologu: datum( 1, kveten, 2003 ) a funktor: datum a argumenty: 1, kveten, 2003 &> arita - pocet argumentů: 3 M Všechny strukturované objekty v Prologu jsou stromy trojuhelnik( bod(4,2), bod(6,4), bod(7,1) ) -í* Hlavní funktor termu - funktor v korenu stromu odpovídající termu -i- trojuhelnikje hlavní funktor v trojuhelnik( bod(4,2), bod(6,4), bod(7,1) ) Hana Rudová, Logické programování I, 15. kvetna 2013 25 Syntaxe a význam Prologovských programu Unifikace Termy jsou unifikovatelné, jestliže jsou identické nebo Jť promenné v obou termech mohou být instanciovány tak, že termyjsou po substituci identické a datum( D1, M1, 2003 ) = datum( 1, M2, Y2) operátor = D1 =1, M1 = M2, Y2 = 2003 Hana Rudová, Logické programování I, 15. kvetna 2013 26 Syntaxe a význam Prologovských programu Unifikace Termy jsou unifikovatelné, jestliže jsou identické nebo Jť promenné v obou termech mohou být instanciovány tak, že termyjsou po substituci identické a datum( D1, M1, 2003 ) = datum( 1, M2, Y2) operátor = D1 =1, M1 = M2, Y2 = 2003 JS> Hledáme nejobecnejší unifikátor (most generál unifier (MGU) jiné instanciace? ... D1 = 1, M1 = 5, Y2 = 2003 ... není MGU ?- datum( D1, M1, 2003 ) = datum( 1, M2, Y2), D1 = M1. Hana Rudová, Logické programování I, 15. kvetna 2013 26 Syntaxe a význam Prologovských programu Unifikace Termy jsou unifikovatelné, jestliže jsou identické nebo Jť promenné v obou termech mohou být instanciovány tak, že termyjsou po substituci identické a datum( D1, M1, 2003 ) = datum( 1, M2, Y2) operátor = D1 =1, M1 = M2, Y2 = 2003 JS> Hledáme nejobecnejší unifikátor (most generál unifier (MGU) jiné instanciace? ... D1 = 1, M1 = 5, Y2 = 2003 ... není MGU ?- datum( D1, M1, 2003 ) = datum( 1, M2, Y2), D1 = M1. & Test výskytu (occurs check) ?- X=f(X). x = f(f(f(f(f(f(f(f(f(f(...)))))))))) Hana Rudová, Logické programování I, 15. kvetna 2013 26 Syntaxe a význam Prologovských programu Unifikace Termy S a T jsou unifikovatelné, jestliže 1. S a T jsou konstanty a tyto konstanty jsou identické; 2. S je promenná a T cokoliv jiného - S je instanciována na T; Tje promenná a S cokoliv jiného - T je instanciována na S 3. S a T jsou termy JS* S a T mají stejný funktor a aritu a M všechny jejich odpovídající argumenty jsou unifikovatelné JÍ* výsledná substituce je urcena unifikací argumentu Príklady: k = k ... yes, k1 = k2 ... no, Hana Rudová, Logické programování I, 15. kvetna 2013 27 Syntaxe a význam Prologovských programu Unifikace Termy S a T jsou unifikovatelné, jestliže 1. S a T jsou konstanty a tyto konstanty jsou identické; 2. S je promenná a T cokoliv jiného - S je instanciována na T; Tje promenná a S cokoliv jiného - T je instanciována na S 3. S a T jsou termy JS* S a T mají stejný funktor a aritu a M všechny jejich odpovídající argumenty jsou unifikovatelné JÍ* výsledná substituce je urcena unifikací argumentu Príklady: k = k ... yes, kl = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes Hana Rudová, Logické programování I, 15. kvetna 2013 27 Syntaxe a význam Prologovských programu Unifikace Termy S a T jsou unifikovatelné, jestliže 1. S a T jsou konstanty a tyto konstanty jsou identické; 2. S je promenná a T cokoliv jiného - S je instanciována na T; Tje promenná a S cokoliv jiného - T je instanciována na S 3. S a T jsou termy JS* S a T mají stejný funktor a aritu a M všechny jejich odpovídající argumenty jsou unifikovatelné JÍ* výsledná substituce je urcena unifikací argumentu Príklady: k = k ... yes, k1 = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes s(sss(2),B,ss(2)) = s(sss(2),4,ss(2),s(1))... Hana Rudová, Logické programování I, 15. kvetna 2013 27 Syntaxe a význam Prologovských programu Unifikace Termy S a T jsou unifikovatelné, jestliže 1. S a T jsou konstanty a tyto konstanty jsou identické; 2. S je promenná a T cokoliv jiného - S je instanciována na T; Tje promenná a S cokoliv jiného - T je instanciována na S 3. S a T jsou termy JS* S a T mají stejný funktor a aritu a M všechny jejich odpovídající argumenty jsou unifikovatelné JÍ* výsledná substituce je urcena unifikací argumentů Príklady: k = k ... yes, kl = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes s(sss(2),B,ss(2)) = s(sss(2),4,ss(2),s(1))... no Hana Rudová, Logické programování I, 15. kvetna 2013 27 Syntaxe a význam Prologovských programu Unifikace Termy S a T jsou unifikovatelné, jestliže 1. S a T jsou konstanty a tyto konstanty jsou identické; 2. S je promenná a T cokoliv jiného - S je instanciována na T; Tje promenná a S cokoliv jiného - T je instanciována na S 3. S a T jsou termy JS* S a T mají stejný funktor a aritu a M všechny jejich odpovídající argumenty jsou unifikovatelné JÍ* výsledná substituce je urcena unifikací argumentu Príklady: k = k ... yes, kl = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes s(sss(2),B,ss(2)) = s(sss(2),4,ss(2),s(1))... no s(sss(A),4,ss(3)) = s(sss(2),4,ss(A))... Hana Rudová, Logické programování I, 15. kvetna 2013 27 Syntaxe a význam Prologovských programu Unifikace Termy S a T jsou unifikovatelné, jestliže 1. S a T jsou konstanty a tyto konstanty jsou identické; 2. S je promenná a T cokoliv jiného - S je instanciována na T; Tje promenná a S cokoliv jiného - T je instanciována na S 3. S a T jsou termy JS* S a T mají stejný funktor a aritu a M všechny jejich odpovídající argumenty jsou unifikovatelné JÍ* výsledná substituce je urcena unifikací argumentů Príklady: k = k ... yes, kl = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes s(sss(2),B,ss(2)) = s(sss(2),4,ss(2),s(1))... no s(sss(A),4,ss(3)) = s(sss(2),4,ss(A))... no Hana Rudová, Logické programování I, 15. kvetna 2013 27 Syntaxe a význam Prologovských programu Unifikace Termy S a T jsou unifikovatelné, jestliže 1. S a T jsou konstanty a tyto konstanty jsou identiCké; 2. S je promenná a T Cokoliv jiného - S je instanCiována na T; Tje promenná a S Cokoliv jiného - T je instanCiována na S 3. S a T jsou termy JS* S a T mají stejný funktor a aritu a M všeChny jejiCh odpovídajíCí argumenty jsou unifikovatelné JÍ* výsledná substituCe je urCena unifikad argumentů Príklady: k = k ... yes, kl = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes s(sss(2),B,ss(2)) = s(sss(2),4,ss(2),s(1))... no s(sss(A),4,ss(3)) = s(sss(2),4,ss(A))... no s(sss(A),4,ss(C)) = s(sss(t(B)),4,ss(A))... Hana Rudová, LogiCké programování I, 15. kvetna 2013 27 Syntaxe a význam PrologovskýCh programu Unifikace Termy S a T jsou unifikovatelné, jestliže 1. S a T jsou konstanty a tyto konstanty jsou identické; 2. S je promenná a T cokoliv jiného - S je instanciována na T; Tje promenná a S cokoliv jiného - T je instanciována na S 3. S a T jsou termy JS* S a T mají stejný funktor a aritu a M všechny jejich odpovídající argumenty jsou unifikovatelné JÍ* výsledná substituce je urcena unifikací argumentu Príklady: k = k ... yes, k1 = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes s(sss(2),B,ss(2)) = s(sss(2),4,ss(2),s(1))... no s(sss(A),4,ss(3)) = s(sss(2),4,ss(A))... no s(sss(A),4,ss(C)) = s(sss(t(B)),4,ss(A))... A=t(B),C=t(B)... yes Hana Rudová, Logické programování I, 15. kvetna 2013 27 Syntaxe a význam Prologovských programu Deklarativní a procedurální význam programů p :- q, r. & Deklarativní: Co je výstupem programu? a p je pravdivé, jestliže q a r jsou pravdivé s Z q a r plyne p => význam mají logické relace Hana Rudová, Logické programování I, 15. kvetna 2013 28 Syntaxe a význam Prologovských programu Deklarativní a procedurální význam programů p :- q, r. Deklarativní: Co je výstupem programu? a p je pravdivé, jestliže q a r jsou pravdivé s Z q a r plyne p => význam mají logické relace Procedurální: Jak vypocítáme výstup programu? Jt p vyrešíme tak, že nejprve vyrešíme q a pak r => krome logických relací je významné i poradí cílu a výstup indikátor yes/no urcující, zda byly cíle splneny instanciace promenných v prípade splnení cílů Hana Rudová, Logické programování I, 15. kvetna 2013 28 Syntaxe a význam Prologovských programu Konjunce "," vs. disjunkce ";" cílů Konjunce = nutné splnení všech cílů p :- q, r. JS> Disjunkce = stací splnení libovolného cíle p q; r. p q. p r. a priorita středníku je vyšší (viz ekvivalentní zápisy): p q, r; s, t, u. p (q, r) ; (s, t, u). p q, r. p s, t, u. Hana Rudová, Logické programování I, 15. kvetna 2013 29 Syntaxe a význam Prologovských programu Poradí klauzulí a cílů (a) a(1). ?- a(1). a(X) :- b(X,Y), a(Y). b(1,1). Hana Rudová, Logické programování I, 15. kvetna 2013 30 Syntaxe a význam Prologovských programu Poradí klauzulí a cílů (a) a(1). ?- a(1). a(X) :- b(X,Y), a(Y). b(1,1). (b) a(X) :- b(X,Y), a(Y). % zmenené poradí klauzulí v programu vzhledem k (a) a(1). b(1,1). Hana Rudová, Logické programování I, 15. kvetna 2013 30 Syntaxe a význam Prologovských programu Pořadí klauzulí a cílů (a) a(1). ?- a(1). a(X) :- b(X,Y), a(Y). b(1,1). (b) a(X) :- b(X,Y), a(Y). % zmenené poradí klauzulí v programu vzhledem k (a) a(1). b(1,1). % nenalezení odpovedi: nekonecný cyklus Hana Rudová, Logické programování I, 15. kvetna 2013 30 Syntaxe a význam Prologovských programu Poradí klauzulí a cílů (a) a(1). ?- a(1). a(X) :- b(X,Y), a(Y). b(1,1). (b) a(X) :- b(X,Y), a(Y). % zmenené poradí klauzulí v programu vzhledem k (a) a(1). b(1,1). % nenalezení odpovedi: nekonecný cyklus (c) a(X) :- b(X,Y), c(Y). ?- a(X). b(1,1). c(2). c(1). Hana Rudová, Logické programování I, 15. kvetna 2013 30 Syntaxe a význam Prologovských programu Poradí klauzulí a cílů (a) a(1). a(X) :- b(X,Y), a(Y). b(1,1). ?- a(1). (b) a(X) :- b(X,Y), a(Y). % zmenené po radí klauzulí v programu vzhledem k (a) a(1). b(1,1). % nenalezení odpovedi: nekonecný cyklus (c) a(X) :- b(X,Y), c(Y). b(1,1). c(2). c(1). (d) a(X) :- c(Y), b(X,Y). b(1,1). c(2). c(1). ?- a(X). % zmenené po radí cílu v tele klauzule vzhledem k (c) Hana Rudová, Logické programování I, 15. kvetna 2013 30 Syntaxe a význam Prologovských programu Poradí klauzulí a cílů (a) a(1). ?- a(1). a(X) :- b(X,Y), a(Y). b(1,1). (b) a(X) :- b(X,Y), a(Y). % zmenené poradí klauzulí v programu vzhledem k (a) a(1). b(1,1). % nenalezení odpovedi: nekonecný cyklus (c) a(X) :- b(X,Y), c(Y). ?- a(X). b(1,1). c(2). c(1). (d) a(X) :- c(Y), b(X,Y). % zmenené poradí cílu v tele klauzule vzhledem k (c) b(1,1). c(2). c(1). % nárocnejší nalezení první odpovedi než u (c) V obou prípadech stejný deklarativní ale odlišný procedurální význam Hana Rudová, Logické programování I, 15. kvetna 2013 30 Syntaxe a význam Prologovských programu Poradí klauzulí a cílů II. (1) a(X) :- c(Y), b(X,Y). (2) b(1,1). (3) c(2). (4) c(1). ?- a(X). a(X) dle (1) c(Y), b(X,Y) dle (3)/^Y=2 dle (4\ Y=1 b(X,2) no b(X,1) dle (2) X=1 yes Hana Rudová, Logické programování I, 15. kvetna 2013 31 Syntaxe a význam Prologovských programu Pořadí klauzulí a cílů II. (1) a(X) :- c(Y), b(X,Y). (2) b(1,1). (3) c(2). (4) c(1). Vyzkoušejte si: (1) a(X) :- b(X,X), c(X). (3) a(X) :- b(Y,X), c(X). (4) b(2,2). (5) b(2,1). (6) c(1). ?- a(X). a(X) dle (1) c(Y), b(X,Y) dle (3)/^Y=2 dle (4\ Y=1 b(X,2) no b(X,1) dle (2) X=1 yes Hana Rudová, LogiCké programování I, 15. kvetna 2013 31 Syntaxe a význam PrologovskýCh programu Cvicení: přůbeh výpoctu a :- b,c,d. b :- e,c,f,g. b :- g,h. c. d. e :- i. e :- h. gh. i. Jak vypadá průbeh výpoctu pro dotaz ?- a. Hana Rudová, Logické programování I, 15. kvetna 2013 32 Syntaxe a význam Prologovských programu Operátory, aritmetika Operátory -í* Infixová notace: 2*a + b*c & Prefixová notace: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400 ± prefixovou notaci lze získat predikátem display/1 :- display((a:-s(0),b,c)). :-(a, ,(s(0), ,(b,c))) M Priorita operátorů: operátor s nejvyšší prioritou je hlavní funktor Hana Rudová, Logické programování I, 15. kvetna 2013 34 Operátory, aritmetika Operátory -í* Infixová notace: 2*a + b*c JS> Prefixová notace: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400 ± prefixovou notaci lze získat predikátem display/1 :- display((a:-s(0),b,c)). :-(a, ,(s(0), ,(b,c))) M Priorita operátorů: operátor s nejvyšší prioritou je hlavní funktor -í* Uživatelsky definované operátory: zna petr zna alese. zna( petr, alese). & Definice operátoru: :- op( 600, xfx, zna ). priorita: 1..1200 Hana Rudová, Logické programování I, 15. kvetna 2013 34 Operátory, aritmetika Operátory Infixová notace: 2*a + b*c Prefixová notace: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400 ± prefixovou notaci lze získat predikátem display/1 display((a:-s(0),b,c)). :-(a, ,(s(0), ,(b,c))) Priorita operátorů: operátor s nejvyšší prioritou je hlavní funktor Uživatelsky definované operátory: zna petr zna alese. zna( petr, alese). Definice operátoru: op( 600, xfx, zna ). priorita: 1..1200 JĽ op( 1100, xfy, ; ). nestrukturované objekty: 0 op( 1000, xfy, , ). p q,r; s,t. p (q,r) ; (s,t). ; má vyšší prioritu než , op( 1200, xfx, ). má nejvyšší prioritu Hana Rudová, Logické programování I, 15. kvetna 2013 34 Operátory, aritmetika Operátory -í* Infixová notace: 2*a + b*c JS> Prefixová notace: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400 ± prefixovou notaci lze získat predikátem display/1 :- display((a:-s(0),b,c)). :-(a, ,(s(0), ,(b,c))) M Priorita operátorů: operátor s nejvyšší prioritou je hlavní funktor -í* Uživatelsky definované operátory: zna petr zna alese. zna( petr, alese). & Definice operátoru: :- op( 600, xfx, zna ). priorita: 1..1200 :- op( 1100, xfy, ; ). nestrukturované objekty: 0 :- op( 1000, xfy, , ). p :- q,r; s,t. p :- (q,r) ; (s,t). ; má vyšší prioritu než , :- op( 1200, xfx, :- ). :- má nejvyšší prioritu & Definice operátoru není spojena s datovými manipulacemi (krome spec. prípadu) Hana Rudová, Logické programování I, 15. kvetna 2013 34 Operátory, aritmetika Typy operátorů Typy operátoru p r. xfx = yfx p r . fx ?- fy -i- infixové operátory: xfx, xfy, yfx prefixové operátory: fx, fy a postfixové operátory: xf, yf x a y urcují prioritu argumentu x reprezentuje argument, jehož priorita musí být striktne menší než u operátoru y reprezentuje argument, jehož priorita je menší nebo rovna operátoru a-b-c odpovídá (a-b)-c a ne a-(b-c): „-" odpovídá yfx chybně správně priorita: 0 priorita: 0 priorita: 500 priorita: 500 Hana Rudová, Logické programování I, 15. kvetna 2013 35 Operátory, aritmetika Aritmetika JS> Preddefinované operátory + , -i *i A ** moCnina, // celocíselné dělení, mod zbytek po delení J* ?- X = 1 + 2. X = 1 + 2 = odpovídá unifikaCi M ?- X is 1 + 2. X = 3 „is" je speciální předdefinovaný operátor, který vynutí evaluaCi Hana Rudová, LogiCké programování I, 15. kvetna 2013 36 Operátory, aritmetika Ařitmetika JS> Preddefinované operátory + , -i *i A ** mocnina, // celoCíselné dělení, mod zbytek po delení Jfc ?- X = 1 + 2. X = 1 + 2 = odpovídá unifikaci M ?- X is 1 + 2. X = 3 „is" je speciální předdefinovaný opeřátoř, který vynutí evaluaci porovnej: N = (1+1+1+1+1) N is (1+1+1+1+1) Hana Rudová, Logické programování I, 15. kvetna 2013 36 Operátory, aritmetika Aritmetika JS> Preddefinované operátory + , -i *i A ** mocnina, // celocíselné dělení, mod zbytek po delení J* ?- X = 1 + 2. X = 1 + 2 = odpovídá unifikaci M ?- X is 1 + 2. X = 3 „is" je speciální preddefinovaný operátor, který vynutí evaluaci porovnej: N = (1+1+1+1+1) N is (1+1+1+1+1) pravá strana musí být vyhodnotitelný výraz (bez promenné) a výraz na pravé strane je nejdríve aritmeticky vyhodnocen a pak unifikován s levou stranou volání ?- X is Y + 1. zpusobí chybu Hana Rudová, Logické programování I, 15. kvetna 2013 36 Operátory, aritmetika Aritmetika JS> Preddefinované operátory + , -i *i A ** mocnina, // celocíselné dělení, mod zbytek po delení Jfc ?- X = 1 + 2. X = 1 + 2 = odpovídá unifikaci M ?- X is 1 + 2. X = 3 „is" je speciální preddefinovaný operátor, který vynutí evaluaci porovnej: N = (1+1+1+1+1) N is (1+1+1+1+1) pravá strana musí být vyhodnotitelný výraz (bez promenné) a výraz na pravé strane je nejdríve aritmeticky vyhodnocen a pak unifikován s levou stranou volání ?- X is Y + 1. zpusobí chybu JS> Další speciální preddefinované operátory >, <, >=, =<, =:= aritmetická rovnost, =\= aritmetická nerovnost -i- porovnej: 1+2 =:= 2+1 1+2 = 2+1 Hana Rudová, Logické programování I, 15. kvetna 2013 36 Operátory, aritmetika Aritmetika JS> Preddefinované operátory + , -i *i A ** mocnina, // celocíselné dělení, mod zbytek po delení J* ?- X = 1 + 2. X = 1 + 2 = odpovídá unifikaci J ?- X is 1 + 2. X = 3 „is" je speciální preddefinovaný operátor, který vynutí evaluaci porovnej: N = (1+1+1+1+1) N is (1+1+1+1+1) Jt pravá strana musí být vyhodnotitelný výraz (bez promenné) a výraz na pravé strane je nejdríve aritmeticky vyhodnocen a pak unifikován s levou stranou volání ?- X is Y + 1. způsobí chybu JS> Další speciální preddefinované operátory >, <, >=, =<, =:= aritmetická rovnost, =\= aritmetická nerovnost -i- porovnej: 1+2 =:= 2+1 1+2 = 2+1 Jt obe strany musí být vyhodnotitelný výraz: volání ?- 1 < A + 2. způsobí chybu Hana Rudová, Logické programování I, 15. kvetna 2013 36 Operátory, aritmetika Různé typy rovností a porovnaní X = Y X a Y jsou unifikovatelné X \= Y X a Y nejsou unifikovatelné, (také \+ X = Y) Hana Rudová, LogiCké programování I, 15. kvetna 2013 37 Operátory, aritmetika Různé typy rovností a porovnání X = Y Xa Y jsou unifikovatelné X \= Y Xa Y nejsou unifikovatelné, (také \+ X = Y) X == Y Xa Y jsou identické porovnej: ?-A == B. ... no ?-A=B, A==B. Hana Rudová, Logické programování I, 15. kvetna 2013 37 Operátory, aritmetika Různé typy řovností a porovnání X = Y X \= Y X == Y X \ == Y Xa Y jsou unifikovatelné Xa Y nejsou unifikovatelné, (také \+ X = Y) X a Y jsou identické porovnej: ?- A == B. ... no ?- A=B, A==B. ... B = A yes X a Y nejsou identické porovnej: ?- A \== B. ... yes ?- A=B, A \== B. ... A no Hana Rudová, Logické programování I, 15. kvetna 2013 37 Operátory, aritmetika Různé typy rovností a porovnaní X=Y X \= Y X == Y X \ == Y X is Y X =:= Y X =\ = Y X < Y X a Y jsou unifikovatelné X a Y nejsou unifikovatelné, (také \+ X = Y) X a Y jsou identiCké porovnej: ?- A == B. ... no ?- A=B, A==B. ... B = A yes X a Y nejsou identiCké porovnej: ?- A \== B. ... yes ?- A=B, A \== B. ... A no Y je aritmetiCky vyhodnoCeno a výsledek je prirazen X X a Y jsou si aritmetiCky rovny X a Y si aritmetiCky nejsou rovny aritmetiCká hodnota X je menší než Y (=<, >, >=) Hana Rudová, LogiCké programování I, 15. kvetna 2013 37 Operátory, aritmetika X = Y X \= Y X == Y X \== Y X is Y X =:= Y X =\= Y X < Y X @< Y Různé typy rovností a porovnání X a Y jsou unifikovatelné X a Y nejsou unifikovatelné, (také \+ X = Y) X a Y jsou identické porovnej: ?- A == B. ... no ?- A=B, A==B. ... B = A yes X a Y nejsou identické porovnej: ?- A \== B. ... yes ?- A=B, A \== B. ... A no X a Y jsou si aritmeticky rovny X a Y si aritmeticky nejsou rovny aritmetická hodnota X je menší než Y (=<, >, >=) term X predchází term Y (@=<, @>, @>=) 1. porovnání termu: podle alfabetického n. aritmetického usporádání 2. porovnání struktur: podle arity, pak hlavního funktoru a pak zleva podle argumentu Hana Rudová, Logické programování I, 15. kvetna 2013 37 Operátory, aritmetika Různé typy rovností a porovnání X = Y X \= Y X == Y X \== Y X is Y X =:= Y X =\ = Y X < Y X @< Y X a Y jsou unifikovatelné X a Y nejsou unifikovatelné, (také \+ X = Y) X a Y jsou identické porovnej: ?- A == B. ... no ?- A=B, A==B. ... B = A yes X a Y nejsou identické porovnej: ?- A \== B. ... yes ?- A=B, A \== B. ... A no Y je aritmeticky vyhodnoceno a výsledek je p r i r azen X X a Y jsou si aritmeticky rovny X a Y si aritmeticky nejsou rovny aritmetická hodnota X je menší než Y (=<, >, >=) term X p r edcházíterm Y (@=<, @>, @>=) 1. porovnání termu: podle alfabetického n. aritmetického uspo rádání 2. porovnání struktur: podle arity, pak hlavního funktoru a pak zleva podle argumentu ?- f( pavel, g(b)) @< f( pavel, h(a)). ... yes Hana Rudová, Logické programování I, 15. kvetna 2013 37 Operátory, aritmetika Řez, negace Řez a upnutí f(X,0) :- X < 3 . f(X,2) :- 3 =< X, X < 6 . f(X,4) :- 6 =< X. pridání operátoru rezu ,,!'' y 4 2 ?- f(1,Y), Y>2. j— J_L -© J_L 3 6 x Hana Rudová, Logické programování I, 15. kvetna 2013 39 Řez, negace Rez a upnutí f(X,0) :- X < 3, I. f(X,2) :- 3 =< X, X < 6, I. f(X,4) :- 6 =< X. přidání opeřátořu řezu ,,!'' y 4 2 J- J_L -© J_L 3 6 x ?- f(1,Y), Y>2. & Upnutí: po splnení podcílu pred rezem se už další klauzule neuvažují Hana Rudová, Logické programování I, 15. kvetna 2013 39 Rez, negace Řez a upnutí f(X,0) :- X < 3, I. f(X,2) :- 3 =< X, X < 6, I. f(X,4) :- 6 =< X. pndání operátoru rezu ,,!'' y 4 2 J- J_L -© ?- f(1,Y), Y>2. f(X,0) :- X < 3, I. f(X,2) :- X < 6, I. %(2) f(X,4). J_L 3 6 x & Upnutí: po splnení podcílu pred rezem se už další klauzule neuvažují Hana Rudová, Logické programování I, 15. kvetna 2013 39 Rez, negace Rez a upnutí f(X,0) :- X < 3, I. f(X,2) :- 3 =< X, X < 6, I. f(X,4) :- 6 =< X. pěidání operátoru rezu ,,!'' y 4 2 J- J_L -© J_L 3 6 x ?- f(1,Y), Y>2. f(X,0) :- X < 3, I. f(X,2) :- X < 6, I. %(2) f(X,4). ?- f(1,Y). Smazání rezu v (1) a (2) zmení Chování programu & Upnutí: po splnení podCílu pred rezem se už další klauzule neuvažují Hana Rudová, LogiCké programování I, 15. kvetna 2013 39 Rez, negaCe Rez a ořezání f(X,Y) :- s(X,Y). s(X,Y) :- Y is X + 1. s(X,Y) :- Y is X + 2. ?- f(1,Z). Hana Rudová, Logické programování I, 15. kvetna 2013 40 Rez, negace Rez a orezání f(X,Y) :- s(X,Y). s(X,Y) :- Y is X + 1. s(X,Y) :- Y is X + 2. ?- f(1,Z). Z = 2 ? ; Z = 3 ? ; no Hana Rudová, Logické programování I, 15. kvetna 2013 40 Rez, negace Rez a orezání f(X,Y) :- s(X,Y). s(X,Y) :- Y is X + 1. s(X,Y) :- Y is X + 2. f(X,Y) :- s(X,Y), I. s(X,Y) :- Y is X + 1. s(X,Y) :- Y is X + 2. ?- f(1,Z). ?- f(1,Z). Z = 2 ? ; Z = 3 ? ; no Orezání: po splnení podcílu pred rezem se už neuvažuje další možné splnení techto podcílu Hana Rudová, Logické programování I, 15. kvetna 2013 40 Řez, negace Řez a orezání f(X,Y) :- s(X,Y). s(X,Y) :- Y is X + 1. s(X,Y) :- Y is X + 2. f(X,Y) :- s(X,Y), I. s(X,Y) :- Y is X + 1. s(X,Y) :- Y is X + 2. ?- f(1,Z). Z = 2 ? ; Z = 3 ? ; no ?- f(1,Z). Z=2?; no Orezání: po splnení podcílu pred rezem se už neuvažuje další možné splnení techto podcílu Smazání rezu zmení chování programu Hana Rudová, Logické programování I, 15. kvetna 2013 40 Rez, negace Chování operátoru rezu Předpokládejme, že klauzule H :- T1, T2, Tm, !, ...Tn. je aktivována voláním cíle G, který je unifikovatelný s H. G=h(X,Y) V momente, kdy je nalezen rez, existuje rešení cílu T1, ..., Tm X=1,Y=1 Orezání: pri provádení rezu se už další možné splnení cílu T1, ..., Tm nehledá a všechny ostatní alternativy jsou odstraneny Upnutí: dále už nevyvolávám další klauzule, jejichž hlava je také unifikovatelná s G Y=2 X=2 ?- h(X,Y). h(1,Y) :- t1(Y), !. h(2,Y) :- a. t1(1) :- b. t1(2) :- c. h(X,Y) X=1 / \ X=2 t1(Y) a (vynechej: upnutí) Y=1 / \ Y=2 b c (vynechej: o rezání) / Hana Rudová, Logické programování I, 15. kvetna 2013 41 Rez, negace Rez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), !, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). Hana Rudová, Logické programování I, 15. kvetna 2013 42 Řez, negace Řez: návrat na rodice ?- a(X). a(x) (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), I, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace Rez: návřat na řodice ?- a(X). a(x) (1) a(X) :- h(X,Y). (2) a(X) :- d. h(X,Y) (3) h(1,Y) :- t1(Y), I, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace Rez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), I, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). Hana Rudová, Logické programování I, 15. kvetna 2013 42 Řez, negace a(x) h(X,Y) X/1 t1(Y),!,e'(X') Řez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), I, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). a(x) h(X,Y) X/1 t1(Y),!,e'(X') Y/1 b,!,e(X') Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace Rez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), I, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). a(x) h(X,Y) X/1 t1(Y),!,e'(X') Y/1 b,!,e(X') c,!,e(X') Hana Rudová, LogiCké programování I, 15. kvetna 2013 42 Rez, negaCe Rez návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). a(x) h(X,Y) X/1 !, e(X). t1(Y),!,e'(X') Y/1 b,!,e(X') c,!,e(X') no Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace Řez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), !, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. no (8) b :- d. (9) d. (10) e(1) . (11) e(2). Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace a(x) h(X,Y) X/1 t1(Y),!,e'(X') Y/1 / b,!,e(X') c,!,e(X') d,!,e(X') Řez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), I, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). a(x) h(X,Y) X/1 t1(Y),!,e'(X') Y/1 / b,!,e(X') c,!,e(X') d,!,e(X') no !,e(X') Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace Rez: návřat na řodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), I, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). a(x) h(X,Y) X/1 t1(Y),!,e'(X') Y/1 / b,!,e(X') c,!,e(X') d,!,e(X') no !,e(X') e(X') Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace Rez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), I, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). a(x) h(X,Y) X/1 t1(Y),!,e'(X') Y/1 / b,!,e(X') c,!,e(X') d,!,e(X') no !,e(X') e(X') X'/1 □ Hana Rudová, LogiCké programování I, 15. kvetna 2013 42 Rez, negaCe Rez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), !, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). a(x) h(X,Y) X/1 t1(Y),!,e'(X') Y/1 / b,!,e(X') c,!,e(X') d,!,e(X') no !,e(X') e(X') X'/l y \ X'/2 Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace Rez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), !, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). a(x) híX/Y) X/1y \^ t1(Y),!,e(X') upnutí Y/1 / \ b,!,e(X') ořezání c,!,e(X') d,!,e(X') no !,e(X') e(X') X'/l y \ X'/2 Po zpracování klauzule s rezem se vracím až na rodice této klauzule, tj. a(X) Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace Řez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), I, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). a(x) h(X/Y) X/1y \^ t1(Y),!,e(Xl) upnutí Y/1 / \ b,!,e(X') ořezání c,!,e(X') d,!,e(X') no !,e(X') e(X') X'/l y \ X'/2 d Po zpracování klauzule s rezem se vracím až na rodice této klauzule, tj. a(X) Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace Rez: návrat na rodice ?- a(X). (1) a(X) :- h(X,Y). (2) a(X) :- d. (3) h(1,Y) :- t1(Y), I, e(X). (4) h(2,Y) :- a. (5) t1(1) :- b. (6) t1(2) :- c. (7) b :- c. (8) b :- d. (9) d. (10) e(1) . (11) e(2). a(x) h(X,Y) x/iX \ t1(Y),!,e(Xl) upnutí Y/1 / \ b,!,e(X') ořezání c,!,e(X') d,!,e(X') no !,e(X') e(X') X'/l y \ X'/2 d Po zpracování klauzule s rezem se vracím až na rodice této klauzule, tj. a(X) Hana Rudová, Logické programování I, 15. kvetna 2013 42 Rez, negace Řez: príklad c(X) :- p(X). c(X) :- v(X). p(1). p(2). v(2). ?- c(2). Hana Rudová, Logické programování I, 15. kvetna 2013 43 Rez, negace c(X) :- p(X). cCX) :- v(X). Řez: príklad p(1). p(2). v(2). ?- c(2). true ? ; %p(2) true ? ; %v(2) no ?- c(X). Hana Rudová, Logické programování I, 15. května 2013 43 Rez, negace Řez: príklad c(X) :- p(X). c(X) :- v(X). p(1). p(2). v(2). ?- c(2). true ? ; %p(2) true ? ; %v(2) no ?- c(X). X = 1 ? ; %p(1) X = 2 ? ; %p(2) X = 2 ? ; %v(2) no Hana Rudová, Logické programování I, 15. kvetna 2013 43 Rez, negace Řez: příklad c(X) :- p(X). c1(X) :- p(X), I. c(X) :- v(X). c1(X) :- v(X). p(1). p(2). v(2). ?- c(2). ?- c1(2). true ? ; %p(2) true ? ; %v(2) no ?- c(X). X = 1 ? ; %p(1) X = 2 ? ; %p(2) X = 2 ? ; %v(2) no Hana Rudová, Logické programování I, 15. května 2013 43 Řez, negace Řez: příklad c(X) :- p(X). c1(X) :- p(X), I. c(X) :- v(X). c1(X) :- v(X). p(1). p(2). v(2). ?- c(2). true ? ; %p(2) true ? ; %v(2) no ?- c1(2). true ? ; %p(2) no ?- c(X). ?- c1(X). X = 1 ? ; %p(1) X = 2 ? ; %p(2) X = 2 ? ; %v(2) no Hana Rudová, Logické programování I, 15. května 2013 43 Řez, negace Řez: příklad c(X) :- p(X). c1(X) :- p(X), I. c(X) :- v(X). c1(X) :- v(X). p(1). p(2). v(2). ?- c(2). true ? ; %p(2) true ? ; %v(2) no ?- c1(2). true ? ; %p(2) no ?- c(X) X = 1 ? ; %p(1) X = 2 ? ; %p(2) X = 2 ? ; %v(2) no ?- c1(X). X = 1 ? ; %p(1) no Hana Rudová, Logické programování I, 15. května 2013 43 Řez, negace Rez: cvicení 1. Porovnejte chování uvedených programu pro zadané dotazy. a(X,X) :- b(X). a(X,Y) :- Y is X+1. b(X) :- X > 10 ?- a(X,Y). ?- a(1,Y). ?- a(11,Y). a(X,X) :- b(X),!. a(X,Y) :- Y is X+1. b(X) :- X > 10. a(X,X) :- b(X),c. a(X,Y) :- Y is X+1. b(X) :- X > 10 c ■- ! 2. Napište predikát pro výpocet maxima max( X, Y, Max ) Hana Rudová, Logické programování I, 15. kvŘetna 2013 44 RŘez, negace Typy rezu Zlepšení efektivity programu: urcíme, které alternativy nemá smysl zkoušet Poznámka: na vstupu pro X ocekávám císlo Zelený rez: odstraní pouze neúspešná odvození f(X,1) :- X >= 0, I. f(X,-1) :- X < 0. Hana Rudová, Logické programování I, 15. kvetna 2013 45 Rez, negace Typy řezu Zlepšení efektivity programu: urcíme, které alternativy nemá smysl zkoušet Poznámka: na vstupu pro X ocekávám císlo Zelený řez: odstraní pouze neúspešná odvození f(X,1) :- X >= 0, I. f(X,-1) :- X < 0. bez rezu zkouším pro nezáporná císla 2. klauzuli Hana Rudová, Logické programování I, 15. kvetna 2013 45 Rez, negace Typy rezu Zlepšení efektivity programu: urcíme, které alternativy nemá smysl zkoušet Poznámka: na vstupu pro X ocekávám císlo Zelený rez: odstraní pouze neúspešná odvození f(X,1) :- X >= 0, I. f(X,-1) :- X < 0. bez rezu zkouším pro nezáporná císla 2. klauzuli Modrý rez: odstraní redundantní r ešení f(X,1) :- X >= 0, I. f(0,1). f(X,-1) :- X < 0. Hana Rudová, Logické programování I, 15. kvetna 2013 45 Rez, negace Typy rezu Zlepšení efektivity programu: urame, které alternativy nemá smysl zkoušet Poznámka: na vstupu pro X ocekávám císlo Zelený rez: odstraní pouze neúspešná odvození f(X,1) :- X >= 0, I. f(X,-1) :- X < 0. bez rezu zkouším pro nezáporná císla 2. klauzuli Modrý rez: odstraní redundantní r ešení f(X,1) :- X >= 0, I. f(0,1). f(X,-1) :- X < 0. bez rezu vrací f(0,1) 2x Hana Rudová, Logické programování I, 15. kvetna 2013 45 Rez, negace Typy řezu Zlepšení efektivity programu: urcíme, které alternativy nemá smysl zkoušet Poznámka: na vstupu pro X ocekávám císlo Zelený řez: odstraní pouze neúspešná odvození f(X,1) :- X >= 0, I. f(X,-1) :- X < 0. bez rezu zkouším pro nezáporná císla 2. klauzuli Modřý řez: odstraní redundantní r ešení f(X,1) :- X >= 0, I. f(0,1). f(X,-1) :- X < 0. bez rezu vrací f(0,1) 2x Ceřvený řez: odstraní úspešná rešení f(X,1) :- X >= 0, I. f(_X,-1). Hana Rudová, Logické programování I, 15. kvetna 2013 45 Rez, negace Typy rezu Zlepšení efektivity programu: urcíme, které alternativy nemá smysl zkoušet Poznámka: na vstupu pro X ocekávám císlo Zelený rez: odstraní pouze neúspešná odvození f(X,1) :- X >= 0, I. f(X,-1) :- X < 0. bez rezu zkouším pro nezáporná císla 2. klauzuli Modrý rez: odstraní redundantní r ešení f(X,1) :- X >= 0, I. f(0,1). f(X,-1) :- X < 0. bez rezu vrací f(0,1) 2x Červený rez: odstraní úspešná rešení f(X,1) :- X >= 0, I. f(_X,-1). bez r ezu uspeje 2. klauzule pro nezáporná císla Hana Rudová, Logické programování I, 15. kvetna 2013 45 Rez, negace Negace jako neúspěch Speciální cíl pro nepravdu (neúspěch) fail a pravdu true JS> X a Y nejsou unifikovatelné: different(X, Y) C different( X, Y ) :- X = Y, I, fail. different( _X, _Y ). JS* X je muž: muz(X) muz( X ) :- zena( X ), I, fail. muz( _X ). Hana Rudová, Logické programování I, 15. kvetna 2013 46 Rez, negace Negace jako neúspech: opeřátoř \+ different(X,Y) :-X=Y, I, fail. muz(X) :-zena(X), I, fail. different(_X,_Y). muz(_X). Unární operátor \+ P & jestliže P uspeje, potom \+ P neuspeje \+(P) :- P, I, fail. v opaCném p rípade \+ P uspeje \+(_). Hana Rudová, Logické programování I, 15. kvetna 2013 47 Rez, negace Negace jako neúspech: opeřátoř \+ M different(X,Y) :- X = Y, I, fail. muz(X) :- zena(X), I, fail. different(_X,_Y). muz(_X). JS> Unární operátor \+ P & jestliže P uspeje, potom \+ P neuspeje \+(P) :- P, I, fail. it v opaCném prípade \+ P uspeje \+(_). C different( X, Y ) :- \+ X=Y. -í* muz( X ) :- \+ zena( X ). & Pozor: takto definovaná negace \+P vyžaduje koneCné odvození P Hana Rudová, Logické programování I, 15. kvetna 2013 47 Rez, negace Negace a proměnné \+(P) r- P, !, fail. % (I) \+(-). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % O) rozumne( Auto ) r- % (4) \+ drahe( Auto ). Hana Rudová, Logické programování I, 15. kvetna 2G1B 48 Rez, negace Negace a promenné \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). ?- dobre( X ), rozumne( X ). Hana Rudová, Logické programování I, 15. kvetna 2013 48 Rez, negace Negace a promenné \+(P) :- P' Ij fai1- % (I) dobre(X),rozumne(X) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). ?- dobre( X ), rozumne( X ). Hana Rudová, LogiCké programování I, 15. kvetna 2013 48 Rez, negaCe Negace a přomenné \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobře( bmw ). % (2) dřahe( bmw ). % (3) řozumne( Auto ) :- % (4) \+ dřahe( Auto ). ?- dobre( X ), rozumne( X ). dobre(X),rozumne(X) dle (1), X/citroen rozumne(citroen) Hana Rudová, Logické programování I, 15. kvetna 2013 48 Rez, negace Negace a promenné \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). ?- dobre( X ), rozumne( X ). dobre(X),rozumne(X) dle (1), X/citroen rozumne(citroen) dle (4) \+ drahe(citroen) Hana Rudová, Logické programování I, 15. kvetna 2013 48 Rez, negace Negace a proměnné \+(P) r- P, !, fail. % (I) \+(-). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % O) rozumne( Auto ) r- % (4) \+ drahe( Auto ). ľ- dobre( X ), rozumne( X ). dobre(X),rozumne(X) dle (1), X/citroen rozumne(citroen) dle (4) \+ drahe(citroen) dle (I) drahe(citroen),!, fail Hana Rudová, Logické programování I, l5. kvetna 2GlB 48 Rez, negace Negace a promenné \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). ?- dobre( X ), rozumne( X ). dobre(X),rozumne(X) dle (1), X/citroen rozumne(citroen) dle (4) \+ drahe(citroen) dle (I) drahe(citroen),!, fail Hana Rudová, Logické programování I, 15. kvetna 2013 48 no Rez, negace Negace a přomenné \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). dobre( bmw ). drahe( bmw ). rozumne( Auto ) :-\+ drahe( Auto ). % (1) % (2) % (3) % (4) ?- dobre( X ), rozumne( X ). dobre(X),rozumne(X) dle (1), X/citroen rozumne(citroen) dle (4) \+ drahe(citroen) dle (I) drahe(citroen),!, fail dle (II) yes Hana Rudová, Logické programování I, 15. kvetna 2013 48 no Rez, negace Negace a promenné \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). Hana Rudová, Logické programování I, 15. kvetna 2013 49 Rez, negace Negace a promenné \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). ?- rozumne( X ), dobre( X ). Hana Rudová, LogiCké programování I, 15. kvetna 2013 49 Rez, negaCe Negace a promenne rozumne(X), dobre(X) \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). ?- rozumne( X ), dobre( X ). Hana Rudová, Logické programování I, 15. kvetna 2013 49 Rez, negace Negace \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). ?- rozumne( X ), dobre( X ). promenné rozumne(X), dobre(X) dle (4) \+ drahe(X), dobre(X) Hana Rudová, Logické programování I, 15. kvetna 2013 49 Rez, negace \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). dobre( bmw ). Negace a promenné rozumne(X), dobre(X) drahe( bmw ). rozumne( Auto ) :-\+ drahe( Auto ). % (1) % (2) % (3) % (4) dle (4) \+ drahe(X), dobre(X) dle (I) drahe(X),!,fail,dobre(X) ?- rozumne( X ), dobre( X ). Hana Rudová, Logické programování I, 15. kvetna 2013 49 Rez, negace Negace a \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). ?- rozumne( X ), dobre( X ). promenné rozumne(X), dobre(X) dle (4) \+ drahe(X), dobre(X) dle (I) drahe(X),!,fail,dobre(X) dle (3), X/bmw !, fail, dobre(bmw) Hana Rudová, Logické programování I, 15. kvetna 2013 49 Rez, negace Negace \+(P) :- P, I, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). ?- rozumne( X ), dobre( X ). Hana Rudová, Logické programování I, 15. května 2013 49 proměnné rozumne(X), dobre(X) dle (4) \+ drahe(X), dobre(X) dle (I) drahe(X),!,fail,dobre(X) dle (3), X/bmw !, fail, dobre(bmw) fail,dobre(bmw) Rez, negace Negace a \+(P) :- P, !, fail. % (I) \+(_). % (II) dobre( citroen ). % (1) dobre( bmw ). % (2) drahe( bmw ). % (3) rozumne( Auto ) :- % (4) \+ drahe( Auto ). ?- rozumne( X ), dobre( X ). Hana Rudová, Logické programování I, 15. května 2013 promenne rozumne(X), dobre(X) dle (4) \+ drahe(X), dobre(X) dle (I) drahe(X),!,fail,dobre(X) dle (3), X/bmw !, fail, dobre(bmw) fail,dobre(bmw) no 9 Rez, negace Bezpečný cíl C ?- \+ drahe( citroen ). yes ?- \+ drahe( X ). no JS> ?- rozumne( citroen ). yes ?- rozumne( X ). no JS> \+ P je bezpečný: proměnné P jsou v okamžiku volání P instanciovány negaci používáme pouze pro bezpečný cíl P Hana Rudová, Logické programování I, 15. kvetna 2013 50 Řez, negace Chování negace J& ?- \+ drahe( citroen ). yes ?- \+ drahe( X ). no C ?- drahe( X ). PTÁME SE: existuje X takové, že drahe( X ) platí? ?- \+ drahe( X ). \+ drahe(X) :-drahe(X),!,fail. \+ drahe(X). z definice \+ plyne: není dokazatelné, že existuje X takové, že drahe( X ) platí tj. pro všechna X platí \+ drahe( X ) Hana Rudová, Logické programování I, 15. kvetna 2013 51 Rez, negace Chování negace J& ?- \+ drahe( citroen ). yes ?- \+ drahe( X ). no C ?- drahe( X ). PTÁME SE: existuje X takové, že drahe( X ) platí? ?- \+ drahe( X ). \+ drahe( X) :- drahe(X),!,fail. \+ drahe(X). z definice \+ plyne: není dokazatelné, že existuje X takové, že drahe( X ) platí tj. přo všechna X platí \+ drahe( X ) & TEDY: pro cíle s negací neplatí existuje X takové, že \+ drahe( X ) Hana Rudová, Logické programování I, 15. kvetna 2013 51 Rez, negace Chování negace J& ?- \+ drahe( citroen ). yes ?- \+ drahe( X ). no C ?- drahe( X ). PTÁME SE: existuje X takové, že drahe( X ) platí? ?- \+ drahe( X ). \+ drahe(X) :-drahe(X),!,fail. \+ drahe(X). z definice \+ plyne: není dokazatelné, že existuje X takové, že drahe( X ) platí tj. pro všechna X platí \+ drahe( X ) & TEDY: pro cíle s negací neplatí existuje X takové, že \+ drahe( X ) => negace jako neúspech není ekvivalentní negaci v matematické logice -i* Negace jako neúspech používá p redpoklad uzav reného sveta pravdivé je pouze to, co je dokazatelné Hana Rudová, Logické programování I, 15. kvetna 2013 51 Rez, negace Predikáty na řízení behu přogřamu I. řez „!" fail: cíl, který vždy neuspeje true: cíl, který vždy uspeje \+ P: negace jako neúspech \+ P :- P, I, fail; true. Hana Rudová, Logické programování I, 15. kvetna 2013 52 Rez, negace Predikáty na r ízení behu programu I. rez „!" fail: cíl, který vždy neuspeje true: cíl, který vždy uspeje \+ P: negace jako neúspech \+ P :- P, I, fail; true. once(P): vrátí pouze jedno rešení cíle P once(P) :- P, I. Hana Rudová, Logické programování I, 15. kvetna 2013 52 Rez, negace Predikáty na r ízení behu programu I. rez „!" fail: cíl, který vždy neuspeje true: cíl, který vždy uspeje \+ P: negace jako neúspech \+ P :- P, I, fail; true. once(P): vrátí pouze jedno rešení cíle P once(P) :- P, I. Vyjád rení podmínky: P -> Q ; R J* jestliže platí P tak Q (P -> Q ; R) :- P, I, Q. v opacném p r ípade R (P -> Q ; R) :- R. príklad: min(X,Y,Z) :- X =< Y -> Z = X ; Z = Y. Hana Rudová, Logické programování I, 15. kvetna 2013 52 Rez, negace Predikáty na rízení behu programu I. rez „!" fail: cíl, který vždy neuspeje true: cíl, který vždy uspeje \+ P: negace jako neúspech \+ P :- P, !, fail; true. once(P): vrátí pouze jedno rešení cíle P once(P) :- P, !. Vyjádrení podmínky: P -> Q ; R J* jestliže platí P tak Q (P -> Q ; R) :- P, !, Q. v opacném prípade R (P -> Q ; R) :- R. príklad: min(X,Y,Z) :- X =< Y -> Z = X ; Z = Y. P -> Q Hana Rudová, Logické programování I, 15. kvetna 2013 52 Rez, negace Predikáty na řízení behu přogřamu I. M řez „!" & fail: cíl, který vždy neuspěje true: cíl, který vždy uspěje -í* \+ P: negace jako neúspech \+ P :- P, I, fail; true. & once(P): vrátí pouze jedno rešení cíle P once(P) :- P, I. & Vyjádření podmínky: P -> Q ; R J* jestliže platí P tak Q (P -> Q ; R) :- P, I, Q. v opacném prípade R (P -> Q ; R) :- R. príklad: min(X,Y,Z) :- X =< Y -> Z = X ; Z = Y. M P -> Q -i- odpovídá: (P -> Q; fail) -fc príklad: zaporne(X) :- number(X) -> X < 0. Hana Rudová, Logické programování I, 15. kvetna 2013 52 Rez, negace Predikáty na ŕízení běhu programu II. call(P): zavolá cíl P a uspeje, pokud uspeje P nekonečná posloupnost backtrackovacích voleb: repeat repeat. repeat :- repeat. Hana Rudová, Logické programování I, l5. kvetna 2GlB 5B Řez, negace Predikáty na ŕízení běhu programu II. call(P): zavolá cíl P a uspeje, pokud uspeje P nekonečná posloupnost backtrackovacích voleb: repeat repeat. repeat :- repeat. klasické použití: generuj akci X, proved'ji a otestuj, zda neskončit Hlava :- ... uloz_stav( StaryStav ), repeat, generuj( X ), % deterministické: generuj, provadej, testuj provadej( X ), testuj( X ), I ■ > obnov_stav( StaryStav ), Hana Rudová, Logické programování I, 15. kvetna 2013 53 Rez, negace Seznamy Reprezentace seznamu -i* Seznam: [a, b, c], prázdný seznam [] & Hlava (libovolný objekt), telo (seznam): .(Hlava, Telo) a všechny strukturované objekty stromy - i seznamy ± funktordva argumenty .(a, .(b, .(c, []))) = [a, b, c] i> notace: [ Hlava | Telo ] = [ajTelo] Hana Rudová, Logické programování I, 15. kvetna 2013 55 Seznamy Repřezentace seznamu & Seznam: [a, b, c], prázdný seznam [] & Hlava (libovolný objekt), telo (seznam): .(Hlava, Telo) a všechny strukturované objekty stromy - i seznamy ± funktordva argumenty .(a, .(b, .(c, []))) = [a, b, c] i> notace: [ Hlava | Telo ] = [a|Te1o] Telo je v [a|Te1o] seznam, tedy píšeme [ a, b, c ] = [ a | [ b, c ] ] Hana Rudová, Logické programování I, 15. kvetna 2013 55 Seznamy Reprezentace seznamu -i* Seznam: [a, b, c], prázdný seznam [] & Hlava (libovolný objekt), telo (seznam): .(Hlava, Telo) a všechny strukturované objekty stromy - i seznamy ± funktordva argumenty .(a, .(b, .(c, []))) = [a, b, c] i> notace: [ Hlava | Telo ] = [a|Te1o] Telo je v [a|Te1o] seznam, tedy píšeme [ a, b, c ] = [ a | [ b, c ] ] & Lze psát i: [a,b|Te1o] pred "|"je libovolný pocet prvků seznamu , za "|"je seznam zbývajících prvků [a,b,c] = [a|[b,c]] = [a,b|[c]] = [a,b,c|[]] Hana Rudová, Logické programování I, l5. kvetna 2GlB 55 Seznamy Reprezentace seznamu -i* Seznam: [a, b, c], prázdný seznam [] & Hlava (libovolný objekt), telo (seznam): .(Hlava, Telo) a všechny strukturované objekty stromy - i seznamy ± funktordva argumenty .(a, .(b, .(c, []))) = [a, b, c] i> notace: [ Hlava | Telo ] = [a|Te1o] Telo je v [a|Te1o] seznam, tedy píšeme [ a, b, c ] = [ a | [ b, c ] ] & Lze psát i: [a,b|Te1o] p r ed T'je libovolný pocet prvků seznamu , za "|"je seznam zbývajících prvků [a,b,c] = [a|[b,c]] = [a,b|[c]] = [a,b,c|[]] pozor: [ [a,b] | [c] ] = [ a,b | [c] ] Hana Rudová, Logické programování I, 15. kvetna 2013 55 Seznamy Reprezentace seznamu -i* Seznam: [a, b, c], prázdný seznam [] & Hlava (libovolný objekt), telo (seznam): .(Hlava, Telo) a všechny strukturované objekty stromy - i seznamy ± funktordva argumenty .(a, .(b, .(c, []))) = [a, b, c] i> notace: [ Hlava | Telo ] = [a|Te1o] Telo je v [a|Te1o] seznam, tedy píšeme [ a, b, c ] = [ a | [ b, c ] ] & Lze psát i: [a,b|Te1o] pred "|"je libovolný pocet prvků seznamu , za "|"je seznam zbývajících prvků [a,b,c] = [a|[b,c]] = [a,b|[c]] = [a,b,c|[]] pozor: [ [a,b] | [c] ] = [ a,b | [c] ] & Seznam jako neúplná datová struktura: [a,b,c|T] Jt Seznam = [a,b,c|T], T = [d,e|S], Seznam = [a,b,c,d,e|S] Hana Rudová, Logické programování I, 15. kvetna 201 3 55 Seznamy Prvek seznamu iS> member( X, S ) C platí: member( b, [a,b,c] ). & neplatí: member( b, [[a,b]|[c]] ). JS> X je prvek seznamu S, když & X je hlava seznamu S nebo member( X, [ X | _ ] ). a X je prvek tela seznamu S member( X, [ _ | Telo ] ) :- member( X, Telo ). %(2) Hana Rudová, Logické programování I, 15. kvetna 2013 56 Seznamy Prvek seznamu member(1,[2,1,3,1,4]) -í* member( X, S ) C platí: member( b, [a,b,c] ). & neplatí: member( b, [[a,b]|[c]] ). JS> X je prvek seznamu S, když & X je hlava seznamu S nebo member( X, [ X | _ ] ). a X je prvek tela seznamu S member( X, [ _ | Telo ] ) :- member( X, Telo ). %(2) Hana Rudová, Logické programování I, 15. kvetna 2013 56 Seznamy Přvek seznamu member(1,[2,1,3,1,4]) iS> member( X, S ) dle (2) C platí: member( b, [a,b,c] ). & neplatí: member( b, [[a,b]|[c]] ). JS> X je prvek seznamu S, když & X je hlava seznamu S nebo member( X, [ X | _ ] ). a X je prvek tela seznamu S member( X, [ _ Telo ] ) :- member(1,[1,3,1,4]) member( X, Telo %(2) Hana Rudová, Logické programování I, 15. kvetna 2013 56 Seznamy Prvek seznamu member( X, S ) platí: member( b, [a,b,c] ). neplatí: member( b, [[a,b]|[c]] ). X je prvek seznamu S, když & X je hlava seznamu S nebo member( X, [ X | _ ] ). a X je prvek tela seznamu S member( X, [ _ | Telo ] ) :- member( X, Telo ). %(2) dle (1) 4 □ yes member(1,[2,1,3,1,4]) dle (2) member(1,[1,3,1,4]) dle (2) member(1,[3,1,4]) Hana Rudová, Logické programování I, 15. kvetna 2013 56 Seznamy Prvek seznamu member( X, S ) platí: member( b, [a,b,c] ). neplatí: member( b, [[a,b]|[c]] ). X je prvek seznamu S, když & X je hlava seznamu S nebo member( X, [ X | _ ] ). a X je prvek tela seznamu S member( X, [ _ | Telo ] ) :- member( X, Telo ). %(2) dle (1) 4 □ yes member(1,[2,1,3,1,4]) dle (2) member(1,[1,3,1,4]) dle (2) member(1,[3,1,4]) dle (2) member(1,[1,4]) Hana Rudová, Logické programování I, 15. kvetna 2013 56 Seznamy Prvek seznamu member( X, S ) platí: member( b, [a,b,c] ). neplatí: member( b, [[a,b]|[c]] ). X je prvek seznamu S, když & X je hlava seznamu S nebo member( X, [ X | _ ] ). a X je prvek tela seznamu S member( X, [ _ | Telo ] ) :- member( X, Telo ). %(2) dle (1) 4 □ yes dle (1) 4 □ yes member(1,[2,1,3,1,4]) dle (2) member(1,[1,3,1,4]) dle (2) member(1,[3,1,4]) dle (2) member(1,[1,4]) dle (2) member(1,[4]) Hana Rudová, Logické programování I, l5. kvetna 2GlB 56 Seznamy Prvek seznamu member( X, S ) platí: member( b, [a,b,c] ). neplatí: member( b, [[a,b]|[c]] ). X je prvek seznamu S, když & X je hlava seznamu S nebo member( X, [ X | _ ] ). a X je prvek tela seznamu S member( X, [ _ | Telo ] ) :- member( X, Telo ). %(2) dle (1) 4 □ yes dle (1) 4 □ yes member(1,[2,1,3,1,4]) dle (2) member(1,[1,3,1,4]) dle (2) member(1,[3,1,4]) dle (2) member(1,[1,4]) dle (2) member(1,[4]) dle (2) member(1,[ ]) Hana Rudová, Logické programování I, 15. kvetna 2013 56 Seznamy Prvek seznamu member( X, S ) platí: member( b, [a,b,c] ). neplatí: member( b, [[a,b]|[c]] ). X je prvek seznamu S, když & X je hlava seznamu S nebo member( X, [ X | _ ] ). a X je prvek tela seznamu S member( X, [ _ | Telo ] ) :- member( X, Telo ). %(2) dle (1) 4 □ yes dle (1) 4 □ yes member(1,[2,1,3,1,4]) dle (2) member(1,[1,3,1,4]) dle (2) member(1,[3,1,4]) dle (2) member(1,[1,4]) dle (2) member(1,[4]) dle (2) member(1,[ ]) dle (2) Hana Rudová, Logické programování I, 15. kvetna 2013 56 no Seznamy Prvek seznamu member( X, S ) platí: member( b, [a,b,c] ). neplatí: member( b, [[a,b]|[c]] ). X je prvek seznamu S, když & X je hlava seznamu S nebo member( X, [ X | _ ] ). a X je prvek tela seznamu S member( X, [ _ | Telo ] ) :- member( X, Telo ). %(2) Príklady použití: Jt member(1,[2,1,3]). -** member(X,[1,2,3]). dle (1) 4 □ yes dle (1) 4 □ yes member(1,[2,1,3,1,4]) dle (2) member(1,[1,3,1,4]) dle (2) member(1,[3,1,4]) dle (2) member(1,[1,4]) dle (2) member(1,[4]) dle (2) member(1,[ ]) dle (2) Hana Rudová, Logické programování I, 15. kvetna 2013 56 no Seznamy Spojení seznamů C append( L1, L2, L3 ) & Platí: append( [a,b], [c,d], [a,b,c,d] ) JS> Neplatí: append( [b,a], [c,d], [a,b,c,d] ), append( [a,[b]], [c,d], [a,b,c,d] ) Hana Rudová, Logické programování I, 15. kvetna 2013 57 Seznamy Spojení seznamů C append( LI, L2, L3 ) & Platí: append( [a,b], [c,d], [a,b,c,d] ) JS> Neplatí: append( [b,a], [c,d], [a,b,c,d] ), append( [a,[b]], [c,d], [a,b,c,d] ) -í* Definice: -i- pokud je 1. argument prázdný seznam, pak 2. a 3. argument jsou stejné seznamy: append( [], S, S ). Hana Rudová, Logické programování I, 15. kvetna 2013 57 Seznamy Spojení seznamů append( L1, L2, L3 ) Platí: append( [a,b], [c,d], [a,b,c,d] ) Neplatí: append( [b,a], [c,d], [a,b,c,d] ), append( [a,[b]], [c,d], [a,b,c,d] ) Definice: -i- pokud je 1. argument prázdný seznam, pak 2. a 3. argument jsou stejné seznamy: append( [], S, S ). J* pokud je 1. argument neprázdný seznam, pak má 3. argument stejnou hlavu jako 1.: append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3). X S1 S2 S3 Hana Rudová, Logické programování I, 15. kvetna 2013 57 Seznamy Cvicení: append/2 append( [], S, S ). % (1) append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3). % (2) :- append([1,2],[3,4],A). Hana Rudová, Logické programování I, 15. kvetna 2013 58 Seznamy Cvicení: append/2 append( [], S, S ). % (1) append( [X|S1], S2, [X|SS] ) r- append( Sl, S2, S5). % (2) r- append([l,2],[5,4],A). | (2) j A=[1|B] Hana Rudová, Logické programování I, l5. kvetna 2GlB 58 Seznamy Cvicení: append/2 append( [], S, S ). % (1) append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3). % (2) :- append([1,2],[3,4],A). | (2) | A=[1|B] | :- append([2],[3,4],B). Hana Rudová, Logické programování I, 15. kvetna 2013 58 Seznamy Cvičení: append/2 append( [], S, S ). % (1) append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3). % (2) :- append([1,2],[3,4],A). | (2) | A=[1|B] | :- append([2],[3,4],B). | (2) | B=[2|C] => A=[1,2|C] Hana Rudová, Logické programování I, 15. kvetna 2013 58 Seznamy Cvicení: append/2 append( [], S, S ). % (1) append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3). % (2) :- append([1,2],[3,4],A). | (2) | A=[1|B] | :- append([2],[3,4],B). | (2) | B=[2|C] => A=[1,2|C] | :- append([],[3,4],C). Hana Rudová, Logické programování I, 15. kvetna 2013 58 Seznamy Cvicení: append/2 append( [], S, S ). % (1) append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3). % (2) :- append([1,2],[3,4],A). | (2) | A=[1|B] | :- append([2],[3,4],B). | (2) | B=[2|C] => A=[1,2|C] | :- append([],[3,4],C). | (1) | C=[3,4] => A=[1,2,3,4], | yes Hana Rudová, Logické programování I, 15. kvetna 2013 58 Seznamy Optimalizace posledního volání Last Call Optimization (LCO) ImplementaCní technika snižující nároky na pamet' Mnoho vnorených rekurzivních volání je nárocné na pamet' Použití LCO umožnuje vnorenou rekurzi s konstantními pametovými nároky Typický príklad, kdy je možné použití LCO: A procedura musí mít pouze jedno rekurzivní volání: v posledním cíli poslední klauzule A cíle predcházející tomuto rekurzivnímu volání musí být deterministické -i> p( ... ) :- ... % žádné rekurzivní volání v tele klauzule p( ...):- ... % žádné rekurzivní volání v tele klauzule p(...) :- I, p( ... ). % rez zajišťuje determinismus & Tento typ rekurze lze prevést na iteraci Hana Rudová, Logické programování I, 15. kvetna 2013 59 Seznamy LCO a akumulátor -í* Reformulace rekurzivní procedury, aby umožnila LCO Výpocet délky seznamu 1ength( Seznam, Delka ) 1ength( [], 0 ). 1ength( [ H | T ], Delka ) :- 1ength( T, DelkaO ), Delka is 1 + DelkaO. Hana Rudová, Logické programování I, 15. kvetna 2013 60 Seznamy LCO a akumulátoř -í* Reformulace rekurzivní procedury, aby umožnila LCO & Výpocet délky seznamu 1ength( Seznam, Delka ) 1ength( [], 0 ). 1ength( [ H | T ], Delka ) :- 1ength( T, DelkaO ), Delka is 1 + DelkaO. & Upravená procedura, tak aby umožnila LCO: % 1ength( Seznam, ZapocitanaDe1ka, Ce1kovaDe1ka ): % Ce1kovaDe1ka = ZapocitanaDe1ka + ,,pocet prvků v Seznam'' Hana Rudová, Logické programování I, 15. kvetna 2013 60 Seznamy LCO a akumulátor -í* Reformulace rekurzivní procedury, aby umožnila LCO ü> Výpocet délky seznamu 1ength( Seznam, Delka ) 1ength( [], O ). 1ength( [ H j T ], Delka ) :- 1ength( T, DelkaO ), Delka is 1 + DelkaO. -í* Upravená procedura, tak aby umožnila LCO: % 1ength( Seznam, ZapocitanaDelka, CelkovaDelka ): % CelkovaDelka = ZapocitanaDelka + ,,pocet prvků v Seznam'' 1ength( Seznam, Delka ) :- 1ength( Seznam, O, Delka ). % pomocný predikát 1ength( [], Delka, Delka ). % celková délka = zapocítaná délka 1ength( [ H j T], A, Delka ) :- AO is A + 1, 1ength( T, AO, Delka ). & Prídavný argument se nazývá akumulátor Hana Rudová, Logické programování I, lS. kvetna 2GlB 6G Seznamy max_1ist s akumulátorem VýpoCět největšího prvku v seznamu max_1ist(Seznam, Max) max_1ist([X], X). max_1ist([X|T], Max) :-max_1ist(T,MaxT), ( MaxT >= X, I, Max = MaxT Max = X ). Hana Rudová, Logické programování I, 15. kvetna 2G1B 61 Seznamy max_1ist s akumulátorem Výpocet nejvetšího prvku v seznamu max_1ist(Seznam, Max) max_1ist([X], X). max_1ist([X|T], Max) :-max_1ist(T,MaxT), ( MaxT >= X, !, Max = MaxT Max = X ). max_1ist([H|T],Max) :- max_1ist(T,H,Max). max_1ist([], Max, Max). max_1ist([H|T], CastecnyMax, Max) :-( H > CastecnyMax, !, max_1ist(T, H, Max ) max_1ist(T, CastecnyMax, Max) ). Hana Rudová, Logické programování I, 15. kvetna 2013 61 Seznamy Akumulátor jako seznam Nalezení seznamu, ve kterém jsou prvky v opacném po radí reverse( Seznam, OpacnySeznam ) -i- reverse( [], [] ). reverse( [ H | T ], Opacny ) :- Hana Rudová, Logické programování I, 15. kvetna 2013 62 Seznamy Akumulátor jako seznam Nalezení seznamu, ve kterém jsou prvky v opacném po radí reverse( Seznam, OpacnySeznam ) -i- reverse( [], [] ). reverse( [ H | T ], Opacny ) :-reverse( T, OpacnyT ), append( OpacnyT, [ H ], Opacny ). & naivní reverse s kvadratickou složitosti Hana Rudová, Logické programování I, 15. kvetna 2013 62 Seznamy Akumulátor jako seznam Nalezení seznamu, ve kterém jsou prvky v opacném poradí reverse( Seznam, OpacnySeznam ) -i- reverse( [], [] ). reverse( [ H | T ], Opacny ) :-reverse( T, OpacnyT ), append( OpacnyT, [ H ], Opacny ). & naivní reverse s kvadratickou složitosti reverse pomocí akumulátoru s lineární složitostí -i- % reverse( Seznam, Akumulator, Opacny ): % Opacny obdržíme prídáním prvků ze Seznam do Akumulator v opacnem poradi Hana Rudová, Logické programování I, 15. kvetna 2013 62 Seznamy Akumulátoř jako seznam Nalezení seznamu, ve kterém jsou prvky v opacném po radí reverse( Seznam, OpacnySeznam ) -i- reverse( [], [] ). reverse( [ H | T ], Opacny ) :-reverse( T, OpacnyT ), append( OpacnyT, [ H ], Opacny ). & naivní reverse s kvadratickou složitosti reverse pomocí akumulátoru s lineární složitostí -i- % reverse( Seznam, Akůmů1ator, Opacny ): % Opacny obdržíme p r ídáním prvků ze Seznam do Akůmů1ator v opacnem poradi reverse( Seznam, OpacnySeznam ) :- reverse( Seznam, [], OpacnySeznam). reverse( [], S, S ). reverse( [ H | T ], A, Opacny ) :- reverse( T, [ H | A ], Opacny ). % p r idání H do akumulátoru Hana Rudová, Logické programování I, 15. kvetna 2013 62 Seznamy Akumulátor jako seznam JS> Nalezení seznamu, ve kterém jsou prvky v opacném poradí reverse( Seznam, OpacnySeznam ) -i- reverse( [], [] ). reverse( [ H | T ], Opacny ) :-reverse( T, OpacnyT ), append( OpacnyT, [ H ], Opacny ). & naivní reverse s kvadratickou složitosti -i* reverse pomocí akumulátoru s lineární složitostí -i- % reverse( Seznam, Akumulator, Opacny ): % Opacny obdržíme prídáním prvků ze Seznam do Akumulator v opacnem poradi reverse( Seznam, OpacnySeznam ) :- reverse( Seznam, [], OpacnySeznam). reverse( [], S, S ). reverse( [ H | T ], A, Opacny ) :- reverse( T, [ H | A ], Opacny ). % pridání H do akumulátoru zpetná konstrukce seznamu (srovnej s predchozí doprednou konstrukcí, napr. append) Hana Rudová, Logické programování I, 15. kvetna 2013 62 Seznamy cvicení reverse( Seznam, OpacnySeznam ) i- % (1) reverse( Seznam, [], OpacnySeznam). reverse( [], S, S ). % (2) reverse( [ H I T ], A, Opacny ) i- % (S) reverse( T, [H I A ], Opacny ). ? - reverse([1,2,5],O). reverse([1,2,5],O) — Hana Rudová, Logické programování I, 1S. kvetna 2013 63 Seznamy cvicení reverse( Seznam, OpacnySeznam ) :- % (1) reverse( Seznam, [], OpacnySeznam). reverse( [], S, S ). % (2) reverse( [ H | T ], A, Opacny ) :- % (3) reverse( T, [ H I A ], Opacny ). ? - reverse([1,2,3],O). reverse([1,2,3],O) - (1) reverse([1,2,3], [], O) - Hana Rudová, Logické programování I, lS. kvetna 201S 63 Seznamy cvicení reverse( Seznam, OpacnySeznam ) :- % (1) reverse( Seznam, [], OpacnySeznam). reverse( [], S, S ). % (2) reverse( [ H | T ], A, Opacny ) :- % (3) reverse( T, [ H | A ], Opacny ). ? - reverse([1,2,3],O). reverse([1,2,3],O) - (1) reverse([1,2,3], [], O) - (3) reverse([2,3], [1], O) - Hana Rudová, Logické programování I, 15. kvetna 2013 63 Seznamy cvicení reverse( Seznam, OpacnySeznam ) :- % (1) reverse( Seznam, [], OpacnySeznam). reverse( [], S, S ). % (2) reverse( [ H | T ], A, Opacny ) :- % (3) reverse( T, [ H | A ], Opacny ). ? - reverse([1,2,3],O). reverse([1,2,3],O) - (1) reverse([1,2,3], [], O) - (3) reverse([2,3], [1], O) - (3) reverse([3], [2,1], O) - Hana Rudová, Logické programování I, 15. kvetna 2013 63 Seznamy cvicení reverse( Seznam, OpacnySeznam ) :- % (1) reverse( Seznam, [], OpacnySeznam). reverse( [], S, S ). % (2) reverse( [ H | T ], A, Opacny ) :- % (3) reverse( T, [ H | A ], Opacny ). ? - reverse([1,2,3],O). reverse([1,2,3],O) - (1) reverse([1,2,3], [], O) - (3) reverse([2,3], [1], O) - (3) reverse([3], [2,1], O) - (3) reverse([], [3,2,1], O) - Hana Rudová, Logické programování I, 15. kvetna 2013 63 Seznamy cvičení reverse( Seznam, OpacnySeznam ) :- % (1) reverse( Seznam, [], OpacnySeznam). reverse( [], S, S ). % (2) reverse( [ H | T ], A, Opacny ) :- % (3) reverse( T, [ H | A ], Opacny ). ? - reverse([1,2,3],O). reverse([1,2,3],O) - (1) reverse([1,2,3], [], O) - (3) reverse([2,3], [1], O) - (3) reverse([3], [2,1], O) - (3) reverse([], [3,2,1], O) - (2) yes O=[3,2,1] Hana Rudová, Logické programování I, 15. kvetna 2013 63 Seznamy Neefektivita p r i spojování seznamů Sjednocení dvou seznamů append( [], S, S ). append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3 ). Hana Rudová, Logické programování I, 15. kvetna 2013 64 Seznamy Neefektivita pri spojování seznamů Sjednocení dvou seznamů append( [], S, S ). append( [X|S1], S2, [X|SS] ) r- append( Sl, S2, SB ). ľ- append( [2,S], [1], S ). Hana Rudová, Logické programování I, 15. kvetna 2G1B 64 Seznamy Neefektivita p ř i spojování seznamů Sjednocení dvou seznamů append( [], S, S ). append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3 ). ?- append( [2,3], [1], S ). postupné volání cílU: append( [2,3], [1], S ) - append( [3], [1], S') - append( [], [1], S'' ) Hana Rudová, Logické programování I, 15. kvetna 2013 64 Seznamy při spojování seznamů C Sjednocení dvou seznamů & append( [], S, S ). append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3 ). & ?- append( [2,3], [1], S ). postupné volání cílů: append( [2,3], [1], S ) - append( [3], [1], S') - append( [], [1], S'' ) C Vždy je nutné projít celý první seznam Hana Rudová, Logické programování I, 15. kvetna 2013 64 Seznamy Rozdílové seznamy Zapamatování konce a p r ipojení na konec: rozdílové seznamy Hana Rudová, Logické programování I, 15. kvetna 2013 65 Seznamy Rozdílové seznamy Zapamatování konce a připojení na konec: rozdílové seznamy [a,b] = L1-L2 = [a,b|T]-T = [a,b,c|S]-[c|S] = [a,b,c]-[c] Reprezentace prázdného seznamu: L-L Hana Rudová, Logické programování I, 15. kvetna 2013 65 Seznamy Rozdílové seznamy Zapamatování konce a p r ipojení na konec: rozdílové seznamy [a,b] = L1-L2 = [a,b|T]-T = [a,b,c|S]-[c|S] = [a,b,c]-[c] Reprezentace prázdného seznamu: L-L A1 Z1 A2 Z2 v 1 L1 L2 \ append( A1-Z1, Z1-Z2, A1-Z2 ). L1 L2 L3 L3 Hana Rudová, Logické programování I, 15. kvetna 2013 65 Seznamy Rozdílové seznamy Zapamatování konce a připojení na konec: rozdílové seznamy [a,b] = L1-L2 = [a,b|T]-T = [a,b,c|S]-[c|S] = [a,b,c]-[c] Reprezentace prázdného seznamu: L-L A1 Z1 A2 Z2 v 1 L1 L2 \ append( A1-Z1, Z1-Z2, A1-Z2 ). L1 L2 L3 [2,3] [1] [2,3,1] [2,3|Z1]-Z1 [1|Z2]-Z2 [2,3,1|Z2]-Z2 L3 Hana Rudová, Logické programování I, 15. kvetna 2013 65 Seznamy Rozdílové seznamy Zapamatování konce a p r ipojení na konec: rozdílové seznamy [a,b] = L1-L2 = [a,b|T]-T = [a,b,c|S]-[c|S] = [a,b,c]-[c] Reprezentace prázdného seznamu: L-L A1 Z1 A2 Z2 v 1 L1 L2 \ L3 append( A1-Z1, Z1-Z2, A1-Z2 ). L1 L2 L3 [2,3] [1] [2,3,1] [2,3|Z1]-Z1 [1|Z2]-Z2 [2,3,1|Z2]-Z2 ?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ). S = Hana Rudová, Logické programování I, 15. května 2013 65 Seznamy Rozdílové seznamy Zapamatování konce a připojení na konec: rozdílové seznamy [a,b] = L1-L2 = [a,b|T]-T = [a,b,c|S]-[c|S] = [a,b,c]-[c] Reprezentace prázdného seznamu: L-L A1 Z1 A2 Z2 v 1 L1 L2 \ L3 append( A1-Z1, Z1-Z2, A1-Z2 ). L1 L2 L3 [2,3] [1] [2,3,1] [2,3|Z1]-Z1 [1|Z2]-Z2 [2,3,1|Z2]-Z2 ?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ). S = A1 - Z2 = Hana Rudová, Logické programování I, 15. kvetna 2013 65 Seznamy Rozdílové seznamy Zapamatování konce a p r ipojení na konec: rozdílové seznamy [a,b] = L1-L2 = [a,b|T]-T = [a,b,c|S]-[c|S] = [a,b,c]-[c] Reprezentace prázdného seznamu: L-L A1 Z1 A2 Z2 v 1 L1 L2 \ append( A1-Z1, Z1-Z2, A1-Z2 ). L1 L2 L3 [2,3] [1] [2,3,1] [2,3|Z1]-Z1 [1|Z2]-Z2 [2,3,1|Z2]-Z2 L3 ?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ). S = A1 - Z2 = [2,3|Z1] - Z2 = Hana Rudová, Logické programování I, 15. kvetna 2013 65 Seznamy Rozdílové seznamy Zapamatování konce a připojení na konec: rozdílové seznamy [a,b] = L1-L2 = [a,b|T]-T = [a,b,c|S]-[c|S] = [a,b,c]-[c] Reprezentace prázdného seznamu: L-L A1 Z1 A2 Z2 v 1 L1 L2 \ L3 append( A1-Z1, Z1-Z2, A1-Z2 ). L1 L2 L3 [2,3] [1] [2,3,1] [2,3|Z1]-Z1 [1|Z2]-Z2 [2,3,1|Z2]-Z2 ?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ). S = A1 - Z2 = [2,3|Z1] - Z2 = [2,3| [1|Z2] ] Z2 Hana Rudová, Logické programování I, 15. kvetna 2013 65 Seznamy Rozdílové seznamy Zapamatování konce a připojení na konec: rozdílové seznamy [a,b] = L1-L2 = [a,b|T]-T = [a,b,c|S]-[c|S] = [a,b,c]-[c] Reprezentace prázdného seznamu: L-L A1 Z1 A2 Z2 v i L1 L2 \ L3 append( A1-Z1, Z1-Z2, A1-Z2 ). L1 L2 L3 [2,3] [1] [2,3,1] [2,3|Z1]-Z1 [1|Z2]-Z2 [2,3,1|Z2]-Z2 ?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ). S = A1 - Z2 = [2,3|Z1] - Z2 = [2,3| [1|Z2] ] Z1 = [1|Z2] S = [2,3,1|Z2]-Z2 Z2 Jednotková složitost, oblíbená technika ale není tak flexibilní Hana Rudová, Logické programování I, 15. kvetna 2013 65 Seznamy Akumulátor vs. rozdílové seznamy: reverse reverse( [], [] ). reverse( [ H | T ], Opacny ) :-reverse( T, OpacnyT ), append( OpacnyT, [ H ], Opacny ). kvadratická složitost reverse( Seznam, Opacny ) :- reverse0( Seznam, [], Opacny ). reverse0( [], S, S ). reverse0( [ H | T ], A, Opacny ) :- reverse0( T, [ H j A ], Opacny ). akumulátor (lineární) Hana Rudová, Logické programování I, 15. kvetna 2G1B 66 Seznamy Akumulátor vs. rozdílové seznamy: reverse reverse( [], [] ). reverse( [ H | T ], Opacny ) i-reverse( T, OpacnyT ), append( OpacnyT, [ H ], Opacny ). kvadratická složitost reverse( Seznam, Opacny ) i- reverse0( Seznam, [], Opacny ). reverse0( [], S, S ). reverse0( [ H | T ], A, Opacny ) i- reverse0( T, [ H I A ], Opacny ). akumulátor (lineární) reverse( Seznam, Opacny ) i- reverse0( Seznam, Opacny-[]). reverse0( [], S-S ). reverse0( [ H | T ], Opacny-OpacnyKonec ) i- rozdílové seznamy reverse0( T, Opacny-[ H | OpacnyKonec] ). (lineární) Hana Rudová, Logické programování I, 1S. kvetna 2013 66 Seznamy Akumulátor vs. rozdílové seznamy: reverse reverse( [], [] ). reverse( [ H | T ], Opacny ) i-reverse( T, OpacnyT ), append( OpacnyT, [ H ], Opacny ). kvadratická složitost reverse( Seznam, Opacny ) i- reverse0( Seznam, [], Opacny ). reverse0( [], S, S ). reverse0( [ H | T ], A, Opacny ) i- reverse0( T, [ H | A ], Opacny ). akumulátor (lineární) reverse( Seznam, Opacny ) i- reverse0( Seznam, Opacny-[]). reverse0( [], S-S ). reverse0( [ H | T ], Opacny-OpacnyKonec ) i- rozdílové seznamy reverse0( T, Opacny-[ H | OpacnyKonec] ). (lineární) Príklad: operace pro manipulaci s frontou JS* test na prázdnost, p r idání na konec, odebrání ze zacátku Hana Rudová, Logické programování I, 1S. kvetna 2013 66 Seznamy Vestavené predikáty Vestavené předikáty -í* Predikáty pro rízení behu programu a fai1, trůe, ... Ruzné typy rovností a unifikace, aritmetická rovnost, ... Databázové operace & zmena programu (programové databáze) za jeho behu -í* Vstup a výstup -i* Všechna r ešení programu JS> Testování typu termu promenná?, konstanta?, struktura?, ... & Konstrukce a dekompozice termu -i- argumenty?, funktor?, ... Hana Rudová, Logické programování I, 15. kvetna 2013 68 Vestavené predikáty Databázové operace Databáze: specifikace množiny relací Prologovský program: programová databáze, kde jsou relace specifikovány explicitne (fakty) i implicitne (pravidly) Vestavené predikáty pro zmenu databáze behem provádení programu: assert( Klauzule ) pridání Klauzule do programu asserta( Klauzule ) pridání na zacátek assertz( Klauzule ) pridání na konec retract( Klauzule ) smazání klauzule unifikovatelné s Klauzule Pozor: nadmerné použití techto operací snižuje srozumitelnost programu Hana Rudová, Logické programování I, 15. kvetna 2013 69 Vestavené predikáty Príklad: databázové operace -í* Caching: odpovedi na dotazy jsou pridány do programové databáze Hana Rudová, Logické programování I, 15. kvetna 2013 70 Vestavené predikáty Příklad: databázové operace Caching: odpovědi na dotazy jsou přidány do programové databáze a ?- so1ve( problem, Solution), asserta( so1ve( problem, Solution) ). J* :- dynamic solve/2. % nezbytné při použití v SICStus Prologu Hana Rudová, Logické programování I, 15. května 2013 70 Vestavěné predikáty P ř íklad: databázové operace Caching: odpovědi na dotazy jsou p r idány do programové databáze a ?- so1ve( problem, Solution), asserta( so1ve( problem, Solution) ). M Pr íklad: u1oz_trojice( Seznaml, Seznam2 ) :- member( Xl, Seznaml ), member( X2, Seznam2 ), spocitej_treti( Xl, X2, X3 ), assertz( trojice( Xl, X2, X3 ) ), fail. J* :- dynamic solve/2. p r i použití v Hana Rudová, Logické programování I, 15. května 2013 70 Vestavěné predikáty Příklad: databázové operace Caching: odpovědi na dotazy jsou přidány do programové databáze a ?- so1ve( problem, Solution), asserta( so1ve( problem, Solution) ). M Příklad: u1oz_trojice( Seznaml, Seznam2 ) :- member( Xl, Seznaml ), member( X2, Seznam2 ), spocitej_treti( Xl, X2, X3 ), assertz( trojice( Xl, X2, X3 ) ), fail. J* :- dynamic solve/2. při použití v u1oz_trojice( Hana Rudová, Logické programování I, 15. května 2013 70 Vestavěné predikáty Vstup a výstup program muže císt data ze vstupního proudu (input stream) program může zapisovat data do výstupního proudu (output stream) dva aktivní proudy & aktivní vstupní proůd -i- aktivní výstupní proůd uživatelský terminál - user Jť datový vstůp z terminálů user chápán jako jeden ze vstupních proudU datový výstup na terminál chápán jako jeden z výstupních proudu soubor 1 soubor 2 user vstupni proudy soubor 3 soubor 4 vystupni proudy Hana Růdová, Logické programování I, 15. května 2013 71 Vestavěné predikáty Vstupní a výstupní přoudy: vestavené předikáty změna (otevření) aktivního vstupního/výstupního proudu: see(S)/tell(S) cteni( Soubor ) :- see( Soubor ), cteni_ze_souboru( Informace ), see( user ). JS> uzavření aktivního vstupního/výstupního proudu: seen/told Hana Rudová, Logické programování I, 15. kvetna 2013 72 Vestavené predikáty Vstupní a výstupní proudy: vestavené predikáty zmena (otevření) aktivního vstupního/výstupního proudu: see(S)/te11(S) cteni( Soubor ) :- see( Soubor ), cteni_ze_souboru( Informace ), see( user ). JS> uzavření aktivního vstupního/výstupního proudu: seen/told & zjištení aktivního vstupního/výstupního proudu: seeing(S)/te11ing(S) cteni( Soubor ) :- seeing( StarySoubor ), see( Soubor ), cteni_ze_souboru( Informace ), seen, see( StarySoubor ). Hana Rudová, Logické programování I, 15. května 2013 72 Vestavěné predikáty Sekvenční p r ístup k textovým souborům čtení dalšího termu: read(Term) & pri ctení jsou termy oddeleny teckou | ?- read(A), read( ahoj(B) ), read( [C,D] ). Hana Rudová, Logické programování I, 15. kvetna 2013 73 Vestavené predikáty Sekvencní prístup k textovým souborům ctení dalšího termu: read(Term) J* pri ctení jsou termy oddeieny teckou | ?- read(A), read( ahoj(B) ), read( [C,D] ). |: ahoj. ahoj( petre ). [ ahoj( 'Petre!' ), jdeme ]. A = ahoj, B = petre, C = ahoj('Petre!'), D = jdeme Hana Rudová, Logické programování I, 15. kvetna 2013 73 Vestavené predikáty Sekvenční p r ístup k textovým souborům čtení dalšího termu: read(Term) & pri ctení jsou termy oddeleny teckou | ?- read(A), read( ahoj(B) ), read( [C,D] ). |: ahoj. ahoj( petre ). [ ahoj( 'Petre!' ), jdeme ]. A = ahoj, B = petre, C = ahoj('Petre!'), D = jdeme a po dosažení konce souboru je vrácen atom end_of_fi1e & zápis dalšího termu: write(Term) ?- write( ahoj ). ?- write( 'Ahoj Petre!' ). nový rádek na výstup: nl N mezer na výstup: tab(N) Hana Rudová, Logické programování I, 15. kvetna 2013 73 Vestavené predikáty Sekvenční p ř ístup k textovým souborům čtení dalšího termu: read(Term) J* p r i Ctení jsou termy odděleny těCkou | ?- read(A), read( ahoj(B) ), read( [C,D] ). |: ahoj. ahoj( petre ). [ ahoj( 'Petre!' ), jdeme ]. A = ahoj, B = petre, C = ahoj('Petre!'), D = jdeme a po dosažení konce souboru jě vrácen atom end_of_file & zápis dalšího termu: write(Term) ?- write( ahoj ). ?- write( 'Ahoj Petre!' ). nový rádek na výstup: nl N mezer na výstup: tab(N) & čtení/zápis dalšího znaku: getO(Znak), get(NeprazdnyZnak)/put(Znak) po dosažení konce souboru je vrácena -1 Hana Rudová, Logické programování I, 15. kvetna 2013 73 Vestavené predikáty Príklad ctení ze souboru process_file( Soubor ) :- seeing( StarySoubor ), see( Soubor ), repeat, read( Term ), process_term( Term ), Term == end_of_file, i ■ j seen, see( StarySoubor ). % zjištění aktivního proudu % otevrení souboru Soubor % ctění termu Term % manipulace s termem % je konec souboru? % uzavrení souboru % aktivace puvodního proudu repeat. % opakování repeat :- repeat. Hana Rudová, Logické programování I, 15. kvetna 2013 74 Vestavené predikáty Ctení přogřamu ze soubořu JS> Inteřpřetování kódu programu a ?- consů1t(program). a ?- consů1t('program.p1'). a ?- consů1t( [programl, 'program2.p1'] ). -i* Kompilace kódu programu a ?- compile( [program1, 'program2.pl'] ). & ?- [program]. ?- [user]. zadávání kódu ze vstupu ukoncené CTRL+D a další varianty podobne jako u interpretování & typické zrychlení: 5 až 10 krát Hana Rudová, Logické programování I, 15. kvetna 2013 75 Vestavené predikáty Všechna řešení Backtracking vrací pouze jedno řešení po druhém Všechna řešení dostupná najednou: bagof/3, setof/3, findall/3 bagof( X, P, S ): vrátí seznam S, všech objektů X takových, že P je splneno vek( petr, 7 ). vek( anna, 5 ). vek( tomas, 5 ). ?- bagof( Dite, vek( Dite, 5 ), Seznam ). Hana Rudová, Logické programování I, 15. května 2013 76 Vestavěné predikáty Všechna řešení Backtracking vrací pouze jedno řešení po druhém Všechna ř ešení dostupná najednou: bagof/3, setof/3, findall/3 bagof( X, P, S ): vrátí seznam S, všech objektů X takových, že P je splneno vek( petr, 7 ). vek( anna, 5 ). vek( tomas, 5 ). ?- bagof( Dite, vek( Dite, 5 ), Seznam ). Seznam = [ anna, tomas ] Hana Rudová, Logické programování I, 15. května 2013 76 Vestavěné predikáty Všechna řešení Backtracking vrací pouze jedno řešení po druhém Všechna řešení dostupná najednou: bagof/3, setof/3, findall/3 bagof( X, P, S ): vrátí seznam S, všech objektů X takových, že P je splneno vek( petr, 7 ). vek( anna, 5 ). vek( tomas, 5 ). ?- bagof( Dite, vek( Dite, 5 ), Seznam ). Seznam = [ anna, tomas ] Volné promenné v cíli P jsou všeobecne kvantifikovány ?- bagof( Dite, vek( Dite, Vek ), Seznam ). Hana Rudová, Logické programování I, 15. kvetna 2013 76 Vestavené predikáty Všechna řešení Backtracking vrací pouze jedno řešení po druhém Všechna řešení dostupná najednou: bagof/3, setof/3, findall/3 bagof( X, P, S ): vrátí seznam S, všech objektů X takových, že P je splneno vek( petr, 7 ). vek( anna, 5 ). vek( tomas, 5 ). ?- bagof( Dite, vek( Dite, 5 ), Seznam ). Seznam = [ anna, tomas ] Volné promenné v cíli P jsou všeobecné kvantifikovány ?- bagof( Dite, vek( Dite, Vek ), Seznam ). Vek = 7, Seznam = [ petr ]; Vek = 5, Seznam = [ anna, tomas ] Hana Rudová, Logické programování I, 15. kvetna 2013 76 Vestavené predikáty Všechna řešení II. Pokud neexistuje r ešení bagof(X,P,S) neuspěje bagof: pokud nejaké r ešení existuje nekolikrát, pak S obsahuje duplicity bagof, setof, findall: P je libovolný cíl vek( petr, 7 ). vek( anna, 5 ). vek( tomas, 5 ). ?- bagof( Dite, ( vek( Dite, 5 ), Dite \= anna ), Seznam ). Seznam = [ tomas ] Hana Rudová, Logické programování I, 15. kvetna 2013 77 Vestavené predikáty vr vr 'II reseni II. C Pokud neexistuje r ešení bagof(X,P,S) neuspeje ii> bagof: pokud nejaké r ešení existuje nekolikrát, pak S obsahuje duplicity JS> bagof, setof, findall: P je libovolný cíl vek( petr, 7 ). vek( anna, 5 ). vek( tomas, 5 ). ?- bagof( Dite, ( vek( Dite, 5 ), Dite \= anna ), Seznam ). Seznam = [ tomas ] JS> bagof, setof, findall: na objekty shromažďované v X nejsou žádná omezení: X je term ?- bagof( Dite-Vek, vek( Dite, Vek ), Seznam ). Seznam = [petr-7,anna-5,tomas-5] Hana Rudová, Logické programování I, 15. kvetna 2013 77 Vestavené predikáty Existenční kvantifikátor „" " Pr idání existenčního kvantifikátoru „~ " ^ hodnota proměnné nemá význam ?- bagof( Dite, Vek~vek( Dite, Vek ), Seznam ). Hana Rudová, Logické programování I, 15. května 2013 78 Vestavěné predikáty Existenční kvantifikátor „" " Přidání existenčního kvantifikátoru „~ " ^ hodnota proměnné němá význam ?- bagof( Dite, Vek~vek( Dite, Vek ), Seznam ). Seznam = [petr,anna,tomas] Hana Rudová, Logické programování I, 15. května 2013 78 Věstavěné prědikáty ExistenCní kvantifikátoř „" " Pr idání existenCního kvantifikátořu „Ä " => hodnota promenné nemá význam ?- bagof( Dite, Vek~vek( Dite, Vek ), Seznam ). Seznam = [petr,anna,tomas] Anonymní promenné jsou všeobecne kvantifikovány, i když jejich hodnota není (jako vždy) vracena na výstup ?- bagof( Dite, vek( Dite, _Vek ), Seznam ). Seznam = [petr] ; Seznam = [anna,tomas] Hana Rudová, Logické programování I, 15. kvetna 2013 78 Vestavené predikáty Existenční kvantifikátor „" " Pr idání existenčního kvantifikátoru „Ä " ^ hodnota promenné nemá význam ?- bagof( Dite, Vek~vek( Dite, Vek ), Seznam ). Seznam = [petr,anna,tomas] Anonymní promenné jsou všeobecne kvantifikovány, i když jejich hodnota není (jako vždy) vracena na výstup ?- bagof( Dite, vek( Dite, _Vek ), Seznam ). Seznam = [petr] ; Seznam = [anna,tomas] Pr ed operátorem „~ " může být i seznam ?- bagof( Vek ,[Jmeno,Prijmeni]~vek( Jmeno, Prijmeni, Vek ), Seznam ). Seznam = [7,5,5] Hana Rudová, Logické programování I, 15. kvetna 2013 78 Vestavené predikáty řešení III. setof( X, P, S ): rozdíly od bagof J* S je usporádaný podle @< Jť prípadné duplicity v S jsou eliminovány Hana Rudová, Logické programování I, 15. kvetna 2013 79 Vestavené predikáty řešení III. setof( X, P, S ): rozdíly od bagof J* S je uspo řádaný podle @< Jť p r ípadné duplicity v S jsou eliminovány JS> finda11( X, P, S ): rozdíly od bagof všechny promenné jsou existencne kvantifikovány ?- findall( Dite, vek( Dite, Vek ), Seznam ). Hana Rudová, Logické programování I, 15. kvetna 2013 79 Vestavené predikáty řešení III. setof( X, P, S ): rozdíly od bagof J* S jě uspo rádaný podlě @< Jť p r ípadné duplicity v S jsou eliminovány & finda11( X, P, S ): rozdíly od bagof všechny proměnné jsou ěxistěnCně kvantifikovány ?- findall( Ditě, věk( Ditě, Věk ), Sěznam ). == v S jsou shromažďovány všěchny možnosti i pro různá r ěšění == findall uspějě p r ěsnějědnou Hana Rudová, Logické programování I, 15. května 2013 79 Věstavěné prědikáty Všechna řešení III. setof( X, P, S ): rozdíly od bagof J* S je uspořádaný podle @< Jť prípadné duplicity v S jsou eliminovány finda11( X, P, S ): rozdíly od bagof všechny proměnné jsou existenCne kvantifikovány ?- findall( Dite, vek( Dite, Vek ), Seznam ). == v S jsou shromažďovány všechny možnosti i pro různá rešení == findall uspeje presne jednou -i- výsledný seznam může být prázdný == pokud neexistuje rešení, uspeje a vrátí S = [] Hana Rudová, Logické programování I, 15. kvetna 2013 79 Vestavené predikáty Všechna řešení III. setof( X, P, S ): rozdíly od bagof J* S je uspořádaný podle @< Jť prípadné duplicity v S jsou eliminovány finda11( X, P, S ): rozdíly od bagof všechny proměnné jsou existenCne kvantifikovány ?- findall( Dite, vek( Dite, Vek ), Seznam ). == v S jsou shromažďovány všechny možnosti i pro různá rešení == findall uspeje presne jednou -i- výsledný seznam muže být prázdný == pokud neexistuje rešení, uspeje a vrátí S = [] -fc ?- bagof( Dite, vek( Dite, Vek ), Seznam ). Vek = 7, Seznam = [ petr ]; Vek = 5, Seznam = [ anna, tomas ] ?- finda11( Dite, vek( Dite, Vek ), Seznam ). Hana Rudová, Logické programování I, 15. kvetna 2013 79 Vestavené predikáty řešení III. setof( X, P, S ): rozdíly od bagof J* S je uspo rádaný podle @< Jť p r ípadné duplicity v S jsou eliminovány & finda11( X, P, S ): rozdíly od bagof všechny promenné jsou existencne kvantifikovány ?- findall( Dite, vek( Dite, Vek ), Seznam ). == v S jsou shromažďovány všechny možnosti i pro různá r ešení == finda11 uspeje p r esne jednou -i- výsledný seznam může být prázdný == pokud neexistuje r ešení, uspeje a vrátí S = [] -fc ?- bagof( Dite, vek( Dite, Vek ), Seznam ). Vek = 7, Seznam = [ petr ]; Vek = 5, Seznam = [ anna, tomas ] ?- finda11( Dite, vek( Dite, Vek ), Seznam ). Seznam = [petr,anna,tomas] Hana Rudová, Logické programování I, 15. kvetna 2013 79 Vestavené predikáty Testování typu termu var(X) X je volná promenná nonvar(X) X není promenná Hana Rudová, Logické programování I, 15. kvetna 2013 80 Vestavené predikáty Testování typu termu var(X) nonvar(X) X je volná proměnná X není proměnná atom(X) integer(X) float(X) atomic(X) X je atom (pavel, 'Pavel Novák', <-->) X je integer X je float X je atom nebo Číslo Hana Rudová, Logické programování I, 15. kvetna 2013 80 Vestavené predikáty Testování typu termu var(X) nonvar(X) X je volná proměnná X není proměnná atom(X) integer(X) float(X) atomic(X) X je atom (pavel, 'Pavel Novák', <-->) X je integer X je float X je atom nebo Číslo compound(X) X je struktura Hana Rudová, Logické programování I, 15. kvetna 2013 80 Vestavené predikáty Určení počtu výskytů prvku v seznamu count( X, S, N ) Hana Rudová, Logické programování I, 15. května 2013 81 Vestavěné predikáty Urcení poctu výskytů prvku v seznamu count( X, S, N ) :- count( X, S, 0, N ). Hana Rudová, Logické programování I, 15. kvetna 2013 81 Vestavené predikáty Určení počtu výskytů prvku v seznamu count( X, S, N ) :- count( X, S, 0, N ). count( _, [], N, N ). Hana Rudová, Logické programování I, 15. května 2013 81 Vestavěné predikáty Určení počtu výskytů prvku v seznamu count( X, S, N ) :- count( X, S, 0, N ). count( _, [], N, N ). count( X, [XjS], N0, N) :- I, N1 is N0 + 1, count( X, S, N1, N). Hana Rudová, Logické programování I, 15. května 2013 81 Vestavěné predikáty Určení počtu výskytů prvku v seznamu count( X, S, N ) :- count( X, S, 0, N ). count( _, [], N, N ). count( X, [X|S], NO, N) :- !, N1 is NO + 1, count( X, S, N1, N). count( X, [_|S], NO, N) :- count( X, S, NO, N). Hana Rudová, Logické programování I, 15. kvetna 2013 81 Vestavené predikáty Urcení poctu výskytů prvku v seznamu count( X, S, N ) :- count( X, S, 0, N ). count( _, [], N, N ). count( X, [X|S], N0, N) :- I, N1 is N0 + 1, count( X, S, N1, N). count( X, [_|S], N0, N) :- count( X, S, N0, N). :-? count( a, [a,b,a,a], N ) N=3 Hana Rudová, Logické programování I, 15. kvetna 2013 81 Vestavené predikáty Určení počtu výskytů prvku v seznamu count( X, S, N ) :- count( X, S, O, N ). count( _, [], N, N ). count( X, [X|S], NO, N) :- !, N1 is NO + 1, count( X, S, N1, N). count( X, [_|S], NO, N) :- count( X, S, NO, N). :-? count( a, [a,b,a,a], N ) :-? count( a, [a,b,X,Y], N). N=3 Hana Rudová, Logické programování I, 15. kvetna 2013 81 Vestavené predikáty Určení počtu výskytů prvku v seznamu count( X, S, N ) :- count( X, S, 0, N ). count( _, [], N, N ). count( X, [XjS], N0, N) :- I, N1 is N0 + 1, count( X, S, N1, N). count( X, [_jS], N0, N) :- count( X, S, N0, N). :-? count( a, [a,b,a,a], N ) :-? count( a, [a,b,X,Y], N). N=3 N=3 Hana Rudová, Logické programování I, 15. května 2013 81 Vestavěné predikáty UřCení poCtu výskytů přvku v seznamu count( X, S, N ) :- count( X, S, 0, N ). count( _, [], N, N ). count( X, [X|S], N0, N) :- I, N1 is N0 + 1, count( X, S, N1, N). count( X, [_|S], N0, N) :- count( X, S, N0, N). :-? count( a, [a,b,a,a], N ) :-? count( a, [a,b,X,Y], N). N=3 N=3 count( _, [], N, N ). count( X, [Y|S], N0, N ) :- nonvar(Y), X = Y, I, N1 is N0 + 1, count( X, S, N1, N ). count( X, [_|S], N0, N ) :- count( X, S, N0, N ). Hana Rudová, Logické programování I, 15. kvetna 2013 81 Vestavené predikáty Konstrukce a dekompozice atomu JS> Atom (opakování) M retezce písmen, Čísel, „_" zaCínající malým písmenem: pavel, pave1_novak, x2, x4_34 a retezce speciálních znaků: +, <->, ===> -fc r etezce v apostrofech: 'Pavel', 'Pavel Novák', 'prší', 'ano' ?- 'ano'=A. A = ano Hana Rudová, Logické programování I, 15. kvetna 2013 82 Vestavené predikáty Konstrukce a dekompozice atomu Atom (opakování) M retezce písmen, císel, „_" zacínající malým písmenem: pavel, pave1_novak, x2, x4_34 A retezce speciálních znaků: +, <->, ===> A r etezce v apostrofech: 'Pavel', 'Pavel Novák', 'prší', 'ano' ?- 'ano'=A. A = ano Řetezec znakU v uvozovkách p r . "ano", "Pavel" ?- A="Pave1". ?- A="ano". A = [80,97,118,101,108] A=[97,110,111] A p r . použití: konstrukce a dekompozice atomu na znaky, vstup a výstup do souboru Hana Rudová, Logické programování I, 15. kvetna 2013 82 Vestavené predikáty Konstrukce a dekompozice atomu JS> Atom (opakování) 3 retezce písmen, Čísel, „_" zaCínající malým písmenem: pavel, pavel_novak, x2, x4_34 A retezce speciálních znaků: +, <->, ===> A r etezce v apostrofech: 'Pavel', 'Pavel Novák', 'prší', 'ano' ?- 'ano'=A. A = ano Řetezeč znaku v uvozovkách p r . "ano", "Pavel" ?- A="Pavel". ?- A="ano". A = [80,97,118,101,108] A=[97,110,111] A p r . použití: konstrukce a dekompozice atomu na znaky, vstup a výstup do souboru * Konstrukče atomu ze znaků, rozložení atomu na znaky name( Atom, SeznamASCIIKodu ) name( ano, [97,110,111] ) name( ano, "ano" ) Hana Rudová, Logické programování I, 15. kvetna 2013 82 Vestavené predikáty Konstrukce a dekompozice termu -í* Konstrukce a dekompozice termu Term =.. [ Funktor | SeznamArgumentu ] a(9,e) =.. [a,9,e] Hana Rudová, Logické programování I, 15. května 2013 83 Vestavěné predikáty Konstrukce a dekompozice termu -í* Konstrukce a dekompozice termu Term =.. [ Funktor | SeznamArgumentu ] a(9,e) =.. [a,9,e] Cil =.. [ Funktor | SeznamArgumentu ], call( Cil ) Hana Rudová, Logické programování I, 15. kvetna 2013 83 Vestavené predikáty Konstrukce a dekompozice termu -í* Konstrukce a dekompozice termu Term =.. [ Funktor | SeznamArgumentu ] a(9,e) =.. [a,9,e] Cil =.. [ Funktor | SeznamArgumentu ], call( Cil ) atom =.. X Hana Rudová, Logické programování I, 15. kvetna 2013 83 Vestavené predikáty Konstrukce a dekompozice termu -í* Konstrukce a dekompozice termu Term =.. [ Funktor | SeznamArgumentu ] a(9,e) =.. [a,9,e] Cil =.. [ Funktor | SeznamArgumentu ], call( Cil ) atom =.. X => X = [atom] Hana Rudová, Logické programování I, 15. května 2013 83 Vestavěné predikáty Konstrukce a dekompozice termu ü> Konstrukce a dekompozice termu Term =.. [ Funktor j SeznamArgumentu ] a(9,e) =.. [a,9,e] Cil =.. [ Funktor j SeznamArgumentu ], ca11( Cil ) atom =.. X => X = [atom] & Pokud chci znát pouze funktor nebo nekteré argumenty, pak je efektivnejší: functor( Term, Funktor, Arita ) functor( a(9,e), a, 2 ) Hana Rudová, Logické programování I, 15. kvetna 2013 83 Vestavené predikáty Konstrukce a dekompozice termu ü> Konstrukce a dekompozice termu Term =.. [ Funktor | SeznamArgumentu ] a(9,e) =.. [a,9,e] Cil =.. [ Funktor | SeznamArgumentu ], call( Cil ) atom =.. X => X = [atom] & Pokud chci znát pouze funktor nebo nekteré argumenty, pak je efektivnejší: functor( Term, Funktor, Arita ) functor( a(9,e), a, 2 ) functor(atom,atom,0) functor(1,1,0) Hana Rudová, Logické programování I, 15. kvetna 2013 83 Vestavené predikáty Konstrukce a dekompozice termu ü> Konstrukce a dekompozice termu Term =.. [ Funktor | SeznamArgumentu ] a(9,e) =.. [a,9,e] Cil =.. [ Funktor | SeznamArgumentu ], call( Cil ) atom =.. X => X = [atom] & Pokud chci znát pouze funktor nebo nekteré argumenty, pak je efektivnejší: functor( Term, Funktor, Arita ) functor( a(9,e), a, 2 ) functor(atom,atom,0) i functor(1,1,0) arg( 2, a(9,e), e) arg( N, Term, Argument ) Hana Rudová, Logické programování I, 15. kvetna 2013 83 Vestavené predikáty Rekurzivní rozklad termu Term je proměnná (var/1), atom nebo Číslo (atomic/1) => konec rozkladu Hana Rudová, Logické programování I, 15. kvetna 2013 84 Vestavené predikáty Rekurzivní rozklad termu Term je promenná (var/1), atom nebo Číslo (atomic/1) => konec rozkladu Term je složený (=../2, functor/3) ^ procházení seznamu argumentu a rozklad každého argumentu Hana Rudová, Logické programování I, 15. kvetna 2013 84 Vestavené predikáty Rekuřzivní řozklad teřmu Term je promenná (var/1), atom nebo císlo (atomic/1) == konec rozkladu Term je seznam ([_|_]) == [] ... rešen výše jako atomic procházení seznamu a rozklad každého prvku seznamu Term je složený (=../2, functor/3) == procházení seznamu argumentu a rozklad každého argumentu Hana Rudová, Logické programování I, 15. kvetna 2013 84 Vestavené predikáty Rekurzivní rozklad termu ii> Term je promenná (var/1), atom nebo císlo (atomic/1) => konec rozkladu Term je seznam ([_|_]) => []... řešen výše jako atomic procházení seznamu a rozklad každého prvku seznamu £ Term je složený (=../2, functor/3) => procházení seznamu argumentů a rozklad každého argumentu ii> Príklad: ground/1 uspeje, pokud v termu nejsou promenné; jinak neuspeje Hana Rudová, Logické programování I, 15. kvetna 2013 84 Vestavené predikáty Rekurzivní rozklad termu ii> Term je proměnná (var/1), atom nebo císlo (atomic/1) => konec rozkladu Term je seznam => []... řešen výše jako atomic procházení seznamu a rozklad každého prvku seznamu £ Term je složený (=../2, functor/3) => procházení seznamu argumentu a rozklad každého argumentu ii> Príklad: ground/1 uspěje, pokud v termu nejsou proměnné; jinak neuspěje ground(Term) :- atomic(Term), I. Hana Rudová, Logické programování I, 15. kvetna 2013 84 Vestavené predikáty Rekurzivní rozklad termu ii> Term je promenná (var/1), atom nebo císlo (atomic/1) => konec rozkladu Term je seznam ([_|_]) => []... řešen výše jako atomic procházení seznamu a rozklad každého prvku seznamu £ Term je složený (=../2, functor/3) => procházení seznamu argumentu a rozklad každého argumentu ii> Príklad: ground/1 uspeje, pokud v termu nejsou promenné; jinak neuspeje ground(Term) :- atomic(Term), !. ground(Term) :- var(Term), !, fail. Hana Rudová, Logické programování I, 15. kvetna 2013 84 Vestavené predikáty Rekurzivní rozklad teřmu & Term je promenná (var/1), atom nebo císlo (atomic/1) == konec rozkladu Term je seznam ([_|_]) == []... řešen výše jako atomic procházení seznamu a rozklad každého prvku seznamu £ Term je složený (=../2, functor/3) => procházení seznamu argumentu a rozklad každého argumentu ii> Príklad: ground/1 uspeje, pokud v termu nejsou promenné; jinak neuspeje ground(Term) :- atomic(Term), I. ground(Term) :- var(Term), I, fail. ground([H|T]) :- I, ground(H), ground(T). Hana Rudová, Logické programování I, 15. kvetna 2013 84 Vestavené predikáty Rekuřzivní řozklad teřmu & Term je promenná (var/1), atom nebo císlo (atomic/1) == konec rozkladu Term je seznam ([_|_]) == []... řešen výše jako atomic procházení seznamu a rozklad každého prvku seznamu £ Term je složený (=../2, functor/3) => procházení seznamu argumentu a rozklad každého argumentu ii> Príklad: ground/1 uspeje, pokud v termu nejsou promenné; jinak neuspeje ground(Term) :- atomic(Term), !. ground(Term) :- var(Term), !, fai1. ground([H|T]) :- !, ground(H), ground(T). ground(Term) :- Term =.. [ _Funktor | Argumenty ], ground( Argumenty ). Hana Rudová, Logické programování I, 15. kvetna 2013 84 Vestavené predikáty Rekurzivní rozklad termu & Term je seznam ([_|_]) => [] ... rešen výše jako atomic procházení seznamu a rozklad každého prvku seznamu £ Term je složený (=../2, functor/3) => procházení seznamu argumentu a rozklad každého argumentu ii> Príklad: ground/1 uspeje, pokud v termu nejsou promenné; jinak neuspeje ground(Term) :- atomic(Term), !. ground(Term) :- var(Term), !, fail. ground([H|T]) :- !, ground(H), ground(T). ground(Term) :- Term =.. [ _Funktor | Argumenty ], ground( Argumenty ). ?- ground(s(2,[a(1,3),b,c],X)). ?- ground(s(2,[a(1,3),b,c])). no yes Hana Rudová, Logické programování I, 15. kvetna 2013 84 Vestavené predikáty Příklad: dekompozice termu I. count_term( Integer, Term, N ) urCí poCet výskytů celého Čísla v termu Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty P ř íklad: dekompozice termu I. count_term( Integer, Term, N ) urCí poCet výskytů celého Čísla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty P ríklad: dekompozice termu I. count_term( Integer, Term, N ) urCí poCet výskytů celého Čísla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, 0, N). Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty Příklad: dekompozice termu I. count_term( Integer, Term, N ) urCí poCet výskytU celého Čísla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, 0, N). count_term( X, T, N0, N ) :- integer(T), X = T, 1, N is N0 + 1. Hana Rudová, Logické programování I, 15. května 2013 85 Věstavěné prědikáty Příklad: dekompozice termu I. count_term( Integer, Term, N ) urCí poCet výskytů celého Čísla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, 0, N). count_term( X, T, N0, N ) :- integer(T), X = T, 1, N is N0 + 1. count_term( _, T, N, N ) :- atomic(T), 1. Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty Příklad: dekompozice termu I. count_term( Integer, Term, N ) urCí poCet výskytů celého Čísla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, 0, N). count_term( X, T, N0, N ) :- integer(T), X = T, 1, N is N0 + 1. count_term( _, T, N, N ) :- atomic(T), 1. count_term( _, T, N, N ) :- var(T), 1. Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty Príklad: dekompozice termu I. M count_term( Integer, Term, N ) urCí poCet výskytů celého Čísla v termu ?- count_term( 1, a(1,2,bCx,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, 0, N). count_term( X, T, N0, N ) :- integer(T), X = T, !, N is N0 + 1. count_term( _, T, N, N ) :- atomic(T), !. count_term( _, T, N, N ) :- var(T), !. count_term( X, T, N0, N ) :- T =.. [ _ | Argumenty L Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty Príklad: dekompozice termu I. count_term( Integer, Term, N ) urcí pocet výskytu celého císla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, 0, N). count_term( X, T, N0, N ) :- integer(T), X = T, !, N is N0 + 1. count_term( _, T, N, N ) :- atomic(T), !. count_term( _, T, N, N ) :- var(T), !. count_term( X, T, N0, N ) :- T =.. [ _ | Argumenty ], count_arg( X, Argumenty, N0, N ). Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty P r íklad: dekompoziče termu I. count_term( Integer, Term, N ) ura pocet výskytu celého císla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, O, N). count_term( X, T, NO, N ) :- integer(T), X = T, !, N is NO + 1. count_term( _, T, N, N ) :- atomic(T), !. count_term( _, T, N, N ) :- var(T), !. count_term( X, T, NO, N ) :- T =.. [ _ | Argumenty ], count_arg( X, Argumenty, NO, N ). count_arg( _, [], N, N ). Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty P ríklad: dekompozice termu I. count_term( Integer, Term, N ) urcí pocet výskytu celého císla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, 0, N). count_term( X, T, N0, N ) :- integer(T), X = T, I, N is N0 + 1. count_term( _, T, N, N ) :- atomic(T), I. count_term( _, T, N, N ) :- var(T), I. count_term( X, T, N0, N ) :- T =.. [ _ j Argumenty ], count_arg( X, Argumenty, N0, N ). count_arg( _, [], N, N ). count_arg( X, [H j T], N0, N) :- count_term( X, H, 0, N1), Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavěné predikáty P ríklad: dekompozice termu I. count_term( Integer, Term, N ) ura pocet výskytu celého císla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, 0, N). count_term( X, T, N0, N ) :- integer(T), X = T, !, N is N0 + 1. count_term( _, T, N, N ) :- atomic(T), !. count_term( _, T, N, N ) :- var(T), !. count_term( X, T, N0, N ) :- T =.. [ _ | Argumenty ], count_arg( X, Argumenty, N0, N ). count_arg( _, [], N, N ). count_arg( X, [H | T], N0, N) :- count_term( X, H, 0, N1), N2 is N0 + N1, Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty P r íklad: dekompoziče termu I. count_term( Integer, Term, N ) ura pocet výskytů celého císla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, O, N). count_term( X, T, NO, N ) :- integer(T), X = T, !, N is NO + 1. count_term( _, T, N, N ) :- atomic(T), !. count_term( _, T, N, N ) :- var(T), !. count_term( X, T, NO, N ) :- T =.. [ _ | Argumenty ], count_arg( X, Argumenty, NO, N ). count_arg( _, [], N, N ). count_arg( X, [ H | T ], NO, N ) :- count_term( X, H, O, N1), N2 is NO + N1, count_arg( X, T, N2, N ). Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty P r íklad: dekompozice termu I. count_term( Integer, Term, N ) urcí pocet výskytů celého císla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, 0, N). count_term( X, T, N0, N ) :- integer(T), X = T, I, N is N0 + 1. count_term( _, T, N, N ) :- atomic(T), I. count_term( _, T, N, N ) :- var(T), I. count_term( X, T, N0, N ) :- T =.. [ _ | Argumenty ], count_arg( X, Argumenty, N0, N ). count_arg( _, [], N, N ). count_arg( X, [ H | T ], N0, N ) :- count_term( X, H, 0, N1), N2 is N0 + N1, count_arg( X, T, N2, N ). ?- count_term( 1, [a,2,[b,c],[d,[e,f],Y]], N ). Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty Príklad: dekompozice termu I. count_term( Integer, Term, N ) urcí pocet výskytů celého císla v termu ?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2 count_term( X, T, N ) :- count_term( X, T, 0, N). count_term( X, T, N0, N ) :- integer(T), X = T, !, N is N0 + 1. count_term( _, T, N, N ) :- atomic(T), !. count_term( _, T, N, N ) :- var(T), !. count_term( X, T, N0, N ) :- T =.. [ _ | Argumenty ], count_arg( X, Argumenty, N0, N ). count_arg( _, [], N, N ). count_arg( X, [ H | T ], N0, N ) :- count_term( X, H, 0, N1), N2 is N0 + N1, count_arg( X, T, N2, N ). ?- count_term( 1, [a,2,[b,c],[d,[e,f],Y]], N ). count_term( X, T, N0, N ) :- T = [_|_], !, count_arg( X, T, N0, N ). klauzuli p r idáme pred poslední klauzuli count_term/4 Hana Rudová, Logické programování I, 15. kvetna 2013 85 Vestavené predikáty Cvičení: dekompozice termu Napište predikát substitute( Podterm, Term, Podterml, Terml), ktěrý nahradí všechny výskyty Podterm v Term těrměm Podterml a výslěděk vrátí v Terml & Pr ědpokládějtě, žě Term a Podterm jsou těrmy běz proměnných & ?- substitute( sin(x), 2*sin(x)*f(sin(x)), t, F ). F=2*t*f(t) Hana Rudová, Logické programování I, 15. května 2013 86 Věstavěné prědikáty Technika a styl programování v Prologu Technika a styl programování v Prologu Styl programování v Prologu s některá pravidla správného stylu & správný vs. špatný styl a komentáre -í* Ladění -í* Efektivita Hana Rudová, Logické programování I, 15. května 2013 88 Technika a styl programování v Prologu Styl programování v Prologu I. ií> Cílem stylistických konvencí je ± redukce nebezpecí programovacích chyb a psaní citelných a srozumitelných programů, které se dob r e ladí a modifikují Hana Rudová, Logické programování I, 15. kvetna 2013 89 Technika a styl programování v Prologu Styl programování v Prologu I. ií> Cílem stylistických konvencí je ± redukce nebezpecí programovacích chyb a psaní citelných a srozumitelných programů, které se dob r e ladí a modifikují ii> Nekterá pravidla správného stylu -i* krátké klauzule -fc krátké procedury; dlouhé procedury pouze s uniformní strukturou (tabulka) Hana Rudová, Logické programování I, 15. kvetna 2013 89 Technika a styl programování v Prologu Styl programování v Prologu I. ií> Cílem stylistických konvencí je ± redukce nebezpecí programovacích chyb a psaní citelných a srozumitelných programu, které se dob r e ladí a modifikují ii> Nekterá pravidla správného stylu -i* krátké klauzule -fc krátké procedury; dlouhé procedury pouze s uniformní strukturou (tabulka) -i- klauzule se základními (hranicními) p r ípady psát p r ed rekurzivními klauzulemi vhodná jmena procedur a promenných nepoužívat seznamy ([...]) nebo závorky ({...}, (...)) pro termy pevné arity a vstupní argumenty psát p r ed výstupními Hana Rudová, Logické programování I, 15. kvetna 2013 89 Technika a styl programování v Prologu Styl programování v Prologu I. ií> Cílem stylistických konvencí je ± redukce nebezpecí programovacích chyb a psaní citelných a srozumitelných programů, které se dob r e ladí a modifikují ii> Nekterá pravidla správného stylu -i* krátké klauzule -fc krátké procedury; dlouhé procedury pouze s uniformní strukturou (tabulka) -i- klauzule se základními (hranicními) p r ípady psát p r ed rekurzivními klauzulemi vhodná jmena procedur a promenných nepoužívat seznamy ([...]) nebo závorky ({...}, (...)) pro termy pevné arity a vstupní argumenty psát p r ed výstupními ± struktura programu - jednotné konvence v rámci celého programu, nap r . mezery, prázdné rádky, odsazení klauzule stejné procedury na jednom míste; prázdné rádky mezi klauzulemi; každý cíl na zvláštním rádku Hana Rudová, Logické programování I, 15. kvetna 2013 89 Technika a styl programování v Prologu Správný styl programování JS* konstrukce setrídeného seznamu Seznam3 ze setříděných seznamu Seznaml, Seznam2: merge( Seznaml, Seznam2, Seznam3 ) M merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] ) Hana Rudová, Logické programování I, 15. kvetna 2013 90 Technika a styl programování v Prologu Správný styl programování ü> konstrukce setrídeného seznamu Seznam3 ze setříděných seznamu Seznaml, Seznam2: merge( Seznaml, Seznam2, Seznam3 ) M merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] ) JS> merge( [], Seznam, Seznam ) :- Hana Rudová, Logické programování I, 15. kvetna 2013 90 Technika a styl programování v Prologu Správný styl programování -í* konstrukce setrídeného seznamu Seznam3 ze setrídených seznamu Seznaml, Seznam2: merge( Seznaml, Seznam2, Seznam3 ) M merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] ) JS> merge( [], Seznam, Seznam ) :- I. % prevence redundantních r ešení Hana Rudová, Logické programování I, 15. kvetna 2013 90 Technika a styl programování v Prologu Správný styl programování -í* konstrukce setrídeného seznamu Seznam3 ze setříděných seznamů Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 ) M merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] ) JS> merge( [], Seznam, Seznam ) :- 1. % prevence redundantních r ešení merge( Seznam, [], Seznam ). Hana Rudová, Logické programování I, 15. května 2013 90 Technika a styl programování vPrologu Správný styl programování -í* konstrukce setrídeného seznamu Seznam3 ze setříděných seznamu Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 ) M merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] ) JS> merge( [], Seznam, Seznam ) :- 1. % prevence redundantních r ešení merge( Seznam, [], Seznam ). merge( [X|Te1o1], [Y|Te1o2], [X|Te1o3] ) :- Hana Rudová, Logické programování I, 15. kvetna 2013 90 Technika a styl programování v Prologu Správný styl programování -í* konstrukce setříděného seznamu Seznam3 ze setříděných seznamů Seznámí, Seznam2: merge( Seznaml, Seznam2, Seznam3 ) M merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] ) JS> merge( [], Seznam, Seznam ) :- I. % prevence redundantních ř ešení merge( Seznam, [], Seznam ). merge( [X|Te1oí], [Y|Te1o2], [X|Te1o3] ) :-X < Y, I, Hana Rudová, Logické programování I, 15. kvetna 2013 90 Technika a styl programování v Prologu Správný styl programování -í* konstrukce setrídeného seznamu Seznam3 ze setrídených seznamů Seznaml, Seznam2: merge( Seznaml, Seznam2, Seznam3 ) M merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] ) JS> merge( [], Seznam, Seznam ) :- I. % prevence redundantních r ešení merge( Seznam, [], Seznam ). merge( [X|Te1o1], [Y|Te1o2], [X|Te1o3] ) :-X < Y, I, merge( Te1o1, [Y|Te1o2], Te1o3 ). Hana Rudová, Logické programování I, 15. kvetna 2013 90 Technika a styl programování v Prologu Správný styl programování -í* konstrukce setříděného seznamu Seznam3 ze setříděných seznamů Seznámí, Seznam2: merge( Seznaml, Seznam2, Seznam3 ) M merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] ) JS> merge( [], Seznam, Seznam ) :- I. % prevence redundantních ř ešení merge( Seznam, [], Seznam ). merge( [X|Te1oí], [Y|Te1o2], [X|Te1o3] ) :-X < Y, I, merge( Telol, [Y|Te1o2], Te1o3 ). merge( Seznaml, [Y|Te1o2], [Y|Te1o3] ) :- Hana Rudová, Logické programování I, 15. kvetna 2013 90 Technika a styl programování v Prologu Správný styl programování -í* konstrukce setříděného seznamu Seznam3 ze setříděných seznamu Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 ) M merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] ) JS> merge( [], Seznam, Seznam ) :- 1. % prevence redundantních ř ešení merge( Seznam, [], Seznam ). merge( [X|Te1o1], [Y|Te1o2], [X|Te1o3] ) :-X < Y, 1, merge( Te1o1, [Y|Te1o2], Te1o3 ). merge( Seznam1, [Y|Te1o2], [Y|Te1o3] ) :-merge( Seznam1, Te1o2, Te1o3 ). Hana Rudová, Logické programování I, 15. kvetna 2013 90 Technika a styl programování v Prologu Špatný styl programování merge( S1, S2, S3 ) :- 51 = [], I, S3 = S2; 52 = [], I, S3 = S1; 51 = [X|T1], 52 = [Y|T2], ( X < Y, I, Z = X, merge( T1, S2, T3 ); Z = Y, merge( S1, T2, T3) ), 53 = [ Z | T3 ]. % první seznam je prázdný % druhý seznam je prázdný % Z je hlava seznamu S3 Hana Rudová, Logické programování I, 15. kvetna 2013 91 Technika a styl programování vPrologu Styl programování v Prologu II. & Středník „;" mUže způsobit nesrozumitelnost klauzule a nedávat st r edník na konec rádku, používat závorky J* v některých p r ípadech: rozdělení klauzle se st r edníkem do více klauzulí Hana Rudová, Logické programování I, 15. kvetna 2013 92 Technika a styl programování v Prologu Styl programování v Prologu II. & Středník „;" muže způsobit nesrozumitelnost klauzule a nedávat st r edník na konec rádku, používat závorky iľ v nekterých p r ípadech: rozdelení klauzle se st r edníkem do více klauzulí & Opatrné používání operátoru rezu -fc preferovat použití zeleného r ezu (nemení deklarativní sémantiku) S cervený rez používat v jasne definovaných konstruktech negace: P, !, fail; true \+ P alternativy: Podminka, !, Cill ; Cil2 Podminka -> Cill ; Cil2 Hana Rudová, Logické programování I, 15. kvetna 2013 92 Technika a styl programování v Prologu Styl programování v Prologu II. & Středník „;" muže způsobit nesrozumitelnost klauzule a nedávat st r edník na konec rádku, používat závorky iľ v některých p r ípadech: rozdělení klauzle se st r edníkem do více klauzulí & Opatrné používání operátoru rezu -fc preferovat použití zeleného r ezu (nemění deklarativní sémantiku) S cervený rez používat v jasně definovaných konstruktech negace: P, I, fail; true \+ P alternativy: Podminka, I, Cil1 ; Cil2 Podminka -> Cil1 ; Cil2 & Opatrné používání negace „\+" a negace jako neúspěch: negace není ekvivalentní negaci v matematické logice Hana Rudová, Logické programování I, 15. kvetna 2013 92 Technika a styl programování v Prologu Styl programování v Prologu II. & Stredník „;" muže způsobit nesrozumitelnost klauzule a nedávat st r edník na konec rádku, používat závorky iľ v nekterých p r ípadech: rozdelení klauzle se st r edníkem do více klauzulí & Opatrné používání operátoru rezu -fc preferovat použití zeleného r ezu (nemení deklarativní sémantiku) -i- cervený rez používat v jasne definovaných konstruktech & Opatrné používání negače „\+" a negace jako neúspech: negace není ekvivalentní negaci v matematické logice & Pozor na assert a retract: snižuji transparentnost chování programu negace: P, !, fail; true alternativy: Podminka, !, Cill ; Cil2 Podminka -> Cill ; Cil2 \+ P Hana Rudová, Logické programování I, 15. kvetna 2013 92 Technika a styl programování vPrologu Dokumentace a komentá ře C co program delá, jak ho používat (jaký cíl spustit a jaké jsou ocekávané výsledky), p ríklad použití Hana Rudová, Logické programování I, 15. kvetna 2013 93 Technika a styl programování v Prologu Dokumentace a komentáre C co program dělá, jak ho používat (jaký cíl spustit a jaké jsou oCěkávané výslědky), p ríklad použití & ktěré prědikáty jsou hlavní (top-level) Hana Rudová, Logické programování I, 15. května 2013 93 Technika a styl programování vPrologu Dokumentace a komentá ře C co program delá, jak ho používat (jaký cíl spustit a jaké jsou ocekávané výsledky), p ríklad použití -í* které predikáty jsou hlavní (top-level) & jak jsou hlavní koncepty (objekty) reprezentovány Hana Rudová, Logické programování I, 15. kvetna 2013 93 Technika a styl programování v Prologu Dokumentace a komentá ře C co program delá, jak ho používat (jaký cíl spustit a jaké jsou ocekávané výsledky), p ríklad použití -í* které predikáty jsou hlavní (top-level) & jak jsou hlavní koncepty (objekty) reprezentovány & doba výpoctu a pamet'ové nároky Hana Rudová, Logické programování I, 15. kvetna 2013 93 Technika a styl programování v Prologu Dokumentace a komentáre C co program delá, jak ho používat (jaký cíl spustit a jaké jsou ocekávané výsledky), p ríklad použití -í* které predikáty jsou hlavní (top-level) & jak jsou hlavní koncepty (objekty) reprezentovány & doba výpoctu a pameťové nároky JS> jaké jsou limitace programu Hana Rudová, Logické programování I, 15. kvetna 2013 93 Technika a styl programování vPrologu Dokumentace a komentáre C co program delá, jak ho používat (jaký cíl spustit a jaké jsou ocekávané výsledky), p ríklad použití & které predikáty jsou hlavní (top-level) & jak jsou hlavní koncepty (objekty) reprezentovány & doba výpoctu a pamet'ové nároky JS> jaké jsou limitace programu ifc zda jsou použity nejaké speciální rysy závislé na systému Hana Rudová, Logické programování I, 15. kvetna 2013 93 Technika a styl programování v Prologu Dokumentace a komentáre C co program dělá, jak ho používat (jaký cíl spustit a jaké jsou ocěkávané výslědky), p ríklad použití & ktěré prědikáty jsou hlavní (top-level) & jak jsou hlavní koncěpty (objěkty) rěprězěntovány & doba výpoctu a paměťové nároky JS> jaké jsou limitacě programu ifc zda jsou použity nějaké spěciální rysy závislé na systému & jaký jě význam prědikátu v programu, jaké jsou jějich arguměnty, ktěré jsou vstupní a ktěré výstupní (pokud vímě) iť vstupní arguměnty „+", výstupní „-" merge( +Seznam1, +Seznam2, -Seznam3 ) JmenoPredikatu/Arita merge/3 Hana Rudová, Logické programování I, 15. května 2013 93 Technika a styl programování vPrologu Dokumentace a komentáre C co program delá, jak ho používat (jaký cíl spustit a jaké jsou ocekávané výsledky), p ríklad použití & které predikáty jsou hlavní (top-level) & jak jsou hlavní koncepty (objekty) reprezentovány & doba výpoctu a pamet'ové nároky JS> jaké jsou limitace programu zda jsou použity nejaké speciální rysy závislé na systému & jaký je význam predikátu v programu, jaké jsou jejich argumenty, které jsou vstupní a které výstupní (pokud víme) i* vstupní argumenty „+", výstupní „-" merge( +Seznam1, +Seznam2, -Seznam3 ) Jt JmenoPredikatu/Arita merge/3 algoritmické a implementacní podrobnosti Hana Rudová, Logické programování I, 15. kvetna 2013 93 Technika a styl programování v Prologu Ladení Pr epínace na trasování: trace/0, notrace/0 & Trasování specifického predikátu: spy/1, nospy/1 -i- spy( merge/3 ) JS> debug/0, nodebug/0: pro trasování pouze predikátu zadaných spy/1 Hana Rudová, Logické programování I, 15. kvetna 2013 94 Technika a styl programování v Prologu M Pr epínace na trasování: trace/0, notrace/0 & Trasování specifického predikátu: spy/1, nospy/1 -i- spy( merge/3 ) & debug/0, nodebug/0: pro trasování pouze predikátů zadaných spy/1 -i* Libovolná cást programu může být spuštena zadáním vhodného dotazu: trasování cíle 3 vstupní informace: jméno predikátu, hodnoty argumentu p r i volání výstupní informace p r i úspechu hodnoty argumentů splnující cíl p r i neuspechu indikace chyby -i- nové vyvolání p r es stejný cíl je volán p r i backtrackingu Hana Rudová, Logické programování I, 15. kvetna 2013 94 Technika a styl programování v Prologu Krabickový (4-branový) model Vizualizace rídícího toku (backtrackingu) na úrovni predikátu Call: volání cíle Exit: úspešné ukoncení volání cíle Fail: volání cíle neuspelo Redo: jeden z následujících cílů neuspel a systém backtrackuje, aby nalezl alternativy k p redchozímu rešení __________________________________________ Call I -----------------> + predek( X, Z ) i- rodic( X, Z ). I I predek( X, Z ) i- rodic( X, Y ), I Exit <----------------- + Fail I predek( Y, Z). + --------- > I I + <--------- I Redo __________________________________________ Hana Rudová, Logické programování I, 15. kvetna 2013 95 Technika a styl programování v Prologu Pr íklad: trasování a(X) i- nonvar(X). a(X) i- c(X). a(X) i- d(X). c(X). d(2). __________________/\ Ca11 j j Exit ------> + a(X) i- nonvar(X).j ------> j a(X) i- c(X). j <------+ a(X) i- d(X). + <------ Fai1 j j Redo ___________________/\ Hana Rudová, Logické programování I, 1S. kvetna 2013 96 Technika a styl programování v Prologu Příklad: trasování a(X) i- nonvar(X). a(X) i- c(X). a(X) i- d(X). c(X). d(2). j ľ- a(X). X 2 2 X Calli a(_463) ľ 2 Calli nonvar(_463) ľ 2 Faili nonvar(_463) ľ __________________/\ Ca11 j j Exit ------> + a(X) i- nonvar(X).j ------> j a(X) i- c(X). j <------+ a(X) i- d(X). + <------ Fai1 j j Redo ___________________/\ Hana Rudová, Logické programování I, 1S. kvetna 2G13 96 Technika a styl programování v Prologu Př íklad: trasovaní a(X) ;- nonvar(X). I ?- a(X). a(X) ;- c(X). 1 1 Call: a(_463) ? a(X) ;- d(X). 2 2 Call: nonvar(_463) ? c(1). 2 2 Fail: nonvar(_463) ? d(2). 3 2 Call: c(_463) ? 3 2 Exit: c(1) ? ? 1 1 Exit: a(1) ? Call I I Exit ------> + a(X) :- nonvar(X).| ------> I a(X) :- c(X). I <------+ a(X) :- d(X). + <------ Fail I I Redo ___________________/\ X = 1 ? Hana Rudová, Logické programování I, 15. kvetna 2013 96 Technika a styl programování v Prologu Pr íklad: trasování a(X) i- nonvar(X). I ľ- a(X). a(X) i- c(X). 1 1 Calli a(_463) ľ a(X) i- d(X). 2 2 Calli nonvar(_463) ľ c(1). 2 2 Faili nonvar(_463) ľ d(2). 3 2 Calli c(_463) ľ 3 2 Exiti c(1) ľ ľ 1 1 Exiti a(1) ľ Call I I Exit X = 1 ľ; > ------ > + a(X) i- nonvar(X).| ------> 1 1 Redoi a(1) ľ I a(X) i- c(X). I 4 2 Calli d(_463) ľ <------+ a(X) i- d(X). + <------ Fail I I Redo ___________________/\ Hana Rudová, Logické programování I, 15. kvetna 2013 96 Technika a styl programování v Prologu Příklad: trasování a(X) :- nonvar(X). I ľ- a(X). a(X) :- cCX). 1 1 Call: aC_463) ľ a(X) :- dCX). 2 2 Call: nonvar(_463) ľ c(1). 2 2 Fail: nonvar(_463) ľ d(2). 3 2 Call: cC_463) ľ 3 2 Exit: cC1) ľ ľ 1 1 Exit: aC1) ľ Call II Exit X=1 ľ ■ > ------> + a(X) nonvar(X).I ------> 1 1 Redo: aC1) ľ I a(X) :- c(X). I 4 2 Call: dC_463) ľ <------ + a(X) :- d(X). + <------ 4 2 Exit: dC2) ľ Fail II Redo 1 1 Exit: aC2) ľ X = 2 ľ ■ > no % trace I ľ- Hana Rudová, Logické programování I, 15. května 2013 96 Technika a styl programování v Prologu Efektivita -í* Cas výpoctu, paměťové nároky, a také casové nároky na vývoj programu 3 u Prologu mužeme castěji narazit na problémy s casem výpoctu a pamětí a Prologovské aplikace redukují cas na vývoj ± vhodnost pro symbolické, nenumerické výpocty se strukturovanými objekty a relacemi mezi nimi Hana Rudová, Logické programování I, 15. května 2013 97 Technika a styl programování v Prologu Efektivita -í* Cas výpoctu, pamet'ové nároky, a také casové nároky na vývoj programu 3 u Prologu mužeme casteji narazit na problémy s casem výpoctu a pametí a Prologovské aplikace redukují cas na vývoj ± vhodnost pro symbolické, nenumerické výpocty se strukturovanými objekty a relacemi mezi nimi & Pro zvýšení efektivity je nutno se zabývat procedurálními aspekty &> zlepšení efektivity p r i prohledávání odstranení zbytecného backtrackingu zrušení provádení zbytecných alternativ co nejd r íve a návrh vhodnejších datových struktur, které umožní efektivnejší operace s objekty Hana Rudová, Logické programování I, 15. kvetna 2013 97 Technika a styl programování v Prologu Zlepšení efektivity: základní techniky Optimalizace posledního volání (LCO) a akumulátory Rozdílové seznamy p r i spojování seznamů Caching: uložení vypocítaných výsledků do programové databáze Hana Rudová, Logické programování I, 15. kvetna 2013 98 Technika a styl programování vPrologu Zlepšení efektivity: základní techniky Optimalizace posledního volání (LCO) a akumulátory Rozdílové seznamy p r i spojování seznamů Caching: uložení vypocítaných výsledku do programové databáze Indexace podle prvního argumentu a nap r . v SICStus Prologu J> p r i volání predikátu s prvním nainstaniovaným argumentem se používá hašovací tabulka zp r ístupnující pouze odpovídající klauzule zamestnanec( Prijmem', KrestniJmeno, Oddelení', ...) -i- seznamy( [], ...) :- ... . seznamy( [H|T], ...) :- ... . Hana Rudová, Logické programování I, 15. kvetna 2013 98 Technika a styl programování v Prologu Zlepšení efektivity: základní tečhniky Optimalizače posledního volání (LCO) a akumulátory & Rozdílové seznamy p r i spojování seznamů JS> Cačhing: uložení vypocítaných výsledků do programové databáze & Indexače podle prvního argumentu a nap r . v SICStus Prologu J> p r i volání predikátu s prvním nainstaniovaným argumentem se používá hašovací tabulka zp r ístupnující pouze odpovídající klauzule zamestnanec( Prijmeni, KrestniJmeno, Oddeleni, ...) -i- seznamy( [], ...) :- ... . seznamy( [H|T], ...) :- ... . Determinismus: -** rozhodnout, které klauzule mají uspet vícekrát, ove r it požadovaný determinismus Hana Rudová, Logické programování I, 15. kvetna 2013 98 Technika a styl programování v Prologu Rezoluce v predikátové logice 1. rádu Rezoluce rezolucní princip: z F v A, G v -A odvodit F v G JS> dokazovací metoda používaná a v Prologu a ve vetšine systému pro automatické dokazování Hana Rudová, Logické programování I, 15. kvetna 2013 100 Rezoluce v PL1 Rezoluce ü> rezoluCní princip: z F v A, G v -A odvodit F v G JS> dokazovací metoda používaná a v Prologu a ve vetšine systému pro automatické dokazování procedura pro vyvrácení a hledáme dukaz pro negaci formule snažíme se dokázat, že negace formule je nesplnitelná => formule je vždy pravdivá Hana Rudová, Logické programování I, 15. kvetna 2013 100 Rezoluce v PL1 Formule M literál l s* pozitivní literál = atomická formule p(t\, • • • ,tn) ť negativní literál = negace atomické formule —p(t1, • • • ,tn) t1, • • • ,tn jsou termy Hana Rudová, Logické programování I, 15. kvetna 2013 101 Rezoluce vPL1 Formule M literál l s* pozitivní literál = atomická formule p(t1, • • • ,tn) ť negativní literál = negace atomické formule —p(t1, • • • ,tn) t1, • • • ,tn jsou termy klauzule C = konecná množina literálů reprezentující jejich disjunkci príklad: p(X) v q(a,f) v -p(Y) notace: {p (X), q(a, f),-p(Y)} -i- klauzule je pravdivá <=> je pravdivý alespon jeden z jejích literálů prázdná klauzule se znací □ a je vždy nepravdivá (neexistuje v ní pravdivý literál) Hana Rudová, Logické programování I, 15. kvetna 2013 101 Rezoluce v PL1 Formule M literál l s* pozitivní literál = atomická formulě p(t1, • • • ,tn) ť negativní literál = něgacě atomické formulě —p(t1, • • • ,tn) t1, • • • ,tn jsou těrmy klauzule C = koněcná množina litěrálů rěprězěntující jějich disjunkci príklad: p(X) v q(a,f) v -p(Y) notacě: {p (X), q(a, f),-p(Y)} -i- klauzule je pravdivá <=> jě pravdivý alěspon jěděn zjějích litěrálů prázdná klauzule sě znací □ a jě vždy něpravdivá (něěxistujě v ní pravdivý litěrál) -í* formule F = množina klauzulí rěprězěntující jějich konjunkci a formulě jě v tzv. konjuktivní normální formě (konjunkcě disjunkcí) i> príklad: (p v q) a (-p) a (p v-q v r) notacě: {{p, q}, {-p}, {p, -q,r}} Hana Rudová, Logické programování I, 15. května 2013 101 Rězolucě v PL1 Formule M literál l s* pozitivní literál = atomická formule p(t1, • • • ,tn) ť negativní literál = negace atomické formule -p(ti, • • • ,tn) t1, • • • ,tn jsou termy klauzule C = konecná množina literálů reprezentující jejich disjunkci príklad: p(X) v q(a,f) v -p(Y) notace: {p (X), q(a, f),-p(Y)} -i- klauzule je pravdivá <=> je pravdivý alespon jeden z jejích literálů prázdná klauzule se znací □ a je vždy nepravdivá (neexistuje v ní pravdivý literál) -í* formule F = množina klauzulí reprezentující jejich konjunkci A formule je v tzv. konjuktivní normální forme (konjunkce disjunkcí) i> príklad: (p v q) a (-p) a (p v-q v r) notace: {{p, q}, {-p}, {p, -q,r}} A formule je pravdivá <=> všechny klauzule jsou pravdivé J> prázdná formule je vždy pravdivá (neexistuje klauzule, která by byla nepravdivá) Hana Rudová, Logické programování I, 15. kvetna 2013 101 Rezoluce v PL1 Formule M literál l s* pozitivní literál = atomická formule p(t1, • • • ,tn) ť negativní literál = negace atomické formule —p(t1, • • • ,tn) t1, • • • ,tn jsou termy klauzule C = konecná množina literálů reprezentující jejich disjunkci p r íklad: p(X) v q(a,f) v -p(Y) notace: {p (X), q(a, f),-p(Y)} -i- klauzule je pravdivá <=> je pravdivý alespon jeden z jejích literálů J* prázdná klauzule se znací □ a je vždy nepravdivá (neexistuje v ní pravdivý literál) -í* formule F = množina klauzulí reprezentující jejich konjunkci A formule je v tzv. konjuktivní normální forme (konjunkce disjunkcí) i> príklad: (p v q) a (-p) a (p v-q v r) notace: {{p, q}, {-p}, {p, -q,r}} A formule je pravdivá <=> všechny klauzule jsou pravdivé J> prázdná formule je vždy pravdivá (neexistuje klauzule, která by byla nepravdivá) & množinová notace: literál je prvek klauzule, klauzule je prvek formule, ... Hana Rudová, Logické programování I, 15. kvetna 2013 101 Rezoluce v PL1 Splnitelnost -i* [Opakování:] Interpretace I jazyka L je dána univerzem D a zobrazením, které p r i radí konstante c prvek D, funkcnímu symbolu f/n n-ární operaci v D a predikátovému symbolu p/n n-ární relaci. p r íklad: F ={{f(a,b) = f (b,a)}, {f(f(a,a),b) = a}} interpretace ?i: D = Z, a := 1,b := -1,f := " + " Hana Rudová, Logické programování I, 15. kvetna 2013 102 Rezoluce v PL1 Splnitelnost -i* [Opakování:] Interpretace I jazyka L je dána univerzem D a zobrazením, které p r i radí konstante c prvek D, funkCnímu symbolu f/n n-ární operaci v D a predikátovému symbolu p/n n-ární relaci. p r íklad: F ={{f(a,b) = f (b,a)}, {f(f(a,a),b) = a}} interpretace 11: D = Z,a := 1,b := -1,f := " + " -í* Formule je splnitelná, existuje-li interpretace, pro kterou je pravdivá a formule je konjunkce klauzulí, tj. všechny klauzule musí být v dané interpretaci pravdivé ± p r íklad (pokraC): F je splnitelná (je pravdivá v I1) Hana Rudová, Logické programování I, 15. kvetna 2013 102 Rezoluce v PL1 Splnitelnost -i* [Opakování:] Interpretace I jazyka L je dána univerzem D a zobrazením, které p r i radí konstante c prvek D, funkCnímu symbolu f/n n-ární operaci v D a predikátovému symbolu p/n n-ární relaci. p r íklad: F ={{f(a,b) = f (b,a)}, {f(f(a,a),b) = a}} interpretace ?i: D = Z, a := 1,b := -1,f := " + " JS> Formule je splnitelná, existuje-li interpretace, pro kterou je pravdivá a formule je konjunkce klauzulí, tj. všechny klauzule musí být v dané interpretaci pravdivé ± p r íklad (pokraC): F je splnitelná (je pravdivá v I1) & Formule je nesplnitelná, neexistuje-li interpretace, pro kterou je pravdivá tj. formule je ve všech iterpretacích nepravdivá -i- tj. neexistuje interpretace, ve které by byly všechny klauzule pravdivé J* p r íklad: G = {{p(b)}, {p(a)}, {-p(a)}} je nesplnitelná ({p(a)} a {-p(a)} nemohou být zároven pravdivé) Hana Rudová, Logické programování I, 15. kvetna 2013 102 Rezoluce v PL1 Rezoluční princip ve výrokové logice M Rezoluční princip = pravidlo, které umožňuje odvodit z klauzulí C1 u {l} a {-l} u C2 klauzuli C1 u C2 Ci u {l} {-l} u C2 Ci u C2 C1 u C2 se ňazývá rezolventou původních klauzulí Hana Rudová, Logické programování I, 15. května 2013 103 Rězolucě vPL1 Rezoluční princip ve výrokové logice Rezoluční princip = pravidlo, které umožňuje odvodit z klauzulí C1 u jí} a j-l} u C2 klauzuli C1 u C2 Ci u jl} j-l} u C2 Ci u C2 C1 u C2 se ňazývá rezolventou puvodňích klauzulí p r íklad: jp,r} j—r,s} (p v r) a (-r v s) jp,s} p v s Hana Rudová, Logické programování I, 15. kvetna 2013 103 Rezoluce vPL1 RezoluCní princip ve výrokové logice RezoluCní princip = pravidlo, které umožnuje odvodit z klauzulí C1 u {l} a {-l} u C2 klauzuli C1 u C2 Ci u {l} {-l} u C2 Ci u C2 C1 u C2 se nazývá rezolventou puvodních klauzulí príklad: {p,r} {-r, s} (p v r) a (-r v s) {p,s} p v s obe klauzule (p v r) a (-r v s) musí být pravdivé protože r nestací k pravdivosti obou klauzulí, musí být pravdivé p (pokud je pravdivé -r) nebo s (pokud je pravdivé r), tedy platí klauzule p v s Hana Rudová, Logické programování I, 15. kvetna 2013 103 Rezoluce v PL1 Rezoluční důkaz rezoluční důkaz klauzule C z formule F je konecná posloupnost Ci,...,Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo rezolventa Cj, Ck pro k,j < i. Hana Rudová, Logické programování I, 15. kvetna 2013 104 Rezoluce v PL1 Rezoluční důkaz rezoluční důkaz klauzule C z formule F jě koněcná posloupnost C1,...,Cn = C klauzulí taková, žě Ct jě bud' klauzulě z F něbo rězolvěnta Cj, Ck pro k,j < t. & príklad: rězolucní důkaz {p} z formulě F = {{p,r}, {q, -r}, {-q}} Hana Rudová, Logické programování I, 15. května 2013 104 Rězolucě vPL1 Rezoluční důkaz rezoluční důkaz klauzule C z formule F je konecná posloupnost C1,...,Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo rezolventa Cj, Ck pro k,j < i. & p ríklad: rezolucní důkaz {p} z formule F = {{p,r}, {g, -r}, {-q}} C1 = {p,r} klauzule z F Hana Rudová, Logické programování I, 15. kvetna 2013 104 Rezoluce vPL1 Rezolucní důkaz rezolucní důkaz klauzule C z formule F je konecná posloupnost C1,...,Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo rezolventa Cj, Ck pro k,j < i. & príklad: rezolucní důkaz {p} z formule F = {{p,r}, {q, -r}, {-q}} C1 = {p,r} klauzule z F C2 = {q, -r} klauzule z F Hana Rudová, Logické programování I, 15. kvetna 2013 104 Rezoluce v PL1 Rezoluční důkaz rezoluční důkaz klauzule C z formule F je konecná posloupnost C\,...,Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo rezolventa Cj, Ck pro k,j < i. & p ríklad: rezolucní důkaz {p} z formule F = {{p,r}, {q, —r}, {-q}} C = {p,r} klauzule z F C2 = {q, —r} klauzule z F C3 = {p, q} rezolventa C\ a C2 Hana Rudová, Logické programování I, 15. května 2013 104 Rezoluce v PL1 Rezolucní důkaz rezolucní důkaz klauzule C z formule F je konecná posloupnost C1,...,Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo rezolventa Cj, Ck pro k,j < i. & príklad: rezolucní důkaz {p} z formule F = {{p,r}, {q, -r}, {-q}} C1 = {p,r} klauzule z F C2 = {q, -r} klauzule z F C3 = {p, q} rezolventa C1 a C2 C4 = {-q} klauzule z F Hana Rudová, Logické programování I, 15. kvetna 2013 104 Rezoluce vPL1 Rezolucní důkaz rezolucní důkaz klauzule C z formule F je konecná posloupnost Ci,...,Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo rezolventa Cj, Ck pro k,j < i. & p ríklad: rezolucní důkaz {p} z formule F = {{p,r}, {q, —r}, {-q}} C\ = {p,r} klauzule z F C2 = {q, —r} klauzule z F C3 = {p, q} rezolventa C\ a C2 C4 = {—q} klauzule z F C5 = {p} = C rezolventa C3 a C4 Hana Rudová, Logické programování I, 15. kvetna 2013 104 Rezoluce v PL1 Rezolucní vyvrácení důkaz pravdivosti formule F spocívá v demonstraci nesplnitelnosti -F & -F nesplnitelná == -F je nepravdivá ve všech interpretacích == F je vždy pravdivá Hana Rudová, Logické programování I, 15. kvetna 2G1B 1G5 Rezoluce v PL1 RezoluCní vyvrácení důkaz pravdivosti formule F spocívá v demonstraci nesplnitelnosti -F & -F nesplnitelná == -F je nepravdivá ve všech interpretacích == F je vždy pravdivá —* zacneme-li z klauzulí reprezentujících -F, musíme postupným uplatnováním rezolucního principu dospet k prázdné klauzuli □ C Pr íklad: F...-*av a Hana Rudová, Logické programování I, 15. kvetna 2013 105 Rezoluce v PL1 Rezolucní vyvrácení důkaz pravdivosti formule F spocívá v demonstraci nesplnitelnosti -F & -F nesplnitelná == -F je nepravdivá ve všech interpretacích == F je vždy pravdivá ii> zacneme-li z klauzulí reprezentujících -F, musíme postupným uplatňováním rezolucního principu dospet k prázdné klauzuli □ C Príklad: F... -a v a G = -F.. .a a -a G = -F... {{a}, {-a}} Hana Rudová, Logické programování I, 15. kvetna 2013 105 Rezoluce v PL1 Rezolucní vyvrácení důkaz pravdivosti formule F spocívá v demonstraci nesplnitelnosti -F & -F nesplnitelná = -F je nepravdivá ve všech interpretacích = F je vždy pravdivá ii> zacneme-li z klauzulí reprezentujících -F, musíme postupným uplatňováním rezolucního principu dospet k prázdné klauzuli □ C Príklad: F... -a v a G = -F.. .a A -a G = -F... {{a}, {-a}} Ci = {a},C2 = {-a} rezolventa C1 a C2 je □, tj. F je vždy pravdivá rezolucní důkaz □ z formule G se nazývá rezolucní vyvrácení formule G -i- a tedy G je nepravdivá ve všech interpretacích, tj. G je nesplnitelná Hana Rudová, Logické programování I, 15. kvetna 2013 105 Rezoluce v PL1 Strom rezolučního důkazu strom rezolučního důkazu klauzule C z formule G je binární strom: J* koren je označen klauzulí C, listy jsou označeny klauzulemi z G a i* každý uzel, který není listem, má bezprostředními potomky označené klauzulemi C\ a C2 je označen rezolventou klauzulí C a C2 m príklad: G = {{p,r}, {q, -r}, {-q}, {-p}} C = □ {p,r} {q, -r} {-q} {-p} / / / strom rezolučního vyvrácení (rezoluční důkaz □ z G) Hana Rudová, Logické programování I, 15. května 2013 106 Rezoluce v PL1 Strom rezolučního důkazu strom rezolučního důkazu klauzule C z formule G je binární strom: J* koren je označen klauzulí C, listy jsou označeny klauzulemi z G a i* každý uzel, který není listem, má bezprostředními potomky označené klauzulemi C\ a C2 je označen rezolventou klauzulí C a C2 m príklad: G = {{p,r}, {q, -r}, {-q}, {-p}} C = □ {p,r} {q, -r} {-q} {-p} IM / / / / / strom rezolučního vyvrácení (rezoluční důkaz □ z G) príklad: {{p,r}, {q, -r}, {-q}, {-p, t}, {-s}, {s,-t}} Hana Rudová, Logické programování I, 15. května 2013 106 Rezoluce v PL1 Substituce JS> co s proměnnými? vhodná substituce a unifikace Hana Rudová, Logické programování I, 15. května 2013 107 Rezoluce v PL1 Substituče čo s promennými? vhodná substituče a unifikače f(X,a,g(Y)) < 1,f(h(c),a,Z) < 1, X = h(c),Z = g(Y) => f (h(c), a, g (Y)) < 1 substituče je libovolná funkce 9 zobrazující výrazy do výrazů tak, že platí -i- 9(E) = E pro libovolnou konstantu E 9(f(E1, • • • ,En)) = f(9(E1), • • • , 9(En)) pro libovolný funkcní symbol f -i* 9(p(E1, • • • ,En)) = p(9(E1), • • • , 9(En)) pro libovolný predik. symbol p substituče je tedy homomorfismus výrazu, který začhová vše krome promennýčh - ty lze nahradit címkoliv substituce zapisujeme zpravidla ve tvaru seznamu [X1/^1, • • • ,Xn/^n] kde Xi jsou promenné a "E)i substituované termy príklad: p(X)[X/f(a)] = p(f(a)) Hana Rudová, Logické programování I, 15. kvetna 2013 107 Rezoluce v PL1 Substituce JS> co s promennými? vhodná substituce a unifikace f(X,a,g(Y)) < 1,f(h(c),a,Z) < 1, X = h(c),Z = g(Y) => f(h(c),a,g(Y)) < 1 & substituce je libovolná funkce 9 zobrazující výrazy do výrazů tak, že platí -i- 9(E) = E pro libovolnou konstantu E 9(f(E1, • • • ,En)) = f (9(E\), • • • , 9(En)) pro libovolný funkcní symbol f -i* 9(p(E1, • • • ,En)) = p(9(E1), • • • , 9(En)) pro libovolný predik. symbol p JS> substituce je tedy homomorfismus výrazů, který zachová vše krome promenných - ty lze nahradit címkoliv & substituce zapisujeme zpravidla ve tvaru seznamu [X1/^1, • • • ,Xn/^n] kde Xi jsou promenné a "E)i substituované termy príklad: p(X)[X/f(a)] = p(f(a)) & prejmenování promenných: speciální náhrada promenných promennými príklad: p(X)[X/Y] = p(Y) Hana Rudová, Logické programování I, 15. kvetna 2013 107 Rezoluce v PL1 Unifikace Ztotožnění dvou litěrálu p, q pomocí vhodné substitucě a takové, žě pa = qa nazývámě unifikací a príslušnou substituci unifikátorem. Unifikátorem množiny S litěrál u nazývámě substitucě 0 takovou, žě množina S0 = {t0\t g S} má jědiný prvěk. Hana Rudová, Logické programování I, 15. května 2013 108 Rězolucě vPL1 Unifikace Ztotožnení dvou literálu p, q pomocí vhodné substituce a takové, že pa = qa nazýváme unifikací a p ríslušnou substituci unifikátorem. & Unifikátorem množiny S literálů nazýváme substituce 0 takovou, že množina se = {t0it g s} má jediný prvek. p r íklad: S = { datum( D1, M1, 2003 ), datum( 1, M2, Y2) } unifikátor 0 = [D1/1, M1/2, M2/2, Y2/2003] S0 = { datum( 1, 2, 2003 ) } Hana Rudová, Logické programování I, 15. kvetna 2013 108 Rezoluce v PL1 Unifikace Ztotožnení dvou literál u p, q pomocí vhodné substituce a takové, že pa = qa nazýváme unifikací a príslušnou substituci unifikátorem. & Unifikátorem množiny S literál u nazýváme substituce 0 takovou, že množina se = {t0it g s} má jediný prvek. príklad: S = { datum( D1, M1, 2003 ), datum( 1, M2, Y2) } unifikátor 0 = [D1/1, M1/2, M2/2, Y2/2003] S0 = { datum( 1, 2, 2003 ) } & Unifikátor a množiny S nazýváme nejobecnejším unifikátorem (mgu - most generál unifier), jestliže pro libovolný unifikátor 0 existuje substituce A taková, že 0 = aA. Hana Rudová, Logické programování I, 15. kvetna 2013 108 Rezoluce v PL1 Unifikace C Ztotožnení dvou literálu p, q pomočí vhodné substituče a takové, že pa = qa nazýváme unifikací a príslušnou substituči unifikátorem. & Unifikátorem množiny S literálu nazýváme substituče 0 takovou, že množina se = {t0\t g s} má jediný prvek. príklad: S = { datum( D1, M1, 2003 ), datum( 1, M2, Y2) } unifikátor 0 = [D1/1, M1/2, M2/2, Y2/2003] S0 = { datum( 1, 2, 2003 ) } & Unifikátor a množiny S nazýváme nejobečnejším unifikátorem (mgu - most generál unifier), jestliže pro libovolný unifikátor 0 existuje substituče A taková, že 0 = aA. a príklad (pokrač.): nejobečnejší unifikátor a = [D1/1, Y2/2003, M1/M2], Hana Rudová, Logičké programování I, 15. kvetna 2013 108 Rezoluče v PL1 Unifikace Ztotožnení dvou literálu p, q pomočí vhodné substituče a takové, že pa = qa nazýváme unifikací a príslušnou substituči unifikátorem. & Unifikátorem množiny S literál u nazýváme substituče 0 takovou, že množina se = {t0\t g s} má jediný prvek. príklad: S = { datum( D1, M1, 2003 ), datum( 1, M2, Y2) } unifikátor 0 = [D1/1, M1/2, M2/2, Y2/2003] S0 = { datum( 1, 2, 2003 ) } & Unifikátor a množiny S nazýváme nejobečnejším unifikátorem (mgu - most generál unifier), jestliže pro libovolný unifikátor 0 existuje substituče A taková, že 0 = aA. príklad (pokrač.): nejobečnejší unifikátor a = [D1/1, Y2/2003, M1/M2], A=[M2/2] Hana Rudová, Logičké programování I, 15. kvetna 2013 108 Rezoluče v PL1 Rezolucní princip v PL1 základ: & rězolucni princip vě výrokové logicě----- Ci u C2 Jť substitucě, unifikátor, nějoběcnější unifikátor Hana Rudová, Logické programování I, 15. května 2013 109 Rězolucě v PL1 Rezolucní princip v PL1 základ: & rezolucní princip ve výrokové logice----- Jť substituce, unifikátor, nejobecnejší unifikátor rezolucní princip v PL1 je pravidlo, které -fc pripraví príležitost pro uplatnení vlastního rezolucního pravidla nalezením vhodného unifikátoru provede rezoluci a získá rezolventu Hana Rudová, Logické programování I, 15. kvetna 2013 109 Rezoluce v PL1 Rezolucní princip v PL1 základ: & rezolucní princip ve výrokové logice----- Ci u C2 Jť substituce, unifikátor, nejobecnejší unifikátor rezolucní princip v PL1 je pravidlo, které -fc pripraví príležitost pro uplatnení vlastního rezolucního pravidla nalezením vhodného unifikátoru provede rezoluci a získá rezolventu Ci u {A} {-B}u C2 Cipa u C2a £> kde p je p rejmenováním promenných takové, že klauzule (Ci u A)p a {B} u C2 nemají spolecné promenné a a je nejobecnejší unifikátor klauzulí Ap a B Hana Rudová, Logické programování I, 15. kvetna 2013 109 Rezoluce v PL1 Príklad: rezoluce v PLI C príklad: Ci = {p(X,Y), q(Y)} C2 = {-q(a), s(X,W)} Hana Rudová, Logické programování I, 15. května 2013 110 Rězolucě vPL1 Príklad: rezoluce v PL1 príklad: Ci = {p(X,Y), q(Y)} C2 = {-q(a), s(X,W)} prejmenování promenných: p = [X/Z] Ci ={p(Z,Y), q(Y)} C2 ={-q(a), s(X,W)} Hana Rudová, Logické programování I, 15. kvetna 2013 110 Rezoluce v PL1 Príklad: rezoluce v PLI príklad: Ci = {p(X,Y), q(Y)} C2 = {-q(a), s(X,W)} prějměnování proměnných: p = [X/Z] Ci ={p(Z,Y), q(Y)} C2 ={-q(a), s(X,W)} nějoběcnější unifikátor: a = [Y/a] Ci = {p(Z,a), q(a)} C2 = {-q(a), s(X,W)} Hana Rudová, Logické programování I, 15. května 2013 110 Rězolucě vPL1 Príklad: rezoluce v PLI príklad: C1 = {p(X,Y), q(Y)} C2 = {-q(a), s(X,W)} prejmenování promenných: p = [X/Z] C1 = {p(Z,Y), q(Y)} C2 = {-q(a), s(X,W)} nejobecnejší unifikátor: a = [Y/a] C1 = {p(Z,a), q(a)} C2 = {-q(a), s(X,W)} rezolucní princip: C = {p(Z,a), s(X,W)} Hana Rudová, Logické programování I, 15. kvetna 2013 110 Rezoluce vPL1 Príklad: rezoluce v PLI príklad: C = {p(X,Y), q(Y)} C2 = {-q(a), s(X,W)} přejmenování promenných: p = [X/Z] C1 ={p(Z,Y), q(Y)} C2 = {-q(a), s(X,W)} nejobecnejší unifikátor: a = [Y/a] C1 = {p(Z,a), q(a)} C2 = {-q(a), s(X,W)} rezolucní princip: C = {p(Z,a), s(X,W)} * vyzkoušejte si: C1 = {q(X), -r (Y), p (X, Y), p (f (Z), f (Z))} C2 = {n(Y), -r(W), -p(f(W),f(W)} Hana Rudová, Logické programování I, 15. kvetna 2013 110 Rezoluce v PL1 Rezoluce v PLI Obecný rezolucní princip v PL1 C1 u {A1, • • • ,Am} {-B1, • • • , -Bn} u C2 C1 pa u C2a & kde p je prejmenováním promenných takové, že množiny klauzulí {A1p, • • • ,Amp, C1p} a {B1, • • • ,Bn, C2} nemají spolecné promenné Jr a je nejobecnejší unifikátor množiny {A1p, • • • ,Amp,B1, • • • ,Bn} Hana Rudová, Logické programování I, 15. kvetna 2013 111 Rezoluce v PL1 Rezoluce v PLI Obecný rezolucní princip v PL1 C1 U {A1, • • • ,Am} {-B1, , -Bn} U C2 C1 pa u C2a & kde p je prejmenováním promenných takové, že množiny klauzulí {A1p, • • • ,Amp, C1p} a {B1, • • • ,Bn, C2} nemají spolecné promenné Jr a je nejobecnejší unifikátor množiny {A1p, • • • ,Amp,B1, • • • ,Bn} príklad: A1 = a(X) vs. {-B1, -B2} = {-a(b), -a(Z)} v jednom kroku potrebuji vyrezolvovat zároven B1 i B2 Hana Rudová, Logické programování I, 15. kvetna 2013 111 Rezoluce vPL1 Rezoluce v PL1 Obecný rezolucní princip v PL1 Ci u {Ai, • • • ,Am} {-Bi, • • • , -Bn} u C2 C1 pa u C2a & kde p je prejmenováním promenných takové, že množiny klauzulí {Aip, • • • ,Amp, Cip} a {Bi, • • • ,Bn, C2} nemají spolecné promenné Jr a je nejobecnejší unifikátor množiny {Aip, • • • ,Amp,Bi, • • • ,Bn} príklad: Ai = a(X) vs. {-Bi, -B2} = {-a(b), -a(Z)} v jednom kroku potrebuji vyrezolvovat zároven Bi i B2 Rezoluce v PL1 a korektní: jestliže existuje rezolucní vyvrácení F, pak F je nesplnitelná & úplná: jestliže F je nesplnitelná, pak existuje rezolucní vyvrácení F Hana Rudová, Logické programování I, 15. kvetna 2013 111 Rezoluce v PL1 Zefektivnení rezoluce rezoluce je intuitivne efektivnejší než axiomatické systémy a axiomatické systémy: který z axiomu a pravidel použít? a rezoluce: pouze jedno pravidlo Hana Rudová, Logické programování I, 15. kvetna 2013 112 Rezoluce v PL1 Zefektivnení rezoluce rezoluče je intuitivne efektivnejší než axiomatičké systémy a axiomatičké systémy: který z axiomu a pravidel použít? a rezoluče: pouze jedno pravidlo stále ale príliš mnoho možností, jak hledat dukaz v prohledávačím prostoru problém SAT= {S\S je splnitelná } NP úplný, ničméne: menší prohledávačí prostor vede k ryčhlejšímu nalezení rešení strategie pro zefektivnení prohledávání => varianty rezoluční metody Hana Rudová, Logičké programování I, 15. kvetna 2013 112 Rezoluče v PL1 Zefektivnení rezoluče $ rezoluce je intuitivne efektivnejší než axiomatické systémy a axiomatické systémy: který z axiomu a pravidel použít? a rezoluce: pouze jedno pravidlo stále ale príliš mnoho možností, jak hledat dukaz v prohledávacím prostoru C- problém SAT= {S|S je splnitelná } NP úplný, nicméne: menší prohledávací prostor vede k rychlejšímu nalezení rešení & strategie pro zefektivnení prohledávání => varianty rezolucní metody & vylepšení prohledávání a zastavit prohledávání cest, které nejsou slibné & specifikace poradí, jak procházíme alternativními cestami Hana Rudová, Logické programování I, 15. kvetna 2013 112 Rezoluce vPL1 Varianty rezolucní metody Veta: Každé omězění rězolucě jě korěktní. J* stálě vímě, žě to, co jsmě dokázali, platí Hana Rudová, Logické programování I, 15. května 2013 113 Rězolucě vPL1 Varianty rezoluční metody Veta: Každé omezení rezoluče je korektní. stále víme, že to, čo jsme dokázali, platí T-rezoluče: klauzule učastníčí se rezoluče nejsou tautologie úplná -i- tautologie nepomuže ukázat, že formule je nesplnitelná Hana Rudová, Logičké programování I, 15. kvetna 2013 113 Rezoluče v PL1 Varianty rezolucní metody Veta: Každé omezení rezoluce je korektní. J* stále víme, že to, co jsme dokázali, platí T-rezoluce: klauzule ucastnící se rezoluce nejsou tautologie úplná -i- tautologie nepomuže ukázat, že formule je nesplnitelná sémantická rezoluce: úplná zvolíme libovolnou interpretaci a pro rezoluci používáme jen takové klauzule, z nichž alespon jednaje v této interpretaci nepravdivá a pokud jsou obe klauzule pravdivé, težko odvodíme nesplnitelnost formule Hana Rudová, Logické programování I, 15. kvetna 2013 113 Rezoluce v PL1 Varianty rezolucní metody Veta: Každé omezení rezoluce je korektní. J* stále víme, že to, co jsme dokázali, platí T-rezoluce: klauzule ucastnící se rezoluce nejsou tautologie úplná -i- tautologie nepomuže ukázat, že formule je nesplnitelná sémantická rezoluce: úplná zvolíme libovolnou interpretaci a pro rezoluci používáme jen takové klauzule, z nichž alespon jednaje v této interpretaci nepravdivá a pokud jsou obe klauzule pravdivé, težko odvodíme nesplnitelnost formule vstupní (input) rezoluce: neúplná alespon jedna z klauzulí, použitá pri rezoluci, je z výchozí vstupní množiny S Hana Rudová, Logické programování I, 15. kvetna 2013 113 Rezoluce v PL1 Varianty rezoluční metody Veta: Každé omezení rezoluče je korektní. stále víme, že to, čo jsme dokázali, platí & T-rezoluče: klauzule učastníčí se rezoluče nejsou tautologie úplná -i- tautologie nepomuže ukázat, že formule je nesplnitelná JS> sémantičká rezoluče: úplná zvolíme libovolnou interpretači a pro rezoluči používáme jen takové klauzule, z ničhž alespon jednaje v této interpretači nepravdivá a pokud jsou obe klauzule pravdivé, težko odvodíme nesplnitelnost formule JS> vstupní (input) rezoluče: neúplná alespon jedna z klauzulí, použitá pri rezoluči, je z výčhozí vstupní množiny S {{p, q}, {-p, q}, {p, -q}, {-p, -q}} existuje rezoluční vyvráčení neexistuje rezoluční vyvráčení pomočí vstupní rezoluče Hana Rudová, Logičké programování I, 15. kvetna 2013 113 Rezoluče v PL1 Rezoluce a logické programování Lineární rezoluce varianta rězolucní mětody a snaha o gěněrování liněární posloupnosti místo stromu v každém kroku kromě prvního mužěmě použít bězprostrědně prědcházějící rězolvěntu a k tomu bud' něktěrou z klauzulí vstupní množiny S něbo něktěrou z prědcházějících rězolvěnt c0^b0 c2 b2 c Hana Rudová, Logické programování I, 15. května 2013 115 Rězolucě a logické programování Lineární rezoluče varianta rezoluční metody snaha o generování lineární posloupnosti místo stromu v každém kroku krome prvního mužeme použít bezprostredne predčházejíčí rezolventu a k tomu bud' nekterou z klauzulí vstupní množiny S nebo nekterou z predčházejíčíčh rezolvent lineární rezoluční důkaz C z S je posloupnost dvojič , ... (Cn,Bn) taková, že C = Cn+i a C0 a každá Bi jsou prvky S nebo nekteré Cj,j < i s» každá Ci+l, i < n je rezolventa Ci a Bi c0^b0 c2 b2 c Hana Rudová, Logičké programování I, 15. kvetna 2013 115 Rezoluče a logičké programování Lineární rezoluce varianta rezolucní metody snaha o generování lineární posloupnosti místo stromu v každém kroku krome prvního mužeme použít bezprostredne predcházející rezolventu a k tomu bud' nekterou z klauzulí vstupní množiny S nebo nekterou z předcházejících rezolvent lineární rezolucní důkaz C z S je posloupnost dvojic Hornova klauzule: nejvýše jeden pozitivní literál {H,-Ti,...,-Tn} {H} {-Ti,...,-Tn} a H V -Ti V ■ ■ ■V -Tn H -Ti V ■ ■ ■V -Tn Hana Rudová, Logičké programování I, lS. kvetna 2Gl3 117 Rezoluče a logičké programování Prologovská notače & Klauzule v matematické logice {h1, ■■■ ,Hm,-T1, ■■■ ,-Tn} H1 V--- V Hm V -t1 V ■ ■ ■ V -tn & Hornova klauzule: nejvýše jeden pozitivní literál {h,-T1,...,-Tn} {H} {-t1,...,-tn} a H V -T1 V ■ ■ ■ V -tn H -T1 V ■ ■ ■ V -tn -i* Pravidlo: jeden pozitivní a alespon jeden negativní literál Prolog: H : - t1, ■ ■ ■ ,Tn. Hana Rudová, Logické programování I, 15. kvetna 2013 117 Rezoluce a logické programování Prologovská notače & Klauzule v matematičké logiče {hi, --- ,Hm,-Ti, --- ,-Tn} Hi v ---v Hm V -ti v - - - v -Tn & Hornova klauzule: nejvýše jeden pozitivní literál {H,-Ti,...,-Tn} {H} {-Ti,...,-Tn} a H v -Ti v - - - v -Tn H -Ti v - - - v -Tn JS> Pravidlo: jeden pozitivní a alespon jeden negativní literál J* Prolog: H : - Ti, - - - ,Tn. Matematičká logika: H <= Ti a - - - a Tn Hana Rudová, Logičké programování I, 15. kvetna 2013 117 Rezoluče a logičké programování Prologovská notace & Klauzule v matematické logice {h1, ■■■ ,Hm,-T1, ■■■ ,-Tn} H1 v--- v Hm v -t1 v ■ ■ ■ v -tn & Hornova klauzule: nejvýše jeden pozitivní literál {h,-T1,...,-Tn} {H} {-t1,...,-tn} a H v -T1 v ■ ■ ■ v -tn H -T1 v ■ ■ ■ v -tn -i* Pravidlo: jeden pozitivní a alespon jeden negativní literál & Prolog: H : - T1, ■ ■ ■ , tn. Matematická logika: H <= t1 a ■ ■ ■ a Tn H <= T Hana Rudová, Logické programování I, 15. kvetna 2013 117 Rezoluce a logické programování Prologovská notace & Klauzulě v matěmatické logicě {hi, --- ,Hm,-Ti, - ,-Tn} Hi v ---v Hm v -Ti v - - - v -Tn & Hornova klauzule: nějvýšě jěděn pozitivní litěrál {H,-Ti,...,-Tn} {H} {-Ti,...,-Tn} a H v -Ti v - - - v -Tn H -Ti v - - - v -Tn JS> Pravidlo: jěděn pozitivní a alěspon jěděn něgativní litěrál J* Prolog: H : - Ti, - - - ,Tn. Matěmatická logika: H <= Ti a - - - a Tn H Hv-T Hana Rudová, Logické programování I, 15. května 2013 117 Rězolucě a logické programování Prologovská notace & Klauzule v matematické logice {H1, ••• ,Hm,-T1, ••• ,-Tn} H1 v • • • v Hm v -T1 v • • • v -Tn & Hornova klauzule: nejvýše jeden pozitivní literál {H,-T1,...,-Tn} {H} {-T1,...,-Tn} a H v -T1 v • • • v -Tn H -T1 v • • • v -Tn JS> Pravidlo: jeden pozitivní a alespon jeden negativní literál J* Prolog: H : - T1, • • • ,Tn. Matematická logika: H <= T1 a • • • a Tn M» H <= T H v-T H v-T1 v • • • v -Tn Hana Rudová, Logické programování I, 15. kvetna 2013 117 Rezoluce a logické programování Prologovská notače -i* Klauzule v matematičké logiče {Hi, ■■■ ,Hm,-Ti, ■■■ ,-Tn} Hi v ■■■v Hm v -Ti v ■ ■ ■ v -Tn ü> Hornova klauzule: nejvýše jeden pozitivní literál {H,-Ti,...,-Tn} {H} {-Ti,...,-Tn} a H v -T1 v ■ ■ ■v -Tn H -T1 v ■ ■ ■v -Tn JS> Pravidlo: jeden pozitivní a alespon jeden negativní literál & Prolog: H : - T1, ■ ■ ■ ,Tn. Matematičká logika: H <= T1 a ■ ■ ■ a Tn -L- H <= T H v-T H v-T1 v ■ ■ ■ v -Tn Klauzule: {H,-T1,..., -Tn} Hana Rudová, Logičké programování I, 1S. kvetna 2G13 117 Rezoluče a logičké programování Prologovská notace -i* Klauzule v matematické logice {hi, ■■■ ,Hm,-Ti, ■■■ ,-Tn} Hi V--- V Hm V -Ti V ■ ■ ■ V -tn & Hornova klauzule: nejvýše jeden pozitivní literál {h,-Ti,...,-Tn} {H} {-ti,...,-tn} a H V -ti V ■ ■ ■ V -tn H -ti V ■ ■ ■ V -tn -i* Pravidlo: jeden pozitivní a alespon jeden negativní literál J* Prolog: h : - ti, ■ ■ ■ ,Tn. Matematická logika: H <= ti a ■ ■ ■ a Tn M» H <= T H V-T H V -ti v ■ ■ ■ V-tn Klauzule: {h,-Ti,..., -Tn} -í* Fakt: pouze jeden pozitivní literál -k Prolog: h. Matematická logika: h Klauzule: {h} Hana Rudová, Logické programování I, 15. kvetna 2013 117 Rezoluce a logické programování Prologovská notace & Klauzule v matematické logice {hi, ■■■ ,Hm,-Ti, ■■■ ,-Tn} Hi v--- v Hm V -Ti v ■ ■ ■ v -tn & Hornova klauzule: nejvýše jeden pozitivní literál {h,-Ti,...,-Tn} {H} {-ti,...,-tn} a H v -ti v ■ ■ ■ v -tn H -ti v ■ ■ ■ v -tn -i* Pravidlo: jeden pozitivní a alespon jeden negativní literál J* Prolog: H : - Ti, ■ ■ ■ , tn. Matematická logika: H <= ti a ■ ■ ■ a Tn M» H <= T H V-T H v-ti v ■ ■ ■ v-tn Klauzule: {h,-Ti,..., -Tn} -í* Fakt: pouze jeden pozitivní literál -k Prolog: h. Matematická logika: h Klauzule: {h} & Cílová klauzule: žádný pozitivní literál J* Prolog: : - Ti,... Tn. Matematická logika: -ti v ■ ■ ■ v -Tn Klauzule: {-ti, ■ ■ ■ -tn} Hana Rudová, Logické programování I, 15. kvetna 2013 117 Rezoluce a logické programování Logický program Programová klauzule: práve jeden pozitivní literál (fakt nebo pravidlo) Logičký program: konecná množina programových klauzulí Príklad: Sľ logický program jako množina klauzulí: P ={P1,P2,P3} P1 = {p}, P2 = {p, -q}, P3 = {q} Hana Rudová, Logické programování I, 15. kvetna 2013 118 Rezoluce a logické programování Logický program Programová klauzule: právě jěděn pozitivní litěrál (fakt něbo pravidlo) Logický program: koněcná množina programových klauzulí Príklad: a logický program jako množina klauzulí: P = {Pi,P2,P3} Pi = {p}, P2 = {p, -q}, P3 = {q} & logický program v prologovské notaci: p. p: -q. q. a cílová klauzulě: G = {-q, -p} : -q, p. Hana Rudová, Logické programování I, 15. května 2013 118 Rězolucě a logické programování Lineární rezoluče pro Hornovy klauzule & Začneme s čílovou klauzulí: C0 = G & Boční klauzule vybíráme z programovýčh klauzulí P m G = {-q,-p} P ={Pi,P2,P3} : Pi = {p}, P2 = {p, -q}, P3 = {q} : -q, p. p. p : -q, q. Hana Rudová, Logičké programování I, 15. kvetna 2013 119 Rezoluče a logičké programování Lineární rezoluce pro Hornovy klauzule St Zacneme s cílovou klauzulí: C0 = G St Bocní klauzule vybíráme z programových klauzulí P mG = {-q,-p} P ={P1,P2,P3} : P1 = {p}, P2 = {p, -q}, P3 = {q} * : -q,p. p. p: -q, q. {^q,^p} {q} {^p} {p} □ Hana Rudová, Logické programování I, 15. kvetna 2013 119 Rezoluce a logické programování Lineární rezoluče pro Hornovy klauzule Zacneme s cílovou klauzulí: Co = G Bocní klauzule vybíráme z programových klauzulí P G = {-q,-p} P = {P1,P2,P3} : P1 = {p}, P2 = {p, -q}, P3 = {q} : -q,p. p. p: -q, q. {^p} {p} {^q} {q} □ □ Hana Rudová, Logické programování I, 15. kvetna 2013 119 Rezoluce a logické programování Lineární rezoluče pro Hornovy klauzule JS* Začneme s čílovou klauzulí: C0 = G St Boční klauzule vybíráme z programovýčh klauzulí P mG ={-q,-p} P ={Pi,P2,P3} : Pi = {p}, P2 = {p, -q}, P3 = {q} * : -q,p. p. p: -q, q. □ □ JS> Strední klauzule jsou čílové klauzule Hana Rudová, Logičké programování I, 15. kvetna 2013 119 Rezoluče a logičké programování Lineární vstupní rezoluce Vstupní rezoluce na P u {G} S» (opakování:) alespon jedna z klauzulí použitá pri rezoluci je z výchozí vstupní množiny & zacneme s cílovou klauzulí: C0 = G J* bocní klauzule jsou vždy z P (tj. jsou to programové klauzule) Hana Rudová, Logické programování I, 15. kvetna 2013 120 Rezoluce a logické programování Lineární vstupní rezoluče Vstupní rezoluče na P u {G} S» (opakování:) alespon jedna z klauzulí použitá pri rezoluči je z výčhozí vstupní množiny & začneme s čílovou klauzulí: C0 = G J* boční klauzule jsou vždy z P (tj. jsou to programové klauzule) (Opakování:) Lineární rezoluční dukaz C z P je posloupnost dvojič (Co,Bo), ... (Cn,Bn) taková, že C = Cn+i a C0 a každá Bi jsou prvky P nebo nekteré Cj,j < i S* každá Ci+1, i < n je rezolventa Ci a Bi Hana Rudová, Logičké programování I, 15. kvetna 2013 120 Rezoluče a logičké programování Lineární vstupní rezoluce -i* Vstupní rezoluce na P u {G} -i* (opakování:) alespon jedna z klauzulí použitá pri rezoluci je z výchozí vstupní množiny & zacneme s cílovou klauzulí: Q = G & bocní klauzule jsou vždy z P (tj. jsou to programové klauzule) M (Opakování:) Lineární rezolucní dukaz C z P je posloupnost dvojic (co,bo>, ... (Cn,Bn) taková, že C = cn+i a a co a každá Bi jsou prvky P nebo nekteré Cj,j < i S» každá ci+i, i < n je rezolventa Ci a Bi Lineární vstupní (Linear Input) rezoluce (LI-rezoluce) C z P u {G} posloupnost dvojic (C0,B0>, ... {Cn,Bn> taková, že C = Cn+i a a C0 = G a každá Bi jsou prvky P lineární rezoluce + vstupní rezoluce a každá Ci+i, i < n je rezolventa Ci a Bi Hana Rudová, Logické programování I, 15. kvetna 2013 120 Rezoluce a logické programování Cíle a fakta pri lineární rezoluči JS> Veta: Je-li S nesplnitelná množina Hornových klauzulí, pak S obsahuje alespon jeden číl a jeden fakt. ± pokud nepoužiji cíl, mám pouze fakta (1 pozit.literál) a pravidla (1 pozit.literál a alespon jeden negat. literál), pri rezoluci mi stále zustává alespon jeden pozit. literál Hana Rudová, Logické programování I, 15. kvetna 2013 121 Rezoluce a logické programování Cíle a fakta pri lineární rezoluci JS> Veta: Je-li S nesplnitelná množina Hornových klauzulí, pak S obsahuje alespon jeden cíl a jeden fakt. ± pokud nepoužiji cíl, mám pouze fakta (1 pozit.literál) a pravidla (1 pozit.literál a alespon jeden negat. literál), pri rezoluci mi stále zůstává alespon jeden pozit. literál -fc pokud nepoužiji fakt, mám pouze cíle (negat.literály) a pravidla (1 pozit.literál a alespon jeden negat. literál), v rezolvente mi stále zustávají negativní literály Hana Rudová, Logické programování I, 15. kvetna 2013 121 Rezoluce a logické programování Cíle a fakta pri lineární rezoluci JS> Veta: Jě-li S něsplnitělná množina Hornových klauzulí, pak S obsahujě alěspon jeden cíl a jeden fakt. ± pokud něpoužiji cíl, mám pouzě fakta (1 pozit.litěrál) a pravidla (1 pozit.litěrál a alěspon jěděn něgat. litěrál), pri rězoluci mi stálě zustává alěspon jěděn pozit. litěrál -fc pokud něpoužiji fakt, mám pouzě cílě (něgat.litěrály) a pravidla (1 pozit.litěrál a alěspon jěděn něgat. litěrál), v rězolvěntě mi stálě zustávají něgativní litěrály veta: Existujě-li rězolucní dukaz prázdné množiny z množiny S Hornových klauzulí, pak těnto rězolucní strom má v listěch jedinou cílovou klauzuli. pokud zacnu dukaz pravidlěm a faktěm, pak dostanu zasě pravidlo -i- pokud zacnu dukaz dvěma pravidly, pak dostanu zasě pravidlo A na dvou faktěch rězolvovat nělzě Hana Rudová, Logické programování I, 15. května 2013 121 Rězolucě a logické programování Cíle a fakta pri lineární rezoluči JS> Veta: Je-li S nesplnitelná množina Hornovýčh klauzulí, pak S obsahuje alespon jeden číl a jeden fakt. ± pokud nepoužiji číl, mám pouze fakta (1 pozit.literál) a pravidla (1 pozit.literál a alespon jeden negat. literál), pri rezoluči mi stále zůstává alespon jeden pozit. literál -fc pokud nepoužiji fakt, mám pouze číle (negat.literály) a pravidla (1 pozit.literál a alespon jeden negat. literál), v rezolvente mi stále zustávají negativní literály veta: Existuje-li rezoluční dukaz prázdné množiny z množiny S Hornovýčh klauzulí, pak tento rezoluční strom má v listečh jedinou čílovou klauzuli. pokud začnu dukaz pravidlem a faktem, pak dostanu zase pravidlo -i- pokud začnu dukaz dvema pravidly, pak dostanu zase pravidlo A na dvou faktečh rezolvovat nelze => dokud nepoužiji číl pračuji stále s množinou faktu a pravidel Hana Rudová, Logičké programování I, 15. kvetna 2013 121 Rezoluče a logičké programování Cíle a fakta p r i lineární rezoluci JS> Veta: Je-li S nesplnitelná množina Hornových klauzulí, pak S obsahuje alespon jeden cíl a jeden fakt. ± pokud nepoužiji cíl, mám pouze fakta (1 pozit.literál) a pravidla (1 pozit.literál a alespon jeden negat. literál), pri rezoluci mi stále zustává alespon jeden pozit. literál -fc pokud nepoužiji fakt, mám pouze cíle (negat.literály) a pravidla (1 pozit.literál a alespon jeden negat. literál), v rezolvente mi stále zustávají negativní literály veta: Existuje-li rezolucní dukaz prázdné množiny z množiny S Hornových klauzulí, pak tento rezolucní strom má v listech jedinou cílovou klauzuli. pokud zacnu dukaz pravidlem a faktem, pak dostanu zase pravidlo -i- pokud zacnu dukaz dvema pravidly, pak dostanu zase pravidlo A na dvou faktech rezolvovat nelze == dokud nepoužiji cíl pracuji stále s množinou faktu a pravidel ± pokud použiji v dukazu cílovou klauzulí, fakta mi ubírají negat.literály, pravidla mi je pridávají, v rezolvente mám stále samé negativní literály, tj. nelze rezolvovat s dalším cílem Hana Rudová, Logické programování I, 15. kvetna 2013 121 Rezoluce a logické programování Korektnost a úplnost Veta: Množina S Hornových klauzulí je nesplnitelná, práve když existuje rezolucní vyvrácení S pomocí vstupní rezoluče. M Korektnost platí stejne jako pro ostatní omezení rezoluce * Úplnost Ll-rezoluče pro Hornovy klauzule: Necht' P je množina programových klauzulí a G cílová klauzule. Je-li množina P u {G} Hornových klauzulí nesplnitelná, pak existuje rezolucní vyvrácení P u {G} pomocí Ll-rezoluce. A vstupní rezoluce pro (obecnou) formuli sama o sobe není úplná => Ll-rezoluce aplikovaná na (obecnou) formuli nezarucuje, že nalezeneme dukaz, i když formule platí! Hana Rudová, Logické programování I, 15. kvetna 2013 122 Rezoluce a logické programování Korektnost a úplnost Veta: Množina S Hornových klauzulí je nesplnitelná, práve když existuje rezolucní vyvrácení S pomocí vstupní rezoluce. M Korektnost platí stejne jako pro ostatní omezení rezoluce * Úplnost LI-rezoluce pro Hornovy klauzule: Necht' P je množina programových klauzulí a G cílová klauzule. Je-li množina P u {G} Hornových klauzulí nesplnitelná, pak existuje rezolucní vyvrácení P u {G} pomocí LI-rezoluce. A vstupní rezoluce pro (obecnou) formuli sama o sobe není úplná => LI-rezoluce aplikovaná na (obecnou) formuli nezarucuje, že nalezeneme dukaz, i když formule platí! & Význam LI-rezoluce pro Hornovy klauzule: i* P = {P1, . . . , Pn}, G = {G1 ,...,Gm} iľ LI-rezolucí ukážeme nesplnitelnost P1 a • • • a Pn a (-G1 v • • • v -Gm) Hana Rudová, Logické programování I, 15. kvetna 2013 122 Rezoluce a logické programování Korektnost a úplnost Veta: Množina S Hornových klauzulí je nesplnitelná, práve když existuje rezolucní vyvrácení S pomocí vstupní rezoluce. M Korektnost platí stejne jako pro ostatní omezení rezoluce * Úplnost LI-rezoluce pro Hornovy klauzule: Necht' P je množina programových klauzulí a G cílová klauzule. Je-li množina P u {G} Hornových klauzulí nesplnitelná, pak existuje rezolucní vyvrácení P u {G} pomocí LI-rezoluce. A vstupní rezoluce pro (obecnou) formuli sama o sobe není úplná => LI-rezoluce aplikovaná na (obecnou) formuli nezarucuje, že nalezeneme dukaz, i když formule platí! & Význam LI-rezoluce pro Hornovy klauzule: i* P = {P1, . . . , Pn}, G = {G1 ,...,Gm} iľ LI-rezolucí ukážeme nesplnitelnost P1 a ■ ■ ■ a Pn a (-G1 v ■ ■ ■ v -Gm) A pokud tedy predpokládáme, že program {P1,.. .,Pn} platí, tak musí být nepravdivá (-G1 v ■ ■ ■ v -Gm), tj. musí platit G1 a ■ ■ ■ a Gm Hana Rudová, Logické programování I, 15. kvetna 2013 122 Rezoluce a logické programování Uspo rádané klauzule (definite clauses) Klauzule = množina literálú JS> Uspo rádáná klauzule (definite clause) = posloupnost literálů -fc nelze volne menit poradí literálů —* Rezolucní princip pro uspo rádané klauzule: _{-Ao,-An}_{B, -Bo,-Bm}_ {-Ao,-Ai-i, -Bop,-Bmp,-Ai+i,-An}a M uspo rádaná rezolventa: {-Ao,-Ai-1, -Bop,-Bmp,-Ai+1,-An}a -i- p je prejmenování promenných takové, že klauzule {Ao,.. .,An} a {B,B0,.. .,Bm}p nemají spolecné promenné & a je nejobecnejší unifikátor pro Ai a Bp Hana Rudová, Logické programování I, 15. kvetna 2G1B 12B Rezoluce a logické programování Uspořádané klauzule (definite clauses) Klauzule = množina literálů JS> Uspořádaná klauzule (definite clause) = posloupnost liteřálů -fc nelze volne menit poradí literálů £ Rezoluční princip přo uspořádané klauzule: _{-Ao,-An}_[B1 -Bo,-Bm\_ {-Ao,-Ai-i, -Bop,-BmP,-At+i,-An} j M uspořádaná řezolventa: {-A0,-Ai-\, -B0p,-Bmp,—Ai+\,-An}j &> p je přejmenování promenných takové, že klauzule {A0,.. .,An} a {B,B0,.. .,Bm}p nemají společné promenné & j je nejobecnejší unifikátor pro Ai a Bp -í* řezoluceje řealizována na liteřálech -Aij a Bpj je dodržováno poradí literálu, tj. {-B0p,-Bmp}j jde do uspořádané řezolventy přesne na pozici -Aij Hana Rudová, Logické programování I, 15. kvetna 2013 123 Rezoluce a logické programování Usporádané klauzule II. C Usporádáné klauzule _{-Ao,-An}_{B1 -Bo,• -Bm\_ {-Ao,-Ai-i, -Bop,-BmP,-Ai+i,-An} LD-rězolucě: korěktní a úplná Hana Rudová, Logické programování I, 15. května 2013 125 Rězolucě a logické programování SLD-rezoluce JS> Lineární rezoluce se selekCním pravidlem = SLD-rezoluce (Selected Linear resolution for Definite clauses) J» rezoluce & SelekCní pravidlo J* Lineární rezoluce a Definite (uspořádané) klauzule a vstupní rezoluce Hana Rudová, Logické programování I, 15. května 2013 126 Rezoluce a logické programování SLD-rezoluče JS> Lineární rezoluče se selekčním pravidlem = SLD-rezoluče (Selected Linear resolution for Definite clauses) J» rezoluce & Selekční pravidlo Jr Lineární rezoluce a Definite (usporádané) klauzule a vstupní rezoluce -i* Selekční pravidlo R je funkce, která každé neprázdné klauzuli C prirazuje nejaký z jejích literálu R(C) g C -i- pri rezoluci vybírám z klauzule literál urcený selekcním pravidlem Hana Rudová, Logické programování I, 15. kvetna 2013 126 Rezoluce a logické programování SLD-rezoluce JS> Lineární rezoluce se selekcním pravidlem = SLD-rezoluce (Selected Linear resolution for Definite clauses) J» rezoluce & Selekcní pravidlo Jr Lineární rezoluce a Definite (usporádané) klauzule a vstupní rezoluce -i* Selekcní pravidlo R je funkce, která každé neprázdné klauzuli C prirazuje nejaký z jejích literálu R(C) g C -i- pri rezoluci vybírám z klauzule literál urcený selekcním pravidlem & Pokud se R neuvádí, pak se predpokládá výber nejlevejšího literálu nejlevejší literál vybírá i Prolog Hana Rudová, Logické programování I, 15. kvetna 2013 126 Rezoluce a logické programování Lineární rezoluce se selekčním pravidlem P = {{p}, {p, -q}, {q}}, G = {-q,-p} {^q,^pj {q} {^q,^p} (pI výběr | y/" výběr | / nejlevějšího {^P} Jp} nejpravějšího Jq} litěrálu I / literálu ' ^ □ □ Hana Rudová, Logické programování I, 15. května 2013 127 Rezoluce a logické programování Lineární rezoluče se selekčním pravidlem P = {{p}, {p, -q}, {q}}, G = {-q,-p} výber | výber | y/ nejlevejšího {^P} Jp} nejpravejšího Jq} literálu ' / literálu ' ^ □ □ SLD-rezoluční vyvráčení P u {G} pomocí selekcního pravidla R je LD-rezolucní vyvrácení ,(Gn,Cn) takové, že G = G0,Gn+1 = □ a R(Gi) je literál rezolvovaný v kroku i Hana Rudová, Logické programování I, 15. kvetna 2013 127 Rezoluce a logické programování Lineární rezoluče se selekčním pravidlem JS> SLD-rezoluční vyvráčení P u {G} pomočí selekčního pravidla R je LD-rezoluční vyvráčení (G0,C0), (Gn,Cn) takové, že G = G0,Gn+1 = □ a R(Gi) je literál rezolvovaný v kroku i m SLD-rezoluče - korektní, úplná -í* Efektivita SLD-rezoluče je závislá na £• selekčním pravidle R & zpusobu výberu príslušné programové klauzule pro tvorbu rezolventy v Prologu se vybírá vždy klauzule, která je v programu první n literálu □ Hana Rudová, Logičké programování I, 15. kvetna 2013 127 Rezoluče a logičké programování Príklad: SLD-strom t: -p,r. t : -s. p : -q, v. p : - u, w q. s. u. (1) (2) (3) (4) (5) (6) (7) : -1. (D/\ (2) :-p,r. (3)/ \(4) :- s. (5) :- v,r. fall :- u,w,r. (7) :- w,r. .(6) □ fall Hana Rudová, Logické programovaní I, 15. kvetna 2013 128 Rezoluce a logické programovaní Strom výpoctu (SLD-strom) SLD-strom jě strom tvorěný všěmi možnými výpocětními posloupnostmi logického programu P vzhlěděm k cíli G Hana Rudová, Logické programování I, 15. května 2013 129 Rězolucě a logické programování Strom výpoctu (SLD-strom) SLD-strom je strom tvorený všemi možnými výpocetními posloupnostmi logického programu P vzhledem k cíli G korenem stromu je cílová klauzule G v uzlech stromu jsou rezolventy (rodice uzlu a programové klauzule) & císlo vybrané programové klauzule pro rezoluci je v príkladu uvedeno jako ohodnocení hrany listy jsou dvojího druhu: a oznacené prázdnou klauzulí - jedná se o úspešné uzly (succes nodes) *> oznacené neprázdnou klauzulí - jedná se o neúspešné uzly (failure nodes) Hana Rudová, Logické programování I, 15. kvetna 2013 129 Rezoluce a logické programování Strom výpoctu (SLD-strom) SLD-strom je strom tvorený všemi možnými výpocetními posloupnostmi logického programu P vzhledem k cíli G korenem stromu je cílová klauzule G v uzlech stromu jsou rezolventy (rodice uzlu a programové klauzule) & císlo vybrané programové klauzule pro rezoluci je v príkladu uvedeno jako ohodnocení hrany listy jsou dvojího druhu: a oznacené prázdnou klauzulí - jedná se o úspešné uzly (succes nodes) *> oznacené neprázdnou klauzulí - jedná se o neúspešné uzly (failure nodes) úplnost SLD-rezoluce zarucuje existenci cesty od korene k úspešnému uzlu pro každý možný výsledek príslušející cíli G Hana Rudová, Logické programování I, 15. kvetna 2013 129 Rezoluce a logické programování Priklad: SLD-strom a vysledna substituce : -a(Z). a(X) : -b(X,Y),c(Y) a(X) : -c(X). b(2, 3). b(l, 2). c(2). (1) (2) (3) (4) (5) :- a(Z). :- b(Z,Y), c(Y). :- c(Z). [Z/2,Y/3] \4) [Z/1,Y/2] \ (5) [Z/2] :- c(3). fall :- c(2). (5) □ [Z/1] □ [Z/2] Hana Rudova, Logicke programovani I, 15. kvetna 2013 130 Rezoluce a logicke programovani Príklad: SLD-strom a výsledná substituce : -a(Z). a(X) : -b(X,Y),c(Y) a(X) : -c(X). b(2, 3). b(l, 2). c (2). Cvicení: p(B) : -q(A,B),r(B). p (A) : -q(A,A). q(a, a). q(a, b). r(b). (1) (2) (3) (4) (5) :- a(Z). (\y \2) :- b(Z,Y), c(Y). :- c(Z). [Z/2,Y/3] (3) / \4) [Z/1,Y/2] \ (5) [Z/2] :- c(3). fall :- c(2). (5) □ [Z/1] □ [Z/2] vě výslědné substituci jsou pouzě proměnné z dotazu, tj. výslědné substitucě jsou [Z/i] a [Z/2] nězajímá mě substitucě [Y/2] Hana Rudová, Logické programování I, 15. května 2013 130 Rězolucě a logické programování Výsledná substituce (answer substitution) q(a). — P(X,Y). q(a). [X/a] p(a,b). I / :- p(a,Y). p(a,b). [Y/b] :-q(X), p(X,Y). / X=a, Y=b □ [X/a,Y/b] Hana Rudová, Logické programování I, 15. května 2013 131 Rezoluce a logické programování Výsledná substituce (answer substitution) q(a). — P(X,Y). q(a). [X/a] p(a,b). I / :- p(a,Y). p(a,b). [Y/b] :-q(X), p(X,Y). / X=a, Y=b □ [X/a,Y/b] JS> Každý krok SLD-rezoluce vytváří novou unifikacní substituci 0i ^ potenciální instanciace proměnné ve vstupní cílové klauzuli & Výsledná substituce (answer substitution) 9 = 9091 • • • 9n složení unifikací Hana Rudová, Logické programování I, 15. kvetna 2013 131 Rezoluce a logické programování Význam SLD-rezolučního vyvráčení P u {G} m Množina P programovýčh klauzulí, čílová klauzule G & Dokazujeme nesplnitelnost (1) P A (VX)(-Gi(X) v -Gz(X) v - -- v -Gn(X)) kde G = {-G1, -G2, - - - , -Gn} a X je vektor promennýčh v G Hana Rudová, Logičké programování I, 15. kvetna 2013 132 Rezoluče a logičké programování Význam SLD-rezolučního vyvráčení P u {G} m Množina P programovýčh klauzulí, čílová klauzule G & Dokazujeme nesplnitelnost (1) P A (VX)(-Gi(X) v -Gz(X) v - -- v -Gn(X)) kde G = { — Gi, —G2, - - - , — Gn} a X je vektor promennýčh v G nesplnitelnost (1) je ekvivalentní tvrzení (2) a (3) (2) P \--G (3) P h (3X)(Gi(X) A--- A Gn(X)) Hana Rudová, Logičké programování I, 15. kvetna 2013 132 Rezoluče a logičké programování Význam SLD-rezolucního vyvrácení P u {G} m Množina P programových klauzulí, cílová klauzule G & Dokazujeme nesplnitelnost (1) P a (VX)(-GAX) v -Gz(X) v • • •v -Gn(X)) kde G = {-G1, -G2, • • • , - Gn} a X je vektor promenných v G nesplnitelnost (1) je ekvivalentní tvrzení (2) a (3) (2) P h-G (3) P h (3X)(G1(X) a^-a Gn(X)) a jedná se tak o dukaz existence vhodných objektu, které na základe vlastností množiny P splnují konjunkci literálů v cílové klauzuli Hana Rudová, Logické programování I, 15. kvetna 2013 132 Rezoluce a logické programování Význam SLD-rezolucního vyvrácení P u {G} C Množina P programových klauzulí, cílová klauzule G & Dokazujeme nesplnitelnost (1) P A (VX)(-Gi(X) v -Gz(X) v - - - v -Gn(X)) kde G = {-G1, -G2, - - - , — Gn} a je vektor proměnných v G nesplnitelnost (1) je ekvivalentní tvrzení (2) a (3) (2) P h- -G (3) P h (3X)(Gi(X) A---A Gn(XÍ)) a jedná se tak o dukaz existence vhodných objektů, které na základe vlastností množiny P splnují konjunkci literálů v cílové klauzuli -i* Důkaz nesplnitelnosti P u {G} znamená nalezení protipříkladu ten pomocí SLD-stromu konstruuje termy (odpoveď) splnující konjunkci v (3) Hana Rudová, Logické programování I, 15. kvetna 2013 132 Rezoluce a logické programování Výpocetní strategie Korektní výpocetní strategie prohledávání stromu výpoctu musí zarucit, že se každý (konecný) výsledek nalézt v konecném case Hana Rudová, Logické programování I, 15. kvetna 2013 133 Rezoluce a logické programování Výpocetní strategie Korektní výpocetní strategie prohledávání stromu výpoctu musí zarucit, že se každý (konecný) výsledek nalézt v konecném case & Korektní výpocetní strategie = prohledávání stromu do šír ky & exponenciální pamet'ová nárocnost a složité rídící struktury Hana Rudová, Logické programování I, 15. kvetna 2013 133 Rezoluce a logické programování Výpočetní strategie Korektní výpočetní strategie prohledávání stromu výpoctu musí zarucit, že se každý (konecný) výsledek nalézt v konecném case & Korektní výpocetní strategie = prohledávání stromu do šírky & exponenciální pamet'ová nárocnost a složité rídící struktury JS> Použitelná výpocetní strategie = prohledávání stromu do hloubky & jednoduché rídící struktury (zásobník) * lineární pamet'ová nárocnost s> není ale úplná: nenalezne vyvrácení i když existuje procházení nekonecné vetve stromu výpoctu ^ na nekonecných stromech dojde k zacyklení nedostaneme se tak na jiné existující úspešné uzly Hana Rudová, Logické programování I, 15. kvetna 2013 133 Rezoluce a logické programování SLD-rezoluče v Prologu: úplnost -í* Prolog: prohledávání stromu do hloubky => neúplnost použité výpočetní strategie -i* Implementače SLD-rezoluče v Prologu a není úplná logičký program: q : -r^ (1) r : (2) (3) dotaz: : -q. :- q. :- r. □ Hana Rudová, Logičké programování I, 15. kvetna 2013 134 Rezoluče a logičké programování Test výskytu Kontrola, zda se promenná vyskytuje v termu, kterým ji substituujeme A dotaz : -a(B,B). i> logický program: a(X,f(X)). by vedl k: [B/X], [X/f(X)] Unifikátor pro g(X1, ...,Xn) a g(f(Xo,Xo),f(X1,X1),.. .,f(Xn-1,Xn-1)) X1 = f(Xo,Xo), X2 = f(X1,X\),..., Xn = f(Xn-1,Xn-1) X2 = f(f(Xo,Xo),f(Xo,Xo)),... délka termu pro Xk exponenciálne narůstá Hana Rudová, Logické programování I, 15. kvetna 2013 135 Rezoluce a logické programování Test výskytu -í* Kontrola, zda se promenná vyskytuje v termu, kterým ji substituujeme A dotaz : -a(B,B). i> logický program: a(X,f(X)). by vedl k: [B/X], [X/f(X)] & Unifikátor pro g(X1, ...,Xn) a g(f(Xo,Xo),f(X1,X1),.. .,f(Xn-1,Xn-1)) X1 = f(Xo,Xo), X2 = f(X1,X\),..., Xn = f(Xn-1,Xn-1) X2 = f (f (Xo,Xo), f (Xo,Xo)),... délka termu pro Xk exponenciálne narůstá => exponenčiální složitost na overení kontroly výskytu & Test výskytu se p r i unifikači v Prologu neprovádí M Dusledek: ? - X = f(X) uspeje s X = f (f (f (f (f (f (f (f (f (f (...)))))))))) Hana Rudová, Logické programování I, 15. kvetna 2013 135 Rezoluce a logické programování SLD-rezoluce v Prologu: korektnost -í* Implěměntacě SLD-rězolucě v Prologu něpoužívá pri unifikaci těst výskytu => není korektní (1) t(X) : -p(X,X). : -t(X). p(X,f(X)). X = f (f(f(f (...)))))))))) problém sě projěví Hana Rudová, Logické programování I, 15. května 2013 136 Rězolucě a logické programování SLD-rezoluče v Prologu: korektnost -í* Implementače SLD-rezoluče v Prologu nepoužívá pri unifikači test výskytu => není korektní (1) t(X) : -p(X,X). : -t(X). p(X,f(X)). X = f (f(f(f (...)))))))))) problém se projeví (2) t : -p(X,X). : -t. p(X,f(X)). yes dokazovačí systém nehledá unifikátor pro X a f(X) Hana Rudová, Logičké programování I, 15. kvetna 2013 136 Rezoluče a logičké programování SLD-rezoluce v Prologu: korektnost -í* Implementace SLD-rezoluce v Prologu nepoužívá pri unifikaci test výskytu => není korektní (1) t(X) : -p(X,X). : -t(X). p(X,f(X)). X = f (f(f(f (...)))))))))) problém se projeví (2) t : -p(X,X). : -t. p(X,f(X)). yes dokazovací systém nehledá unifikátor pro X a f(X) -í* Rešení: problém typu (2) prevést na problém typu (1) ? Hana Rudová, Logické programování I, 15. kvetna 2013 136 Rezoluce a logické programování SLD-rezoluce v Prologu: korektnost Implementace SLD-rezoluce v Prologu nepoužívá pri unifikaci test výskytu není korektní (1) t(X) : -p(X,X). : -t(X). p(X,f(X)). X = f(f(f(f(...)))))))))) problém se projeví (2) t • —p(X,X) p(X,f(X))^ • —t. yes dokazovací systém nehledá unifikátor pro X a f(X) Rešení: problém typu (2) prevést na problém typu (1) ? *> každá promenná v hlave klauzule se objeví i v tele, aby se vynutilo hledání unifikátoru (pridáme X = X pro každou X, která se vyskytuje pouze v hlave) t: -p(X,X). p(X,f(X)) : -X = X. Hana Rudová, Logické programování I, 15. kvetna 2013 136 Rezoluce a logické programování SLD-rezoluče v Prologu: korektnost Implementace SLD-rezoluce v Prologu nepoužívá při unifikaci test výskytu není korektní (1) t(X) : -p(X,X)- : -t(X). p(Xj(X)). X = f (f(f(f (•••)))))))))) problém se projeví (2) t : -p(X,X) p(X,f(X)). : -t. yes dokazovací systém nehledá unifikátor pro X a f(X) Rešení: problém typu (2) převést na problém typu (1) ? *> každá promenná v hlave klauzule se objeví i v tele, aby se vynutilo hledání unifikátoru (pridáme X = X pro každou X, která se vyskytuje pouze v hlave) t: -p(XX)-p(X,f(X)) : -X = X. a optimalizače v kompilátoru mohou způsobit opet odpoved' „yes" Hana Rudová, Logické programování I, 15. kvetna 2013 136 Rezoluce a logické programování Řízení implementace: JS> rez se syntakticky chová jako kterýkoliv jiný literál & nemá ale žádnou deklarativní sémantiku JS> místo toho mení implementaci programu *> p : -q, !,v. ořezání Hana Rudová, Logické programování I, 15. kvetna 2013 137 Rezoluce a logické programování Řízení implementace: rez rěz sě syntakticky chová jako ktěrýkoliv jiný litěrál němá alě žádnou děklarativní sémantiku místo toho mení implementaci programu p : -q, !,v. snažímě sě splnit q pokud uspěji => prěskocím rěz a pokracuji jako by tam rěz něbyl :- q,!,v. upnutí ořezání pokud ale neuspěji (a tedy i při backtrackingu) a vracím se přes řez => vracím se až na rodiCe : -p. a zkouším další vetev Hana Rudová, Logické programování I, 15. května 2013 137 Rězolucě a logické programování Řízení implementace: rez r ez se syntakticky chová jako kterýkoliv jiný literál nemá ale žádnou deklarativní sémantiku místo toho mení implementaci programu p : -q, !,v. snažíme se splnit q pokud uspeji => p reskocím rez a pokracuji jako by tam r ez nebyl :- q,!,v. upnutí ořezání pokud ale neuspeji (a tedy i p r i backtrackingu) a vracím se p res rez => vracím se až na rodice : -p. a zkouším další vetev => nezkouším tedy další možnosti, jak splnit p upnutí ^ a nezkouším ani další možnosti, jak splnit q v SLD-stromu o r ezání Hana Rudová, Logické programování I, 15. kvetna 2013 137 Rezoluce a logické programování Príklad: rez t: -p,r. t: -s. p : -q(X), !,v, p : -u,w. q(a). q(b). s. u. (1) (2) (3) (4) (5) (6) (7) (8) (D/ \<2) :- p,r. :- q(X),!,v,r. [X/a] (5) :— ! v r (!) :— v, r. fail (7) □ Hana Rudová, Logické programování I, 15. května 2013 138 Rezoluce a logické programování a(X) : -b(X, Y),\,c(Y) a(X) : -c(X). b(2, 3). b(l, 2). c(2). s(X) : -a(X). s(X) : -p(X). p(B) : -q(A,B),r(B). p (A) : -q(A,A). q(a, a). q(a, b). r(b). Príklad: rez II (1) (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) :- s(X). (6) / \ (7) :— a(X). :- b(X,Y),!,c(Y). [X/2,Y/3] (3) :— !,c(3). (rez) :— c(3). fail Hana Rudová, Logické programování I, 15. května 2013 139 Rezoluce a logické programování a(X) : -b(X,Y),c(Y),! a(X) : -c(X). b(2, 3). b(l, 2). c(2). s(X) : -a(X). s(X) : -p(X). p(B) : -q(A,B),r(B). p (A) : -q(A,A). q(a, a). q(a, b). r(b). Pr íklad: rez III d) (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) :- s(X). (6) / \(7) (1l :- a(X). :- b(X,Y),c(Y),!. [X/2,Y/3] (3^ \ (4) [X/1,Y/2] :- c(3),!. :- c(2),!. fail (5) • • • (rez) □ [X/1] Hana Rudová, Logické programování I, 15. května 2013 140 Rezoluce a logické programování Operační a deklarativní semantika Operacní sémantika Operacní sémantikou logického programu P rozumíme množinu O(P) všech atomických formulí bez promenných, které lze pro nejaký cíl G1 odvodit nejakým rezolucním dukazem ze vstupní množiny P u {Q}. 1tímto výrazem jsou míneny všechny cíle, pro než zmínený rezolucní dukaz existuje. Hana Rudová, Logické programování I, 15. kvetna 2013 142 Sémantiky Operační sémantika Operační sémantikou logičkého programu P rozumíme množinu O(P) všečh atomičkýčh formulí bez promennýčh, které lze pro nejaký číl G1 odvodit nejakým rezolučním dukazem ze vstupní množiny P u {Q}. Hímto výrazem jsou míneny všečhny číle, pro než zmínený rezoluční dukaz existuje. iS* Deklarativní sémantika logičkého programu P ??? Hana Rudová, Logičké programování I, 15. kvetna 2013 142 Sémantiky Opakování: interpretace -i* Interpretace l jazyka L je dána univerzem D a zobrazením, které přiřadí konstantě c prvek D, funkčnímu symbolu f /n n-ární operaci v D a predikátovému symbolu p/n n-ární relaci. príklad: F = {{f(a,b) = f (b,a)}, {f(f(a,a),b) = a}} interpretace li: D = Z,a := 1,b := -1,f := " + " Hana Rudová, Logické programování I, 15. kvetna 2013 143 Sémantiky Opakování: interpretace -i* Interpretace I jazyka L je dána univerzem D a zobrazením, které přiřadí konstantě c prvek D, funkčnímu symbolu f/n n-ární operaci v D a predikátovému symbolu p/n n-ární relaci. príklad: F = {{f(a,b) = f (b,a)}, {f(f(a,a),b) = a}} interpretace 11: D = Z, a := 1,b := -1,f := " + " Interpretace se nazývá modelem formule, je-li v ní tato formule pravdivá interpretace množiny N s obvyklými operacemi je modelem formule ( 0 + s(0) = s(0)) Hana Rudová, Logické programování I, 15. kvetna 2013 143 Sémantiky Herbrandovy interpretace Omězění na obor skládající sě zě symbolických výrazu tvorených z predikátových a funkcních symbolu daného jazyka i* pri zkoumání pravdivosti nění nutné uvažovat moděly nad všěmi intěrprětacěmi Hana Rudová, Logické programování I, 15. května 2013 144 Sémantiky Herbrandovy interpretače Omezení na obor skládajíčí se ze symboličkýčh výrazu tvorenýčh z predikátovýčh a funkčníčh symbolu daného jazyka i* pri zkoumání pravdivosti není nutné uvažovat modely nad všemi interpretačemi Herbrandovo univerzum: množina všečh termů bez promennýčh, které mohou být tvoreny funkčními symboly a konstantami daného jazyka Herbrandova interpretače: libovolná interpretače, která prirazuje i* promenným prvky Herbrandova univerza Jť konstantám sebe samé J* funkčním symbolům funkče, které symbolu f pro argumenty t\, • • • ,tn priradí term f(t\, • • • ,tn) J* predikátovým symbolům libovolnou funkči z Herbrand. univerza do pravdivostníčh hodnot Hana Rudová, Logičké programování I, 15. kvetna 2013 144 Sémantiky Herbrandovy interpretače & Omezení na obor skládajíčí se ze symboličkýčh výrazu tvorenýčh z predikátovýčh a funkčníčh symbolu daného jazyka iť pri zkoumání pravdivosti není nutné uvažovat modely nad všemi interpretačemi JS> Herbrandovo univerzum: množina všečh termů bez promennýčh, které mohou být tvoreny funkčními symboly a konstantami daného jazyka i* promenným prvky Herbrandova univerza Jť konstantám sebe samé & funkčním symbolům funkče, které symbolu f pro argumenty t\, • • • ,tn priradí term f(t\, • • • ,tn) J* predikátovým symbolům libovolnou funkči z Herbrand. univerza do pravdivostníčh hodnot & Herbranduv model množiny uzavrenýčh formulí P: Herbrandova interpretače taková, že každá formule z P je v ní pravdivá. prirazuje Hana Rudová, Logičké programování I, 15. kvetna 2013 144 Sémantiky Specifikace Herbrandova modelu C Hěrbrandovy intěrprětacě mají prědděfinovaný význam funktorů a konstant -í* Pro spěcifikaci Hěrbrandovy intěrprětacě tědy stací zadat rělacě pro každý prědikátový symbol Hana Rudová, Logické programování I, 15. května 2013 145 Sémantiky Specifikace Herbrandova modelu C Herbrandovy interpretace mají preddefinovaný význam funktorů a konstant —* Pro specifikaci Herbrandovy interpretace tedy stací zadat relace pro každý predikátový symbol & Príklad: Herbrandova interpretace a Herbranduv model množiny formulí 1ichy(s(0)). % (1) 1ichy(s(s(X))) :- lichy(X). % (2) Hana Rudová, Logické programování I, 15. kvetna 2013 145 Sémantiky Spečifikače Herbrandova modelu C Herbrandovy interpretace mají p r eddefinovaný význam funktorů a konstant & Pro specifikaci Herbrandovy interpretace tedy stací zadat relace pro každý predikátový symbol & Príklad: Herbrandova interpretace a Herbrandův model množiny formulí 1ichy(s(0)). % (1) 1ichy(s(s(X))) :- lichy(X). % (2) a 11 = 0 není model (1) Hana Rudová, Logické programování I, 15. kvetna 2013 145 Sémantiky Specifikace Herbrandova modelu C Hěrbrandovy intěrprětacě mají prědděfinovaný význam funktorů a konstant -í* Pro spěcifikaci Hěrbrandovy intěrprětacě tědy stací zadat rělacě pro každý prědikátový symbol & Príklad: Hěrbrandova intěrprětacě a Hěrbranduv moděl množiny formulí 1ichy(s(0)). % (1) 1ichy(s(s(X))) :- lichy(X). % (2) a Ii = 0 nění moděl (1) a 12 = {lichy(s(0))} nění moděl (2) Hana Rudová, Logické programování I, 15. května 2013 145 Sémantiky Specifikace Herbrandova modelu C Herbrandovy interpretace mají preddefinovaný význam funktom a konstant & Pro specifikaci Herbrandovy interpretace tedy staCí zadat relace pro každý predikátový symbol & Príklad: Herbrandova interpretace a Herbranduv model množiny formulí 1ichy(s(0)). % (1) 1ichy(s(s(X))) :- lichy(X). % (2) a I1 = 0 není model (1) a 12 = {lichy(s(0))} není model (2) I3 = {lichy (s (0)), lichy(s(s(s(0))))} není model (2) Hana Rudová, Logické programování I, 15. kvetna 2013 145 Sémantiky Specifikace Herbrandova modelu C Herbrandovy interpretace mají preddefinovaný význam funktorú a konstant —* Pro specifikaci Herbrandovy interpretace tedy stací zadat relace pro každý predikátový symbol & Príklad: Herbrandova interpretace a Herbrandův model množiny formulí 1ichy(s(G)). % (1) 1ichy(s(s(X))) i- lichy(X). % (2) a I1 = 0 není model (1) a 12 = {lichy(s(0))} není model (2) 13 = {lichy(s(0)), lichy(s(s(s(0))))} není model (2) 14 = {lichy (sn(0))\n g {1, 3, 5, V,...}} Herbrandův model (1) i (2) Hana Rudová, Logické programování I, 15. kvetna 2G1B 145 Sémantiky Specifikace Herbrandova modelu Herbrandovy interpretace mají preddefinovaný význam funktorů a konstant Pro specifikaci Herbrandovy interpretace tedy staCí zadat relace pro každý predikátový symbol Príklad: Herbrandova interpretace a Herbrandův model množiny formulí 1ichy(s(0)). % (1) 1ichy(s(s(X))) :- lichy(X). % (2) & li = 0 není model (1) a l2 = {lichy(s(0))} není model (2) 13 = {lichy (s (0)), lichy (s(s(s(0))))} není model (2) 14 = {lichy(sn(0))\n e {i, 3, 5, 7,...}} Herbrandův model (1) i (2) 15 = {lichy(sn(0))\n e n}} Herbrandův model (1) i (2) Hana Rudová, Logické programování I, 15. kvetna 2013 145 Sémantiky Príklad: Herbrandovy interpretače rodic(a,b). rodic(b,c). predek(X,Y) predek(X,Z) :- rodic(X,Y). :- rodic(X,Y), predek(Y,Z). Hana Rudová, Logičké programování I, 15. kvetna 2013 146 Sémantiky Príklad: Herbrandovy interpretace rodic(a,b). rodic(b,c). predek(X,Y) :- rodic(X,Y). predek(X,Z) :- rodic(X,Y), predek(Y,Z). 11 = {rodic(a, b),rodic(b, c),predek(a, b),predek(b, c),predek(a, c)} 12 = {rodic(a,b),rodic(b,c), predek(a, b), predek(b, c), predek(a, c), predek(a, a)} 11 i 12 jsou Herbrandovy modely klauzulí Cvicení: Napište minimální Herbranduv model pro následující logický program. muz(petr). muz(pavel). zena(olga). zena(jitka). pary(X,Y) :- zena(X), muz(Y). Uved'te další model tohoto programu, který není minimální. Hana Rudová, Logické programování I, 15. kvetna 2013 146 Sémantiky a operační sémantika ii> Je-li S množina programovýčh klauzulí a M libovolná množina Herbrandovýčh modelů S, pak prunik tečhto modelu je opet Herbrandův model množiny S. JS> Dusledek: Existuje nejmenší Herbranduv model množiny S, který značíme M(S). Hana Rudová, Logičké programování I, 15. kvetna 2013 147 Sémantiky a operacní sémantika ii> Jě-li S množina programových klauzulí a M libovolná množina Hěrbrandových modělu S, pak průnik techto modelů jě opět Hěrbrandův moděl množiny S. JS> Důsledek: Existujě nejmenší Herbrandův model množiny S, ktěrý znacímě M(S). -á* Deklarativní sémantikou logického programu P rozumímě jěho minimální Hěrbrandův moděl M(P). Hana Rudová, Logické programování I, 15. května 2013 147 Sémantiky a operační sémantika ii> Je-li S množina programových klauzulí a M libovolná množina Herbrandových modelu S, pak průnik techto modelů je opet Herbrandův model množiny S. JS> Důsledek: Existuje nejmenší Herbrandův model množiny S, který znacíme M(S). -á* Deklarativní sémantikou logického programu P rozumíme jeho minimální Herbrandův model M(P). & Pripomenutí: Operační sémantikou logického programu P rozumíme množinu O(P) všech atomických formulí bez promenných, které lze pro nejaký cíl G1 odvodit nejakým rezolucním dukazem ze vstupní množiny P u {Q}. 1tímto výrazem jsou míneny všechny cíle, pro než zmínený rezolucní dukaz existuje. Hana Rudová, Logické programování I, 15. kvetna 2013 147 Sémantiky a operacní sémantika ii> Je-li S množina programových klauzulí a M libovolná množina Herbrandových modelu S, pak průnik techto modelů je opet Herbrandův model množiny S. JS> Důsledek: Existuje nejmenší Herbrandův model množiny S, který znacíme M(S). -á* Deklarativní sémantikou logického programu P rozumíme jeho minimální Herbrandův model M(P). & Pripomenutí: Operacní sémantikou logického programu P rozumíme množinu O(P) všech atomických formulí bez proměnných, které lze pro nejaký cíl G1 odvodit nejakým rezolucním dukazem ze vstupní množiny P u (G). Hímto výrazem jsou míneny všechny cíle, pro než zmínený rezolucní důkaz existuje. -i* Pro libovolný logický program P platí M(P) = O(P) Hana Rudová, Logické programování I, 15. kvetna 2013 147 Sémantiky Negace v logickém programování Negativní znalost JS> logičké programy vyjadrují pozitivní znalost negativní literály: poziče určena definičí Hornovýčh klauzulí => nelze vyvodit negativní informači z logičkého programu & každý predikát definuje úplnou relači iť negativní literál není logičkým dusledkem programu Hana Rudová, Logičké programování I, 15. kvetna 2013 149 Negače v logičkém programování Negativní znalost JS> logické programy vyjadrují pozitivní znalost negativní literály: pozice urcena definicí Hornových klauzulí => nelze vyvodit negativní informaci z logického programu & každý predikát definuje úplnou relaci i* negativní literál není logickým dusledkem programu relace vyjádreny explicitne v nejmenším Herbrandove modelu -i- nad(X,Y) : -na(X,Y). na(c,b). nad(X, Y) : -na(X, Z),nad(Z, Y). na(b, a). J* nejmenší Herbranduv model: {na(b,a),na(c, b),nad(b,a),nad(c, b),nad(c,a)} Hana Rudová, Logické programování I, 15. kvetna 2013 149 Negace v logickém programování Negativní znalost JS> logické programy vyjadrují pozitivní znalost negativní literály: pozicě urcěna děfinicí Hornových klauzulí => nělzě vyvodit negativní informaci z logického programu & každý prědikát děfinujě úplnou rělaci iť něgativní litěrál není logickým duslědkěm programu rělacě vyjádrěny ěxplicitně v nějměnším Hěrbrandově modělu -i- nad(X,Y) : -na(X,Y). na(c,b). nad(X, Y) : -na(X, Z),nad(Z, Y). na(b, a). J* nějměnší Hěrbrandův moděl: {na(b,a),na(c, b),nad(b,a),nad(c, b),nad(c,a)} & ani program ani moděl nězahrnují něgativní informaci A a nění nad c, a nění na c S* i v rěalitě jě něgativní informacě vyjadrěna ěxplicitně zrídka, napr. jízdní rád Hana Rudová, Logické programování I, 15. května 2013 149 Něgacě v logickém programování Predpoklad uzavreného sveta neexistence informace chápána jako opak: predpoklad uzavřeného sveta (closed world assumption, CWA) prevzato z databází urcitý vztah platí pouze když je vyvoditelný z programu. P ^ A „odvozovací pravidlo" (A je (uzavrený) term):-— (CWA) Hana Rudová, Logické programování I, 15. kvetna 2013 150 Negace v logickém programování Predpoklad uzavreného sveta neexistenče informače čhápána jako opak: predpoklad uzavreného sveta (closed world assumption, CWA) prevzato z databází určitý vztah platí pouze když je vyvoditelný z programu. P \£ A „odvozovačí pravidlo" (A je (uzavrený) term):-— (CWA) —A pro SLD-rezoluči: P \£ nad(a,c), tedy lze podle CWA odvodit —nad(a,c) Hana Rudová, Logičké programování I, 15. kvetna 2013 150 Negače v logičkém programování P redpoklad uzav reného sveta C neexistence informace chápána jako opak: p r edpoklad uzav r eného sveta (closed world assumption, CWA) -í* prevzato z databází & urcitý vztah platí pouze když je vyvoditelný z programu. pro SLD-rezoluci: P £ nad(a,c), tedy lze podle CWA odvodit -nad(a,c) & problém: není rozhodnutelné, zda daná atomická formule je logickým důsledkem daného logického programu. -** nelze tedy urát, zda pravidlo CWA je aplikovatelné nebo ne & CWA v logickém programování obecne nepoužitelná. JS> „odvozovací pravidlo" (A je (uzavrený) term): P £ A (CWA) A Hana Rudová, Logické programování I, 15. kvetna 2013 150 Negace v logickém programování Negace jako neúspěch (negation as failure) slabší verze CWA: definitivně neúspěšný (finitely failed) SLD-strom cíle : -A : -A má definitivně (koneCne) neúspešný SLD-strom -A (negation as failure, NF) normální cíl: cíl obsahující i negativní literály -í* : -nad(c,a), -nad(b,c). Hana Rudová, Logické programování I, 15. kvetna 2013 151 Negace v logickém programování Negace jako neúspech (negation as failure) slabší verze CWA: definitívne neúspešný (finitely failed) SLD-strom cíle : -A : -A má definitivne (konecne) neúspešný SLD-strom -A (negation as failure, NF) M normální cíl: cíl obsahující i negativní literály -í* : -nad(c,a), -nad(b,c). -í* rozdíl mezi CWA a NF -i- program nad(X,Y) : -nad(X, Y), cíl : --nad(b,c) it neexistuje odvození cíle podle NF, protože SLD-strom : -nad(b,c) je nekonecný Jt existuje odvození cíle podle CWA, protože neexistuje vyvrácení: -nad(b,c) Hana Rudová, Logické programování I, 15. kvetna 2013 151 Negace v logickém programování Negace jako neúspech (negation as failure) M slabší verze CWA: definitívne neúspešný (finitely failed) SLD-strom cíle : -A : -A má definitívne (konecne) neúspešný SLD-strom -A (negation as failure, NF) M normální cíl: cíl obsahující i negativní literály -í* : -nad(c,a), -nad(b,c). -í* rozdíl mezi CWA a NF -i- program nad(X,Y) : -nad(X, Y), cíl : --nad(b,c) neexistuje odvození cíle podle NF, protože SLD-strom : -nad(b,c) je nekonecný A existuje odvození cíle podle CWA, protože neexistuje vyvrácení: -nad(b,c) M CWA i NF jsou nekorektní: A není logickým dusledkem programu P & rešení: definovat programy tak, aby jejich dusledkem byly i negativní literály zúplnení logického programu Hana Rudová, Logické programování I, 15. kvetna 2013 151 Negace v logickém programování Podstata zúplnení logického programu převod všech if příkazů v logickém programu na iff nad(X,Y) : -na(X,Y). nad(X, Y) : -na(X, Z),nad(Z,Y). -i* lze psát jako: nad(X,Y) : -(na(X,Y)) v (na(X, Z),nad(Z,Y)). zúplnění: nad(X,Y) (na(X,Y)) v (na(X,Z),nad(Z,Y)). Hana Rudová, Logické programování I, 15. kvetna 2013 152 Negace v logickém programování Podstata zúplnení logického programu prěvod všěch if príkazů v logickém programu na iff nad(X,Y) : -na(X,Y). nad(X, Y) : -na(X,Z),nad(Z,Y). J* lzě psát jako: nad(X,Y) : -(na(X,Y)) v (na(X,Z),nad(Z,Y)). zúplnění: nad(X,Y) (na(X,Y)) v (na(X,Z),nad(Z,Y)). & X jě nad Y práve tehdy, když alespoň jedna z podmínek platí A tědy pokud žádná z podmínek neplatí, X není nad Y Hana Rudová, Logické programování I, 15. května 2013 152 Něgacě v logickém programování Podstata zúplnení logického programu prevod všečh if príkazu v logičkém programu na iff nad(X,Y) : -na(X,Y). nad(X, Y) : -na(X, Z),nad(Z,Y). -i* lze psát jako: nad(X,Y) : -(na(X,Y)) v (na(X, Z),nad(Z,Y)). zúplnení: nad(X,Y) — (na(X,Y)) v (na(X,Z),nad(Z,Y)). & X je nad Y práve tehdy, když alespoň jedna z podmínek platí A tedy pokud žádná z podmínek neplatí, X není nad Y kombinače klauzulí je možná pouze pokud mají identičké hlavy S> na(c,b). na(b, a). S* lze psát jako: na(X\,X2) : -X\ = c,X2 = b. na(X\,X2) : -X\ = b,X2 = a. -i- zúplnení: na(X\,X2) — (X\ = c,X2 = b) v (X\ = b,X2 = a). Hana Rudová, Logičké programování I, 15. kvetna 2013 152 Negače v logičkém programování Zúplnení programu Zúplnení programu P je: comp(P) := IFF(P) u CET -í* Základní vlastnosti: *> comp(P) = P s do programuje pridána pouze negativní informace Hana Rudová, Logické programování I, 15. kvetna 2013 153 Negace v logickém programování Zúplnení programu Zúplnení programu P je: comp(P) := IFF(P) u CET -í* Základní vlastnosti: *> comp(P) ^ P s do programuje pridána pouze negativní informače & IFF(P): spojka : - v IF(P) je nahrazena spojkou — -í* IF(P): množina všečh formulí IF(q,P) pro všečhny predikátové symboly q v programu P -* Cíl: definovat IF(q,P) & def(p/n) predikátu p/n je množina všečh klauzulí predikátu p/n Hana Rudová, Logičké programování I, 15. kvetna 2013 153 Negače v logičkém programování IF(q, P) na(X1,X2) : -3YX = c,X2 = b, f (Y)) v (X1 = b,X2 = a, g). q/n predikátový symbol programu P na(c,b):-f(Y). na(b,a): -g. X1, ...,Xn jsou „nové" promenné, které se nevyskytují nikde v P Necht' C je klauzule ve tvaru q(t1, . . . , tn) : —L1, . . . , Lm kde m > 0, t1,...,tn jsou termy a L1,Lm jsou literály. Pak označme E(C) výraz 3Y1,Yk(X1 = t1,...,Xn = tn,L1,... ,Lm) kde Y1,...,Yk jsou všechny promenné v C. Hana Rudová, Logické programování I, 15. kvetna 2013 154 Negace v logickém programování na(Xi,X2) : -3Y(Xi = c,X2 = b,f(Y)) v (Xi = b,X2 = a,g). q/n predikátový symbol programu P na(c,b):-f(Y). na(b,a): -g. Xi, ...,Xn jsou „nové" promenné, které se nevyskytují nikde v P Necht' C je klauzule ve tvaru q(t1, . . . , tn) : —L1, . . . , Lm kde m > 0, ti,...,tn jsou termy a Li,Lm jsou literály. Pak oznacme E(C) výraz 3Yi,Yk(Xi = ti,...,Xn = tn,Li,... ,Lm) kde Yi,...,Yk jsou všechny promenné v C. Necht' def(q/n) = {Ci,Cj}. Pak formuli l¥(q,P) získáme následujícím postupem: q(Xi, ...,Xn) : -E(Ci) v E(C2) v - - - v E(Cj) pro j> 0 a q(Xi,... ,Xn) : - □ pro j = 0 [q/n není v programu P] Hana Rudová, Logické programování I, 15. kvetna 2013 154 Negace v logickém programování Clarkova Teorie Rovnosti (CET) všechny formule jsou univerzálne kvantifikovány: 1. X = X 2. X = Y - Y = X 3. X = Y a Y = Z - X = Z 4. pro každý f/m: Xi = Yi a • • • a Xm = Ym - f (Xi,...,Xm) = f(Yi,...,Ym) 5. pro každý p/m: Xi = Yi a • • • a Xm = Ym - (p(Xi,... ,Xm) - p(Yi,... ,Ym)) 6. pro všechny různé f/m a g/n, (m,n > 0): f(Xi,... ,Xm) = g(Yi,Yn) 7. pro každý f /m: f(Xi ,...,Xm) = f(Yi,...,Ym) - Xi = Yi a • • • a Xm = Ym 8. pro každý term t obsahující X jako vlastní podterm: t = X X = Y je zkrácený zápis -(X = Y) Hana Rudová, Logické programování I, 15. kvetna 2013 155 Negace v logickém programování Korektnost a úplnost NF pravidla & Korektnost NF pravidla: Něcht' P logický program a : -A cíl. Jěstližě : -A má děfinitivně něúspěšný SLD-strom, pak \/(-A) jě logickým duslědkěm comp(P) (něbo-li comp(P) = \/(-A)) Hana Rudová, Logické programování I, 15. května 2013 156 Něgacě v logickém programování Korektnost a úplnost NF pravidla & Korektnost NF pravidla: Necht' P logický program a : -A cíl. Jestliže : -A má definitivne neúspešný SLD-strom, pak V(-A) je logickým dusledkem comp(P) (nebo-li comp(P) £ V(-A)) JS> Úplnost NF pravidla: Necht' P je logický program. Jestliže comp(P) £ V(-A), pak existuje definitivne neúspešný SLD-strom : -A. -i- zůstává problém: není rozhodnutelné, zda daná atomická formule je logickým důsledkem daného logického programu. teorém mluví pouze o existenči definitivne neúspešného SLD-stromu J* definitivne (konecne) neúspešný SLD-strom sice existuje, ale nemusíme ho nalézt napr. v Prologu: muže existovat konecné odvození, ale program presto cyklí (Prolog nenajde definitivne neúspešný strom) Hana Rudová, Logické programování I, 15. kvetna 2013 156 Negace v logickém programování Korektnost a úplnost NF pravidla & Korektnost NF pravidla: Nečht' P logičký program a : -A číl. Jestliže : -A má definitívne neúspešný SLD-strom, pak V(—A) je logičkým dusledkem comp(P) (nebo-li comp(P) = V(—A)) JS> Úplnost NF pravidla: Nečht' P je logičký program. Jestliže comp(P) = V (—A), pak existuje definitivne neúspešný SLD-strom : -A. J» zůstává problém: není rozhodnutelné, zda daná atomičká formule je logičkým důsledkem daného logičkého programu. teorém mluví pouze o existenči definitivne neúspešného SLD-stromu Jt definitivne (konečne) neúspešný SLD-strom siče existuje, ale nemusíme ho nalézt napr. v Prologu: muže existovat konečné odvození, ale program presto čyklí (Prolog nenajde definitivne neúspešný strom) Odvození pomočí NF pouze test, nelze konstruovat výslednou substituči Jt v (comp(P) = V(— A)) je A všeob. kvantifikováno, v V (—A) nejsou volné promenné Hana Rudová, Logičké programování I, 15. kvetna 2013 156 Negače v logičkém programování Normální a stratifikované programy & normální program: obsahuje negativní literály v pravidlečh JS> problém: existenče zúplnení, která nemají žádný model p : --p. zúplnení: p — -p m rozdelení programu na vrstvy J* vynučují použití negače relače pouze tehdy pokud je relače úplne definovaná Hana Rudová, Logičké programování I, 15. kvetna 2013 157 Negače v logičkém programování Normální a stratifikované programy & normální program: obsahujě něgativní litěrály v pravidlěch JS> problém: ěxistěncě zúplnění, ktěrá němají žádný moděl A p : --p. zúplnění: p -p m rozdělění programu na vrstvy J* vynucují použití něgacě rělacě pouzě těhdy pokud jě rělacě úplně děfinovaná ± a. a. a : -—b, a. a : -—b, a. b. b : --a. Hana Rudová, Logické programování I, 15. května 2013 157 Negace v logickém programování Normální a stratifikované programy & normální program: obsahuje negativní literály v pravidlech JS> problém: existence zúplnení, která nemají žádný model p : --p. zúplnení: p -p m rozdelení programu na vrstvy J* vynucují použití negace relace pouze tehdy pokud je relace úplne definovaná ± a. a. a : -—b, a. a : -—b, a. b. b : -—a. stratifikovaný není stratifikovaný Hana Rudová, Logické programování I, 15. května 2013 157 Negace v logickém programování Normální a stratifikované programy & normální program: obsahuje negativní literály v pravidlech JS> problém: existence zúplnení, která nemají žádný model p : --p. zúplnení: p — —p m rozdelení programu na vrstvy J* vynucují použití negace relace pouze tehdy pokud je relace úplne definovaná ±> a. a. a : -—b,a. a : -—b,a. b. b : -—a. stratifikovaný není stratifikovaný & normální program P je stratifikovaný: množina predikátových symbolu programu lze rozdelit do disjunktních množin So,...,Sm (St = stratum) *> p(...) : - q(...),... g P, p g Sk => q g S0 u ... u Sk a p(...) : - ..., —q(...),... g P, p g Sk => q g S0 u ... u Sk-1 Hana Rudová, Logické programování I, 15. kvetna 2013 157 Negace v logickém programování Stratifikované programy II program je m-stratifikovaný <^> m je nejmenší index takový, že S0 u ... u Sm je množina všech predikátových symbolu z P & Veta: Zúplnení každého stratifikovaného programu má Herbranduv model. & p : --p. nemá Herbrandův model a p : --p. ale není stratifikovaný Hana Rudová, Logické programování I, 15. kvetna 2013 158 Negace v logickém programování Stratifikované programy II program je m-stratifikovaný <^> m je nejmenší index takový, že S0 u ... u Sm je množina všech predikátových symbolu z P & Veta: Zúplnení každého stratifikovaného programu má Herbranduv model. & p : - — p. nemá Herbrandův model a p : - — p. ale není stratifikovaný JS> stratifikované programy nemusí mít jedinečný minimální Herbrandův model & cykli: -—zastavi. s* dva minimální Herbrandovy modely: {cykli}, {zastavi} M dusledek toho, že cykli: -—zastavi. je ekvivalentní cykli v zastavi Hana Rudová, Logické programování I, 15. května 2013 158 Negace v logickém programování SLDNF rezoluce: úspešné odvození C NF pravidlo: : - C. má konecne neúspešný SLD-strom £ Pokud máme negativní podcíl —C v dotazu G, pak hledáme dukaz pro C & Pokud odvození C selže (strom pro C je koneCne neúspešný), pak je odvození G (i — C) celkove úspešné nahore(X) : -—blokovaný(X). blokovaný(X) : -na(Y,X). na(a, b). Hana Rudová, Logické programování I, 15. kvetna 2013 159 Negace v logickém programování C NF pravidlo: -í* Pokud máme negativní podcíl -C v dotazu G, pak hledáme dukaz pro C & Pokud odvození C selže (strom pro C je konecne neúspešný), pak je odvození G (i -C) celkove úspešné nahore(X) : -—blokovaný(X). blokovaný (X) : -na(Y,X). na(a, b). : -nahore(c). yes :- nahore(c). :- blokovany(c). ■ blokovany(c). ■ :- na(Y,c). FAIL => úspešné odvození Hana Rudová, Logické programování I, 15. kvetna 2013 159 Negace v logickém programování SLDNF rezoluce: neúspešné odvození C NF pravidlo: : - C. má koněcně něúspěšný SLD-strom JS> Pokud mámě něgativní podcíl —C v dotazu G, pak hlědámě dukaz pro C & Pokud existuje vyvrácení C s prázdnou substitucí (strom pro C je konecne úspešný), pak je odvození G (i —C) celkove neúspešné nahore(X) : -—blokovaný(X). blokovaný(X) : -na(Y,X). na(_, _). Hana Rudová, Logické programování I, 15. května 2013 160 Něgacě v logickém programování NF pravidlo: -c Pokud máme negativní podcíl ->C v dotazu G, pak hledáme důkaz pro C & Pokud existuje vyvrácení C s prázdnou substitucí (strom pro C je konecne úspešný), pak je odvození G (i — C) celkove neúspešné nahore(X) : -—blokovaný(X). blokovaný (X) : -na(Y,X). na(_, _). : -nahore(X). no :- nahore(X). :- blokovany(X). ■ blokovany(X). ■ :- na(Y,X). □ => neúspešné odvození Hana Rudová, Logické programování I, 15. kvetna 2013 160 Negace v logickém programování SLDNF rezoluce: uvázlé odvození C NF pravidlo: : - C. má konečne neúspešný SLD-strom —C -í* Pokud máme negativní podčíl —C v dotazu G, pak hledáme důkaz pro C & Pokud existuje vyvrácení C s neprázdnou substitucí (strom pro C je koneCne úspešný), pak je odvození G (i — C) uvázlé nahore(X) : -—blokovaný(X). blokovaný(X) : -na(Y,X). na(a, b). Hana Rudová, Logičké programování I, 15. kvetna 2013 161 Negače v logičkém programování SLDNF rezoluče: uvázlé odvození C NF pravidlo: : - C. má kone c n e neúsp e šný SLD-strom -C -í* Pokud máme negativní podcíl -C v dotazu G, pak hledáme dukaz pro C £ Pokud existuje vyvráčení C s neprázdnou substitučí (strom pro C je konečne úspešný), pak je odvození G (i -C) uvázlé nahore(X) : --blokovaný(X). blokovaný (X) : -na(Y,X). na(a, b). : -nahore(X). :- nahore(X). :- blokovany(X). blokovany(X). :- na(Y,X). | [Y/a,X/b] ^ => uvázlé odvození [X/b] Hana Rudová, Logické programování I, 15. kvetna 2013 161 Negace v logickém programování CviCení: SLDNF odvození Napište množinu SLDNF odvození pro uvedený dotaz. :- a(B). a(X) :- b(X), \+ c(X). a(X) :- d(X), Y is X+1, \+ c(Y), b(X). b(1). c(A) :- d(A). d(1). Hana Rudová, Logické programování I, 15. kvetna 2013 162 Negace v logickém programování SLD+ odvození P je normální program, G0 normální číl, R selekční pravidlo: SLD+-odvození G0 je bud' konečná posloupnost (Go, Co),..., (Gt-i, Ct-i), Gi nebo nekonečná posloupnost (Go, Co), (Gi, Ci), (G2, C2),... kde v každém kroku m + l(m > 0), R vybírá pozitivní literál v Gm a dospívá k Gm+i obvyklým zpusobem. Hana Rudová, Logičké programování I, 15. kvetna 2013 163 Negače v logičkém programování SLD+ odvození P je normální program, G0 normální cíl, R selekcní pravidlo: SLD+-odvození G0 je bud' konecná posloupnost (Gom, C0),..., (Gi-i, Ci-i), Gi nebo nekonecná posloupnost (G0; C0), (Gi, Ci), (G2, C2),... kde v každém kroku m + l(m > 0), R vybírá pozitivní literál v Gm a dospívá k Gm+i obvyklým zpusobem. muže být: 2. neúspešné 3. blokované: Gi je negativní (napr. —A) Hana Rudová, Logické programování I, 15. kvetna 2013 163 Negace v logickém programování SLDNF rezoluce: pojmy & Úroveň cíle a P normální program, G0 normální cíl, R selekční pravidlo: úroveň cíle G0 se rovná 0 <^> žádné SLD+-odvození s pravidlem R není blokováno 3 k + 1 <^> maximální úroven cílů : -A, které ve tvaru —A blokují SLD+-odvození G0, je k ±> nekonecná úroven Hana Rudová, Logické programování I, 15. kvetna 2013 164 Negace v logickém programování SLDNF rezoluce: pojmy Úroven cíle a P normální program, G0 normální cíl, R selekcní pravidlo: úroven cíle G0 se rovná 0 <^> žádné SLD+-odvození s pravidlem R není blokováno > k + 1 <^> maximální úroven cílu : -A, které ve tvaru —A blokují SLD+-odvození G0, je k J* nekonecná úroven cíle: blokované SLDNF odvození Množina SLDNF odvození = {(SLDNF odvození G0) u (SLDNF odvození: -A)} Jr p r i odvozování G0 jsme se dostali k cíli —A SLDNF odvození cíle G ? Hana Rudová, Logické programování I, 15. kvetna 2013 164 Negace v logickém programování SLDNF rezoluce P normální program, G0 normální cíl, R sělěkcní pravidlo: množina SLDNF odvození a podmnožina neúspešných SLDNF odvození cílě G0 jsou takové nějměnší množiny, žě: & každé SLD+-odvození G0 jě SLDNF odvozění G0 & jě-li SLD+-odvozění {G0; C0), ...,Gi blokováno na —A tj. Gi jě tvaru : - L\,..., Lm-\, —A, Lm+\,... ,Ln pak Hana Rudová, Logické programování I, 15. května 2013 165 Něgacě v logickém programování SLDNF rezoluce P normální program, G0 normální cíl, R selekční pravidlo: množina SLDNF odvození a podmnožina neúspešných SLDNF odvození cíle G0 jsou takové nejmenší množiny, že: & každé SLD+-odvození G0 je SLDNF odvození G0 & je-li SLD+-odvození (Go; Co), ...,Gi blokováno na —A tj. Gi je tvaru : - Li,..., Lm-\, —A, Lm+\,... ,Ln pak a existuje-li SLDNF odvození: -A (pod R) s prázdnou cílovou substitucí, pak (G0; C0), ...,Gi je neúspešné SLDNF odvození Hana Rudová, Logické programování I, 15. kvetna 2013 165 Negace v logickém programování SLDNF rezoluce P normální program, G0 normální číl, R selekční pravidlo: množina SLDNF odvození a podmnožina neúspešných SLDNF odvození číle G0 jsou takové nejmenší množiny, že: & každé SLD+-odvození G0 je SLDNF odvození G0 & je-li SLD+-odvození {G0; C0), ...,Gi blokováno na —A tj. Gi je tvaru : - L\,..., Lm-\, —A, Lm+\,... ,Ln pak a existuje-li SLDNF odvození: -A (pod R) s prázdnou čílovou substitučí, pak {G0; C0), ...,Gi je neúspešné SLDNF odvození & je-li každé úplné SLDNF odvození: -A (pod R) neúspešné pak {G0; Co) i . . . ■> {Gii c) j (: - L1i . . . ■> Lm-1> Lm+1> . . . ■> Ln) je (úspešné) SLDNF odvození cíle G0 c označuje prázdnou čílovou substituči Hana Rudová, Logičké programování I, 15. kvetna 2013 165 Negače v logičkém programování Typy SLDNF odvození Konečné SLDNF-odvození může být: 1. úspešné: Gt = □ 2. neúspešné 3. uvázlé (flounder): Gt je negativní (—A) a : -A je úspešné s neprázdnou čílovou substitučí 4. blokované: Gt je negativní (—A) a : -A nemá konečnou úroveň. Hana Rudová, Logičké programování I, 15. kvetna 2013 166 Negače v logičkém programování Korektnost a úplnost SLDNF odvození -í* korektnost SLDNF-odvozeňí: P normální program, : -G normální cíl a R je selekcní pravidlo: je-li 9 cílová substituce SLDNF-odvození cíle : -G, pak G9 je logickým důsledkem comp(P) Hana Rudová, Logické programování I, 15. kvetna 2013 167 Negace v logickém programování Korektnost a úplnost SLDNF odvození -í* korektnost SLDNF-odvození: P normální program, : -G normální cíl a R je selekcní pravidlo: je-li 9 cílová substituce SLDNF-odvození cíle : -G, pak G9 je logickým dusledkem comp(P) S implementace SLDNF v Prologu není korektní Prolog nereší uvázlé SLDNF-odvození (neprázdná substituce) -i- použití bezpecných cílu (negace neobsahuje promenné) Hana Rudová, Logické programování I, 15. kvetna 2013 167 Negace v logickém programování Korektnost a úplnost SLDNF odvození £ korektnost SLDNF-odvození: P normální program, : -G normální cíl a R je selekcní pravidlo: je-li 9 cílová substituce SLDNF-odvození cíle : -G, pak G9 je logickým důsledkem comp(P) S implementace SLDNF v Prologu není korektní Prolog nereší uvázlé SLDNF-odvození (neprázdná substituce) -i- použití bezpecných cílů (negace neobsahuje promenné) úplnost SLDNF-odvození: SLDNF-odvození není úplné pokud existuje konecný neúspešný strom : -a, pak -a platí ale místo toho se odvozování: -a muže zacyklit, tj. SLDNF rezoluce -a neodvodí == -a tedy sice platí, ale SLDNF rezoluce ho nedokáže odvodit Hana Rudová, Logické programování I, 15. kvetna 2013 167 Negace v logickém programování Logické programování s omezujícími podmínkami Constraint Logic Programming: CLP CP: elektronické materiály & Dechter, R. Constraint Processing. Morgan Kaufmann Publishers, 2003. -i- http://www.ics.uci.edu/~dechter/books/materials.html prUsvitky ke knize Barták R. Prednáška Omezující podmínky na MFF UK, Praha. A http://kti.ms.mff.cuni.cz/~bartak/podminky/index.html & SICStus Prolog User's Manual. Kapitola o CLP(FD). i* http://www.fi.muni.cz/~hanka/sicstus/doc/html/ -í* Príklady v distribuci SICStus Prologu: cca 60 p ríkladů, zdrojový kód i lib/sicstus-*/library/clpfd/examples/ Hana Rudová, Logické programování I, 15. května 2013 169 Logické programování s omezujícími podmínkami Probírané oblasti m Obsah úvod: od LP k CLP & základy programování a základní algoritmy pro rešení problémů s omezujícími podmínkami Hana Rudová, Logické programování I, 15. kvetna 2013 170 Logické programování s omezujícími podmínkami Probírané oblasti m Obsah úvod: od LP k CLP Jt základy programování Jt základní algoritmy pro rešení problémů s omezujíčími podmínkami & Príbuzné prednášky na FI s PA163 Programování s omezujíčími podmínkami viz interaktivní osnova IS *> PA167 Rozvrhování -v http://www.fi.muni.cz/~hanka/rozvrhovani zahrnuty CP tečhniky pro rešení rozvrhovačíčh problémů Hana Rudová, Logičké programování I, 15. kvetna 2013 170 Logičké programování s omezujíčími podmínkami Omezení (constraint) JS> Dána a množina (doménových) promenných Y = jýi,... ,yk} konecná množina hodnot (doména) D = {D1,... ,Dk} Omezení c na Y je podmnožina D1 x ... x Dk a omezuje hodnoty, kterých mohou promenné nabývat soucasne Hana Rudová, Logické programování I, 15. kvetna 2013 171 Logické programování s omezujícími podmínkami Omezení (constraint) JS> Dána a množina (doménových) promenných Y = [ýi,... ,yk} konecná množina hodnot (doména) D = [Di,... ,Dk} Omezení c na Y jě podmnožina Di x ... x Dk S> omězujě hodnoty, ktěrých mohou proměnné nabývat soucasně Príklad: proměnné: A,B domény: {0,1} pro A {1,2} pro B omězění: něbo (A,B) G {(0,1),(0,2),(1,2)} Hana Rudová, Logické programování I, 15. května 2013 171 Logické programování s omězujícími podmínkami Omezení (constraint) JS> Dána a množina (doménových) promenných Y = {y1,... ,yk} konecná množina hodnot (doména) D = {D1,... ,Dk} Omezení c na Y je podmnožina D1 x ... x Dk a omezuje hodnoty, kterých mohou promenné nabývat soucasne m Príklad: a promenné: A,B -i- domény: {0,1} pro A {1,2} pro B omezení: A=B nebo (A,B) g {(0,1),(0,2),(1,2)} & Omezení c definováno na y1, ...yk je splneno, pokud pro d1 g D1, ...dk g Dk platí ... dk) g c -i- príklad (pokracování): omezení splneno pro (0,1), (0, 2), (1,2), není splneno pro (1,1) Hana Rudová, Logické programování I, 15. kvetna 2013 171 Logické programování s omezujícími podmínkami Problém splňování podmínek (CSP) C Dána a konečná množina proměnných X = [xi,... ,xn} it konečná množina hodnot (doména) D = [Di,... ,Dn} it konečná množina omezení C = [ci,cm} omezení je definováno na podmnožině X Problém splňování podmínek je trojice (X,D,C) (constraint satisfaction problem) Hana Rudová, Logické programování I, 15. kvetna 2013 172 Logické programování s omezujícími podmínkami Problém splňování podmínek (CSP) C Dána a konečná množina proměnných X = [xi,... ,xn} it konečná množina hodnot (doména) D = [Di,... ,Dn} it konečná množina omezení C = [ci,cm} omezení je definováno na podmnožině X Problém splňování podmínek je trojice (X,D,C) (constraint satisfaction problem) m Príklad: it promenne: A,B,C Jt domeny: {0,1} pro A {1,2} pro B {0,2} pro C omezení: A=B, B=C Hana Rudová, Logické programování I, 15. kvetna 2013 172 Logické programování s omezujícími podmínkami Rešeňí CSP CásteCňé ohodnocení promeňňých (d1,dk),k < n s* nekteré promenné mají přiřazenu hodnotu Úplňé ohodňoceňí promeňňých (di,dn) & všechny promenné mají prirazenů hodnotu Hana Rudová, Logické programování I, 15. kvetna 2013 173 Logické programování s omezujícími podmínkami Řešení CSP ■v Řástecné ohodnocení promenných (di,dk),k < n s» něktěré proměnné mají prirazěnu hodnotu Úplné ohodnocení promenných (di,dn) & všěchny proměnné mají prirazěnu hodnotu Řešení CSP -fc úplné ohodnocění proměnných, ktěré splnujě všěchna omězění s (didn) g Di x ... x Dn jě rešení (X, D, C) pro každé ci g C na xii,...xik platí (dii,...dik) g ci Hana Rudová, Logické programování I, 15. května 2013 173 Logické programování s omězujícími podmínkami Řešení CSP ■v Cástecné ohodnocení promenných (d1,dk),k < n s» nekteré promenné mají p r i razenu hodnotu Úplné ohodnocení promenných (di,dn) & všechny promenné mají p r i razenu hodnotu Řešení CSP -fc úplné ohodnocení promenných, které splnuje všechna omezení s (d1dn) g D1 x ... x Dn je rešení (X, D, C) pro každé c g C na xii,...xik platí (dii,...dik) g a Hledáme: jedno nebo všechna rešení nebo optimální r ešení (vzhledem k objektivní funkci) Hana Rudová, Logické programování I, 15. kvetna 2013 173 Logické programování s omezujícími podmínkami Příklad: jednoduchý školní rozvrh proměnné: Jan, Petr, ... domény: {3,4, 5,6}, {3,4},... omezení: all_distinct([Jan,Petr,...]) učitel min max Jan 3 6 Petr 3 4 Anna 2 5 Ota 2 4 Eva 3 4 Marie 1 6 Hana Rudová, Logičké programování I, 15. května 2013 174 Logičké programování s omezujíčími podmínkami P ríklad: jednoduchý školní rozvrh promeňňé: Jan, Petr, ... doméňy: {3,4, 5,6}, {3,4},... omezeňí: a11_distinct([Jan,Petr,...]) cástecňé ohodňoceňí: Jan=6, Anna=5, Marie=1 úplňé ohodňoceňí: Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Marie=6 učitel min max Jan 3 6 Petr 3 4 Anna 2 5 Ota 2 4 Eva 3 4 Marie 1 6 Hana Rudová, Logické programování I, 15. kvetna 2013 174 Logické programování s omezujícími podmínkami Príklad: jednoduchý školní rozvrh proměnné: Jan, Petr, ... domény: (3,4, 5,6}, {3,4},... omězění: a11_distinct([Jan,Petr,...]) částečné ohodnocení: Jan=6, Anna=5, Marie=1 úplné ohodnocení: Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Mariě=6 rěšění CSP: Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Marie=1 učitel min max Jan 3 6 Petr 3 4 Anna 2 5 Ota 2 4 Eva 3 4 Marie 1 6 všechna řešení: ješte Jan=6, Petr=4, Anna=5, Ota=2, Eva=3, Marie=1 Hana Rudová, Logické programování I, 15. kvetna 2013 174 Logické programování s omezujícími podmínkami P r íklad: jednodučhý školní rozvrh promenné: Jan, Petr, ... domény: {3,4, 5,6}, {3,4},... omezení: a11_distinct([Jan,Petr,...]) částečné ohodnočení: Jan=6, Anna=5, Marie=1 úplné ohodnočení: Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Marie=6 rešení CSP: Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Marie=1 všečhna rešení: ješte Jan=6, Petr=4, Anna=5, Ota=2, Eva=3, Marie=1 optimálizace: ženy ucí co nejdríve učitel min max Jan 3 6 Petr 3 4 Anna 2 5 Ota 2 4 Eva 3 4 Marie 1 6 Hana Rudová, Logické programování I, 15. kvetna 2013 174 Logické programování s omezujícími podmínkami P ríklad: jednoduchý školní rozvrh & promenné: Jan, Petr, ... -i* domény: {3,4, 5,6}, {3,4},... omezení: a11_distinct([Jan,Petr,...]) JS> cástecné ohodnocení: Jan=6, Anna=5, Marie=1 JS> úplné ohodnocení: Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Marie=6 řešení CSP: Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Marie=1 & všechna rešení: ješte Jan=6, Petr=4, Anna=5, Ota=2, Eva=3, Marie=1 & optimálizace: ženy ucí co nejdříve Anna+Eva+Marie #= Cena minimalizace hodnoty promenné Cena optimální rešení: Jan=6, Petr=4, Anna=5, Ota=2, Eva=3, Marie=1 Hana Rudová, Logické programování I, 15. kvetna 2013 174 Logické programování s omezujícími podmínkami učitel min max Jan 3 6 Petr 3 4 Anna 2 5 Ota 2 4 Eva 3 4 Marie 1 6 CLP(FD) program & Základní struktura CLP programu 1. definice proměnných a jejich domén 2. definice omezení 3. hledání rešení Hana Rudová, Logické programování I, 15. kvetna 2013 175 Logické programování s omezujícími podmínkami CLPCFD) program & Základní struktura CLP programu 1. děfinicě proměnných ajějich domén 2. děfinicě omězění 3. hlědání rěšění & (1) a (2) děklarativní cást modelování problému a vyjádrění problému splnování podmíněk Hana Rudová, Logické programování I, 15. května 2013 175 Logické programování s omězujícími podmínkami CLPCFD) program -i* Základní struktura CLP programu 1. definice proměnných a jejich domén 2. definice omezení 3. hledání r ešení ü> (1) a (2) deklarativní cást Jt modelování problému a vyjád rení problému splnování podmínek -i* (3) r ídící cást & prohledávání stavového prostoru r ešení Jt procedura pro hledání r ešení (enumeraci) se nazývá labeling s> umožní nalézt jedno, všechna nebo optimální řešení Hana Rudová, Logické programování I, 15. kvetna 2013 175 Logické programování s omezujícími podmínkami Kód CLPCFD) programu % základní struktura CLP programu solve( Variables ) declare_variables( Variables ), domain([Jan],3,6], ... Hana Rudová, Logické programování I, 15. května 2013 176 Logické programování s omezujícími podmínkami Kód CLP(FD) programu % základní struktura CLP programu solve( Variables ) declare_variables( Variables ), post_constraints( Variables ), domain([Jan],3,6], ... a11_distinct([Jan,Petr,...]) Hana Rudová, Logičké programování I, 15. kvetna 2G13 176 Logičké programování s omezujíčími podmínkami Kód CLPCFD) programu % základní struktura CLP programu solve( Variables ) :- dec1are_variab1es( Variables ), domain([Jan],3,6], ... post_constraints( Variables ), a11_distinct([Jan,Petr,...]) labelingC Variables ). Hana Rudová, Logické programování I, 15. května 2013 176 Logické programování s omezujícími podmínkami Kód CLPCFD) programu % základní struktura CLP programu solve( Variables ) :- dec1are_variab1es( Variables ), domain([Jan],3,6], ... post_constraints( Variables ), a11_distinct([Jan,Petr,...]) labelingC Variables ). % triviální labeling labelingC [] ). labelingC [Var|Rest] ) :-fd_min(Var,Min), C Var#=Min, labelingC Rest ) % výber nejmenší hodnoty z domény Hana Rudová, Logické programování I, 15. kvetna 2013 176 Logické programování s omezujícími podmínkami Kód CLP(FD) programu % základní struktura CLP programu so1ve( Variables ) :- dec1are_variab1es( Variables ), domain([Jan],3,6], ... post_constraints( Variables ), a11_distinct([Jan,Petr,...]) 1abe1ing( Variables ). % triviální labeling 1abe1ing( [] ). 1abe1ing( [Var|Rest] ) :- fd_min(Var,Min), % výber nejmenší hodnoty z domény ( Var#=Min, 1abe1ing( Rest ) ■ Var#>Min , 1abe1ing( [Var|Rest] ) Hana Rudová, Logičké programování I, 15. kvetna 2G13 176 Logičké programování s omezujíčími podmínkami Príklad: algebrogram Prirad'te čifry 0, ... 9 písmenům S, E, N, D, M, O, R, Y tak, aby platilo: SEND + MORE = MONEY Jt různá písmena mají prirazena různé čifry s S a M nejsou 0 Hana Rudová, Logičké programování I, 15. kvetna 2013 177 Logičké programování s omezujíčími podmínkami Príklad: algebrogram Priraďtě cifry 0, ... 9 písměnům S, E, N, D, M, O, R, Y tak, aby platilo: SEND + MORE = MONEY mzná písměna mají prirazěna různé cifry s S a M nějsou 0 domain([E,N,D,O,R,Y], 0, 9), domain([S,M],1,9) Hana Rudová, Logické programování I, 15. května 2013 177 Logické programování s omězujícími podmínkami P ríklad: algebrogram Přiřaďte cifry 0, ... 9 písmenům S, E, N, D, M, O, R, Y tak, aby platilo: SEND + MORE = MONEY různá písmena mají přiřazena různé cifry s S a M nejsoů 0 domain([E,N,D,O,R,Y], 0, 9), domain([S,M],1,9) 1000*S + 100*E + 10*N + D + 1000*M + 100*0 + 10*R + E #= 10000*M + 1000*0 + 100*N + 10*E + Y Hana Růdová, Logické programování I, 15. kvetna 2013 177 Logické programování s omezujícími podmínkami Príklad: algebrogram Prirad'te čifry 0, ... 9 písmenům S, E, N, D, M, O, R, Y tak, aby platilo: SEND + MORE = MONEY mzná písmena mají prirazena různé čifry s S a M nejsou 0 domain([E,N,D,O,R,Y], 0, 9), domain([S,M],1,9) 1000*S + 100*E + 10*N + D + 1000*M + 100*0 + 10*R + E #= 10000*M + 1000*0 + 100*N + 10*E + Y a11_distinct( [S,E,N,D,M,0,R,Y] ) Hana Rudová, Logičké programování I, 15. kvetna 2013 177 Logičké programování s omezujíčími podmínkami Príklad: algebrogram Priraďtě cifry 0, ... 9 písměnům S, E, N, D, M, O, R, Y tak, aby platilo: SEND + MORE = MONEY mzná písměna mají prirazěna různé cifry s S a M nějsou 0 domain([E,N,D,O,R,Y], 0, 9), domain([S,M],1,9) 1000*S + 100*E + 10*N + D + 1000*M + 100*0 + 10*R + E #= 10000*M + 1000*0 + 100*N + 10*E + Y a11_distinct( [S,E,N,D,M,0,R,Y] ) 1abe1ing( [S,E,N,D,M,0,R,Y] ) Hana Rudová, Logické programování I, 15. května 2013 177 Logické programování s omězujícími podmínkami Od LP k CLP I. -í* CLP: rozšírení logického programování o omezující podmínky -í* CLP systémy se liší podle typu domény -i- CLP(A) generický jazyk -fc CLP(fd) domény promenných jsou konecné (Finite Domains) 3» CLP(R) doménou promenných je množina reálných císel Hana Rudová, Logické programování I, 15. kvetna 2013 178 Logické programování s omezujícími podmínkami Od LP k CLP I. -í* CLP: rozšírení logického programování o omezující podmínky & CLP systémy se liší podle typu domény -i- CLP(A) generický jazyk it CLP(fd) domény promenných jsou konecné (Finite Domains) it CLP(R) doménou promenných je množina reálných císel C Cíl it využít syntaktické a výrazové prednosti LP dosáhnout vetší efektivity Hana Rudová, Logické programování I, 15. kvetna 2013 178 Logické programování s omezujícími podmínkami Od LP k CLP I. -í* CLP: rozšírení logického programování o omezující podmínky -í* CLP systémy se liší podle typu domény -i- CLP(A) generický jazyk -fc CLP(fd) domény promenných jsou konecné (Finite Domains) 3» CLP(R) doménou promenných je množina reálných císel m Cíl ± využít syntaktické a výrazové prednosti LP dosáhnout vetší efektivity Unifikače v LP je nahrazena splnováním podmínek & unifikace se chápe jako jedna z podmínek A = B M A #< B, A in 0..9, domain([A,B],0,9), a11_distinct([A,B,C]) Hana Rudová, Logické programování I, 15. kvetna 2013 178 Logické programování s omezujícími podmínkami Od LP k CLP II. Pro řešení podmínek se používají konzistenCní techniky A consistency techniques, propagace omezení (constraint propagation) £> omezení: A in 0..2, B in 0..2, B #< A Hana Rudová, Logické programování I, 15. května 2013 179 Logické programování s omezujícími podmínkami Od LP k CLP II. Pro rešení podmínek se používají konzistenCní techniky A consistency techniques, propagace omezení (constraint propagation) £> omezení: A in 0..2, B in 0..2, B #< A domény po propagaci omezení B #< A: A in 1..2, B in 0..1 Hana Rudová, Logické programování I, 15. kvetna 2013 179 Logické programování s omezujícími podmínkami Od LP k CLP II. Pro r ešení podmínek se používají konzistenCní techniky it consistency techniques, propagace omezení (constraint propagation) Jt omezení: A in 0..2, B in 0..2, B #< A domény po propagaci omezení B #< A: A in 1..2, B in 0..1 Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky Hana Rudová, Logické programování I, 15. kvetna 2013 179 Logické programování s omezujícími podmínkami Od LP k CLP II. & Pro řešení podmínek se používají konzistenCní techniky A consistency techniques, propagace omezení (constraint propagation) omezení: A in 0..2, B in 0..2, B #< A domény po propagaci omezení B #< A: A in 1..2, B in 0..1 ii> Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky JS> Prohledávání doplneno konzistenCními technikami A in 1..2, B in 0..1, B #< A Hana Rudová, Logické programování I, 15. kvetna 2013 179 Logické programování s omezujícími podmínkami Od LP k CLP II. & Pro rešení podmínek se používají konzistenCní techniky A consistency techniques, propagace omezení (constraint propagation) Á> omezení: A in 0..2, B in 0..2, B #< A domény po propagaci omezení B #< A: A in 1..2, B in 0..1 ii> Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky JS> Prohledávání doplneno konzistenCními technikami A in 1..2, B in 0..1, B #< A -fc po provedení A #=1 se z B #< A se odvodí: B #= 0 Hana Rudová, Logické programování I, 15. kvetna 2013 179 Logické programování s omezujícími podmínkami Od LP k CLP II. & Pro r ešení podmínek se používají konzistenCní techniky A consistency techniques, propagace omezení (constraint propagation) it omezení: A in 0..2, B in 0..2, B #< A domény po propagaci omezení B #< A: A in 1..2, B in 0..1 ii> Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky JS> Prohledávání doplneno konzistencními technikami A in 1..2, B in 0..1, B #< A it po provedení A #=1 se z B #< A se odvodí: B #= 0 & Podmínky jako výstup it kompaktní reprezentace nekonecného poctu r ešení, výstup lze použít jako vstup Hana Rudová, Logické programování I, 15. kvetna 2013 179 Logické programování s omezujícími podmínkami Od LP k CLP II. JS> Pro rešení podmínek se používají konzistenCní techniky it consistency techniques, propagace omezení (constraint propagation) Jt omezení: A in 0..2, B in 0..2, B #< A domény po propagaci omezení B #< A: A in 1..2, B in 0..1 iS> Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky JS> Prohledávání doplneno konzistenCními technikami A in 1..2, B in 0..1, B #< A it po provedení A #=1 se z B #< A se odvodí: B #= 0 iS» Podmínky jako výstup it kompaktní reprezentace nekonecného poctu rešení, výstup lze použít jako vstup Jt dotaz: A in 0..2, B in 0..2, B #< A výstup: A in 1..2, B in 0..1, Hana Rudová, Logické programování I, 15. kvetna 2013 179 Logické programování s omezujícími podmínkami Od LP k CLP II. & Pro r ešení podmínek se používají konzistenCní techniky A consistency techniques, propagace omezení (constraint propagation) it omezení: A in 0..2, B in 0..2, B #< A domény po propagaci omezení B #< A: A in 1..2, B in 0..1 ii> Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky JS> Prohledávání doplneno konzistencními technikami A in 1..2, B in 0..1, B #< A it po provedení A #=1 se z B #< A se odvodí: B #= 0 & Podmínky jako výstup it kompaktní reprezentace nekonecného poctu r ešení, výstup lze použít jako vstup it dotaz: A in 0..2, B in 0..2, B #< A výstup: A in 1..2, B in 0..1, B #< A Hana Rudová, Logické programování I, 15. kvetna 2013 179 Logické programování s omezujícími podmínkami Syntaxe CLP Výběr jazyka omezení CLP klauzule jako LP klauzule, ale její tělo mUže obsahovat omezení daného jazyka p(X,Y) :- X #< Y+1, q(X), r(X,Y,Z). Rezoluční krok v LP A kontrola existence nejobecnejšího unifikátoru (MGU) mezi cílem a hlavou £ Krok odvození v CLP také zahrnuje J* kontrola konzistence aktuální množiny omezení s omezeními v tele klauzule => Vyvolání dvou r ešičů: unifikace + r ešič omezení Hana Rudová, Logické programování I, 15. kvetna 2013 180 Logické programování s omezujícími podmínkami Operační sémantika CLP CLP výpočet cíle G J» Store množina aktivních omezení = prostor omezení (constraint store) & inicializace Store = 0 Jr seznamy cílů v G provádeny v obvyklém poradí a pokud narazíme na cíl s omezením c: NewStore = Store u {c} & snažíme se splnit c vyvoláním jeho rešice pri neúspechu se vyvolá backtracking pri úspechu se podmínky v NewStore zjednoduší propagací omezení &> zbývající cíle jsou provádeny s upraveným NewStore CLP výpocet cíle G je úspešný, pokud se dostaneme z iniciálního stavu (G, 0) do stavu (G',Store), kde G' je prázdný cíl a Store je splnitelná. Hana Rudová, Logické programování I, 15. kvetna 2013 181 Logické programování s omezujícími podmínkami CLPCFD) v SICStus Prologu Systémy a jazyky pro CP J* IBM ILOG CP 1987 Jt omezující podmínky v C++, Jave nebo generickém modelovacím jazyku OPL iľ implementace podmínek založena na objektove orientovaném programování A špickový komercní sw, vznikl ve Francii, nedávno zakoupen IBM J> nyní nove volne dostupný pro akademické použití Hana Rudová, Logické programování I, 15. kvetna 2013 183 CLP(FD) v SICStus Prologu Systémy a jazyky pro CP J* IBM ILOG CP 1987 Jt omezujíčí podmínky v C++, Jave nebo generičkém modelovačím jazyku OPL iľ implementače podmínek založena na objektove orientovaném programování A špičkový komerční sw, vznikl ve Frančii, nedávno zakoupen IBM J> nyní nove volne dostupný pro akademičké použití & Swedish Institute of Computer Science: SICStus Prolog 1985 Jt silná CLP(fl)) knihovna, komerční i akademičké použití Hana Rudová, Logičké programování I, 15. kvetna 2013 183 CLP(FD) v SICStus Prologu Systémy a jazyky pro CP Ji* IBM ILOG CP 1987 it omezující podmínky v C++, Jave nebo generickém modelovacím jazyku OPL it implementace podmínek založena na objektove orientovaném programování it špickový komercní sw, vznikl ve Francii, nedávno zakoupen IBM it nyní nove volne dostupný pro akademické použití & Swedish Institute of Computer Science: SICStus Prolog 1985 it silná CLP(fl)) knihovna, komercní i akademické použití IC-PARC, Imperial College London, Cisco Systems: ECL*PSe 1984 it široké možnosti kooperace mezi ruznými r ešicemi: konecné domény, reálná císla, repair it od 2004 vlastní Cisco Systems volne dostupné pro akademické použití, rozvoj na IC-PARC, platformy: Windows, Linux, Solaris Hana Rudová, Logické programování I, 15. kvetna 2013 183 CLP(FD) v SICStus Prologu Systémy a jazyky pro CP Ji* IBM ILOG CP 1987 A omezující podmínky v C++, Jave nebo generickém modelovacím jazyku OPL iľ implementace podmínek založena na objektove orientovaném programování A špickový komercní sw, vznikl ve Francii, nedávno zakoupen IBM J* nyní nove volne dostupný pro akademické použití & Swedish Institute of Computer Science: SICStus Prolog 1985 -fc silná CLP(fl)) knihovna, komercní i akademické použití IC-PARC, Imperial College London, Cisco Systems: ECL*PSe 1984 J* široké možnosti kooperace mezi ruznými rešicemi: konecné domény, reálná císla, repair Jť od 2004 vlastní Cisco Systems volne dostupné pro akademické použití, rozvoj na IC-PARC, platformy: Windows, Linux, Solaris iS> Mnoho dalších systému: Choco, Gecode, Minion, Oz, SWI Prolog, ... Hana Rudová, Logické programování I, 15. kvetna 2013 183 CLP(FD) v SICStus Prologu CLP(FD) v SICStus Prologu & Vestavené predikáty jsou dostupné v separátním modulu (knihovne) :- use_modu1e(1ibrary(c1pfd)). Obecné principy platné všude nicméne standarty jsou nedostatecné Jt stejné/podobné vestavené predikáty existují i jinde s CLP knihovny v SWI Prologu i ECLiPSe se liší Hana Rudová, Logické programování I, 15. kvetna 2013 184 CLPCFD) v SICStus Prologu Príslušnost k doméne: Range termy -i* ?- domain( [A,B], 1,3). domain( +Variab1es, +Min, +Max) A in 1..3 B in 1..3 Hana Rudová, Logické programování I, 15. května 2013 185 CLP(FD) v SICStus Prologu Príslušnost k doméne: Range termy -i* ?- domain( [A,B], 1,3). domain( +Variab1es, +Min, +Max) A in 1..3 B in 1..3 B ?- a in 1..8, A #\= 4. ?X in +Min..+Max A in (1..3) \/ (5..8) Hana Rudová, Logické programování I, 15. kvetna 2013 185 CLP(FD) v SICStus Prologu Příslušnost k doméne: Range termy -i* ?- domain( [A,B], 1,3). domain( +Variab1es, +Min, +Max) A in 1..3 B in 1..3 B ?- a in 1..8, A #\= 4. ?X in +Min..+Max A in (1..3) \/ (5..8) & Doména reprezentována jako posloupnost intervalů celých císel M ?- a in (1..3) \/ (8..15) \/ C5..9) \/ {100}. ?X in +Range A in (1..3) \/ (5..15) \/ {100} Hana Rudová, Logické programování I, 15. kvetna 2013 185 CLP(FD) v SICStus Prologu Príslušnost k doméne: Range termy i& ?- domain( [A,B], 1,3). domain( +Variables, +Min, +Max) A in 1..3 B in 1..3 Jfc ?- A in 1..8, A #\= 4. ?X in +Min..+Max A in (1..3) \/ (5..8) & Doména reprezentována jako posloupnost intervalů čelýčh čísel M ?- a in (1..3) \/ (8..15) \/ (5..9) \/ {100}. ?X in +Range A in (1..3) \/ (5..15) \/ {100} Zjištení domény Range promenné Var: fd_dom(?Var,?Range) A in 1..8, A #\= 4, fd_dom(A,Range). Range=(1..3) \/ (5..8) Hana Rudová, Logičké programování I, 15. kvetna 2013 185 CLP(FD) v SICStus Prologu P r íslušnost k doméne: Range termy -i* ?- domain( [A,B], 1,3). domain( +Variab1es, +Min, +Max) A in 1..3 B in 1..3 B ?- a in 1..8, A #\= 4. ?X in +Min..+Max A in (1..3) \/ (5..8) & Doména reprezentována jako posloupnost intervalů celých císel M ?- a in (1..3) \/ (8..15) \/ C5..9) \/ {100}. ?X in +Range A in (1..3) \/ (5..15) \/ {100} Zjištení domény Range promenné Var: fd_dom(?Var,?Range) A in 1..8, A #\= 4, fd_dom(A,Range). Range=(1..3) \/ (5..8) M A in 2..10, fd_dom(A,(1..3) \/ (5..8)). no Hana Rudová, Logické programování I, 15. kvetna 2013 185 CLP(FD) v SICStus Prologu P r íslušnost k doméne: Range termy i& ?- domain( [A,B], 1,3). domain( +Variab1es, +Min, +Max) A in 1..3 B in 1..3 B ?- a in 1..8, A #\= 4. ?X in +Min..+Max A in (1..3) \/ (5..8) & Doména reprezentována jako posloupnost intervalů celých císel M ?- a in (1..3) \/ (8..15) \/ C5..9) \/ {100}. ?X in +Range A in (1..3) \/ (5..15) \/ {100} Zjištení domény Range promenné Var: fd_dom(?Var,?Range) A in 1..8, A #\= 4, fd_dom(A,Range). Range=(1..3) \/ (5..8) A in 2..10, fd_dom(A,(1..3) \/ (5..8)). no -í* Range term: reprezentace nezávislá na implementaci Hana Růdová, Logické programování I, 15. kvetna 2013 185 CLP(FD) v SICStůs Prologů Príslušnost k doméne: FDSet termy C FDSet těrm: rěprězěntacě závislá na implěměntaci J ?- A in 1..8, A#\= 4, fd_set(A,FDSet). A in (1..3) \/ C5..8) FDSet = [[1|3],[5|8]] fd_set(?Var,?FDSet) Hana Rudová, Logické programování I, 15. května 2013 186 CLP(FD) v SICStus Prologu Príslušnost k doméne: FDSet termy C FDSet term: reprezentace závislá na implementaci M ?- A in 1..8, A #\= 4, fd_set(A,FDSet). fd_set(?Var,?FDSet) A in (1..3) \/ C5..8) FDSet = [[1|3],[5|8]] J ?- A in 1..8.A #\= 4, fd_set(A,FDSet),B in_set FDSet. ?X in_set +FDSet A in (1..3) \/ C5..8) FDSet = [[1|3],[5|8]] B in (1..3) \/ C5..8) Hana Rudová, Logické programování I, 15. kvetna 2013 186 CLP(FD) v SICStus Prologu Príslušnost k doméne: FDSet termy C FDSet term: reprezentače závislá na implementači M ?- A in 1..8, A #\= 4, fd_set(A,FDSet). fd_set(?Var,?FDSet) A in (1..3) \/ C5..8) FDSet = [[1|3],[5|8]] J ?- A in 1..8.A #\= 4, fd_set(A,FDSet),B in_set FDSet. ?X in_set +FDSet A in (1..3) \/ C5..8) FDSet = [[1|3],[5|8]] B in (1..3) \/ C5..8) & FDSet termy predstavují nízko-úrovnovou implementači FDSet termy nedoporučeny v programečh -k používat pouze predikáty pro manipulači s nimi -i- omezit použití A in_set [[1|2],[6|9]] & Range termy preferovány Hana Rudová, Logičké programování I, 15. kvetna 2013 186 CLP(FD) v SICStus Prologu Další fd_... predikáty fdset_to_1ist(+FDset, -List) vrací do seznamů prvky FDset & 1ist_to_fdset(+List, -FDset) vrací FDset odpovídající seznamů fd_var(?Var) je Var doménová promenná? fd_min(?Var,?Min) nejmenší hodnota v doméne fd_max(?Var,?Max) nejvetší hodnota v doméne fd_size(?Var,?Size) velikost domény fd_degree(?Var,?Degree) pocet navázaných omezení na promenné iľ mení se behem výpoctů: poůze aktivní omezení, i odvozená aktivní omezení Hana Růdová, Logické programování I, 15. kvetna 2013 187 CLP(FD) v SICStůs Prologů Aritmetičká omezení J> Expr RelOp Expr RelOp -> #= | #\= | #< | #=< | #> | #>= A A + B #=< 3, A #\= (C - 4) * ( D - 5), A/2 #= 4 A POZOR: neplést #=< a #>= s operátory pro implikaci: #<= #=> Hana Rudová, Logické programování I, 15. kvetna 2013 188 CLP(FD) v SICStus Prologu Aritmetická omezení J* Expr RelOp Expr RelOp -> #= I #\= I #< I #=< I #> I #>= A A + B #=< 3, A #\= (C - 4) * (D - S), A/2 #= 4 A POZOR: neplést #=< a #>= s operátory pro implikaci: #<= #=> & sum(Variab1es,Re1Op,Suma) domain([A,B,C,F],1,3), sum([A,B,C],#= ,F) & Variables i Suma musí být doménové promenné nebo celá císla Hana Rudová, Logické programování I, 1S. kvetna 201S 188 CLP(FD) v SICStus Prologu Aritmetičká omezení J> Expr RelOp Expr RelOp -> #= | #\= | #< | #=< | #> | #>= A A + B #=< 3, A #\= (C - 4) * ( D - 5), A/2 #= 4 A POZOR: neplést #=< a #>= s operátory pro implikaci: #<= #=> & sum(Variab1es,Re1Op,Suma) domain([A,B,C,F],1,3), sum([A,B,C],#= ,F) S> Variables i Suma musí být doménové promenné nebo celá císla sca1ar_product(Coeffs,Variab1es,Re1Op,Sca1arProduct) M domain([A,B,C,F],1,6), sca1ar_product( [1,2,3],[A,B,C],#= ,F) iľ Variab1es i Va1ue musí být doménové promenné nebo celá císla, Coeffs jsou celá císla POZOR na poradí argumentu, nejprve jsou celoaselné koeficienty, pak dom. promenné 3 sca1ar_product(Coeffs, Variab1es, #= , Va1ue, [consistency(domain)]) silnejší typ konzistence POZOR: domény musí mít konecné hranice Hana Rudová, Logické programování I, 15. kvetna 2013 188 CLP(FD) v SICStus Prologu Základní globální omezení all_distinct(l_ist) M všechny proměnné různé cumulative(...) disjunktivní a kumulativní rozvrhování cumulatives(...) kumulativní rozvrhování na více zdrojů Hana Rudová, Logické programování I, 15. května 2013 189 CLP(FD) v SICStus Prologu proměnné ruzne a11_distinct(Variab1es), a11_different(Variab1es) ü> Proměnné v seznamu Variab1es jsou různé a11_distinct a a11_different se liší úrovní propagace a a11_distinct má úplnou propagaci s» a11_different má slabší (neúplnou) propagaci Hana Rudová, Logické programování I, 15. kvetna 2013 190 CLP(FD) v SICStus Prologu Všechny proměnné různé all_distinct(Variables), a11_different(Variab1es) Proměnné v seznamu Variables jsou různé a11_distinct a a11_different se liší úrovní propagace a a11_distinct má úplnou propagaci a a11_different má slabší (neúplnou) propagaci Príklad: uCitelé musí uCit v mzné hodiny uCitel min max Jan 3 6 Petr 3 4 Anna 2 5 Ota 2 4 Eva 3 4 Marie 1 6 Hana Rudová, Logické programování I, 15. kvetna 2013 190 CLP(FD) v SICStus Prologu Všechny promenné různé a11_distinct(Variab1es), a11_different(Variab1es) Proměnné v sěznamu Variab1es jsou různé a11_distinct a a11_different sě liší úrovní propagacě a a11_distinct má úplnou propagaci a a11_different má slabší (něúplnou) propagaci Príklad: ucitělé musí ucit v mzné hodiny a11_distinct([Jan,Petr,Anna,0ta,Eva,Marie]) Jan = 6, 0ta = 2, Anna = 5, Marie = 1, Petr in 3..4, Eva in 3..4 učitel min max Jan 3 6 Petr 3 4 Anna 2 5 Ota 2 4 Eva 3 4 Marie 1 6 Hana Rudová, Logické programování I, 15. května 2013 190 CLP(FD) v SICStus Prologu Všechny promenné různé a11_distinct(Variab1es), a11_different(Variab1es) Promenné v seznamu Variab1es jsou různé a11_distinct a a11_different se liší úrovní propagace a a11_distinct má úplnou propagaci a a11_different má slabší (neúplnou) propagaci Príklad: ucitelé musí ucit v mzné hodiny a11_distinct([Jan,Petr,Anna,Ota,Eva,Marie]) Jan = 6, Ota = 2, Anna = 5, Marie = 1, Petr in 3..4, Eva in 3..4 3 a11_different([Jan,Petr,Anna,Ota,Eva,Marie]) Jan in 3..6, Petr in 3..4, Anna in 2..5, Ota in 2..4, Eva in 3..4, Marie in 1..6 učitel min max Jan 3 6 Petr 3 4 Anna 2 5 Ota 2 4 Eva 3 4 Marie 1 6 Hana Rudová, Logické programování I, 15. kvetna 2013 190 CLP(FD) v SICStus Prologu Disjunktivní rozvrhování (unární zdroj) ifc cumulative([task(Start, Duration, End, 1, Id) | Tasks]) iS> Rozvržení úloh zadaných startovním a koncovým casem (Start,End), dobou trvání (nezáporné Duration) a identifikátorem (Id) tak, aby se nepřekrývaly Hana Rudová, Logické programování I, 15. kvetna 2013 191 CLP(FD) v SICStus Prologu Disjunktivní rozvrhování (unární zdroj) ifc cumu1ative([task(Start, Duration, End, 1, Id) | Tasks]) iS> Rozvržení úloh zadaných startovním a koncovým casem (Start,End), dobou trvání (nezáporné Duration) a identifikátorem (Id) tak, aby se nepřekrývaly A príklad s konstantami: cumu1ative([task(0,2,2,1,1), task(3,1,4,1,2), task(5,1,6,1,3)]) f. 3 1 2 3 4 5 6 Hana Rudová, Logické programování I, 15. kvetna 2013 191 CLP(FD) v SICStus Prologu Disjunktivní rozvrhování (unární zdroj) ifc cumulative([task(Start, Duration, End, 1, Id) | Tasks]) iS> Rozvržení úloh zadaných startovním a koncovým casem (Start,End), dobou trvání (nezáporné Duration) a identifikátorem (Id) tak, aby se neprekrývaly Jt príklad s konstantami: cumulative([task(0,2,2,1,1), task(3,1,4,1,2), task(5,1,6,1,3)]) f. í 2 3 12 3 4 5 6 ± príklad: vytvorení rozvrhu, za predpokladu, že doba trvání hodin není stejná Hana Rudová, Logické programování I, 15. kvetna 2013 191 CLP(FD) v SICStus Prologu Disjunktivní rozvrhování (unární zdroj) ifc cumulative([task(Start, Duration, End, 1, Id) | Tasks]) iS> Rozvržení úloh zadaných startovním a koncovým casem (Start,End), dobou trvání (nezáporné Duration) a identifikátorem (Id) tak, aby se nepřekrývaly A príklad s konstantami: cumulative([task(0,2,2,1,1), task(3,1,4,1,2), task(5,1,6,1,3)]) f. í 2 3 12 3 4 5 6 ± příklad: vytvoření rozvrhu, za předpokladu, že doba trvání hodin není stejná JanE#= Jan+3, PetrE#= Petr+1, AnnaE#= Anna+2, ... cumulative(taskOan,3,JanE,1,1),task(Petr,1,PetrE,1,2),task(Anna,2,AnnaE,1,3), task(Ota,2,OtaE,1,4),task(Eva,2,EvaE,1,5),task(Marie,3,MarieE,1,6)]) Hana Rudová, Logické programování I, 15. kvetna 2013 191 CLP(FD) v SICStus Prologu Kumulativní rozvrhování & cumu1ative([task(Start,Duration,End,Demand,TaskId) | Tasks], [limit(Limit)]) & Rozvržení úloh zadaných startovním a koncovým casem (Start,End), dobou trvání (nezáporné Duration), požadovanou kapacitou zdroje (Demand) a identifikátorem (Id) tak, aby se nep r ekrývaly a aby celková kapacita zdroje nikdy nep r ekrocila Limit Hana Rudová, Logické programování I, 15. kvetna 2013 192 CLP(FD) v SICStus Prologu Kumulativní rozvrhování & cumu1ative([task(Start,Duration,End,Demand,TaskId) | Tasks], [limit(Limit)]) & Rozvržení úloh zadaných startovním a koncovým casem (Start,End), dobou trvání (nezáporné Duration), požadovanou kapacitou zdroje (Demand) a identifikátorem (Id) tak, aby se nepřekrývaly a aby celková kapacita zdroje nikdy neprekrocila Limit ií> Príklad s konstantami: cumu1ative([task(Q,4,4,1,1),task(1,2,3,2,2),task(3,3,6,2,3),task(4,2,6,1,4)],[1imit(3)]) 2 4 3 1 T Hana Rudová, Logické programování I, 15. kvetna 2013 ^ 192 ^ ^ ° u CLP(FD) v SICStus Prologu Kumulativní rozvrhování s více zdroji Rozvržení úloh tak, aby se nep r ekrývaly a daná kapacita zdrojů nebyla p r ekrocena (limit zdroje chápán jako horní mez - bound(upper)) cumu1atives([task(Start,Duration,End,Demand,MachineId)|Tasks], [machine(Id,Limit)|Machines],[bound(upper)]) Úlohy zadány startovním a koncovým casem (Start,End), dobou trvání (nezáporné Duration), požadovanou kapacitou zdroje (Demand) a požadovaným typem zdroje (MachineId) Zdroje zadány identifikátorem (Id) a kapacitou (Limit) Hana Rudová, Logické programování I, 15. kvetna 2013 193 CLP(FD) v SICStus Prologu Kumulativní rozvrhování s více zdroji i& Rozvržení úloh tak, aby se neprekrývaly a daná kapacita zdrojů nebyla prekrocena (limit zdroje chápán jako horní mez - bound(upper)) iS> cumu1atives([task(Start,Duration,End,Demand, MachineId)|Tasks], [machine(Id,Limit)|Machines],[bound(upper)]) & Úlohy zadány startovním a koncovým ccasem (Start,End), doboů trvání (nezáporné Duration), požadovanoů kapacitoů zdroje (Demand) a požadovaným typem zdroje (MachineId) & Zdroje zadány identifikátorem (Id) a kapacitoů (Limit) m Príklad: ?- domain([B,C],1,2), cumu1atives([task(0,4,4,1,1),task(3,1,4,1,B), task(5,1,6,1,C)], [machine(1,1),machine(2,1)], [bound(upper)]). C in 1..2, B=2 Hana Růdová, Logické programování I, 15. kvetna 2013 193 CLP(FD) v SICStůs Prologů Príklad: kumulativní rozvrhování C Vytvortě rozvrh pro náslědující úlohy, tak aby něbyla prěkrocěna kapacita 13 zdrojě, a minimalizujte cělkovou dobu trvání úloha doba trvání kapacita t1 16 2 t2 6 9 t3 13 3 t4 7 7 t5 5 10 t6 18 1 t7 4 11 Hana Rudová, Logické programování I, 15. května 2013 194 CLP(FD) v SICStus Prologu Řešení: kumulativní rozvrhování | ?- schedu1e(13, [16,6,13,7,5,18,4], [2,9,3,7,10,1,11], 69, Ss, End). Ss = [0,16,9,9,4,4,0], End = 22 ? Hana Růdová, Logické programování I, 15. kvetna 2013 195 CLP(FD) v SICStůs Prologů Řešení: kumulativní rozvrhování | ?- schedule(13, [16,6,13,7,5,18,4], [2,9,3,7,10,1,11], 69, Ss, End). Ss = [0,16,9,9,4,4,0], End = 22 ? schedule(Lirrnt, Ds, Rs, MaxCas, Ss, End) Hana Rudová, Logické programování I, 15. května 2013 195 CLP(FD) v SICStus Prologu Řešení: kumulativní rozvrhování | ?- schedu1e(13, [16,6,13,7,5,18,4], [2,9,3,7,10,1,11], 69, Ss, End). Ss = [0,16,9,9,4,4,0], End = 22 ? schedu1e(l_imit, Ds, Rs, MaxCas, Ss, End) :-domain(Ss, 0, MaxCas), End in 0..MaxCas, Hana Rudová, Logické programování I, 15. kvetna 2013 195 CLP(FD) v SICStus Prologu Řešení: kumulativní rozvrhování | ?- schedule(13, [16,6,13,7,5,18,4], [2,9,3,7,10,1,11], 69, Ss, End). Ss = [0,16,9,9,4,4,0], End = 22 ? schedule(l_imit, Ds, Rs, MaxCas, Ss, End) :-domain(Ss, 0, MaxCas), End in 0..MaxCas, vytvor_ulohy(Ss,Ds,Rs,1,Tasks), Hana Rudová, Logické programování I, 15. kvetna 2013 195 CLP(FD) v SICStus Prologu Řešení: kumulativní rozvrhování | ?- schedule(13, [16,6,13,7,5,18,4], [2,9,3,7,10,1,11], 69, Ss, End). Ss = [0,16,9,9,4,4,0], End = 22 ? schedule(l_imit, Ds, Rs, MaxCas, Ss, End) :-domain(Ss, 0, MaxCas), End in 0..MaxCas, vytvor_ulohy(Ss,Ds,Rs,1,Tasks), cumulative(Tasks, [limit(Limit)]), Hana Růdová, Logické programování I, 15. kvetna 2013 195 CLP(FD) v SICStůs Prologů Řešení: kumulativní rozvrhování | ?- schedule(13, [16,6,13,7,5,18,4], [2,9,3,7,10,1,11], 69, Ss, End). Ss = [0,16,9,9,4,4,0], End = 22 ? schedule(Lirrnt, Ds, Rs, MaxCas, Ss, End) domain(Ss, 0, MaxCas), End in 0..MaxCas, vytvor_ulohy(Ss,Ds,Rs,1,Tasks), cumulative(Tasks, [limit(Limit)]), after(Ss, Ds, End), % koncový Cas Hana Rudová, Logické programování I, 15. kvetna 2013 195 CLP(FD) v SICStus Prologu Řešení: kumulativní rozvrhování | ?- schedule(13, [16,6,13,7,5,18,4], [2,9,3,7,10,1,11], 69, Ss, End). Ss = [0,16,9,9,4,4,0], End = 22 ? schedule(Lirrnt, Ds, Rs, MaxCas, Ss, End) domain(Ss, 0, MaxCas), End in 0..MaxCas, vytvor_ulohy(Ss,Ds,Rs,1,Tasks), cumulative(Tasks, [limit(Limit)]), after(Ss, Ds, End), % koncovýCas append(Ss, [End], Vars), Hana Rudová, Logické programování I, 15. května 2013 195 CLP(FD) v SICStus Prologu Řešení: kumulativní rozvrhování | ?- schedule(13, [16,6,13,7,5,18,4], [2,9,3,7,10,1,11], 69, Ss, End). Ss = [0,16,9,9,4,4,0], End = 22 ? schedule(Limit, Ds, Rs, MaxCas, Ss, End) :-domain(Ss, 0, MaxCas), End in 0..MaxCas, vytvor_ulohy(Ss,Ds,Rs,1,Tasks), cumulative(Tasks, [limit(Limit)]), after(Ss, Ds, End), % koncový Cas append(Ss, [End], Vars), labeling([minimize(End)],Vars). Hana Rudová, Logické programování I, 15. kvetna 2013 195 CLP(FD) v SICStus Prologu Řešení: kumulativní rozvrhování | ?- schedule(13, [16,6,13,7,5,18,4], [2,9,3,7,10,1,11], 69, Ss, End). Ss = [0,16,9,9,4,4,0], End = 22 ? schedule(Limit, Ds, Rs, MaxCas, Ss, End) :-domain(Ss, 0, MaxCas), End in 0..MaxCas, vytvor_ulohy(Ss,Ds,Rs,1,Tasks), cumulative(Tasks, [limit(Limit)]), after(Ss, Ds, End), % koncový Cas append(Ss, [End], Vars), labeling([minimize(End)],Vars). vytvor_ulohy([],[],[],_Id,[]). vytvor_ulohy([S|Ss], [D|Ds], [R|Rs], Id, [task(S,D,E,R,Id)|Tasks]):-NewId is Id+1, E #= S+D, vytvor_ulohy(Ss,Ds,Rs, NewId,Tasks). Hana Rudová, Logické programování I, 15. kvetna 2013 195 CLP(FD) v SICStus Prologu Řešení: kumulativní rozvrhování | ?- schedule(13, [16,6,13,7,5,18,4], [2,9,3,7,10,1,11], 69, Ss, End). Ss = [0,16,9,9,4,4,0], End = 22 ? schiedule(Lirrnt, Ds, Rs, MaxCas, Ss, End) domain(Ss, 0, MaxCas), End in 0..MaxCas, vytvor_ulohy(Ss,Ds,Rs,1,Tasks), cumulative(Tasks, [limit(Limit)]), after(Ss, Ds, End), % koncovýCas append(Ss, [End], Vars), labeling([minimize(End)],Vars). vytvor_ulohy([],[],[],_Id,[]). vytvor_ulohy([S|Ss], [D|Ds], [R|Rs], Id, [task(S,D,E,R,Id)|Tasks]):-NewId is Id+1, E #= S+D, vytvor_ulohy(Ss,Ds,Rs, NewId,Tasks). after([], [], _). after([S|Ss], [D|Ds], End) E #>= S+D, after(Ss, Ds, End). Hana Rudová, Logické programování I, 15. kvetna 2013 195 CLP(FD) v SICStus Prologu Vestavěné predikáty pro labeling Instanciacě proměnné Variab1e hodnotami vjějí doméně indomain( Variab1e ) hodnoty jsou instanciovány pri backtrackingu vě vzrůstajícím poradí ?- X in 4..5, indomain(X). X = 4 ? ; X = 5 ? Hana Rudová, Logické programování I, 15. května 2013 196 CLP(FD) v SICStus Prologu Vestavené predikáty pro labeling Instanciace promenné Variab1e hodnotami v její doméne indomain( Variab1e ) hodnoty jsou instanciovány pri backtrackingu ve vzrůstajícím poradí ?- X in 4..5, indomain(X). X = 4 ? ; X = 5 ? 1abe1ing( [] ). 1abe1ing( [Var|Rest] ) :- % výber nejlevejší promenné k instanciaci indomain( Var ), % výber hodnot ve vzrustajícím poradí 1abe1ing( Rest ). Hana Rudová, Logické programování I, 15. kvetna 2013 196 CLP(FD) v SICStus Prologu Vestavěné predikáty pro labeling Instanciace proměnné Variable hodnotami v její doméně indomain( Variable ) hodnoty jsou instanciovány pri backtrackingu ve vzrůstajícím poradí ?- X in 4..5, indomain(X). X = 4 ? ; X = 5 ? 1abe1ing( [] ). 1abe1ing( [Var|Rest] ) :-indomain( Var ), 1abe1ing( Rest ). % výběr nejlevější proměnné k instanciaci % výběr hodnot ve vzrUstajícím poradí M 1abe1ing( Options, Variab1es ) ?- A in 0..2, B in 0..2, B#< A, 1abe1ing([], [A,B]). Hana Rudová, Logické programování I, 15. května 2013 196 CLP(FD) v SICStus Prologu Uspořádání hodnot a proměnných Při prohledávání je rozhodující uspořádání hodnot a proměnných Určují je heuristiky výběru hodnot a výběru proměnných labeling( [] ). labeling( Variables ) select_van'able(Van'ables,Var,Rest), select_value(Var,Value), Hana Rudová, Logické programování I, 15. kvetna 2013 197 CLP(FD) v SICStus Prologu Uspořádání hodnot a proměnných Pri prohledávání je rozhodující uspořádání hodnot a proměnných UrCujíje heuristiky výběru hodnot a výběru proměnných labeling( [] ). labeling( Variables ) :- select_variable(Variables,Var,Rest), select_value(Var,Value), ( Var #= Value, labeling( Rest ) Hana Rudová, Logické programování I, 15. května 2013 197 CLP(FD) v SICStus Prologu Uspo rádání hodnot a proměnných & Pr i prohledávání je rozhodující uspo rádání hodnot a promenných Urcujíje heuristiky výberu hodnot a výberu promenných 1abe1ing( [] ). 1abe1ing( Variab1es ) :- se1ect_variab1e(Variab1es,Var,Rest), se1ect_va1ue(Var,Va1ue), ( Var #= Va1ue, 1abe1ing( Rest ) Var #\=Va1ue , % nemusí dojít k instanciaci Var 1abe1ing( Variab1es ) % proto pokracujeme se všemi promennými vcetne Var Hana Rudová, Logické programování I, 15. kvetna 2013 197 CLP(FD) v SICStus Prologu Usporádání hodnot a proměnných & Pri prohlědávání jě rozhodující usporádání hodnot a promenných Urcujíjě heuristiky výberu hodnot a výberu promenných 1abe1ing( [] ). 1abe1ing( Variab1es ) :- se1ect_variab1e(Variab1es,Var,Rest), se1ect_va1ue(Var,Va1ue), ( Var #= Va1ue, 1abe1ing( Rest ) Var #\=Va1ue , % němusí dojít k instanciaci Var 1abe1ing( Variab1es ) % proto pokracujěmě sě všěmi proměnnými vcětně Var & Statické uspořádání: urcěno už prěd prohlědáváním JS> Dynamické usporádání: pocítá sě běhěm prohlědávání Hana Rudová, Logické programování I, 15. května 2013 197 CLP(FD) v SICStus Prologu Výber hodnoty JS> Obecný princip výberu hodnoty: první úspech (succeed first) J* volíme poradí tak, abychom výber nemuseli opakovat ?- domain([A,B,C],1,2), A#=B+C. Hana Rudová, Logické programování I, 15. kvetna 2013 198 CLP(FD) v SICStus Prologu Výběr hodnoty JS> Obecný princip výběru hodnoty: první úspěch (succeed first) J* volíme po radí tak, abychom výběr nemuseli opakovat A ?- domain([A,B,C],1,2), A#=B+C. optimální výber A=2,B=1,C=1 je bez backtrackingu Hana Rudová, Logické programování I, 15. kvetna 2013 198 CLP(FD) v SICStus Prologu Výber hodnoty JS> Obecný princip výberu hodnoty: první úspech (succeed first) J* volíme poradí tak, abychom výber nemuseli opakovat A ?- domain([A,B,C],1,2), A#=B+C. optimální výber A=2,B=1,C=1 je bez backtrackingu & Parametry labeling/2 ovlivnující výber hodnoty pr. 1abe1ing([down], Vars) -i- up: doména procházena ve vzrůstajícím poradí (default) -fc down: doména procházena v klesajícím poradí Hana Rudová, Logické programování I, 15. kvetna 2013 198 CLP(FD) v SICStus Prologu Výber hodnoty JS> Obecný princip výberu hodnoty: první úspech (succeed first) J* volíme poradí tak, abychom výber nemuseli opakovat Jt ?- domain([A,B,C],1,2), A#=B+C. optimální výber A=2,B=1,C=1 je bez backtrackingu & Parametry labeling/2 ovlivnující výber hodnoty pr. 1abe1ing([down], Vars) -i- up: doména procházena ve vzrůstajícím poradí (default) Jt down: doména procházena v klesajícím poradí C- Parametry labeling/2 rídící, jak je výber hodnoty realizován j- step: volba mezi X #= M, X #\= M (default) viz drívejší príklad u "Usporádání hodnot a promenných" Jt enum: vícenásobná volba mezi všemi hodnotami v doméne podobne jako pri indomain/1 Hana Rudová, Logické programování I, 15. kvetna 2013 198 CLP(FD) v SICStus Prologu Výber promenné Obecný princip výberu promenné: first-fail výber promenné, pro kterou je nejobtížnejší nalézt správnou hodnotu pozdejší výber hodnoty pro tuto promennou by snadneji vedl k failu Jt výbereme promennou s nejmenší doménou ?- domain([A,B,C],1,3), A#<3, A#=B+C. Hana Rudová, Logické programování I, 15. kvetna 2013 199 CLP(FD) v SICStus Prologu Výběr proměnné Obecný princip výběru proměnné: first-fail výber promenné, pro kterou je nejobtížnejší nalézt správnou hodnotu pozdejší výber hodnoty pro tuto promennou by snadneji vedl k failu vybereme promennou s nejmenší doménou ?- domain([A,B,C],1,3), A#<3, A#=B+C. nejlépe je zacít s výberem A Hana Rudová, Logické programování I, 15. kvetna 2013 199 CLP(FD) v SICStus Prologu Výber promenné Obecný princip výberů promenné: first-fail výber promenné, pro kteroů je nejobtížnejší nalézt správnoů hodnotů pozdejší výber hodnoty pro tůto promennoů by snadneji vedl k failů A výbereme promennoů s nejmenší doménou J* ?- domain([A,B,C],1,3), A#<3, A#=B+C. nejlépe je zacít s výberem A Parametry 1abe1ing/2 ovlivnůjící výber promenné -i- 1eftmost: nejlevejší (defaůlt) M ff: s (1) nejmenší velikostí domény fd_size(Var,Size) (2) (pokůd s nejmenší velikostí domény více, tak) nejlevejší z nich Hana Růdová, Logické programování I, 15. kvetna 2013 199 CLP(FD) v SICStůs Prologů Výběr proměnné Obecný princip výberu promenné: first-fail výber promenné, pro kterou je nejobtížnejší nalézt správnou hodnotu pozdejší výber hodnoty pro tuto promennou by snadneji vedl k failu výbereme promennou s nejmenší doménou ?- domain([A,B,C],1,3), A#<3, A#=B+C. nejlépe je zacít s výberem A & Parametry 1abe1ing/2 ovlivnující výber promenné -i- 1eftmost: nejlevejší (default) M ff: s (1) nejmenší velikostí domény fd_size(Var,Size) (2) (pokud s nejmenší velikostí domény více, tak) nejlevejší z nich s> ffc: s (1) nejmenší velikostí domény (2) nejvetším množstvím omezením „cekajících" na promenné fd_degree(Var,Size) (3) nejlevejší z nich min/max: s (1) nejmenší/nejvetší hodnotou v doméne promenné (2) nejlevnejšíz nich fd_min(Var,Min)/fd_max(Var,Max) Hana Rudová, Logické programování I, 15. kvetna 2013 199 CLP(FD) v SICStus Prologu rešení (predpokládejme minimalizaci) Parametry 1abe1ing/2 pro optimalizaci: minimize(F)/maximize(F) it Cena #= A+B+C, 1abe1ing([minimize(Cena)], [A,B,C]) Metoda vetví a mezí (branch&bound) Jt algoritmus, který implementuje proceduru pro minimalizaci (duálne pro maximalizaci) -i- uvažujeme nejhorší možnou cenu r ešení UB (nap r . cena už nalezeného rešení) Jt pocítáme dolní odhad LB ceny cástecného r ešení LB je tedy nejlepší možná cena pro rozšír ení tohoto r ešení procházíme strom a vyžadujeme, aby prozkoumávaná vetev mela cenu LB < UB pokud je LB > UB, tak víme, že v této vetvi není lepší rešení a od r ízneme ji p r idává se tedy inkrementálne omezení LB# 0 c4: x2 + x5 - x6 = 0 Hana Rudová, Logické programování I, 15. kvetna 2013 202 3 Algoritmy pro CSP Binární CSP M Binární CSP i* CSP, ve kterém jsou pouze binární podmínky Jt unární podmínky zakódovány do domény promenné JS> Graf podmínek pro binární CSP A není nutné uvažovat hypergraf, stací graf (podmínka spojuje pouze dva vrcholy) Hana Rudová, Logické programování I, 15. kvetna 2013 203 Algoritmy pro CSP Binární CSP M Binární CSP i* CSP, vě ktěrém jsou pouzě binární podmínky unární podmínky zakódovány do domény proměnné JS> Graf podmínek pro binární CSP A nění nutné uvažovat hypěrgraf, stací graf (podmínka spojujě pouzě dva vrcholy) & Každý CSP lze transformovat na "korespondující" binární CSP iS* Výhody a něvýhody binarizacě 3 získávámě unifikovaný tvar CSP problému, rada algoritmu navržěna pro binární CSP -fc bohužěl alě znacné zvětšění vělikosti problému Hana Rudová, Logické programování I, 15. května 2013 203 Algoritmy pro CSP Binární CSP M Binární CSP i* CSP, ve kterém jsoů poůze binární podmínky ůnární podmínky zakódovány do domény promenné JS> Graf podmínek pro binární CSP A není nůtné ůvažovat hypergraf, stací graf (podmínka spojůje poůze dva vrcholy) & Každý CSP lze transformovat na "korespondující" binární CSP iS> Výhody a nevýhody binarizace 3 získáváme ůnifikovaný tvar CSP problémů, rada algoritmů navržena pro binární CSP -fc bohůžel ale znacné zvetšení velikosti problémů & Nebinární podmínky A složitejší propagacní algoritmy lze vyůžít jejich sémantiky pro lepší propagaci i. príklad: a11_distinct vs. množina binárních nerovností Hana Růdová, Logické programování I, 15. kvetna 2013 203 Algoritmy pro CSP Vrčholová a hranová konzistenče & Vrčholová konzistenče (node consistency) NC -fc každá hodnota z aktuální domény Vi promenné splnuje všechny unární podmínky s promennou Vi Hana Rudová, Logické programování I, 15. kvetna 2013 204 Algoritmy pro CSP Vrcholová a hranová konzistence & Vrcholová konzistence (node consistency) NC Jt každá hodnota z aktuální domény Vi promenné splnuje všechny unární podmínky s promennou Vi & Hranová konzistence (arc consistency) AC pro binární CSP J* hrana (Vi,Vj) je hranove konzistentní, práve když pro každou hodnotu x z aktuální domény Di existuje hodnota y tak, že ohodnocení [Vi = x,Vj = y] splnuje všechny binární podmínky nad Vi,Vj. Hana Rudová, Logické programování I, 15. kvetna 2013 204 Algoritmy pro CSP Vrcholová a hranová konzistence Vrcholová konzistence (node consistency) NC -fc každá hodnota z aktuální domény Vi promenné splnuje všechny unární podmínky s promennou Vi Hranová konzistence (arc consistency) AC pro binární CSP J* hrana (Vi,Vj) je hranove konzistentní, práve když pro každou hodnotu x z aktuální domény Di existuje hodnota y tak, že ohodnocení [Vi = x,Vj = y] splnuje všechny binární podmínky nad Vi,Vj. a hranová konzistence je smerová konzistence hrany (Vi,Vj) nezarucuje konzistenci hrany (Vj,Vi) A I 3..7 A procedure revise((i,j)) De1eted := fa1se for V x in Di do if neexistuje y g Dj takové, že (x,y) je konzistentní then Di := Di - {x} De1eted := true end if return De1eted end revise Hana Rudová, Logické programování I, 15. května 2013 205 Algoritmy pro CSP Algoritmus rěvizě hrany & Jak udělat hranu (Vi,Vj) hranově konzistentní? -í* Z domény Di vyradím takové hodnoty x, které nejsou konzistentní s aktuální doménou Dj (pro x neexistuje žádá hodnoty y v Dj tak, aby ohodnocení Vi = x a Vj = y spinovalo všechny binární podmínky mezi Vl a Vj) JS> procedure revise((i,j)) Deleted := false for V x in Dl do if neexistuje y g Dj takové, že (x,y) je konzistentní then Di := Di - {x} Deleted := true end if return Deleted end revise m domain([Vi,V2],2,4), Vi#< V2 Hana Rudová, Logické programování I, 15. kvetna 2013 205 Algoritmy pro CSP Algoritmus revize hrany & Jak udělat hranu (Vi,Vj) hranově konzistentní? -í* Z domény Di vyřadím takové hodnoty x, které nejsou konzistentní s aktuální doménou Dj (pro x neexistuje žádá hodnoty y v Dj tak, aby ohodnocení Vi = x a Vj = y spinovalo všechny binární podmínky mezi Vl a Vj) JS> procedure revise((i,j)) Deleted := false for v x in Dl do if neexistuje y g Dj takové, že (x,y) je konzistentní then Di := Di - {x} Deleted := true end if return Deleted end revise m domain([Vi, V2J,2,4), Vi#< V2 revise((1,2)) smaže 4 z Di, Hana Rudová, Logické programování I, 15. kvetna 2013 205 Algoritmy pro CSP Algoritmus revize hrany & Jak udelat hranu (Vi,Vj) hranove konzistentní? iS> Z domény Di vyradím takové hodnoty x, které nejsou konzistentní s aktuální doménou Dj (pro x neexistuje žádá hodnoty y v Dj tak, aby ohodnocení Vi = x a Vj = y splnovalo všechny binární podmínky mezi Vl a Vj) & procedure revise((i,j)) Deleted := false for V x in Dl do if neexistuje y g Dj takové, že (x,y) je konzistentní then Di := Di - {x} Deleted := true end if return Deleted end revise JS> domain([Vi, V2],2,4), Vi#< V2 revise((1,2)) smaže 4 z Di,D2 se nezmení Hana Rudová, Logické programování I, 15. kvetna 2013 205 Algoritmy pro CSP Dosažení hranové konzistence problému Jak udelat CSP hranove konzistentní? a revize je potreba opakovat, dokud se mení doména nejaké promenné a efektivnejší: opakování revizí můžeme delat pomocí fronty pridáváme do ní hrany, jejichž konzistence mohla být narušena zmenšením domény Hana Rudová, Logické programování I, 15. kvetna 2013 206 Algoritmy pro CSP Dosažení hranové konzistence problému Jak udělat CSP hranově konzistentní? Jt revize je potreba opakovat, dokud se mění doména nějaké proměnné s* efektivnější: opakování revizí mUžeme dělat pomocí fronty pridávame do ní hrany, jejichž konzistence mohla být narušena zmenšením domény Jaké hrany presně revidovat po zmenšení domény? ty, jejichž konzistence mUže být zmenšením domény proměnné narušena jsou to hrany (i,k), které vedou do proměnné Vk se zmenšenou doménou V < V k m hranu (m, k) vedoucí z proměnné Vm, která zmenšení domény způsobila, není treba revidovat (změna se jí nedotkne) Hana Rudová, Logické programování I, 15. května 2013 206 Algoritmy pro CSP Algoritmus AC-3 procedure AC-3(G) ____^ Vk *^ Vm Q : = ) I ) g hrany(G), í = j} % seznam hran pro revizi while Q non empty do vyber a smaž (k,m) z Q if revise((k, m)) then % pridani pouze hran, ktere Q := Q u {(í,k) g hrany(G), í = k, í = m} % dosud nejsou ve fronte end while end AC-3 Hana Rudová, Logické programování I, 15. kvetna 2013 207 Algoritmy pro CSP Algoritmus AC-3 procedure AC-3(G) ____^ Vk *^ Vm Q : = ) I ) £ hrany(G), í = j} % seznam hran pro revizi while Q non empty do vyber a smaž (k,m) z Q if revise((k, m)) then % pridani pouze hran, ktere Q := Q u {(í,k) £ hrany(G), í = k, í = m} % dosud nejsou ve fronte end while end AC-3 Príklad: A Víme alespon zda rešení existuje? NE Hana Rudová, Logické programování I, 15. kvetna 2013 208 Algoritmy pro CSP Je hranová konzistenče dostatečná? Použitím AC odstraníme mnoho nekompatibilních hodnot a Dostaneme potom rešení problému? NE %> Víme alespon zda r ešení existuje? NE domain([X,Y,Z],1,2), X#\= Y, Y#\= Z, Z#\= X a hranove konzistentní a nemá žádné r ešení Hana Rudová, Logické programování I, 15. kvetna 2013 208 Algoritmy pro CSP Je hranová konzistence dostateCná? Použitím AC odstraníme mnoho nekompatibilních hodnot a Dostaneme potom rešení problému? NE %> Víme alespon zda r ešení existuje? NE domain([X,Y,Z],1,2), X#\= Y, Y#\= Z, Z#\= X a hranove konzistentní a nemá žádné r ešení Jaký je tedy význam AC? a nekdydár ešení p rímo nejaká doména se vyprázdní ^ rešení neexistuje všechny domény jsou jednoprvkové ^ máme r ešení a v obecném p rípade se alespon zmenší prohledávaný prostor Hana Rudová, Logické programování I, 15. kvetna 2013 208 Algoritmy pro CSP k-konzistenče Mají NC a AC neco spolecného? s NC: konzistence jedné promenné & AC: konzistence dvou promenných ... mužeme pokracovat Hana Rudová, Logické programování I, 15. kvetna 2013 209 Algoritmy pro CSP k-konzistence Mají NC a AC neco spolecného? s NC: konzistence jedné promenné Jt AC: konzistence dvou proměnných ... mužeme pokracovat CSP je k-konzistentní práve tehdy, když mužeme libovolné konzistentní ohodnocení (k-1) mzných proměnných rozšír it do libovolné k-té promenné Hana Rudová, Logické programování I, 15. kvetna 2013 209 Algoritmy pro CSP k-konzistenče Mají NC a AC něco společného? s NC: konzistence jedné proměnné & AC: konzistence dvou proměnných ... mUžeme pokračovat CSP je k-konzistentní práve tehdy, když mUžeme libovolné konzistentní ohodnocení (k-1) rUzných promenných rozšířit do libovolné k-té promenné 1,2,3 1,2,3 1,2,3 4 -í* Pro obecné CSP, tedy i pro nebinární podmínky Hana Rudová, Logické programování I, 15. kvetna 2013 209 4-konzistentní graf Algoritmy pro CSP Silná k-konzistence 3-konzistentní graf 1,2 1,2 1,2,3 není 2-konzistentní Hana Růdová, Logické programování I, 15. kvetna 2013 210 Algoritmy pro CSP Silná k-konzistence 3-konzistentní graf (1,1) lze rozšírit na (1,1,1) (2, 2) lze rozšírit na (2, 2,2) 1,2 1,2 1,2,3 není 2-konzistentní (3) nelze rozšírit (1, 3) ani (2, 3) nejsou konzistentní dvojice (nerozširujeme je) Hana Rudová, Logické programování I, 15. kvetna 2013 210 Algoritmy pro CSP Silná k-konzistence 3-konzistentní graf (1,1) lze rozšírit na (1,1,1) (2, 2) lze rozšírit na (2, 2,2) 1,2 1,2 1,2,3 není 2-konzistentní (3) nelze rozšírit (1, 3) ani (2, 3) nejsoů konzistentní dvojice (nerozširujeme je) & CSP je silne k-konzistentní práve tehdy, když je j-konzistentní pro každé j k-konzistence -í* Silná k-konzistence => j-konzistence \/j < k & k-konzistence J> silná k-konzistence Hana Rudová, Logické programování I, 15. kvetna 2013 210 Algoritmy pro CSP Silná k-konzistence 3-konzistentní graf (1,1) lze rozšírit na (1,1,1) 1,2 1,2 1,2,3 není 2-konzistentní ( 3 ) nelze rozší rit (2, 2) lze rozšírit na (2, 2,2) (1, 3) ani (2, 3) nejsou konzistentní dvojice (nerozširujeme je) & CSPje silne k-konzistentní práve tehdy, když je j-konzistentní pro každé j k-konzistence -í* Silná k-konzistence => j-konzistence \/j < k -í* k-konzistence J> silná k-konzistence & NC = silná 1-konzistence = 1-konzistence J* AC = (silná) 2-konzistence Hana Rudová, Logické programování I, 15. kvetna 2013 210 Algoritmy pro CSP Konzistence pro nalezení rešení Máme-li graf s n vrcholy, jak silnou konzistenci potrebujeme, abychom p rímo našli rešení? a silná n-konzistence je nutná pro graf s n vrcholy Hana Rudová, Logické programování I, 15. kvetna 2013 211 Algoritmy pro CSP Konzistence pro nalezení rešení Máme-li graf s n vrcholy, jak silnou konzistenci potrebujeme, abychom p rímo našli rešení? a silná n-konzistence je nutná pro graf s n vrcholy n-konzistence nestací (viz p r edchozí p ríklad) Hana Rudová, Logické programování I, 15. kvetna 2013 211 Algoritmy pro CSP Konzistence pro nalezení řešení Máme-li graf s n vrcholy, jak silnou konzistenci potřebujeme, abychom přímo našli řešení? a silná n-konzistence je nutná pro graf s n vrcholy n-konzistence nestací (viz predchozí príklad) silná k-konzistence pro k B => min(A) = min(B)+1, max(B) = max(A)-1 príklad: A in 4..10, B in 6..18, A #> B min(A) = 6+1 => A in 7..10 max(B) = 10-1 => B in 6..9 Hana Rudová, Logické programování I, 15. kvetna 2013 214 Algoritmy pro CSP Konzistence mezí & Bounds consistency BC: slabší než obecná hranová konzistence & podmínka má konzistentní meze (BC), práve když pro každou promennou Vj z této podmínky a každou hodnou x g Dj existuje ohodnocení zbylých proměnných v podmínce tak, že je podmínka splnena a pro vybrané ohodnocení yí promenné Ví platí min(Di) < yi < max(Di) a stací propagace pouze pri zmene minimální nebo maximální hodnoty (při zmene mezí) v doméne promenné & Konzistence mezí pro nerovnice L- A #> B => min(A) = min(B)+1, max(B) = max(A)-1 príklad: A in 4..10, B in 6..18, A #> B min(A) = 6+1 => A in 7..10 max(B) = 10-1 ^ B in 6..9 podobne: A #< B, A #>= B, A #=< B Hana Rudová, Logické programování I, 15. kvetna 2013 214 Algoritmy pro CSP Konzistenče mezí a aritmetičká omezení & A #= B + C => min(A) = min(B)+min(C), max(A) = max(B)+max(C) min(B) = min(A)-max(C), max(B) = max(A)-min(C) min(C) = min(A)-max(B), max(C) = max(A)-min(B) Hana Rudová, Logické programování I, 15. kvetna 2013 215 AlgoritmyproCSP Konzistence mezí a aritmetická omezení & A #= B + C => min(A) = min(B)+min(C), max(A) = max(B)+max(C) min(B) = min(A)-max(C), max(B) = max(A)-min(C) min(C) = min(A)-max(B), max(C) = max(A)-min(B) A zmena min(A)vyvolá pouze zmenu min(B) a min(C) A zmena max(A)vyvolá pouze zmenu max(B) a max(C), ... Hana Rudová, Logické programování I, 15. kvetna 2013 215 Algoritmy pro CSP Konzistence mezí a aritmetická omezení & A #= B + C => min(A) = min(B)+min(C), max(A) = max(B)+max(C) min(B) = min(A)-max(C), max(B) = max(A)-min(C) min(C) = min(A)-max(B), max(C) = max(A)-min(B) Jt zmena min(A)vyvolá pouze zmenu min(B) a min(C) Jt zmena max(A)vyvolá pouze zmenu max(B) a max(C), ... C Príklad: A in 1..10, B in 1..10, A #= B + 2, A #> 5, A #\= 8 A #= B + 2 ^> Hana Rudová, Logické programování I, 15. kvetna 2013 215 Algoritmy pro CSP Konzistenče mezí a aritmetičká omezení & A #= B + C => min(A) = min(B)+min(C), max(A) = max(B)+max(C) min(B) = min(A)-max(C), max(B) = max(A)-min(C) min(C) = min(A)-max(B), max(C) = max(A)-min(B) A zmena min(A)vyvolá pouze zmenu min(B) a min(C) A zmena max(A)vyvolá pouze zmenu max(B) a max(C), ... C Príklad: A in 1..10, B in 1..10, A #= B + 2, A #> 5, A #\= 8 A #= B + 2 => min(A)=1+2, max(A)=10+2 => A in 3..10 => min(B)=1-2, max(B)=10-2 => B in 1..8 Hana Rudová, Logické programování I, 15. kvetna 2013 215 AlgoritmyproCSP Konzistence mezí a aritmetická omezení & A #= B + C => min(A) = min(B)+min(C), max(A) = max(B)+max(C) min(B) = min(A)-max(C), max(B) = max(A)-min(C) min(C) = min(A)-max(B), max(C) = max(A)-min(B) A změna min(A)vyvolá pouze změnu min(B) a min(C) A změna max(A)vyvolá pouze změnu max(B) a max(C), ... m Príklad: A in 1..10, B in 1..10, A #= B + 2, A #> 5, A #\= 8 A #= B + 2 => min(A)=1+2, max(A)=10+2 => A in 3..10 = min(B)=1-2, max(B)=10-2 = B in 1..8 A #> 5 == min(A)=6 == A in 6..10 == min(B)=6-2 == B in 4..8 (nové vyvolání A #= B + 2) Hana Rudová, Logické programování I, 15. května 2013 215 Algoritmy pro CSP Konzistence mezí a aritmetická omezení & A #= B + C => min(A) = min(B)+min(C), max(A) = max(B)+max(C) min(B) = min(A)-max(C), max(B) = max(A)-min(C) min(C) = min(A)-max(B), max(C) = max(A)-min(B) A zmena min(A)vyvolá pouze zmenu min(B) a min(C) A zmena max(A)vyvolá pouze zmenu max(B) a max(C), ... m Príklad: A in 1..10, B in 1..10, A #= B + 2, A #> 5, A #\= 8 A #= B + 2 = min(A)=1+2, max(A)=10+2 = A in 3..10 = min(B)=1-2, max(B)=10-2 = B in 1..8 A #> 5 = min(A)=6 = A in 6..10 = min(B)=6-2 = B in 4..8 (nové vyvolání A #= B + 2) A #\= 8 = A in (6..7) \/ (9..10) (meze stejné, k propagaci A #= B + 2 nedojde) Hana Rudová, Logické programování I, 15. kvetna 2013 215 Algoritmy pro CSP Konzistence mezí a aritmetická omezení & A #= B + C => min(A) = min(B)+min(C), max(A) = max(B)+max(C) min(B) = min(A)-max(C), max(B) = max(A)-min(C) min(C) = min(A)-max(B), max(C) = max(A)-min(B) A změna min(A)vyvolá pouzě změnu min(B) a min(C) A změna max(A)vyvolá pouzě změnu max(B) a max(C), ... m Príklad: A in 1..10, B in 1..10, A #= B + 2, A #> 5, A #\= 8 A #= B + 2 = min(A)=1+2, max(A)=10+2 = A in 3..10 = min(B)=1-2, max(B)=10-2 = B in 1..8 A #> 5 = min(A)=6 = A in 6..10 = min(B)=6-2 = B in 4..8 (nové vyvolání A #= B + 2) A #\= 8 = A in (6..7) \/ (9..10) (mězě stějné, k propagaci A #= B + 2 nědojdě) JG* Vyzkoušějtě si: A #= B - C, A #>= B + C Hana Rudová, Logické programování I, 15. května 2013 215 Algoritmy pro CSP Globální podmínky & Propagace je lokální A pracuje se s jednotlivými podmínkami & interakce mezi podmínkami je pouze pres domény promenných C Jak dosáhnout více, když je silnejší propagace drahá? & Seskupíme nekolik podmínek do jedné tzv. globální podmínky JS> Propagaci p res globální podmínku r ešíme speciálním algoritmem navrženým pro danou podmínku C Príklady: M all_distinct omezení: hodnoty všech promenných mzné serialized omezení: rozvržení úloh zadaných startovním casem a dobou trvání tak, aby se nep rekrývaly Hana Rudová, Logické programování I, 15. kvetna 2013 216 Algoritmy pro CSP Propagace pro all_distinct -I U = {X2, X4, X5}, dom(U) = {2, 3, 4}: {2,3,4} nelze pro X1, X3, X6 učitel min max Jan 3 6 Petr 4 Anna 2 5 Ota 4 Eva 4 Marie 1 6 Hana Rudová, Logické programování I, 15. kvetna 2013 217 Algoritmy pro CSP Propagace pro all_distinct U = {X2, X4, X5}, dom(U) = {2, 3, 4}: {2,3,4} nelze pro X1, X3, X6 X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6) učitel min max Jan 3 6 Petr 4 Anna 2 5 Ota 4 Eva 4 Marie 1 6 Hana Rudová, Logičké programování I, 15. kvetna 2013 217 Algoritmy pro CSP Propagace pro all_distinct -I U = {X2, X4, X5}, dom(U) = {2,3,4} nelze pro X1, X1 in 5..6, X3 = 5, & Konzistence: V[X\,... ,Xk} 2, 3, 4}: X3, X6 X6 in {1} \/ (5.-6) c V : card{Di u • • • u Dk} > k učitel min max Jan 3 6 Petr 4 Anna 2 5 Ota 4 Eva 4 Marie 1 6 Hana Rudová, Logické programování I, 15. května 2013 217 Algoritmy pro CSP Propagače pro all_distinct U = {X2, X4, X5}, dom(U) = {2, 3, 4}: učitel min max {2,3,4} nelze pro X1, X3, X6 Jan 3 6 X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6) Petr 4 Konzistenče: \/{Xi,.. .,Xk} c V : card{Di u • • • u Dk} > k Anna 2 5 stací hledat Hallův interval I: velikost intervalu I je rovna Ota 4 poctu promenných, jejichž doména je v I Eva 4 Marie 1 6 Hana Rudová, Logické programování I, 15. kvetna 2013 217 Algoritmy pro CSP Propagace pro all_distinct U = {X2, X4, X5}, dom(U) = {2, 3, 4}: {2,3,4} nelze pro X1, X3, X6 X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6) Konzistence: V{X1?.. .,Xk} c V : card{Di u • • • u Dk} > k stací hledat Hallův interval I: velikost intervalu I je rovna poctu proměnných, jejichž doména je v I Inferencní pravidlo U = {Xi,...,Xk}, dom(U) = {Di u • • • u Dk} učitel min max Jan 3 6 Petr 4 Anna 2 5 Ota 4 Eva 4 Marie 1 6 card(U) = card(dom(U)) => Vv g dom(U), VX g (V - U),X = v Hana Rudová, Logické programování I, 15. kvetna 2013 217 Algoritmy pro CSP Propagace pro all_distinct U = {X2, X4, X5}, dom(U) = {2, 3, 4}: {2,3,4} nelze pro X1, X3, X6 X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6) Konzistence: VjXi,.. .,Xk} c V : card{D1 u • • • u Dk} > k stací hledat Hallův interval I: velikost intervalu I je rovna poctu proměnných, jejichž doména je v I Inferencní pravidlo U = {Xi,...,Xk}, dom(U) = {Di u • • • u Dk} card(U) = card(dom(U)) = Vv g dom(U), VX g (V - U),X = v s» hodnoty v Hallově intervalu jsou pro ostatní proměnné nedostupné učitel min max Jan 3 6 Petr 4 Anna 2 5 Ota 4 Eva 4 Marie 1 6 Hana Rudová, Logické programování I, 15. kvetna 2013 217 Algoritmy pro CSP Propagace pro all_distinct U = {X2, X4, X5}, dom(U) = {2, 3, 4}: {2,3,4} nelze pro X1, X3, X6 X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6) Konzistence: \/{X1,.. .,Xk} c V : card{D1 u - - - u Dk} > k stací hledat Hallův interval I: velikost intervalu I je rovna poctu promenných, jejichž doména je v I Inferencní pravidlo U = {X1,...,Xk}, dom(U) = {D1 u • • - u Dk} card(U) = card(dom(U)) => \/v e dom(U), \/X e (V - U),X = v s» hodnoty v Hallove intervalu jsou pro ostatní promenné nedostupné učitel min max Jan 3 6 Petr 4 Anna 2 5 Ota 4 Eva 4 Marie 1 6 Složitost: O(2n) - hledání všech podmnožin množiny n promenných (naivní) Hana Rudová, Logické programování I, 15. kvetna 2013 217 Algoritmy pro CSP Propagace pro all_distinct U = {X2, X4, X5}, dom(U) = {2, 3, 4}: {2,3,4} nelze pro X1, X3, X6 X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6) Konzistence: \/{Xi,.. .,Xk} c V : card{D1 u • • • u Dk} > k stací hledat Hallův interval I: velikost intervalu I je rovna poctu proměnných, jejichž doména je v I InferenCní pravidlo U = {Xu...,Xk}, dom(U) = {Di u • • • u Dk} card(U) = card(dom(U)) => Vv g dom(U), VX g (V - U),X = v s» hodnoty v Hallove intervalu jsou pro ostatní promenné nedostupné Složitost: O(2n) - hledání všech podmnožin množiny n proměnných (naivní) O(nlogn) - kontrola hranicních bodu Hallových intervalu (1998) učitel min max Jan 3 6 Petr 4 Anna 2 5 Ota 4 Eva 4 Marie 1 6 Hana Rudová, Logické programování I, 15. kvetna 2013 217 Algoritmy pro CSP Prohledávání + konzistence Splňování podmínek prohledáváním prostoru řešení A podmínky jsou užívány pasivné jako test J> přiřazuji hodnoty promenných a zkouším co se stane vestavený prohledávací algoritmus Prologu: backtracking, triviální: generuj & testuj Hana Rudová, Logické programování I, 15. kvetna 2013 218 Algoritmy pro CSP Prohledávání + konzistence Splňování podmínek prohledáváním prostoru řešení A podmínky jsou užívány pasivné jako test J> přiřazuji hodnoty promenných a zkouším co se stane vestavený prohledávací algoritmus Prologu: backtracking, triviální: generuj & testuj úplná metoda (nalezneme rešení nebo dokážeme jeho neexistenci) zbytecne pomalé (exponenciální): procházím i „evidentne" špatná ohodnocení Hana Rudová, Logické programování I, 15. kvetna 2013 218 Algoritmy pro CSP Prohledávání + konzistenče JS> Splnování podmínek prohledáváním prostoru r ešení A podmínky jsou užívány pasivne jako test p r i razuji hodnoty promenných a zkouším co se stane vestavený prohledávací algoritmus Prologu: bačktračking, triviální: generuj & testuj úplná metoda (nalezneme r ešení nebo dokážeme jeho neexistenci) & zbytecne pomalé (exponenciální): procházím i „evidentne" špatná ohodnocení & Konzistenční (propagační) tečhniky -i- umožnují odstranení nekonzistentních hodnot z domény promenných neúplná metoda (v doméne zustanou ješte nekonzistentní hodnoty) A relativne rychlé (polynomiální) Hana Rudová, Logické programování I, 15. kvetna 2013 218 Algoritmy pro CSP Prohledávání + konzistence Splnování podmínek prohledáváním prostoru r ešení A podmínky jsou užívány pasivne jako test p r i razuji hodnoty promenných a zkouším co se stane vestavený prohledávací algoritmus Prologu: backtracking, triviální: generuj & testuj úplná metoda (nalezneme r ešení nebo dokážeme jeho neexistenci) zbytecne pomalé (exponenciální): procházím i „evidentne" špatná ohodnocení & Konzistencní (propagacní) techniky -i- umožnují odstranení nekonzistentních hodnot z domény promenných neúplná metoda (v doméne zustanou ješte nekonzistentní hodnoty) A relativne rychlé (polynomiální) B Používá se kombinace obou metod -fc postupné p r i razování hodnot promenným -i- po p r i razení hodnoty odstranení nekonzistentních hodnot konzistencními technikami Hana Rudová, Logické programování I, 15. kvetna 2013 218 Algoritmy pro CSP Prohledávání do hloubky Základní prohledávací algoritmus pro problémy splňování podmínek & Prohledávání stavového prostoru do hloubky (depth first search) & Dve fáze prohledávání s navracením & dopredná fáze: promenné jsou postupne vybírány, rozširuje se CásteCné rešení prirazením konzistení hodnoty (pokud existuje) další promenné po vybrání hodnoty testujeme konzistenci a zpetná fáze: pokud neexistuje konzistentní hodnota pro aktuální promennou, algoritmus se vrací k předchozí prirazené hodnote Hana Rudová, Logické programování I, 15. kvetna 2013 219 Algoritmy pro CSP Prohledávání do hloubky & Základní prohlědávací algoritmus pro problémy splnování podmíněk & Prohledávání stavového prostoru do hloubky (depth first search) & Dvě fázě prohlědávání s navracěním & dopredná fáze: proměnné jsou postupně vybírány, rozši r ujě sě cástěcné r ěšění p r i razěním konzistění hodnoty (pokud ěxistujě) další proměnné po vybrání hodnoty těstujěmě konzistěnci a zpetná fáze: pokud něěxistujě konzistěntní hodnota pro aktuální proměnnou, algoritmus sě vrací k p r ědchozí p r i razěné hodnotě & Proměnné dělímě na & minulé - proměnné, ktěré už byly vybrány (a mají p r i razěnu hodnotu) * aktuální - proměnná, ktěrájě právě vybrána a jě jí p r i r azována hodnota s budoucí - proměnné, ktěré budou vybrány v budoucnosti Hana Rudová, Logické programování I, 15. května 2013 219 Algoritmy pro CSP Základní algoritmus prohledávání do hloubky Pro jednoduchost promenné ocíslujeme a ohodnocujeme je v daném poradí Na zacátku voláno jako 1abe1ing(G,1) procedure 1abe1ing(G,a) if a > |uz1y(G)| then return uzly(G) for V x g Da do if consistent(G,a) then % consistent(G,a) je nahrazeno FC(G,a), LA(G,a), . R := 1abe1ing(G,a +1) if R = fail then return R return fail end labeling Po prirazení všech promenných vrátíme jejich ohodnocení Procedury consistent uvedeme pouze pro binární podmínky Hana Rudová, Logické programování I, 15. kvetna 2013 220 Algoritmy pro CSP Backtracking (BT) Backtracking overuje v každém kroku konzistenci podmínek vedoucích z minulých proměnných do aktuální promenné Backtracking tedy zajišťuje konzistenci podmínek A na všech minulých promenných -fc na podmínkách mezi minulými promennými a aktuální promennou Hana Rudová, Logické programování I, 15. kvetna 2013 221 Algoritmy pro CSP Backtracking (BT) Backtracking ove r uje v každém kroku konzistenci podmínek vedoucích z minulých promenných do aktuální promenné Backtracking tedy zajišťuje konzistenci podmínek A na všech minulých promenných -fc na podmínkách mezi minulými promennými a aktuální promennou procedure BT(G,a) Q:={(Vi, va) g hrany(G), i < a} % hrany vedoucí z minulých promenných do aktuální Consistent := true while Q není prázdná a Consistent do vyber a smaž libovolnou hranu (Vk,Vm) z Q Consistent := not revise(Vk,Vm) % pokud vyradíme prvek, bude doména prázdná return Consistent end BT Hana Rudová, Logické programování I, 15. kvetna 2013 221 Algoritmy pro CSP Príklad: backtracking C Omezení: Vi, V2, V3 in 1... 3, Vi# = 3 x V3 & Stavový prostor: í S* cervené ctverecky: chybný pokus o instanciaci, r ešení neexistuje i* nevyplnená kolecka: nalezeno r ešení Jť cerná kolecka: vnit r ní uzel, máme pouze cástecné p r i razení Hana Rudová, Logické programování I, 15. kvetna 2013 222 Kontrola dopředu (FC - forward checking) FC je rozšírení backtrackingu FC navíc zajišťuje konzistenci mezi aktuální promennou a budoucími promennými, které jsou s ní spojeny dosud nesplnenými podmínkami Hana Rudová, Logické programování I, 15. kvetna 2013 223 Algoritmy pro CSP Kontrola dopředu (FC - forward checking) FC je rozšírení backtrackingu FC navíc zajišťuje konzistenci mezi aktuální promennou a budoucími promennými, které jsou s ní spojeny dosud nesplnenými podmínkami procedure FC(G,a) Q:={(Ví, Va) g hrany(G), í> a} % přidání hran z budoucích do aktuální promenné Consistent := true while Q není prázdná a Consistent do vyber a smaž libovolnou hranu (Vk,Vm) z Q if revise((Vk,Vm)) then Consistent := (|Dk| > 0) % vyprázdnení domény znamená nekonzistenci return Consistent end FC Hrany z minulých promenných do aktuální promenné není nutno testovat Hana Rudová, Logické programování I, 15. kvetna 2013 223 Algoritmy pro CSP Príklad: kontrola dopredu C Omezení: V1,V2,V3 in 1... 3, c : V1# = 3 x V3 -í* Stavový prostor: Hana Rudová, Logické programování I, 15. kvetna 2013 224 Algoritmy pro CSP Pohled dopredu (LA - looking ahead) LA je rozšírení FC, navíc overuje konzistenci hran mezi budoucími promennými procedure LA(G,a) Q := {(Vi,Va) g hrany(G), i> a} % zaCínáme s hranami do a Consistent := true while Q není prázdná a Consistent do vyber a smaž libovolnou hranu (Vk,Vm) z Q if revise((Vk,Vm)) then Q := Q u {(Vi,Vk)\(Vi,Vk) g hrany(G), i = k, i = m,i> a} Consistent := (\Dk\ > 0) return Consistent end LA Hana Rudová, Logické programování I, 15. kvetna 2013 225 Algoritmy pro CSP Pohled dop ř edu (LA - looking ahead) LA je rozšírení FC, navíc ove ř uje konzistenci hran mezi budoucími proměnnými procedure LA(G,a) Q := {(Vi,Va) g hrany(G), i> a} % zaCínáme s hranami do a Consistent := true while Q není prázdná a Consistent do vyber a smaž libovolnou hranu (Vk,Vm) z Q if revise((Vk,Vm)) then Q := Q u {(Vi,Vk)\(Vi,Vk) g hrany(G), i = k,i = m,i> a} Consistent := (\Dk\ > 0) return Consistent end LA A Hrany z minulých promenných do aktuální promenné opet netestujeme -i- Tato LA procedura je založena na AC-3, lze použít i jiné AC algoritmy -i* LA udržuje hranovou konzistenci: protožě alě LA(G,a) používá AC-3, musímě zajistit iniciální konzistenci pomocí AC-3 jěště p rěd startěm prohlědávání Hana Rudová, Logické programování I, 15. května 2013 225 Algoritmy pro CSP Príklad: pohled dop redu (pomocí AC-3) Omezení: V1.V2.V3 in 1...4, c 1: Vi# > V2, c2: V?# = 3 x V3 Stavový prostor (spouští se iniciální konzistence se p red startem prohledávání) q cl => V! in 2..4 V2 in 1..3 c2 => V2 = 3 V3 = 1 V1 4 cl => V1= 4 V2 31 V3 4 Hana Rudová, Logické programování I, 15. kvetna 2013 226 Algoritmy pro CSP Prehled algoritmů Bačktračking (BT) kontroluje v kroku a podmínky C(Vi ,Va),...,C(Va-1,Va) z minulých promenných do aktuální promenné BT FC LA promenne aktuálni Hana Rudová, Logické programování I, 15. kvetna 2013 227 Algoritmy pro CSP Prehled algoritmů Backtracking (BT) kontroluje v kroku a podmínky c(Vi ,Va),...,C(Va-1,Va) z minulých promenných do aktuální promenné Kontrola dopredu (FC) kontroluje v kroku a podmínky C(Va+1,Va),...,C(Vn,Va) z budoucích promenných do aktuální promenné BT a FC LA n promenne aktuální Hana Rudová, Logické programování I, 15. kvetna 2013 227 Algoritmy pro CSP Přehled algoritmu BT Backtracking (BT) kontroluje v kroku a podmínky C(Vi ,Va),...,c(Va-1,Va) z minulých proměnných do aktuální promenné Kontrola dopredu (FC) kontroluje v kroku a podmínky c(Va+1,Va),...,c(Vn,Va) z budoucích proměnných do aktuální promenné Pohled dopredu (LA) kontroluje v kroku a podmínky \/l(a < l < n), \/k(a < k < n),k = l: c(Vk,Vi) z budoucích promenných do aktuální promenné LA a mezi budoucími proměnnými a FC n promenne aktuální Hana Rudová, Logické programování I, 15. kvetna 2013 227 Algoritmy pro CSP CviCení 1. Jak vypadá stavový prostor rešení pro následující omezení A in 1..4, B in 3..4, C in 3..4, B #< C, A #= C pri použití kontroly dopredu a uspořádání promenných A,B,C? Popište, jaký typ propagace probehne v jednotlivých uzlech. 2. Jak vypadá stavový prostor rešení pro následující omezení A in 1..4, B in 3..4, C in 3..4, B #< C, A#= C pri použití pohledu dopredu a usporádání promenných A,B,C? Popište, jaký typ propagace probehne v jednotlivých uzlech. 3. Jak vypadá stavový prostor rešení pro následující omezení domain([A,B,C],0,1), A#= B-1, C #= A*A p r i použití backtrackingu a pohledu dop r edu a uspo rádání promenných A,B,C? Popište, jaký typ propagace probehne v jednotlivých uzlech. Hana Rudová, Logické programování I, 15. kvetna 2013 228 Algoritmy pro CSP Cvicení 1. Jaká jsou pravidla pro konzistenci mezí u omezení X#= Y+5? Jaké typy propagací pak proběhnou v následujícím příkladě pri použití konzistence mezí? X in 1..20, Y in 1..20, X #= Y+ 5, Y#> 10. 2. Ukažte, jak je dosaženo hranové konzistence v následujícím príkladu: domain([X,Y,Z],1,5]), X #< Y, Z#= Y+1 . Hana Rudová, Logické programování I, 15. kvetna 2013 229 Algoritmy pro CSP Implementace Prologu Literatura: & Matyska L., Toman D.: Implementacní techniky Prologu, Informacní systémy, (1990), 21-59. http://www.ics.muni.cz/people/matyska/vyuka/lp/lp.html Opakování: základní pojmy -í* Konecná množina klauzulí Hlava :- Tělo tvo rí program P. JS> Hlava je literál & Tělo je (eventuálne prázdná) konjunkce literál u T1,...Ta, a > 0 & Literál je tvoren m-árním predikátovým symbolem (m/p) a m termy (argumenty) JS> Term je konstanta, promenná nebo složený term. -í* Složený term s n termy na míste argumentu & Dotaz (číl) je neprázdná množina literálu. Hana Rudová, Logické programování I, 15. kvetna 2013 231 Implementace Prologu Interpretace Deklarativní sémantika: Hlava platí, platí-li jednotlivé literály tela. Hana Rudová, Logické programování I, 15. kvetna 2013 232 Implementace Prologu Interpretace Deklarativní sémantika: Hlava platí, platí-li jednotlivé literály tela. Procedurální (imperativní) sémantika: Entry: Hlava:: { call Ti ■ ■ ■ call Ta } Volání procedury s názvem Hlava uspeje, pokud uspeje volání všech procedur (literálu) v tele. Hana Rudová, Logické programování I, 15. kvetna 2013 232 Implementace Prologu Interpretace Deklarativní sémantika: Hlava platí, platí-li jednotlivé literály těla. Procedurální (imperativní) sémantika: Entry: Hlava:: { call Ti ■ ■ ■ call Ta } Volání procedury s názvem Hlava uspěje, pokud uspěje volání všech procedur (literálu) v těle. Procedurální sémantika = podklad pro implementaci Hana Rudová, Logické programování I, 15. května 2013 232 Implementace Prologu Abstraktní interpret Vstup: Logický program P a dotaz G. 1. Inicializuj množinu cílů S literály z dotazu G; S:=G 2. while ( S != empty ) do 3. Vyber AeS a dále vyber klauzuli A':-B1 ,...,Bn (n > 0) z programu P takovou, že 3a : Aa = A' a; a je nejobecnejší unifikátor. Pokud neexistuje A' nebo a, ukonci cyklus. Hana Rudová, Logické programování I, 15. kvetna 2013 233 Implementace Prologu Abstraktní interpret Vstup: Logický program P a dotaz G. 1. Inicializuj množinu cílů S literály z dotazu G; S:=G 2. while ( S != empty ) do 3. Vyber AeS a dále vyber klauzuli A':-B1 ,...,Bn (n > 0) z programu P takovou, že 3a : Aer = A' a; a je nejobecnejší unifikátor. Pokud neexistuje A' nebo a, ukonci cyklus. 4. Nahrad' A v S cíli B1 až Bn. 5. Aplikuj a na G a S. 6. end while 7. Pokud S==empty, pak výpocet úspešne skoncil a výstupem je G se všemi aplikovanými substitucemi. Pokud S!=empty, výpocet koncí neúspechem. Hana Rudová, Logické programování I, 15. kvetna 2013 233 Implementace Prologu Abstraktní interpret - pokracování Kroky (3) až (5) p r edstavují redukci (logickou inferenci) cíle A. Pocet redukcí za sekundu (LIPS) == indikátor výkonu implementace Hana Rudová, Logické programování I, 15. kvetna 2013 234 Implementace Prologu Abstraktní interpret - pokracování Kroky (3) až (5) p r ědstavují redukci (logickou infěrěnci) cílě A. Pocět rědukcí za sěkundu (LIPS) == indikátor výkonu implěměntacě veta Existujě-li instancě C dotazu G, odvoditělná z programu P v koněcném poctu kroků, pak budě tímto intěrprětěm nalězěna. Hana Rudová, Logické programování I, 15. května 2013 234 Implěměntacě Prologu Nedeterminismus interpetu 1. Selekční pravidlo: výběr cíle A z množiny cílů S M neovlivňuje výrazně výsledek chování interpretů 2. Způsob prohledávání stromu výpočtu: výber klauzule A' z programů P JG* je velmi důležitý, všechny klaůzůle totiž nevedou k úspešnému rešení Hana Růdová, Logické programování I, 15. kvetna 2013 235 Implementace Prologů Nedeterminismus interpetu 1. SelekCní pravidlo: výber cíle A z množiny cílu S JÍ neovlivnuje výrazne výsledek chování interpretu 2. Způsob prohledávání stromu výpoCtu: výber klauzule A' z programu P JG* je velmi důležitý, všechny klauzule totiž nevedou k úspešnému rešení Vztah k úplnosti: 1. Selekcní pravidlo neovlivnuje úplnost & možno zvolit libovolné v rámci SLD rezoluce 2. Prohledávání stromu výpoctu do šírky nebo do hloubky Hana Rudová, Logické programování I, 15. kvetna 2013 235 Implementace Prologu Nedeterminismus interpetu 1. Selekcní pravidlo: výber cíle A z množiny cílu S JÍ neovlivnuje výrazne výsledek chování interpretu 2. Způsob prohledávání stromu výpoctu: výber klauzule A' z programu P JG* je velmi důležitý, všechny klauzule totiž nevedou k úspešnému r ešení Vztah k úplnosti: 1. Selekcní pravidlo neovlivnuje úplnost & možno zvolit libovolné v rámci SLD rezoluce 2. Prohledávání stromu výpoctu do šírky nebo do hloubky „Prozření" - automatický výber správné klauzule & vlastnost abstraktního interpretu, kterou ale reálné interprety nemají Hana Rudová, Logické programování I, 15. kvetna 2013 235 Implementace Prologu Prohledávání do šírky 1. Vybereme všechny klauzule A-, které je možno unifikovat s literálem A m necht'je těchto klauzulí q 2. Vytvoríme q kopií množiny S 3. V každé kopii redukujeme A jednou z klauzulí AÍ. m aplikujeme príslušný nejobecnější unifikátor Hana Rudová, Logické programování I, 15. kvetna 2013 236 Implementace Prologu Prohledávání do šírky 1. Vybereme všechny klauzule které je možno unifikovat s literálem A m necht'je techto klauzulí q 2. Vytvoríme q kopií množiny S 3. V každé kopii redukujeme A jednou z klauzulí AÍ. m aplikujeme príslušný nejobecnejší unifikátor 4. V následujících krocích redukujeme všechny množiny Si soucasne. Hana Rudová, Logické programování I, 15. kvetna 2013 236 Implementace Prologu Prohledávání do šírky 1. Vybereme všechny klauzule A-, které je možno unifikovat s literálem A m necht'je techto klauzulí q 2. Vytvoríme q kopií množiny S 3. V každé kopii redukujeme A jednou z klauzulí AÍ. m aplikujeme príslušný nejobecnejší unifikátor 4. V následujících krocích redukujeme všechny množiny Si soucasne. 5. Výpocet ukoncíme úspechem, pokud se alespon jedna z množin Si stane prázdnou. Hana Rudová, Logické programování I, 15. kvetna 2013 236 Implementace Prologu Prohledávání do šírky 1. Vybereme všechny klaůzůle které je možno ůnifikovat s literálem A m necht'je techto klaůzůlí q 2. Vytvoríme q kopií množiny S 3. V každé kopii redůkůjeme A jednoů z klaůzůlí A-. m aplikujeme príslůšný nejobecnejší ůnifikátor 4. V následůjících krocích redůkůjeme všechny množiny Si soůcasne. 5. Výpocet ůkoncíme úspechem, pokůd se alespon jedna z množin Si stane prázdnoů. -í* Ekvivalence s abstraktnímů interpretem A pokůd jeden interpret neůspeje, pak neůspeje i drůhý pokůd jeden interpret ůspeje, pak ůspeje i drůhý Hana Růdová, Logické programování I, 15. kvetna 2013 236 Implementace Prologů Prohledávání do hloubky 1. Vyběrěmě všěchny klauzulě A'i, ktěré jě možno unifikovat s litěrálěm A. 2. Všěchny tyto klauzulě zapíšěmě na zásobník. 3. Rědukci prověděmě s klauzulí na vrcholu zásobníku. Hana Rudová, Logické programování I, 15. května 2013 237 Implěměntacě Prologu Prohledávání do hloubky 1. Vybereme všechny klauzule A'i, které je možno unifikovat s literálem A. 2. Všechny tyto klauzule zapíšeme na zásobník. 3. Redukci provedeme s klauzulí na vrcholu zásobníku. 4. Pokud v nejakém kroku nenajdeme vhodnou klauzuli A', vrátíme se k p r edchozímu stavu (tedy anulujeme aplikace posledního unifikátoru a) a vybereme ze zásobníku další klauzuli. Hana Rudová, Logické programování I, 15. kvetna 2013 237 Implementace Prologu Prohledávání do hloubky 1. Vybereme všechny klauzule A'i, které je možno unifikovat s literálem A. 2. Všechny tyto klauzule zapíšeme na zásobník. 3. Redukci provedeme s klauzulí na vrcholu zásobníku. 4. Pokud v nejakém kroku nenajdeme vhodnou klauzuli A', vrátíme se k predchozímu stavu (tedy anulujeme aplikace posledního unifikátoru a) a vybereme ze zásobníku další klauzuli. 5. Pokud je zásobník prázdný, koncívýpocet neúspechem. 6. Pokud naopak zredukujeme všechny literály v S, výpocet koncí úspechem. Hana Rudová, Logické programování I, 15. kvetna 2013 237 Implementace Prologu Prohledávání do hloubky 1. Vybereme všechny klauzule A'i, které je možno unifikovat s literálem A. 2. Všechny tyto klauzule zapíšeme na zásobník. 3. Redukci provedeme s klauzulí na vrcholu zásobníku. 4. Pokud v nejakém kroku nenajdeme vhodnou klauzuli A', vrátíme se k predchozímu stavu (tedy anulujeme aplikace posledního unifikátoru a) a vybereme ze zásobníku další klauzuli. 5. Pokud je zásobník prázdný, koncívýpocet neúspechem. 6. Pokud naopak zredukujeme všechny literály v S, výpocet koncí úspechem. -» Není úplné, tj. nemusí najít všechna rešení Nižší pametová nárocnost než prohledáváni do ši r ky -í* Používá se v Prologu Hana Rudová, Logické programování I, 15. kvetna 2013 237 Implementace Prologu Reprezentace objektů J& Běztypový jazyk ii> Kontrola „typu" za běhu výpoctu JS> Informacě o strukturě soucástí objěktu Hana Rudová, Logické programování I, 15. května 2013 238 Implěměntacě Prologu Reprezentace objektů J& Beztypový jazyk ii> Kontrola „typů" za běhu výpoctu JS> Informace o strukture soucástí objektu Typy objektů M Primitivní objekty: konstanta císlo -i. volná proměnná -i- odkaz (reference) Hana Rudová, Logické programování I, 15. kvetna 2013 238 Implementace Prologu Reprezentace objektů J& Beztypový jazyk JS> Kontrola „typu" za behu výpoctu JS> Informace o strukture soucástí objektu Typy objektů M Primitivní objekty: konstanta císlo -i. volná promenná -i- odkaz (reference) JS> Složené (strukturované) objekty: ± struktura A seznam Hana Rudová, Logické programování I, 15. kvetna 2013 238 Implementace Prologu Reprezentace objektů II P ríznaky (tags): Objekt Príznak volná promenná FREE konstanta CONST celé císlo INT odkaz REF složený term FUNCT Hana Rudová, Logické programování I, 1S. kvetna 201S 239 Implementace Prologu Reprezentace objektů II P ríznaky (tags): Objekt Pr íznak volná promenná FREE konstanta CONST celé císlo INT odkaz REF složený term FUNCT Obsah adresovatelného slova: hodnota a p r íznak. Hana Rudová, Logické programování I, 15. kvetna 2013 239 Implementace Prologu Reprezentace objektů II Príznaky (tags): Objekt Príznak volná promenná FREE konstanta CONST celé císlo INT odkaz REF složený term FUNCT Obsah adrěsovatělného slova: hodnota a p r íznak. Primitivní objěkty uložěny prímo vě slově Hana Rudová, Logické programování I, 15. května 2013 239 Implěměntacě Prologu Reprezentace objektů II Příznaky (tags): Objekt Příznak volná promenná FREE konstanta CONST čelé číslo INT odkaz REF složený term FUNCT Obsah adresovatelného slova: hodnota a príznak. Primitivní objekty ůloženy prímo ve slove Složené objekty Ä jsoů instance termů ve zdrojovém textů, tzv. zdrojového termů & zdrojový term bez promenných => každá instanciace ekvivalentní zdrojovémů termů zdrojový term s promennými => dve instance se mohoů lišit aktůálními hodnotami promenných, jedinecnost zajišt'ůje kopírování strůktůr nebo sdílení strůktůr Hana Rudová, Logičké programování I, 15. kvetna 2G13 239 Implementace Prologů Kopírování struktur P ríklad: a(b(X),c(X,Y),d), FUNCT a/S REF REF CONSTd FUNCT c/2 REF FREE Y FUNCT b/1 - FREE X Hana Rudová, Logické programování I, 1S. kvetna 2G1S 24G Implementace Prologu Kopírování struktur II Term F s aritou A reprezentován A+1 slovy: A funktor a arita v prvním slove J* 2. slovo nese první argument (resp. odkaz na jeho hodnotu) . A A+1 slovo nese hodnotu A-tého argumentu Reprezentace vychází z orientovaných acyklických grafu a/3 i _ d c/2 Y b/1 X Vykopírována každá instance => kopírování struktur Termy ukládány na globální zásobník Hana Rudová, Logické programování I, 15. kvetna 2013 241 Implementace Prologu Sdílení struktur Vychází z myšlěnky, žě pri rěprězěntaci jě trěba rěšit prítomnost proměnných JS> Instancě těrmu < kostra_termu; rámec > M kostra_termu jě zdrojový těrm s ocíslovanými proměnnými & rámec jě věktor aktuálních hodnot těchto proměnných í-tá položka něsě hodnotu í-té proměnné v původním těrmu Hana Rudová, Logické programování I, 15. května 2013 242 Implěměntacě Prologu Sdílení struktur II Príklad: a(b(X),c(X,Y),d) reprezentuje < a(b($1),c($1,$2),d) ; [FREE, FREE] > kde symbolem $i oznacujeme í-tou proměnnou. Hana Rudová, Logické programování I, 15. kvetna 2013 243 Implementace Prologu Sdílení struktur II Pr íklad: a(b(X),c(X,Y),d) reprezentuje < a(b($1),c($1,$2)fd) ; [FREE, FREE] > kde symbolem Si oznacujeme t-tou promennou. Implementace: < &kostra_termu; &rámec > (& vrací adresu objektu) Všechny instance sdílí spolecnou kostru_termu ^ sdílení struktur Hana Rudová, Logické programování I, 15. kvetna 2013 243 Implementace Prologu Srovnání: p r íklad Naivní srovnání: sdílení pamet'ove méne nárocné Hana Rudová, Logické programování I, 15. kvetna 2013 244 Implementace Prologu Srovnání: príklad Naivní srovnání: sdílení pamet'ove méne nárocné Platí ale pouze pro rozsáhlé termy prítomné ve zdrojovém kódu Hana Rudová, Logické programování I, 15. kvetna 2013 244 Implementace Prologu Srovnání: příklad Naivní srovnání: sdílení paměťově méně náročné Platí ale pouze pro rozsáhlé termy prítomné ve zdrojovém kódu Postupná tvorba termů: A = a(K,L,M), K = b(X), L = c(X,Y), M = d Sdílení termů A - kostra_a - K L M:d - kostra_b kostra_č - X Y Hana Rudová, Logické programování I, 15. kvetna 2013 244 Implementace Prologu Srovnání: príklad - pokračování C Kopírování struktur: A = a(K,L,M), K = b(X), L = c(X,Y), M = d FUNCT a/S REF - REF - CONST d FUNCT c/2 - REF FREE Y FUNCT b/1 FREE X Hana Rudová, Logické programování I, 1S. kvetna 2G1S 24S Implementace Prologu Srovnání: príklad - pokračování C Kopírování struktur: A = a(K,L,M), K = b(X), L = c(X,Y), M = d FUNCT a/3 REF - REF - CONST d FUNCT c/Z - REF FREE Y FUNCT b/l FREE X tj. identické jako prímé vytvorení termu a(b(X),c(X,Y),d) Hana Rudová, Logické programování I, 15. května 2013 245 Implementace Prologu Srovnání II Složitost algoritmů pro prístup k jednotlivým argumentům s sdílení struktur: nutná víceúrovnová neprímá adresace & kopírování struktur: bez problému jednodušší algoritmy usnadnují i optimalizace Hana Rudová, Logické programování I, 15. kvetna 2013 246 Implementace Prologu Srovnání II Složitost algoritmů pro přístup k jednotlivým argumentům s sdílení struktur: nutná víceúrovnová neprímá adresace & kopírování struktur: bez problémů jednodušší algoritmy usnadnují i optimalizace Lokalita prístupu do pameti s sdílení struktur: prístupy rozptýleny po pameti & kopírování struktur: lokalizované prístupy pri stránkování pameti - rozptýlení vyžaduje prístup k více stránkám Hana Rudová, Logické programování I, 15. kvetna 2013 246 Implementace Prologu Srovnání II Složitost algoritmů pro p r ístup k jednotlivým argumentům s sdílení struktur: nutná víceúrovnová nep rímá adresace & kopírování struktur: bez problémU jednodušší algoritmy usnadnují i optimalizace Lokalita p r ístupů do pameti s sdílení struktur: p rístupy rozptýleny po pameti & kopírování struktur: lokalizované p rístupy p r i stránkování pameti - rozptýlení vyžaduje p rístup k více stránkám Z praktického hlediska neexistuje mezi temito p rístupy zásadní rozdíl Hana Rudová, Logické programování I, 15. kvetna 2013 246 Implementace Prologu Rízení výpoctu JS> Dop r ednývýpocet a po úspěchu (úspěšná rědukcě) jědnotlivá volání procědur skoncí úspěchěm a klasické volání rěkurzivních procědur Hana Rudová, Logické programování I, 15. května 2013 247 Implěměntacě Prologu Řízení výpočtu JS> Dopredný výpočet & po úspěchu (úspěšná redukce) jednotlivá volání procedur skonCí úspěchem it klasické volání rekurzivních procedur JS> Zpetný výpočet (backtracking) it po neúspechu vyhodnocení literálu (neúspešná redukce) nepodarí se unifikace aktuálních a formálních parametrů hlavy it návrat do bodu, kde zústala nevyzkoušená alternativa výpoctu je nutná obnova původních hodnot jednotlivých promenných po nalezení místa s dosud nevyzkoušenou klauzulí pokracuje dále dopredný výpocet Hana Rudová, Logické programování I, 15. kvetna 2013 247 Implementace Prologu Aktivační záznam -í* Volání (=aktivace) procedury M Aktivace sdílí společný kód, liší se obsahem aktivačního záznamu JS> Aktivacní záznam uložen na lokálním zásobníku Hana Rudová, Logické programování I, 15. kvetna 2013 248 Implementace Prologu Aktivační záznam -í* Volání (=aktivace) procedury M Aktivace sdílí společný kód, liší se obsahem aktivačního záznamu & AktivaCní záznam uložen na lokálním zásobníku JS> Dopredný výpoCet i> stav výpoCtu v okamžiku volání procedury A aktuální parametry iľ lokální proměnné pomocné promenné ('a la registry) Hana Rudová, Logické programování I, 15. kvetna 2013 248 Implementace Prologu Aktivační záznam -í* Volání (=aktivace) procedury M Aktivace sdílí společný kód, liší se obsahem aktivačního záznamu JS> Aktivacní záznam uložen na lokálním zásobníku JS> Dopredný výpocet i> stav výpoctu v okamžiku volání procedury A aktuální parametry iľ lokální promenné & pomocné promenné ('a la registry) J& Zpetný výpocet (backtracking) -i- hodnoty parametrů v okamžiku zavolání procedury -fc následující klauzule pro zpracování pri neúspechu Hana Rudová, Logické programování I, 15. kvetna 2013 248 Implementace Prologu Aktivační záznam a roll-back Neúspěšná klauzule mohla nainstanciovat nelokální proměnné a(X) :- X = b(c,Y), Y = d. ?- W = b(Z,e), a(W). Hana Rudová, Logické programování I, 15. kvetna 2013 249 Implementace Prologu Aktivační záznam a roll-back Neúspěšná klauzule mohla nainstanciovat nelokální proměnné a(X) : - X = b(c,Y), Y = d. ?- W = b(Z,e), a(W). (viz instanciace Z) Hana Rudová, Logické programování I, 15. kvetna 2013 249 Implementace Prologu Aktivační záznam a roll-back Neúspešná klauzule mohla nainstanciovat nelokální promenné a(X) : - X = b(c,Y), Y = d. ?- W = b(Z,e), a(W). (viz instanciace Z) -í* Pri návratu je treba obnovit (roll-back) původní hodnoty proměnných Využijeme vlastností logických promenných Jť instanciovat lze pouze volnou promennou iť jakmile promenná získá hodnotu, nelze ji zmenit jinak než návratem výpočtu => puvodní hodnoty všech promenných odpovídají volné promenné Hana Rudová, Logické programování I, 15. kvetna 2013 249 Implementace Prologu Aktivační záznam a roll-back Neúspěšná klauzule mohla nainstanciovat nelokální proměnné a(X) : - X = b(c,Y), Y = d. ?- W = b(Z,e), a(W). (viz instanciace Z) -í* Pri návratu je treba obnovit (roll-back) původní hodnoty proměnných Využijeme vlastností logických proměnných Jť instanciovat lze pouze volnou proměnnou i* jakmile proměnná získá hodnotu, nelze ji změnit jinak než návratem výpočtu => puvodní hodnoty všech proměnných odpovídají volné proměnné & Stopa (trail): zásobník s adresami instanciovaných proměnných A ukazatel na aktuální vrchol zásobníku uchováván v aktivacním záznamu pri neúspěchu jsou hodnoty proměnných na stopě v úseku mezi aktuálním a uloženým vrcholem zásobníku změněny na „volná" Hana Rudová, Logické programování I, 15. května 2013 249 Implementace Prologu Aktivační záznam a roll-back Neúspešná klauzule mohla nainstanciovat nelokální promenné a(X) : - X = b(c,Y), Y = d. ?- W = b(Z,e), a(W). (viz instanciace Z) -í* Pri návratu je treba obnovit (roll-back) puvodní hodnoty promenných Využijeme vlastností logických promenných Jť instanciovat lze pouze volnou promennou iť jakmile promenná získá hodnotu, nelze ji zmenit jinak než návratem výpočtu => puvodní hodnoty všech promenných odpovídají volné promenné & Stopa (trail): zásobník s adresami instanciovaných promenných A ukazatel na aktuální vrchol zásobníku uchováván v aktivacním záznamu pri neúspechu jsou hodnoty promenných na stope v úseku mezi aktuálním a uloženým vrcholem zásobníku zmeneny na „volná" & Globální zásobník: pro uložení složených termu S> ukazatel na aktuální vrchol zásobníku uchováván v aktivacním záznamu -i- pri neúspechu vrchol zásobníku snížen podle uschované hodnoty v aktivacním záznamu Hana Rudová, Logické programování I, 15. kvetna 2013 249 Implementace Prologu Okolí a bod volby Aktivacní záznam úspěšně ukoncěné procědury nělzě odstranit z lokálního zásobníku => rozdelení aktivacního záznamu: JS> okolí (ěnvironměnt) - informacě nutné pro doprědný běh programu M bod volby (choicě point) - informacě nězbytné pro zotavění po něúspěchu Hana Rudová, Logické programování I, 15. května 2013 250 Implěměntacě Prologu Okolí a bod volby Aktivacní záznam úspěšně ukoncěné procědury nělzě odstranit z lokálního zásobníku => rozdelení aktivacního záznamu: JS> okolí (ěnvironměnt) - informacě nutné pro doprědný běh programu M bod volby (choicě point) - informacě nězbytné pro zotavění po něúspěchu & ukládány na lokální zásobník & samostatně provázány (odkaz na prědchozí okolí rěsp. bod volby) Hana Rudová, Logické programování I, 15. května 2013 250 Implěměntacě Prologu Okolí a bod volby Aktivacní záznam úspešne ukoncené procedury nelze odstranit z lokálního zásobníku => rozdelení aktivačního záznamu: JS> okolí (environment) - informace nutné pro dopredný beh programu -í* bod volby (choice point) - informace nezbytné pro zotavení po neúspechu & ukládány na lokální zásobník -i* samostatne provázány (odkaz na predchozí okolí resp. bod volby) Důsledky: & samostatná práce s každou cástí aktivacního záznamu (optimalizace) Hana Rudová, Logické programování I, 15. kvetna 2013 250 Implementace Prologu Okolí a bod volby Aktivacní záznam úspešne ukoncené procedury nelze odstranit z lokálního zásobníku => rozdelení aktivačního záznamu: JS> okolí (environment) - informace nutné pro dopredný beh programu -í* bod volby (choice point) - informace nezbytné pro zotavení po neúspechu & ukládány na lokální zásobník -i* samostatne provázány (odkaz na předchozí okolí resp. bod volby) Důsledky: & samostatná práce s každou cástí aktivacního záznamu (optimalizace) -í* alokace pouze okolí pro deterministické procedury Hana Rudová, Logické programování I, 15. kvetna 2013 250 Implementace Prologu Okolí a bod volby Aktivacní záznam úspešne ukoncené procedury nelze odstranit z lokálního zásobníku => rozdelení aktivačního záznamu: JS> okolí (environment) - informace nutné pro dop r edný beh programu -í* bod volby (choice point) - informace nezbytné pro zotavení po neúspechu & ukládány na lokální zásobník -i* samostatne provázány (odkaz na p r edchozí okolí resp. bod volby) Důsledky: & samostatná práce s každou cástí aktivacního záznamu (optimalizace) -í* alokace pouze okolí pro deterministické procedury & možnost odstranení okolí po úspešném vykonání (i nedeterministické) procedury (pokud okolí následuje po bodu volby dané procedury) pokud je okolí na vrcholu zásobníku Hana Rudová, Logické programování I, 15. kvetna 2013 250 Implementace Prologu Řez JS> Prostredek pro ovlivnení behu výpoctu programátorem a(X) :- b(X), !, c(X). a(3). b(1). b(2). c(1). c(2). Hana Rudová, Logické programování I, 15. kvetna 2013 251 Implementace Prologu Řez JS> Prostředek pro ovlivnení behu výpoctu programátorem a(X) :- b(X), !, c(X). a(3). b(1). b(2). c(1). c(2). -í* Rez: neovlivnuje dopredný výpocet, má vliv pouze na zpetný výpocet & Odstranení alternativních vetví výpoctu ^ odstranení odpovídajících bodů volby A tj. odstranení bodu volby mezi soucasným vrcholem zásobníku a bodem volby procedury, která rez vyvolala (vcetne bodu volby procedury s rezem) => zmena ukazatele na „nejmladší" bod volby Hana Rudová, Logické programování I, 15. kvetna 2013 251 Implementace Prologu Řez JS> Prostredek pro ovlivnění běhu výpoctu programátorem a(X) :- b(X), !, c(X). a(3). b(1). b(2). c(1). c(2). -í* Rez: neovlivnuje dopredný výpocet, má vliv pouze na zpětný výpocet & Odstranění alternativních větví výpoctu ^ odstranění odpovídajících bodů volby A tj. odstranění bodu volby mezi soucasným vrcholem zásobníku a bodem volby procedury, která rez vyvolala (vcetně bodu volby procedury s rezem) => změna ukazatele na „nejmladší" bod volby ^ Vytvárení deterministických procedur => Optimalizace využití zásobníku Hana Rudová, Logické programování I, 15. května 2013 251 Implementace Prologu Interpret Prologu Základní principy: JS> klauzulě uložěny jako těrmy -i* programová databáze a pro uložění klauzulí Jr má charaktěr haldy 3 umožnujě modifikovatělnost prologovských programu za běhu (assert) C klauzulě zrětězěny podlě poradí nactění J* triviální zrětězění Hana Rudová, Logické programování I, 15. května 2013 252 Implěměntacě Prologu Interpret Prologu Základní principy: JS> klauzule uloženy jako termy -i* programová databáze a pro uložení klauzulí Jr má charakter haldy & umožnuje modifikovatelnost prologovských programu za behu (assert) C klauzule zretezeny podle poradí nactení J* triviální zretezení Vyhodnocení dotazu: volání procedur rízené unifikací Hana Rudová, Logické programování I, 15. kvetna 2013 252 Implementace Prologu Interpret - Základní princip 1. Vyber redukovaný literál („první", tj. nejlevejší literál cíle) 2. Lineárním průchodem od zaCátku databáze najdi klauzuli, jejíž hlava má stejný funktor a stejný poCet argumentů jako redukovaný literál 3. V prípade nalezení klauzule založ bod volby procedury 4. Založ dále okolí první klauzule (velikost odvozena od poCtu lokálních promenných v klauzuli) Hana Rudová, Logické programování I, 15. kvetna 2013 253 Implementace Prologu Interpret - Základní prinčip 1. Vyber redukovaný literál („první", tj. nejlevejší literál cíle) 2. Lineárním průchodem od zacátku databáze najdi klauzuli, jejíž hlava má stejný funktor a stejný pocet argumentů jako redukovaný literál 3. V prípade nalezení klauzule založ bod volby procedury 4. Založ dále okolí první klauzule (velikost odvozena od poctu lokálních promenných v klauzuli) 5. Proved' unifikaci literálu a hlavy klauzule 6. Úspech == pridej všechny literály klauzule k cíli („doleva", tj. na místo redukovaného literálu). Telo prázdné == výpocet se s úspechem vrací do klauzule, jejíž adresa je v aktuálním okolí. 7. Neúspech unifikace == z bodu volby se obnoví stav a pokracuje se v hledání další vhodné klauzule v databázi. Hana Rudová, Logické programování I, 15. kvetna 2013 253 Implementace Prologu Interpret - Základní princip 1. Vyber redukovaný literál („první", tj. nejlevejší literál cíle) 2. Lineárním průchodem od zacátku databáze najdi klauzuli, jejíž hlava má stejný funktor a stejný pocet argumentu jako redukovaný literál 3. V prípade nalezení klauzule založ bod volby procedury 4. Založ dále okolí první klauzule (velikost odvozena od poctu lokálních promenných v klauzuli) 5. Proved' unifikaci literálu a hlavy klauzule 6. Úspech == pridej všechny literály klauzule k cíli („doleva", tj. na místo redukovaného literálu). Telo prázdné == výpocet se s úspechem vrací do klauzule, jejíž adresa je v aktuálním okolí. 7. Neúspech unifikace == z bodu volby se obnoví stav a pokracuje se v hledání další vhodné klauzule v databázi. 8. Pokud není nalezena odpovídající klauzule, výpocet se vrací na predchozí bod volby (krátí se lokální i globální zásobník). 9. Výpocet koncí neúspechem: neexistuje již bod volby, k nemuž by se výpocet mohl vrátit. 10. Výpocet koncí úspechem, jsou-li úspešne redukovány všechny literály v cíli. Hana Rudová, Logické programování I, 15. kvetna 2013 253 Implementace Prologu Interpret - vlastnosti -í* Lokální i globální zásobník pri dopredném výpoctu roste A pri zpetném výpoctu se zmenšuje Lokální zásobník se může zmenšit pri dopredném úspešném výpoctu deterministické procedury. Hana Rudová, Logické programování I, 15. kvetna 2013 254 Implementace Prologu interpret - vlastnosti Lokální i globální zásobník p r i dop ř edném výpočtu roste A p ř i zpětném výpočtu se zmenšuje Lokální zásobník se může zmenšit p ř i dop ředném úspešném výpočtu deterministické procedury. Unifikace argumentů hlavy - obecný unifikační algoritmus Současne poznačí adresy instanciovaných promenných na stopu. Hana Rudová, Logické programování I, 15. kvetna 2013 254 Implementace Prologu Interpret - vlastnosti -í* Lokální i globální zásobník Jt pri dopredném výpoctu roste Jt pri zpetném výpoctu se zmenšuje Lokální zásobník se může zmenšit pri dopredném úspešném výpoctu deterministické procedury. -í* Unifikace argumentů hlavy - obecný unifikacní algoritmus Soucasne poznací adresy instanciovaných promenných na stopu. -í* „Interpret": interpretCQuery, Vars) :- call(Query), success(Query, Vars). interpret(_,_) :- failure. Jt dotaz vsazen do kontextu této speciální nedeterministické procedury -** tato procedura odpovídá za korektní reakci systému v prípade úspechu i neúspechu Hana Rudová, Logické programování I, 15. kvetna 2013 254 Implementace Prologu Optimalizace: Indexace Zrětězění klauzulí podlě poradí nactění vělmi něěfěktivní & Provázání klauzulí sě stějným funktorěm a aritou hlavy (tvorí jědnu proceduru) a tj., indexace procedur & Hash tabulka pro vyhlědání první klauzulě & Možno rozhodnout (parciálně) dětěrminismus procědury Hana Rudová, Logické programování I, 15. května 2013 255 Implěměntacě Prologu Indexace argumentů a(1) :- q(1). a(a) :- b(X). a([A|T]) :- c(A,T). & Obecně nedeterministická JS> Pri volání s alespon cástecně instanciovaným argumentem vždy deterministická (pouze jedna klauzule může uspět) Hana Rudová, Logické programování I, 15. kvetna 2013 256 Implementace Prologu Indexace argumentů a(1) :- q(1). a(a) :- b(X). a([A|T]) :- c(A,T). & Obecne nedeterministická -í* Pri volání s alespon cástecne instanciovaným argumentem vždy deterministická (pouze jedna klauzule může uspet) Indexace podle prvního argumentu Základní typy zretezení: -i- podle poradí klauzulí (aktuální argument je volná promenná) A dle konstant (aktuální je argument konstanta) -i- formální argument je seznam (aktuální argument je seznam) dle struktur (aktuální argument je struktura) Hana Rudová, Logické programování I, 15. kvetna 2013 256 Implementace Prologu Indexače argumentů II C Složitejší indexacní techniky a podle všech argumentů %> podle nejvíce diskriminujícího argumentu kombinace argumentu (indexové techniky z databází) zejména pro prístup k faktům Hana Rudová, Logické programování I, 15. kvetna 2013 257 Implementace Prologu Tail Recursion Optimization, TRO Iterace prováděna pomocí rekurze => lineární paměťová náročnost cyklů Hana Rudová, Logické programování I, 15. května 2013 258 Implementace Prologu Tail Recursion Optimization, TRO Iterace provádena pomocí rekurze => lineární pameťová nárocnost cyklů Optimalizace koncové rekurze (Tail Recursion Optimisation), TRO: Okolí se odstraní pred rekurzivním voláním posledního literálu klauzule, pokud je klauzule resp. její volání deterministické. Rízení se nemusí vracet: & v prípade úspechu se rovnou pokracuje JS> v prípade neúspechu se vrací na predchozí bod volby („nad" aktuální klauzulí) aktuální klauzule nemá dle predpokladu bod volby Rekurzivne volaná klauzule muže být volána prímo z kontextu volající klauzule. Hana Rudová, Logické programování I, 15. kvetna 2013 258 Implementace Prologu TRO - príklad Program: append([], L, L). append([A|X], L, [A|Y]) :- append(X, L, Y). Dotaz: ?- append([a,b,c], [x], L). Hana Rudová, Logické programování I, 15. kvetna 2013 259 Implementace Prologu TRO - p ř íklad Program: append([], L, L). append([A|X], L, [A|Y]) :- append(X, L, Y). Dotaz: ?- append([a,b,c], [x], L). append volán rekurzivně 4krát £ bez TRO: 4 okolí, lineární paměťová náročnost -í* s TRO: 1 okolí, konstatní paměťová náročnost Hana Rudová, Logické programování I, 15. května 2013 259 Implementace Prologu Optimalizace posledního volání TRO pouze speciální případ obecné optimalizace posledního volání (Last Call Optimization), LCO Hana Rudová, Logické programování I, 15. května 2013 260 Implementace Prologu Optimalizace posledního volání TRO pouze speciální případ obecné optimalizace posledního volání (Last Call Optimization), LCO Okolí (před redukcí posledního literálu) odstraňováno vždy, když leží na vrcholu zásobníku. Hana Rudová, Logické programování I, 15. kvetna 2013 260 Implementace Prologu Optimalizace posledního volání TRO pouze speciální prípad obecné optimalizace posledního volání (Last Call Optimization), LCO Okolí (pred redukcí posledního literálu) odstranováno vždy, když leží na vrcholu zásobníku. Nutné úpravy interpretu JS> disciplina smerování ukazatelu -fc vždy „mladší" ukazuje na „starší" („mladší" budou odstraneny dríve) -i- z lokálního do globálního zásobníku vyhneme se vzniku „visících odkazu" pri predcasném odstranení okolí Hana Rudová, Logické programování I, 15. kvetna 2013 260 Implementace Prologu Optimalizače posledního volání TRO pouze speciální prípad obecné optimalizače posledního volání (Last Call Optimization), LCO Okolí (pred redukcí posledního literálu) odstranováno vždy, když leží na vrcholu zásobníku. Nutné úpravy interpretu JS> disciplina směrování ukazatelu A vždy „mladší" ukazuje na „starší" („mladší" budou odstraneny dríve) -i- z lokálního do globálního zásobníku vyhneme se vzniku „visících odkazu" pri predcasném odstranení okolí „globalizace" lokálních promenných: lokální promenné posledního literálu A nutno presunout na globální zásobník i> pouze pro neinstanciované promenné Hana Rudová, Logické programování I, 15. kvetna 2013 260 Implementace Prologu Warrenův abstraktní poCítaC, WAM I. Navržen D.H.D. Warrenem v roce 1983, modifikace do druhé poloviny 80. let Datové oblasti: & Oblast kódu (programová databáze) separátní oblasti pro uživatelský kód (modifikovatelný) a vestavěné predikátý (nemění se) -i- obsahuje rovněž všechny statické objekty (texty atomu a funktoru apod.) JS> Lokální zásobník (Stack) & Stopa (Trail) JS> Globální zásobník n. halda(Heap) JS> Pomocný zásobník (Push Down List, PDL) pracovní pamět' abstraktního pocítace -i- použitý v unifikaci, syntaktické analýze apod. Hana Rudová, Logické programování I, 15. května 2013 261 Implementace Prologu Rozmístění datových oblastí Príklad konfigurace Halda Stopa Zásobník PDL Oblast kodu Ý A Halda i lokální zásobník musí mst stejným smerem it lze jednoduše porovnat stárí dvou promenných srovnáním adres využívá se pri zabránení vzniku visících odkazu Hana Rudová, Logické programování I, 15. kvetna 2013 262 Implementace Prologu Registry WAMu JS> Stavové registry: P citac adrěs (Program countěr) CP adrěsa návratu (Continuation Pointěr) E ukazatěl na nějmladší okolí (Environměnt) B ukazatěl na nějmladší bod volby (Backtrack point) TR vrchol stopy (TRail) H vrchol haldy (Hěap) HB vrchol haldy v okamžiku založění poslědního bodu volby (Hěap on Backtrack point) S ukazatěl, používaný pri analýzě složěných těrmů (Structurě pointěr) CUT ukazatěl na bod volby, na ktěrý sě rězěm zarízně zásobník Argumentové registry: A1,A2,... (pri prědávání paramětru n. pracovní rěgistry) Registry pro lokální promenné: Y1,Y2,... abstraktní znázornění lok. proměnných na zásobníku Hana Rudová, Logické programování I, 15. května 2013 263 Implěměntacě Prologu Typy instrukcí WAMu & put instrukce - p ríprava argumentů p r ed voláním podcíle A žádná z techto instrukcí nevolá obecný unifikační algoritmus & get instrukce - unifikace aktuálních a formálních parametru -i- vykonávají cinnost analogickou instrukcím unify -fc obecná unifikace pouze p r i get_value & unify instrukce - zpracování složených termu jednoargumentové instrukce, používají registr S jako druhý argument pocátecní hodnota S je odkaz na 1. argument J* volání instrukce unify zvetší hodnotu S o jednicku 3 obecná unifikace pouze p r i unify_value a unify_local_value Indexacní instrukce - indexace klauzulí a manipulace s body volby & Instrukce ř ízení behu - p r edávání rízení a explicitní manipulace s okolím Hana Rudová, Logické programování I, 15. kvetna 2013 264 Implementace Prologu Instrukce put a get: příklad Príklad: a(X,Y,Z) :- b(f,X,Y,Z). get_var A1,A5 get_var A2,A6 get_var A3,A7 put_const Alf put_va1ue A2,A5 put_va1ue A3,A6 put_va1ue A4,A7 execute b/4 Hana Rudová, Logické programování I, 15. kvetna 2013 265 Implementace Prologu WAM - optimalizace 1. Indexace klauzulí 2. Generování optimální posloupnosti instrukcí WAMu 3. Odstranění redundancí pri generování cílového kódu. Hana Rudová, Logické programování I, 15. kvetna 2013 266 Implementace Prologu WAM - optimalizace 1. Indexace klauzulí 2. Generování optimální posloupnosti instrukcí WAMu 3. Odstranení redundancí pri generování cílového kódu. & Príklad: a(X,Y,Z) :- b(f,X,Y,Z). naivní kód (vytvorí kompilátor pracující striktne zleva doprava) vs. optimalizovaný kód (pocet registrů a tedy i pocet instrukcí/presunů v pameti snížen): get_var A1,A5 | get_var A3,A4 get_var A2,A6 | get_var A2,A3 get_var A3,A7 | get_var A1,A2 put_const A1,f | put_const A1,f put_value A2,A5 | execute b/4 put_value A3,A6 put_value A4,A7 execute b/4 Hana Rudová, Logické programování I, 15. kvetna 2013 266 Implementace Prologu Instrukce WAMu get instrukce put instrukce unify instrukce get_var Ai,Y put_var Ai,Y unify_var Y get_value Ai,Y put_value Ai,Y unify_value Y get_const Ai,C put_unsafe_value Ai,Y unify_local_value Y get_nil Ai put_const Ai,C unify_const C get_struct Ai,F/N put_nil Ai unify_nil get_list Ai put_struct Ai,F/N unify_void N put_list Ai instrukce rízení allocate deallocate call Proc/N,A execute Proc/N proceed indexacní instrukce try_me_else Next retry_me_else Next trust_me_else fail try Next retry Next trust fail cut_last save_cut Y load_cut Y switch_on_term Var,Const,List,Struct switch_on_const Table switch_on_struct Table Hana Rudová, Logické programování I, 15. kvetna 2G13 267 Implementace Prologu WAM - indexace Provázání klauzulí: instrukce XX_me_e1se: M první klauzule: try_me_e1se; založí bod volby i> poslední klauzule: trust_me_e1se; zruší nejmladší bod volby a ostatní klauzule: retry_me_e1se; znovu použije nejmladší bod volby po neúspechu Hana Rudová, Logické programování I, 15. kvetna 2013 268 Implementace Prologu WAM - indexace Provázání klauzulí: instrukce XX_me_e1se: M první klauzule: try_me_e1se; založí bod volby i> poslední klauzule: trust_me_e1se; zruší nejmladší bod volby a ostatní klauzule: retry_me_e1se; znovu použije nejmladší bod volby po neúspechu ii> Provázání podmnožiny klauzulí (podle argumentu): S try retry -i- trust Hana Rudová, Logické programování I, 15. kvetna 2013 268 Implementace Prologu WAM - indexace Provázání klauzulí: instrukce XX_me_else: M první klauzule: try_me_else; založí bod volby i> poslední klauzule: trust_me_else; zruší nejmladší bod volby a ostatní klauzule: retry_me_else; znovu použije nejmladší bod volby po neúspechu & Provázání podmnožiny klauzulí (podle argumentu): S try retry -i- trust „Rozskokové" instrukce (dle typu a hodnoty argumentu): switch_on_term Var, Const, List, Struct výpocet následuje uvedeným návestím podle typu prvního argumentu switch_on_YY: hashovací tabulka pro konkrétní typ (konstanta, struktura) Hana Rudová, Logické programování I, 15. kvetna 2013 268 Implementace Prologu Pr íklad indexače instrukčí Procedu re a(atom) :- bodyl. a(1) :- body2. a(2) :- body3. a([X|Y]) :- body4. a([X|Y]) :- body5. a(s(N)) :- body6. a(f(N)) :- bodyľ. odpovídají instrukce a: switch_on_term Ll, L2, L3, L4 L5a: body2 L2: switch_on_const atom :Lla L6: retry_me_else L7 l :L5a L6a: body3 2 :L6a L7: retry_me_else L8 L3: try L7a L7a: body4 trust L8a L8: retry_me_else L9 L4: switch_on_struct s/l :L9a L8a: body5 f/1 :Ll0a L9: retry_me_else Ll0 Ll: try_me_else L5 L9a: body6 Lla: bodyl Ll0: trust_me_else fail L5: retry_me_else L6 LlOa: body7 Hana Rudová, Logické programování I, 15. kvetna 2013 269 Implementace Prologu WAM - rízení výpočtu & execute Proc: ekvivalentní príkazu goto Hana Rudová, Logické programování I, 15. kvetna 2013 270 Implementace Prologu WAM - rízení výpoCtu & execute Proc: ekvivalentní príkazu goto J5> proceed: zpracování faktu Hana Rudová, Logické programování I, 15. května 2013 270 Implementace Prologu WAM - r ízení výpoCtu & execute Proc: ekvivalentní príkazu goto J5> proceed: zpracování faktu M allocate: alokuje okolí (pro nekteré klauzule netreba, proto explicitne generováno) Hana Rudová, Logické programování I, 15. kvetna 2013 270 Implementace Prologu WAM - ř ízení výpočtu & execute Proc: ekvivalentní příkazu goto J5> proceed: zpracování faktU M allocate: alokuje okolí (pro některé klauzule netřeba, proto explicitne generováno) & deallocate: uvolní okolí (je-li to možné, tedy leží-li na vrcholu zásobníku) & call Proc,N: zavolá Proc, N udává pocet lok. promenných (odpovídá velikosti zásobníku) Hana Rudová, Logické programování I, 15. kvetna 2013 270 Implementace Prologu WAM - řízení výpočtu & execute Proc: ekvivalentní príkazu goto J5> proceed: zpracování faktU M allocate: alokuje okolí (pro některé klauzule netreba, proto explicitne generováno) & deallocate: uvolní okolí (je-li to možné, tedy leží-li na vrcholu zásobníku) & call Proc,N: zavolá Proc, N udává pocet lok. promenných (odpovídá velikosti zásobníku) Možná optimalizace: vhodným usporádáním promenných lze dosáhnout postupného zkracování lokálního zásobníku a(A,B,C,D) :- b(D), c(A,C), d(B), e(A), f. generujeme instrukce allocate call b/1,4 call c/2,3 call d/1,2 call e/1,1 deallocate execute f/0 Hana Rudová, Logické programování I, 15. kvetna 2013 270 Implementace Prologu WAM - řez Implementace r ezu (opakování): odstranení bodu volby mezi soucasným vrcholem zásobníku a bodem volby procedury, která r ez vyvolala (vcetne bodu volby procedury s rezem) Indexacní instrukce znemožnují v dobe p r ekladu rozhodnout, zda bude alokován bod volby M p r íklad: ?- a(X). muže být nedeterministické, ale ?- a(1). muže být deterministické Hana Rudová, Logické programování I, 15. kvetna 2013 271 Implementace Prologu WAM - rez Implementace rezu (opakování): odstranení bodů volby mezi soucasným vrcholem zásobníku a bodem volby procedury, která rez vyvolala (vcetne bodu volby procedury s rezem) Indexacní instrukce znemožnují v dobe prekladu rozhodnout, zda bude alokován bod volby M príklad: ?- a(X). muže být nedeterministické, ale ?- a(1). muže být deterministické cut_1ast: B := CUT save_cut Y: Y := CUT 1oad_cut Y: B := Y Hana Rudová, Logické programování I, 15. kvetna 2013 271 Implementace Prologu WAM - řez Implementace rezu (opakování): odstranení bodů volby mezi soucasným vrcholem zásobníku a bodem volby procedury, která rez vyvolala (vcetne bodu volby procedury s rezem) Indexacní instrukce znemožnují v dobe prekladu rozhodnout, zda bude alokován bod volby M príklad: ?- a(X). může být nedeterministické, ale ?- a(1). muže být deterministické cut_1ast: B := CUT save_cut Y: Y := CUT 1oad_cut Y: B := Y Hodnota registru B je uchovávána v registru CUT instrukcemi call a execute. Je-li rez prvním predikátem klauzule, použije se rovnou cut_1ast. V opacném prípade se použije jako první instrukce save_cut Y a v míste skutecného volání rezu se použije 1oad_cut Y. Hana Rudová, Logické programování I, 15. kvetna 2013 271 Implementace Prologu WAM - rez Implěměntacě rězu (opakování): odstranění bodů volby mězi soucasným vrcholěm zásobníku a boděm volby procědury, ktěrá r ěz vyvolala (vcětně bodu volby procědury s rězěm) Inděxacní instrukcě zněmožnují v době p r ěkladu rozhodnout, zda budě alokován bod volby M príklad: ?- a(X). mužě být nědětěrministické, alě ?- a(1). mužě být dětěrministické cut_last: B := CUT save_cut Y: Y := CUT load_cut Y: B := Y Hodnota rěgistru B jě uchovávána v rěgistru CUT instrukcěmi call a execute. Jě-li rěz prvním prědikátěm klauzulě, použijě sě rovnou cut_last. V opacném prípadě sě použijě jako první instrukcě save_cut Y a v místě skutěcného volání r ězu sě použijě load_cut Y. Príklad: a(X,Z) :- b(X), !, c(Z). a(2,Z) :- !, c(Z). a(X,Z) :- d(X,Z). odpovídá save_cut Y2; get A2,Y1; call b/1,2; load_cut Y2; put Y1.A1; execute c/1 get_const A1,2; cut_last; put A2,A1; execute c/1 execute d/2 Hana Rudová, Logické programování I, 15. května 2013 271 Implěměntacě Prologu