IB013 Logické programování I
Hana Rudová
jaro 2010
Hodnocení předmětu
JS> ZápoCtový projekt: celkem až 40 bodů
JS> Průběžná písemná přáce: až 30 bodů (základy programování v Prologů)
S> pro každého jediný termín: l.dubna nebo 2.dubna (bůde ůpresneno) -i- alternativní termín poůze v prípadech závažných důvodů pro neúCast -fc vzor písemky na webů predmetů
-i* ZáveřeCná písemná přáce: až 150 bodů
a vzor písemky na webů predmetů
opravný termín možný jako ústní zkoůška
JS> Hodnocení: soůCet bodů za projekt a za obe písemky
známka A za cca 175 bodů, známka F za cca 110 bodů -i- známka bůde zapsána poůze tem, kterí dostanoů zápocet za projekt
Hana Růdová, Logické programování I, 19. kvetna 2010
2
Organizace predmetů
Základní informace
& Prednáška: úcast není povinná nicméně ... -í* CviCení: úCast povinná, zápoCet udělen za zápoCtový projekt individuální dopinující príklady za zmeškaná cviCení
Web predmetu: interaktivní osnova na IS
J* prUsvitky dostupné postupne v průbehu semestru
harmonogram výuky, predbežný obsah výuky pro jednotlivé prednášky behem semestru J* elektronicky dostupné materiály -i- informace o zápoctových projektech
JS> Obsah prednášky
± základy programování v jazyce Prolog
a teorie logického programováni
& logické programování s omezujícími podmínkami
a implementace logického programováni
Hana Rudová, Logické programování I, 19. kvetna 2010 3 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, 19. kvetna 2010
4
Organizace predmetu
Software: SICStus Prolog
C Doporučovaná implementace Prologu
& Dokumentace: http://www.fi.muni.cz/~hanka/sicstus/doc/html JS> Komerční produkt
Zakoupena licence pro instalace na domácí počítače studentů
Podrobné informace na webu predmetu
Hana Rudová, Logické programování I, 19. května 2010
5
Organizace předmětu
Cvičení
Zaměřeno na praktické aspekty, u počítačů Skupiny:
* skupina 01, sudý pátek, první cvičení 26.února s skupina 02, lichý pátek, první cvičení 5.brezna
Zápočtové projekty: Adriana Strejčkova <ada@fi.muni.čz>
a zápočtové projekty dostupné pres web predmetu
-fc podrobné pokyny k zápočtovým projektum na webu predmetu
&> zahájení registrace rešitelů projektu: 11. brezna
a predbežná analýza rešeného problému: 8. dubna
J* termín pro odevzdání projektů: 20. kvetna
&> predvádení projektů (po registraci): 26.kvetna - 18.června
Hana Rudová, Logické programování I, 19. kvetna 2010
6
Organizace predmetu
Průběžná písemná práce
M Pro každého jediný termín 1.dubna nebo 2.dubna (bude upřesněno) 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, 19. května 2010
7
Organizace predmetu
Průběžná písemná práce
Pro každého jediný termín 1.dubna nebo 2.dubna (bude upřesněno) 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í programu Obsah: první čtyri prednášky a první dve cvičení Oblasti, kterých se budou príklady zejména týkat
unifikace seznamy & backtracking it optimalizace posledního volání
*> rez it aritmetika
j* Ukázka průběžné písemné práce na webu
Hana Rudová, Logické programování I, 19. května 2010 7 Organizace předmětu
Úvod do Prologu
Prolog
-í* PROgramming in LOGic
a Část predikátové logiky prvního řádu
-í* Deklarativní programování
-i- spěcifikační jazyk, jasná sémantika, nevhodné pro procedurální postupy -fc Co delat namísto Jak delat
-i* Základní mechanismy
J* unifikace, stromové datové struktury, automatický backtracking
Hana Rudová, Logické programování I, 19. května 2010
9
Úvod do Prologu
Prolog: historie a současnost
Rozvoj zaCíná po rocě 1970
Roběrt Kowalski - teoretické základy
Alain Colměrauěr, David Warrěn (Warren Abstract Machine) - implementace iť pozdější rozšírení Prologu o logické programování s omezujícími podmínkami
Hana Rudová, Logické programování I, 19. května 2010
10
Úvod do Prologu
Prolog: historie a současnost
M Rozvoj začíná po roce 1970
J* Robert Kowalski - teoretické základy
Alain Colmerauer, David Warren (Warren Abstract Machine) - implementace i* pozdejší rozšírení Prologu o logické programování s omezujícími podmínkami
-í* Prolog v současnosti
-fc zavedené aplikační oblasti, nutnost pridání inteligence
hypotéky; pediatrický sw; konfigurace a pravidla pro stanovení ceny objednávky; testovací nástroje, modelové testování; ...
J* náhrada procedurálního kódu Prologem vede k
desetinásobnému zmenšení kódu, rádove menšímu času na vývoj, jednodušší údržbe
-i- efektivita Prologu?
zrychlení počítaču + výrazné zvetšení nároku sw == ve prospech kompaktnosti i rychlosti Prologu
Hana Rudová, Logické programování I, 19. kvetna 2010 10 Úvod do Prologu
Program = fakta + pravidla
(Prologovský) program je seznam programových klauzulí
i> programové klauzule: fakt, pravidlo
Fakt: deklaruje vždy pravdivé veci
-fc clovek( novak, 18, student ).
Pravidlo: deklaruje veci, jejichž pravdivost závisí na daných podmínkách
J* studuje( X )      clovek( X, _Vek, student ). Jt alternativní (obousměrný) význam pravidel
pro každé X, pro každé X,
X studuje, jestliže X je student, potom
X je student X studuje
Jt pracuje( X )      clovek( X, _Vek, CoDela ), prace( CoDela ).
Hana Rudová, Logické programování I, 19. kvetna 2010
11
Ú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
-fc 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í (obousmerný) význam pravidel
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 ).
JS> Predikát: množina pravidel a faktů 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, 19. kvetna 2010 11 Úvod do Prologu
Komentáre k syntaxi
C Klauzule ukončeny tečkou
& Základní príklady argumentu
-i- konstanty: (tomas, anna) ... začínají malým písmenem i* promenné
X, Y ... začínají velkým písmenem
_, _A, _B ... začínají podtržítkem (nezajímá nás vračená hodnota)
£ Psaní komentárů
clovek( novak, 18, student ). % komentár na konči rádku
clovek( novotny, 30, ucitel ). /* komentár */
Hana Rudová, Logičké programování I, 19. kvetna 2010
12
Úvod do Prologu
Dotaz
Dotaz: uživatel se ptá programu, zda jsou veci pravdivé
?- studuje( novak). % yes        splnitelný dotaz
?- studuje( novotny). % no nesplnitelný dotaz
Odpoveď na dotaz
A positivní - dotaz je splnitelný a uspel
-í* negativní - dotaz je nesplnitelný a neuspel
Hana Rudová, Logické programování I, 19. května 2010
13
Úvod do Prologu
Dotaz
Dotaz: uživatel se ptá programu, zda jsou veci pravdivé
?- studuje( novak). ?- studuje( novotny).
% yes % no
splnitelný dotaz nesplnitelný dotaz
Odpoveď na dotaz
Jt positivní - dotaz je splnitelný a uspel
-í* negativní - dotaz je nesplnitelný a neuspel
Proměnné jsou behem výpoCtu instanciovány (= nahrazeny objekty)
-i- ?- clovek( novak, 18, Prace ).
A výsledkem dotazu je instanciace promenných v dotazu
-i- dosud nenainstanciovaná promenná: volná promenná
Hana Rudová, Logické programování I, 19. kvetna 2010
13
Úvod do Prologu
Dotaz
-í* Dotaz: uživatel se ptá programu, zda jsou veci pravdivé
?- studuje( novak). % yes        splnitelný dotaz
?- studuje( novotny). % no nesplnitelný dotaz
JS> Odpoveď na dotaz
A positivní - dotaz je splnitelný a uspel
-í* negativní - dotaz je nesplnitelný a neuspel
& Promenné jsou behem výpoctu instanciovány (= nahrazeny objekty)
-i- ?- clovek( novak, 18, Prace ).
A výsledkem dotazu je instanciace promenných v dotazu
-i- dosud nenainstanciovaná promenná: volná promenná
ií> Prolog umí generovat více odpovedí pokud existují
?- clovek( novak, Vek, Prace ). % všechna rešení pres ";"
Hana Rudová, Logické programování I, 19. kvetna 2010 13 Ú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 = konjůnkce
& Fakt: poůze 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, poůze telo
J* ?- clovek( novak, Vek, Prace ).
?- rodic( pavla, Dite ), rodic( Dite, Vnuk ).
Hana Růdová, Logické programování I, 19. kvetna 2010
14
Úvod do Prologů
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, 19. května 2010 15 Ú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, 19. května 2010
15
Ú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á, Logičké programování I, 19. kvetna 2010 16 Úvod do Prologu
Výpočet odpovědi 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 ) :- rodic( X, Z). % (1)
predek( X, Z ) :- rodic( X, Y ), % (2')
predek( Y, Z ).
Hana Rudová, Logické programování I, 19. kvetna 2010
17
Úvod do Prologu
Výpočet odpovedi na dotaz ?- predek(tomas, petr)
predek(tomas, petr)
dle (1)
t
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, 19. kvetna 2010
18
Úvod do Prologu
Odpoved' na dotaz ?- predek(robert, Potomek)
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(robert,Potomek) --> ???
Hana Rudová, Logické programování I, 19. kvetna 2010
19
Úvod do Prologu
Syntaxe a význam Přologovských přogřamů
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á
Jt 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, _ )
Jt lexikální rozsah promenné je pouze jedna klauzule:
prvni(X,X,X). prvni(X,X,_).
Hana Rudová, Logické programování I, 19. kvetna 2010 21 Syntaxe a význam Prologovských programu
Termy
M Term - datové objekty v Prologu: datum( 1, kveten, 2003 )
a funktor: datum Jt argumenty: 1, kveten, 2003 Jt arita - pocet argumentu: 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
it trojuhelnikje hlavní funktor v trojuhelnik( bod(4,2), bod(6,4), bod(7,1) )
Hana Rudová, Logické programování I, 19. kvetna 2010 22 Syntaxe a význam Prologovských programu
Unifikace
Termy jsou unifikovatelné, jestliže
jsou identické nebo
Jt promenné v obou termech mohou být instanciovány tak, že termyjsou po substituci identické
Jt datum( D1, M1, 2003 ) = datum( 1, M2, Y2)      operátor = D1 =1, M1 = M2, Y2 = 2003
Hana Rudová, Logické programování I, 19. kvetna 2010
23
Syntaxe a význam Prologovských programu
Unifikace
Termy jsoů unifikovatelné, jestliže
jsoů identické nebo
Jť promenné v oboů termech mohoů být instanciovány tak, že termyjsoů po sůbstitůci identické
a datum( D1, M1, 2003 ) = datum( 1, M2, Y2)      opeřátoř = D1 =1, M1 = M2, Y2 = 2003
JS> Hledáme nejobecnejší unifikátoř (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 Růdová, Logické programování I, 19. kvetna 2010
23
Syntaxe a význam Prologovských programů
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, 19. kvetna 2010
23
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
JÍ* S a T mají stejný funktor a aritu a
M všechny jejich odpovídající argumenty jsou unifikovatelné JS* výsledná substituce je urcena unifikací argumentů
Příklady:
k = k ... yes, kl = k2 ... no,
Hana Rudová, Logičké programování I, 19. kvetna 2010
24
Syntaxe a význam Prologovskýčh 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
Hana Rudová, Logické programování I, 19. kvetna 2010
24
Syntaxe a význam Prologovských programu
Unifikače
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 určena 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))...
Hana Rudová, Logické programování I, 19. kvetna 2010
24
Syntaxe a význam Prologovských programu
Unifikace
Těrmy S a T jsou unifikovatělné, jěstližě
1. S a T jsou konstanty a tyto konstanty jsou iděntické;
2. S jě proměnná a T cokoliv jiného - S jě instanciována na T; Tjě proměnná a S cokoliv jiného - T jě instanciována na S
3. S a T jsou těrmy
JS* S a T mají stějný funktor a aritu a
M všěchny jějich odpovídající arguměnty jsou unifikovatělné -Ä* výslědná substitucě jě urcěna unifikací arguměntů
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, 19. května 2010
24
Syntaxě 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))...
Hana Rudová, Logické programování I, 19. kvetna 2010
24
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, 19. kvetna 2010
24
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))... no
s(sss(A),4,ss(C)) = s(sss(t(B)),4,ss(A))...
Hana Rudová, Logické programování I, 19. kvetna 2010
24
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))... 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, 19. kvetna 2010
24
Syntaxe a význam Prologovských programu
Deklarativní a pročedurá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, 19. kvetna 2010
25
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í logičké relače
Pročedurální: Jak vypočítáme výstup programu?
-fc p vyrešíme tak, že nejprve vyrešíme q a pak r
=> krome logičkýčh relačí je významné i poradí čílu a výstup
indikátor yes/no určujíčí, zda byly číle splneny instančiače promennýčh v prípade splnení čílů
Hana Rudová, Logičké programování I, 19. kvetna 2010
25
Syntaxe a význam Prologovskýčh programu
Deklarativní význam programu
Máme-li program a cíl G, pak deklarativní význam ríká:
cíl G je splnitelný práve tehdy, když cíl ?- ma_dite(petr).
existuje klauzule C v programu taková, že existuje instance I klauzule C taková, že hlava I je identická s G a všechny cíle v tele I jsou pravdivé.
Instance klauzule: promenné v klauzuli jsou substituovány termem
ma_dite(X)       rodic( X, Y ). % klauzule
ma_dite(petr)       rodic( petr, Z ).        % instance klauzule
Hana Rudová, Logické programování I, 19. kvetna 2010
26
Syntaxe a význam Prologovských programu
Konjunce "," vs. disjunkce ";" cílů
Konjunce = nůtné splnení všech cílů
p :- q, r.
JS> Disjunkce = stací splnení libovolného cíle
ap:-q;r. p:-q.
p r.
a priorita středníků je vyšší:
p      q, r; s, t, u.
p      (q, r) ; (s, t, u).
p      q, r. p      s, t, u.
Hana Růdová, Logické programování I, 19. kvetna 2010
27
Syntaxe a význam Prologovských programů
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, 19. kvetna 2010
28
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).       % změněné poradí klauzulí v programu vzhlěděm k (a) a(1).
b(1,1).
Hana Rudová, Logické programování I, 19. května 2010
28
Syntaxě 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
Hana Rudová, Logické programování I, 19. kvetna 2010
28
Syntaxe a význam Prologovských programu
Poradí klauzulí a cílu
(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: nekonečný cyklus
(c) a(X) :- b(X,Y), c(Y). ?- a(X). b(1,1).
c(2). c(1).
Hana Rudová, Logické programování I, 19. kvetna 2010
28
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é poradí 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é poradí cílu v tele klauzule vzhledem k (c)
Hana Rudová, Logické programování I, 19. kvetna 2010
28
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í klaůzůlí v programů vzhledem k (a) a(1).
b(1,1). % nenalezení odpovedi: nekonecný cyklůs
(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ílů v tele klaůzůle vzhledem k (c) b(1,1).
c(2).
c(1). % nárocnejší nalezení první odpovedi než ů (c)
V oboů prípadech stejný deklařativní ale odlišný přoceduřální význam
Hana Růdová, Logické programování I, 19. kvetna 2010 28 Syntaxe a význam Prologovských programů
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á, Logičké programování I, 19. kvetna 2010
29
Syntaxe a význam Prologovskýčh 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).
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, 19. kvetna 2010
29
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
M Priorita operátorů: operátor s nejvyšší prioritou je hlavní funktor
Hana Rudová, Logické programování I, 19. kvetna 2010
31
Operátory, aritmetika
Operátory
JS* Infixová notacě: 2*a + b*c
-í* Prěfixová notacě: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400
M Priorita operátorů: opěrátor s nejvyšší prioritou jě hlavní funktor
& Uživatělsky děfinované opěrátory: zna
petr zna alese.      zna( petr, alese).
& Děfinicě opěrátoru: :- op( 600, xfx, zna ). priorita: 1..1200
Hana Rudová, Logické programování I, 19. května 2010
31
Opěrátory, aritmětika
Operátory
-í* Infixová notace: 2*a + b*c
& Prefixová notace: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400
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
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, 19. kvetna 2010
31
Operátory, aritmetika
Operátory
JS* Infixová notace: 2*a + b*c
-í* Prefixová notace: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400
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
J> :- op( 1100, xfy, ; ). nestrukturované objekty: 0
:- op( 1000, xfy, , ).
p :- q,r; s,t. p :- Cq,r) ; (s,t).      ; má vyšší prioritu než ,
& :- op( 1200, xfx, :- ).       :- má nejvyšší prioritu
-í* Definice operátoru není spojena s datovými manipulacemi (krome speciálních prípadu)
Hana Rudová, Logické programování I, 19. kvetna 2010
31
Operátory, aritmetika
Typy operátoru
Typy operátoru
J* infixové operátory: xfx, xfy, yfx it prefixové operátory: fx, fy &> postfixové operátory: xf, yf
pr.   xfx = yfx pr.   fx ?- fy
x a y urcují prioritu argumentu
J* x reprezentuje argument, jehož priorita musí být striktne menší než u operátoru -i- y reprezentuje argument, jehož priorita je menší nebo rovna operátoru Jt a-b-c odpovídá (a-b)-c a ne a-(b-c): „-" odpovídá yfx
správně
priorita: 0 priorita: 0
chybně
priorita: 500
priorita: 500
Hana Rudová, Logické programování I, 19. kvetna 2010
32
Operátory, aritmetika
Aritmetika
JS* Preddefinované operátory
+ , -i *i A ** močnina, // celocíselné dělení, mod zbytek po delení
J* ?- X = 1 + 2. X = 1 + 2      = odpovídá unifikači
M ?- X is 1 + 2.
X = 3      „is" je speciální preddefinovaný operátor, který vynutí evaluači
Hana Rudová, Logičké programování I, 19. kvetna 2010
33
Operátory, aritmetika
Aritmetika
JS* Preddefinované operátory
+ , -i *i A ** mocnina, // celočí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)
Hana Rudová, Logické programování I, 19. kvetna 2010
33
Operátory, aritmetika
Ařitmetika
& Preddefinované operátory
+ , -i *i A ** mocnina, // celočíselné dělení, mod zbytek po delení
J* ?- X = 1 + 2. X = 1 + 2      = odpovídá ůnifikaci
M ?- X is 1 + 2.
X = 3      „is" je speciální předdefinovaný opeřátoř, který vynůtí evalůaci
porovnej:      N = (1+1+1+1+1) N is (1+1+1+1+1)
a pravá strana můsí být vyhodnotitelný výraz (bez promenné) volání ?- X is Y + 1. způsobí chybů
Hana Růdová, Logické programování I, 19. kvetna 2010
33
Operátory, aritmetika
Aritmetika
-i* Preddefinované operátory
+ , -i *i A ** mocnina, // celoCíselné delení, mod zbytek po delení
J* ?- X = 1 + 2. X = 1 + 2      = odpovídá unifikaci
M ?- X is 1 + 2.
X = 3      „is" je spečiální preddefinovaný operátor, který vynutí evaluaci
porovnej:      N = (1+1+1+1+1) N is (1+1+1+1+1)
a pravá strana musí být vyhodnotitelný výraz (bez promenné) volání ?- X is Y + 1. zpusobí chybu
JS> Další speciální preddefinované operátory
>, <, >=, =<, =:= aritmetičká rovnost, =\= aritmetičká nerovnost
-i- porovnej:      1+2 =:= 2+1 1+2 = 2+1
Hana Rudová, Logické programování I, 19. kvetna 2010
33
Operátory, aritmetika
Aritmetika
& 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)
Jt pravá strana musí být vyhodnotitelný výraz (bez promenné) 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. zpusobí chybu
Hana Rudová, Logické programování I, 19. kvetna 2010 33 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)
Hana Rudová, Logické programování I, 19. kvetna 2010
34
Operátory, aritmetika
Různé typy řovností a porovnání
X = Y      Xa Y jsoů ůnifikovatelné
X \= Y     Xa Y nejsoů ůnifikovatelné, (také \+ X = Y)
X == Y     Xa Y jsoů identické
porovnej:   ?-A == B. ... no      ?-A=B, A==B.
Hana Růdová, Logické programování I, 19. kvetna 2010
34
Operátory, aritmetika
Různé typy rovností 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, 19. kvetna 2010
34
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 a Y jsou unifikovatelné
Xa Y nejsou unifikovatelné, (také \+ X = Y)
X a Y jsou identičké
porovnej: ?- A == B. ... no ?- A=B, A==B. ... B = A yes X a Y nejsou identičké
porovnej:   ?- A \== B. ... yes      ?- A=B, A \== B. ... A no
Y je aritmetičky vyhodnočeno a výsledek je prirazen X
X a Y jsou si aritmetičky rovny
X a Y si aritmetičky nejsou rovny
aritmetičká hodnota X je menší než Y (=<, >, >=)
Hana Rudová, Logičké programování I, 19. kvetna 2010
34
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 předchá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, 19. kvetna 2010
34
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řiř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 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 ?- f( pavel, g(b)) @< f( pavel, h(a)). ... yes
Hana Rudová, Logické programování I, 19. kvetna 2010
34
Operátory, aritmetika
Prolog: príklady
Príklad: průbeh výpočtu
a :- b,c,d. b :- e,c,f,g. b :- g,h.
c.
d.
e :- i. e :- h.
gh.
i.
Jak vypadá pmbeh výpoctu pro dotaz ?- a.
Hana Rudová, Logické programování I, 19. kvetna 2010
36
Prolog: príklad
Príklad: vež z kostek
Príklad: postavtě věž zadané vělikosti zě trí různě vělkých kostěk tak, žě kostka smí lěžět pouzě na větší kostcě.
Hana Rudová, Logické programování I, 19. května 2010
37
Prolog: p ríklad
Príklad: vež z kostek
Príklad: postavte vež zadané velikosti ze trí různe velkých kostek tak, že kostka smí ležet pouze na vetší kostce.
kostka(mala).    kostka(stredni). kostka(velka).
vetsi(zeme,ve1ka).   vetsi(zeme,stredni). vetsi(zeme,ma1a). vetsi(ve1ka,stredni). vetsi(ve1ka,ma1a). vetsi(stredni,ma1a).
% ?- postav_vez(vez(zeme,0), vez(Kostka,0)). % ?- postav_vez(vez(zeme,0), vez(Kostka,3)).
Hana Rudová, Logické programování I, 19. kvetna 2010
37
Prolog: příklad
Príklad: vež z kostek
Príklad: postavte vež zadané velikosti ze trí různe velkých kostek tak, že kostka smí ležet pouze na vetší kostce.
kostka(mala).    kostka(stredni). kostka(velka).
vetsi(zeme,velka).   vetsi(zeme,stredni). vetsi(zeme,mala). vetsi(velka,stredni). vetsi(velka,mala). vetsi(stredni,mala).
% ?- postav_vez(vez(zeme,0), vez(Kostka,0)). % ?- postav_vez(vez(zeme,0), vez(Kostka,3)). postav_vez( Vez, Vez ).
postav_vez( Vstup, Vystup ) :- pridej_kostku( Vstup, Pridani ),
postav_vez( Pridani, Vystup ).
pridej_kostku( Vstup, Pridani ) :- Vstup = vez( Vrchol, Vyska ),
kostka( Kostka ), vetsi( Vrchol, Kostka ), NovaVyska is Vyska + 1, Pridani = vez( Kostka, NovaVyska ).
Hana Rudová, Logické programování I, 19. kvetna 2010
37
Prolog: příklad
Řez, negace
Rez a upnutí
f(X,0)  :- X < 3 .
f(X,2)  :- 3 =< X, X < 6 .
f(X,4)  :- 6 =< X.
přidání operátoru rezu ,,!''
y
4
2
?- f(1,Y), Y>2.
j—
J_L
-©
J_L
3
6
x
Hana Rudová, Logičké programování I, 19. kvetna 2010
39
Řez, negače
Rez a upnutí
f(X,0)  :- X < 3, I.
f(X,2)  :- 3 =< X, X < 6, I.
f(X,4)  :- 6 =< X.
pridání operátoru rezu ,,!''
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, 19. kvetna 2010 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.
pridání opeřátořu řezu
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ílů pred rezem se ůž další klaůzůle neůvažůjí
Hana Růdová, Logické programování I, 19. kvetna 2010 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.
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, 19. kvetna 2010 39 Rez, negace
Řez 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, 19. kvetna 2010
40
Řez, 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, 19. kvŘetna 2010
40
RŘez, 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, 19. kvetna 2010
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 splnění podcílů prěd rězěm sě už něuvažujě další možné splnění těchto podcílu
Smazání rězu změní chování programu
Hana Rudová, Logické programování I, 19. května 2010
40
Rěz, něgacě
Chování operátoru rezu
Predpokládejme, že klauzule H :- T1, T2, Tm,  I,  ...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
Orezaní: 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), I. h(2,Y) :- a.
t1(1) :- b. t1(2)  :- c.
Hana Rudová, Logické programování I, 19. kvetna 2010
h(X,Y) X=1   /     \ X=2
t1(Y)     a   (vynechej: upnutí)
Y=1 /   \ Y=2
b c   (vynechej: o rezání)
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).
-í* Po zpračování klauzule s rezem se vračím až na rodiče této klauzule, tj. a(X)
Hana Rudová, Logičké programování I, 19. kvetna 2010
42
Rez, negače
Rez: príklad
c(X) :- p(X). c(X) :- v(X).
p(1).   p(2). v(2).
?- c(2).
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. května 2010
43
Řez, negace
Řez: pří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, 19. května 2010 43 Řez, negace
Řez: prí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, 19. kvetna 2010 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).
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, 19. května 2010 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, 19. května 2010
43
Rez, negace
Rez: cvičení
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, 19. kvŘetna 2010
44
RŘez, negace
Typy rezu
Zlepšení efektivity programu: urcíme, které alternativy nemá smysl zkoušet 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, 19. kvetna 2010
45
Rez, negace
Typy rezu
Zlepšení efektivity programu: urcíme, které alternativy nemá smysl zkoušet 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
Hana Rudová, Logické programování I, 19. kvetna 2010
45
Rez, negace
Typy rezu
Zlepšení efektivity programu: určíme, které alternativy nemá smysl zkoušet 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á čí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, 19. kvetna 2010
45
Rez, negace
Typy rezu
Zlepšení efektivity programu: urcíme, které alternativy nemá smysl zkoušet Zelený rez: odstraní pouze neúspešná odvození
f(X,1)  :- X >= 0,  !.    f(X,-1)  :- X < 0.
bez rezu zkouším pro nezáporná císla 2. klauzuli
Modrý rez: odstraní redundantní r ešení
a f(X,1) :- X >= 0,  !.    f(0,1). f(X,-1) :- X < 0. bez r ezu vrací f(0,1) 2x
Hana Rudová, Logické programování I, 19. kvetna 2010
45
Rez, negace
Typy rezu
Zlepšení efektivity programu: urcíme, které alternativy nemá smysl zkoušet 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í
a f(X,1) :- X >= 0,  I.    f(0,1). f(X,-1) :- X < 0. bez r ezu vrací f(0,1) 2x
Červený rez: odstraní úspešná rešení
f(X,1)  :- X >= 0,  I. f(_X,-1).
Hana Rudová, Logické programování I, 19. kvetna 2010
45
Rez, negace
Typy rezu
Zlepšení efektivity programu: urcíme, které alternativy nemá smysl zkoušet 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í
a f(X,1) :- X >= 0,  I.    f(0,1). f(X,-1) :- X < 0. bez r ezu vrací f(0,1) 2x
Červený rez: odstraní úspešná rešení
Jť 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, 19. kvetna 2010
45
Rez, negace
Negace jako neúspech
Speciální cíl přo nepravdu (neúspech) fail a přavdu true
& X a Y nejsou unifikovatelné: different(X, Y)
C different( X, Y ) :- X = Y,  I, fail. different( _X, _Y ).
-í* X je muž: muz(X)
muz( X ) :- zena( X ),  I, fail. muz( _X ).
Hana Rudová, Logické programování I, 19. kvetna 2010
46
Rez, negace
Negace jako neúspěch: operátor \+
ďifferent(XfY) :-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.
it v opačném p rípade \+ P uspeje \+(_).
Hana Rudová, Logické programování I, 19. kvetna 2010
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).
& 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, 19. kvetna 2010
47
Rez, negace
Negace a promenné
\+(P)  :- P,  !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobře( bmw ). % (2)
dřahe( bmw ). % (3)
řozumne( Auto ) :- % (4)
\+ dřahe( Auto ).
Hana Rudová, Logičké programování I, 19. kvetna 2010
48
Rez, negače
Negace a promenné
\+(P) :- P,  I, fail. % (I)
\+(-). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (Z)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ). ľ- dobre( X ), rozumne( X ).
Hana Rudová, Logické programování I, 19. kvetna 2G1G
48
Rez, negace
Negace a promenne
\+(P) :- P' !' 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, 19. kvetna 2010
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)
Hana Rudová, Logické programování I, 19. kvetna 2010
48
Rez, negace
Negace a promenné
\+(P) :- P,  I, fai1. % (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, 19. kvetna 2010
48
Rez, negace
Negace a promenné
\+(P)  :- P,  !, 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)
dle (4) \+ drahe(citroen)
dle (I) drahe(citroen),!, fail
Hana Rudová, Logičké programování I, 19. kvetna 2010
48
Rez, negače
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, 19. kvetna 2010
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, 19. kvetna 2010
48
no
Rez, negace
Negace a promenne
\+(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, 19. kvetna 2010
49
Rez, negace
Negace a promenné
\+(P) :- P,  I, fai1. % (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, 19. kvetna 2010
49
Rez, negace
Negace a promenné
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, 19. kvetna 2010
49
Rez, negace
Negace
\+(P) :- P,  I, fail. % (I)
\+(-)- % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (Z)
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, l9. kvetna 2GlG
49
Rez, negace
\+(P) :- P, !, fail. % (I) \+(_). % (II)
dobre( citroen ) dobre( bmw )
Negace a promenne
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, 19. kvetna 2010
49
Rez, negace
Negace a
\+(P)  :- P,  !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobře( bmw ). % (2)
dřahe( bmw ). % (3)
řozumne( Auto ) :- % (4)
\+ dřahe( Auto ). ?- řozumne( 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á, Logičké programování I, 19. kvetna 2010
49
Rez, negače
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, 19. května 2010 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,  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, 19. kvetna 2010
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)
fail,dobre(bmw) no
9 Rez, negace
Bezpečný cíl
C ?- rozumne( citroen ). yes
?- rozumne( X ). no
JS> ?- \+ drahe( citroen ). yes
?- \+ drahe( 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, 19. kvetna 2010
50
Řez, negace
Chování negace
-í* ?- \+ drahe( citroen ). yes ?- \+ drahe( X ). no
& Negace jako neúspech poůžívá předpoklad uzavřeného sveta
pravdivé je poůze to, co je dokazatelné
?- \+ 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 )
Hana Růdová, Logické programování I, 19. kvetna 2010
51
Rez, negace
Chování negace
-í* ?- \+ drahe( citroen ). yes ?- \+ drahe( X ). no
& Negace jako neúspech používá p redpoklad uzav reneho sveta
pravdivé je pouze to, co je dokazatelné
?- \+ 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 )
M ?- drahe( X ).
VÍME: existuje X takové, že drahe( X ) platí
JS> ALE: pro cíle s negací neplatí existuje X takové, že \+ drahe( X )
Hana Rudová, Logické programování I, 19. kvetna 2010
51
Rez, negace
Chování negace
JS* ?- \+ drahe( citroen ). yes ?- \+ drahe( X ). no
& Negace jako neúspěch používá předpoklad uzavřeného sveta
pravdivé je pouze to, co je dokazatelné
?- \+ 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 )
M ?- drahe( X ).
VÍME: existuje X takové, že drahe( X ) platí
JS> ALE: pro cíle s negací neplatí existuje X takové, že \+ drahe( X )
=> negace jako neúspech není ekvivalentní negaci v matematické logice
Hana Rudová, Logické programování I, 19. kvetna 2010
51
Rez, negace
Predikáty na ŕízení běhu programu I.
řez „!"
fail: cíl, který vždy neuspeje      true: cíl, který vždy uspeje \+ P: negace jako neúspech
\+ P :- P,  1, fail; true.
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2010
52
Rez, negace
Předikáty na řízení behu přogřamu I.
řez „!"
fail: cíl, který vždy neůspeje      true: cíl, který vždy ůspeje \+ P: negace jako neúspech
\+ P :- P,  1, fail; true.
once(P): vrátí poůze jedno rešení cíle P once(P) :- P, 1.
Vyjádrení podmínky: P -> Q ; R
J* jestliže platí P tak Q        (P -> Q ; R) :- P,  1, Q. v opacném prípade R      (P -> Q ; R) :- R. príklad: min(X,Y,Z) :- X =< Y -> Z = X ; Z = Y.
Hana Růdová, Logické programování I, 19. kvetna 2010
52
Rez, negace
Predikáty na ŕízení běhu programu I.
rez „!"
fail: cíl, který vždy neuspeje      true: cíl, který vždy uspeje \+ P: negace jako neúspech
\+ P :- P,  1, fail; true.
once(P): vrátí pouze jedno rešení cíle P once(P) :- P, 1.
Vyjád rení podmínky: P -> Q ; R
J* jestliže platí P tak Q        (P -> Q ; R) :- P,  1, Q. v opacném p r í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, 19. kvetna 2010
52
Rez, negace
Predikáty na rízení behu programu I.
M rez „!"
& fail: číl, který vždy neuspeje      třue: číl, který vždy uspeje JS* \+ P: negače jako neúspečh
\+ P :- P,  !, fail; třue.
& once(P): vrátí pouze jedno rešení čí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 opačné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)
S> príklad: zaporne(X) :- number(X) -> X < 0.
Hana Rudová, Logičké programování I, 19. kvetna 2010 52 Rez, negače
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, 19. kvetna 2010
53
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.
klasické použití: generuj akci X, proved'ji a otestuj, zda neskonat 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, 19. kvetna 2010
53
Rez, negace
Seznamy
Reprezentace seznamu
-i* Seznam: [a, b, c], prázdný seznam []
JS* 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, 19. kvetna 2010
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 ] ]
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2G1G
SS
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, 19. kvetna 2010
55
Seznamy
Repřezentace seznamu
& Seznam: [a, b, c], prázdný seznam []
& Hlava (libovolný objekt), telo (seznam): .(Hlava, Telo)
a všechny strůktůrované objekty stromy - i seznamy ± fůnktordva argůmenty
.(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]
-i* pred "|"je libovolný pocet prvků seznamů , 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á střuktuřa: [a,b,c|T]
a Seznam = [a,b,c|T], T = [d,e|S], Seznam = [a,b,c,d,e|S]
Hana Růdová, Logické programování I, 19. kvetna 2010 5 5 Seznamy
Prvek seznamu
-í* 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, 19. kvetna 2010
56
Seznamy
Prvek seznamu
member(1,[2,1,3,1,4])
-í* membeř( X, S )
C platí: membeř( b,  [a,b,c] ).
& neplatí: membeř( b,  [[a,b]|[c]] ).
JS> X je prvek seznamu S, když
& X je hlava seznamu S nebo
membeř( X,  [ X | _ ] ).
a X je prvek tela seznamu S
member( X,  [ _ | Telo ] ) :-
membeř( X, Telo ). %(2)
Hana Rudová, Logičké programování I, 19. kvetna 2010
56
Seznamy
Prvek seznamu
member(1,[2,1,3,1,4])
-í* 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, 19. kvetna 2010
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, 19. kvetna 2010
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, 19. kvetna 2010
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, 19. kvetna 2010
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,[ j)
Hana Rudová, Logické programování I, 19. kvetna 2G1G
S6
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, 19. kvetna 2010
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)
Další p ríklady použití:
Jt member(X,[1,2,3]). J* member(1,[2,1,3,1]).
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, 19. kvetna 2010
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, 19. kvetna 2010
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á, Logičké programování I, 19. kvetna 2010
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- pokůd je 1. argůment prázdný seznam, pak 2. a 3. argůment jsoů stejné seznamy: append( [], S, S ).
& pokůd je 1. argůment neprázdný seznam, pak má 3. argůment stejnoů hlavů jako 1.: append( [X|S1], S2,  [X|S3] )  :- append( S1, S2, S3).
X
S1
S2
S3
Hana Růdová, Logické programování I, 19. kvetna 2010
57
Seznamy
P r íklady použití append
append( [], S, S ).
append( [X|S1], S2,  [X|S3] ) :- append( S1, S2, S3).
Spojení seznamů: append( [a,b,c],  [1,2,3], S ). S = [a,b,c,1,2,3]
append( [a,  [b,c], d],  [a,  [], b], S ). S = [a,  [b,c], d, a,  [], b] ]
Hana Rudová, Logické programování I, 19. kvetna 2010
58
Seznamy
P r íklady použití append
append( [], S, S ).
append( [X|S1], S2,  [X|S3] ) :- append( S1, S2, S3).
-i* Spojení seznamů: append( [a,b,c],  [1,2,3], S ). S = [a,b,c,1,2,3]
append( [a,  [b,c], d],  [a,  [], b], S ). S = [a,  [b,c], d, a,  [], b] ]
-í* Dekompozice seznamu na dva seznamy: append( S1, S2,  [a, b ]).
S1 = [], S2 = [a,b] ; S1 = [a], S2 = [b] ? ; S1 = [a,b], S2 = []
Hana Rudová, Logické programování I, 19. kvetna 2010
58
Seznamy
P r íklady použití append
append( [], S, S ).
append( [X|S1], S2,  [X|S3] ) :- append( S1, S2, S3).
& Spojení seznamů: append( [a,b,c],  [1,2,3], S ). S = [a,b,c,1,2,3]
append( [a,  [b,c], d],  [a,  [], b], S ). S = [a,  [b,c], d, a,  [], b] ]
& Dekompozice seznamu na dva seznamy: append( S1, S2,  [a, b ]).
S1 = [], S2 = [a,b] ; S1 = [a], S2 = [b] ? ; S1 = [a,b], S2 = []
& Vyhledávání v seznamu: append( Pred,  [c | Za ],  [a,b,c,d,e] ). Pred = [a,b], Za = [d,e]
Hana Rudová, Logické programování I, 19. kvetna 2010
58
Seznamy
Příklady použití append
append( [], S, S ).
append( [X|S1], S2,  [X|S3] ) :- append( S1, S2, S3).
& Spojení seznamů: append( [a,b,c],  [1,2,3], S ). S = [a,b,c,1,2,3]
append( [a,  [b,c], d],  [a,  [], b], S ). S = [a,  [b,c], d, a,  [], b] ]
& Dekompozice seznamu na dva seznamy: append( S1, S2,  [a, b ]).
S1 = [], S2 = [a,b] ; S1 = [a], S2 = [b] ? ; S1 = [a,b], S2 = []
& Vyhledávání v seznamu: append( Pred,  [c | Za ],  [a,b,c,d,e] ). Pred = [a,b], Za = [d,e]
-i* Předchůdce a následník: append( _,  [Pred,c,Za|_],  [a,b,c,d,e] ). Pred = b, Za = d
Hana Rudová, Logické programování I, 19. kvetna 2010 58 Seznamy
Smazání přvku seznamu de1ete( X, S, S1 )
& Seznam S1 odpovídá seznamů S, ve kterém je smazán prvek X
a jestliže X je hlava seznamů S, pak výsledkem je telo S de1ete( X,  [X|Te1o], Telo).
& jestliže X je v tele seznamů, pak X je smazán až v tele
de1ete( X,  [Y|Te1o],  [Y|Te1o1] ) :- de1ete( X, Telo, Te1o1 ).
Hana Růdová, Logické programování I, 19. kvetna 2010
59
Seznamy
Smazání prvku seznamu de1ete( X, S, S1 )
& Seznam S1 odpovídá seznamu S, ve kterém je smazán prvek X
a jestliže X je hlava seznamu S, pak výsledkem je telo S de1ete( X,  [X|Te1o], Telo).
& jestliže X je v tele seznamu, pak X je smazán až v tele
de1ete( X,  [Y|Te1o],  [Y|Te1o1] ) :- de1ete( X, Telo, Te1o1 ).
& delete smaže libovolný výskyt prvku pomocí backtrackingu ?- de1ete(a,  [a,b,a,a], S). S = [b,a,a]; S = [a,b,a]; S = [a,b,a]
Hana Rudová, Logické programování I, 19. kvetna 2010
59
Seznamy
Smazání prvku seznamu delete( X, S, S1 )
& Seznam S1 odpovídá seznamu S, ve kterém je smazán prvek X
a jestliže X je hlava seznamu S, pak výsledkem je telo S delete( X,  [X|Telo], Telo).
& jestliže X je v tele seznamu, pak X je smazán až v tele
delete( X,  [Y|Telo],  [Y|Telo1] ) :- delete( X, Telo, Telo1 ).
& delete smaže libovolný výskyt prvku pomocí backtrackingu ?- delete(a,  [a,b,a,a], S). S = [b,a,a]; S = [a,b,a]; S = [a,b,a]
delete, který smaže pouze první výskyt prvku X
^   delete( X,  [X|Telo], Telo) :- I.
delete( X,  [Y|Telo],  [Y|Telo1] ) :- delete( X, Telo, Telo1).
Hana Rudová, Logické programování I, 19. kvetna 2010 59 Seznamy
Optimalizace posledního volání
Last Call Optimization (LCO)
Implementacní technika snižující nároky na pamet'
Mnoho vno r ených rekurzivních volání je nárocné na pamet'
Použití LCO umožnuje vno r enou rekurzi s konstantními palmetovými nároky Typický p r í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 p r edchá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(...) :- !, p( ... ). % rez zajišťuje determinismus
& Tento typ rekurze lze prevést na iteraci
Hana Rudová, Logické programování I, 19. kvetna 2010 60 Seznamy
LCO a akumulátor
JS* 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, 19. kvetna 2010 61 Seznamy
LCO a akumulátor
-í* Reformulace rekurzivní procedury, aby umožnila LCO & Výpočet 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 prvku v Seznam''
Hana Rudová, Logické programování I, 19. kvetna 2010
61
Seznamy
LCO a akumulátor
JS* Reformulace rekurzivní procedury, aby umožnila LCO & Výpocet délky seznamu 1ength( Seznam, Delka )
1ength( [], O ).
1ength( [ H j T ], Delka ) i- 1ength( T, DelkaO ), Delka is 1 + DelkaO.
& Upravená procedura, tak aby umožnila LCO:
% 1ength( Seznam, ZapocitanaDelka, CelkovaDelka )i
% CelkovaDelka = ZapocitanaDelka + ,,pocet prvků v Seznam''
1ength( Seznam, Delka ) i- 1ength( Seznam, O, Delka ). % pomocný predikát
1ength( [], Delka, Delka ). % celková délka = zapocítaná délka
1ength( [ H j T], A, Delka ) i- AO is A + 1, 1ength( T, AO, Delka ).
JS* Prídavný argument se nazývá akumulátor
Hana Rudová, Logické programování I, 19. kvetna 2G1G
61
Seznamy
max_list s akumulátorem
Výpočet nejvetšího prvku v seznamu max_list(Seznam, Max)
max_list([X], X).
max_list([X|T], Max) :-max_list(T,MaxT), ( MaxT >= X,  !, Max = MaxT
Max = X ).
Hana Rudová, Logické programování I, 19. kvetna 2010
62
Seznamy
max_1ist s akumulátorem
Výpočet 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, 19. kvetna 2010 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 ) :-
Hana Rudová, Logické programování I, 19. kvetna 2010
63
Seznamy
Akumulátoř jako seznam
Nalezení seznamů, ve kterém jsoů prvky v opacném poradí reverse( Seznam, OpacnySeznam )
-i- reverse( [], [] ).
reverse( [ H | T ], Opacny ) :-reverse( T, OpacnyT ), append( OpacnyT,  [ H ], Opacny ).
& naivní reverse s kvadratickoů složitosti
Hana Růdová, Logické programování I, 19. kvetna 2010
63
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, 19. kvetna 2010
63
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 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
Hana Rudová, Logické programování I, 19. kvetna 2010
63
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, 19. kvetna 2010 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, 19. kvetna 2010
64
Seznamy
Neefektivita p r 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 ).
Hana Rudová, Logické programování I, 19. kvetna 2010
64
Seznamy
Neefektivita pn 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, 19. kvetna 2010
64
Seznamy
při spojování seznamů
C Sjednocení dvoů seznamů
& append( [], S, S ).
append( [X|S1], S2,  [X|S3] ) :- append( S1, S2, S3 ).
& ?- append( [2,3],  [1], S ). postůpné volání cílů:
append( [2,3], [1], S ) - append( [3], [1], S') - append( [], [1], S'' )
C Vždy je nůtné projít celý první seznam
Hana Růdová, Logické programování I, 19. kvetna 2010
64
Seznamy
Rozdílové seznamy
Zapamatování konče a p r ipojení na koneč: rozdílové seznamy
Hana Rudová, Logické programování I, 19. kvetna 2010
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
Hana Rudová, Logické programování I, 19. kvetna 2010
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
L1
1 \	1
L2	\
append( A1-Z1, Z1-Z2, A1-Z2 ). L1        L2 L3
L3
Hana Rudová, Logické programování I, 19. kvetna 2010
65
Seznamy
Rozdílové seznamy
Zapamatování konče a p r ipojení na koneč: rozdílové seznamy [a,b] = L1-L2 = [a,b|T]-T = [a,b,c|S]-[c|S] = [a,b,c]-[c] Reprezentače prázdného seznamu: L-L
A1
Z1 A2
Z2
L1
1 \	1
L2	\
append( A1-Z1, Z1-Z2, A1-Z2 ). L1        L2 L3 [2,3]       [1] [2,3,1] [2,3|Z1]-Z1 [1|Z2]-Z2
L3
Hana Rudová, Logické programování I, 19. kvetna 2010
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
L1
1 \	1
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|Z1]-Z2
Hana Rudová, Logické programování I, 19. kvetna 2010
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
L1
1 \	1
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|Z1]-Z2 [2,3,1|Z2]-Z2
Hana Rudová, Logické programování I, 19. kvetna 2010
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
L1
1 \	1
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|Z1]-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, 19. kvetna 2010 65
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í)
Hana Rudová, Logické programování I, 19. kvetna 2010
66
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 | A ], Opacny ). akumulátor (lineární)
reverse( Seznam, Opacny ) :- reverse0( Seznam, Opacny-[]). reverse0( [], S-S ).
reverse0( [ H | T ], Opacny-OpacnyKonec   ) :- rozdílové seznamy
reverse0( T, Opacny-[ H | OpacnyKonec] ). (lineární)
Hana Rudová, Logické programování I, 19. kvetna 2G1G
66
Seznamy
Akumulátoř vs. řozdí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 | A ], Opacny ). akumulátor (lineární)
reverse( Seznam, Opacny ) :- reverse0( Seznam, Opacny-[]). reverse0( [], S-S ).
reverse0( [ H | T ], Opacny-OpacnyKonec   ) :- rozdílové seznamy
reverse0( T, Opacny-[ H | OpacnyKonec] ). (lineární)
Príklad: operace pro manipůlaci s frontoů
iS* test na prázdnost, pridání na konec, odebrání ze zacátků
Hana Růdová, Logické programování I, 19. kvetna 2010
66
Seznamy
Vestavené predikáty
Vestavené predikáty
-í* Predikáty pro rízení behu programu a fail, true, ...
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, 19. kvetna 2010 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 )      přidá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, 19. kvetna 2010
69
Vestavené predikáty
P ríklad: databázové operace
-í* Caching: odpovedi na dotazy jsou p r idány do programové databáze
Hana Rudová, Logické programování I, 19. kvetna 2010
70
Vestavené predikáty
P ř íklad: databázové operace
Caching: odpovědi na dotazy jsou p r idány do programové databáze
& ?- so1ve( problem, Solution),
asserta( so1ve( problem, Solution) ).
J* :- dynamic solve/2. % nezbytné pri použití v SICStus Prologu
Hana Rudová, Logické programování I, 19. května 2010
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, 19. května 2010
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, 19. května 2010
70
Vestavěné predikáty
Vstup a výstup
program muže ccí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 proudů
datový výstup na terminál
chápán jako jeden z výstupních proudů
soubor 1 soubor 2
user
vstupni proudy
soubor 3 soubor 4
vystupni proudy
Hana Růdová, Logické programování I, 19. května 2010
71
Vestavěné predikáty
Vstupní a výstupní proudy: vestavené prediká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, 19. kvetna 2010
72
Vestavené predikáty
Vstupní a výstupní proudy: vestavené predikáty
zmena (otevrení) aktivního vstupního/výstupního proudu: see(S)/te11(S)
cteni( Soubor ) :- see( Soubor ),
cteni_ze_souboru( Informace ), see( user ).
JS> uzavrení 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, 19. kvetna 2010
72
Vestavené predikáty
Sekvenční prístup k textovým souborům
čtení dalšího termu: read(Term)
J* pri ctení jsou termy oddeleny teckou
| ?- read(A), read( ahoj(B) ), read( [C,D] ).
Hana Rudová, Logické programování I, 19. kvetna 2010
73
Vestavené predikáty
SekvenCní p r ístup k textovým souborům
Ctení dalšího termu: read(Term)
& p r i čtení jsou termy oddeleny tečkou
| ?- 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, 19. kvetna 2010
73
Vestavené predikáty
Sekvenční prístup k textovým souborům
čtení dalšího termu: read(Term)
J* 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 = ahojC'Petre!'), D = jdeme
a po dosažení konce souboru je 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)
Hana Rudová, Logické programování I, 19. kvetna 2010
73
Vestavené predikáty
Sekvenční p ř ístup k textovým souborům
čtení dalšího termu: read(Term)
& p r i ctení jsou termy odděleny tečkou
| ?- 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_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, 19. kvetna 2010 73 Vestavené predikáty
P ř íklad čtení 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, 19. kvetna 2010
74
Vestavené predikáty
Ctení programu ze souboru
JS> Interpretování kódu programu
a ?- consult(program).
a ?- consult('program.pl').
a ?- consult( [program1,  'program2.pl'] ).
-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, 19. kvetna 2010
75
Vestavené predikáty
Všechna rešení
Backtracking vrací pouze jedno rešení po druhém
Všechna r 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, 19. kvetna 2010
76
Vestavené predikáty
Všechna řešení
Backtracking vrací pouze jedno rešení po druhém
Všechna reš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, 19. kvetna 2010
76
Vestavené predikáty
Všechna rešení
Backtracking vrací pouze jedno rešení po druhém
Všechna r 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, 19. kvetna 2010
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šeobecne kvantifikovány
?- bagof( Dite, vek( Dite, Vek ), Seznam ). Vek = 7, Seznam = [ petr ]; Vek = 5, Seznam = [ anna, tomas ]
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2010
77
Vestavené predikáty
vr       vr 'II
reseni II.
C Pokud neexistuje řešení bagof(X,P,S) neuspěje
-í* bagof: pokud nejaké ř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í
?- bagof( Dite-Vek, vek( Dite, Vek ), Seznam ). Seznam = [petr-7,anna-5,tomas-5]
Hana Rudová, Logické programování I, 19. kvetna 2010 77 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 ).
Hana Rudová, Logické programování I, 19. kvetna 2010
78
Vestavené predikáty
ExistenCní kvantifikátor „" "
Pr idání existenCního kvantifikátoru „Ä " ^ hodnota promenné nemá význam
?- bagof( Dite, Vek~vek( Dite, Vek ), Seznam ). Seznam = [petr,anna,tomas]
Hana Rudová, Logické programování I, 19. kvetna 2010
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]
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2010
78
Vestavené predikáty
reš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, 19. kvetna 2010
79
Vestavené predikáty
řešení III.
setof( X, P, S ): rozdíly od bagof
J* S je uspo rádaný podle @<
p r í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 ).
Hana Rudová, Logické programování I, 19. května 2010
79
Vestavěné predikáty
ř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
Mš 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
Hana Rudová, Logické programování I, 19. kvetna 2010
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 může být prázdný      == pokud neexistuje rešení, uspeje a vrátí S = []
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2010
79
Vestavené predikáty
reš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í
== findall uspeje p r esnejednou
-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, 19. kvetna 2010 79 Vestavené predikáty
Testování typu termu
var(X) X je volná proměnná
nonvar(X) X  není proměnná
Hana Rudová, Logické programování I, 19. května 2010
80
Vestavěné predikáty
Testování typu termu
var(X) nonvar(X)
X je volná promenná X  není promenná
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 císlo
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2010
80
Vestavené predikáty
UrCení poCtu výskytů prvku v seznamu
count( X, S, N )
Hana Rudová, Logické programování I, 19. kvetna 2010
81
Vestavené predikáty
Urcení poctu výskytů prvku v seznamu
count( X, S, N )  :- count( X, S, 0, N ).
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2010 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,  [XjS], N0, N) :- I, N1 is N0 + 1, count( X, S, N1, N).
Hana Rudová, Logické programování I, 19. kvetna 2010
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, [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, 19. kvetna 2010
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, [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, 19. května 2010
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], 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
Hana Rudová, Logické programování I, 19. kvetna 2010
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, [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, 19. kvetna 2010
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 N=3
count( _,  [], N, N ).
count( X,  [Y|S], NO, N )  :- nonvar(Y), X = Y, !,
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, 19. kvetna 2010
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, 19. kvetna 2010
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ů: +, <->, ===>
-fc 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, 19. kvetna 2010
82
Vestavené predikáty
Konstrukce a dekompozice atomu
JS> 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
* Konstrukce 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, 19. kvetna 2010 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, 19. května 2010
83
Vestavěné predikáty
Konstrukče a dekompoziče termu
-í* Konstrukce a dekompozice termu
Term =..  [ Funktor | SeznamArgumentu ]
a(9,e) =.. [a,9,e]
Cil =..  [ Funktor | SeznamArgumentu ], ca11( Cil )
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2010
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, 19. května 2010
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 ) 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, 19. kvetna 2010
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, 19. kvetna 2010
83
Vestavené predikáty
Konstrukce a dekompozice termu
-í* Konstrukce a dekompozice těrmu
Term =..  [ Funktor | SeznamArgumentu ]
a(9,e) =.. [a,9,e]
Cil =..  [ Funktor | SeznamArgumentu ], call( Cil ) atom =.. X => X = [atom]
& Pokud chci znát pouzě funktor něbo některé argumenty, pak jě efektivnější: 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, 19. května 2010
83
Věstavěné prědikáty
Rekurzivní rozklad termu
Term je promenná (var/1), atom nebo císlo (atomic/1) => konec rozkladu
Hana Rudová, Logické programování I, 19. kvetna 2010
84
Vestavené predikáty
Rekurzivní rozklad termu
Term je promenná (var/1), atom nebo cí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, 19. kvetna 2010
84
Vestavené predikáty
Rekurzivní rozklad termu
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, 19. kvetna 2010
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, 19. kvetna 2010
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), !.
Hana Rudová, Logické programování I, 19. kvetna 2010
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), I. ground(Term) :- var(Term),  I, fail.
Hana Rudová, Logické programování I, 19. kvetna 2010
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 uspeje, pokud v termu nejsou promenné; jinak neuspeje
ground(Term) :- atomic(Term), I. ground(Term) :- var(Term),  I, fail. ground([HjT]) :- I, ground(H), ground(T).
Hana Rudová, Logické programování I, 19. kvetna 2010
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. ground([H|T]) :- !, ground(H), ground(T). ground(Term) :- Term =..  [ _Funktor | Argumenty ],
ground( Argumenty ).
Hana Rudová, Logické programování I, 19. kvetna 2010
84
Vestavené predikáty
Rekurzivní rozklad teřmu
& 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
& 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, 19. kvetna 2010
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, 19. kvetna 2010
85
Vestavené predikáty
P r íklad: dekompoziče 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
Hana Rudová, Logické programování I, 19. kvetna 2010
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 Jt count_term( X, T, N ) :- count_term( X, T, 0, N).
Hana Rudová, Logické programování I, 19. května 2010
85
Věstavěné prědikáty
Prí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,  I, N is N0 + 1.
Hana Rudová, Logické programování I, 19. kvetna 2010
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.
Hana Rudová, Logické programování I, 19. kvetna 2010
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).
count_term( X, T, N0, N ) :- integerCT), 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, 19. kvetna 2010
85
Vestavené predikáty
Př íklad: dekompozice termu I.
M count_term( Integer, Term, N ) urcí počet 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, 1,	N is N0 + 1.
count_term( _,	T,	N, N ) :- atomic(T), 1.	
count_term( _,	T,	N, N ) :- var(T), 1.	
count_term( X,	T,	N0, N ) :- T =..  [ _ | Argumenty	L
Hana Rudová, Logické programování I, 19. kvetna 2010
85
Vestavené predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) urc pocět výskytu cělého císla v těrmu
?- 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, 19. května 2010
85
Vestavěné prědikáty
P ríklad: dekompozke 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,  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 ).
Hana Rudová, Logické programování I, 19. kvetna 2010
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,  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),
Hana Rudová, Logické programování I, 19. kvetna 2010
85
Vestavené 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,  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,
Hana Rudová, Logické programování I, 19. kvetna 2010
85
Vestavené predikáty
P r íklad: dekompoziče 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, 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, 19. kvetna 2010
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,  !, 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 ).
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2010 85 Vestavené predikáty
Cvičení: dekompozice termu
Napište predikát substitute( Podterm, Term, Podterm1, Term1), který nahradí všechny výskyty Podterm v Term termem Podterm1 a výsledek vrátí v Term1
& Pr edpokládejte, že Term a Podterm jsou termy bez promenných
& ?- substitute( sin(x), 2*sin(x)*f(sin(x)), t, F ). F=2*t*f(t)
Hana Rudová, Logické programování I, 19. kvetna 2010
86
Vestavené predikáty
Technika a styl programování v Prologu
Technika a styl programování v Prologu
Styl programování v Prologu
s nekterá pravidla správného stylu & správný vs. špatný styl a komentáre
-í* Ladení
-í* Efektivita
Hana Rudová, Logické programování I, 19. kvetna 2010
88
Technika a styl programování v Prologu
Styl programování v Prologu I.
ií> Cílěm stylistických konvěncí jě
± rědukcě něbězpěcí programovacích chyb
a psaní citělných a srozumitělných programů, ktěré sě dobrě ladí a modifikují
Hana Rudová, Logické programování I, 19. května 2010
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, 19. kvetna 2010
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 dobre 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) prípady psát pred rekurzivními klauzulemi vhodná jmena procedur a promenných
nepoužívat seznamy ([...]) nebo závorky ({...}, (...)) pro termy pevné arity a vstupní argumenty psát pred výstupními
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2010 89 Technika a styl programování v Prologu
Správný styl programování
JS* konstrukce setříděného seznamu Seznam3 ze setříděných seznamů Seznaml, Seznam2: merge( Seznami, Seznam2, Seznam3 )
M merge( [2,4,7],  [1,3,4,8],  [1,2,3,4,4,7,8] )
Hana Rudová, Logické programování I, 19. května 2010
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ů 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, 19. května 2010
90
Technika a styl programování vPrologu
Správný styl programování
-í* konstrukce setříděného seznamu Seznam3 ze setříděných seznamů Seznámí, Seznam2: meřge( Seznaml, Seznam2, Seznam3 )
M meřge( [2,4,7],  [1,3,4,8],  [1,2,3,4,4,7,8] )
JS> meřge( [], Seznam, Seznam ) :-
I. % prevence redundantních ř ešení
Hana Rudová, Logické programování I, 19. kvetna 2010
90
Technika a styl programování vPrologu
Správný styl programování
-í* konstrukce setřídeného seznamu Seznam3 ze setřídených seznamů Seznaml, Seznam2: meřge( Seznaml, Seznam2, Seznam3 )
M meřge( [2,4,7],  [1,3,4,8],  [1,2,3,4,4,7,8] )
JS> meřge( [], Seznam, Seznam ) :-
I. % prevence redundantních ř ešení
meřge( Seznam,  [], Seznam ).
Hana Rudová, Logické programování I, 19. kvetna 2010
90
Technika a styl programování vPrologu
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 ) :-
!. % prevence redundantních ř ešení
merge( Seznam,  [], Seznam ).
merge( [X|Te1o1],  [Y|Te1o2],  [X|Te1o3] ) :-
Hana Rudová, Logické programování I, 19. kvetna 2010
90
Technika a styl programování v Prologu
Správný styl programování
-í* konstrukce setrídeného seznamu Seznam3 ze setrídený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 ).
merge( [X|Te1o1],  [Y|Te1o2],  [X|Te1o3] ) :-X < Y, 1,
Hana Rudová, Logické programování I, 19. kvetna 2010
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 ).
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. května 2010
90
Technika a styl programování vPrologu
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( Teloí,  [Y|Te1o2], Te1o3 ).
merge( Seznamí,  [Y|Te1o2],  [Y|Te1o3] ) :-merge( Seznamí, Te1o2, Te1o3 ).
Hana Rudová, Logické programování I, 19. kvetna 2010
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, 19. kvetna 2010
91
Technika a styl programování vPrologu
Styl programování v Prologu II.
& Středník „;" může způsobit nesrozumitelnost klauzule
a nedávat st r edník na konec rádku, používat závorky
J* v nekterých p r ípadech: rozdeiení klauzle se st r edníkem do více klauzulí
Hana Rudová, Logické programování I, 19. kvetna 2010
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,  I, fail; true \+ P
alternativy: Podminka,  I, Cil1 ; Cil2 Podminka ->   Cil1 ; Cil2
Hana Rudová, Logické programování I, 19. kvetna 2010
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,  I, fail; true \+ P
alternativy: Podminka,  I, Cil1 ; Cil2 Podminka ->   Cil1 ; Cil2
& Opatrné používání negace „\+"
a negace jako neúspech: negace není ekvivalentní negaci v matematické logice
Hana Rudová, Logické programování I, 19. kvetna 2010
92
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
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
& Opatrné používání negace „\+"
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, 19. kvetna 2010
92
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í
Hana Rudová, Logické programování I, 19. kvetna 2010
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)
Hana Rudová, Logické programování I, 19. kvetna 2010
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
Hana Rudová, Logické programování I, 19. kvetna 2010
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 očekávané výsledky), p ríklad použití
-í* které predikáty jsou hlavní (top-level)
& jak jsou hlavní koncepty (objekty) reprezentovány
& doba výpočtu a pamet'ové nároky
Hana Rudová, Logické programování I, 19. kvetna 2010
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), prí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
Hana Rudová, Logické programování I, 19. kvetna 2010
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
& doba výpoctu a pameťové nároky
JS> jaké jsou limitace programu
zda jsou použity nejaké speciální rysy závislé na systému
Hana Rudová, Logické programování I, 19. kvetna 2010
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
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 )
JmenoPredikatu/Arita merge/3
Hana Rudová, Logické programování I, 19. kvetna 2010
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 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 )
JmenoPredikatu/Arita merge/3
algoritmické a implementacní podrobnosti
Hana Rudová, Logické programování I, 19. kvetna 2010 93 Technika a styl programování v Prologu
Ladení
Pr epínace na trasování: trace/O, notrace/O & Trasování specifického predikátu: spy/1, nospy/1
-i- spy( merge/3 )
JS> debug/O, nodebug/O: pro trasování pouze predikátu zadaných spy/1
Hana Rudová, Logické programování I, 19. kvetna 2010
94
Technika a styl programování v Prologu
M Prepí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
.0 vstupní informace: jméno predikátu, hodnoty argumentu pri volání výstupní informace
pri úspechu hodnoty argumentů splnující cíl pri neuspechu indikace chyby
-i- nové vyvolání pres     stejný cíl je volán pri backtrackingu
Hana Rudová, Logické programování I, 19. kvetna 2010 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 predchozímu rešení
__________________________________________
Call j
-----------------> +   predekC X, Z ) i- rodicC X, Z ).
j
j    predekC X, Z ) i- rodicC X, Y ),
j
Exit
<----------------- +
Fail j
predekC Y, Z ).
+ --------- >
j j
+ <---------
j Redo
__________________________________________
Hana Rudová, Logické programování I, 19. kvetna 2010
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(1). d(2).
__________________/\
Ca11    j j Exit
------> + a(X) i- nonvar(X).| ------>
| a(X) i- c(X). | <------+ a(X) i- d(X).        + <------
Fai1  j j Redo
___________________/\
Hana Rudová, Logické programování I, 19. kvetna 2G1G
96
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).
j ľ-
a(X).
X 2 2
X Calli a(_463) ľ
2 Calli nonvar(_463) ľ
2 Faili nonvar(_463) ľ
__________________/\
Call    j j Exit
------> + a(X) i- nonvar(X).j ------>
j a(X) i- c(X). j <------+ a(X) i- d(X).        + <------
Fail   j j Redo
___________________/\
Hana Rudová, Logické programování I, 19. kvetna 2010
96
Technika a styl programování vPrologu
Príklad: trasování
a(X)	i-	nonvar(X).	| ľ- 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) ľ	
Ca11    | | Exit
------> + a(X) i- nonvar(X).| ------>
| a(X) i- c(X). | <------+ a(X) i- d(X).        + <------
Fai1  | | Redo
___________________/\
X = 1 ľ
Hana Rudová, Logické programování I, l9. kvetna 2GlG
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).		l	l	Calli	a(_463) ľ	
a(X) i-	d(X).		2	2	Calli	nonvar(_463)	ľ
c(l).			2	2	Faili	nonvar(_463)	ľ
d(2).			3	2	Calli	c(_463) ľ	
			3	2	Exiti	c(l) ľ	
		ľ	l	l	Exiti	a(l) ľ	
Call	I                                 I Exit	X=l	ľ; >				
------ >	+ a(X) i- nonvar(X).I ------>		l	l	Redoi	a(l) ľ	
	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, 19. kvetna 2G1G
96
Technika a styl programování v Prologu
Pr íklad: trasování
a(X) i-	nonvar(X).		j ľ-	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	jj	Exit	X=1	ľ; >				
------ >	+ a(X) i- nonvar(X).j	------>		1	1	Redoi	a(1) ľ	
	j a(X) i- c(X). j			4	2	Calli	d(_463) ľ	
<------	+ a(X) i- d(X). +	<------		4	2	Exiti	d(2) ľ	
Fail	jj	Redo		1	1	Exiti	a(2) ľ	
			X=2	ľ; >				
no
% trace
j ľ-
Hana Rudová, Logické programování I, 19. kvetna 2010
96
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
Hana Rudová, Logické programování I, 19. kvetna 2010
97
Technika a styl programování vPrologu
Efektivita
-í* Cas výpoctu, pameť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 pri 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, 19. kvetna 2010
97
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ů
Cačhing: uložení vypocítaných výsledků do programové databáze
Hana Rudová, Logické programování I, 19. kvetna 2010
98
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 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( Prijmeni, KrestniJmeno, Odděleni, ...)
Hana Rudová, Logické programování I, 19. kvetna 2010
98
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 pri spojování seznamů
Caching: uložení vypocítaných výsledků do programové databáze Indexace podle prvního argumentu a napr. v SICStus Prologu
J> pri volání predikátu s prvním nainstaniovaným argumentem se používá hašovací tabulka zprístupnující pouze odpovídající klauzule
zamestnanec( Prijmem', KrestniJmeno, Odděleni, ...) Determinismus:
J* rozhodnout, které klauzule mají uspet vícekrát, overit požadovaný determinismus
Hana Rudová, Logické programování I, 19. kvetna 2010
98
Technika a styl programování v Prologu
Predikátová logika l.řádu
Teorie logického programování
-í* PROLOG: PROgramming in LOGic, cást predikátové logiky 1. rádu
a fakta: rodic(petr,petrik), VXa(X)
klauzule: VXVY rodic(X,Y) => predek(X,Y)
Hana Rudová, Logické programování I, 19. kvetna 2010
100
Teorie logického programování
Teorie logického programování
-í* PROLOG: PROgramming in LOGic, cást predikátové logiky 1. rádu
a fakta: rodic(petr,petrik), VXa(X)
klauzule: VXVY rodic(X,Y) => predek(X,Y)
& Predikátová logika I. r ádu(PLl)
soubory objektu: lidé, císla, body prostoru, ... -i* syntaxe PL1, sémantika PL1, pravdivost a dokazatelnost
Hana Rudová, Logické programování I, 19. kvetna 2010
100
Teorie logického programování
Teorie logického programování
-í* PROLOG: PROgramming in LOGic, cást predikátové logiky 1. rádu
a fakta: rodic(petr,petrik), VXa(X)
klauzule: VXVY rodic(X,Y) => predek(X,Y)
& Predikátová logika I. rádu (PL1)
soubory objektu: lidé, císla, body prostoru, ... -i* syntaxe PL1, sémantika PL1, pravdivost a dokazatelnost
-í* Rezoluce ve výrokové logice, v PL1 dokazovací metoda
C Rezoluce v logickém programování -í* Backtracking, r ez, negace vs. rezoluce
Hana Rudová, Logické programování I, 19. kvetna 2010
100
Teorie logického programování
Predikátová logika I. rádu (PL1)
Abeceda A jazyka L PLI se skládá ze symbolu:
JS> promenné X, Y, ... oznacují libovolný objekt z daného oboru
Hana Rudová, Logické programování I, 19. kvetna 2010
101
Predikátová logika
Predikátová logika I. rádu (PL1)
Abeceda A jazyka L PL1 se skládá ze symbolu:
JS> promenné X, Y, ... oznacují libovolný objekt z daného oboru & funkcní symboly f, g, ... oznacují operace (p ríklad: +, x ) -i- arita = pocet argumentů, n-ární symbol, znaame f/n
A nulární funkcní symboly - konstanty: oznacují význacné objekty (p r íklad: 0, 1, ...)
Hana Rudová, Logické programování I, 19. kvetna 2010
101
Predikátová logika
Predikátová logika I. rádu (PL1)
Abeceda A jazyka L PL1 se skládá ze symbolu:
JS> promenné X, Y, ... oznacují libovolný objekt z daného oboru
& funkční symboly f, g, ... oznacují operace (p ríklad: +, x )
-i- arita = pocet argumentu, n-ární symbol, znacíme f/n
nulární funkcní symboly - konstanty: oznacují význacné objekty (p r íklad: 0, 1, ...)
& predikátové symboly p,q, ... pro vyjád r ení vlastností a vztahů mezi objekty arita = pocet argumentu, n-ární symbol, znacíme p/n      p r íklad: <, g
Hana Rudová, Logické programování I, 19. kvetna 2010
101
Predikátová logika
Predikátová logika I. rádu (PL1)
Abeceda A jazyka L PL1 se skládá ze symbolu:
JS> promenné X, Y, ... oznacují libovolný objekt z daného oboru
& funkcní symboly f, g, ... oznacují operace (p ríklad: +, x )
-i- arita = pocet argumentů, n-ární symbol, znacíme f/n
nulární funkcní symboly - konstanty: oznacují význacné objekty (p r íklad: 0, 1, ...)
& predikátové symboly p,q, ... pro vyjád r ení vlastností a vztahů mezi objekty arita = pocet argumentu, n-ární symbol, znacíme p/n      p r íklad: <, g
& logické spojky a, v,     =>, =
Hana Rudová, Logické programování I, 19. kvetna 2010
101
Predikátová logika
Predikátová logika I. řádu (PLl)
Abeceda A jazyka L PL1 se skládá ze symbolu:
JS> přomenné X, Y, ... oznacují libovolný objekt z daného oboru
& funkcní symboly f, g, ... oznacují operace (p ríklad: +, x )
-i- ařita = pocet argumentu, n-ářní symbol, znacíme f/n
nulární funkcní symboly - konstanty: oznacují význacné objekty (p r íklad: 0, 1, ...)
& předikátové symboly p,q, ... pro vyjád r ení vlastností a vztahů mezi objekty ařita = pocet argumentu, n-ářní symbol, znacíme p/n      p r íklad: <, g
& logické spojky a, v,     =>, =
JS> kvantifikátořy V, 3
± logika I. rádu používá kvantifikaci pouze přo individua (odlišnost od logik vyššího rádu) v logice 1. rádu nelze: v R : V A c R, Vf : R - R
Hana Rudová, Logické programování I, 19. kvetna 2010
101
Predikátová logika
Predikátová logika I. rádu (PL1)
Abeceda A jazyka L PLI se skládá ze symbolu:
JS> promenné X, Y, ... oznacují libovolný objekt z daného oboru
& funkcní symboly f, g, ... oznacují operace (p ríklad: +, x )
-i- arita = pocet argumentu, n-ární symbol, znacíme f/n
nulární funkcní symboly - konstanty: oznacují význacné objekty (p r íklad: 0, 1, ...)
& predikátové symboly p,q, ... pro vyjád r ení vlastností a vztahů mezi objekty arita = pocet argumentů, n-ární symbol, znacíme p/n      p r íklad: <, g
& logické spojky a, v,     =>, =
JS> kvantifikátory V, 3
± logika I. rádu používá kvantifikaci pouze pro individua (odlišnost od logik vyššího rádu) v logice 1. rádu nelze: v R : V A c R, Vf : R - R
& závorky: ),(
Hana Rudová, Logické programování I, 19. kvetna 2010 101 Predikátová logika
Jazyky PL1
Specifikace jazyka L je definována funkcními a predikátovými symboly symboly tedy urcují oblast, kterou jazyk popisuje
Jazyky s rovností: obsahují predikátový symbol pro rovnost „="
Hana Rudová, Logické programování I, 19. kvetna 2010
102
Predikátová logika
Jazyky PLI
Specifikace jazyka L je definována funkcními a predikátovými symboly symboly tedy urcují oblast, kterou jazyk popisuje
& Jazyky s rovností: obsahují predikátový symbol pro rovnost „=" Pr íklady
C jazyk teorie uspo rádání
& jazyk s =, binární prediátový symbol <
Hana Rudová, Logické programování I, 19. kvetna 2010
102
Predikátová logika
Jazyky PL1
Specifikace jazyka L je definována funkcními a predikátovými symboly symboly tedy urcují oblast, kterou jazyk popisuje
& Jazyky s rovností: obsahují predikátový symbol pro rovnost „=" Príklady
C jazyk teorie uspořádání
J* jazyk s =, binární prediátový symbol <
JS* jazyk teorie množin
-i- jazyk s =, binární predikátový symbol g
Hana Rudová, Logické programování I, 19. kvetna 2010
102
Predikátová logika
Jazyky PL1
Specifikace jazyka L je definována funkcními a predikátovými symboly symboly tedy urcují oblast, kterou jazyk popisuje
& Jazyky s rovností: obsahují predikátový symbol pro rovnost „=" Príklady
C jazyk teorie uspo rádání
J* jazyk s =, binární prediátový symbol <
JS* jazyk teorie množin
-i- jazyk s =, binární predikátový symbol g
& jazyk elementární aritmetiky
jazyk s =, nulární funkcní symbol 0 pro nulu, unární funkcní symbol s pro operaci následníka, binární funkcní symboly pro scítání + a násobení x
Hana Rudová, Logické programování I, 19. kvetna 2010 102 Predikátová logika
Term, atomická formule, formule
Term nad abecedou A
Jť každá promenná z A je term
je-li f/n z A a t\,...,tn jsou termy, pak f(t\, ...,tn) je také term -i- každý term vznikne konecným poctem užití p r echozích kroku f( X, g(X,0))
Hana Rudová, Logické programování I, 19. kvetna 2010
103
Predikátová logika
Term, atomičká formule, formule
M Term nad abecedou A
Jť každá promenná z A je term
je-li f/n z A a t1,...,tn jsou termy, pak f(t\, ...,tn) je také term -i- každý term vznikne konecným poctem užití p r echozích kroku f( X, g(X,0))
& Atomičká formule (atom) nad abecedou A
-fc je-li p/n z A a t1,...,tn jsou termy, pak p(t1,. ..,tn) je atomická formule     f(X) < g(X,0)
Hana Rudová, Logické programování I, 19. kvetna 2010
103
Predikátová logika
Term, atomická formule, formule
Term nad abecedou A
Jť každá promenná z A je term
je-li f/n z A a t1,...,tn jsou termy, pak f(t\, ...,tn) je také term -i- každý term vznikne konecným poctem užití prechozích kroku f( X, g(X,0))
& Atomická formule (atom) nad abecedou A
-fc je-li p/n z A a t1,...,tn jsou termy, pak p(t1,. ..,tn) je atomická formule     f(X) < g(X,0)
& Formule nad abecedou A
a každá atomická formule je formule
J> jsou-li F a G formule, pak také (-F), (F a G), (F v G), (F == G), (F = G) jsou formule je-li X promenná a F formule, pak také (VX F) a (3X F) jsou formule každá formule vznikne konecným poctem užití prechozích kroku     (3X ((f(X) = 0) a p(0)))
Hana Rudová, Logické programování I, 19. kvetna 2010
103
Predikátová logika
Interpretace
Interpretace I jazyka L nad abecedou A je dána
a neprázdnou množinou D (také znaCíme      nazývá se univerzum) a a zobrazením, které
každé konstante c g A p r i radí nejaký prvek D
každému funkCnímu symbolu f/n g A p r i radí n-ární operaci nad D
každému predikátovému symbolu p/n g A p r i radí n-ární relaci nad D
Hana Rudová, Logické programování I, 19. kvetna 2010
104
Predikátová logika
Interpretace
Interpretace I jazyka L nad abecedou A je dána
a neprázdnou množinou D (také znaCíme      nazývá se univerzum) a a zobrazením, které
každé konstante c g A p r i radí nejaký prvek D
každému funkCnímu symbolu f/n g A p r i radí n-ární operaci nad D
každému predikátovému symbolu p/n g A p r i radí n-ární relaci nad D
Príklad: uspo rádání na R
a jazyk: predikátový symbol mensi/2
& interpretace: univerzum R; zobrazení: mensi(x,y) := x < y
Hana Rudová, Logické programování I, 19. kvetna 2010
104
Predikátová logika
Interpretace
& Interpretace I jazyka L nad abecedou A je dána
a neprázdnou množinou D (také znaCíme      nazývá se univerzum) a a zobrazením, které
každé konstante c g A p r i radí nejaký prvek D
každému funkCnímu symbolu //n g A p r i radí n-ární operaci nad D
každému predikátovému symbolu p/n g A p r i radí n-ární relaci nad D
-í* Príklad: uspo rádání na R
a jazyk: predikátový symbol mensi/2
& interpretace: univerzum R; zobrazení: mensi(x,y) := x < y
Príklad: elementární aritmetika nad množinou N (vCetne 0)
-fc jazyk: konstanta zero, funCní symboly s/1, plus/2 J* interpretace:
univerzum N; zobrazení: zero := 0,   s(x) := 1 + x,   plus(x,y) := x + y
Hana Rudová, Logické programování I, 19. kvetna 2010 104 Predikátová logika
Sémantika formulí
Ohodnocení proměnné qp(X): každé promenné X je p r i razen prvek |1|
Hodnota termu qp(t): každému termu je p r i razen prvek univerza
p r íklad: necht' qp(X) := 0 qp(plus(s(zero),X)) =
Hana Rudová, Logické programování I, 19. kvetna 2010
105
Predikátová logika
Sémantika fořmulí
Ohodnocení přomenné qp(X): každé promenné X je p r i razen prvek |1|
Hodnota teřmu qp(t): každému termu je p r i razen prvek univerza
p r íklad: necht' qp(X) := 0
qp (plus (s (zero), X)) = qp(s(zero)) + qp(X) =
Hana Rudová, Logické programování I, 19. kvetna 2010
105
Predikátová logika
Sémantika formulí
Ohodnocení promenné qp(X): každé promenné X je p r i razen prvek |1| Hodnota termu qp(t): každému termu je p r i razen prvek univerza
p r íklad: necht' qp(X) := 0
qp (plus (s (zero), X)) = qp(s(zero)) + qp(X) = (1 + qp(zero)) + 0 =
Hana Rudová, Logické programování I, 19. kvetna 2010
105
Predikátová logika
Sémantika formulí
Ohodnocení promenné qp(X): každé promenné X je p r i razen prvek |1| Hodnota termu op(t): každému termu je p r i razen prvek univerza
p ríklad: necht' qp(X) := 0
q (plus (s (zero), X)) = qp(s(zero)) + op[X) = (1 + op(zero)) + 0 = (1 + 0) + 0 = 1
Hana Rudová, Logické programování I, 19. kvetna 2010
105
Predikátová logika
Sémantika formulí
Ohodnočení promenné qp(X): každé promenné X je p r i razen prvek |1| Hodnota termu op(t): každému termu je p r i razen prvek univerza
p r íklad: necht' qp(X) := 0
q (plus (s (zero), X)) = qp(s(zero)) + qp(X) = (i + qp(zero)) + 0 = (i + 0) + 0 = i
Každá dob re utvo rená formule oznacuje pravdivostní hodnotu (pravda, nepravda) v závislosti na své struktu r e a interpretaci
Pravdivá formule I Nq q: formule Q oznacena pravda Neravdivá formule I ^ q: formule Q oznacena nepravda
Hana Rudová, Logické programování I, 19. kvetna 2010
105
Predikátová logika
Sémantika formulí
Ohodnocení proměnné qp(X): každé promenné X je p r i razen prvek |1| Hodnota termu op(t): každému termu je p r i razen prvek univerza
p r íklad: necht' qp(X) := 0
q (plus (s (zero), X)) = qp(s(zero)) + qp(X) = (1 + qp(zero)) + 0 = (1 + 0) + 0 = 1
Každá dobre utvorená formule oznacuje pravdivostní hodnotu (pravda, nepravda) v závislosti na své struktu r e a interpretaci
Pravdivá formule I Nq q: formule Q oznacena pravda Neravdivá formule I Nq q: formule Q oznacena nepravda
-fc p r íklad: p/1 predikátový symbol, tj. p ^ |1|      p := {(1), (3), (5),...} I N p (zero) a p (s (zero))
Hana Rudová, Logické programování I, 19. kvetna 2010
105
Predikátová logika
Sémantika fořmulí
Ohodnocení přomenné qp(X): každé promenné X je p r i razen prvek |1| Hodnota teřmu op(t): každému termu je p r i razen prvek univerza
p r íklad: necht' qp(X) := 0
op (plus (s (zero), X)) = op(s(zero)) + qp(X) = (1 + op(zero)) + 0 = (1 + 0) + 0 = 1
Každá dobře utvořená fořmule oznacuje přavdivostní hodnotu (pravda, nepravda) v závislosti na své struktu r e a interpretaci
Přavdivá fořmule I Nq q: formule Q oznacena pravda Neřavdivá fořmule I Nq q: formule Q oznacena nepravda
-fc p r íklad: p/1 predikátový symbol, tj. p c |?|      p := {(1), (3), (5),...} I N p(zero) a p(s(zero)) iff I N p(zero) a I N p(s(zero))
Hana Rudová, Logické programování I, 19. kvetna 2010
105
Predikátová logika
Sémantika formulí
Ohodnocení promenné qp(X): každé promenné X je p r i razen prvek |1| Hodnota termu op(t): každému termu je p r i razen prvek univerza
p ríklad: necht' qp(X) := 0
q (plus (s (zero), X)) = qp(s(zero)) + qp(X) = (1 + qp(zero)) + 0 = (1 + 0) + 0 = 1
Každá dob re utvo rená formule oznacuje pravdivostní hodnotu (pravda, nepravda) v závislosti na své struktu r e a interpretaci
Pravdivá formule I Nq q: formule Q oznacena pravda Neravdivá formule I Nq q: formule Q oznacena nepravda
-fc p r íklad: p/1 predikátový symbol, tj. p ^ |1|      p := {(1), (3), (5),...} I N p(zero) a p(s(zero)) iff I N p(zero) a I N p(s(zero))
iff  (qp(zero)) g p a (qp(s(zero))) g p
Hana Rudová, Logické programování I, 19. kvetna 2010
105
Predikátová logika
Sémantika formulí
Ohodnocení proměnné qp(X): každé proměnné X je p r i razen prvek |1| Hodnota termu op(t): každému termu je p r i razen prvek univerza
p r íklad: necht' qp(X) := 0
q (plus (s (zero), X)) = qp(s(zero)) + qp(X) = (1 + qp(zero)) + 0 = (1 + 0) + 0 = 1
Každá dob re utvo rená formule oznaCuje pravdivostní hodnotu (pravda, nepravda) v závislosti na své struktu r e a interpretaci
Pravdivá formule I Nq q: formule Q oznaCena pravda Neravdivá formule I Nq q: formule Q oznaCena nepravda
& p r íklad: p/1 predikátový symbol, tj. p ^ |1|      p := {(1), (3), (5),...} I N p(zero) a p(s(zero)) iff I N p(zero) a I N p(s(zero))
iff  (qp(zero)) g p a (qp(s(zero))) g p iff  (qp(zero)) g p a ((1 + qp(zero)) g p
Hana Rudová, Logické programování I, 19. kvetna 2010
105
Predikátová logika
Sémantika formulí
Ohodnocení promenné qp(X): každé proměnné X je p r i razen prvek |1| Hodnota termu op(t): každému termu je p r i razen prvek univerza
p r íklad: necht' qp(X) := 0
q (plus (s (zero), X)) = qp(s(zero)) + qp(X) = (1 + qp(zero)) + 0 = (1 + 0) + 0 = 1
Každá dob re utvo rená formule označuje pravdivostní hodnotu (pravda, nepravda) v závislosti na své struktu r e a interpretaci
Pravdivá formule I Nq q: formule Q označena pravda Neravdivá formule I Nq q: formule Q označena nepravda
& p r íklad: p/1 predikátový symbol, tj. p ^ |1|      p := {(1), (3), (5),...} I N p(zero) a p(s(zero)) iff I N p(zero) a I N p(s(zero))
iff  (qp(zero)) g p a (qp(s(zero))) g p iff  (qp(zero)) g p a ((1 + qp(zero)) g p iff  (0) g p a (1) g p (1) g p ale (0) G p, tedy formule je nepravdivá v I
Hana Rudová, Logické programování I, 19. kvetna 2010
105
Predikátová logika
Model
Interpretace se nazývá modelem formule, je-li v ní tato formule pravdivá
interpretace množiny N s obvyklými operacemi je modelem formule ( 1 + s(0) = s(s(0))) interpretace, která se liší p r i razením s/1: s(x):=x není modelem této formule
Hana Rudová, Logické programování I, 19. kvetna 2010
106
Predikátová logika
Model
Interpretace se nazývá modelem formule, je-li v ní tato formule pravdivá
interpretace množiny N s obvyklými operacemi je modelem formule ( 1 + s(0) = s(s(0))) interpretace, která se liší p r i razením s/1: s(x):=x není modelem této formule
Teorie T jazyka L je množina formulí jazyka L, tzv. axiomů
- s(X) = 0 je jeden z axiomu teorie elementární aritmetiky
Hana Rudová, Logické programování I, 19. kvetna 2010
106
Predikátová logika
Model
Interpretace se nazývá modelem formule, je-li v ní tato formule pravdivá
interpretace množiny N s obvyklými operacemi je modelem formule ( 1 + s(0) = s(s(0))) interpretace, která se liší prirazením s/1: s(x):=x není modelem této formule
Teorie T jazyka L je množina formulí jazyka L, tzv. axiomů
- s(X) = 0 je jeden z axiomu teorie elementární aritmetiky
Model teorie: libovolná interpretace, která je modelem všech jejích axiomů J* všechny axiomy teorie musí být v této interpretaci pravdivé
Hana Rudová, Logické programování I, 19. kvetna 2010
106
Predikátová logika
Model
Interpretace se nazývá modelem formule, je-li v ní tato formule pravdivá
interpretace množiny N s obvyklými operacemi je modelem formule ( 1 + s(0) = s(s(0))) interpretace, která se liší p r i razením s/1: s(x):=x není modelem této formule
Teořie T jazyka L je množina formulí jazyka L, tzv. axiomů
- s(X) = 0 je jeden z axiomu teorie elementární aritmetiky
Model teořie: libovolná interpretace, která je modelem všech jejích axiomů J* všechny axiomy teorie musí být v této interpretaci pravdivé
Přavdivá fořmule v teořii T = F: pravdivá v každém z modelů teorie T
A r íkáme také formule platí v teořii nebo je splnena v teořii
± formule 1 + s(0) = s(s(0))je pravdivá v teorii elementárních císel
Hana Rudová, Logické programování I, 19. kvetna 2010
106
Predikátová logika
Model
Interpretace se nazývá modelem formule, je-li v ní tato formule pravdivá
interpretace množiny N s obvyklými operacemi je modelem formule ( 1 + s(0) = s(s(0))) interpretace, která se liší p r i razením s/1: s(x):=x není modelem této formule
JS> Teorie T jazyka L je množina formulí jazyka L, tzv. axiomů
- s(X) = 0 je jeden z axiomu teorie elementární aritmetiky
-i* Model teorie: libovolná interpretace, která je modelem všech jejích axiomů J* všechny axiomy teorie musí být v této interpretaci pravdivé
& Pravdivá formule v teorii T = F: pravdivá v každém z modelu teorie T
A r íkáme také formule platí v teorii nebo je splnena v teorii
± formule 1 + s(0) = s(s(0))je pravdivá v teorii elementárních císel
JS> Logičky pravdivá formule = F: libovolná interpretace je jejím modelem
S> nebo-li F je pravdivá v každém modelu libovolné teorie
formule G v - G je logicky pravdivá, formule 1 + s(0) = s(s(0)) není logicky pravdivá
Hana Rudová, Logické programování I, 19. kvetna 2010 106 Predikátová logika
Zkoumání pravdivosti formulí
Zjištení pravdivosti provádíme dukazem
Důkaz: libovolná posloupnost F1,..., Fn formulí jazyka L, v níž každé Fi je bud' axiom teorie jazyka L nebo lze Fi odvodit z předchozích Fj (j < i) použitím urcitých odvozovacích pravidel
Hana Rudová, Logické programování I, 19. kvetna 2010
107
Predikátová logika
Zkoumání pravdivosti formulí
Zjištení pravdivosti provádíme dukazem
Důkaz: libovolná posloupnost Fi,..., Fn formulí jazyka L, v níž každé Fi je bud' axiom teorie jazyka L nebo lze Fi odvodit z p redchozích Fj (j < i) použitím urcitých odvozovacích pravidel
JS> Odvozovací pravidla - p ríklady
a pravidlo modus ponens: z formulí F a F => G lze odvodit G
Hana Rudová, Logické programování I, 19. kvetna 2010
107
Predikátová logika
Zkoumání pravdivosti formulí
Zjištení pravdivosti provádíme dukazem
Důkaz: libovolná posloupnost F1,..., Fn formulí jazyka L, v níž každé Fi je bud' axiom teorie jazyka L nebo lze Fi odvodit z predchozích Fj (j < i) použitím urcitých odvozovacích pravidel
—* Odvozovací pravidla - príklady
a pravidlo modus ponens: z formulí F a F == G lze odvodit G i* rezoluCní princip: z formulí F v A, G v -A odvodit F v G
Hana Rudová, Logické programování I, 19. kvetna 2010
107
Predikátová logika
Zkoumání pravdivosti formulí
Zjištení pravdivosti provádíme dukazem
Důkaz: libovolná posloupnost F1,..., Fn formulí jazyka L, v níž každé Fi je bud' axiom teorie jazyka L nebo lze Fi odvodit z p redchozích Fj (j < i) použitím urcitých odvozovacích pravidel
JS> Odvozovací pravidla - p ríklady
A pravidlo modus ponens: z formulí F a F => G lze odvodit G i* rezolucní princip: z formulí F v A, G v -A odvodit F v G
& F je dokazatelná z formulí A1, • • • ,An A1, • • • ,An h F
existuje-li dukaz F z A1, • • • ,An
Hana Rudová, Logické programování I, 19. kvetna 2010
107
Predikátová logika
Zkoumání pravdivosti formulí
Zjištení pravdivosti provádíme dukazem
Důkaz: libovolná posloupnost F1,..., Fn formulí jazyka L, v níž každé Fi je bud' axiom teorie jazyka L nebo lze Fi odvodit z p redchozích Fj (j < i) použitím urcitých odvozovacích pravidel
JS> Odvozovací pravidla - p ríklady
A pravidlo modus ponens: z formulí F a F => G lze odvodit G i* rezolucní princip: z formulí F v A, G v -A odvodit F v G
& F je dokazatelná z formulí A1, • • • ,An A1, • • • ,An h F
existuje-li důkaz F z A1, • • • ,An
& Dokazatelné formule v teorii T nazýváme teorémy teorie T
Hana Rudová, Logické programování I, 19. kvetna 2010
107
Predikátová logika
Korektnost a úplnost
Uzavřená formule: neobsahuje volnou promennou (bez kvantifikace)
VY ((0 < Y) a ( 3X (X < Y))) je uzavrená formule iľ ( 3X (X < Y)) není uzavrená formule
Hana Rudová, Logické programování I, 19. kvetna 2010
108
Predikátová logika
Korektnost a úplnost
Uzavrená formule: neobsahuje volnou promennou (bez kvantifikace)
VY ((0 < Y) a ( 3X (X < Y))) je uzavr ená formule iľ ( 3X (X < Y)) není uzavrená formule
M Množina odvozovacích pravidel se nazývá korektní, jestliže pro každou množinu uzavr ených formulí P a každou uzavr enou formuli F platí:
jestliže P h F pak P N F       (jestliže je neco dokazatelné, pak to platí)
Hana Rudová, Logické programování I, 19. kvetna 2010
108
Predikátová logika
Kořektnost a úplnost
Uzavřená fořmule: neobsahuje volnou promennou (bez kvantifikace)
VY ((0 < Y) a ( 3X (X < Y))) je uzavr ená formule iľ ( 3X (X < Y)) není uzavrená formule
M Množina odvozovacích pravidel se nazývá kořektní, jestliže pro každou množinu uzavr ených formulí P a každou uzavr enou formuli F platí:
jestliže P h F pak P N F       (jestliže je neco dokazatelné, pak to platí)
Odvozovací pravidla jsou úplná, jestliže
jestliže P N F pak P h F       (jestliže neco platí, pak je to dokazatelné)
Hana Rudová, Logické programování I, 19. kvetna 2010
108
Predikátová logika
Korektnost a úplnost
Uzavrená formule: neobsahuje volnou promennou (bez kvantifikace)
VY ((0 < Y) a ( 3X (X < Y))) je uzavr ená formule iľ ( 3X (X < Y)) není uzavrená formule
M Množina odvozovacích pravidel se nazývá korektní, jestliže pro každou množinu uzavr ených formulí P a každou uzavr enou formuli F platí:
jestliže P h F pak P N F       (jestliže je neco dokazatelné, pak to platí)
Odvozovací pravidla jsou úplná, jestliže
jestliže P N F pak P h F       (jestliže neco platí, pak je to dokazatelné)
-í* PL1: úplná a korektní dokazatelnost, tj.
pro teorii T s množinou axiomu A platí:   T = F práve když Ah F
Hana Rudová, Logické programování I, 19. kvetna 2010
108
Predikátová logika
Rezoluce v predikátové logice I. rádu
Rezoluče
& 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, 19. kvetna 2010
110
Rezoluce v PL1
Rezoluce
—* rezoluční princip: z F v A, G v -A odvodit F v G —* dokazovací metoda používaná a v Prologu
a ve většině 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, 19. kvetna 2010
110
Rezoluce v PL1
Formule
literál l
s* pozitivní literál = atomická formule p(tl, • • • ,tn)
& negativní literál = negace atomické formule -p(tl, • • • ,tn)
Hana Rudová, Logické programování I, l9. kvetna 2GlG
lll
Rezoluce v PLl
Formule
literál l
s* pozitivní literál = atomická formule p(t1, • • • ,tn) s* negativní literál = negace atomické formule -p(t1, • • • ,tn) & 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)} A klauzule je pravdivá <=> je pravdivý alespoň jeden z jejích literálů -i- prázdná klauzule se znací □ a je vždy nepravdivá (neexistuje v ní pravdivý literál)
Hana Rudová, Logické programování I, 19. kvetna 2010
111
Rezoluce v PL1
Formule
literál l
J» pozitivní literál = atomická formule p(t1, • • • ,tn) s* negativní literál = negace atomické formule -p(t1, • • • ,tn) & 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)} A klauzule je pravdivá <=> je pravdivý alespon jeden z jejích literálů -i- 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
& formule je v tzv. konjuktivní normální forme (konjunkce disjunkcí)
J* p r íklad: (p v q) a (-p) a (p v-q v r)      notace: {{p, q}, {-p}, {p, -q,r}}
Hana Rudová, Logické programování I, 19. kvetna 2010
111
Rezoluce v PL1
Formule
literál l
s* pozitivní literál = atomická formule p(t1, • • • ,tn) s* negativní literál = negace atomické formule -p(t1, • • • ,tn) & 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)} A klauzule je pravdivá <=> je pravdivý alespon jeden z jejích literálů -i- 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
& formule je v tzv. konjuktivní normální forme (konjunkce disjunkcí)
j* p r í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, 19. kvetna 2010
111
Rezoluce v PL1
Formule
literál l
J» pozitivní literál = atomická formule p(t1, • • • ,tn) s* negativní literál = negace atomické formule -p(ti, • • • ,tn) & 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)} A klauzule je pravdivá <=> je pravdivý alespoň jeden z jejích literálů -i- 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
formule je v tzv. konjuktivní normální forme (konjunkce disjunkcí) J* 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á notače: literál je prvek klauzule, klauzule je prvek formule, ...
Hana Rudová, Logické programování I, 19. kvetna 2010 111 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, 19. kvetna 2010
112
Rezoluce vPL1
Splnitelnost
[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)
Hana Rudová, Logické programování I, 19. kvetna 2010
112
Rezoluce v PL1
Splnitelnost
& [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 := " + "
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 11)
& Formule je nesplnitelná, neexistuje-li interpretace, pro kterou je pravdivá
J* 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, 19. kvetna 2010 112 Rezoluce v PL1
Rezoluční princip ve výrokové logice
M Rezoluční princip = pravidlo, které umožňuje odvodit z klauzulí C1 u jí} a j-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, 19. kvetna 2010
113
Rezoluce v PL1
Rezoluční princip ve výrokové logice
Rezoluční princip = pravidlo, které umožňuje odvodit z klauzulí C1 u jí} a { —í} u C2 klauzuli Ci u C2
Ci u {l}        { —í} u C2 Ci u C2
C1 u C2 se ňazývá rezolventou puvodňích klauzulí příklad:
jp,r}        {—r,s}      (p v r) a (—r v s) jp,s} p v s
Hana Rudová, Logické programování I, lg. kvetna 2G1G
113
Rezoluce vPLl
RezoluCní princip ve výrokové logice
RezoluCní princip = pravidlo, které umožnuje odvodit z klauzulí Ci u jí} a { —í} u C2 klauzuli Ci u C2
Ci ují}        { —í} u C2 Ci u C2
C1 u C2 se nazývá rezolventou puvodních klauzulí p r íklad:
jp,r}        {—r,s}      (p v r) a (—r v s) jp,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, 19. kvetna 2010
113
Rezoluce v PL1
RezoluCní důkaz
rezoluCní 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.
Hana Rudová, Logické programování I, 19. kvetna 2010
114
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í dukaz {p} z formule F = {{p,r}, {q, -r}, {-q}}
Hana Rudová, Logické programování I, 19. kvetna 2010
114
Rezoluce v PL1
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.
& príklad: rezolucní důkaz {p} z formule F = {{p,r}, {q, -r}, {-q}}
C1 = {p,r} klauzule z F
Hana Rudová, Logické programování I, 19. kvetna 2010
114
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
Hana Rudová, Logické programování I, 19. kvetna 2010
114
Rezoluce v PL1
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.
& 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
Hana Rudová, Logické programování I, 19. kvetna 2010
114
Rezoluce v PL1
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.
& 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, 19. kvetna 2010
114
Rezoluce v PL1
Rezoluční důkaz
řezoluční důkaz klauzule C z fořmule 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, 19. kvetna 2010
114
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, 19. kvetna 2G1G
115
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 uplatnováním rezolucního principu dospet k prázdné klauzuli □
C Pr íklad:
F...-*av a
Hana Rudová, Logické programování I, 19. kvetna 2010
115
Rezoluce v PL1
Rezolucní vyvrácení
důkaz pravdivosti formule F spocívá v demonstraci nesplnitelnosti — F
J* —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 —F.. .a a —a —F... {{a}, {—a}}
Hana Rudová, Logické programování I, 19. kvetna 2010
115
Rezoluce v PL1
Rezolucní vyvrácení
dukaz 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 -F.. .a a -a -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, 19. kvetna 2010 115 Rezoluce v PL1
Strom rezolučního důkazu
strom rezolučního důkazu klauzule C z formule F je binární strom:
J* koren je označen klauzulí C,
listy jsou označeny klauzulemi z F 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: F = {{p,r}, {q, -r}, {-q}, {-p}}      C = □  
{p,r}    {q, -r} {-q}
{-p}
/
/
/
strom rezolučního vyvrácení
(rezoluční dukaz □ z F)
Hana Rudová, Logické programování I, 19. května 2010
116
Rezoluce v PL1
Strom rezolučního důkazu
strom rezolučního důkazu klauzule C z formule F je binární strom:
J* koren je označen klauzulí C,
listy jsou označeny klauzulemi z F 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: F = {{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 F)
príklad: {{p,r}, {q, -r}, {-q}, {-p, t}, {-s}, {s,-t}}
Hana Rudová, Logické programování I, 19. května 2010
116
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
Hana Rudová, Logické programování I, 19. kvetna 2010
117
Rezoluce vPL1
Substituce
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
substituce je tedy homomorfismus výrazu, 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))
Hana Rudová, Logické programování I, 19. kvetna 2010
117
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, 19. kvetna 2010 117 Rezoluce v PL1
Unifikace
Ztotožnení dvou literálu p, q pomocí vhodné substituce a takové, že pa = qa nazýváme unifikací a príslušnou substituci unifikátořem.
Unifikátořem množiny S literálů nazýváme substituce 0 takovou, že množina
S0 = {t0|t g S}
má jediný prvek.
Hana Rudová, Logické programování I, 19. kvetna 2010
118
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ů 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 ) }
Hana Rudová, Logické programování I, 19. kvetna 2010
118
Rezoluce v PL1
Unifikace
Ztotožnení dvou literálu 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, 19. kvetna 2010
118
Rezoluce vPL1
Unifikace
C Ztotožnení dvou literálu p, q pomocí vhodné substituce a takové, že pa = qa nazýváme unifikací a príslušnou substituci unifikátořem.
& Unifikátořem množiny S literálu nazýváme substituce 0 takovou, že množina
S0 = {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 nejobecnejším unifikátořem (mgu - most generál unifier), jestliže pro libovolný unifikátor 0 existuje substituce A taková, že 0 = aA.
a príklad (pokrač): nejobecnejší unifikátor a = [D1/1, Y2/2003, M1/M2],
Hana Rudová, Logické programování I, 19. kvetna 2010
118
Rezoluce 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, 19. kvetna 2010
118
Rezoluče v PL1
Rezolucní princip v PL1
základ:
& rezolucní princip ve výrokové logice-----
C1 u C2
Jť substituce, unifikátor, nejobecnejší unifikátor
Hana Rudová, Logické programování I, lg. kvetna 2G1G
Hg
Rezoluce v PL1
Rezolucní princip v PL1
základ:
& rezolucní princip ve výrokové logice-----
C1 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
Hana Rudová, Logické programování I, 19. kvetna 2010
119
Rezoluce v PL1
Rezoluční princip v PL1
základ:
& rezoluční prinčip ve výrokové logiče-----
Ci u C2
Jť substituče, unifikátor, nejobečnejší unifikátor
rezoluční prinčip v PL1 je pravidlo, které
-fc pripraví príležitost pro uplatnení vlastního rezolučního pravidla nalezením vhodného unifikátoru
-** provede rezoluči a získá rezolventu
Ci u {A}        {-B}u C2 C1 pa u C2a
*> kde p je přejmenováním promennýčh takové,
že klauzule (C1 u A)p a {B} u C2 nemají společné promenné
a a je nejobečnejší unifikátor klauzulí Ap a B
Hana Rudová, Logičké programování I, 19. kvetna 2010
119
Rezoluče v PL1
Príklad: rezoluce v PL1
C príklad: C = {p(X,Y),   q(Y)}     C2 = {-q(a), s(X,W)}
Hana Rudová, Logické programování I, 19. kvetna 2010
120
Rezoluce 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)}
Hana Rudová, Logické programování I, 19. kvetna 2010
120
Rezoluce v PL1
Príklad: rezoluce v PLI
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)}
nejobecnejší unifikátor: a = [Y/a]
Ci = {p(Z,a),   q(a)}     C2 = {-q(a), s(X,W)}
Hana Rudová, Logické programování I, 19. kvetna 2010
120
Rezoluce vPL1
Příklad: řezoluce 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)}
nejobecnejší unifikátor: a = [Y/a]
Ci = {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, 19. kvetna 2010
120
Rezoluce v PL1
Príklad: rezoluce v PL1
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)}
* 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, 19. kvetna 2010
120
Rezoluce vPL1
Rezoluce v PL1
Obečný rezoluční princip v PL1
Ci u {Ai, • • • ,Am} {-Bi,       , -Bn} u C2
Cipa u C2a
& kde p je přejmenováním promennýčh takové, že množiny klauzulí {A1p, • • • ,Amp, C1p} a {B1, • • • ,Bn, C2} nemají společné promenné
Jr a je nejobečnejší unifikátor množiny {A1p, • • • ,Amp,B1, • • • ,Bn}
Hana Rudová, Logičké programování I, 19. kvetna 2010
121
Rezoluče 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, 19. kvetna 2010
121
Rezoluce v PL1
Rezoluce v PLI
Obecný rezoluCní princip v PL1
Ci u {Ai, • • • ,Am} {-Bi, • • • , -Bn} u C2
Cipa u C2a
kde p je přejmenováním proměnný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}
příklad: A1 = a(X) vs. {-B1, -B2} = {-a(b), -a(Z)}
v jednom kroku potřebuji vyrezolvovat zároven B1 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, 19. kvetna 2010
121
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, 19. kvetna 2010
122
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
stále ale príliš mnoho možností, jak hledat dukaz v prohledávacím prostoru 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
Hana Rudová, Logické programování I, 19. kvetna 2010
122
Rezoluce v PL1
Zefektivnění rezoluce
C rezoluce je intuitivně efektivnější než axiomatické systémy
a axiomatické systémy: který z axiomU a pravidel použít? a rezoluce: pouze jedno pravidlo
JS> stále ale príliš mnoho možností, jak hledat dukaz v prohledávacím prostoru
C- problém SAT= (515 je splnitelná } NP úplný,
nicméne: menší prohledávací prostor vede k rychlejšímu nalezení řeš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, 19. kvetna 2010
122
Rezoluce v PL1
Varianty rezolucní metody
Veta: Každé omezení rezoluce je korektní.
& stále víme, že to, co jsme dokázali, platí
Hana Rudová, Logické programování I, 19. kvetna 2010
123
Rezoluce vPL1
Vařianty řezolucní metody
Veta: Každé omezení rezoluce je korektní.
& stále víme, že to, co jsme dokázali, platí
T-řezoluce: klauzule ucastnící se rezoluce nejsou tautologie úplná
-i- tautologie nepomuže ukázat, že formule je nesplnitelná
Hana Rudová, Logické programování I, 19. kvetna 2010
123
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
Hana Rudová, Logické programování I, 19. kvetna 2010
123
Rezoluce 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 neporrmže ukázat, že formule je nesplnitelná
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
vstupní (input) rezoluče: neúplná alespon jedna z klauzulí, použitá pri rezoluči, je z výčhozí vstupní množiny S
Hana Rudová, Logičké programování I, 19. kvetna 2010
123
Rezoluče v PL1
Varianty rezolucní metody
Veta: Každé omezení rezoluce je korektní.
& 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á
JS> 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
JS> vstupní (input) rezoluce: neúplná alespon jedna z klauzulí, použitá pri rezoluci, je z výchozí vstupní množiny S
{{p, q},   {-p, q},   {p, -q},   {-p, -q}} existuje rezolucní vyvrácení
neexistuje rezolucní vyvrácení pomocí vstupní rezoluce
Hana Rudová, Logické programování I, 19. kvetna 2010 123 Rezoluce v PL1
Rezoluče a logičké programování
Lineářní řezoluce
varianta rezolucní metody
a 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 predcházejících rezolvent
C0^B0 C2 B2
c
Hana Rudová, Logické programování I, 19. kvetna 2010
125
Rezoluce 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č <Co,Bo>, ... (Cn,Bn) taková, že C = Cn+1 a
Jr C0 a každá Bi jsou prvky S nebo nekteré Cj,j < i J» každá Ci+1, i < n je rezolventa Ci a Bi
C0^B0 C2 B2
c
Hana Rudová, Logičké programování I, 19. kvetna 2010
125
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 predcházejících rezolvent
lineární rezolucní důkaz C z S je posloupnost dvojic <Co,Bo), ... (Cn,Bn) taková, že C = Cn+1 a
Jr C0 a každá Bi jsou prvky S nebo nekteré Cj,j < i s» každá Ci+1, i < n je rezolventa Ci a Bi
lineární vyvrácení S = lineární rezolucní důkaz □ z S
C0^B0
c,y,
C2 B2
C
Hana Rudová, Logické programování I, 19. kvetna 2010
125
Rezoluce a logické programování
Lineární rezoluce II.
-í* príklad: S = {Ai,A2,A3,A4}
Ai = {p,q} A2 = {p, -q} A3 = {-p,q} A4 = {-p, -q}
Hana Rudová, Logické programování I, 19. kvetna 2010
126
Rezoluce a logické programování
Lineární rezoluce II.
-í* príklad: S = {A1,A2,A3,A4}
A1 = { p, q}
A2 = {p, -q} A3 = {-p,q} A4 = {-p, -q}
C Bi {p,q}{p, -1 q}
{p} {^p,q}
IX
{^p} {p}
□
Hana Rudová, Logické programování I, 19. kvetna 2010
126
Rezoluce a logické programování
Lineární rezoluče II.
-í* príklad: S = {A1,A2,A3,A4}
Ai = {p,q} A2 = {p, -q} A3 = {-p,q} A4 = {-p, -q}
S: vstupní množina klauzulí JS> Q: strední klauzule & B{. boční klauzule
C Bi {p,q}{p, -1 q}
{p} {^p,q}
IX
□
Hana Rudová, Logičké programování I, 19. kvetna 2010
126
Rezoluče a logičké programování
Přologovská notace
& Klauzule v matematické logice
{Hi, ■■■ ,Hm, —Ti, ■■■ , —Tn} Hi V--- V Hm V —Ti V ■ ■ ■ V — Tn
Hana Rudová, Logické programování I, 19. kvetna 2010
127
Rezoluce 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
Hana Rudová, Logické programování I, 19. kvetna 2010
127
Rezoluce 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
-i* Pravidlo: jeden pozitivní a alespon jeden negativní literál
Prolog: H : - T1, ■ ■ ■ ,Tn.
Hana Rudová, Logické programování I, 19. kvetna 2010 127 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
JS> Pravidlo: jeden pozitivní a alespon jeden negativní literál
& Prolog: H : - Ti, ■ ■ ■ ,Tn.     Matematická logika: H <= Ti a ■ ■ ■ a Tn
Hana Rudová, Logické programování I, 19. kvetna 2010
127
Rezoluce a logické programování
Prologovská notace
-i* Klauzule v matematické logice
{Hl, ■■■ ,Hm, —Tl, ■■■ , —Tn} Hl 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 — Tl v ■ ■ ■ v — Tn        H — Tl v ■ ■ ■ v —Tn
Pravidlo: jeden pozitivní a alespon jeden negativní literál
J* Prolog: H : - Tl, ■ ■ ■ ,Tn.     Matematická logika: H <= Tl a ■ ■ ■ a Tn
H <= T
Hana Rudová, Logické programování I, l9. kvetna 2GlG
127
Rezoluce a logické programování
Přologovská notace
& Klauzule v matematické logice
{Hi, ■■■ ,Hm, —Ti, ■■■ , —Tn} Hi v — v Hm V —Ti v ■ ■ ■ v — Tn
& Hořnova 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> Přavidlo: jeden pozitivní a alespon jeden negativní literál
J* Prolog: H : - Ti, ■ ■ ■ ,Tn.     Matematická logika: H <= Ti a ■ ■ ■ a Tn
Hana Rudová, Logické programování I, 19. kvetna 2010
127
Rezoluce a logické programování
Prologovská notače
& Klauzule v matematičké logiče
{H1, ••• ,Hm,-T1, ••• ,-Tn} H1 v • • • v Hm v -T1 v • • • v -Tn
& Hornova klauzule: nejvýše jeden pozitivní literál
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.     Matematičká logika: H <= T1 a • • • a Tn
M» H <= T      H v-T     H v-T1 v • • • v -Tn
Hana Rudová, Logičké programování I, 19. kvetna 2010 127 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
J* Prolog: H : - T1, ■ ■ ■ ,Tn.     Matematická logika: H <= T1 a ■ ■ ■ a Tn
M» H <= T      H v-T     H v-T1 v ■ ■ ■ v-Tn      Klauzule: {H,-T1,..., -Tn}
Hana Rudová, Logické programování I, 19. kvetna 2010 127 Rezoluce 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
-i* 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      Klauzule: {H,-T1,..., -Tn}
JS> Fakt: pouze jeden pozitivní literál
Prolog: H.      Matematická logika: H      Klauzule: {H}
Hana Rudová, Logické programování I, 19. kvetna 2010 127 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í literal
{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í literal
& Prolog: H : - Ti, - - - ,Tn.     Matematická logika: H <= Ti a - - - a Tn
J* H <= T      H v-T     H v-Ti v---v-Tn      Klauzule: {H,-Ti,..., -Tn}
-í* Fakt: pouze jeden pozitivní literal
Prolog: H.      Matematická logika: H      Klauzule: {H}
& Cílová klauzule: žádný pozitivní literal
it Prolog: : - Ti,... Tn.   Matematická logika: -Ti v - - - v -Tn   Klauzule: {-Ti, - - - -Tn}
Hana Rudová, Logické programování I, 19. kvetna 2010 127 Rezoluce a logické programování
Logický program
Programová klauzule: práve jeden pozitivní literál (fakt nebo pravidlo) Logický 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, 19. kvetna 2010
128
Rezoluce a logické programování
Logický program
Programová klauzule: práve jeden pozitivní literál (fakt nebo pravidlo) Logický program: konecná 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} a logický program v prologovské notaci: p.
p: -q. q.
a cílová klauzule: G = {-q, -p}      : -q, p.
Hana Rudová, Logické programování I, 19. kvetna 2010
128
Rezoluce a logické programování
Lineářní řezoluce přo Hořnovy klauzule
& Zacneme s cílovou klauzulí: C0 = G
& Bocní klauzule vybíráme z programových klauzulí P
M G = {—q, —p}        P ={Pi,P2,Pb} :   Pi = {p},   P2 = {p, —q},   P3 = {q} : -q, p. p. p : -q, q.
Hana Rudová, Logické programování I, 19. kvetna 2010
129
Rezoluce a logické programování
Lineární rezoluce pro Hornovy klauzule
St Zacneme s cílovou klauzulí: Co = G
St Bocní klauzule vybíráme z programových klauzulí P
3 G = {—q, —p}        P ={P1,Pz,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, 19. kvetna 2010 129 Rezoluce a logické programování
Lineární rezoluce pro Hornovy klauzule
Zacneme s cílovou klauzulí: C0 = 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, 19. kvetna 2010
129
Rezoluce a logické programování
Lineární rezoluce pro Hornovy klauzule
JS* Zacneme s cílovou klauzulí: Co = G
St Bocní klauzule vybíráme z programových klauzulí P
3 G = {-q,-p}        P ={P1,P2,P3} :   P1 = {p},   P2 = {p, -q},   P3 = {q}
*        : -q,p. p. p: -q, q.
\/ \/
□ □
JS> Strední klauzule jsou cílové klauzule
Hana Rudová, Logické programování I, 19. kvetna 2010 129 Rezoluce a logické programování
Lineářní vstupní řezoluce
Vstupní řezoluce na P u {G}
-i* (opakování:) alespoň jedna z klauzulí použitá pri rezoluci je z výchozí vstupní množiny & zacneme s cílovou klauzulí: Co = G
& bocní klauzule jsou vždy z P (tj. jsou to programové klauzule)
Hana Rudová, Logické programování I, 19. kvetna 2010
130
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 S je posloupnost dvojič
{Co,Bo>, ... {Cn,Bn> taková, že C = Cn+1 a
a C0 a každá Bi jsou prvky S nebo nekteré Cj,j < i S* každá Ci+1, i < n je rezolventa Ci a Bi
Hana Rudová, Logičké programování I, 19. kvetna 2010
130
Rezoluče a logičké programování
Lineární vstupní rezoluce
& Vstupní rezoluce na P u {G}
-i* (opakování:) alespon jedna z klauzulí použitá pri rezoluci je z výchozí vstupní množiny Jt zacneme s cílovou klauzulí: C0 = G
s* bocní klauzule jsou vždy z P (tj. jsou to programové klauzule)
JS* (Opakování:) Lineární rezolucní dukaz C z S je posloupnost dvojic
(Co,Bo>, ... (Cn,Bn) taková, že C = Cn+1 a
C0 a každá Bi jsou prvky S nebo nekteré Cj,j < i S» každá Ci+1, 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+1 a
a C0 = G a každá Bi jsou prvky P lineární rezoluce + vstupní rezoluce
a každá Ci+1, i < n je rezolventa Q a Bi
Hana Rudová, Logické programování I, 19. kvetna 2010 130 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 zustává alespon jeden pozit. literál
Hana Rudová, Logické programování I, 19. kvetna 2010
131
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, 19. kvetna 2010
131
Rezoluce a logické programování
Cíle a fakta při lineářní řezoluci
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
Hana Rudová, Logické programování I, 19. kvetna 2010
131
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
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
Hana Rudová, Logické programování I, 19. kvetna 2010
131
Rezoluce a logické 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, 19. kvetna 2010 131 Rezoluce a logické programování
Korektnost a úplnost
Veta: Množina S Hornovýčh klauzulí je nesplnitelná, práve když existuje rezoluční vyvráčení S pomočí vstupní rezoluče. M Korektnost platí stejne jako pro ostatní omezení rezoluče
* Úplnost LI-rezoluče pro Hornovy klauzule:
Nečht' P je množina programovýčh klauzulí a G čílová klauzule.
Je-li množina P u {G} Hornovýčh klauzulí nesplnitelná,
pak existuje rezoluční vyvráčení P u {G} pomočí LI-rezoluče.
A vstupní rezoluče pro (obečnou) formuli sama o sobe není úplná
=> LI-rezoluče aplikovaná na (obečnou) formuli nezaručuje, že nalezeneme dukaz, i když formule platí!
Hana Rudová, Logičké programování I, 19. kvetna 2010
132
Rezoluče a logičké 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, 19. kvetna 2010
132
Rezoluce a logické programování
Korektnost a úplnost
Veta: Množina S Hornovýčh klauzulí je nesplnitelná, práve když existuje rezoluční vyvráčení S pomočí vstupní rezoluče. M Korektnost platí stejne jako pro ostatní omezení rezoluče
* Úplnost LI-rezoluče pro Hornovy klauzule:
Nečht' P je množina programovýčh klauzulí a G čílová klauzule.
Je-li množina P u {G} Hornovýčh klauzulí nesplnitelná,
pak existuje rezoluční vyvráčení P u {G} pomočí LI-rezoluče.
A vstupní rezoluče pro (obečnou) formuli sama o sobe není úplná
=> LI-rezoluče aplikovaná na (obečnou) formuli nezaručuje, že nalezeneme dukaz, i když formule platí!
& Význam LI-rezoluče pro Hornovy klauzule:
i*  P = {P1, . . . , Pn}, G = {G'1 ,...,Gm}
iľ LI-rezolučí ukážeme nesplnitelnost P1 a • • • a Pn a (-G1 v • • • v -Gm)
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á, Logičké programování I, 19. kvetna 2010 132 Rezoluče a logičké programování
Usporádané klauzule (definite clauses)
JS> Klauzule = množina literálu
JS> Usporádáná klauzule (definite clause) = posloupnost literálu
-fc nelze volne menit poradí literálu
ü> Rezolucní princip pro usporádané klauzule:
_{— Ao,—An}_{B, —Bo,— Bm}_
{—Ao,—Ai-l, —Bop,—Bmp,—Ai+l,—An}a
M usporádaná rezolventa: {—Ao,—Ai-l, —Bop,—Bmp,—Ai+l,—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, 19. kvetna 2G1G
133
Rezoluce a logické programování
Uspořádané klauzule (definite clauses)
Klauzule = množina literálů JS> Uspořádaná klauzule (definite clause) = posloupnost liteřálU
it nelze volne menit poradí literálů
£ Rezoluční princip přo uspořádané klauzule:
_I-Aq,      -An}_{B, -Bq,-Bm\_
I-Aq,—Ai-i, -BqP,      —BmP,—At+i,—An}v
M uspořádaná řezolventa: {-Aq,     -Ai-1, -B0p,—Bmp,—Ai+1,-An}cr
it p je přejmenování promenných takové, že klauzule {Aq, .. .,An} a {B,Bq, .. .,Bm}p nemají společné promenné
it a je nejobecnejší unifikátor pro Ai a Bp
it řezoluceje řealizována na liteřálech —Aia a Bpa
Jt je dodržováno poradí literálu, tj.
{-B0p,—Bmp}a jde do uspořádané řezolventy přesne na pozici —Aia
Hana Rudová, Logické programování I, 19. kvetna 2010 133 Rezoluce a logické programování
Usporádané klauzule II.
C Usporádáné klauzule
_{-Ao.....-An}_{B1 -Bo..... -Bm\_
{-Ao.....-Ai-1. -Bop..... -BmP.-Ai+1..... -An}<J
Hornovy klauzule
: —Ao. . . . . An. B : —Bo. . . . . Bm.
: -(Ao.... .Ai-1.Bop.... .BmP.Ai+1.... .An)cr.
Hana Rudová, Logické programování I, 19. kvetna 2010
134
Rezoluce a logické programování
Uspo rádané klauzule II.
Usporádáné klauzule
{-Ao,-An} {B, -Bo,-Bm}
Hornovy klauzule
: —A0, . . . , An. B : —B0, . . . , Bm.
Príklad
: — (Ao.....Ai-1,Bop,... ,Bmp,Ai+1,... ,An)a.
{-s(X),-t(1), -u(X)}      {t(Z), -q(Z,X), -r(3)} {-s(X), -q(1,A), -r(3),-u(X)}
: -s(X),t(1),u(X).     t (Z) : -q(Z,X),r(3)
: -s(X),q(1,A),r(3),u(X). p = [X/A]     a = [Z/1]
Hana Rudová, Logické programování I, 19. kvetna 2010 134 Rezoluce a logické programování
LD-rezoluče
-í* LD-rezoluční vyvráčení množiny usporádanýčh klauzulí P u {G} je posloupnost (Go, C0),(Gn, Cn) taková, že
a Gí,Cíjsou uspořádané klauzule
G = Go
a Gi je usporádaná čílová klauzule a Ci je prejmenování klauzule z P
Ci neobsahuje promenné, které jsou v Gj, j < i nebo v Ck,k < i
J» Gi+1,0 < i < n je usporádaná rezolventa Gi a Ci
Hana Rudová, Logičké programování I, 19. kvetna 2010
135
Rezoluče a logičké programování
LD-rezoluče
-í* LD-rezoluční vyvráčení množiny usporádanýčh klauzulí P u {G} je posloupnost (G0, C0),(Gn, Cn) taková, že
a Gi,Cijsou usporádané klauzule
G = Go
a Gi je usporádaná čílová klauzule a Ci je prejmenování klauzule z P
Ci neobsahuje promenné, které jsou v Gj, j < i nebo v Ck,k < i
J» Gi+1,0 < i < n je usporádaná rezolventa Gi a Ci JS> LD-rezoluče: korektní a úplná
Hana Rudová, Logičké programování I, 19. kvetna 2010
135
Rezoluče a logičké programování
SLD-rezoluce
JS> Lineární rezoluce se selekCním pravidlem   = SLD-rezoluce (Selected Linear resolution for Definite clauses)
s» rezoluce
& SelekCní pravidlo
s Lineární rezoluce
a Definite (uspořádané) klauzule
a vstupní rezoluce
Hana Rudová, Logické programování I, 19. května 2010
136
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
Hana Rudová, Logické programování I, 19. kvetna 2010
136
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, 19. kvetna 2010 136 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/1 výběr      | /
nejlevějšího   {~iP} Jp} nejpravějšího Jq}
litěrálu      I / literálu       ' '
□ □
Hana Rudová, Logické programování I, 19. května 2010
137
Rezoluce a logické programování
Lineární rezoluce se selekcním pravidlem
P = {{p}. {p. -q}. {q}},    G = {-q.-p}
výber      | y/ výber |
nejlevejšího   {~iP} Jp} nejpravejšího Jq}
literálu      ' ' literálu       ' '
□ □
SLD-rezolucní vyvrácení P u {G} pomocí selekcního pravidla R je LD-rezolucní vyvrácení <Go.Co>..... (Gn.Cn) takové, že G = Go.Gn+1 = □ a R(Gi) je literál rezolvovaný v kroku i
Hana Rudová, Logické programování I, 19. kvetna 2010
137
Rezoluce a logické programování
Lineární rezoluce se selekcním pravidlem
-í* SLD-rezolucní vyvrácení P u |G} pomocí selekcního pravidla R je
LD-rezolucní vyvrácení (Go,Co>,(Gn,Cn) takové, že G = G0,Gn+\ = □ a R(Gi) je literál rezolvovaný v kroku i
& SLD-rezoluce - korektní, úplná
& Efektivita SLD-rezoluce je závislá na
& selekcní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í
* P = {{p}, {p, -q}, {q}},    G = {-q,-p}
n
literálu
□
n
literálu
□
Hana Rudová, Logické programování I, 19. kvetna 2010
137
Rezoluce a logické 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, 19. kvetna 2010
138
Rezoluce a logické programovaní
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
Hana Rudová, Logické programování I, 19. kvetna 2010
139
Rezoluce a logické programování
Střom výpoctu (SLD-střom)
SLD-střom je strom tvorený všemi možnými výpocetními posloupnostmi logického programu P vzhledem k cíli G
ii> koreny stromy jsou programové klauzule a cílová klauzule G
-i* v uzlech jsou rezolventy
-í* výchozím korenem rezoluce je cílová klauzule G
Hana Rudová, Logické programování I, 19. kvetna 2010
139
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
koreny stromy jsou programové klauzule a cílová klauzule G
v uzlech jsou rezolventy
výchozím korenem rezoluce je cílová klauzule G listy jsou dvojího druhu:
-fc 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, 19. kvetna 2010
139
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
koreny stromy jsou programové klauzule a cílová klauzule G
v uzlech jsou rezolventy
výchozím korenem rezoluce je cílová klauzule G listy jsou dvojího druhu:
Jt oznacené prázdnou klauzulí - jedná se o úspešné uzly (succes nodes)
Jt 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, 19. kvetna 2010
139
Rezoluce a logické programování
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).
(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]
Hana Rudová, Logické programování I, 19. kvetna 2010
140
Rezoluce a logické programování
Příklad: SLD-strom a výsledná substituce
: -a(Z).
a(X) : -b(X,Y),c(Y) a(X) : -c(X). b(2, 3). b(1,2). c(2).
Cvičení:
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).
:- 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]
ve výsledné substituči jsou pouze promenné z dotazu, tj. výsledné substituče jsou [Z/1] a [Z/2] nezajímá me substituče [Y/2]
Hana Rudová, Logické programování I, 19. května 2010
140
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]
Hana Rudová, Logické programování I, 19. května 2010
141
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 Qi
^ potenciální instanciace proměnné ve vstupní cílové klauzuli
& Výsledná substituce (answer substitution)
Q = QqQi • • • Qn složení unifikací
Hana Rudová, Logické programování I, 19. kvetna 2010
141
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 X je vektor promenných v G
Hana Rudová, Logické programování I, 19. kvetna 2010
142
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)(-GAX) v -Gz(Xl) v • • •v —Gn(X))
kde G = { — G1, —G2, • • • , — Gn} a X je vektor promennýčh v G nesplnitelnost (1) je ekvivalentní tvrzení (2) a (3)
(2) P v- —G
(3) P v (3X)(G1(X) a^-a Gn(X))
Hana Rudová, Logičké programování I, 19. kvetna 2010
142
Rezoluče a logičké 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)(-GAX) v -Gz(X) v ■ ■ ■ v -Gn(Xl))
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 objektů, které na základe vlastností množiny P splnují konjunkci literálů v cílové klauzuli
Hana Rudová, Logické programování I, 19. kvetna 2010
142
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 = {-Gi, -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)(Gi(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
-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, 19. kvetna 2010
142
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, 19. kvetna 2010
143
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í pameťová nárocnost a složité rídící struktury
Hana Rudová, Logické programování I, 19. kvetna 2010
143
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 šírky
Jt 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
Jt 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, 19. kvetna 2010 143 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 : -q. (2)
q. (3) dotaz: : -q.
:- q.
:- r. □
Hana Rudová, Logičké programování I, 19. kvetna 2010
144
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)). vede k: [B/X], [X/f(X)]
Unifikátor pro g(Xi, ...,Xn) a g(f(Xo,Xo),f(Xl,Xl),.. .,f(Xn-i,Xn-i))
Xi = f(Xo,Xo),   X2 = f(X\,X\),...,    Xn = f(Xn-l,Xn-l)
X2 = f (f (Xo,Xo), f (Xo,Xo)),... délka termu pro Xk exponenciálne narůstá
Hana Rudová, Logické programování I, 19. kvetna 2010
145
Rezoluce a logické programování
Test výskytu
-í* Kontrola, zda se proměnná vyskytuje v termu, kterým ji substituujeme
A dotaz : -a(B,B). i> logický program: a(X,f(X)). vede k: [B/X], [X/f(X)]
& Unifikátor pro g(Xi, ...,Xn) a g(f(Xo,Xo),f(Xi,Xi),.. .,f(Xn-i,Xn-i))
Xi = f(Xo,Xo),   X2 = f(Xi,Xi),...,    Xn = f(Xn-l,Xn-l)
X2 = f (f (Xo,Xo), f (Xo,Xo)),...
délka termu pro Xk exponenciálne narůstá => exponenciální složitost na overení kontroly výskytu JS> Test výskytu se pri unifikaci v Prologu neprovádí
* Dusledek:      ? - X = f(X) uspeje s X = f (f (f (f (f (f (f (f (f (f (...))))))))))
Hana Rudová, Logické programování I, 19. kvetna 2010 145 Rezoluce a logické programování
SLD-řezoluce v Přologu: kořektnost
-í* Implementace SLD-rezoluce v Prologu nepoužívá pri unifikaci test výskytu
=> není kořektní
(1) t(X) : -p(X,X).    : -t(X).
p(X,f(X)). X = f (f(f(f (...))))))))))      problém se projeví
Hana Rudová, Logické programování I, 19. kvetna 2010
146
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).        : -t.
p(X,f(X)). yes      dokazovací systém nehledá unifikátor pro X a f(X)
Hana Rudová, Logické programování I, 19. kvetna 2010
146
Rezoluce 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)
-í* Rešení: problém typu (2) prevést na problém typu (1) ?
Hana Rudová, Logičké programování I, 19. kvetna 2010
146
Rezoluče a logičké programování
SLD-rezoluce 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(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)
Řeš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 Řudová, Logické programování I, 19. kvetna 2010
146
Řezoluce a logické programování
SLD-rezoluce 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(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.
a optimalizace v kompilátoru mohou způsobit opet odpoved' „yes"
Hana Rudová, Logické programování I, 19. kvetna 2010
146
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 přogřamu
*> p : -q,
ořezání
Hana Rudová, Logické programování I, 19. kvetna 2010
147
Rezoluce a logické programování
Řízení implementače: rez
rez se syntaktičky čhová jako kterýkoliv jiný literál nemá ale žádnou deklarativní sémantiku místo toho mení implementači programu
p : -q, !,v. snažíme se splnit q
pokud uspeji
=> preskočím rez a pokračuji jako by tam rez nebyl
:- 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á, Logičké programování I, 19. kvetna 2010
147
Rezoluče a logičké programování
Řízení implementace: rez
rez 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
=> preskocím rez a pokracuji jako by tam rez nebyl
:- q,!,v.
upnutí
ořezání
pokud ale neuspeji (a tedy i pri backtrackingu) a vracím se pres 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 orezání
Hana Rudová, Logické programování I, 19. kvetna 2010
147
Rezoluce a logické programování
Pŕ íklad: rez
t: -p,r. t: -s.
p : -q(X),!,v,
p : -u,w.
q(a).
q(b).
s.
u.
(D
(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é programovaní I, 19. kvetna 2010
148
Rezoluce a logické programovaní
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, 19. května 2010
149
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
(1)
(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, 19. kvetna 2010
150
Rezoluce a logické programování
Operacní a deklarativní semantika
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 {g}.
1tímto výrazem jsou míneny všečhny číle, pro než zmínený rezoluční dukaz existuje.
Hana Rudová, Logičké programování I, 19. kvetna 2010
152
Sémantiky
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 (G).
1tímto výrazem jsou míneny všechny cíle, pro než zmínený rezolucní dukaz existuje.
iS* Deklarativní sémantika logického programu P ???
Hana Řudová, Logické programování I, 19. kvetna 2010
152
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 ?i: D = Z, a := 1,b := -1,f := " + "
Hana Rudová, Logické programování I, 19. kvetna 2010
153
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 := " + "
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, 19. kvetna 2010
153
Sémantiky
Herbrandovy interpretace
Omezení na obor skládající se ze symbolických výrazu tvorených z predikátových a funkcních symbolu daného jazyka
i* pri zkoumání pravdivosti není nutné uvažovat modely nad všemi interpretacemi
Hana Rudová, Logické programování I, 19. kvetna 2010
154
Sémantiky
Herbrandovy interpretace
Omezení na obor skládající se ze symbolických výrazu tvorených z predikátových a funkcních symbolu daného jazyka
i* pri zkoumání pravdivosti není nutné uvažovat modely nad všemi interpretacemi
Herbrandovo univerzum: množina všech termů bez promenných, které mohou být tvoreny funkcními symboly a konstantami daného jazyka
Herbrandova interpretace: libovolná interpretace, která prirazuje
i* promenným prvky Herbrandova univerza Jť konstantám sebe samé
J* funkcním symbolům funkce, které symbolu f pro argumenty t1, • • • ,tn priradí term
f (ti, • • • ,tn)
M predikátovým symbolum libovolnou funkci z Herbrand. univerza do pravdivostních hodnot
Hana Rudová, Logické programování I, 19. kvetna 2010
154
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é
J* funkčním symbolům funkče, které symbolu f pro argumenty t\, • • • ,tn priradí term
f(t\, • • • ,tn)
M predikátovým symbolum libovolnou funkči z Herbrand. univerza do pravdivostníčh hodnot
& Herbrandův 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, 19. kvetna 2010
154
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
Hana Řudová, Logické programování I, 19. kvetna 2010
155
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, 19. kvetna 2010
155
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(0)). % (1)
1ichy(s(s(X))) :- lichy(X). % (2)
a ?i = 0 není model (1)
Hana Rudová, Logické programování I, 19. kvetna 2010
155
Sémantiky
Specifikace Heřbřandova 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)
a ?i = 0 není model (1)
a 12 = {lichy(s(0))} není model (2)
Hana Rudová, Logické programování I, 19. kvetna 2010
155
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(G)). % (1)
1ichy(s(s(X))) i- 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, 19. kvetna 2010
155
Sémantiky
Spečifikače Herbrandova modelu
C Herbrandovy interpretače mají preddefinovaný význam funktoru a konstant
-í* Pro spečifikači Herbrandovy interpretače tedy stačí zadat relače pro každý predikátový symbol
& Príklad: Herbrandova interpretače a Herbranduv model množiny formulí
1ichy(s(0)). % (1)
1ichy(s(s(X))) :- lichy(X). % (2)
a 11 = 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 e {1, 3, 5, 7,...}} Herbranduv model (1) i (2)
Hana Rudová, Logičké programování I, 19. kvetna 2010
155
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)
a ?i = 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, 7,...}} Herbrandův model (1) i (2)
15 = {lichy(sn(0))\n g N}} Herbrandův model (1) i (2)
Hana Rudová, Logické programování I, 19. kvetna 2010
155
Sémantiky
Príklad: Herbrandovy interpretace
rodic(a,b). rodic(b,c). predek(X,Y) predek(X,Z)
:- rodic(X,Y). :- rodic(X,Y),
predek(Y,Z).
Hana Rudová, Logické programování I, 19. kvetna 2010
156
Sémantiky
Príklad: Herbrandovy interpretače
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í
Hana Rudová, Logičké programování I, 19. kvetna 2010
156
Sémantiky
a operacní sémantika
ii> Je-li S množina programových klauzulí a M libovolná množina Herbrandových modelů S, pak prunik techto modelu je opet Herbrandův model množiny S.
JS> Dusledek:
Existuje nejmenší Herbranduv model množiny S, který znacíme M(S).
Hana Rudová, Logické programování I, 19. kvetna 2010
157
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 prUnik techto modelU 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).
Hana Rudová, Logické programování I, 19. kvetna 2010
157
Sémantiky
a operacní sémantika
ii> Je-li S množina programových klauzulí a M libovolná množina Herbrandových modelů 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).
& 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 (G).
1tímto výrazem jsou míneny všechny cíle, pro než zmínený rezolucní dukaz existuje.
Hana Řudová, Logické programování I, 19. kvetna 2010
157
Sémantiky
a opeřacní sémantika
& Je-li S množina programových klauzulí a M libovolná množina Herbrandových modelu S, pak přůnik techto modelů je opet Herbrandův model množiny S.
JS> Důsledek:
Existuje nejmenší Heřbřandův model množiny S, který znacíme M(S).
£ Deklařativní sémantikou logického programu P rozumíme jeho minimální Herbrandův model M(P).
& Opeřacní 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 důkazem ze vstupní množiny P u {G}.
1tímto výrazem jsou míneny všechny cíle, pro než zmínený rezolucní dukaz existuje.
& Pro libovolný logický program P platí      M(P) = O(P)
Hana Rudová, Logické programování I, 19. kvetna 2010
157
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
J> 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, 19. kvetna 2010
159
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, 19. kvetna 2010
159
Negace v logickém programování
Negativní znalost
JS> logické programy vyjadřují 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ší Herbrandův model: {na(b,a),na(c, b),nad(b,a),nad(c, b),nad(c,a)}
JS> ani program ani model nezahrnují negativní informaci A a není nad c, a není na c
S* i v realite je negativní informace vyjadrena explicitne zrídka, napr. jízdní rád
Hana Rudová, Logické programování I, 19. kvetna 2010
159
Negace v logickém programování
Predpoklad uzavreného sveta
neexistence informace chápána jako opak:
predpoklad uzavrené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, 19. kvetna 2010
160
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, 19. kvetna 2010
160
Negače v logičkém programování
Předpoklad uzavřeného světa
C neexistence informace chápána jako opak:
předpoklad uzavřeného světa (closed world assumption, CWA)
-í* převzato 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 urcit, zda pravidlo CWA je aplikovatelné nebo ne ii> 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, 19. kvetna 2010
160
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)
normální cíl: cíl obsahující i negativní literály
-í* : -nad(c,a), -nad(b,c).
Hana Rudová, Logické programování I, 19. kvetna 2010
161
Negace v logickém programování
Negace jako neúspěch (negation as failure)
slabší verze CWA: definitívne neúspešný (finitely failed) SLD-střom cíle : -A : -A má definitivne (konecne) neúspešný SLD-strom
-A (negation as failure, NF)
M nořmá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)
Hana Rudová, Logické programování I, 19. května 2010 161 Negace v logickém programování
Negace jako neúspěch (negation as failure)
£ slabší verze CWA: definitívne neúspešný (finitely failed) SLD-strom číle : -A : -A má definitívne (konečne) neúspešný SLD-strom
-A (negation as failure, NF)
M normální číl: číl obsahujíčí i negativní literály
-í* :-nad(c,a), -nad(b,c).
-í* rozdíl mezi CWA a NF
-i- program   nad(X,Y) : -nad(X, Y), číl   : -—nad(b,c)
neexistuje odvození číle podle NF, protože SLD-strom : -nad(b,c) je nekonečný A existuje odvození číle podle CWA, protože neexistuje vyvráčení: -nad(b,c)
M CWA i NF jsou nekorektní: A není logičkým dusledkem programu P
& rešení: definovat programy tak, abyjejičh dusledkem byly i negativní literály zúplnení logičkého programu
Hana Rudová, Logičké programování I, 19. kvetna 2010 161 Negače v logičkém programování
Podstata zúplnení logičkého programu
prevod všečh if príkazů 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)).
Hana Rudová, Logičké programování I, 19. kvetna 2010
162
Negače v logičkém programování
Podstata zúplnení logičké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
Hana Rudová, Logičké programování I, 19. kvetna 2010
162
Negače v logičkém programování
Podstata zúplnení logického programu
prevod všech if prí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úplnení: nad(X,Y) — (na(X,Y)) v (na(X,Z),nad(Z,Y)).
& X je nad Y práve tehdy, když alespon jedna z podmínek platí
A tedy pokud žádná z podmínek neplatí, X není nad Y
JS> kombinace klauzulí je možná pouze pokud mají identické hlavy
S> na (c, b). na(b, a).
S* lze psát jako: na(X1,X2) : -Xi = c,X2 = b.
na(X1,X2) : -X1 = b,X2 = a.
-i- zúplnení: na(X1,X2) — (X1 = c,X2 = b) v (X1 = b,X2 = a).
Hana Rudová, Logické programování I, 19. kvetna 2010 162 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) i= P
s do programuje pridána pouze negativní informace
Hana Řudová, Logické programování I, 19. kvetna 2010
163
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) i= P
s do programuje pridána pouze negativní informace
& IFF(P): spojka : - v IF(P) je nahrazena spojkou —
& IF(P): množina všech formulí IF(q,P)
pro všechny predikátové symboly q v programu P
J* Cíl: definovat IF(q,P)
& def(p/n) predikátu p/n je množina všech klauzulí predikátu p/n
Hana Rudová, Logické programování I, 19. kvetna 2010
163
Negace v logickém programování
IF(q, P)
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 označme E(C) výraz 3Yi,Yk(Xi = ti,...,Xn = tn,Li,... ,Lm) kde Yi,...,Yk jsou všechny promenné v C.
Hana Rudová, Logické programování I, 19. kvetna 2010
164
Negace v logickém programování
IF(q, P)
na(Xi,X2) : -SY(Xi = c,X2 = b, f (Y)) v X = 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
kde m > 0, t1,...,tn jsou termy a L1,Lm jsou literály.
Pak oznacme E(C) výraz 3Y1,Yk(X1 = t1,...,Xn = tn,L1,... ,Lm) kde Y1,...,Yk jsou všechny promenné v C.
Necht' def(q/n) = (C1,Cj}.
Pak formuli IF(q,P) získáme následujícím postupem: q(X1, ...,Xn) : -E(C1) v E(C2) v • • • v E(Cj) pro j> 0 a
q(X1,... ,Xn) : - □ pro j = 0 [q/n není v programu P]
Hana Řudová, Logické programování I, 19. kvetna 2010
164
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: Xl = Yl a • • • a Xm = Ym - /(Xi,...,Xm) = f(Yl,...,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(Xif... ,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, 19. kvetna 2010
165
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 \/(—A) je logičkým dusledkem comp(P) (nebo-li comp(P) = \/(—A))
Hana Rudová, Logičké programování I, 19. kvetna 2010
166
Negače v logičkém programování
Kořektnost a úplnost NF přavidla
& Kořektnost NF přavidla: 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) i= V(-A))
JS> Úplnost NF přavidla: 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 dusledkem daného logického programu.
teorém mluví pouze o existenci definitivne neúspešného SLD-stromu
± 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, 19. kvetna 2010
166
Negace 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) i= 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 dusledkem daného logického programu.
teorém mluví pouze o existenci 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)
M Odvození pomocí NF pouze test, nelze konstruovat výslednou substituci
j* v(comp(P) = v(—A))je A všeob. kvantifikováno, v V (—A) nejsou volné promenné
Hana Rudová, Logické programování I, 19. kvetna 2010
166
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á
Hana Rudová, Logické programování I, 19. kvetna 2010
167
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 Jt 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.
Hana Rudová, Logické programování I, 19. května 2010 167 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
C- 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, 19. května 2010 167 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 A 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 S0,...,Sm (St = stratum)
*> p(...) : -      q(...),... g P, p g Sk => q g S0 u ... u Sk p(...) : -      —q(...),... g P, p g Sk => q g S0 u ... u Sk-1
Hana Řudová, Logické programování I, 19. kvetna 2010 167 Negace v logickém programování
Stratifikované programy II
program je m-stratifikovaný <^> m je nejmenší index takový, že So 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.
Jt p : - — p.      nemá Herbrandův model Jt p : - — p.      ale není stratifikovaný
Hana Rudová, Logické programování I, 19. kvetna 2010
168
Negace v logickém programování
Střatifikované přogřamy II
program je m-střatifikovaný <^> m je nejmenší index takový, že So 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ý
& stratifikované programy nemusí mít jedinecný 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, 19. května 2010 168 Negace v logickém programování
SLDNF rezoluče: úspešné 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 dukaz pro C
& Pokud odvození C selže (strom pro C je konečne neúspešný), pak je odvození G (i —C) čelkove úspešné
nahore(X) : -—blokovaný(X). blokovaný(X) : -na(Y,X). na(a, b).
Hana Rudová, Logičké programování I, 19. kvetna 2010
169
Negače v logičkém programování
C NF pravidlo:
-í* Pokud máme negativní podčíl -C v dotazu G, pak hledáme dukaz pro C
& Pokud odvození C selže (strom pro C je konečne neúspešný), pak je odvození G (i -C) čelkove ú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
=> úspěšné odvození
Hana Rudová, Logické programování I, 19. května 2010
169
Negace v logickém programování
SLDNF rezoluce: neúspešné odvození
C NF pravidlo: : - C. má konecne neúspešný SLD-strom
JS> Pokud máme negativní podcíl —C v dotazu G, pak hledáme 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, 19. kvetna 2010
170
Negace v logickém programování
JS> NF pravidlo:
Pokud máme negativní podcíl ->C v dotazu G, pak hledáme důkaz pro C
-i* Pokud existuje vyvrácení C s prázdnou substitucí (strom pro C je konečne ú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, 19. kvetna 2010
170
Negace v logickém programování
SLDNF rezoluce: uvázlé odvození
C NF pravidlo: : - C. má konecne neúspešný SLD-strom
—C
JS> Pokud máme negativní podcí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á, Logické programování I, 19. kvetna 2010
171
Negace v logickém programování
SLDNF rezoluce: uvázlé odvození
C NF pravidlo: : - C. má konecne neúspešný SLD-strom
—C
JS> Pokud máme negativní podcíl — C v dotazu G, pak hledáme dukaz 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).
: -nahore(X).
:- nahore(X).       :- blokovany(X).
blokovany(X). :- na(Y,X).
| [Y/a,X/b]
^ => uvázlé odvození
[X/b]
Hana Řudová, Logické programování I, 19. kvetna 2010 171 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, 19. kvetna 2010
172
Negače v logičké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.
muže být:
2. neúspešné
3. blokované: Gt je negativní (napr. —A)
Hana Rudová, Logičké programování I, 19. kvetna 2010
172
Negače v logičké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, 19. kvetna 2010
173
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
3 nekonecná úroven cíle: blokované SLDNF odvození
Množina SLDNF odvození = {(SLDNF odvození G0) u (SLDNF odvození: -A)} Jr pri odvozování G0 jsme se dostali k cíli -A SLDNF odvození cíle G ?
Hana Rudová, Logické programování I, 19. kvetna 2010
173
Negace v logickém programování
SLDNF řezoluce
P normální program, G0 normální cíl, R selekcní 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í <G0; C0>, ...,Gi   blokováno na —A tj. Gi je tvaru : - L\,..., Lm-i, —A, Lm+i,... ,Ln pak
Hana Rudová, Logické programování I, 19. kvetna 2010
174
Negace v logickém programování
SLDNF rezoluce
P normální program, G0 normální cíl, R selekcní 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í <G0; C0>, ...,Gi   blokováno na —A tj. Gi je tvaru : - Li,..., Lm-i, —A, Lm+i, ...,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, 19. kvetna 2010
174
Negace v logickém programování
SLDNF rezoluče
P normální program, G0 normální číl, R selekční pravidlo:
množina SLDNF odvození a podmnožina neúspešnýčh 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), ...,Gt   blokováno na —A tj. Gt je tvaru : - Li,..., Lm-i, —A, Lm+i, ...,Ln pak
a existuje-li SLDNF odvození: -A (pod R) s prázdnou čílovou substitučí, pak (G0; C0), ...,Gt je neúspešné SLDNF odvození
& je-li každé úplné SLDNF odvození: -A (pod R) neúspešné pak
(G0; C0), . . . , (Gi, £), (: - Ll, . . . , Lm-l, Lm+l, . . . , Ln) je
(úspešné) SLDNF odvození číle G0
e označuje prázdnou čílovou substituči
Hana Rudová, Logičké programování I, 19. kvetna 2010 174 Negače v logičkém programování
Typy SLDNF odvození
Konecné 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 cílovou substitucí
4. blokované: Gt je negativní (—A) a : -A nemá konecnou úroveň.
Hana Rudová, Logické programování I, 19. kvetna 2010
175
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)
Hana Rudová, Logické programování I, 19. kvetna 2010
176
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, 19. kvetna 2010
176
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é)
ú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 Řudová, Logické programování I, 19. kvetna 2010
176
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/
JS> Barták R. Prednáška Omezující podmínky na MFF UK, Praha.
& http://kti.ms.mff.cuni.cz/~bartak/podminky/prednaska.html
SICStus Prolog User's Manual, 2007. Kapitola o CLP(FD).
-i- http://www.fi.muni.cz/~hanka/sicstus/doc/html/
& Príklady v distribuci SICStus Prologu: cca 45 príkladu, zdrojový kód
v lib/sicstus-*/library/clpfd/examples/
Hana Rudová, Logické programování I, 19. května 2010
178
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, 19. kvetna 2010
179
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
ii> Príbuzné prednášky na FI
s PA163 Programování s omezujícími podmínkami
-v http://www.fi.muni.cz/~hanka/cp *> PA167 Rozvrhování
-v http://www.fi.muni.cz/~hanka/rozvrhovani
zahrnuty CP techniky pro rešení rozvrhovacích problému
Hana Rudová, Logické programování I, 19. kvetna 2010
179
Logické programování s omezujícími podmínkami
Historie a současnost
& 1963 interaktivní grafika (Sutherland: Sketchpad)
M Polovina 80. let: logické programování omezujícími podmínkami
& Od 1990: komerCní využití
JS* Už v roce 1996: výnos rádove stovky milionů dolarU
& Aplikace - príklady
a Lufthansa: krátkodobé personální plánování
reakce na zmeny pri doprave (zpoždení letadla, ...) minimalizace zmeny v rozvrhu, minimalizace ceny
J* Nokia: automatická konfigurace sw pro mobilní telefony
Jt Renault: krátkodobé plánování výroby, funkcní od roku 1995
Hana Rudová, Logické programování I, 19. kvetna 2010
180
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 = {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, 19. kvetna 2010
181
Logické programování s omezující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
Príklad:
proměnné:
A,B
-i- domény:
{0,1} pro A
{1,2} pro B
omezení:
nebo
(A,B) g {(0,1),(0,2),(1,2)}
Hana Rudová, Logické programování I, 19. kvetna 2010
181
Logické programování s omezujícími podmínkami
Omezení (constraint)
JS> Dána
a množina (doménových) promenných Y = [yi,... ,yk} *> koneCná množina hodnot (doména) D = [D\,... ,Dk}
Omezení c na Y je podmnožina D\ x ... x Dk
S> omezuje hodnoty, kterýčh mohou promenné nabývat současne
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 y\, ...yk je splneno, pokud pro di g D\, ...dk g Dk platí (d\,... dk) g c
Hana Rudová, Logičké programování I, 19. kvetna 2010
181
Logičké programování s omezujíčí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, 19. kvetna 2010
181
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 splnování podmínek je trojice (X,D,C) (constraint satisfaction problem)
Hana Rudová, Logické programování I, 19. kvetna 2010
182
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 = jxi,... , xn}
it konečná množina hodnot (doména) D = |D1,... ,Dn} it konečná množina omezení C = (c1,..., cm} omezení je definováno na podmnožině X
Problém splnová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, 19. kvetna 2010
182
Logické programování s omezujícími podmínkami
Rešení CSP
■v
Cástecné ohodnocení proměnných (di,dk),k < n
s» některé proměnné mají přiřazenu hodnotu Úplné ohodnocení proměnných (di,dn)
& všechny proměnné mají přiřazenu hodnotu
Hana Rudová, Logické programování I, 19. kvetna 2010
183
Logické programování s omezujícími podmínkami
Řešení CSP
■v
Řástecné ohodnocení přomenných (d1,dk),k < n s» nekteré promenné mají prirazenu hodnotu Úplné ohodnocení přomenných (d1,dn) & všechny promenné mají prirazenu hodnotu Řešení CSP
-fc úplné ohodnocení promenných, které splnuje všechna omezení s (d1dn) g D1 x ... x Dn je řešení (X, D, C) pro každé ci g C na xi1,...xik platí (di1,...dik) g ci
Hana Rudová, Logické programování I, 19. kvetna 2010
183
Logické programování s omezujícími podmínkami
Řešení CSP
■v
Cástecné ohodnocení promenných (di,dk),k < n s* nekteré promenné mají prirazenu hodnotu Úplné ohodnocení promenných (di,dn) & všechny promenné mají prirazenu hodnotu Řešení CSP
-fc úplné ohodnocení promenných, které splnuje všechna omezení s (didn) g Di x ... x Dn je rešení (X, D, C) pro každé ct g C na xti,...xtk platí (dti,...dtk) g ct
Hledáme: jedno nebo
všechna rešení nebo
optimální r ešení (vzhledem k objektivní funkci)
Hana Rudová, Logické programování I, 19. kvetna 2010
183
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í: a11_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á, Logické programování I, 19. kvetna 2010
184
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},...
omezení: 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, 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, 19. kvetna 2010
184
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 Řudová, Logické programování I, 19. kvetna 2010
184
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
všechna rěšění: ještě Jan=6, Pětr=4, Anna=5, Ota=2, Eva=3, Marie=1
optimalizace: ženy učí co nejdří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, 19. kvetna 2010
184
Logické programování s omezujícími podmínkami
Příklad: jednoduchý školní řozvřh
& přomenné: Jan, Petr, ... & 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, Mařie=6
řešení CSP:
Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Marie=1
& všechna řešení: ješte Jan=6, Petř=4, Anna=5, Ota=2, Eva=3, Marie=1
& optimálizace: ženy ucí co nejdríve
Anna+Eva+Marie #= Cena minimalizace hodnoty promenné Cena optimální řešení: Jan=6, Petř=4, Anna=5, Ota=2, Eva=3, Marie=1
Hana Rudová, Logické programování I, 19. kvetna 2010 184 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, 19. kvetna 2010 185 Logické programování s omezujícími podmínkami
CLP(FD) program
& Základní struktura CLP programu
1. definice promenných a jejich domén
2. definice omezení
3. hledání rešení
& (1) a (2) deklarativní cást
Jt modelování problému
a vyjádrení problému splnování podmínek
Hana Rudová, Logické programování I, 19. kvetna 2010 185 Logické programování s omezujícími podmínkami
CLP(FD) program
& Základní struktura CLP programu
1. definiče promennýčh ajejičh domén
2. definiče omezení
3. hledání r ešení
& (1) a (2) deklarativní část
Jt modelování problému
a vyjád rení problému splnování podmínek
& (3) r ídíčí část
& prohledávání stavového prostoru r ešení
Jt pročedura pro hledání r ešení (enumerači) se nazývá labeling
s> umožní nalézt jedno, všečhna nebo optimální rešení
Hana Rudová, Logičké programování I, 19. kvetna 2010 185 Logičké programování s omezujíčími podmínkami
Kód CLP(FD) programu
% základní struktura CLP programu so1ve( Variables ) :-
dec1are_variab1es( Variables ), domain([Jan],3,6], ...
Hana Rudová, Logické programování I, 19. května 2010
186
Logické programování s omezujícími podmínkami
Kód CLPCFD) přogřamu
% základní struktura CLP programu
so1ve( Variables ) :-
dec1are_variab1es( Variables ), post_constraints( Variables ),
domain([Jan],3,6], ... a11_distinct([Jan,Petr,...])
Hana Rudová, Logické programování I, 19. kvetna 2010
186
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 ).
Hana Rudová, Logické programování I, 19. května 2010
186
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( Variab1es ), a11_distinct([Jan,Petr,...])
1abe1ing( Variab1es ).
% triviální labeling 1abe1ing( [] ). 1abe1ing( [Var|Rest]   ) :-
fd_min(Var,Min),
( Var#=Min, 1abe1ing( Rest )
% výběr nejmenší hodnoty z domény
Hana Rudová, Logické programování I, 19. kvetna 2010
186
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á, Logické programování I, 19. kvetna 2010 186 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 různá písmena mají prirazena různé čifry s S a M nejsou 0
Hana Rudová, Logičké programování I, 19. kvetna 2010
187
Logičké programování s omezujíčími podmínkami
Príklad: algebrogram
Prirad'te cifry 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é cifry s S a M nejsou 0
domain([E,N,D,O,R,Y], 0, 9), domain([S,M],1,9)
Hana Rudová, Logické programování I, 19. kvetna 2010
187
Logické programování s omezujícími podmínkami
Príklad: algebrogram
Prirad'te cifry 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é cifry 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
Hana Rudová, Logické programování I, 19. kvetna 2010
187
Logické programování s omezujícími podmínkami
Príklad: algebrogram
Prirad'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í prirazena různé cifry 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á, Logické programování I, 19. kvetna 2010
187
Logické programování s omezujícími podmínkami
Príklad: algebrogram
Prirad'te cifry 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é cifry 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] )
1abe1ing( [S,E,N,D,M,0,R,Y] )
Hana Rudová, Logické programování I, 19. kvetna 2010
187
Logické programování s omezujícími podmínkami
Od LP k CLP I.
-í* CLP: rozšír ení 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
Hana Rudová, Logické programování I, 19. kvetna 2010
188
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
C Cíl
± využít syntaktické a výrazové prednosti LP dosáhnout vetší efektivity
Hana Rudová, Logické programování I, 19. kvetna 2010
188
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
-i* Unifikace v LP je nahrazena splnováním podmínek
J* unifikace se chápe jako jedna z podmínek A = B
3 A #< B,   A in 0..9,   domain([A,B],0,9), all_distinct([A,B,C])
Hana Řudová, Logické programování I, 19. kvetna 2010 188 Logické programování s omezujícími podmínkami
Od LP k CLP II.
Pro ř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
Hana Rudová, Logické programování I, 19. kvetna 2010
189
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
Hana Rudová, Logické programování I, 19. května 2010
189
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, 19. kvetna 2010
189
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
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, 19. kvetna 2010 189 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)
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 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, 19. kvetna 2010
189
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
Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky 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, 19. kvetna 2010
189
Logické programování s omezujícími podmínkami
Od LP k CLP II.
JS> Pro rešení podmínek se používají konzistenční 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
iS> Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky JS> Prohledávání doplneno konzistenční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 it 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, 19. kvetna 2010 189 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 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 Jt 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, 19. kvetna 2010 189 Logické programování s omezujícími podmínkami
Syntaxe CLP
Výber jazyka omezení CLP klauzule
jako LP klauzule, ale její telo muže obsahovat omezení daného jazyka
p(X,Y)  :- X #< Y+1, q(X), r(X,Y,Z).
Rezolucní krok v LP
A kontrola existence nejobecnejšího unifikátoru (MGU) mezi cílem a hlavou
£ Krok odvození v CLP také zahrnuje
S kontrola konzistence aktuální množiny omezení s omezeními v tele klauzule
=> Vyvolání dvou rešiců: unifikace + rešic omezení
Hana Rudová, Logické programování I, 19. kvetna 2010
190
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, 19. kvetna 2010
191
Logické programování s omezujícími podmínkami
CLP(FD) v SICStus Prologu
Nejpoužívanější systémy a jazyky pro CP
Swedish Institute of Computer Science: SICStus Prolog 1985
i* silná CLP(FD) knihovna, komerční i akademické použití
Hana Rudová, Logické programování I, 19. kvetna 2010
193
CLP(FD) v SICStus Prologu
Nejpoužívanejší systémy a jazyky pro CP
Swedish Institute of Computer Science: SICStus Prolog 1985
i* silná CLP(FD) knihovna, komercní i akademické použití
B IC-PARC, Imperial College London, Cisco Systems: ECL*PSe 1984
-i- š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, 19. kvetna 2010
193
CLP(FD) v SICStus Prologu
Nejpoužívanejší systémy a jazyky pro CP
Swedish Institute of Computer Sčienče: SICStus Prolog 1985
it silná CLP(FD) knihovna, komercní i akademické použití
B IC-PARC, Imperial College London, Cisčo Systems: ECL*PSe 1984
-i- široké možnosti kooperace mezi různý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
JS> IBM ILOG CP Optimizer, omezujíčí podmínky v C++ 1987
it špickový komercní sw, vznikl ve Francii, nedávno zakoupen IBM it nyní nove volne dostupný pro akademické použití
it implementace podmínek založena na objektove orientovaném programování
Hana Rudová, Logické programování I, 19. kvetna 2010 193 CLP(FD) v SICStus Prologu
Nejpoužívanejší systémy a jazyky pro CP
Swedish Institute of Computer Science: SICStus Prolog 1985
it silná CLPCFD) knihovna, komercní i akademické použití
B 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
JS> IBM ILOG CP Optimizer, omezující podmínky v C++ 1987
it špickový komercní sw, vznikl ve Francii, nedávno zakoupen IBM it nyní nove volne dostupný pro akademické použití
it implementace podmínek založena na objektove orientovaném programování
JS> http://www.fi.muni.ez/~hanka/bookmarks.html#tools
cca 50 odkazů na nejmznejší systémy založené na Prologu, C++, Java, Lisp, ...
Hana Rudová, Logické programování I, 19. kvetna 2010 193 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é
a stejné/podobné vestavené predikáty existují i jinde s> CLP knihovny v SWI Prologu i ECLiPSe se liší
Hana Rudová, Logické programování I, 19. kvetna 2010
194
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
Hana Rudová, Logické programování I, 19. kvetna 2010
195
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)
Hana Rudová, Logické programování I, 19. kvetna 2010
195
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)
& Doména reprezentována jako posloupnost intervalů celých ccí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, 19. kvetna 2010
195
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)
& 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)
Hana Rudová, Logické programování I, 19. kvetna 2010
195
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
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) \/ 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á, Logičké programování I, 19. kvetna 2010
195
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ů 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 Řudová, Logické programování I, 19. kvetna 2010
195
CLP(FD) v SICStus Prologu
Příslušnost k doméne: FDSet termy
C FDSet term: reprezentace závislá na implementaci
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, 19. kvetna 2010
196
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, 19. kvetna 2010
196
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)
& FDSet termy predstavují nízko-úrovnovou implementaci
& FDSet termy nedoporuceny v programech
-k používat pouze predikáty pro manipulaci s nimi -i- omezit použití A in_set [[1|2],[6|9]]
& Range termy preferovány
Hana Rudová, Logické programování I, 19. kvetna 2010 196 CLP(FD) v SICStus Prologu
Další fd_... predikáty
fdset_to_1ist(+FDset, -List) vrací do seznamu prvky FDset & 1ist_to_fdset(+List, -FDset) vrací FDset odpovídající seznamu
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é
Hana Rudová, Logické programování I, 19. kvetna 2010 197 CLP(FD) v SICStus Prologu
Další fd_... predikáty
fdset_to_list(+FDset, -List) vrací do seznamu prvky FDset & list_to_fdset(+List, -FDset) vrací FDset odpovídající seznamu
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ýpoctu: pouze aktivní omezení, i odvozená aktivní omezení
Hana Řudová, Logické programování I, 19. kvetna 2010 197 CLP(FD) v SICStus Prologu
Aritmetická omezení
J* Expr RelOp Expr RelOp -> #= | #\= | #< | #=< | #> | #>=
A A + B #=< 3, A #\= (C - 4) * (D - 5), A/2 #= 4
Jt POZOR: neplést #=< a #>= s operátory pro implikaci:   #<= #=>
Hana Rudová, Logické programování I, 19. kvetna 2010
198
CLP(FD) v SICStus Prologu
Aritmetická 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)
Hana Rudová, Logické programování I, 19. kvetna 2010
198
CLP(FD) v SICStus Prologu
Aritmetická omezení
J* Expr RelOp Expr RelOp -> #= | #\= | #< | #=< | #> | #>=
A A + B #=< 3, A #\= (C - 4) * ( D - 5), A/2 #= 4
it 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) it Variables i Suma musí být doménové promenné nebo celá císla
sea1ar_produet(Coeffs,Variab1es,Re1Op,Sea1arProduet)
M domain([A,B,C,F],1,6), sea1ar_produet( [1,2,3],[A,B,C],#= ,F)
it Variab1es i Va1ue musí být doménové promenné nebo konstanty, Coeffs jsou celá císla
it POZOR na po radí argumentu, nejprve jsou celocíselné koeficienty, pak dom. promenné
3 sea1ar_produet(Coeffs, Variab1es, #= , Va1ue, [eonsisteney(domain)])
silnejší typ konzistence
POZOR: domény musí mít konecné hranice
Hana Rudová, Logické programování I, 19. kvetna 2010 198 CLP(FD) v SICStus Prologu
Výroková omezení, reifikace
Výroková omezení pozor na efektivitu
Jt \# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6
Hana Rudová, Logické programování I, 19. května 2010
199
CLP(FD) v SICStus Prologu
Výroková omezení, reifikace
M Výroková omezení
Jt \# negače, #/\ konjunkče, #\/ 3 x #> 4 #/\ y #< 6 p ríklad:
A#\= 3, A#\= 4
A in (inf..2)\/ (5..sup)
pozor na efektivitu
disjunkče, #<=> ekvivalenče, ...
A#\= 3 #/\ A#\= 4 A#=1 #\/ A#=2
A in (inf..2)\/ (5..sup) A in inf..sup
Hana Rudová, Logičké programování I, 19. kvetna 2010
199
CLP(FD) v SICStus Prologu
Výroková omezení, reifikace
M Výroková omezení pozor na efektivitu
Jt \# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6 Jt príklad:
A#\= 3, A#\= 4 A#\= 3 #/\ A#\= 4 A#=1 #\/ A#=2
A in (inf..2)\/ (5..sup) A in (inf..2)\/ (5..sup) A in inf..sup tj. propagace disjunkce A#=1 #\/ A#=2 je p ríliš slabá (propagacní algoritmy p r íliš obecné)
Hana Rudová, Logické programování I, 19. kvetna 2010
199
CLP(FD) v SICStus Prologu
Výroková omezení, reifikace
M Výroková omezení pozor na efektivitu
it \# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6 it príklad:
A#\= 3, A#\= 4 A#\= 3 #/\ A#\= 4 A#=1 #\/ A#=2
A in (inf..2)\/ (5..sup) A in (inf..2)\/ (5..sup) A in inf..sup
tj. propagace disjunkce A#=1 #\/ A#=2 je príliš slabá (propagacní algoritmy príliš obecné)
& Reifikace pozor na efektivitu
Jt Constraint #<=> Bool
Bool in 0..1 v závislosti na tom, zda je Constraint splnen
A príklad: A in 1..10 #<=> Bool
Hana Rudová, Logické programování I, 19. kvetna 2010
199
CLP(FD) v SICStus Prologu
Výroková omezení, reifikače
M Výroková omezení pozor na efektivitu
\# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6
príklad:
A#\= 3, A#\= 4 A#\= 3 #/\ A#\= 4 A#=1 #\/ A#=2
A in (inf..2)\/ (5..sup) A in (inf..2)\/ (5..sup) A in inf..sup
tj. propagace disjunkce A#=1 #\/ A#=2 je príliš slabá (propagacní algoritmy príliš obecné)
& Reifikače pozor na efektivitu
Constraint #<=> Bool
Bool in 0..1 v závislosti na tom, zda je Constraint splnen A príklad: A in 1..10 #<=> Bool
-i- za predpokladu X in 3..10, Y in 1..4, Bool in 0..1
porovnej rozdíl mezi   X#<Y X#<Y #<=> Bool
Hana Rudová, Logické programování I, 19. kvetna 2010
199
CLP(FD) v SICStus Prologu
Výroková omezení, reifikače
M Výroková omezení pozor na efektivitu
it \# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6 it príklad:
A#\= 3, A#\= 4 A#\= 3 #/\ A#\= 4 A#=1 #\/ A#=2
A in (inf..2)\/ (5..sup) A in (inf..2)\/ (5..sup) A in inf..sup
tj. propagace disjunkce A#=1 #\/ A#=2 je príliš slabá (propagacní algoritmy príliš obecné)
iS» Reifikače pozor na efektivitu
it Constraint #<=> Bool
Bool in 0..1 v závislosti na tom, zda je Constraint splnen
A príklad: A in 1..10 #<=> Bool
it za predpokladu X in 3..10, Y in 1..4, Bool in 0..1
porovnej rozdíl mezi   X#<Y X#<Y #<=> Bool
X= 3, Y = 4 X in 3..10, Y in 1..4, Bool in 0..1
Hana Rudová, Logické programování I, 19. kvetna 2010 199 CLP(FD) v SICStus Prologu
Príklad: reifikace
C- Presne N prvků v seznamu S je rovno X: exact1y(X,S,N)
Hana Rudová, Logičké programování I, 19. kvetna 2010
200
CLP(FD) v SICStus Prologu
Príklad: reifikace
Presne N prvků v seznamu S je rovno X: exact1y(X,S,N) exact1y(_,  [], 0).
Hana Rudová, Logické programování I, 19. kvetna 2010
200
CLP(FD) v SICStus Prologu
Pr íklad: reifikace
Pr esne N prvků v seznamu S je rovno X: exact1y(X,S,N)
exact1y(_,  [], 0). exact1y(X,  [Y|L], N) :-
X #= Y #<=> B, % reifikace
Hana Rudová, Logické programování I, 19. kvetna 2010
200
CLP(FD) v SICStus Prologu
Príklad: reifikace
Presne N prvků v seznamu S je rovno X: exact1y(X,S,N)
exact1y(_,  [], 0).
exact1y(X,  [Y|L], N) :-X #= Y #<=> B, N #= M+B, exactly(X, L, M).
% reifikace
% doménová promenná místo akumulátoru
Hana Rudová, Logické programování I, 19. kvetna 2010
200
CLP(FD) v SICStus Prologu
Príklad: reifikace
Presne N prvků v seznamu S je rovno X: exact1y(X,S,N)
exact1y(_,  [], 0).
exact1y(X,  [Y|L], N) :-X #= Y #<=> B, N #= M+B, exactly(X, L, M).
% reifikace
% doménová promenná místo akumulátoru
| ?- domain([A,B,C,D,E,N],1,2), exact1y(1,[A,B,C,D,E],N),
Hana Řudová, Logické programování I, 19. kvetna 2010
200
CLP(FD) v SICStus Prologu
Príklad: reifikace
Presne N prvků v seznamu S je rovno X: exact1y(X,S,N)
exact1y(_,  [], 0).
exact1y(X,  [Y|L], N) :-X #= Y #<=> B, N #= M+B, exactly(X, L, M).
% reifikace
% doménová promenná místo akumulátoru
| ?- domain([A,B,C,D,E,N],1,2), exact1y(1,[A,B,C,D,E],N),A#< 2,
Hana Rudová, Logické programování I, 19. kvetna 2010
200
CLP(FD) v SICStus Prologu
Príklad: reifikace
Presne N prvků v seznamu S je rovno X: exact1y(X,S,N)
exact1y(_,  [], 0).
exact1y(X,  [Y|L], N) :-X #= Y #<=> B, N #= M+B, exactly(X, L, M).
% reifikace
% doménová promenná místo akumulátoru
| ?- domain([A,B,C,D,E,N],1,2), exact1y(1,[A,B,C,D,E],N),A#< 2,B#< 2.
Hana Rudová, Logické programování I, 19. kvetna 2010
200
CLP(FD) v SICStus Prologu
Příklad: reifikace
C- Presne N prvků v seznamu S je rovno X: exact1y(X,S,N)
exact1y(_,  [], 0).
exact1y(X,  [Y|L], N) :-
X #= Y #<=> B, % reifikace
N #= M+B, % doménová promenná místo akumulátoru
exactly(X, L, M).
| ?- domain([A,B,C,D,E,N],1,2), exact1y(1,[A,B,C,D,E],N),A#< 2,B#< 2. A = 1, B = 1, C = 2, D = 2, E = 2, N = 2
Hana Rudová, Logické programování I, 19. kvetna 2010
200
CLP(FD) v SICStus Prologu
Príklad: reifikace
C- Presne N prvků v seznamu S je rovno X: exact1y(X,S,N)
exact1y(_,  [], 0).
exact1y(X,  [Y|L], N) :-
X #= Y #<=> B, % reifikace
N #= M+B, % doménová promenná místo akumulátoru
exactly(X, L, M).
| ?- domain([A,B,C,D,E,N],1,2), exact1y(1,[A,B,C,D,E],N),A#< 2,B#< 2. A = 1, B = 1, C = 2, D = 2, E = 2, N = 2
-í* Vyzkoušejte si
M greaters(X,S,N): presne N prvku v seznamu S je vetší než X ± at1east(X,S,N): alespon N prvku v seznamu S je rovno X A atmost(X,S,N): nejvýše N prvků v seznamu S je rovno X
Hana Řudová, Logické programování I, 19. kvetna 2010
200
CLP(FD) v SICStus Prologu
Základní globální omezení
a11_distinct(List) M všechny promenné mzné
cumu1ative(...), cumu1atives(...)
-i- disjunktivní a kumulativní rozvrhování
Hana Rudová, Logické programování I, 19. kvetna 2010
201
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, 19. kvetna 2010
202
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, 19. kvetna 2010
202
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
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, 19. kvetna 2010
202
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
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
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, 19. kvetna 2010
202
CLP(FD) v SICStus Prologu
Disjunktivní rozvrhování (unární zdroj)
-í* eumu1ative([task(Start, Duration, End, 1, Id) | Tasks])
-í* 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 r ekrývaly
Hana Rudová, Logické programování I, 19. kvetna 2010
203
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
it príklad s konstantami: cumulative([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, 19. kvetna 2010
203
CLP(FD) v SICStus Prologu
Disjunktivní rozvrhování (unární zdroj)
-í* cumu1ative([task(Start, Duration, End, 1, Id) | Tasks])
-í* 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 r ekrývaly
Jt p r íklad s konstantami: cumu1ative([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 r íklad: vytvo r ení rozvrhu, za p r edpokladu, že doba trvání hodin není stejná
Hana Rudová, Logické programování I, 19. kvetna 2010
203
CLP(FD) v SICStus Prologu
Disjunktivní rozvrhování (unární zdroj)
-í* cumulative([task(Start, Duration, End, 1, Id) | Tasks])
-í* 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
it 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 ó
± příklad: vytvoření rozvrhu, za předpokladu, že doba trvání hodin není stejná JanE#= Jan+1, PetrE#= Petr+1, AnnaE#= Anna+2,
cumulative(task(Jan,1,JanE,1,1),task(Petr,1,PetrE,1,2),task(Anna,1,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, 19. kvetna 2010
203
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, 19. kvetna 2010
204
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 časem (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, 19. kvetna 2010 ^  204  ^ ^ ° u CLP(FD) v SICStus Prologu
Kumulativní rozvrhování s více zdroji
Rozvržení úloh tak, aby se neprekrývaly a daná kapačita zdrojů nebyla prekročena (limit zdroje čhá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 končovým časem (Start,End), dobou trvání (nezáporné Duration), požadovanou kapačitou zdroje (Demand) a požadovaným typem zdroje (MachineId)
Zdroje zadány identifikátorem (Id) a kapačitou (Limit)
Hana Rudová, Logičké programování I, 19. kvetna 2010
205
CLP(FD) v SICStus Prologu
Kumulativní rozvrhování s více zdroji
& Rozvržení úloh tak, aby se neprekrývaly a daná kapacita zdroju nebyla prekrocena (limit zdroje chápán jako horní mez - bound(upper))
& cumu1atives([task(Start,Duration,End,Demand,Machineld)|Tasks],
[machine(Id,Limit)|Machines],[bound(upper)])
& Úlohy zadány startovním a koncovým ccasem (Start,End), dobou trvání (nezáporné Duration), požadovanou kapacitou zdroje (Demand) a požadovaným typem zdroje (Machineld)
JS> Zdroje zadány identifikátorem (Id) a kapacitou (Limit)
M Príklad:
?- domain([B,C],1,2),
cumu1atives([task(Q,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 Rudová, Logické programování I, 19. kvetna 2010 205 CLP(FD) v SICStus Prologu
Věstavěné prědikáty pro laběling
Instanciace promenné Variable hodnotami vjejí doméne indomain( Variable )
hodnoty jsou instanciovány pri backtrackingu ve vzrůstajícím poradí
?- X in 4..5, indomain(X). X = 4 ? ; X = 5 ?
Hana Rudová, Logické programování I, 19. kvetna 2010
206
CLP(FD) v SICStus Prologu
Vestavěné predikáty pro labeling
Instanciace promenné Variab1e hodnotami vjejí 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, 19. kvetna 2010
206
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, 19. května 2010 206
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, 19. kvetna 2010
207
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 UrCují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),
( Var #= Value, labeling( Rest )
Hana Rudová, Logické programování I, 19. kvetna 2010
207
CLP(FD) v SICStus Prologu
Usporádání hodnot a proměnných
Pri prohledávání je rozhodující usporádání hodnot a promenných Urcujíje heuristiky výberu hodnot a výberu promenných
labelingC [] )■ labelingC Variables   ) :-
se1ect_variab1e(Variab1es,Var,Rest),
se1ect_va1ue(Var,Va1ue),
C Var #= Value, labelingC Rest )
>
Var #\= Value , % nemusí dojít k instanciaci Var
labelingC Variables )   % proto pokracujeme se všemi promennými vcetne Var
Hana Rudová, Logické programování I, 19. kvetna 2G1G
2G7
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 proměnných Urcujíje heuristiky výběru hodnot a výběru proměnný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
-í* Statické uspořádání: urceno už p red prohledáváním JS> Dynamické uspo rádání: pocítá se behem prohledávání
Hana Rudová, Logické programování I, 19. kvetna 2010 207 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, 19. kvetna 2010
208
CLP(FD) v SICStus Prologu
Výber hodnoty
JS> Obecný princip výberu hodnoty: první úspech (succeed first)
Jt volíme poradí tak, abychom výber nemuseli opakovat
it ?- 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, 19. kvetna 2010
208
CLP(FD) v SICStus Prologu
Výběr hodnoty
JS> Obecný princip výběru hodnoty: první úspěch (succeed first)
& volíme poradí 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
& Parametry labeling/2 ovlivnující výber hodnoty    pr. labeling([down], Vars)
-i- up: doména procházena ve vzrůstajícím poradí (default) it down: doména procházena v klesajícím poradí
Hana Rudová, Logické programování I, 19. kvetna 2010
208
CLP(FD) v SICStus Prologu
Výber hodnoty
JS> Obecný princip výberu hodnoty: první úspech (succeed first)
it volíme po radí tak, abychom výber nemuseli opakovat
it ľ- domain([A,B,C],l,2), A#=B+C. optimální výber A=2,B=1,C=1 je bez backtrackingu
ü> Parametry 1abe1ing/2 ovlivnující výber hodnoty    pr . 1abe1ing([down], Vars)
it up: doména procházena ve vzrůstajícím po radí (default) it down: doména procházena v klesajícím po radí
Parametry 1abe1ing/2 rídící, jak je výber hodnoty realizován
step: volba mezi X #= M, X #\= M (default)
viz d r ívejší p r íklad u "Uspo rádání hodnot a promenných" it enum: vícenásobná volba mezi všemi hodnotami v doméne
podobne jako p r i indomain/1 it bisect: volba mezi X #=< Mid, X #> Mid
vjednom kroku labelingu nedochází nutne k instanciaci promenné
Hana Rudová, Logické programování I, 19. kvetna 2G1G 2G8 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 A výbereme promennou s nejmenší doménou ?- domain([A,B,C],1,3), A#<3, A#=B+C.
Hana Rudová, Logické programování I, 19. kvetna 2010
209
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 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
Hana Řudová, Logické programování I, 19. kvetna 2010
209
CLP(FD) v SICStus Prologu
Výber promenné
Obečný prinčip 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
J* ?- domain([A,B,C],1,3), A#<3, A#=B+C. nejlépe je začít s výberem A
Parametry labeling/2 ovlivnujíčí výber promenné
-i- leftmost: nejlevejší (default)
M ff: s (1) nejmenší velikostí domény fd_size(Var,Size) (2) (pokud s nejmenší velikostí domény víče, tak) nejlevejší z ničh
Hana Rudová, Logičké programování I, 19. kvetna 2010
209
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 nějměnší doménou
?- domain([A,B,C],1,3), A#<3, A#=B+C. nejlépe je zaCít s výberem A
& Parametry labeling/2 ovlivnující výber promenné
-i- leftmost: 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
-4» 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, 19. kvetna 2010 209 CLP(FD) v SICStus Prologu
reseni
(predpokládejme minimalizaci)
JS> Parametry labeling/2 pro optimalizaci: minimize(F)/maximize(F)

A Cena #= A+B+C, 1abe1ing([minimize(Cena)], [A,B,C])
-i- uvažujeme nejhorší možnou cenu r ešení UB (nap r . cena už nalezeného rešení)
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
ü> Metoda větví a mezí (branch&bound)
branch_and_bound(Vars, Cost)
Hana Rudová, Logické programování I, 19. kvetna 2010
2lG
CLP(FD) v SICStus Prologu
Hlědání optimálního rěšění
(prědpokládějmě minimalizaci)
JS> Parametry labeling/2 pro optimalizaci: minimize(F)/maxirrrize(F)
A Cena #= A+B+C, labeling([minimize(Cena)], [A,B,C])
Mětoda větví a mězí (branch&bound) branch_and_bound(Vars, Cost)
Jt uvažujeme nejhorší možnou cenu r ešení UB (nap r . cena už nalezeného rešení)
& 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
£ Iniciálne je Bound je p r edem známá nejhorší cena (nap r . krajní hodnota v doméne)
branch_and_bound( Bound, Vars, Cost ) % triviální implementace
Cost #< Bound,
findall( Vars-Cost, (labeling( Vars ),  ! ), [ Solution-FoundCost ]), !, asserta( solution( Solution, FoundCost ) ), branch_and_bound( FoundCost, Vars, Cost ). branch_and_bound( _, Vars, Cost )      solution( Vars, Cost ), !.
Hana Rudová, Logické programování I, 19. kvetna 2010 210 CLP(FD) v SICStus Prologu
Hledání optimálního řešení
(předpokládejme minimalizaci)
JS> Parametry labeling/2 pro optimalizaci: minimize(F)/maximize(F)
A Cena #= A+B+C, 1abe1ing([minimize(Cena)], [A,B,C])
Metoda vetví a mezí (branch&bound) branch_and_bound(Vars, Cost)
uvažujeme nejhorší možnou cenu r ešení UB (nap r . cena už nalezeného rešení)
& 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
£ Iniciálne je Bound je p r edem známá nejhorší cena (nap r . krajní hodnota v doméne)
branch_and_bound( Bound, Vars, Cost ) :- % triviální implementace
Cost #< Bound,
finda11( Vars-Cost, (1abe1ing( Vars ),  ! ), [ Solution-FoundCost ]), !, asserta( so1ution( So1ution, FoundCost ) ), branch_and_bound( FoundCost, Vars, Cost ). branch_and_bound( _, Vars, Cost ) :- so1ution( Vars, Cost ), !.
Hana Rudová, Logické programování I, 19. kvetna 2010 210 CLP(FD) v SICStus Prologu
Algoritmy pro rešení problému splnování podmínek (CSP)
Grafová reprezentace CSP
& Reprezentace podmínek
& intenzionální (matematická/logická formule)
J* extenzionální (výcet k-tic kompatibilních hodnot, 0-1 matice)
Hana Rudová, Logické programování I, 19. kvetna 2010
212
Algoritmy pro CSP
Grafová reprezentace CSP
Reprezentace podmínek
Jt intenzionální (matematičká/logičká formule)
J* extenzionální (výčet k-tič kompatibilníčh hodnot, 0-1 matiče)
Graf: vrčholy, hrany (hrana spojuje dva vrčholy) Hypergraf: vrčholy, hrany (hrana spojuje množinu vrčholu) Reprezentače CSP pomočí hypergrafu podmínek
Jt vrčhol = promenná, hyperhrana = podmínka
Hana Rudová, Logičké programování I, 19. kvetna 2010
212
Algoritmy pro CSP
Grafová reprezentace CSP
Reprezentace podmínek
& intenzionální (matematická/logická formule)
J* extenzionální (výCet k-tic kompatibilních hodnot, 0-1 matice)
Graf: vrcholy, hrany (hrana spojuje dva vrcholy) Hypergraf: vrcholy, hrany (hrana spojuje množinu vrcholU) Reprezentace CSP pomocí hypergrafu podmínek
vrchol = promenná, hyperhrana = podmínka
Cl
Príklad
promenné x1,...,x6 s doménou {0,1} omezení c1 : x1 + x2 + x6 = 1
c2: x1 - x3 + x4 = 1 c3 : x4 + x5 - x6 > 0 c4: x2 + x5 - x6 = 0
Hana Rudová, Logické programování I, 19. kvetna 2010
212
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, 19. kvetna 2010
213
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, stačí graf (podmínka spojuje pouze dva vrčholy)
& Každý CSP lze transformovat na "korespondující" binární CSP
ii> Výhody a nevýhody binarizače
3 získáváme unifikovaný tvar CSP problému, rada algoritmu navržena pro binární CSP Jt bohužel ale značné zvetšení velikosti problému
Hana Rudová, Logičké programování I, 19. kvetna 2010
213
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)
& Každý CSP lze transformovat na "korespondující" binární CSP
ii> Výhody a nevýhody binarizace
3 získáváme unifikovaný tvar CSP problému, rada algoritmu navržena pro binární CSP Jt bohužel ale znacné zvetšení velikosti problému
JS> Nebinární podmínky
A složitejší propagacní algoritmy
Jt lze využít jejich sémantiky pro lepší propagaci
X p r íklad: all_different vs. množina binárních nerovností
Hana Rudová, Logické programování I, 19. kvetna 2010 213 Algoritmy pro CSP
Vrcholová a hranová konzistence
iS> Vrcholová konzistence (node consistency) NC
Jt každá hodnota z aktuální domény Vi proměnné splňuje všechny unární podmínky s proměnnou Vi
Hana Rudová, Logické programování I, 19. května 2010
214
Algoritmy pro CSP
Vrcholová a hranová konzistence
& Vrcholová konzistence (node consistency) NC
Jt každá hodnota z aktuální domény Ví proměnné spinuje všechny unární podmínky s proměnnou Ví
& Hranová konzistence (arc consistency) AC pro binární CSP
J* hrana (Ví,Vj) jě hranově konzistentní, právě když
pro každou hodnotu x z aktuální domény Dí ěxistujě hodnota y tak, žě ohodnocění [Ví = x,Vj = y] spinujě všěchny binární podmínky nad Ví,Vj.
Hana Rudová, Logické programování I, 19. května 2010
214
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<B
1..5I B   A I 3..4
A<B
_^
1..5 I B   A I 3..4
A<B
_^
4.. 5 B
konzistence (A,B)     konzistence (A,B) i (B,A)
Hana Rudová, Logické programování I, 19. kvetna 2010
214
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<B
1..5I B   A I 3..4
A<B
_^
1..5 I B   A I 3..4
A<B
_^
4.. 5 B
konzistence (A,B)     konzistence (A,B) i (B,A)
CSP je hranove konzistentní, práve když
jsou všechny jeho hrany (v obou smerech) hranove konzistentní
Hana Rudová, Logické programování I, 19. kvetna 2010
214
Algoritmy pro CSP
Algoritmus revize hrany
& Jak udělat hranu (Vi,Vj) hranově konzistentní?
iS> Z domény Di vyradím takové hodnoty x, ktěré nějsou konzistěntní s aktuální doménou Dj (pro x něěxistujě žádá hodnoty y v Dj tak, aby ohodnocění Vi = x a Vj = y splnovalo všěchny binární podmínky mězi Vi a Vj)
Hana Rudová, Logické programování I, 19. května 2010
215
Algoritmy pro CSP
Algoritmus rěvizě 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
Hana Rudová, Logické programování I, 19. kvetna 2010
215
AlgoritmyproCSP
Algoritmus revize hrany
& Jak udelat hranu (Vi,Vj) hranove 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 splnovalo všechny binární podmínky mezi Vl a Vj)
JS> 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
M domain([Vi,V2],2,4), Vi#< V2
Hana Rudová, Logické programování I, 19. kvetna 2010
215
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, V2],2,4), Vi#< V2     revise((1,2)) smaže 4 z Di,
Hana Rudová, Logické programování I, 19. kvetna 2010
215
Algoritmy pro CSP
Algoritmus rěvizě hrany
& Jak udělat hranu (Ví,Vj) hranově konzistěntní?
-í* Z domény Dí vyradím takové hodnoty x, ktěré nějsou konzistěntní s aktuální doménou Dj (pro x něěxistujě žádá hodnoty y v Dj tak, aby ohodnocění Ví = x a Vj = y splnovalo všěchny binární podmínky mězi Ví a Vj)
& procedure revise((í,j)) Deleted := false for v x in Dí do
if neexistuje y g Dj takové, že (x,y) je konzistentní then Dí := Dí -  {x} Deleted := true end if return Deleted end revise
JS> domain([Vi, V2],2,4), Vi#< V2     revise((1,2)) smažě 4 z Di,D2 sě nězmění
Hana Rudová, Logické programování I, 19. května 2010
215
Algoritmy pro CSP
Dosažení hranové konzistence problému
JS> Jak udělat CSP hranově konzistěntní?
Jt rěvizě jě pot r ěba opakovat, dokud sě mění doména nějaké proměnné s> ěfěktivnější: opakování rěvizí můžěmě dělat pomocí fronty
pridávámě do ní hrany, jějichž konzistěncě mohla být narušěna změnšěním domény
Hana Rudová, Logické programování I, 19. května 2010
216
Algoritmy pro CSP
Dosažení hranové konzistence problému
Jak udělat CSP hranově konzistentní?
a revize je potreba opakovat, dokud se mění doména nějaké proměnné a 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)
príklad: Vk < Vm, (VkVm): (3..7,1U5) (m>k) (3..7,4..5) (k^) (3..4,4..5) (m±k)
Hana Rudová, Logické programování I, 19. května 2010
216
Algoritmy pro CSP
Algoritmus AC-3
procedure AC-3(G) ____^ Vk *^ Vm
Q : = {(i,j) I (i,j) £ 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 {(i,k)  g hrany(G), i = k, i = m}      % dosud nejsou ve fronte end while end AC-3
Hana Rudová, Logické programování I, 19. května 2010
217
Algoritmy pro CSP
Algoritmus AC-3
procedure AC-3(G) ____^ Vk *^ Vm
Q : = {(i,j) I (i,j) £ 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 {(i,k)  g hrany(G), i = k, i = m}      % dosud nejsou ve fronte end while end AC-3
Pr íklad:
A<B, B<C:  C3..7,1..5,1..5) - (3..4,1..5,1..5) -
C3..4,4..5,1..5) BC C3..4,4,1..5) - (3..4,4,5)
^B (3,4,5)
Hana Rudová, Logické programování I, 19. května 2010
217
Algoritmy pro CSP
Algoritmus AC-3
procedure AC-3(G) ____^ Vk *^ Vm
Q := {(i,j) I (i,j) £ 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 {(i,k)  g hrany(G), i = k, i = m}      % dosud nejsou ve fronte end while end AC-3
Príklad:
A<B, B<C:  (3..7,1..5,1..5) - (3..4,1..5,1..5) -
(3..4,4..5,1..5) BC (3..4,4,1..5) - (3..4,4,5)
^B (3,4,5)
Těchnika AC-3 jě dněs asi nějpoužívánější, alě stálě nění optimální
Jaké budou domény A,B,C po AC-3 pro: domain([A,B,C],1,10), A #= B + 1, C #< B
Hana Rudová, Logické programování I, 19. kvetna 2010
217
Algoritmy pro CSP
Jě hranová konzistěncě dostatěCná?
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
Hana Rudová, Logické programování I, 19. kvetna 2010
218
Algoritmy pro CSP
Jě hranová konzistěncě dostatěcná?
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
s» hranove konzistentní a nemá žádné r ešení
Hana Rudová, Logické programování I, 19. kvetna 2010
218
Algoritmy pro CSP
Jě hranová konzistěncě dostatěcná?
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
s» 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, 19. kvetna 2010
218
Algoritmy pro CSP
k-konzistence
Mají NC a AC neco spolecného?
s NC: konzistence jedné promenné & AC: konzistence dvou proměnných ... mužeme pokracovat
Hana Rudová, Logické programování I, 19. kvetna 2010 219 Algoritmy pro CSP
k-konzistence
Mají NC a AC neco spolecného?
s NC: konzistence jedné promenné & AC: konzistence dvou promenných ... mužeme pokracovat
CSP je k-konzistentní práve tehdy, když mužeme libovolné konzistentní ohodnocení (k-1) ruzných promenných rozšír it do libovolné k-té promenné
Hana Rudová, Logické programování I, 19. kvetna 2010
219
Algoritmy pro CSP
k-konzistence
Mají NC a AC něco společného?
s NC: konzistence jedné proměnné .i* 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, 19. kvetna 2010 219
4-konzistentní graf
Algoritmy pro CSP
Silná k-konzistěncě
3-konzistentní graf
1,2		1,2		1,2,3
není 2-konzistentní
Hana Rudová, Logické programování I, 19. kvetna 2010
220
Algoritmy pro CSP
Silná k-konzistence
3-konzistentní graf
(1,1) lze rozšír it na (1,1,1) (2, 2) lze rozšír it na (2, 2,2)
1,2		1,2		1,2,3
není 2-konzistentní (3) nelze rozšír it
(1, 3) ani (2, 3) nejsou konzistentní dvojice (nerozši r ujeme je)
Hana Rudová, Logické programování I, 19. kvetna 2010
220
Algoritmy pro CSP
Silná k-konzistence
3-konzistentní graf
(1,1) lze rozšír it na (1,1,1) (2, 2) lze rozšír it na (2, 2,2)
1,2		1,2		1,2,3
není 2-konzistentní (3) nelze rozšír it
(1, 3) ani (2, 3) nejsou konzistentní dvojice (nerozši r ujeme je)
& CSPje silne k-konzistentní práve tehdy, když je j-konzistentní pro každé j<k
Hana Rudová, Logické programování I, 19. kvetna 2010
220
Algoritmy pro CSP
Silná k-konzistěncě
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 silně k-konzistěntní práve tehdy, když je j-konzistentní pro každé j<k
JS> Silná k-konzistence => k-konzistence
-í* Silná k-konzistence => j-konzistence V j < k
-í* k-konzistence ^ silná k-konzistence
Hana Rudová, Logické programování I, 19. kvetna 2010
220
Algoritmy pro CSP
Silná k-konzistence
3-konzistentní graf (1,1) lze rozšír it na (1,1,1)
1,2
1,2
1,2,3
není 2-konzistentní
(3) nelze rozšír it
(2, 2) lze rozšír it na (2, 2,2)
(1, 3) ani (2, 3) nejsou konzistentní dvojice (nerozši r ujeme je)
& CSPje silne k-konzistentní práve tehdy, když je j-konzistentní pro každé j<k
-í* Silná k-konzistence => k-konzistence
-í* Silná k-konzistence => j-konzistence V j < k
-í* k-konzistence ^ silná k-konzistence
& NC = silná 1-konzistence = 1-konzistence J* AC = (silná) 2-konzistence
Hana Rudová, Logické programování I, 19. kvetna 2010
220
Algoritmy pro CSP
Konzistence pro nalezení reSení
Máme-li graf s n vrcholy, jak silnou konzistenci potrebujeme, abychom p rímo našli rešení?
ifc silná n-konzistence je nutná pro graf s n vrcholy
Hana Rudová, Logické programování I, 19. kvetna 2010
221
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í?
ifc 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, 19. kvetna 2010
221
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<n také nestací
1,2,...,n-1
graf s n vrcholy domény 1..(n-1)
Hana Rudová, Logické programování I, 19. kvetna 2010
221
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<n také nestací
1,2,...,n-1
graf s n vrcholy domény 1..(n-1)
silne k-konzistentní pro každé k<n p resto nemá rešení
Hana Rudová, Logické programování I, 19. kvetna 2010
221
Algoritmy pro CSP
Řešení nebinárních podmínek
Ü* k-konzistence má exponenciální složitost, v reálu se nepoužívá ü> S n-árními podmínkami se pracuje prímo
& Podmínka je obecne hranové konzistentní (GAC), práve když pro každou proměnnou Vt z této podmínky a každou hodnou x g Dt existuje ohodnocení zbylých proměnných v podmínce tak, že podmínka platí
J* A + B = C, A in 1..3, B in 2..4, C in 3..7 je obecne hranove konzistentní
Hana Rudová, Logické programování I, 19. kvetna 2010
222
Algoritmy pro CSP
Řešení nebinárních podmínek
k-konzistence má exponenciální složitost, v reálu se nepoužívá S n-árními podmínkami se pracuje p rímo
i* Podmínka je obecne hranove konzistentní (GAC), práve když pro každou proměnnou Vt z této podmínky a každou hodnou x g Dt existuje ohodnocení zbylých proměnných v podmínce tak, že podmínka platí
J* A + B = C, A in 1..3, B in 2..4, C in 3..7 je obecne hranove konzistentní
-í* Využívá se sémantika podmínek
s> speciální typy konzistence pro globální omezení
±* viz all_distinct
a konzistence mezí
propagace pouze p r i zmene nejmenší a nejvetší hodnoty v doméne promenné C- Pro různé podmínky lze použít mzný druh konzistence J* A#<B: hranová konzistence, konzistence mezí
Hana Rudová, Logické programování I, 19. kvetna 2010 222 Algoritmy pro CSP
Konzistencní algoritmus pro nebinární podmínky
& Algoritmus s frontou promenných (nekdy též nazýván AC-8)
3» opakovane se provádí revize podmínek, dokud se mení domény procedure Nonbinary-AC-3-with-Variab1es(Q) whi1e Q non empty do
vyber a smaž Vj g Q for V C takové, že Vj g scope(C) do W := reviseCVj, C)
// W je množina proměnných jejichž, doména se zmeni1a if B Vi g W taková, že Di = 0 then return fai1 Q := Q u {W} end Non-binary-consistency
Jt rozsah omezení scope(C): množina promenných, na nichž je C definováno
Hana Rudová, Logické programování I, 19. kvetna 2G1G
223
Algoritmy pro CSP
KonzistenCní algoritmus pro nebinární podmínky
& Algoritmus s frontou promenných (někdy též nazýván AC-8)
opakovaně se provádí revize podmínek, dokud se mění domény proceduře Nonbinary-AC-3-with-Variables(Q) while Q non empty do
vyber a smaž Vj g Q for V C takové, že Vj g scope(C) do W := revise(Vj, C)
// W je množina proměnných jejichž, doména se zmenila if 3 Vi g W taková, že Di = 0 then return fail Q := Q u {W} end Non-binary-consistency
3» rozsah omezení scope(C): množina proměnných, na nichž je C definováno
& Implementace
A u každé proměnné je seznam vybraných podmínek pro propagaci
-i- REVISE procedury pro tyto podmínky definuje uživatel v závislosti na typu podmínky
Hana Rudová, Logické programování I, 19. května 2010 223 Algoritmy pro CSP
Konzistence mezí
Bounds consistency BC: slabší než obecná hranová konzistence
-fc 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 promenných v podmínce tak, že je podmínka splnena a pro vybrané ohodnocení yí promenné Ví platí mm(Di) < yi < max(D^)
Hana Rudová, Logické programování I, 19. kvetna 2010
224
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 p r i 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
p r í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, 19. kvetna 2010
224
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, 19. kvetna 2010 224 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)
Hana Rudová, Logické programování I, 19. kvetna 2010
225
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), ...
Hana Rudová, Logické programování I, 19. kvetna 2010
225
Algoritmy pro CSP
Konzistěncě mězí a aritmětická omězění
& 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, 19. kvetna 2010
225
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), ...
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, 19. kvetna 2010
225
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 změna min(A)vyvolá pouzě změnu min(B) a min(C)
Jt 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)
Hana Rudová, Logické programování I, 19. května 2010
225
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, 19. kvetna 2010
225
AlgoritmyproCSP
Konzistěncě mězí a aritmětická omězění
& 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), ...
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) JS* Vyzkoušejte si: A #= B - C, A #>= B + C
Hana Rudová, Logické programování I, 19. kvetna 2010
225
Algoritmy pro CSP
Globální podmínky
& Propagace je lokální
A pracuje se s jednotlivými podmínkami
i* 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 pres globální podmínku rešíme
speciálním algoritmem navrženým pro danou podmínku
C Príklady:
M all_different omezení: hodnoty všech promenných různé serialized omezení:
rozvržení úloh zadaných startovním casem a dobou trvání tak, aby se neprekrývaly
Hana Rudová, Logické programování I, 19. kvetna 2010
226
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, 19. kvetna 2010
227
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á, Logické programování I, 19. května 2010
227
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, 19. května 2010
227
Algoritmy pro CSP
Propagace 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
Konzistence: \/{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 proměnných, jejichž doména je v I	Eva		4
	Marie	1	6
Hana Rudová, Logické programování I, 19. kvetna 2010
227
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, 19. kvetna 2010
227
Algoritmy pro CSP
Propagace pro all_distinct
U = {X2, X4, X5}, dom(U) = {2, 3, 4}:
{2,3,4} nělzě 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í hlědat Hallův interval I: vělikost intěrvalu I jě rovna poctu proměnných, jějichž doména jě 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ě intěrvalu jsou pro ostatní proměnné nědostupné
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, 19. května 2010
227
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{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 = {Xl,...,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
Složitost: O(2n) - hledání všech podmnožin množiny n proměnných (naivní)
Hana Rudová, Logické programování I, 19. kvetna 2010
227
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{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 = {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, 19. kvetna 2010
227
Algoritmy pro CSP
Prohledávání + konzistence
Splňování podmínek prohledáváním prostoru r ešení
A podmínky jsou užívány pasivné jako test
J> p r i razuji 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, 19. kvetna 2010
228
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í
Hana Rudová, Logické programování I, 19. kvetna 2010
228
Algoritmy pro CSP
Prohledávání + konzistence
Splnování podmínek prohledáváním prostoru rešení
A podmínky jsou užívány pasivne jako test
J> prirazuji 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í
& 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í)
Hana Rudová, Logické programování I, 19. kvetna 2010
228
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í)
& 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, 19. kvetna 2010 228 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
Jt dopredná fáze: proměnné jsou postupně vybírány, rozširujě sě cástěcné rěšění prirazě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 prědchozí prirazěné hodnotě
Hana Rudová, Logické programování I, 19. května 2010
229
Algoritmy pro CSP
Prohlědávání do hloubky
& Základní prohledávací algoritmus pro problémy splnování podmínek & Prohlědávání stavového prostoru do hloubky (depth first search)
& Dve fáze prohledávání s navracením
& doprědná fázě: 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 zpětná fázě: pokud neexistuje konzistentní hodnota pro aktuální promennou, algoritmus se vrací k predchozí prirazené hodnote
& Promenné delíme na
& minulé - promenné, které už byly vybrány (a mají prirazenu hodnotu) * aktuální - promenná, která je práve vybrána a je jí prirazována hodnota s budoucí - promenné, které budou vybrány v budoucnosti
Hana Rudová, Logické programování I, 19. kvetna 2010 229 Algoritmy pro CSP
Základní algoritmus prohledávání do hloubky
Pro jednoduchost proměnné očíslujeme a ohodnocujeme je v daném pořadí Na začátku voláno jako 1abe1ing(G,1)
procedure 1abe1ing(G,a)
if a > |uz1y(G)| then return uzly(G)
for Vx 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 přiřazení všech promenných vrátíme jejich ohodnocení Procedury consistent uvedeme pouze pro binární podmínky
Hana Rudová, Logické programování I, 19. května 2010
230
Algoritmy pro CSP
Backtracking (BT)
Backtracking ove r uje 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, 19. kvetna 2010
231
Algoritmy pro CSP
Backtracking (BT)
Backtracking overuje 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:={(Ví, 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, 19. kvetna 2010
231
Algoritmy pro CSP
Příklad: backtracking
C Omezení: Vu V2, V3 in 1... 3, Vľ# = 3 x V3 & Stavový prostor: í
S* červené čtverečky: chybný pokus o instanciaci, r ešení neexistuje i* nevyplnená kolečka: nalezeno r ešení
Jť černá kolečka: vnit r ní uzel, máme pouze částečné p r i razení
Hana Rudová, Logičké programování I, 19. kvetna 2010 232
Kontrola dopředu (FC - forward checking)
FC je rozšírení backtrackingu
FC navíc zajišťuje konzistenci mezi aktuální proměnnou a budoucími proměnnými, které jsou s ní spojeny dosud nesplněnými podmínkami
Hana Rudová, Logické programování I, 19. kvetna 2010
233
Algoritmy pro CSP
Kontrola dop ř edu (FC - forward checking)
FC je rozšír ení backtrackingu
FC navíc zajišťuje konzistenci mezi aktuální proměnnou a budoucími proměnnými, které jsou s ní spojeny dosud nesplnenými podmínkami
procedure FC(G,a)
Q:={(Vi, va) g hrany(G), i > a} % p r 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, 19. kvetna 2010
233
Algoritmy pro CSP
Príklad: kontrola dopredu
C Omězění: V1,V2, V3 in 1... 3,   c : V1# = 3 x V3 & Stavový prostor:
Hana Rudová, Logické programování I, 19. května 2010 234 Algoritmy pro CSP
Pohled dopředu (LA - looking ahead)
LA je rozšírení FC, navíc ověř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
Hana Rudová, Logické programování I, 19. kvetna 2010
235
Algoritmy pro CSP
Pohled dop ř edu (LA - looking ahead)
LA je rozšírení FC, navíc ove r 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
JS> LA udržuje hranovou konzistenci: protože ale LA(G,a) používá AC-3, musíme zajistit iniciální konzistenci pomocí AC-3 ješte p red startem prohledávání
Hana Rudová, Logické programování I, 19. kvetna 2010 235 Algoritmy pro CSP
Príklad: pohled dopredu (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 pred 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, 19. května 2010
236
Algoritmy pro CSP
Přehled algoritmů
Backtracking (BT) kontrolujě v kroku a podmínky
c(Vi ,Va),...,c(Va-l,Va)
z minulých proměnných do aktuální proměnné
BT
FC
LA
promenne
aktuálni
Hana Rudová, Logické programování I, 19. května 2010
237
Algoritmy pro CSP
Přehled algoritmu
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 dopředu (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, 19. kvetna 2010
237
Algoritmy pro CSP
Přehled algoritmů
BT
Backtracking (BT) kontroluje v kroku a podmínky
,Va),...,c(Va-1,Va)
z minulých proměnných do aktuální proměnné Kontrola dopředu (FC) kontroluje v kroku a podmínky
c(Va+1,Va),...,c(Vn,Va)
z budoucích proměnných do aktuální proměnné
Pohled dopredu (LA) kontrolujě v kroku a podmínky
Vl(a < l < n), \/k(a < k < n),k = l: c(Vk,Vi) z budoucích proměnných do aktuální proměnné LA a mězi budoucími proměnnými
a
FC
n
promenne
aktuální
Hana Rudová, Logické programování I, 19. května 2010
237
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í proměnných A,B,C? Popište, jaký typ propagace proběhne 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
p r i použití pohledu dop r edu a uspo rádání proměnných A,B,C? Popište, jaký typ propagace proběhne 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í proměnných A,B,C? Popište, jaký typ propagace proběhne v jednotlivých uzlech.
Hana Rudová, Logické programování I, 19. května 2010 238 Algoritmy pro CSP
Cvicení
1. Jaká jsou pravidla pro konzistenci mezí u omezení X#= Y+5? Jaké typy propagací pak probehnou v následujícím príklade 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, 19. kvetna 2010
239
Algoritmy pro CSP
Implementace Prologu
Litěratura:
& Matyska L., Toman D.: Implěměntacní těchniky 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 tvorí 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, proměnná nebo složený term.
-í* Složený term
s n termy na míste argumentu
& Dotaz (cíl) je neprázdná množina literálu.
Hana Rudová, Logické programování I, 19. kvetna 2010
241
Implementace Prologu
Interpretace
Deklarativní sémantika:
Hlava platí, platí-li jednotlivé literály tela.
Hana Rudová, Logické programování I, 19. kvetna 2010
242
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, 19. kvetna 2010
242
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álů) v tele.
Procedurální sémantika = podklad pro implementaci
Hana Rudová, Logické programování I, 19. kvetna 2010 242
Implementace Prologu
Abstraktní interpret
Vstup: Logický program P a dotaz G.
1. Inicializuj množinu cílů S litěrály z dotazu G; S:=G
2. while ( S != empty ) do
3. Vyběr AeS a dálě vyběr klauzuli A':-B1 ,...,Bn   (n > 0) z programu P takovou, žě 3a : Aa = A' a; a jě nějoběcnější unifikátor.
Pokud něěxistujě A' něbo a, ukonci cyklus.
Hana Rudová, Logické programování I, 19. května 2010
243
Implěměntacě 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 AgS 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.
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, 19. kvetna 2010 243 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, 19. kvetna 2010
244
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
veta
Existuje-li instance C dotazu G, odvoditelná z programu P v konecném poctu kroků, pak bude tímto interpretem nalezena.
Hana Rudová, Logické programování I, 19. kvetna 2010
244
Implementace Prologu
Nědětěrminismus intěrpětu
1. Sělěkcní pravidlo: výber cíle A z množiny cílu S JÍ neovlivnuje výrazne výsledek chování interpretu
2. Způsob prohlědá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í
Hana Rudová, Logické programování I, 19. kvetna 2010
245
Implementace Prologu
Nedeterminismus interpetu
1. SelekCní pravidlo: výběr cíle A z množiny cílu S JÍ neovlivnuje výrazně výsledek chování interpretu
2. Způsob prohledávání stromu výpoCtu: výběr klauzule A' z programu P
JG* je velmi důležitý, všechny klauzule totiž nevedou k úspěš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, 19. kvetna 2010
245
Implementace Prologu
Nedeterminismus interpetu
1. Selekcní pravidlo: výběr cílě A z množiny cílu S M něovlivnujě výrazně výslěděk chování intěrprětu
2. Způsob prohledávání stromu výpoctu: výběr klauzulě A' z programu P
JG* jě vělmi důlěžitý, všěchny klauzulě totiž něvědou k úspěšnému rěšění
Vztah k úplnosti:
1. Sělěkcní pravidlo něovlivnujě úplnost
& možno zvolit libovolné v rámci SLD rězolucě
2. Prohlědávání stromu výpoctu do šírky něbo do hloubky
„Prozrění" - automatický výběr správné klauzulě
& vlastnost abstraktního intěrprětu, ktěrou alě rěálné intěrprěty němají
Hana Rudová, Logické programování I, 19. května 2010 245 Implěměntacě Prologu
Prohledávání do šířky
1. Vybereme všečhny klauzule     které je možno unifikovat s literálem A M nečht'je tečhto klauzulí q
2. Vytvo ríme q kopií množiny S
3. V každé kopii redukujeme A jednou z klauzulí AÍ. M aplikujeme p ríslušný nejobečnejší unifikátor
Hana Rudová, Logičké programování I, 19. kvetna 2010
246
Implementače 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, 19. kvetna 2010
246
Implementace Prologu
Prohledávání do ší r ky
1. Vybereme všechny klauzule A-, které je možno unifikovat s literálem A M necht'je techto klauzulí q
2. Vytvo ríme q kopií množiny S
3. V každé kopii redukujeme A jednou z klauzulí A-. M aplikujeme p rí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, 19. kvetna 2010
246
Implementace Prologu
Prohlědá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.
-í* Ekvivalence s abstraktnímu interpretem
A pokud jeden interpret neuspeje, pak neuspeje i druhý i> pokud jeden interpret uspeje, pak uspeje i druhý
Hana Rudová, Logické programování I, 19. kvetna 2010 246 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.
Hana Rudová, Logické programování I, 19. kvetna 2010
247
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.
Hana Rudová, Logické programování I, 19. kvetna 2010
247
Implementace Prologu
Prohledávání do hloubky
1. Vybereme všečhny klauzule A'i, které je možno unifikovat s literálem A.
2. Všečhny tyto klauzule zapíšeme na zásobník.
3. Redukči provedeme s klauzulí na vrčholu zásobníku.
4. Pokud v nejakém kroku nenajdeme vhodnou klauzuli A', vrátíme se
k p r edčhozímu stavu (tedy anulujeme aplikače posledního unifikátoru a) a vybereme ze zásobníku další klauzuli.
5. Pokud je zásobník prázdný, končí výpočet neúspečhem.
6. Pokud naopak zredukujeme všečhny literály v S, výpočet končí úspečhem.
Hana Rudová, Logičké programování I, 19. kvetna 2010
247
Implementače 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ředchozí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 širky -í* Používá se v Prologu
Hana Rudová, Logické programování I, 19. kvetna 2010 247 Implementace Prologu
Reprezentace objektů
J& Beztypový jazyk
ü> Kontrola „typů" za běhu výpočtu
JS> Informace o strukture součástí objektů
Hana Rudová, Logické programování I, 19. kvetna 2010
248
Implementace Prologu
Reprezentace objektů
J& Beztypový jazyk
JS> Kontrola „typů" za behu výpočtu
JS> Informace o strukture součástí objektu
Typy objektů
M Primitivní objekty:
konstanta číslo
i* volná proměnná -i- odkaz (reference)
Hana Rudová, Logické programování I, 19. kvetna 2010
248
Implementace Prologu
Reprezentace objektů
J& Běztypový jazyk
ii> Kontrola „typu" za běhu výpoctu
JS> Informacě o strukturě soucástí objěktu
Typy objektů
M Primitivní objekty:
konstanta císlo
-i. volná proměnná -i- odkaz (rěfěrěncě)
& Složené (strukturované) objekty:
± struktura A sěznam
Hana Rudová, Logické programování I, 19. května 2010 248 Implěměntacě 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, 19. kvetna 2010
249
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 príznak.
Hana Rudová, Logické programování I, 19. kvetna 2G1G
249
Implementace Prologu
Reprezentace objektů II
Příznaky (tags):
Objekt	Pří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. Primitivní objekty uloženy prímo ve slove
Hana Rudová, Logické programování I, 19. kvetna 2010
249
Implementace Prologu
Rěprězěntacě objěktu II
Příznaky (tags):
Objekt	Příznak
volná promenná	FREE
konstanta	CONST
celé císlo	INT
odkaz	REF
složený term	FUNCT
Obsah adresovatelného slova: hodnota a príznak. Primitivní objekty uloženy prímo ve slove Složené objekty
Ä jsou instance termu ve zdrojovém textu, tzv. zdrojového termu
& zdrojový term bez promenných => každá instanciace ekvivalentní zdrojovému termu
zdrojový term s promennými => dve instance se mohou lišit aktuálními hodnotami promenných, jedinecnost zajišťuje kopírování struktur nebo sdílení struktur
Hana Rudová, Logické programování I, 19. kvetna 2010
249
Implementace Prologu
Kopírování struktur
P ríklad:
a(b(X),c(X,Y),d),
FUNCT a/3
REF
REF
CONSTd
FUNCT c/2
REF
FREE Y
FUNCT b/1 -
FREE X
Hana Rudová, Logické programování I, 19. kvetna 2010
250
Implementace Prologu
Kopírování struktur II
Term F s aritou A reprezentován A+l slovy: A funktor a arita v prvním slove
J* 2. slovo nese první argument (resp. odkaz na jeho hodnotu) i A A+l 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, 19. kvetna 2010
251
Implementace Prologu
Sdílení struktur
Vychází z myšlenky, že p r i reprezentaci je tr eba r ešit p rítomnost promenných & Instance termu
< kostra_termu; rámec >
M kostra_termu je zdrojový term s ocíslovanými promennými & rámec je vektor aktuálních hodnot techto promenných
í-tá položka nese hodnotu í-té promenné v původním termu
Hana Rudová, Logické programování I, 19. kvetna 2010
252
Implementace 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 promennou.
Hana Rudová, Logické programování I, 19. kvetna 2010
253
Implementace 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 označujeme í-tou promennou.
Implementace:
< &kostra_termu; &rámec > (& vračí adresu objektu) Všečhny instanče sdílí společnou kostru_termu ^ sdílení struktur
Hana Rudová, Logičké programování I, 19. kvetna 2010
253
Implementače Prologu
Srovnání: p r íklad
Naivní srovnání: sdílení pamet'ove méne nárocné
Hana Rudová, Logické programování I, 19. kvetna 2010
254
Implementace Prologu
Srovnání: príklad
Naivní srovnání: sdílění paměťově méně nárocné
Platí alě pouzě pro rozsáhlé těrmy prítomné vě zdrojovém kódu
Hana Rudová, Logické programování I, 19. května 2010
254
Implěměntacě 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, 19. kvetna 2010
254
Implementace Prologu
Srovnání: p r íklad - pokracová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/2	
	- REF	
	FREE Y	
		
	FUNCT b/l	
	FREE X	
Hana Rudová, Logické programování I, lg. kvetna 2GlG
255
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/2	
	- REF	
	FREE Y	
		
	FUNCT b/1	
	FREE X	
tj. identické jako prímé vytvorení termu a(b(X),c(X,Y),d)
Hana Rudová, Logické programování I, 19. kvetna 2010 255 Implementace Prologu
Srovnání II
Složitost algoritmů pro prístup k jednotlivým argumentům
s sdílění struktur: nutná vícěúrovnová něprímá adrěsacě & kopírování struktur: běz problému
jědnodušší algoritmy usnadnují i optimalizacě
Hana Rudová, Logické programování I, 19. května 2010
256
Implěměntacě Prologu
Srovnání II
Složitost algoritmů pro přístup k jědnotlivým arguměntum
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 paměti
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, 19. kvetna 2010
256
Implementace Prologu
Srovnání II
Složitost algoritmů pro prístup k jednotlivým argumentům
s sdílení struktur: nutná víceúrovnová nepřímá adresace & kopírování struktur: bez problému
jednodušší algoritmy usnadnují i optimalizace
Lokalita přístupů 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
Z praktického hlediska neexistuje mezi temito prístupy zásadní rozdíl
Hana Rudová, Logické programování I, 19. kvetna 2010
256
Implementace Prologu
Řízení výpoctu
JS> Dop r ednývýpocet
a po úspechu (úspešná redukce)
jednotlivá volání procedur skoncí úspechem
a klasické volání rekurzivních procedur
Hana Rudová, Logické programování I, 19. kvetna 2010
257
Implementace Prologu
Řízení výpoCtu
JS> Dopredný výpoCet
a po úspečhu (úspešná redukče)
jednotlivá volání pročedur skončí úspečhem
a klasičké volání rekurzivníčh pročedur
-i* Zpetný výpoCet (backtracking)
a po neúspečhu vyhodnočení literálu (neúspešná redukče) nepoda r í se unifikače aktuálníčh a formálníčh parametrů hlavy
a návrat do bodu, kde zústala nevyzkoušená alternativa výpočtu je nutná obnova původníčh hodnot jednotlivýčh promennýčh
po nalezení místa s dosud nevyzkoušenou klauzulí pokračuje dále dop r edný výpočet
Hana Rudová, Logičké programování I, 19. kvetna 2010
257
Implementače Prologu
Aktivacní záznam
-í* Volání (=aktivacě) procědury
M Aktivacě sdílí spolecný kód, liší sě obsahěm aktivacního záznamu & Aktivacní záznam uložěn na lokálním zásobníku
Hana Rudová, Logické programování I, 19. května 2010
258
Implěměntacě 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, 19. kvetna 2010
258
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í promenné
& pomocné promenné ('a la registry)
-í* 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, 19. kvetna 2010
258
Implementace Prologu
Aktivacní 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).
Hana Rudová, Logické programování I, 19. kvetna 2010
259
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, 19. kvetna 2010
259
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 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é
Hana Rudová, Logické programování I, 19. kvetna 2010
259
Implementace Prologu
Aktivacní 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)
-i* Pr i návratu je tr eba obnovit (roll-back) původní 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á"
Hana Rudová, Logické programování I, 19. kvetna 2010 259 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, 19. kvetna 2010 259 Implementace Prologu
Okolí a bod volby
Aktivacní záznam úspešne ukoncené procedury nelze odstranit z lokálního zásobníku => rozdělění aktivačního záznamu:
JS> okolí (environment) - informace nutné pro dopredný beh programu
-i* bod volby (choice point) - informace nezbytné pro zotavení po neúspechu
Hana Rudová, Logické programování I, 19. kvetna 2010
260
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 predchozí okolí resp. bod volby)
Hana Rudová, Logické programování I, 19. kvetna 2010
260
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)
Hana Rudová, Logické programování I, 19. kvetna 2010
260
Implementace Prologu
Okolí a bod volby
Aktivacní záznam úspešne ukoncené procedury nelze odstranit z lokálního zásobníku => rozdělění aktivačního záznamu:
JS> okolí (environment) - informace nutné pro dopredný beh programu
-i* bod volby (choice point) - informace nezbytné pro zotavení po neúspechu
& ukládány na lokální zásobník
& samostatne provázány (odkaz na predchozí okolí resp. bod volby) Důslědky:
& samostatná práce s každou cástí aktivacního záznamu (optimalizace) JS> alokace pouze okolí pro deterministické procedury
Hana Rudová, Logické programování I, 19. kvetna 2010
260
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
M 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
& 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, 19. kvetna 2010 260 Implementace Prologu
Řez
JS> Prostr edek pro ovlivnení behu výpočtu programátorem
a(X) :- b(X),  !, c(X). a(3). b(1). b(2). c(1). c(2).
Hana Rudová, Logičké programování I, 19. kvetna 2010
261
Implementače Prologu
Řez
JS> Prostředek pro ovlivnění běhu výpočtu programátorem
a(X) :- b(X),  !, c(X). a(3). b(1). b(2). c(1). c(2).
-í* Řez: neovlivňuje dopredný výpočet, má vliv pouze na zpětný výpočet
-i* Odstranení alternativních vetví výpočtu
=> odstranení odpovídajících bodů volby
A tj. odstranení bodu volby mezi současným vrcholem zásobníku a bodem volby procedury, která rez vyvolala (včetne bodu volby procedury s rezem)
=> zmena ukazatele na „nejmladší" bod volby
Hana Řudová, Logické programování I, 19. kvetna 2010
261
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).
-í* 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
^ Vytvárení deterministických procedur => Optimalizace využití zásobníku
Hana Rudová, Logické programování I, 19. kvetna 2010 261
Implementace Prologu
Interpret Prologu
Základní prinčipy:
JS> klauzule uloženy jako termy
-í* programová databáze
a pro uložení klauzulí Jr má čharakter haldy
3 umožnuje modifikovatelnost prologovskýčh programu za behu (assert)
C klauzule zretezeny podle poradí načtení triviální z r etezení
Hana Rudová, Logičké programování I, 19. kvetna 2010
262
Implementače 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
3 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, 19. kvetna 2010
262
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)
Hana Rudová, Logické programování I, 19. kvetna 2010
263
Implementace Prologu
Intěrprět - 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)
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, 19. kvetna 2010
263
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 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, 19. kvetna 2010 263 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, 19. kvetna 2010 264 Implementace Prologu
Interpret - vlastnosti
Lokální i globální zásobník
pri dopredném výpočtu roste A pri zpetném výpočtu se zmenšuje
Lokální zásobník se může zmenšit pri dopredné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 Řudová, Logické programování I, 19. kvetna 2010
264
Implementace Prologu
Interpret - vlastnosti
-í* Lokální i globální zásobník
p r i dop r edném výpočtu roste A p r i zpetném výpočtu se zmenšuje
Lokální zásobník se může zmenšit p r i dop redném úspešném výpočtu determinističké pročedury.
-í* Unifikače argumentů hlavy - obečný unifikační algoritmus
Současne poznačí adresy instančiovanýčh promennýčh na stopu.
-í* „Interpret":
interpret(Query, Vars) :- call(Query), success(Query, Vars). interpret(_,_) :- failure.
dotaz vsazen do kontextu této spečiální nedeterminističké pročedury
tato pročedura odpovídá za korektní reakči systému v p r ípade úspečhu i neúspečhu
Hana Rudová, Logičké programování I, 19. kvetna 2010 264 Implementače Prologu
Optimalizace: Indexace
Zretezení klauzulí podle poradí nactení velmi neefektivní & Provázání klauzulí se stejným funktorem a aritou hlavy (tvorí jednu proceduru)
a tj., indexace procedur -í* Hash tabulka pro vyhledání první klauzule & Možno rozhodnout (parciálne) determinismus procedury
Hana Rudová, Logické programování I, 19. kvetna 2010
265
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)
Hana Rudová, Logické programování I, 19. kvetna 2010
266
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, 19. kvetna 2010 266 Implementace Prologu
Inděxacě arguměntů 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, 19. kvetna 2010
267
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, 19. kvetna 2010
268
Implementace Prologu
Tail Recursion Optimization, TRO
Iterace provádena pomocí rekurze => lineární pameťová náročnost 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é.
Řízení se nemusí vracet:
& v prípade úspechu se rovnou pokračuje
JS> v prípade neúspechu se vrací na predchozí bod volby („nad" aktuální klauzulí) aktuální klauzule nemá dle predpokladu bod volby
Řekurzivne volaná klauzule muže být volána prímo z kontextu volající klauzule.
Hana Řudová, Logické programování I, 19. kvetna 2010
268
Implementace Prologu
TRO - p r í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, 19. kvetna 2010
269
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).
append volán rekurzivne 4krát
£ bez TRO: 4 okolí, lineární pamet'ová nárocnost & s TRO: 1 okolí, konstatní pamet'ová nárocnost
Hana Rudová, Logické programování I, 19. kvetna 2010
269
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, 19. května 2010
270
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, 19. kvetna 2010
270
Implementace Prologu
Optimalizace posledního volání
TRO pouze spečiální p rípad
obečné optimalizace posledního volání (Last Call Optimization), LCO
Okolí (p r ed redukčí posledního literálu)
odstranováno vždy, když leží na vrčholu zásobníku.
Nutné úpravy interpretu
JS> disčiplina směrování ukazatelu
A vždy „mladší" ukazuje na „starší" („mladší" budou odstraneny d r íve) -i- z lokálního do globálního zásobníku
vyhneme se vzniku „visíčíčh odkazu" p r i p r edčasném odstranení okolí
Hana Rudová, Logičké programování I, 19. kvetna 2010
270
Implementače Prologu
Optimalizacě poslědního volání
TRO pouze speciální prípad
obecné optimalizacě poslědní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 intěrprětu
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, 19. kvetna 2010 270 Implementace Prologu
Preklad
Preklad
Motivace:
dosažení vyšší míry optimalizace i* kompaktní kód
Jť cástecná nezávislost na hardware
Hana Rudová, Logické programování I, 19. kvetna 2010 272 Preklad
Preklad
-í* Motivace:
dosažení vyšší míry optimalizace i* kompaktní kód
Jť cástecná nezávislost na hardware Etapy prekladu:
1. zdrojový text == kód abstraktního pocítace
2. kód abstraktního pocítace == kód (instrukce) cílového pocítace
Hana Rudová, Logické programování I, 19. kvetna 2010
272
Preklad
Preklad
-í* Motivace:
dosažení vyšší míry optimalizace i* kompaktní kód
Jť cástecná nezávislost na hardware Etapy prekladu:
1. zdrojový text == kód abstraktního pocítace
2. kód abstraktního pocítace == kód (instrukce) cílového pocítace
& Výhody:
-i- snazší prenos jazyka (nutno prepsatjen druhou cást)
S> kód abstraktního pocítace možno navrhnout s ohledem na jednoduchost prekladu; prostor pro strojove nezávislou optimalizaci
Hana Rudová, Logické programování I, 19. kvetna 2010
272
Preklad
Preklad
-í* Motivace:
dosažení vyšší míry optimalizace i* kompaktní kód
Jť cástecná nezávislost na hardware
JS> Etapy prekladu:
1. zdrojový text == kód abstraktního pocítace
2. kód abstraktního pocítace == kód (instrukce) cílového pocítace
& Výhody:
-i- snazší prenos jazyka (nutno prepsatjen druhou cást)
S> kód abstraktního pocítace možno navrhnout s ohledem na jednoduchost prekladu; prostor pro strojove nezávislou optimalizaci
C Preklad Prologu založen na principu existence abstraktního pocítace V dalším se venujeme jeho odvození a vlastnostem
Hana Rudová, Logické programování I, 19. kvetna 2010 272 Preklad
Parčiální vyhodnočení
& Jak navrhnout Warrenův abstraktní počítač?
prostřednictvím parciálního vyhodnocení
Parčiální vyhodnočení
a forma zpracování programu,
tzv. transformace na úrovni zdrojového kódu
a dosazení známých hodnot vstupních parametru a vyhodnocení všech operací nad nimi
príklad: vyhodnocení aritmetických výrazu nad konstantami
Hana Rudová, Logické programování I, 19. kvetna 2010
273
Preklad
Parciální vyhodnocení - p r íklad
a(X,Y) :- b(X), c(X,Y).          a(X,Y) :- b(Y), c(Y,X). b(1).     b(2).     b(3). b(4).
c(1,2). c(1,3). c(1,4). c(2,3). c(2,4). c(3,4). Dotaz ?- a(2,Z).
Hana Rudová, Logické programování I, 19. kvetna 2010
274
Preklad
Parciální vyhodnocení - príklad
a(X,Y) :- b(X), c(X,Y). a(X,Y) :- b(Y), c(Y,X).
b(1).     b(2).     b(3). b(4).
c(1,2).     c(1,3).     c(1,4).     c(2,3).     c(2,4). c(3,4). Dotaz ?- a(2,Z).
lze společne s uvedeným programem parciálne vyhodnotit na nový program a'(3).    a'(4). a'(1). a nový dotaz ?- a'(Z).
Hana Řudová, Logické programování I, 19. kvetna 2010
274
Preklad
Parciální vyhodnocení - príklad
a(X,Y) :- b(X), c(X,Y). a(X,Y) :- b(Y), c(Y,X).
b(1).     b(2).     b(3). b(4).
c(1,2).     c(1,3).     c(1,4).     c(2,3).     c(2,4). c(3,4). Dotaz ?- a(2,Z).
lze spolecne s uvedeným programem parciálne vyhodnotit na nový program a'(3).    a'(4). a'(1). a nový dotaz ?- a'(Z).
Je evidentní, že dotaz nad parciálne vyhodnoceným programem bude zpracován mnohem rychleji (efektivneji) než v prípade původního programu.
Hana Rudová, Logické programování I, 19. kvetna 2010
274
Preklad
Parciální vyhodnocení II
Konstrukce p rekladace: parciálním vyhodnocením interpretu Problémy:
& príliš složitá operace
A vyhodnocení se musí provést vždy znovu pro každý nový program
JS> výsledný program príliš rozsáhlý JS> nedostatecná dekompozice
-fc zejména pri použití zdrojového jazyka jako implementacního jazyka interpretu
Hana Rudová, Logické programování I, 19. kvetna 2010
275
Preklad
Parčiální vyhodnočení II
Konstrukče prekladače: parciálním vyhodnocením interpretu Problémy:
& príliš složitá operace
A vyhodnocení se musí provést vždy znovu pro každý nový program
JS> výsledný program príliš rozsáhlý JS> nedostatecná dekompozice
-fc zejména pri použití zdrojového jazyka jako implementacního jazyka interpretu Vhodnejší:
JS> využití („rucního") parciálního vyhodnocení pro návrh abstraktního pocítace
1. nalezení operací zdrojového jazyka, které lze dekomponovat do jednodušších operací
2. dekomponujeme tak dlouho, až jsou výsledné operace dostatecne jednoduché nebo již neexistují informace pro parciální vyhodnocení
Hana Rudová, Logické programování I, 19. kvetna 2010 275 Preklad
Parciální vyhodnocení Prologu
Cílová operače: unifikace. Duvod:
rízení výpočtu pomerne podrobné i v interpretu £ unifikače v interpretu atomičkou operačí
& unifikače v interpretu nahrazuje radu podstatne jednoduššíčh operačí (testy, p r i r azení, p r edání a p r evzetí parametrů ...)
& vetšina unifikačí nevyžaduje obečnou unifikači a lze je nahradit jednoduššími operačemi
Hana Rudová, Logičké programování I, 19. kvetna 2010
276
Preklad
Parciální vyhodnocění Prologu
Cílová operace: unifikacě. Duvod:
Ä rízení výpoctu pomerne podrobné i v interpretu
JG* unifikace v interpretu atomickou operací
& unifikace v interpretu nahrazuje radu podstatne jednodušších operací (testy, p r i r azení, p r edání a p r evzetí parametrů ...)
& vetšina unifikací nevyžaduje obecnou unifikaci a lze je nahradit jednoduššími operacemi
Zviditělnění unifikacě: transformací zdrojového programu
termy reprezentujeme kopírováním struktur na globálním zásobníku
& parametry procedur jsou vždy umísteny na globální zásobník (predikátem put/2) a p r edáványjsou pouze adresy
& formálním parametrem procedury jsou pouze volné promenné, které se v hlave vyskytují pouze jednou
JG* všechny unifikace jsou explicitne zachyceny voláním predikátu unify/2
Hana Rudová, Logické programování I, 19. kvetna 2010 276 Preklad
Explicitní unifikace
Príklad: append/3 s explicitní unifikací:
append(A1, A2, A3) :- unify(A1,[]), | append([],L,L).
unify(A2,L), | unify(A3,L).
Hana Řudová, Logické programování I, 19. kvetna 2010
277
Preklad
Explicitní unifikace
Príklad: append/3 s explicitní unifikací:
append(A1, A2, A3)
append(A1, A2, A3)
:- unify(A1,[]),
unify(A2,L),
unify(A3,L). :- unify(A1,[A|X]),
unify(A2,L),
unify(A3,[A|Y]),
put(X,B1),
put(L,B2),
put(Y,B3),
append(B1,B2,B3).
| append([],L,L).
| append([A|X],L,[A|Y] :-
append(X,L,Y).
Hana Rudová, Logické programování I, 19. kvetna 2010
277
Preklad
Explicitní unifikace
Príklad: append/3 s explicitní unifikací:
append(A1, A2, A3)
append(A1, A2, A3)
:- unify(A1,[]),
unify(A2,L),
unify(A3,L). :- unify(A1,[A|X]),
unify(A2,L),
unify(A3,[A|Y]),
put(X,B1),
put(L,B2),
put(Y,B3),
append(B1,B2,B3).
| append([],L,L).
| append([A|X],L,[A|Y] :-
append(X,L,Y).
Cíl: parciálne vyhodnotit predikáty unify/2 a put/2
Hana Rudová, Logické programování I, 19. kvetna 2010
277
Preklad
Pomocné termy a predikáty
term $addr$(A) - odkaz na objekt s adresou A
predikát is_addr(P,V) - je-li P ve tvaru $addr$(A), pak V se unifikuje s hodnotou slova na adrese A (jinak predikát selže)
predikát : = (X,T) - priradí volné promenné X term T;
X musí být volná promenná.
Hana Rudová, Logické programování I, 19. kvetna 2010
278
Preklad
Pomocné termy a predikáty
term $addr$(A) - odkaz na objekt s adresou A
predikát is_addr(P,V) - je-li P ve tvaru $addr$(A), pak V se unifikuje s hodnotou slova na adrese A (jinak predikát selže)
predikát : = (X,T) - priradí volné promenné X term T;
X musí být volná promenná.
predikát repres(A,Tag,V) - uloží do promenné Tag príznak a do
promenné V hodnotu slova na adrese A.
A musí být adresa na globálním zásobníku, Tag i V musí být volné promenné.
príznak: informace o strukture soucástí objektu
volná promenná FREE, konstanta CONST, celé císlo INT, odkaz REF, složený term FUNCT
Hana Rudová, Logické programování I, 19. kvetna 2010
278
Preklad
Pomocné termy a predikáty
-í* term $addr$(A) - odkaz na objekt s adresou A
& predikát is_addr(P,V) — je-li P ve tvaru $addr$(A), pak V se unifikuje s hodnotou slova na adrese A (jinak predikát selže)
JS> predikát : = (X,T) — priradí volné promenné X term T;
X musí být volná promenná.
predikát repres(A,Tag,V) — uloží do promenné Tag príznak a do
promenné V hodnotu slova na adrese A.
A musí být adresa na globálním zásobníku, Tag i V musí být volné promenné.
príznak: informace o strukture součástí objektu
volná promenná FŘEE, konstanta CONST, celé číslo INT, odkaz ŘEF, složený term FUNCT
-í* je-li A adresa a i celočíselná konstanta, pak výraz A+i reprezentuje adresu o i slov vyšší (ukazatelová aritmetika)
Hana Řudová, Logické programování I, 19. kvetna 2010 278 Preklad
unify pro volnou proměnnou
unify(A,T) unifikuje term na adrese A (aktuální parametr) s termem T (formální parametr). Podle hodnoty T mohou nastat následujíčí 4 p rípady:
1) T je volná promenná: výsledkem je instančiače
unify(A,T) :- var(T),
( var(A), create_var(A)
;   true ),
T := $addr$(A).
Hana Rudová, Logičké programování I, 19. kvetna 2010
279
Preklad
unify pro volnou promennou
unify(A,T) unifikuje term na adrese A (aktuální parametr) s termem T (formální parametr). Podle hodnoty T mohou nastat následující 4 prípady:
1) T je volná promenná: výsledkem je instanciace
unify(A,T) :- var(T),
( var(A), create_var(A)
;   true ),
T := $addr$(A).
Disjunkce garantuje, že A je korektní adresa na globálním zásobníku: nutný run-time test, tedy nelze využít pri parc. prekladu. Lze proto prepsat na
unify(A,T) :- var(T),
unify_var(A,T).
kde unify_var/2 vloží do T odkaz nebo založí novou promennou.
Hana Rudová, Logické programování I, 19. kvetna 2010
279
Preklad
unify pro konstantu
2) T je konstanta: výsledkem je test nebo přiřazení
unify(A,T) :-atomic(T),
( ( var(A), create_var(A), instantiate_const(A,T) ) ; ( repres(A,Tag,Value), Tag == 'FREE', instantiate_const(A,T) ; Tag == 'CONST', Value == T )
)■
kde instantiate_const/2 uloží do slova s adresou A hodnotu T.
Hana Rudová, Logické programování I, 19. kvetna 2010
280
Preklad
unify pro konstantu
2) T je konstanta: výsledkem je test nebo prirazení
unify(A,T) :-atomic(T),
( ( var(A), create_var(A), instantiate_const(A,T) ) ; ( repres(A,Tag,Value), Tag == 'FREE', instantiate_const(A,T) ; Tag == 'CONST', Value == T )
kde instantiate_const/2 uloží do slova s adresou A hodnotu T. Opet možno prepsat do kompaktního tvaru
unify(A,T) :-atomic(T), unify_const(A,T).
kde unify_const/2 provede príslušný test nebo prirazení.
Hana Rudová, Logické programování I, 19. kvetna 2010 280 Preklad
unify pro složený term
3) T je složený term: dvoufázové zpracování, v první fázi test nebo založení funktoru, v druhé rekurzivní unifikace argumentů
unify(A,T) :-struct(T), functor(T,F,N), unify_struct(F,N,A),
T =.. UTl], unify_args(Tl,A+1).
Predikát unify_struct/3 je analogický výše použitým predikátum unify_var/2 a unify_const/2.
Hana Rudová, Logické programování I, 19. kvetna 2010
281
Preklad
unify pro složený term
3) T je složený term: dvoufázové zpracování, v první fázi test nebo založení funktoru, v druhé rekurzivní unifikace argumentů
unify(A,T) :-struct(T), functor(T,F,N), unify_struct(F,N,A), T =.. [_|Tl], unify_args(Tl,A+1).
Predikát unify_struct/3 je analogický výše použitým predikátum unify_var/2 a unify_const/2.
Druhá fáze: unify_args([],_).
unify_args([T|Tl], A) :-unify(A,T), unify_args(Tl,A+1).
Hana Rudová, Logické programování I, 19. kvetna 2010 281 Preklad
unify pro odkaz
4) T je odkazem: nutno použít obecnou unifikaci (není žádná informace pro parciální vyhodnocení)
unify(A,T) :-
is_addr(T,P), unification(A,P).
Hana Rudová, Logické programování I, 19. kvetna 2010
282
Preklad
put
Parametry pročedur jsou vždy umísteny na globální zásobník predikátem put/2 a p r edáványjsou pouze adresy.
Predikát put/2 je jednodušší (nikdy nepotr ebuje unifikači)
put(T,B) :-
is_addr(T,B). %Tje odkaz
put(T,B) :-
var(T), %Tje promenná
create_var(B),
T := $addr$(B). put(T,B) :-
atomic(T), %T je konstanta
create_const(B,T). put(T,B) :-
struct(T), %Tje struktura
create_struct(B,T).
Hana Rudová, Logičké programování I, 19. kvetna 2010
283
Preklad
První klauzule append/3
Parciální vyhodnocení první klauzule programu append/3
append(A1, A2, A3) :- unify(A1,[]), | append([],L,L).
unify(A2,L), | unify(A3,L). |
upraví
unify(A1,[]) na unify_const(A1,[])
unify(A2,L)    na L:=$addr$(A2)
unify(A3,L)   na is_addr(L,T), unification(T,A3)
Hana Řudová, Logické programování I, 19. kvetna 2010
284
Preklad
První klauzule append/3
Parciální vyhodnocení první klauzule programu append/3
append(A1, A2, A3) :- unify(A1,[]), | append([],L,L).
unify(A2,L), | unify(A3,L). |
upraví
unify(A1,[]) na unify_const(A1,[])
unify(A2,L)    na L:=$addr$(A2)
unify(A3,L)   na is_addr(L,T), unification(T,A3)
posloupnost L:=$addr$(A2), is_addr(L,T) odpovídá prejmenování T na A2
Hana Řudová, Logické programování I, 19. kvetna 2010
284
Preklad
První klauzule append/3
Parciální vyhodnocení první klauzule programu append/3
append(A1, A2, A3) :- unify(A1,[]), | append([],L,L).
unify(A2,L), | unify(A3,L). |
upraví
unify(A1,[]) na unify_const(A1,[])
unify(A2,L)    na L:=$addr$(A2)
unify(A3,L)   na is_addr(L,T), unification(T,A3)
posloupnost L:=$addr$(A2), is_addr(L,T) odpovídá prejmenování T na A2
=> není nutné vytváret novou promennout T
=> stací provést unification(A2,A3)
Hana Rudová, Logické programování I, 19. kvetna 2010
284
Preklad
Výsledný tvar append/3
append(A1, A2, A3) :-
unify_const(A1,[]),
unification(A2,A3). append(A1, A2, A3) :-
unify_struct('.',2,A1),
unify_var(A,A1+1),
unify_var(X,A1+2),
unify_var(L,A2),
unify_struct('.',2,A3),
unification(A1+1,A3+1),
unify_var(Y,A3+2),
append(A1+2,A2,A3+2).
Vetšina původních unifikací prevedena unifikace v posledním kroku je nezbytná
append(A1, A2, A3) :-
unify(A1,[]),
unify(A2,L), unify(A3,L). append(A1, A2, A3) :-
unify(A1,[A|X]),
unify(A2,L), unify(A3,[A|Y]),
put(X,B1), put(L,B2), put(Y,B3), append(B1,B2,B3).
jednodušší operace; (důsledkem dvojího výskytu promenné)
Hana Rudová, Logické programování I, 19. kvetna 2010
285
Preklad
Jiný príklad
a(c,s(f),d,X) :- g(X).
Procedurální pseudokód (testy a přiřazení) a kód abstraktního počítače:
proceduře a(X,Y,Z,A) is |
if ( X == 'c' && | ( is_struct(Y,'s',1) && |
first_arg(Y) == f ) && |
Z == 'ď   ) |
then |
call g(A) |
else |
a(A1, A2, A3, A4) :-unify_const(c,A1), unify_struct(s,1,A2), unify_const(f,A2+1), unify_const(d,A3), unify_var(A,A4), g(A4).
call fail | end procedure tj. posloupnost testů jako v procedurálním jazyce
Hana Rudová, Logické programování I, 19. kvetna 2010
286
Preklad
Jiný příklad
a(c,s(f),d,X) :- g(X).
Procedurální pseudokód (testy a p r i razení) a kód abstraktního pocítace:
procedure a(X,Y,Z,A) is |
if ( X == 'c' && | ( is_struct(Y,'s',1) && |
first_arg(Y) == f ) && |
Z == 'ď   ) |
then |
call g(A) |
else |
a(A1, A2, A3, A4) :-unify_const(c,A1), unify_struct(s,1,A2), unify_const(f,A2+1), unify_const(d,A3), unify_var(A,A4), g(A4).
call fail I end procedure tj. posloupnost testů jako v procedurálním jazyce
Vyzkoušejte si: delete(X,  [YjT],  [Y|T1]) :- delete(X, T, T1).
Hana Rudová, Logické programování I, 19. kvetna 2010
286
Preklad
Warrenův abstraktní počítač, 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 vestavené predikátý (nemení se) -i- obsahuje rovnež 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)
& Pomočný zásobník (Push Down List, PDL)
pracovní pamet' abstraktního pocítace -i- použitý v unifikaci, syntaktické analýze apod.
Hana Rudová, Logické programování I, 19. kvetna 2010
287
Preklad
Rozmístení datových oblastí
Príklad konfigurače
Halda
Stopa
Zásobník
PDL
Oblast kodu
Ý A
Halda i lokální zásobník musí mst stejným smerem
-i- lze jednoduše porovnat stár í dvou promennýčh srovnáním adres využívá se p r i zabránení vzniku visíčíčh odkazu
Hana Rudová, Logičké programování I, 19. kvetna 2010
288
Preklad
Registry WAMu
JS> Stavové registry:
P citac adres (Program counter)
CP adresa návratu (Continuation Pointer)
E ukazatel na nejmladší okolí (Environment)
B ukazatel na nejmladší bod volby (Backtrack point)
TR vrchol stopy (TRail)
H vrchol haldy (Heap)
HB vrchol haldy v okamžiku založení posledního bodu volby (Heap on Backtrack point)
S ukazatel, používaný pri analýze složených termu (Structure pointer)
CUT ukazatel na bod volby, na který se rezem zarízne zásobník
Argumentové registry: A1,A2,...       (pri predávání parametru n. pracovní registry)
Registry pro lokální promenné: Y1,Y2,...
abstraktní znázornení lok. promenných na zásobníku
Hana Rudová, Logické programování I, 19. kvetna 2010 289 Preklad
Typy instrukcí WAMu
& put instrukce - príprava argumentů pred voláním podcíle A žádná z techto instrukcí nevolá obecný unifikacní algoritmus
& get instrukce - unifikace aktuálních a formálních parametru
-i- vykonávají cinnost analogickou instrukcím unify u parc. vyhodnocení -fc obecná unifikace pouze pri get_value
& unify instrukce - zpracování složených termů
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 pri unify_value a unify_local_value
Indexacní instrukce - indexace klauzulí a manipulace s body volby & Instrukce rízení behu - predávání rízení a explicitní manipulace s okolím
Hana Rudová, Logické programování I, 19. kvetna 2010 290 Preklad
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	A1,f
put_value	A2,A5
put_value	A3,A6
put_value	A4,A7
execute	b/4
Hana Rudová, Logické programování I, 19. kvetna 2010
291
Preklad
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, 19. kvetna 2G1G
292
Preklad
Instrukcě unify, get, put
Vetší pocet typu objektů
& rozlišeny atomy, císla, nil = prázdný seznam, seznam speciální druh složeního termu
unify_void umožní preskocit anonymních promenné ve složených termech & put_unsafe_value pro optimalizaci práce s lokálními promennými pri TRO
a(X) :- b(X,Y),  !, a(Y).
pri TRO nesmí být lokální promenné posledního literálu (Y) na lokálním zásobníku
J* kompilátor muže všechny něbězpěcné (unsafe) výskyty lok. promenných detekovat pri prekladu (jsou to poslední výskyty lok. promenných) a generuje složitejší instrukce put_unsafe_value, které provádejí test umístení
Hana Rudová, Logické programování I, 19. kvetna 2010
293
Preklad
Instrukce unify, get, put
C Vetší počet typu objektu
J* rozlišeny atomy, čísla, nil = prázdný seznam, seznam speciální druh složeního termu
unify_void umožní preskočit anonymních promenné ve složených termech & put_unsafe_value pro optimalizaci práce s lokálními promennými pri TRO
a(X) :- b(X,Y),  !, a(Y).
pri TRO nesmí být lokální promenné posledního literálu (Y) na lokálním zásobníku
J* kompilátor muže všechny nebezpečné (unsafe) výskyty lok. promenných detekovat pri prekladu (jsou to poslední výskyty lok. promenných) a generuje složitejší instrukce put_unsafe_value, které provádejí test umístení
unify_local_value kvuliTROjako put_unsafe_value
-i- a(X) :- d(X), b(s(Y),X).    objekt prístupný pres Y opet nesmí být na lok. zásobníku doba života s/1 muže být delší než doba života okolí na než se Y odkazuje
Jť unify_local_value testují umístení a pokud nutné presouvají objekty na haldu
Hana Rudová, Logické programování I, 19. kvetna 2010 293 Preklad
WAM - indexace
Provázání klauzulí: instrukče 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úspečhu
Hana Rudová, Logičké programování I, 19. kvetna 2010
294
Preklad
WAM - indexače
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
ii> Provázání podmnožiny klauzulí (podle argumentu):
S try
retry -i- trust
Hana Rudová, Logické programování I, 19. kvetna 2010
294
Preklad
WAM - inděxacě
Provázání klauzulí: instrukce XX_me_e1se:
M první klauzule: try_me_e1se; založí bod volby
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 -k 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, 19. kvetna 2010
294
Preklad
Príklad indexace instrukcí
Procedu re a(atom) :- body1. 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 L1, L2, L3, L4 L2:     switch_on_const   atom :L1a
1 :L5a
2 :L6a L3:     try L7a
trust L8a L4:     switch_on_struct s/1 :L9a
f/1 :L10a
L1:    try_me_else L5 L1a: body1
L5:     retry_me_else L6
Hana Rudová, Logické programování I, 19. května 2010
L5a:	body2	
L6:	retry_me_else	L7
L6a:	body3	
L7:	retry_me_else	L8
L7a:	body4	
L8:	retry_me_else	L9
L8a:	body5	
L9:	retry_me_else	L10
L9a:	body6	
L10:	trust_me_else	fail
L10a:	body7	
295 Preklad
WAM - r ízení výpočtu
& execute Proc: ekvivalentní príkazu goto
Hana Rudová, Logické programování I, 19. kvetna 2010
296
Preklad
WAM - rízení výpoCtu
& execute Proc: ekvivalentní príkazu goto J5> proceed: zpracování faktu
Hana Rudová, Logické programování I, 19. kvetna 2010
296
Preklad
WAM - r ízení výpočtu
& 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, 19. kvetna 2010
296
Preklad
WAM - řízení výpočtu
& execute Proc: ekvivalentní príkazu goto
J5> proceed: zpracování faktů
M allocate: alokuje okolí (pro nekteré 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)
Hana Rudová, Logické programování I, 19. kvetna 2010
296
Preklad
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, 19. kvetna 2010 296 Preklad
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). může být nedeterministické, ale ?- a(1). muže být deterministické
Hana Rudová, Logické programování I, 19. kvetna 2010
297
Preklad
WAM - rez
Implementace rezu (opakování): odstranení bodu 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_last:     B := CUT save_cut Y:    Y := CUT load_cut Y:     B := Y
Hana Rudová, Logické programování I, 19. kvetna 2010
297
Preklad
WAM - rěz
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é
cut_last:     B := CUT save_cut Y:    Y := CUT load_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_last. V opacném p r ípade se použije
jako první instrukce save_cut Y a v míste skutecného volání r ezu se použije load_cut Y.
Hana Rudová, Logické programování I, 19. kvetna 2010
297
Preklad
WAM - řez
Implementace rezu (opakování): odstranení bodu 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_last:     B := CUT save_cut Y:    Y := CUT load_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_last. 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 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, 19. kvetna 2010 297 Preklad
WAM - optimalizace
1. Indexace klauzulí
2. Generování optimální posloupnosti instrukcí WAMu
3. Odstranění redundancí p r i generování cílového kódu.
Hana Rudová, Logičké programování I, 19. kvetna 2010
298
Preklad
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, 19. kvetna 2010 298 Preklad