IB013 Logické programování I
Hana Rudová
jaro 2007
Hodnocení předmětu
Zápočtový projekt: celkem až 40 bodů
Průběžná písemná práce: až 30 bodů (základy programování v Prologu)
pro každého jediný termín: 19. března
alternativní termín pouze v případech závažných důvodů pro neúčast
Závěrečná písemná práce: až 150 bodů
cca tři řádné termíny písemky, vzor písemky na webu předmětu
žádná opravná písemka
opravný termín: ústní zkouška
alternativní termín po dohodě jen v případech závažných důvodů pro neúčast
spíše formou delší ústní zkoušky
Hodnocení: součet bodů za projekt a za obě písemky
známka A za cca 175 bodů, známka F za cca 110 bodů
známka bude zapsána pouze těm, kteří dostanou zápočet za projekt
Hana Rudová, Logické programování I, 17. května 2007 2 Organizace předmětu
Základní informace
Přednáška: účast není povinná
Cvičení: zápočet udělen za zápočtový projekt
Web předmětu na IS: Studijní materiály -> Titulní strana
https://is.muni.cz/auth/elearning/warp.pl?fakulta=1433;obdobi=3524;kod=IB013;qurl=/el/1433/jaro2007/IB013/index.qwarp
průsvitky dostupné postupně v průběhu semestru
harmonogram výuky
předběžný obsah výuky pro jednotlivé přednášky během semestru
elektronicky dostupné materiály
Obsah přednášky
základy programování v jazyce Prolog
teorie logického programováni
logické programování s omezujícími podmínkami
implementace logického programováni
Hana Rudová, Logické programování I, 17. května 2007 3 Organizace předmětu
Literatura
Bratko, I. Prolog Programming for Artificial Intelligence.
Addison-Wesley, 2001.
prezenčně v knihovně
Clocksin, W. F. ­ Mellish, Ch. S. Programming in Prolog. Springer, 1994.
Sterling, L. ­ Shapiro, E. Y. The art of Prolog : advanced programming
techniques. MIT Press, 1987.
Nerode, A. ­ Shore, R. A. Logic for applications. Springer-Verlag, 1993.
prezenčně v knihovně
Dechter, R. Constraint Processing. Morgan Kaufmann Publishers, 2003.
prezenčně v knihovně
+ Elektronicky dostupné materiály (viz web předmětu)
Hana Rudová, Logické programování I, 17. května 2007 4 Organizace předmětu
Software: SICStus Prolog
Doporučovaná implementace Prologu
Dokumentace: http://www.fi.muni.cz/~hanka/sicstus/doc/html
Komerční produkt
Zakoupena licence pro instalace na domácí počítače studentů
Podrobné informace na webu předmětu
Hana Rudová, Logické programování I, 17. května 2007 5 Organizace předmětu
Cvičení
Zaměřeno na praktické aspekty, u počítačů
Skupiny:
skupina 01, sudé pondělí, první cvičení 19.února
skupina 02, liché pondělí, první cvičení 26.února
Zápočtové projekty: Adriana Strejčková <ada@fi.muni.cz>
zápočtové projekty dostupné přes web předmětu
podrobné pokyny k zápočtovým projektům na webu předmětu
vystavení projektů na webu předmětu: do 28.února
zahájení registrace řešitelů projektu: 14. března
předběžná analýza řešeného problému: 4. dubna
termín pro odevzdání projektů: 18. května
předvádění projektů (po registraci): 28.května - 15.června
Hana Rudová, Logické programování I, 17. května 2007 6 Organizace předmětu
Průběžná písemná práce
Pro každého jediný termín 19. března
Alternativní termín pouze v závažných důvodech pro neúčast
Celkem až 30 bodů (150 závěrečná písemka, 40 projekt)
Hana Rudová, Logické programování I, 17. května 2007 7 Organizace předmětu
Průběžná písemná práce
Pro každého jediný termín 19. března
Alternativní termín pouze v závažných důvodech pro neúčast
Celkem až 30 bodů (150 závěrečná písemka, 40 projekt)
3 příklady, 40 minut
Napsat zadaný predikát, porovnat chování programů
Oblasti, kterých se budou příklady zejména týkat
unifikace
backtracking
řez
seznamy
optimalizace posledního volání
aritmetika
Ukázka průběžné písemné práce na webu
Hana Rudová, Logické programování I, 17. května 2007 7 Organizace předmětu
Úvod do Prologu
Prolog
PROgramming in LOGic
část predikátové logiky prvního řádu
Deklarativní programování
specifikační jazyk, jasná sémantika, nevhodné pro procedurální postupy
Co dělat namísto Jak dělat
Základní mechanismy
unifikace, stromové datové struktury, automatický backtracking
Hana Rudová, Logické programování I, 17. května 2007 9 Úvod do Prologu
Prolog: historie a současnost
Rozvoj začíná po roce 1970
Robert Kowalski ­ teoretické základy
Alain Colmerauer, David Warren (Warren Abstract Machine) ­ implementace
pozdější rozšíření Prologu o logické programování s omezujícími podmínkami
Hana Rudová, Logické programování I, 17. května 2007 10 Úvod do Prologu
Prolog: historie a současnost
Rozvoj začíná po roce 1970
Robert Kowalski ­ teoretické základy
Alain Colmerauer, David Warren (Warren Abstract Machine) ­ implementace
pozdější rozšíření Prologu o logické programování s omezujícími podmínkami
Prolog v současnosti
zavedené aplikační oblasti, nutnost přidání inteligence
hypotéky; pediatrický sw; konfigurace a pravidla pro stanovení ceny objednávky;
testovací nástroje, modelové testování; ...
náhrada procedurálního kódu Prologem vede k
desetinásobnému zmenšení kódu, řádově menšímu času na vývoj, jednodušší údržbě
efektivita Prologu?
zrychlení počítačů + výrazné zvětšení nároků sw
 ve prospěch kompaktnosti i rychlosti Prologu
Hana Rudová, Logické programování I, 17. května 2007 10 Úvod do Prologu
Program = fakta + pravidla
(Prologovský) program je seznam programových klauzulí
programové klauzule: fakt, pravidlo
Fakt: deklaruje vždy pravdivé věci
clovek( novak, 18, student ).
Pravidlo: deklaruje věci, jejichž pravdivost závisí na daných podmínkách
studuje( X ) :- clovek( X, _Vek, student ).
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
pracuje( X ) :- clovek( X, _Vek, CoDela ), prace( CoDela ).
Hana Rudová, Logické programování I, 17. května 2007 11 Úvod do Prologu
Program = fakta + pravidla
(Prologovský) program je seznam programových klauzulí
programové klauzule: fakt, pravidlo
Fakt: deklaruje vždy pravdivé věci
clovek( novak, 18, student ).
Pravidlo: deklaruje věci, jejichž pravdivost závisí na daných podmínkách
studuje( X ) :- clovek( X, _Vek, student ).
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
pracuje( X ) :- clovek( X, _Vek, CoDela ), prace( CoDela ).
Predikát: množina pravidel a faktů se stejným funktorem a aritou
značíme: clovek/3, student/1; analogie procedury v procedurálních jazycích,
Hana Rudová, Logické programování I, 17. května 2007 11 Úvod do Prologu
Komentáře k syntaxi
Klauzule ukončeny tečkou
Základní příklady argumentů
konstanty: (tomas, anna) . . . začínají malým písmenem
proměnné
X, Y . . . začínají velkým písmenem
_, _A, _B . . . začínají podtržítkem (nezajímá nás vracená hodnota)
Psaní komentářů
clovek( novak, 18, student ). % komentář na konci řádku
clovek( novotny, 30, ucitel ). /* komentář */
Hana Rudová, Logické programování I, 17. května 2007 12 Úvod do Prologu
Dotaz
Dotaz: uživatel se ptá programu, zda jsou věci pravdivé
?- studuje( novak). % yes splnitelný dotaz
?- studuje( novotny). % no nesplnitelný dotaz
Odpověd' na dotaz
positivní ­ dotaz je splnitelný a uspěl
negativní ­ dotaz je nesplnitelný a neuspěl
Hana Rudová, Logické programování I, 17. května 2007 13 Úvod do Prologu
Dotaz
Dotaz: uživatel se ptá programu, zda jsou věci pravdivé
?- studuje( novak). % yes splnitelný dotaz
?- studuje( novotny). % no nesplnitelný dotaz
Odpověd' na dotaz
positivní ­ dotaz je splnitelný a uspěl
negativní ­ dotaz je nesplnitelný a neuspěl
Proměnné jsou během výpočtu instanciovány (= nahrazeny objekty)
?- clovek( novak, 18, Prace ).
výsledkem dotazu je instanciace proměnných v dotazu
dosud nenainstanciovaná proměnná: volná proměnná
Hana Rudová, Logické programování I, 17. května 2007 13 Úvod do Prologu
Dotaz
Dotaz: uživatel se ptá programu, zda jsou věci pravdivé
?- studuje( novak). % yes splnitelný dotaz
?- studuje( novotny). % no nesplnitelný dotaz
Odpověd' na dotaz
positivní ­ dotaz je splnitelný a uspěl
negativní ­ dotaz je nesplnitelný a neuspěl
Proměnné jsou během výpočtu instanciovány (= nahrazeny objekty)
?- clovek( novak, 18, Prace ).
výsledkem dotazu je instanciace proměnných v dotazu
dosud nenainstanciovaná proměnná: volná proměnná
Prolog umí generovat více odpovědí pokud existují
?- clovek( novak, Vek, Prace ). % všechna řešení přes ";"
Hana Rudová, Logické programování I, 17. května 2007 13 Úvod do Prologu
Klauzule = fakt, pravidlo, dotaz
Klauzule se skláda z hlavy a těla
Tělo je seznam cílů oddělených čárkami, čárka = konjunkce
Fakt: pouze hlava, prázdné tělo
rodic( pavla, robert ).
Pravidlo: hlava i tělo
upracovany_clovek( X ) :- clovek( X, _Vek, Prace ), prace( Prace, tezka ).
Dotaz: prázdná hlava, pouze tělo
?- clovek( novak, Vek, Prace ).
?- rodic( pavla, Dite ), rodic( Dite, Vnuk ).
Hana Rudová, Logické programování I, 17. května 2007 14 Úvod do Prologu
Rekurzivní pravidla
predek( X, Z ) :- rodic( X, Z ). % (1)
predek( X, Z ) :- rodic( X, Y ), % (2)
rodic( Y, Z ).
Hana Rudová, Logické programování I, 17. května 2007 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, 17. května 2007 15 Úvod do Prologu
Příklad: rodokmen
rodic( pavla, robert ).
rodic( tomas, robert ).
rodic( tomas, eliska ).
rodic( robert, anna ).
rodic( robert, petr ).
rodic( petr, jirka ).
predek( X, Z ) :- rodic( X, Z ). % (1)
predek( X, Z ) :- rodic( X, Y ), % (2')
predek( Y, Z ).
anna petr
pavla tomas Rodice
robert eliska
jirka Deti
Hana Rudová, Logické programování I, 17. května 2007 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( X, Z ) :- rodic( X, Z ). % (1)
predek( X, Z ) :- rodic( X, Y ), % (2')
predek( Y, Z ).
dle (1)
predek(tomas,robert)
rodic(tomas,robert)yes
Hana Rudová, Logické programování I, 17. května 2007 17 Úvod do Prologu
Výpočet odpovědi na dotaz ?- predek(tomas, petr)
predek( robert, petr)
predek( Y, petr)
rodic( tomas, petr) rodic(tomas, Y)
predek(tomas, petr)
dle (1) dle (2')
rodic(robert, petr) yes
no
Y=robert dle rodic(tomas, robert)
dle (1)
rodic( tomas, robert ).
rodic( tomas, eliska ).
rodic( robert, petr ).
predek( X, Z ) :- rodic( X, Z ). % (1)
predek( X, Z ) :- rodic( X, Y ), % (2')
predek( Y, Z ).
Hana Rudová, Logické programování I, 17. května 2007 18 Úvod do Prologu
Odpověd' na dotaz ?- predek(robert, Potomek)
anna petr
pavla tomas Rodice
robert eliska
jirka Deti
rodic( pavla, robert ).
rodic( tomas, robert ).
rodic( tomas, eliska ).
rodic( robert, anna ).
rodic( robert, petr ).
rodic( petr, jirka ).
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, 17. května 2007 19 Úvod do Prologu
Syntaxe a význam Prologovských programů
Syntaxe Prologovských programů
Typy objektů jsou rozpoznávány podle syntaxe
Atom
řetězce písmen, čísel, ,,_" začínající malým písmenem: pavel, pavel_novak, x25
řetězce speciálních znaků: <-->, ====>
řetězce v apostrofech: 'Pavel', 'Pavel Novák'
Celá a reálná čísla: 0, -1056, 0.35
Proměnná
řetězce písmen, čísel, ,,_" začínající velkým písmenem nebo ,,_"
anonymní proměnná: ma_dite(X) :- rodic( X, _ ).
hodnotu anonymní proměnné Prolog na dotaz nevrací: ?- rodic( X, _ )
lexikální rozsah proměnné je pouze jedna klauzule:
prvni(X,X,X).
prvni(X,X,_).
Hana Rudová, Logické programování I, 17. května 2007 21 Syntaxe a význam Prologovských programů
Termy
Term ­ datové objekty v Prologu: datum( 1, kveten, 2003 )
funktor: datum
argumenty: 1, kveten, 2003
arita ­ počet argumentů: 3
Všechny strukturované objekty v Prologu jsou stromy
trojuhelnik( bod(4,2), bod(6,4), bod(7,1) )
Hlavní funktor termu ­ funktor v kořenu stromu odpovídající termu
trojuhelnik je hlavní funktor v trojuhelnik( bod(4,2), bod(6,4), bod(7,1) )
Hana Rudová, Logické programování I, 17. května 2007 22 Syntaxe a význam Prologovských programů
Unifikace
Termy jsou unifikovatelné, jestliže
jsou identické nebo
proměnné v obou termech mohou být instanciovány tak,
že termy jsou po substituci identické
datum( D1, M1, 2003 ) = datum( 1, M2, Y2) operátor =
D1 = 1, M1 = M2, Y2 = 2003
Hana Rudová, Logické programování I, 17. května 2007 23 Syntaxe a význam Prologovských programů
Unifikace
Termy jsou unifikovatelné, jestliže
jsou identické nebo
proměnné v obou termech mohou být instanciovány tak,
že termy jsou po substituci identické
datum( D1, M1, 2003 ) = datum( 1, M2, Y2) operátor =
D1 = 1, M1 = M2, Y2 = 2003
Nejobecnější unifikátor (most general unifier (MGU)
jiné instanciace? . . . D1 = 1, M1 = 5, Y2 = 2003
?- datum( D1, M1, 2003 ) = datum( 1, M2, Y2), D1 = M1.
Hana Rudová, Logické programování I, 17. května 2007 23 Syntaxe a význam Prologovských programů
Unifikace
Termy jsou unifikovatelné, jestliže
jsou identické nebo
proměnné v obou termech mohou být instanciovány tak,
že termy jsou po substituci identické
datum( D1, M1, 2003 ) = datum( 1, M2, Y2) operátor =
D1 = 1, M1 = M2, Y2 = 2003
Nejobecnější unifikátor (most general unifier (MGU)
jiné instanciace? . . . D1 = 1, M1 = 5, Y2 = 2003
?- 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, 17. května 2007 23 Syntaxe a význam Prologovských programů
Unifikace
Termy S a T jsou unifikovatelné, jestliže
1. S a T jsou konstanty a tyto konstanty jsou identické;
2. S je proměnná a T cokoliv jiného ­ S je instanciována na T;
T je proměnná a S cokoliv jiného ­ T je instanciována na S
3. S a T jsou termy
S a T mají stejný funktor a aritu a
všechny jejich odpovídající argumenty jsou unifikovatelné
výsledná substituce je určena unifikací argumentů
Příklady:
k = k ... yes, k1 = k2 ... no,
Hana Rudová, Logické programování I, 17. května 2007 24 Syntaxe a význam Prologovských programů
Unifikace
Termy S a T jsou unifikovatelné, jestliže
1. S a T jsou konstanty a tyto konstanty jsou identické;
2. S je proměnná a T cokoliv jiného ­ S je instanciována na T;
T je proměnná a S cokoliv jiného ­ T je instanciována na S
3. S a T jsou termy
S a T mají stejný funktor a aritu a
všechny jejich odpovídající argumenty jsou unifikovatelné
výsledná substituce je určena unifikací argumentů
Pří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, 17. května 2007 24 Syntaxe a význam Prologovských programů
Unifikace
Termy S a T jsou unifikovatelné, jestliže
1. S a T jsou konstanty a tyto konstanty jsou identické;
2. S je proměnná a T cokoliv jiného ­ S je instanciována na T;
T je proměnná a S cokoliv jiného ­ T je instanciována na S
3. S a T jsou termy
S a T mají stejný funktor a aritu a
všechny jejich odpovídající argumenty jsou unifikovatelné
výsledná substituce je určena unifikací argumentů
Příklady:
k = k ... yes, k1 = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes
s(sss(2),B,ss(2)) = s(sss(2),4,ss(2),s(1))...
Hana Rudová, Logické programování I, 17. května 2007 24 Syntaxe a význam Prologovských programů
Unifikace
Termy S a T jsou unifikovatelné, jestliže
1. S a T jsou konstanty a tyto konstanty jsou identické;
2. S je proměnná a T cokoliv jiného ­ S je instanciována na T;
T je proměnná a S cokoliv jiného ­ T je instanciována na S
3. S a T jsou termy
S a T mají stejný funktor a aritu a
všechny jejich odpovídající argumenty jsou unifikovatelné
výsledná substituce je určena unifikací argumentů
Pří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
Hana Rudová, Logické programování I, 17. května 2007 24 Syntaxe a význam Prologovských programů
Unifikace
Termy S a T jsou unifikovatelné, jestliže
1. S a T jsou konstanty a tyto konstanty jsou identické;
2. S je proměnná a T cokoliv jiného ­ S je instanciována na T;
T je proměnná a S cokoliv jiného ­ T je instanciována na S
3. S a T jsou termy
S a T mají stejný funktor a aritu a
všechny jejich odpovídající argumenty jsou unifikovatelné
výsledná substituce je určena unifikací argumentů
Pří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, 17. května 2007 24 Syntaxe a význam Prologovských programů
Unifikace
Termy S a T jsou unifikovatelné, jestliže
1. S a T jsou konstanty a tyto konstanty jsou identické;
2. S je proměnná a T cokoliv jiného ­ S je instanciována na T;
T je proměnná a S cokoliv jiného ­ T je instanciována na S
3. S a T jsou termy
S a T mají stejný funktor a aritu a
všechny jejich odpovídající argumenty jsou unifikovatelné
výsledná substituce je určena unifikací argumentů
Příklady:
k = k ... yes, k1 = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes
s(sss(2),B,ss(2)) = s(sss(2),4,ss(2),s(1))... no
s(sss(A),4,ss(3)) = s(sss(2),4,ss(A))... no
Hana Rudová, Logické programování I, 17. května 2007 24 Syntaxe a význam Prologovských programů
Unifikace
Termy S a T jsou unifikovatelné, jestliže
1. S a T jsou konstanty a tyto konstanty jsou identické;
2. S je proměnná a T cokoliv jiného ­ S je instanciována na T;
T je proměnná a S cokoliv jiného ­ T je instanciována na S
3. S a T jsou termy
S a T mají stejný funktor a aritu a
všechny jejich odpovídající argumenty jsou unifikovatelné
výsledná substituce je určena unifikací argumentů
Příklady:
k = k ... yes, k1 = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes
s(sss(2),B,ss(2)) = s(sss(2),4,ss(2),s(1))... no
s(sss(A),4,ss(3)) = s(sss(2),4,ss(A))... no
s(sss(A),4,ss(C)) = s(sss(t(B)),4,ss(A))...
Hana Rudová, Logické programování I, 17. května 2007 24 Syntaxe a význam Prologovských programů
Unifikace
Termy S a T jsou unifikovatelné, jestliže
1. S a T jsou konstanty a tyto konstanty jsou identické;
2. S je proměnná a T cokoliv jiného ­ S je instanciována na T;
T je proměnná a S cokoliv jiného ­ T je instanciována na S
3. S a T jsou termy
S a T mají stejný funktor a aritu a
všechny jejich odpovídající argumenty jsou unifikovatelné
výsledná substituce je určena unifikací argumentů
Příklady:
k = k ... yes, k1 = k2 ... no, A = k(2,3) ... yes, k(s,a,l(1)) = A ... yes
s(sss(2),B,ss(2)) = s(sss(2),4,ss(2),s(1))... no
s(sss(A),4,ss(3)) = s(sss(2),4,ss(A))... no
s(sss(A),4,ss(C)) = s(sss(t(B)),4,ss(A))... A=t(B),C=t(B)... yes
Hana Rudová, Logické programování I, 17. května 2007 24 Syntaxe a význam Prologovských programů
Deklarativní a procedurální význam programů
p :- q, r.
Deklarativní: Co je výstupem programu?
p je pravdivé, jestliže q a r jsou pravdivé
Z q a r plyne p
 význam mají logické relace
Hana Rudová, Logické programování I, 17. května 2007 25 Syntaxe a význam Prologovských programů
Deklarativní a procedurální význam programů
p :- q, r.
Deklarativní: Co je výstupem programu?
p je pravdivé, jestliže q a r jsou pravdivé
Z q a r plyne p
 význam mají logické relace
Procedurální: Jak vypočítáme výstup programu?
p vyřešíme tak, že nejprve vyřešíme q a pak r
 kromě logických relací je významné i pořadí cílů
výstup
indikátor yes/no určující, zda byly cíle splněny
instanciace proměnných v případě splnění cílů
Hana Rudová, Logické programování I, 17. května 2007 25 Syntaxe a význam Prologovských programů
Deklarativní význam programu
Máme-li program a cíl G, pak deklarativní význam říká:
cíl G je splnitelný právě 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 těle I jsou pravdivé.
Instance klauzule: proměnné 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, 17. května 2007 26 Syntaxe a význam Prologovských programů
Konjunce "," vs. disjunkce ";" cílů
Konjunce = nutné splnění všech cílů
p :- q, r.
Disjunkce = stačí splnění libovolného cíle
p :- q; r. p :- q.
p :- r.
priorita středníku je vyšší:
p :- q, r; s, t, u.
p :- (q, r) ; (s, t, u).
p :- q, r.
p :- s, t, u.
Hana Rudová, Logické programování I, 17. května 2007 27 Syntaxe a význam Prologovských programů
Pořadí 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, 17. května 2007 28 Syntaxe a význam Prologovských programů
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é pořadí klauzulí v programu vzhledem k (a)
a(1).
b(1,1).
Hana Rudová, Logické programování I, 17. května 2007 28 Syntaxe a význam Prologovských programů
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é pořadí klauzulí v programu vzhledem k (a)
a(1).
b(1,1). % nenalezení odpovědi: nekonečný cyklus
Hana Rudová, Logické programování I, 17. května 2007 28 Syntaxe a význam Prologovských programů
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é pořadí klauzulí v programu vzhledem k (a)
a(1).
b(1,1). % nenalezení odpovědi: 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, 17. května 2007 28 Syntaxe a význam Prologovských programů
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é pořadí klauzulí v programu vzhledem k (a)
a(1).
b(1,1). % nenalezení odpovědi: nekonečný cyklus
(c) a(X) :- b(X,Y), c(Y). ?- a(X).
b(1,1).
c(2).
c(1).
(d) a(X) :- c(Y), b(X,Y). % změněné pořadí cílů v těle klauzule vzhledem k (c)
b(1,1).
c(2).
c(1).
Hana Rudová, Logické programování I, 17. května 2007 28 Syntaxe a význam Prologovských programů
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é pořadí klauzulí v programu vzhledem k (a)
a(1).
b(1,1). % nenalezení odpovědi: nekonečný cyklus
(c) a(X) :- b(X,Y), c(Y). ?- a(X).
b(1,1).
c(2).
c(1).
(d) a(X) :- c(Y), b(X,Y). % změněné pořadí cílů v těle klauzule vzhledem k (c)
b(1,1).
c(2).
c(1). % náročnější nalezení první odpovědi než u (c)
V obou případech stejný deklarativní ale odlišný procedurální význam
Hana Rudová, Logické programování I, 17. května 2007 28 Syntaxe a význam Prologovských programů
Pořadí klauzulí a cílů II.
(1) a(X) :- c(Y), b(X,Y). ?- a(X).
(2) b(1,1).
(3) c(2).
(4) c(1).
c(Y), b(X,Y)
a(X)
dle (1)
b(X,2)
no
dle (4) Y=1dle (3) Y=2
b(X,1)
yes
dle (2) X=1
Hana Rudová, Logické programování I, 17. května 2007 29 Syntaxe a význam Prologovských programů
Pořadí klauzulí a cílů II.
(1) a(X) :- c(Y), b(X,Y). ?- a(X).
(2) b(1,1).
(3) c(2).
(4) c(1).
c(Y), b(X,Y)
a(X)
dle (1)
b(X,2)
no
dle (4) Y=1dle (3) Y=2
b(X,1)
yes
dle (2) X=1Vyzkoušejte si:
a(X) :- b(X,X), c(X).
a(X) :- b(X,Y), c(X).
b(2,2).
b(2,1).
c(1).
Hana Rudová, Logické programování I, 17. května 2007 29 Syntaxe a význam Prologovských programů
Operátory, aritmetika
Operátory
Infixová notace: 2*a + b*c
Prefixová notace: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400
Priorita operátorů: operátor s nejvyšší prioritou je hlavní funktor
Hana Rudová, Logické programování I, 17. května 2007 31 Operátory, aritmetika
Operátory
Infixová notace: 2*a + b*c
Prefixová notace: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400
Priorita operátorů: operátor s nejvyšší prioritou je hlavní funktor
Uživatelsky definované operátory: zna
petr zna alese. zna( petr, alese).
Definice operátoru: :- op( 600, xfx, zna ). priorita: 1..1200
Hana Rudová, Logické programování I, 17. května 2007 31 Operátory, aritmetika
Operátory
Infixová notace: 2*a + b*c
Prefixová notace: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400
Priorita operátorů: operátor s nejvyšší prioritou je hlavní funktor
Uživatelsky definované operátory: zna
petr zna alese. zna( petr, alese).
Definice operátoru: :- op( 600, xfx, zna ). priorita: 1..1200
:- op( 1100, xfy, ; ). nestrukturované objekty: 0
:- op( 1000, xfy, , ).
p :- q,r; s,t. p :- (q,r) ; (s,t). ; má vyšší prioritu než ,
:- op( 1200, xfx, :- ). :- má nejvyšší prioritu
Hana Rudová, Logické programování I, 17. května 2007 31 Operátory, aritmetika
Operátory
Infixová notace: 2*a + b*c
Prefixová notace: +( *(2,a), *(b,c) ) priorita +: 500, priorita *: 400
Priorita operátorů: operátor s nejvyšší prioritou je hlavní funktor
Uživatelsky definované operátory: zna
petr zna alese. zna( petr, alese).
Definice operátoru: :- op( 600, xfx, zna ). priorita: 1..1200
:- op( 1100, xfy, ; ). nestrukturované objekty: 0
:- op( 1000, xfy, , ).
p :- q,r; s,t. p :- (q,r) ; (s,t). ; má vyšší prioritu než ,
:- op( 1200, xfx, :- ). :- má nejvyšší prioritu
Definice operátoru není spojena s datovými manipulacemi
(kromě speciálních případů)
Hana Rudová, Logické programování I, 17. května 2007 31 Operátory, aritmetika
Typy operátorů
Typy operátorů
infixové operátory: xfx, xfy, yfx př. xfx = yfx -
prefixové operátory: fx, fy př. fx ?- fy -
postfixové operátory: xf, yf
x a y určují prioritu argumentu
x reprezentuje argument, jehož priorita musí být striktně menší než u operátoru
y reprezentuje argument, jehož priorita je menší nebo rovna operátoru
a-b-c odpovídá (a-b)-c a ne a-(b-c): ,,-" odpovídá yfx
priorita: 0
a b
c
priorita: 500
priorita: 0
a
b c
priorita: 500
chybně
správně
Hana Rudová, Logické programování I, 17. května 2007 32 Operátory, aritmetika
Aritmetika
Předdefinované operátory
+, -, *, /, ** mocnina, // celočíselné dělení, mod zbytek po dělení
?- X = 1 + 2. X = 1 + 2 = odpovídá unifikaci
?- X is 1 + 2.
X = 3 ,,is" je speciální předdefinovaný operátor, který vynutí evaluaci
Hana Rudová, Logické programování I, 17. května 2007 33 Operátory, aritmetika
Aritmetika
Předdefinované operátory
+, -, *, /, ** mocnina, // celočíselné dělení, mod zbytek po dělení
?- X = 1 + 2. X = 1 + 2 = odpovídá unifikaci
?- X is 1 + 2.
X = 3 ,,is" je speciální předdefinovaný 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, 17. května 2007 33 Operátory, aritmetika
Aritmetika
Předdefinované operátory
+, -, *, /, ** mocnina, // celočíselné dělení, mod zbytek po dělení
?- X = 1 + 2. X = 1 + 2 = odpovídá unifikaci
?- X is 1 + 2.
X = 3 ,,is" je speciální předdefinovaný operátor, který vynutí evaluaci
porovnej: N = (1+1+1+1+1) N is (1+1+1+1+1)
pravá strana musí být vyhodnotitelný výraz (bez proměnné)
volání ?- X is Y + 1. způsobí chybu
Hana Rudová, Logické programování I, 17. května 2007 33 Operátory, aritmetika
Aritmetika
Předdefinované operátory
+, -, *, /, ** mocnina, // celočíselné dělení, mod zbytek po dělení
?- X = 1 + 2. X = 1 + 2 = odpovídá unifikaci
?- X is 1 + 2.
X = 3 ,,is" je speciální předdefinovaný operátor, který vynutí evaluaci
porovnej: N = (1+1+1+1+1) N is (1+1+1+1+1)
pravá strana musí být vyhodnotitelný výraz (bez proměnné)
volání ?- X is Y + 1. způsobí chybu
Další speciální předdefinované operátory
>, <, >=, =<, =:= aritmetická rovnost, =\= aritmetická nerovnost
porovnej: 1+2 =:= 2+1 1+2 = 2+1
Hana Rudová, Logické programování I, 17. května 2007 33 Operátory, aritmetika
Aritmetika
Předdefinované operátory
+, -, *, /, ** mocnina, // celočíselné dělení, mod zbytek po dělení
?- X = 1 + 2. X = 1 + 2 = odpovídá unifikaci
?- X is 1 + 2.
X = 3 ,,is" je speciální předdefinovaný operátor, který vynutí evaluaci
porovnej: N = (1+1+1+1+1) N is (1+1+1+1+1)
pravá strana musí být vyhodnotitelný výraz (bez proměnné)
volání ?- X is Y + 1. způsobí chybu
Další speciální předdefinované operátory
>, <, >=, =<, =:= aritmetická rovnost, =\= aritmetická nerovnost
porovnej: 1+2 =:= 2+1 1+2 = 2+1
obě strany musí být vyhodnotitelný výraz: volání ?- 1 < A + 2. způsobí chybu
Hana Rudová, Logické programování I, 17. května 2007 33 Operátory, aritmetika
Různé typy rovností a porovnání
X = Y X a Y jsou unifikovatelné
X \= Y X a Y nejsou unifikovatelné, (také \+ X = Y)
Hana Rudová, Logické programování I, 17. května 2007 34 Operátory, aritmetika
Různé typy rovností a porovnání
X = Y X a Y jsou unifikovatelné
X \= Y X a Y nejsou unifikovatelné, (také \+ X = Y)
X == Y X a Y jsou identické
porovnej: ?- A == B. . . . no ?- A=B, A==B.
Hana Rudová, Logické programování I, 17. května 2007 34 Operátory, aritmetika
Různé typy rovností a porovnání
X = Y X a Y jsou unifikovatelné
X \= Y X a Y nejsou unifikovatelné, (také \+ X = Y)
X == Y X a Y jsou identické
porovnej: ?- A == B. . . . no ?- A=B, A==B. . . . B = A yes
X \== Y X a Y nejsou identické
porovnej: ?- A \== B. . . . yes ?- A=B, A \== B. . . . A no
Hana Rudová, Logické programování I, 17. května 2007 34 Operátory, aritmetika
Různé typy rovností a porovnání
X = Y X a Y jsou unifikovatelné
X \= Y X a Y nejsou unifikovatelné, (také \+ X = Y)
X == Y X a Y jsou identické
porovnej: ?- A == B. . . . no ?- A=B, A==B. . . . B = A yes
X \== Y X a Y nejsou identické
porovnej: ?- A \== B. . . . yes ?- A=B, A \== B. . . . A no
X is Y Y je aritmeticky vyhodnoceno a výsledek je přiřazen X
X =:= Y X a Y jsou si aritmeticky rovny
X =\= Y X a Y si aritmeticky nejsou rovny
X < Y aritmetická hodnota X je menší než Y (=<, >, >=)
Hana Rudová, Logické programování I, 17. května 2007 34 Operátory, aritmetika
Různé typy rovností a porovnání
X = Y X a Y jsou unifikovatelné
X \= Y X a Y nejsou unifikovatelné, (také \+ X = Y)
X == Y X a Y jsou identické
porovnej: ?- A == B. . . . no ?- A=B, A==B. . . . B = A yes
X \== Y X a Y nejsou identické
porovnej: ?- A \== B. . . . yes ?- A=B, A \== B. . . . A no
X is Y Y je aritmeticky vyhodnoceno a výsledek je přiřazen X
X =:= Y X a Y jsou si aritmeticky rovny
X =\= Y X a Y si aritmeticky nejsou rovny
X < Y aritmetická hodnota X je menší než Y (=<, >, >=)
X @< Y term X předchází term Y (@=<, @>, @>=)
1. porovnání termů: podle alfabetického n. aritmetického uspořádání
2. porovnání struktur: podle arity, pak hlavního funktoru a pak
zleva podle argumentů
Hana Rudová, Logické programování I, 17. května 2007 34 Operátory, aritmetika
Různé typy rovností a porovnání
X = Y X a Y jsou unifikovatelné
X \= Y X a Y nejsou unifikovatelné, (také \+ X = Y)
X == Y X a Y jsou identické
porovnej: ?- A == B. . . . no ?- A=B, A==B. . . . B = A yes
X \== Y X a Y nejsou identické
porovnej: ?- A \== B. . . . yes ?- A=B, A \== B. . . . A no
X is Y Y je aritmeticky vyhodnoceno a výsledek je přiřazen X
X =:= Y X a Y jsou si aritmeticky rovny
X =\= Y X a Y si aritmeticky nejsou rovny
X < Y aritmetická hodnota X je menší než Y (=<, >, >=)
X @< Y term X předchází term Y (@=<, @>, @>=)
1. porovnání termů: podle alfabetického n. aritmetického uspořádání
2. porovnání struktur: podle arity, pak hlavního funktoru a pak
zleva podle argumentů
?- f( pavel, g(b) ) @< f( pavel, h(a) ). . . . yes
Hana Rudová, Logické programování I, 17. května 2007 34 Operátory, aritmetika
Prolog: příklady
Příklad: průběh výpočtu
a :- b,c,d.
b :- e,c,f,g.
b :- g,h.
c.
d.
e :- i.
e :- h.
g.
h.
i.
Jak vypadá průběh výpočtu pro dotaz ?- a.
Hana Rudová, Logické programování I, 17. května 2007 36 Prolog: příklad
Příklad: věž z kostek
Příklad: postavte věž zadané velikosti ze tří různě velkých kostek tak,
že kostka smí ležet pouze na větší kostce.
Hana Rudová, Logické programování I, 17. května 2007 37 Prolog: příklad
Příklad: věž z kostek
Příklad: postavte věž zadané velikosti ze tří různě velkých kostek tak,
že kostka smí ležet pouze na větší 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)).
Hana Rudová, Logické programování I, 17. května 2007 37 Prolog: příklad
Příklad: věž z kostek
Příklad: postavte věž zadané velikosti ze tří různě velkých kostek tak,
že kostka smí ležet pouze na větší 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, 17. května 2007 37 Prolog: příklad
Řez, negace
Řez a upnutí
f(X,0) :- X < 3 . přidání operátoru řezu ,,!''
f(X,2) :- 3 =< X, X < 6 .
f(X,4) :- 6 =< X.
3 6 x
2
4
y ?- f(1,Y), Y>2.
Hana Rudová, Logické programování I, 17. května 2007 39 Řez, negace
Řez a upnutí
f(X,0) :- X < 3, !. přidání operátoru řezu ,,!''
f(X,2) :- 3 =< X, X < 6, !.
f(X,4) :- 6 =< X.
3 6 x
2
4
y ?- f(1,Y), Y>2.
Upnutí: po splnění podcílů před řezem se už další klauzule neuvažují
Hana Rudová, Logické programování I, 17. května 2007 39 Řez, negace
Řez a upnutí
f(X,0) :- X < 3, !. přidání operátoru řezu ,,!''
f(X,2) :- 3 =< X, X < 6, !.
f(X,4) :- 6 =< X.
3 6 x
2
4
y ?- f(1,Y), Y>2.
f(X,0) :- X < 3, !. %(1)
f(X,2) :- X < 6, !. %(2)
f(X,4).
Upnutí: po splnění podcílů před řezem se už další klauzule neuvažují
Hana Rudová, Logické programování I, 17. května 2007 39 Řez, negace
Řez a upnutí
f(X,0) :- X < 3, !. přidání operátoru řezu ,,!''
f(X,2) :- 3 =< X, X < 6, !.
f(X,4) :- 6 =< X.
3 6 x
2
4
y ?- f(1,Y), Y>2.
f(X,0) :- X < 3, !. %(1)
f(X,2) :- X < 6, !. %(2)
f(X,4).
?- f(1,Y).
Smazání řezu v (1) a (2) změní chování programu
Upnutí: po splnění podcílů před řezem se už další klauzule neuvažují
Hana Rudová, Logické programování I, 17. května 2007 39 Řez, 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, 17. května 2007 40 Řez, 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).
Z = 2 ? ;
Z = 3 ? ;
no
Hana Rudová, Logické programování I, 17. května 2007 40 Řez, 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).
Z = 2 ? ;
Z = 3 ? ;
no
f(X,Y) :- s(X,Y), !.
s(X,Y) :- Y is X + 1.
s(X,Y) :- Y is X + 2.
?- f(1,Z).
Ořezání: po splnění podcílů před řezem se už neuvažuje další možné splnění
těchto podcílů
Hana Rudová, Logické programování I, 17. května 2007 40 Řez, 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).
Z = 2 ? ;
Z = 3 ? ;
no
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 ? ;
no
Ořezání: po splnění podcílů před řezem se už neuvažuje další možné splnění
těchto podcílů
Smazání řezu změní chování programu
Hana Rudová, Logické programování I, 17. května 2007 40 Řez, negace
Chování operátoru řezu
Předpokládejme, že klauzule H :- T1, T2, ..., Tm, !, ...Tn. je
aktivována voláním cíle G, který je unifikovatelný s H. G=h(X,Y)
V momentě, kdy je nalezen řez, existuje řešení cílů T1, . . . , Tm X=1,Y=1
Ořezání: při provádění řezu se už další možné splnění cílů T1, . . . , Tm
nehledá a všechny ostatní alternativy jsou odstraněny Y=2
Upnutí: dále už nevyvolávám další klauzule, jejichž hlava je také X=2
unifikovatelná s G
?- h(X,Y).
h(1,Y) :- t1(Y), !.
h(2,Y) :- a.
t1(1) :- b.
t1(2) :- c.
h(X,Y)
X=1 / \ X=2
t1(Y) a (vynechej: upnutí)
Y=1 / \ Y=2
b c (vynechej: ořezání)
/
Hana Rudová, Logické programování I, 17. května 2007 41 Řez, negace
Řez: příklad
c(X) :- p(X).
c(X) :- v(X).
p(1). p(2). v(2).
?- c(2).
Hana Rudová, Logické programování I, 17. května 2007 42 Ř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).
Hana Rudová, Logické programování I, 17. května 2007 42 Ř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, 17. května 2007 42 Řez, negace
Řez: příklad
c(X) :- p(X). c1(X) :- p(X), !.
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, 17. května 2007 42 Řez, negace
Řez: příklad
c(X) :- p(X). c1(X) :- p(X), !.
c(X) :- v(X). c1(X) :- v(X).
p(1). p(2). v(2).
?- c(2). ?- c1(2).
true ? ; % p(2) true ? ; % p(2)
true ? ; % v(2) no
no
?- c(X). ?- c1(X).
X = 1 ? ; % p(1)
X = 2 ? ; % p(2)
X = 2 ? ; % v(2)
no
Hana Rudová, Logické programování I, 17. května 2007 42 Řez, negace
Řez: příklad
c(X) :- p(X). c1(X) :- p(X), !.
c(X) :- v(X). c1(X) :- v(X).
p(1). p(2). v(2).
?- c(2). ?- c1(2).
true ? ; % p(2) true ? ; % p(2)
true ? ; % v(2) no
no
?- c(X). ?- c1(X).
X = 1 ? ; % p(1) X = 1 ? ; % p(1)
X = 2 ? ; % p(2) no
X = 2 ? ; % v(2)
no
Hana Rudová, Logické programování I, 17. května 2007 42 Řez, negace
Řez: cvičení
1. Porovnejte chování uvedených programů pro zadané dotazy.
a(X,X) :- b(X). a(X,X) :- b(X),!. a(X,X) :- b(X),c.
a(X,Y) :- Y is X+1. a(X,Y) :- Y is X+1. a(X,Y) :- Y is X+1.
b(X) :- X > 10. b(X) :- X > 10. b(X) :- X > 10.
c :- !.
?- a(X,Y).
?- a(1,Y).
?- a(11,Y).
2. Napište predikát pro výpočet maxima max( X, Y, Max )
Hana Rudová, Logické programování I, 17. května 2007 43 Řez, negace
Typy řezu
Zlepšení efektivity programu: určíme, které alternativy nemá smysl zkoušet
Zelený řez: odstraní pouze neúspěšná odvození
f(X,1) :- X >= 0, !. f(X,-1) :- X < 0.
Hana Rudová, Logické programování I, 17. května 2007 44 Řez, negace
Typy řezu
Zlepšení efektivity programu: určíme, které alternativy nemá smysl zkoušet
Zelený řez: odstraní pouze neúspěšná odvození
f(X,1) :- X >= 0, !. f(X,-1) :- X < 0.
bez řezu zkouším pro nezáporná čísla 2. klauzuli
Hana Rudová, Logické programování I, 17. května 2007 44 Řez, negace
Typy řezu
Zlepšení efektivity programu: určíme, které alternativy nemá smysl zkoušet
Zelený řez: odstraní pouze neúspěšná odvození
f(X,1) :- X >= 0, !. f(X,-1) :- X < 0.
bez řezu zkouším pro nezáporná čísla 2. klauzuli
Modrý řez: odstraní redundantní řešení
f(X,1) :- X >= 0, !. f(0,1). f(X,-1) :- X < 0.
Hana Rudová, Logické programování I, 17. května 2007 44 Řez, negace
Typy řezu
Zlepšení efektivity programu: určíme, které alternativy nemá smysl zkoušet
Zelený řez: odstraní pouze neúspěšná odvození
f(X,1) :- X >= 0, !. f(X,-1) :- X < 0.
bez řezu zkouším pro nezáporná čísla 2. klauzuli
Modrý řez: odstraní redundantní řešení
f(X,1) :- X >= 0, !. f(0,1). f(X,-1) :- X < 0. bez řezu vrací f(0,1) 2x
Hana Rudová, Logické programování I, 17. května 2007 44 Řez, negace
Typy řezu
Zlepšení efektivity programu: určíme, které alternativy nemá smysl zkoušet
Zelený řez: odstraní pouze neúspěšná odvození
f(X,1) :- X >= 0, !. f(X,-1) :- X < 0.
bez řezu zkouším pro nezáporná čísla 2. klauzuli
Modrý řez: odstraní redundantní řešení
f(X,1) :- X >= 0, !. f(0,1). f(X,-1) :- X < 0. bez řezu vrací f(0,1) 2x
Červený řez: odstraní úspěšná řešení
f(X,1) :- X >= 0, !. f(_X,-1).
Hana Rudová, Logické programování I, 17. května 2007 44 Řez, negace
Typy řezu
Zlepšení efektivity programu: určíme, které alternativy nemá smysl zkoušet
Zelený řez: odstraní pouze neúspěšná odvození
f(X,1) :- X >= 0, !. f(X,-1) :- X < 0.
bez řezu zkouším pro nezáporná čísla 2. klauzuli
Modrý řez: odstraní redundantní řešení
f(X,1) :- X >= 0, !. f(0,1). f(X,-1) :- X < 0. bez řezu vrací f(0,1) 2x
Červený řez: odstraní úspěšná řešení
f(X,1) :- X >= 0, !. f(_X,-1). bez řezu uspěje 2. klauzule pro nezáporná čísla
Hana Rudová, Logické programování I, 17. května 2007 44 Řez, negace
Negace jako neúspěch
Speciální cíl pro nepravdu (neúspěch) fail a pravdu true
X a Y nejsou unifikovatelné: different(X, Y)
different( X, Y ) :- X = Y, !, fail.
different( _X, _Y ).
X je muž: muz(X)
muz( X ) :- zena( X ), !, fail.
muz( _X ).
Hana Rudová, Logické programování I, 17. května 2007 45 Řez, negace
Negace jako neúspěch: operátor \+
different(X,Y) :- X = Y, !, fail. muz(X) :- zena(X), !, fail.
different(_X,_Y). muz(_X).
Unární operátor \+ P
jestliže P uspěje, potom \+ P neuspěje
\+(P) :- P, !, fail.
v opačném případě \+ P uspěje
\+(_).
Hana Rudová, Logické programování I, 17. května 2007 46 Řez, negace
Negace jako neúspěch: operátor \+
different(X,Y) :- X = Y, !, fail. muz(X) :- zena(X), !, fail.
different(_X,_Y). muz(_X).
Unární operátor \+ P
jestliže P uspěje, potom \+ P neuspěje
\+(P) :- P, !, fail.
v opačném případě \+ P uspěje
\+(_).
different( X, Y ) :- \+ X=Y.
muz( X ) :- \+ zena( X ).
Pozor: takto definovaná negace \+P vyžaduje konečné odvození P
Hana Rudová, Logické programování I, 17. května 2007 46 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
Hana Rudová, Logické programování I, 17. května 2007 47 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
?- dobre( X ), rozumne( X ).
Hana Rudová, Logické programování I, 17. května 2007 47 Řez, negace
Negace a proměnné
\+(P) :- P, !, 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)
Hana Rudová, Logické programování I, 17. května 2007 47 Řez, negace
Negace a proměnné
\+(P) :- P, !, 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, 17. května 2007 47 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
?- dobre( X ), rozumne( X ).
dobre(X),rozumne(X)
dle (1), X/citroen
rozumne(citroen)
dle (4)
\+ drahe(citroen)
Hana Rudová, Logické programování I, 17. května 2007 47 Řez, negace
Negace a proměnné
\+(P) :- P, !, 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, 17. května 2007 47 Řez, negace
Negace a proměnné
\+(P) :- P, !, 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
no
Hana Rudová, Logické programování I, 17. května 2007 47 Řez, negace
Negace a proměnné
\+(P) :- P, !, 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
no
yes
dle (II)
Hana Rudová, Logické programování I, 17. května 2007 47 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
Hana Rudová, Logické programování I, 17. května 2007 48 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
?- rozumne( X ), dobre( X ).
Hana Rudová, Logické programování I, 17. května 2007 48 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
?- rozumne( X ), dobre( X ).
rozumne(X), dobre(X)
Hana Rudová, Logické programování I, 17. května 2007 48 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
?- rozumne( X ), dobre( X ).
rozumne(X), dobre(X)
dle (4)
\+ drahe(X), dobre(X)
Hana Rudová, Logické programování I, 17. května 2007 48 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
?- rozumne( X ), dobre( X ).
rozumne(X), dobre(X)
dle (4)
\+ drahe(X), dobre(X)
dle (I)
drahe(X),!,fail,dobre(X)
Hana Rudová, Logické programování I, 17. května 2007 48 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
?- rozumne( X ), dobre( X ).
rozumne(X), dobre(X)
dle (4)
\+ drahe(X), dobre(X)
dle (I)
drahe(X),!,fail,dobre(X)
dle (3), X/bmw
!, fail, dobre(bmw)
Hana Rudová, Logické programování I, 17. května 2007 48 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
?- rozumne( X ), dobre( X ).
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)
Hana Rudová, Logické programování I, 17. května 2007 48 Řez, negace
Negace a proměnné
\+(P) :- P, !, fail. % (I)
\+(_). % (II)
dobre( citroen ). % (1)
dobre( bmw ). % (2)
drahe( bmw ). % (3)
rozumne( Auto ) :- % (4)
\+ drahe( Auto ).
?- rozumne( X ), dobre( X ).
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
Hana Rudová, Logické programování I, 17. května 2007 48 Řez, negace
Bezpečný cíl
?- rozumne( citroen ). yes
?- rozumne( X ). no
?- \+ drahe( citroen ). yes
?- \+ drahe( X ). no
\+ 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, 17. května 2007 49 Řez, negace
Chování negace
?- \+ drahe( citroen ). yes
?- \+ drahe( X ). no
Negace jako neúspěch používá předpoklad uzavřeného světa
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 )
Hana Rudová, Logické programování I, 17. května 2007 50 Řez, negace
Chování negace
?- \+ drahe( citroen ). yes
?- \+ drahe( X ). no
Negace jako neúspěch používá předpoklad uzavřeného světa
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 )
?- drahe( X ).
VÍME: existuje X takové, že drahe( X ) platí
ALE: pro cíle s negací neplatí existuje X takové, že \+ drahe( X )
Hana Rudová, Logické programování I, 17. května 2007 50 Řez, negace
Chování negace
?- \+ drahe( citroen ). yes
?- \+ drahe( X ). no
Negace jako neúspěch používá předpoklad uzavřeného světa
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 )
?- drahe( X ).
VÍME: existuje X takové, že drahe( X ) platí
ALE: pro cíle s negací neplatí existuje X takové, že \+ drahe( X )
 negace jako neúspěch není ekvivalentní negaci v matematické logice
Hana Rudová, Logické programování I, 17. května 2007 50 Řez, negace
Predikáty na řízení běhu programu I.
řez ,,!"
fail: cíl, který vždy neuspěje true: cíl, který vždy uspěje
\+ P: negace jako neúspěch
\+ P :- P, !, fail; true.
Hana Rudová, Logické programování I, 17. května 2007 51 Řez, negace
Predikáty na řízení běhu programu I.
řez ,,!"
fail: cíl, který vždy neuspěje true: cíl, který vždy uspěje
\+ P: negace jako neúspěch
\+ P :- P, !, fail; true.
once(P): vrátí pouze jedno řešení cíle P
once(P) :- P, !.
Hana Rudová, Logické programování I, 17. května 2007 51 Řez, negace
Predikáty na řízení běhu programu I.
řez ,,!"
fail: cíl, který vždy neuspěje true: cíl, který vždy uspěje
\+ P: negace jako neúspěch
\+ P :- P, !, fail; true.
once(P): vrátí pouze jedno řešení cíle P
once(P) :- P, !.
Vyjádření podmínky: P -> Q ; R
jestliže platí P tak Q (P -> Q ; R) :- P, !, Q.
v opačném případě R (P -> Q ; R) :- R.
příklad: min(X,Y,Z) :- X =< Y -> Z = X ; Z = Y.
Hana Rudová, Logické programování I, 17. května 2007 51 Řez, negace
Predikáty na řízení běhu programu I.
řez ,,!"
fail: cíl, který vždy neuspěje true: cíl, který vždy uspěje
\+ P: negace jako neúspěch
\+ P :- P, !, fail; true.
once(P): vrátí pouze jedno řešení cíle P
once(P) :- P, !.
Vyjádření podmínky: P -> Q ; R
jestliže platí P tak Q (P -> Q ; R) :- P, !, Q.
v opačném případě R (P -> Q ; R) :- R.
příklad: min(X,Y,Z) :- X =< Y -> Z = X ; Z = Y.
P -> Q
Hana Rudová, Logické programování I, 17. května 2007 51 Řez, negace
Predikáty na řízení běhu programu I.
řez ,,!"
fail: cíl, který vždy neuspěje true: cíl, který vždy uspěje
\+ P: negace jako neúspěch
\+ P :- P, !, fail; true.
once(P): vrátí pouze jedno řešení cíle P
once(P) :- P, !.
Vyjádření podmínky: P -> Q ; R
jestliže platí P tak Q (P -> Q ; R) :- P, !, Q.
v opačném případě R (P -> Q ; R) :- R.
příklad: min(X,Y,Z) :- X =< Y -> Z = X ; Z = Y.
P -> Q
odpovídá: (P -> Q; fail)
příklad: zaporne(X) :- number(X) -> X < 0.
Hana Rudová, Logické programování I, 17. května 2007 51 Řez, negace
Predikáty na řízení běhu programu II.
call(P): zavolá cíl P a uspěje, pokud uspěje P
nekonečná posloupnost backtrackovacích voleb: repeat
repeat.
repeat :- repeat.
Hana Rudová, Logické programování I, 17. května 2007 52 Řez, negace
Predikáty na řízení běhu programu II.
call(P): zavolá cíl P a uspěje, pokud uspěje P
nekonečná posloupnost backtrackovacích voleb: repeat
repeat.
repeat :- repeat.
klasické použití: generuj akci X, proved' ji a otestuj, zda neskončit
Hlava :- ...
uloz_stav( StaryStav ),
repeat,
generuj( X ), % deterministické: generuj, provadej, testuj
provadej( X ),
testuj( X ),
!,
obnov_stav( StaryStav ),
...
Hana Rudová, Logické programování I, 17. května 2007 52 Řez, negace
Seznamy
Reprezentace seznamu
Seznam: [a, b, c], prázdný seznam []
Hlava (libovolný objekt), tělo (seznam): .(Hlava, Telo)
všechny strukturované objekty stromy ­ i seznamy
funktor ".", dva argumenty
.(a, .(b, .(c, []))) = [a, b, c]
notace: [ Hlava | Telo ] = [a|Telo]
Hana Rudová, Logické programování I, 17. května 2007 54 Seznamy
Reprezentace seznamu
Seznam: [a, b, c], prázdný seznam []
Hlava (libovolný objekt), tělo (seznam): .(Hlava, Telo)
všechny strukturované objekty stromy ­ i seznamy
funktor ".", dva argumenty
.(a, .(b, .(c, []))) = [a, b, c]
notace: [ Hlava | Telo ] = [a|Telo]
Telo je v [a|Telo] seznam, tedy píšeme [ a, b, c ] = [ a | [ b, c ] ]
Hana Rudová, Logické programování I, 17. května 2007 54 Seznamy
Reprezentace seznamu
Seznam: [a, b, c], prázdný seznam []
Hlava (libovolný objekt), tělo (seznam): .(Hlava, Telo)
všechny strukturované objekty stromy ­ i seznamy
funktor ".", dva argumenty
.(a, .(b, .(c, []))) = [a, b, c]
notace: [ Hlava | Telo ] = [a|Telo]
Telo je v [a|Telo] seznam, tedy píšeme [ a, b, c ] = [ a | [ b, c ] ]
Lze psát i: [a,b|Telo]
před "|" je libovolný počet 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, 17. května 2007 54 Seznamy
Reprezentace seznamu
Seznam: [a, b, c], prázdný seznam []
Hlava (libovolný objekt), tělo (seznam): .(Hlava, Telo)
všechny strukturované objekty stromy ­ i seznamy
funktor ".", dva argumenty
.(a, .(b, .(c, []))) = [a, b, c]
notace: [ Hlava | Telo ] = [a|Telo]
Telo je v [a|Telo] seznam, tedy píšeme [ a, b, c ] = [ a | [ b, c ] ]
Lze psát i: [a,b|Telo]
před "|" je libovolný počet 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, 17. května 2007 54 Seznamy
Reprezentace seznamu
Seznam: [a, b, c], prázdný seznam []
Hlava (libovolný objekt), tělo (seznam): .(Hlava, Telo)
všechny strukturované objekty stromy ­ i seznamy
funktor ".", dva argumenty
.(a, .(b, .(c, []))) = [a, b, c]
notace: [ Hlava | Telo ] = [a|Telo]
Telo je v [a|Telo] seznam, tedy píšeme [ a, b, c ] = [ a | [ b, c ] ]
Lze psát i: [a,b|Telo]
před "|" je libovolný počet prvků seznamu , za "|" je seznam zbývajících prvků
[a,b,c] = [a|[b,c]] = [a,b|[c]] = [a,b,c|[]]
pozor: [ [a,b] | [c] ] = [ a,b | [c] ]
Seznam jako neúplná datová struktura: [a,b,c|T]
Seznam = [a,b,c|T], T = [d,e|S], Seznam = [a,b,c,d,e|S]
Hana Rudová, Logické programování I, 17. května 2007 54 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 | _ ] ). %(1)
X je prvek těla seznamu S
member( X, [ _ | Telo ] ) :-
member( X, Telo ). %(2)
Hana Rudová, Logické programování I, 17. května 2007 55 Seznamy
Prvek seznamu
member(1,[2,1,3,1,4])
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 | _ ] ). %(1)
X je prvek těla seznamu S
member( X, [ _ | Telo ] ) :-
member( X, Telo ). %(2)
Hana Rudová, Logické programování I, 17. května 2007 55 Seznamy
Prvek seznamu
member(1,[2,1,3,1,4])
member(1,[1,3,1,4])
dle (2)
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 | _ ] ). %(1)
X je prvek těla seznamu S
member( X, [ _ | Telo ] ) :-
member( X, Telo ). %(2)
Hana Rudová, Logické programování I, 17. května 2007 55 Seznamy
Prvek seznamu
member(1,[2,1,3,1,4])
member(1,[1,3,1,4])
dle (2)
member(1,[3,1,4])
dle (2)
yes
dle (1)
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 | _ ] ). %(1)
X je prvek těla seznamu S
member( X, [ _ | Telo ] ) :-
member( X, Telo ). %(2)
Hana Rudová, Logické programování I, 17. května 2007 55 Seznamy
Prvek seznamu
member(1,[2,1,3,1,4])
member(1,[1,3,1,4])
dle (2)
member(1,[3,1,4])
dle (2)
yes
dle (1)
member(1,[1,4])
dle (2)
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 | _ ] ). %(1)
X je prvek těla seznamu S
member( X, [ _ | Telo ] ) :-
member( X, Telo ). %(2)
Hana Rudová, Logické programování I, 17. května 2007 55 Seznamy
Prvek seznamu
member(1,[2,1,3,1,4])
member(1,[1,3,1,4])
dle (2)
member(1,[3,1,4])
dle (2)
yes
dle (1)
member(1,[1,4])
dle (2)
member(1,[4])
dle (2)
yes
dle (1)
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 | _ ] ). %(1)
X je prvek těla seznamu S
member( X, [ _ | Telo ] ) :-
member( X, Telo ). %(2)
Hana Rudová, Logické programování I, 17. května 2007 55 Seznamy
Prvek seznamu
member(1,[2,1,3,1,4])
member(1,[1,3,1,4])
dle (2)
member(1,[3,1,4])
dle (2)
yes
dle (1)
member(1,[1,4])
dle (2)
member(1,[4])
dle (2)
yes
dle (1)
member(1,[ ])
dle (2)
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 | _ ] ). %(1)
X je prvek těla seznamu S
member( X, [ _ | Telo ] ) :-
member( X, Telo ). %(2)
Hana Rudová, Logické programování I, 17. května 2007 55 Seznamy
Prvek seznamu
member(1,[2,1,3,1,4])
member(1,[1,3,1,4])
dle (2)
member(1,[3,1,4])
dle (2)
yes
dle (1)
member(1,[1,4])
dle (2)
member(1,[4])
dle (2)
yes
dle (1)
member(1,[ ])
dle (2)
dle (2)
no
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 | _ ] ). %(1)
X je prvek těla seznamu S
member( X, [ _ | Telo ] ) :-
member( X, Telo ). %(2)
Hana Rudová, Logické programování I, 17. května 2007 55 Seznamy
Prvek seznamu
member(1,[2,1,3,1,4])
member(1,[1,3,1,4])
dle (2)
member(1,[3,1,4])
dle (2)
yes
dle (1)
member(1,[1,4])
dle (2)
member(1,[4])
dle (2)
yes
dle (1)
member(1,[ ])
dle (2)
dle (2)
no
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 | _ ] ). %(1)
X je prvek těla seznamu S
member( X, [ _ | Telo ] ) :-
member( X, Telo ). %(2)
Další příklady použití:
member(X,[1,2,3]).
member(1,[2,1,3,1]).
Hana Rudová, Logické programování I, 17. května 2007 55 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] )
Hana Rudová, Logické programování I, 17. května 2007 56 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:
pokud je 1. argument prázdný seznam, pak 2. a 3. argument jsou stejné seznamy:
append( [], S, S ).
Hana Rudová, Logické programování I, 17. května 2007 56 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:
pokud je 1. argument prázdný seznam, pak 2. a 3. argument jsou stejné seznamy:
append( [], S, S ).
pokud je 1. argument neprázdný seznam, pak má 3. argument stejnou hlavu jako 1.:
append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3).
X S1 S2
S3
Hana Rudová, Logické programování I, 17. května 2007 56 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] ]
Hana Rudová, Logické programování I, 17. května 2007 57 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 = []
Hana Rudová, Logické programování I, 17. května 2007 57 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]
Hana Rudová, Logické programování I, 17. května 2007 57 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]
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, 17. května 2007 57 Seznamy
Smazání prvku seznamu delete( X, S, S1 )
Seznam S1 odpovídá seznamu S, ve kterém je smazán prvek X
jestliže X je hlava seznamu S, pak výsledkem je tělo S
delete( X, [X|Telo], Telo).
jestliže X je v těle seznamu, pak X je smazán až v těle
delete( X, [Y|Telo], [Y|Telo1] ) :- delete( X, Telo, Telo1 ).
Hana Rudová, Logické programování I, 17. května 2007 58 Seznamy
Smazání prvku seznamu delete( X, S, S1 )
Seznam S1 odpovídá seznamu S, ve kterém je smazán prvek X
jestliže X je hlava seznamu S, pak výsledkem je tělo S
delete( X, [X|Telo], Telo).
jestliže X je v těle seznamu, pak X je smazán až v těle
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]
Hana Rudová, Logické programování I, 17. května 2007 58 Seznamy
Smazání prvku seznamu delete( X, S, S1 )
Seznam S1 odpovídá seznamu S, ve kterém je smazán prvek X
jestliže X je hlava seznamu S, pak výsledkem je tělo S
delete( X, [X|Telo], Telo).
jestliže X je v těle seznamu, pak X je smazán až v těle
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) :- !.
delete( X, [Y|Telo], [Y|Telo1] ) :- delete( X, Telo, Telo1).
Hana Rudová, Logické programování I, 17. května 2007 58 Seznamy
Optimalizace posledního volání
Last Call Optimization (LCO)
Implementační technika snižující nároky na pamět'
Mnoho vnořených rekurzivních volání je náročné na pamět'
Použití LCO umožňuje vnořenou rekurzi s konstantními pamětovými nároky
Typický příklad, kdy je možné použití LCO:
procedura musí mít pouze jedno rekurzivní volání: v posledním cíli poslední klauzule
cíle předcházející tomuto rekurzivnímu volání musí být deterministické
p( ... ) :- ... % žádné rekurzivní volání v těle klauzule
p( ... ) :- ... % žádné rekurzivní volání v těle klauzule
...
p(...) :- ..., !, p( ... ). % řez zajišt'uje determinismus
Tento typ rekurze lze převést na iteraci
Hana Rudová, Logické programování I, 17. května 2007 59 Seznamy
LCO a akumulátor
Reformulace rekurzivní procedury, aby umožnila LCO
Výpočet délky seznamu length( Seznam, Delka )
length( [], 0 ).
length( [ H | T ], Delka ) :- length( T, Delka0 ), Delka is 1 + Delka0.
Hana Rudová, Logické programování I, 17. května 2007 60 Seznamy
LCO a akumulátor
Reformulace rekurzivní procedury, aby umožnila LCO
Výpočet délky seznamu length( Seznam, Delka )
length( [], 0 ).
length( [ H | T ], Delka ) :- length( T, Delka0 ), Delka is 1 + Delka0.
Upravená procedura, tak aby umožnila LCO:
% length( Seznam, ZapocitanaDelka, CelkovaDelka ):
% CelkovaDelka = ZapocitanaDelka + ,,počet prvků v Seznam''
Hana Rudová, Logické programování I, 17. května 2007 60 Seznamy
LCO a akumulátor
Reformulace rekurzivní procedury, aby umožnila LCO
Výpočet délky seznamu length( Seznam, Delka )
length( [], 0 ).
length( [ H | T ], Delka ) :- length( T, Delka0 ), Delka is 1 + Delka0.
Upravená procedura, tak aby umožnila LCO:
% length( Seznam, ZapocitanaDelka, CelkovaDelka ):
% CelkovaDelka = ZapocitanaDelka + ,,počet prvků v Seznam''
length( Seznam, Delka ) :- length( Seznam, 0, Delka ). % pomocný predikát
length( [], Delka, Delka ). % celková délka = započítaná délka
length( [ H | T ], A, Delka ) :- A0 is A + 1, length( T, A0, Delka ).
Přídavný argument se nazývá akumulátor
Hana Rudová, Logické programování I, 17. května 2007 60 Seznamy
max_list s akumulátorem
Výpočet největší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, 17. května 2007 61 Seznamy
max_list s akumulátorem
Výpočet největší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 ).
max_list([H|T],Max) :- max_list(T,H,Max).
max_list([], Max, Max).
max_list([H|T], CastecnyMax, Max) :-
( H > CastecnyMax, !,
max_list(T, H, Max )
;
max_list(T, CastecnyMax, Max) ).
Hana Rudová, Logické programování I, 17. května 2007 61 Seznamy
Akumulátor jako seznam
Nalezení seznamu, ve kterém jsou prvky v opačném pořadí
reverse( Seznam, OpacnySeznam )
reverse( [], [] ).
reverse( [ H | T ], Opacny ) :-
Hana Rudová, Logické programování I, 17. května 2007 62 Seznamy
Akumulátor jako seznam
Nalezení seznamu, ve kterém jsou prvky v opačném pořadí
reverse( Seznam, OpacnySeznam )
reverse( [], [] ).
reverse( [ H | T ], Opacny ) :-
reverse( T, OpacnyT ),
append( OpacnyT, [ H ], Opacny ).
naivní reverse s kvadratickou složitosti
Hana Rudová, Logické programování I, 17. května 2007 62 Seznamy
Akumulátor jako seznam
Nalezení seznamu, ve kterém jsou prvky v opačném pořadí
reverse( Seznam, OpacnySeznam )
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í
% reverse( Seznam, Akumulator, Opacny ):
% Opacny obdržíme přídáním prvků ze Seznam do Akumulator v opacnem poradi
Hana Rudová, Logické programování I, 17. května 2007 62 Seznamy
Akumulátor jako seznam
Nalezení seznamu, ve kterém jsou prvky v opačném pořadí
reverse( Seznam, OpacnySeznam )
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í
% reverse( Seznam, Akumulator, Opacny ):
% Opacny obdržíme pří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 ). % přidání H do akumulátoru
Hana Rudová, Logické programování I, 17. května 2007 62 Seznamy
Akumulátor jako seznam
Nalezení seznamu, ve kterém jsou prvky v opačném pořadí
reverse( Seznam, OpacnySeznam )
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í
% reverse( Seznam, Akumulator, Opacny ):
% Opacny obdržíme pří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 ). % přidání H do akumulátoru
zpětná konstrukce seznamu (srovnej s předchozí dopřednou konstrukcí, např. append)
Hana Rudová, Logické programování I, 17. května 2007 62 Seznamy
Neefektivita př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, 17. května 2007 63 Seznamy
Neefektivita při spojování seznamů
Sjednocení dvou seznamů
append( [], S, S ).
append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3 ).
?- append( [2,3], [1], S ).
Hana Rudová, Logické programování I, 17. května 2007 63 Seznamy
Neefektivita při spojování seznamů
Sjednocení dvou seznamů
append( [], S, S ).
append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3 ).
?- append( [2,3], [1], S ).
postupné volání cílů:
append( [2,3], [1], S )  append( [3], [1], S')  append( [], [1], S'' )
Hana Rudová, Logické programování I, 17. května 2007 63 Seznamy
Neefektivita při spojování seznamů
Sjednocení dvou seznamů
append( [], S, S ).
append( [X|S1], S2, [X|S3] ) :- append( S1, S2, S3 ).
?- append( [2,3], [1], S ).
postupné volání cílů:
append( [2,3], [1], S )  append( [3], [1], S')  append( [], [1], S'' )
Vždy je nutné projít celý první seznam
Hana Rudová, Logické programování I, 17. května 2007 63 Seznamy
Rozdílové seznamy
Zapamatování konce a připojení na konec: rozdílové seznamy
Hana Rudová, Logické programování I, 17. května 2007 64 Seznamy
Rozdílové seznamy
Zapamatování konce a připojení na konec: rozdílové seznamy
[a,b] = L1-L2 = [a,b|T]-T = [a,b,c|S]-[c|S] = [a,b,c]-[c]
Reprezentace prázdného seznamu: L-L
Hana Rudová, Logické programování I, 17. května 2007 64 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
L1 L2
A1 Z1 A2 Z2
L3
Hana Rudová, Logické programování I, 17. května 2007 64 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
L1 L2
A1 Z1 A2 Z2
L3
append( A1-Z1, Z1-Z2, A1-Z2 ).
L1 L2 L3
Hana Rudová, Logické programování I, 17. května 2007 64 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
L1 L2
A1 Z1 A2 Z2
L3
append( A1-Z1, Z1-Z2, A1-Z2 ).
L1 L2 L3
?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ).
S =
Hana Rudová, Logické programování I, 17. května 2007 64 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
L1 L2
A1 Z1 A2 Z2
L3
append( A1-Z1, Z1-Z2, A1-Z2 ).
L1 L2 L3
?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ).
S = A1 - Z2
Hana Rudová, Logické programování I, 17. května 2007 64 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
L1 L2
A1 Z1 A2 Z2
L3
append( A1-Z1, Z1-Z2, A1-Z2 ).
L1 L2 L3
?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ).
S = A1 - Z2 = [2,3|Z1] - Z2
Hana Rudová, Logické programování I, 17. května 2007 64 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
L1 L2
A1 Z1 A2 Z2
L3
append( A1-Z1, Z1-Z2, A1-Z2 ).
L1 L2 L3
?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ).
S = A1 - Z2 = [2,3|Z1] - Z2 = [2,3| [1|Z2] ] - Z2
Hana Rudová, Logické programování I, 17. května 2007 64 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
L1 L2
A1 Z1 A2 Z2
L3
append( A1-Z1, Z1-Z2, A1-Z2 ).
L1 L2 L3
?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ).
S = A1 - Z2 = [2,3|Z1] - Z2 = [2,3| [1|Z2] ] - Z2
Z1 = [1|Z2] S = [2,3,1|Z2]-Z2
Hana Rudová, Logické programování I, 17. května 2007 64 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
L1 L2
A1 Z1 A2 Z2
L3
append( A1-Z1, Z1-Z2, A1-Z2 ).
L1 L2 L3
?- append( [2,3|Z1]-Z1, [1|Z2]-Z2, S ).
S = A1 - Z2 = [2,3|Z1] - Z2 = [2,3| [1|Z2] ] - Z2
Z1 = [1|Z2] S = [2,3,1|Z2]-Z2
Jednotková složitost, oblíbená technika ale není tak flexibilní
Hana Rudová, Logické programování I, 17. května 2007 64 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í)
Hana Rudová, Logické programování I, 17. května 2007 65 Seznamy
Akumulátor vs. rozdílové seznamy: reverse
reverse( [], [] ).
reverse( [ H | T ], Opacny ) :-
reverse( T, OpacnyT ),
append( OpacnyT, [ H ], Opacny ). kvadratická složitost
reverse( Seznam, Opacny ) :- reverse0( Seznam, [], Opacny ).
reverse0( [], S, S ).
reverse0( [ H | T ], A, Opacny ) :-
reverse0( T, [ H | 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, 17. května 2007 65 Seznamy
Akumulátor vs. rozdílové seznamy: reverse
reverse( [], [] ).
reverse( [ H | T ], Opacny ) :-
reverse( T, OpacnyT ),
append( OpacnyT, [ H ], Opacny ). kvadratická složitost
reverse( Seznam, Opacny ) :- reverse0( Seznam, [], Opacny ).
reverse0( [], S, S ).
reverse0( [ H | T ], A, Opacny ) :-
reverse0( T, [ H | 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í)
Příklad: operace pro manipulaci s frontou
test na prázdnost, přidání na konec, odebrání ze začátku
Hana Rudová, Logické programování I, 17. května 2007 65 Seznamy
Vestavěné predikáty
Vestavěné predikáty
Predikáty pro řízení běhu programu
fail, true, . . .
Různé typy rovností
unifikace, aritmetická rovnost, . . .
Databázové operace
změna programu (programové databáze) za jeho běhu
Vstup a výstup
Všechna řešení programu
Testování typu termu
proměnná?, konstanta?, struktura?, . . .
Konstrukce a dekompozice termu
argumenty?, funktor?, . . .
Hana Rudová, Logické programování I, 17. května 2007 67 Vestavěné predikáty
Databázové operace
Databáze: specifikace množiny relací
Prologovský program: programová databáze, kde jsou relace specifikovány
explicitně (fakty) i implicitně (pravidly)
Vestavěné predikáty pro změnu databáze během provádění programu:
assert( Klauzule ) přidání Klauzule do programu
asserta( Klauzule ) přidání na začátek
assertz( Klauzule ) přidání na konec
retract( Klauzule ) smazání klauzule unifikovatelné s Klauzule
Pozor: nadměrné použití těchto operací snižuje srozumitelnost programu
Hana Rudová, Logické programování I, 17. května 2007 68 Vestavěné predikáty
Příklad: databázové operace
Caching: odpovědi na dotazy jsou přidány do programové databáze
Hana Rudová, Logické programování I, 17. května 2007 69 Vestavěné predikáty
Příklad: databázové operace
Caching: odpovědi na dotazy jsou přidány do programové databáze
?- solve( problem, Solution),
asserta( solve( problem, Solution) ).
:- dynamic solve/2. % nezbytné při použití v SICStus Prologu
Hana Rudová, Logické programování I, 17. května 2007 69 Vestavěné predikáty
Příklad: databázové operace
Caching: odpovědi na dotazy jsou přidány do programové databáze
?- solve( problem, Solution),
asserta( solve( problem, Solution) ).
:- dynamic solve/2. % nezbytné při použití v SICStus Prologu
Příklad:
uloz_trojice( Seznam1, Seznam2 ) :-
member( X1, Seznam1 ),
member( X2, Seznam2 ),
spocitej_treti( X1, X2, X3 ),
assertz( trojice( X1, X2, X3 ) ),
fail.
Hana Rudová, Logické programování I, 17. května 2007 69 Vestavěné predikáty
Příklad: databázové operace
Caching: odpovědi na dotazy jsou přidány do programové databáze
?- solve( problem, Solution),
asserta( solve( problem, Solution) ).
:- dynamic solve/2. % nezbytné při použití v SICStus Prologu
Příklad:
uloz_trojice( Seznam1, Seznam2 ) :-
member( X1, Seznam1 ),
member( X2, Seznam2 ),
spocitej_treti( X1, X2, X3 ),
assertz( trojice( X1, X2, X3 ) ),
fail.
uloz_trojice( _, _ ) :- !.
Hana Rudová, Logické programování I, 17. května 2007 69 Vestavěné predikáty
Vstup a výstup
program může čí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í proud
aktivní výstupní proud
uživatelský terminál ­ user
datový vstup z terminálu
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ů
uzivatelsky
terminal
useruser
soubor 1
soubor 2
soubor 3
soubor 4
vystupni proudyvstupni proudy
program
Hana Rudová, Logické programování I, 17. května 2007 70 Vestavěné predikáty
Vstupní a výstupní proudy: vestavěné 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 ).
uzavření aktivního vstupního/výstupního proudu: seen/told
Hana Rudová, Logické programování I, 17. května 2007 71 Vestavěné predikáty
Vstupní a výstupní proudy: vestavěné 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 ).
uzavření aktivního vstupního/výstupního proudu: seen/told
zjištění aktivního vstupního/výstupního proudu: seeing(S)/telling(S)
cteni( Soubor ) :- seeing( StarySoubor ),
see( Soubor ),
cteni_ze_souboru( Informace ),
seen,
see( StarySoubor ).
Hana Rudová, Logické programování I, 17. května 2007 71 Vestavěné predikáty
Sekvenční přístup k textovým souborům
čtení dalšího termu: read(Term)
při čtení jsou termy odděleny tečkou
| ?- read(A), read( ahoj(B) ), read( [C,D] ).
Hana Rudová, Logické programování I, 17. května 2007 72 Vestavěné predikáty
Sekvenční přístup k textovým souborům
čtení dalšího termu: read(Term)
při čtení 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
Hana Rudová, Logické programování I, 17. května 2007 72 Vestavěné predikáty
Sekvenční přístup k textovým souborům
čtení dalšího termu: read(Term)
při čtení 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
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ý řádek na výstup: nl
N mezer na výstup: tab(N)
Hana Rudová, Logické programování I, 17. května 2007 72 Vestavěné predikáty
Sekvenční přístup k textovým souborům
čtení dalšího termu: read(Term)
při čtení 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
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ý řádek na výstup: nl
N mezer na výstup: tab(N)
čtení/zápis dalšího znaku: get0(Znak), get(NeprazdnyZnak)/put(Znak)
po dosažení konce souboru je vrácena -1
Hana Rudová, Logické programování I, 17. května 2007 72 Vestavěné predikáty
Příklad čtení ze souboru
process_file( Soubor ) :-
seeing( StarySoubor ), % zjištění aktivního proudu
see( Soubor ), % otevření souboru Soubor
repeat,
read( Term ), % čtení termu Term
process_term( Term ), % manipulace s termem
Term == end_of_file, % je konec souboru?
!,
seen, % uzavření souboru
see( StarySoubor ). % aktivace původního proudu
repeat. % opakování
repeat :- repeat.
Hana Rudová, Logické programování I, 17. května 2007 73 Vestavěné predikáty
Čtení programu ze souboru
Interpretování kódu programu
?- consult(program).
?- consult('program.pl').
?- consult( [program1, 'program2.pl'] ).
?- [program].
?- [user]. zadávání kódu ze vstupu ukončené CTRL+D
Hana Rudová, Logické programování I, 17. května 2007 74 Vestavěné predikáty
Čtení programu ze souboru
Interpretování kódu programu
?- consult(program).
?- consult('program.pl').
?- consult( [program1, 'program2.pl'] ).
?- [program].
?- [user]. zadávání kódu ze vstupu ukončené CTRL+D
Kompilace kódu programu
?- compile( [program1, 'program2.pl'] ).
další varianty podobně jako u interpretování
typické zrychlení: 5 až 10 krát
Hana Rudová, Logické programování I, 17. května 2007 74 Vestavěné predikáty
Všechna řešení
Backtracking vrací pouze jedno řešení po druhém
Všechna řešení dostupná najednou: bagof/3, setof/3, findall/3
bagof( X, P, S ): vrátí seznam S, všech objektů X takových, že P je splněno
vek( petr, 7 ).
vek( anna, 5 ).
vek( tomas, 5 ).
?- bagof( Dite, vek( Dite, 5 ), Seznam ).
Hana Rudová, Logické programování I, 17. května 2007 75 Vestavěné predikáty
Všechna řešení
Backtracking vrací pouze jedno řešení po druhém
Všechna řešení dostupná najednou: bagof/3, setof/3, findall/3
bagof( X, P, S ): vrátí seznam S, všech objektů X takových, že P je splněno
vek( petr, 7 ).
vek( anna, 5 ).
vek( tomas, 5 ).
?- bagof( Dite, vek( Dite, 5 ), Seznam ).
Seznam = [ anna, tomas ]
Hana Rudová, Logické programování I, 17. května 2007 75 Vestavěné predikáty
Všechna řešení
Backtracking vrací pouze jedno řešení po druhém
Všechna řešení dostupná najednou: bagof/3, setof/3, findall/3
bagof( X, P, S ): vrátí seznam S, všech objektů X takových, že P je splněno
vek( petr, 7 ).
vek( anna, 5 ).
vek( tomas, 5 ).
?- bagof( Dite, vek( Dite, 5 ), Seznam ).
Seznam = [ anna, tomas ]
Volné proměnné v cíli P jsou všeobecně kvantifikovány
?- bagof( Dite, vek( Dite, Vek ), Seznam ).
Hana Rudová, Logické programování I, 17. května 2007 75 Vestavěné predikáty
Všechna řešení
Backtracking vrací pouze jedno řešení po druhém
Všechna řešení dostupná najednou: bagof/3, setof/3, findall/3
bagof( X, P, S ): vrátí seznam S, všech objektů X takových, že P je splněno
vek( petr, 7 ).
vek( anna, 5 ).
vek( tomas, 5 ).
?- bagof( Dite, vek( Dite, 5 ), Seznam ).
Seznam = [ anna, tomas ]
Volné proměnné v cíli P jsou všeobecně kvantifikovány
?- bagof( Dite, vek( Dite, Vek ), Seznam ).
Vek = 7, Seznam = [ petr ];
Vek = 5, Seznam = [ anna, tomas ]
Hana Rudová, Logické programování I, 17. května 2007 75 Vestavěné predikáty
Všechna řešení II.
Pokud neexistuje řešení bagof(X,P,S) neuspěje
bagof: pokud nějaké řešení existuje několikrá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, 17. května 2007 76 Vestavěné predikáty
Všechna řešení II.
Pokud neexistuje řešení bagof(X,P,S) neuspěje
bagof: pokud nějaké řešení existuje několikrá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 ]
bagof, setof, findall:
na objekty shromažd'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, 17. května 2007 76 Vestavěné predikáty
Existenční kvantifikátor ,,^ "
Přidání existenčního kvantifikátoru ,,^ "  hodnota proměnné nemá význam
?- bagof( Dite, Vek^ vek( Dite, Vek ), Seznam ).
Hana Rudová, Logické programování I, 17. května 2007 77 Vestavěné predikáty
Existenční kvantifikátor ,,^ "
Přidání existenčního kvantifikátoru ,,^ "  hodnota proměnné nemá význam
?- bagof( Dite, Vek^ vek( Dite, Vek ), Seznam ).
Seznam = [petr,anna,tomas]
Hana Rudová, Logické programování I, 17. května 2007 77 Vestavěné predikáty
Existenční kvantifikátor ,,^ "
Přidání existenčního kvantifikátoru ,,^ "  hodnota proměnné nemá význam
?- bagof( Dite, Vek^ vek( Dite, Vek ), Seznam ).
Seznam = [petr,anna,tomas]
Anonymní proměnné jsou všeobecně 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, 17. května 2007 77 Vestavěné predikáty
Existenční kvantifikátor ,,^ "
Přidání existenčního kvantifikátoru ,,^ "  hodnota proměnné nemá význam
?- bagof( Dite, Vek^ vek( Dite, Vek ), Seznam ).
Seznam = [petr,anna,tomas]
Anonymní proměnné jsou všeobecně 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]
Př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, 17. května 2007 77 Vestavěné predikáty
Všechna řešení III.
setof( X, P, S ): rozdíly od bagof
S je uspořádaný podle @<
případné duplicity v S jsou eliminovány
Hana Rudová, Logické programování I, 17. května 2007 78 Vestavěné predikáty
Všechna řešení III.
setof( X, P, S ): rozdíly od bagof
S je uspořádaný podle @<
případné duplicity v S jsou eliminovány
findall( X, P, S ): rozdíly od bagof
všechny proměnné jsou existenčně kvantifikovány
?- findall( Dite, vek( Dite, Vek ), Seznam ).
Hana Rudová, Logické programování I, 17. května 2007 78 Vestavěné predikáty
Všechna řešení III.
setof( X, P, S ): rozdíly od bagof
S je uspořádaný podle @<
případné duplicity v S jsou eliminovány
findall( X, P, S ): rozdíly od bagof
všechny proměnné jsou existenčně kvantifikovány
?- findall( Dite, vek( Dite, Vek ), Seznam ).
 v S jsou shromažd'ovány všechny možnosti i pro různá řešení
 findall uspěje přesně jednou
Hana Rudová, Logické programování I, 17. května 2007 78 Vestavěné predikáty
Všechna řešení III.
setof( X, P, S ): rozdíly od bagof
S je uspořádaný podle @<
případné duplicity v S jsou eliminovány
findall( X, P, S ): rozdíly od bagof
všechny proměnné jsou existenčně kvantifikovány
?- findall( Dite, vek( Dite, Vek ), Seznam ).
 v S jsou shromažd'ovány všechny možnosti i pro různá řešení
 findall uspěje přesně jednou
výsledný seznam může být prázdný  pokud neexistuje řešení, uspěje a vrátí S = []
Hana Rudová, Logické programování I, 17. května 2007 78 Vestavěné predikáty
Všechna řešení III.
setof( X, P, S ): rozdíly od bagof
S je uspořádaný podle @<
případné duplicity v S jsou eliminovány
findall( X, P, S ): rozdíly od bagof
všechny proměnné jsou existenčně kvantifikovány
?- findall( Dite, vek( Dite, Vek ), Seznam ).
 v S jsou shromažd'ovány všechny možnosti i pro různá řešení
 findall uspěje přesně jednou
výsledný seznam může být prázdný  pokud neexistuje řešení, uspěje a vrátí S = []
?- bagof( Dite, vek( Dite, Vek ), Seznam ).
Vek = 7, Seznam = [ petr ];
Vek = 5, Seznam = [ anna, tomas ]
?- findall( Dite, vek( Dite, Vek ), Seznam ).
Hana Rudová, Logické programování I, 17. května 2007 78 Vestavěné predikáty
Všechna řešení III.
setof( X, P, S ): rozdíly od bagof
S je uspořádaný podle @<
případné duplicity v S jsou eliminovány
findall( X, P, S ): rozdíly od bagof
všechny proměnné jsou existenčně kvantifikovány
?- findall( Dite, vek( Dite, Vek ), Seznam ).
 v S jsou shromažd'ovány všechny možnosti i pro různá řešení
 findall uspěje přesně jednou
výsledný seznam může být prázdný  pokud neexistuje řešení, uspěje a vrátí S = []
?- bagof( Dite, vek( Dite, Vek ), Seznam ).
Vek = 7, Seznam = [ petr ];
Vek = 5, Seznam = [ anna, tomas ]
?- findall( Dite, vek( Dite, Vek ), Seznam ).
Seznam = [petr,anna,tomas]
Hana Rudová, Logické programování I, 17. května 2007 78 Vestavěné 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, 17. května 2007 79 Vestavěné predikáty
Testování typu termu
var(X) X je volná proměnná
nonvar(X) X není proměnná
atom(X) X je atom (pavel, 'Pavel Novák', <-->)
integer(X) X je integer
float(X) X je float
atomic(X) X je atom nebo číslo
Hana Rudová, Logické programování I, 17. května 2007 79 Vestavěné predikáty
Testování typu termu
var(X) X je volná proměnná
nonvar(X) X není proměnná
atom(X) X je atom (pavel, 'Pavel Novák', <-->)
integer(X) X je integer
float(X) X je float
atomic(X) X je atom nebo číslo
compound(X) X je struktura
Hana Rudová, Logické programování I, 17. května 2007 79 Vestavěné predikáty
Určení počtu výskytů prvku v seznamu
count( X, S, N )
Hana Rudová, Logické programování I, 17. května 2007 80 Vestavěné predikáty
Určení počtu výskytů prvku v seznamu
count( X, S, N ) :- count( X, S, 0, N ).
Hana Rudová, Logické programování I, 17. května 2007 80 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 ).
Hana Rudová, Logické programování I, 17. května 2007 80 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) :- !, N1 is N0 + 1, count( X, S, N1, N).
Hana Rudová, Logické programování I, 17. května 2007 80 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) :- !, N1 is N0 + 1, count( X, S, N1, N).
count( X, [_|S], N0, N) :- count( X, S, N0, N).
Hana Rudová, Logické programování I, 17. května 2007 80 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) :- !, 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, 17. května 2007 80 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) :- !, 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
:-? count( a, [a,b,X,Y], N).
Hana Rudová, Logické programování I, 17. května 2007 80 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) :- !, 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
:-? count( a, [a,b,X,Y], N).
N=3
Hana Rudová, Logické programování I, 17. května 2007 80 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) :- !, 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
:-? count( a, [a,b,X,Y], N).
N=3
count( _, [], N, N ).
count( X, [Y|S], N0, N ) :- nonvar(Y), X = Y, !,
N1 is N0 + 1, count( X, S, N1, N ).
count( X, [_|S], N0, N ) :- count( X, S, N0, N ).
Hana Rudová, Logické programování I, 17. května 2007 80 Vestavěné predikáty
Konstrukce a dekompozice atomu
Atom (opakování)
řetězce písmen, čísel, ,,_" začínající malým písmenem: pavel, pavel_novak, x2, x4_34
řetězce speciálních znaků: +, <->, ===>
řetězce v apostrofech: 'Pavel', Pavel Novák', 'prší', 'ano'
?- 'ano'=A. A = ano
Hana Rudová, Logické programování I, 17. května 2007 81 Vestavěné predikáty
Konstrukce a dekompozice atomu
Atom (opakování)
řetězce písmen, čísel, ,,_" začínající malým písmenem: pavel, pavel_novak, x2, x4_34
řetězce speciálních znaků: +, <->, ===>
řetězce v apostrofech: 'Pavel', Pavel Novák', 'prší', 'ano'
?- 'ano'=A. A = ano
Řetězec znaků v uvozovkách
př. "ano", "Pavel"
?- A="Pavel". ?- A="ano".
A = [80,97,118,101,108] A=[97,110,111]
př. použití: konstrukce a dekompozice atomu na znaky, vstup a výstup do souboru
Hana Rudová, Logické programování I, 17. května 2007 81 Vestavěné predikáty
Konstrukce a dekompozice atomu
Atom (opakování)
řetězce písmen, čísel, ,,_" začínající malým písmenem: pavel, pavel_novak, x2, x4_34
řetězce speciálních znaků: +, <->, ===>
řetězce v apostrofech: 'Pavel', Pavel Novák', 'prší', 'ano'
?- 'ano'=A. A = ano
Řetězec znaků v uvozovkách
př. "ano", "Pavel"
?- A="Pavel". ?- A="ano".
A = [80,97,118,101,108] A=[97,110,111]
př. 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, 17. května 2007 81 Vestavěné 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, 17. května 2007 82 Vestavěné predikáty
Konstrukce a dekompozice termu
Konstrukce a dekompozice termu
Term =.. [ Funktor | SeznamArgumentu ]
a(9,e) =.. [a,9,e]
Cil =.. [ Funktor | SeznamArgumentu ], call( Cil )
Hana Rudová, Logické programování I, 17. května 2007 82 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
Hana Rudová, Logické programování I, 17. května 2007 82 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]
Hana Rudová, Logické programování I, 17. května 2007 82 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 některé argumenty, pak je efektivnější:
functor( Term, Funktor, Arita ) functor( a(9,e), a, 2 )
Hana Rudová, Logické programování I, 17. května 2007 82 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 některé argumenty, pak je efektivnější:
functor( Term, Funktor, Arita ) functor( a(9,e), a, 2 )
functor(atom,atom,0) functor(1,1,0)
Hana Rudová, Logické programování I, 17. května 2007 82 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 některé argumenty, pak je efektivnější:
functor( Term, Funktor, Arita ) functor( a(9,e), a, 2 )
functor(atom,atom,0) functor(1,1,0)
arg( N, Term, Argument ) arg( 2, a(9,e), e)
Hana Rudová, Logické programování I, 17. května 2007 82 Vestavěné predikáty
Rekurzivní rozklad termu
Term je proměnná (var/1), atom nebo číslo (atomic/1)  konec rozkladu
Hana Rudová, Logické programování I, 17. května 2007 83 Vestavěné predikáty
Rekurzivní rozklad termu
Term je proměnná (var/1), atom nebo číslo (atomic/1)  konec rozkladu
Term je složený (=../2, functor/3) 
procházení seznamu argumentů a rozklad každého argumentu
Hana Rudová, Logické programování I, 17. května 2007 83 Vestavěné predikáty
Rekurzivní rozklad termu
Term je proměnná (var/1), atom nebo číslo (atomic/1)  konec rozkladu
Term je seznam ([_|_]) 
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
Hana Rudová, Logické programování I, 17. května 2007 83 Vestavěné predikáty
Rekurzivní rozklad termu
Term je proměnná (var/1), atom nebo číslo (atomic/1)  konec rozkladu
Term je seznam ([_|_]) 
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
Příklad: ground/1 uspěje, pokud v termu nejsou proměnné; jinak neuspěje
Hana Rudová, Logické programování I, 17. května 2007 83 Vestavěné predikáty
Rekurzivní rozklad termu
Term je proměnná (var/1), atom nebo číslo (atomic/1)  konec rozkladu
Term je seznam ([_|_]) 
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
Příklad: ground/1 uspěje, pokud v termu nejsou proměnné; jinak neuspěje
ground(Term) :- atomic(Term), !.
Hana Rudová, Logické programování I, 17. května 2007 83 Vestavěné predikáty
Rekurzivní rozklad termu
Term je proměnná (var/1), atom nebo číslo (atomic/1)  konec rozkladu
Term je seznam ([_|_]) 
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
Příklad: ground/1 uspěje, pokud v termu nejsou proměnné; jinak neuspěje
ground(Term) :- atomic(Term), !.
ground(Term) :- var(Term), !, fail.
Hana Rudová, Logické programování I, 17. května 2007 83 Vestavěné predikáty
Rekurzivní rozklad termu
Term je proměnná (var/1), atom nebo číslo (atomic/1)  konec rozkladu
Term je seznam ([_|_]) 
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
Příklad: ground/1 uspěje, pokud v termu nejsou proměnné; jinak neuspěje
ground(Term) :- atomic(Term), !.
ground(Term) :- var(Term), !, fail.
ground([H|T]) :- !, ground(H), ground(T).
Hana Rudová, Logické programování I, 17. května 2007 83 Vestavěné predikáty
Rekurzivní rozklad termu
Term je proměnná (var/1), atom nebo číslo (atomic/1)  konec rozkladu
Term je seznam ([_|_]) 
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
Příklad: ground/1 uspěje, pokud v termu nejsou proměnné; jinak neuspěje
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, 17. května 2007 83 Vestavěné predikáty
Rekurzivní rozklad termu
Term je proměnná (var/1), atom nebo číslo (atomic/1)  konec rozkladu
Term je seznam ([_|_]) 
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
Příklad: ground/1 uspěje, pokud v termu nejsou proměnné; jinak neuspěje
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, 17. května 2007 83 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet výskytů celého čísla v termu
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet výskytů celého čísla v termu
?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet výskytů celého čísla v termu
?- count_term( 1, a(1,2,b(x,z(a,b,1)),Y), N ). N=2
count_term( X, T, N ) :- count_term( X, T, 0, N).
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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.
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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), !.
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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), !.
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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 ],
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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 ).
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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 ).
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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),
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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,
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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 ).
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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, 17. května 2007 84 Vestavěné predikáty
Příklad: dekompozice termu I.
count_term( Integer, Term, N ) určí počet 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 ).
count_term( X, T, N0, N ) :- T = [_|_], !, count_arg( X, T, N0, N ).
klauzuli přidáme před poslední klauzuli count_term/4
Hana Rudová, Logické programování I, 17. května 2007 84 Vestavěné 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
Předpokládejte, že Term a Podterm bez proměnných)
?- substitute( sin(x), 2*sin(x)*f(sin(x)), t, F ). F=2*t*f(t)
Hana Rudová, Logické programování I, 17. května 2007 85 Vestavěné predikáty
Technika a styl programování v Prologu
Technika a styl programování v Prologu
Styl programování v Prologu
některá pravidla správného stylu
správný vs. špatný styl
komentáře
Ladění
Efektivita
Hana Rudová, Logické programování I, 17. května 2007 87 Technika a styl programování v Prologu
Styl programování v Prologu I.
Cílem stylistických konvencí je
redukce nebezpečí programovacích chyb
psaní čitelných a srozumitelných programů, které se dobře ladí a modifikují
Hana Rudová, Logické programování I, 17. května 2007 88 Technika a styl programování v Prologu
Styl programování v Prologu I.
Cílem stylistických konvencí je
redukce nebezpečí programovacích chyb
psaní čitelných a srozumitelných programů, které se dobře ladí a modifikují
Některá pravidla správného stylu
krátké klauzule
krátké procedury; dlouhé procedury pouze s uniformní strukturou (tabulka)
Hana Rudová, Logické programování I, 17. května 2007 88 Technika a styl programování v Prologu
Styl programování v Prologu I.
Cílem stylistických konvencí je
redukce nebezpečí programovacích chyb
psaní čitelných a srozumitelných programů, které se dobře ladí a modifikují
Některá pravidla správného stylu
krátké klauzule
krátké procedury; dlouhé procedury pouze s uniformní strukturou (tabulka)
klauzule se základními (hraničními) případy psát před rekurzivními klauzulemi
vhodná jmena procedur a proměnných
nepoužívat seznamy ([...]) nebo závorky ({...}, (...)) pro termy pevné arity
vstupní argumenty psát před výstupními
Hana Rudová, Logické programování I, 17. května 2007 88 Technika a styl programování v Prologu
Styl programování v Prologu I.
Cílem stylistických konvencí je
redukce nebezpečí programovacích chyb
psaní čitelných a srozumitelných programů, které se dobře ladí a modifikují
Některá pravidla správného stylu
krátké klauzule
krátké procedury; dlouhé procedury pouze s uniformní strukturou (tabulka)
klauzule se základními (hraničními) případy psát před rekurzivními klauzulemi
vhodná jmena procedur a proměnných
nepoužívat seznamy ([...]) nebo závorky ({...}, (...)) pro termy pevné arity
vstupní argumenty psát před výstupními
struktura programu ­ jednotné konvence v rámci celého programu, např.
mezery, prázdné řádky, odsazení
klauzule stejné procedury na jednom místě; prázdné řádky mezi klauzulemi;
každý cíl na zvláštním řádku
Hana Rudová, Logické programování I, 17. května 2007 88 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ů
Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 )
merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] )
Hana Rudová, Logické programování I, 17. května 2007 89 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ů
Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 )
merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] )
merge( [], Seznam, Seznam ) :-
Hana Rudová, Logické programování I, 17. května 2007 89 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ů
Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 )
merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] )
merge( [], Seznam, Seznam ) :-
!. % prevence redundantních řešení
Hana Rudová, Logické programování I, 17. května 2007 89 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ů
Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 )
merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] )
merge( [], Seznam, Seznam ) :-
!. % prevence redundantních řešení
merge( Seznam, [], Seznam ).
Hana Rudová, Logické programování I, 17. května 2007 89 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ů
Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 )
merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] )
merge( [], Seznam, Seznam ) :-
!. % prevence redundantních řešení
merge( Seznam, [], Seznam ).
merge( [X|Telo1], [Y|Telo2], [X|Telo3] ) :-
Hana Rudová, Logické programování I, 17. května 2007 89 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ů
Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 )
merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] )
merge( [], Seznam, Seznam ) :-
!. % prevence redundantních řešení
merge( Seznam, [], Seznam ).
merge( [X|Telo1], [Y|Telo2], [X|Telo3] ) :-
X < Y, !,
Hana Rudová, Logické programování I, 17. května 2007 89 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ů
Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 )
merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] )
merge( [], Seznam, Seznam ) :-
!. % prevence redundantních řešení
merge( Seznam, [], Seznam ).
merge( [X|Telo1], [Y|Telo2], [X|Telo3] ) :-
X < Y, !,
merge( Telo1, [Y|Telo2], Telo3 ).
Hana Rudová, Logické programování I, 17. května 2007 89 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ů
Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 )
merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] )
merge( [], Seznam, Seznam ) :-
!. % prevence redundantních řešení
merge( Seznam, [], Seznam ).
merge( [X|Telo1], [Y|Telo2], [X|Telo3] ) :-
X < Y, !,
merge( Telo1, [Y|Telo2], Telo3 ).
merge( Seznam1, [Y|Telo2], [Y|Telo3] ) :-
Hana Rudová, Logické programování I, 17. května 2007 89 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ů
Seznam1, Seznam2: merge( Seznam1, Seznam2, Seznam3 )
merge( [2,4,7], [1,3,4,8], [1,2,3,4,4,7,8] )
merge( [], Seznam, Seznam ) :-
!. % prevence redundantních řešení
merge( Seznam, [], Seznam ).
merge( [X|Telo1], [Y|Telo2], [X|Telo3] ) :-
X < Y, !,
merge( Telo1, [Y|Telo2], Telo3 ).
merge( Seznam1, [Y|Telo2], [Y|Telo3] ) :-
merge( Seznam1, Telo2, Telo3 ).
Hana Rudová, Logické programování I, 17. května 2007 89 Technika a styl programování v Prologu
Špatný styl programování
merge( S1, S2, S3 ) :-
S1 = [], !, S3 = S2; % první seznam je prázdný
S2 = [], !, S3 = S1; % druhý seznam je prázdný
S1 = [X|T1],
S2 = [Y|T2],
( X < Y, !,
Z = X, % Z je hlava seznamu S3
merge( T1, S2, T3 );
Z = Y,
merge( S1, T2, T3) ),
S3 = [ Z | T3 ].
Hana Rudová, Logické programování I, 17. května 2007 90 Technika a styl programování v Prologu
Styl programování v Prologu II.
Středník ,,;" může způsobit nesrozumitelnost klauzule
nedávat středník na konec řádku, používat závorky
v některých případech: rozdělení klauzle se středníkem do více klauzulí
Hana Rudová, Logické programování I, 17. května 2007 91 Technika a styl programování v Prologu
Styl programování v Prologu II.
Středník ,,;" může způsobit nesrozumitelnost klauzule
nedávat středník na konec řádku, používat závorky
v některých případech: rozdělení klauzle se středníkem do více klauzulí
Opatrné používání operátoru řezu
preferovat použití zeleného řezu (nemění deklarativní sémantiku)
červený řez používat v jasně definovaných konstruktech
negace: P, !, fail; true \+ P
alternativy: Podminka, !, Cil1 ; Cil2 Podminka -> Cil1 ; Cil2
Hana Rudová, Logické programování I, 17. května 2007 91 Technika a styl programování v Prologu
Styl programování v Prologu II.
Středník ,,;" může způsobit nesrozumitelnost klauzule
nedávat středník na konec řádku, používat závorky
v některých případech: rozdělení klauzle se středníkem do více klauzulí
Opatrné používání operátoru řezu
preferovat použití zeleného řezu (nemění deklarativní sémantiku)
červený řez používat v jasně definovaných konstruktech
negace: P, !, fail; true \+ P
alternativy: Podminka, !, Cil1 ; Cil2 Podminka -> Cil1 ; Cil2
Opatrné používání negace ,,\+"
negace jako neúspěch: negace není ekvivalentní negaci v matematické logice
Hana Rudová, Logické programování I, 17. května 2007 91 Technika a styl programování v Prologu
Styl programování v Prologu II.
Středník ,,;" může způsobit nesrozumitelnost klauzule
nedávat středník na konec řádku, používat závorky
v některých případech: rozdělení klauzle se středníkem do více klauzulí
Opatrné používání operátoru řezu
preferovat použití zeleného řezu (nemění deklarativní sémantiku)
červený řez používat v jasně definovaných konstruktech
negace: P, !, fail; true \+ P
alternativy: Podminka, !, Cil1 ; Cil2 Podminka -> Cil1 ; Cil2
Opatrné používání negace ,,\+"
negace jako neúspěch: negace není ekvivalentní negaci v matematické logice
Pozor na assert a retract: snižuji transparentnost chování programu
Hana Rudová, Logické programování I, 17. května 2007 91 Technika a styl programování v Prologu
Dokumentace a komentáře
co program dělá, jak ho používat (jaký cíl spustit a jaké jsou očekávané
výsledky), příklad použití
Hana Rudová, Logické programování I, 17. května 2007 92 Technika a styl programování v Prologu
Dokumentace a komentáře
co program dělá, jak ho používat (jaký cíl spustit a jaké jsou očekávané
výsledky), příklad použití
které predikáty jsou hlavní (top-level)
Hana Rudová, Logické programování I, 17. května 2007 92 Technika a styl programování v Prologu
Dokumentace a komentáře
co program dělá, jak ho používat (jaký cíl spustit a jaké jsou očekávané
výsledky), příklad použití
které predikáty jsou hlavní (top-level)
jak jsou hlavní koncepty (objekty) reprezentovány
Hana Rudová, Logické programování I, 17. května 2007 92 Technika a styl programování v Prologu
Dokumentace a komentáře
co program dělá, jak ho používat (jaký cíl spustit a jaké jsou očekávané
výsledky), příklad použití
které predikáty jsou hlavní (top-level)
jak jsou hlavní koncepty (objekty) reprezentovány
doba výpočtu a pamět'ové nároky
Hana Rudová, Logické programování I, 17. května 2007 92 Technika a styl programování v Prologu
Dokumentace a komentáře
co program dělá, jak ho používat (jaký cíl spustit a jaké jsou očekávané
výsledky), příklad použití
které predikáty jsou hlavní (top-level)
jak jsou hlavní koncepty (objekty) reprezentovány
doba výpočtu a pamět'ové nároky
jaké jsou limitace programu
Hana Rudová, Logické programování I, 17. května 2007 92 Technika a styl programování v Prologu
Dokumentace a komentáře
co program dělá, jak ho používat (jaký cíl spustit a jaké jsou očekávané
výsledky), příklad použití
které predikáty jsou hlavní (top-level)
jak jsou hlavní koncepty (objekty) reprezentovány
doba výpočtu a pamět'ové nároky
jaké jsou limitace programu
zda jsou použity nějaké speciální rysy závislé na systému
Hana Rudová, Logické programování I, 17. května 2007 92 Technika a styl programování v Prologu
Dokumentace a komentáře
co program dělá, jak ho používat (jaký cíl spustit a jaké jsou očekávané
výsledky), příklad použití
které predikáty jsou hlavní (top-level)
jak jsou hlavní koncepty (objekty) reprezentovány
doba výpočtu a pamět'ové nároky
jaké jsou limitace programu
zda jsou použity nějaké speciální rysy závislé na systému
jaký je význam predikátů v programu, jaké jsou jejich argumenty, které jsou
vstupní a které výstupní (pokud víme)
vstupní argumenty ,,+", výstupní ,,­" merge( +Seznam1, +Seznam2, -Seznam3 )
JmenoPredikatu/Arita merge/3
Hana Rudová, Logické programování I, 17. května 2007 92 Technika a styl programování v Prologu
Dokumentace a komentáře
co program dělá, jak ho používat (jaký cíl spustit a jaké jsou očekávané
výsledky), příklad použití
které predikáty jsou hlavní (top-level)
jak jsou hlavní koncepty (objekty) reprezentovány
doba výpočtu a pamět'ové nároky
jaké jsou limitace programu
zda jsou použity nějaké speciální rysy závislé na systému
jaký je význam predikátů v programu, jaké jsou jejich argumenty, které jsou
vstupní a které výstupní (pokud víme)
vstupní argumenty ,,+", výstupní ,,­" merge( +Seznam1, +Seznam2, -Seznam3 )
JmenoPredikatu/Arita merge/3
algoritmické a implementační podrobnosti
Hana Rudová, Logické programování I, 17. května 2007 92 Technika a styl programování v Prologu
Ladění
Přepínače na trasování: trace/0, notrace/0
Trasování specifického predikátu: spy/1, nospy/1
spy( merge/3 )
debug/0, nodebug/0: pro trasování pouze predikátů zadaných spy/1
Hana Rudová, Logické programování I, 17. května 2007 93 Technika a styl programování v Prologu
Ladění
Přepínače na trasování: trace/0, notrace/0
Trasování specifického predikátu: spy/1, nospy/1
spy( merge/3 )
debug/0, nodebug/0: pro trasování pouze predikátů zadaných spy/1
Libovolná část programu může být spuštěna
zadáním vhodného dotazu: trasování cíle
vstupní informace: jméno predikátu, hodnoty argumentů při volání
výstupní informace
při úspěchu hodnoty argumentů splňující cíl
při neůspěchu indikace chyby
nové vyvolání přes ";": stejný cíl je volán při backtrackingu
Hana Rudová, Logické programování I, 17. května 2007 93 Technika a styl programování v Prologu
Krabičkový (4-branový) model
Vizualizace řídícího toku (backtrackingu) na úrovni predikátu
Call: volání cíle
Exit: úspěšné ukončení volání cíle
Fail: volání cíle neuspělo
Redo: jeden z následujících cílů neuspěl a systém backtrackuje, aby nalezl alternativy k
předchozímu řešení
*------------------------------------------*
Call | | Exit
-----------------> + predek( X, Z ) :- rodic( X, Z ). + --------->
| |
| predek( X, Z ) :- rodic( X, Y ), |
<----------------- + predek( Y, Z ). + <---------
Fail | | Redo
*------------------------------------------*
Hana Rudová, Logické programování I, 17. května 2007 94 Technika a styl programování v Prologu
Příklad: trasování
a(X) :- nonvar(X).
a(X) :- c(X).
a(X) :- d(X).
c(1).
d(2).
*------------------*
Call | | Exit
------> + a(X) :- nonvar(X).| ------>
| a(X) :- c(X). |
<------ + a(X) :- d(X). + <------
Fail | | Redo
*-------------------*
Hana Rudová, Logické programování I, 17. května 2007 95 Technika a styl programování v Prologu
Příklad: trasování
a(X) :- nonvar(X).
a(X) :- c(X).
a(X) :- d(X).
c(1).
d(2).
*------------------*
Call | | Exit
------> + a(X) :- nonvar(X).| ------>
| a(X) :- c(X). |
<------ + a(X) :- d(X). + <------
Fail | | Redo
*-------------------*
| ?- a(X).
1 1 Call: a(_463) ?
2 2 Call: nonvar(_463) ?
2 2 Fail: nonvar(_463) ?
Hana Rudová, Logické programování I, 17. května 2007 95 Technika a styl programování v Prologu
Příklad: trasování
a(X) :- nonvar(X).
a(X) :- c(X).
a(X) :- d(X).
c(1).
d(2).
*------------------*
Call | | Exit
------> + a(X) :- nonvar(X).| ------>
| a(X) :- c(X). |
<------ + a(X) :- d(X). + <------
Fail | | Redo
*-------------------*
| ?- a(X).
1 1 Call: a(_463) ?
2 2 Call: nonvar(_463) ?
2 2 Fail: nonvar(_463) ?
3 2 Call: c(_463) ?
3 2 Exit: c(1) ?
? 1 1 Exit: a(1) ?
X = 1 ?
Hana Rudová, Logické programování I, 17. května 2007 95 Technika a styl programování v Prologu
Příklad: trasování
a(X) :- nonvar(X).
a(X) :- c(X).
a(X) :- d(X).
c(1).
d(2).
*------------------*
Call | | Exit
------> + a(X) :- nonvar(X).| ------>
| a(X) :- c(X). |
<------ + a(X) :- d(X). + <------
Fail | | Redo
*-------------------*
| ?- a(X).
1 1 Call: a(_463) ?
2 2 Call: nonvar(_463) ?
2 2 Fail: nonvar(_463) ?
3 2 Call: c(_463) ?
3 2 Exit: c(1) ?
? 1 1 Exit: a(1) ?
X = 1 ? ;
1 1 Redo: a(1) ?
4 2 Call: d(_463) ?
Hana Rudová, Logické programování I, 17. května 2007 95 Technika a styl programování v Prologu
Příklad: trasování
a(X) :- nonvar(X).
a(X) :- c(X).
a(X) :- d(X).
c(1).
d(2).
*------------------*
Call | | Exit
------> + a(X) :- nonvar(X).| ------>
| a(X) :- c(X). |
<------ + a(X) :- d(X). + <------
Fail | | Redo
*-------------------*
| ?- a(X).
1 1 Call: a(_463) ?
2 2 Call: nonvar(_463) ?
2 2 Fail: nonvar(_463) ?
3 2 Call: c(_463) ?
3 2 Exit: c(1) ?
? 1 1 Exit: a(1) ?
X = 1 ? ;
1 1 Redo: a(1) ?
4 2 Call: d(_463) ?
4 2 Exit: d(2) ?
1 1 Exit: a(2) ?
X = 2 ? ;
no
% trace
| ?-
Hana Rudová, Logické programování I, 17. května 2007 95 Technika a styl programování v Prologu
Efektivita
Čas výpočtu, pamět'ové nároky, a také časové nároky na vývoj programu
u Prologu můžeme častěji narazit na problémy s časem výpočtu a pamětí
Prologovské aplikace redukují čas na vývoj
vhodnost pro symbolické, nenumerické výpočty se strukturovanými objekty
a relacemi mezi nimi
Hana Rudová, Logické programování I, 17. května 2007 96 Technika a styl programování v Prologu
Efektivita
Čas výpočtu, pamět'ové nároky, a také časové nároky na vývoj programu
u Prologu můžeme častěji narazit na problémy s časem výpočtu a pamětí
Prologovské aplikace redukují čas na vývoj
vhodnost pro symbolické, nenumerické výpočty se strukturovanými objekty
a relacemi mezi nimi
Pro zvýšení efektivity je nutno se zabývat procedurálními aspekty
zlepšení efektivity při prohledávání
odstranění zbytečného backtrackingu
zrušení provádění zbytečných alternativ co nejdříve
návrh vhodnějších datových struktur, které umožní
efektivnější operace s objekty
Hana Rudová, Logické programování I, 17. května 2007 96 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ři spojování seznamů
Caching: uložení vypočítaných výsledků do programové databáze
Hana Rudová, Logické programování I, 17. května 2007 97 Technika a styl programování v Prologu
Zlepšení efektivity: základní techniky
Optimalizace posledního volání (LCO) a akumulátory
Rozdílové seznamy při spojování seznamů
Caching: uložení vypočítaných výsledků do programové databáze
Indexace podle prvního argumentu
např. v SICStus Prologu
při volání predikátu s prvním nainstaniovaným argumentem se používá hašovací tabulka
zpřístupňující pouze odpovídající klauzule
zamestnanec( Prijmeni, KrestniJmeno, Oddeleni, ...)
Hana Rudová, Logické programování I, 17. května 2007 97 Technika a styl programování v Prologu
Zlepšení efektivity: základní techniky
Optimalizace posledního volání (LCO) a akumulátory
Rozdílové seznamy při spojování seznamů
Caching: uložení vypočítaných výsledků do programové databáze
Indexace podle prvního argumentu
např. v SICStus Prologu
při volání predikátu s prvním nainstaniovaným argumentem se používá hašovací tabulka
zpřístupňující pouze odpovídající klauzule
zamestnanec( Prijmeni, KrestniJmeno, Oddeleni, ...)
Determinismus:
rozhodnout, které klauzule mají uspět vícekrát, ověřit požadovaný determinismus
Hana Rudová, Logické programování I, 17. května 2007 97 Technika a styl programování v Prologu
Predikátová logika 1.řádu
Teorie logického programování
PROLOG: PROgramming in LOGic, část predikátové logiky 1.řádu
fakta: rodic(petr,petrik), X a(X)
klauzule: X Y rodic(X,Y)  predek(X,Y)
Hana Rudová, Logické programování I, 17. května 2007 99 Teorie logického programování
Teorie logického programování
PROLOG: PROgramming in LOGic, část predikátové logiky 1.řádu
fakta: rodic(petr,petrik), X a(X)
klauzule: X Y rodic(X,Y)  predek(X,Y)
Predikátová logika I. řádu (PL1)
soubory objektů: lidé, čísla, body prostoru, . . .
syntaxe PL1, sémantika PL1, pravdivost a dokazatelnost
Hana Rudová, Logické programování I, 17. května 2007 99 Teorie logického programování
Teorie logického programování
PROLOG: PROgramming in LOGic, část predikátové logiky 1.řádu
fakta: rodic(petr,petrik), X a(X)
klauzule: X Y rodic(X,Y)  predek(X,Y)
Predikátová logika I. řádu (PL1)
soubory objektů: lidé, čísla, body prostoru, . . .
syntaxe PL1, sémantika PL1, pravdivost a dokazatelnost
Rezoluce ve výrokové logice, v PL1
dokazovací metoda
Rezoluce v logickém programování
Backtracking, řez, negace vs. rezoluce
Hana Rudová, Logické programování I, 17. května 2007 99 Teorie logického programování
Predikátová logika I. řádu (PL1)
Abeceda A jazyka L PL1 se skládá ze symbolů:
proměnné X, Y, . . . označují libovolný objekt z daného oboru
Hana Rudová, Logické programování I, 17. května 2007 100 Predikátová logika
Predikátová logika I. řádu (PL1)
Abeceda A jazyka L PL1 se skládá ze symbolů:
proměnné X, Y, . . . označují libovolný objekt z daného oboru
funkční symboly f, g, . . . označují operace (příklad: +, × )
arita = počet argumentů, n-ární symbol, značíme f/n
nulární funkční symboly ­ konstanty: označují význačné objekty (příklad: 0, 1, . . . )
Hana Rudová, Logické programování I, 17. května 2007 100 Predikátová logika
Predikátová logika I. řádu (PL1)
Abeceda A jazyka L PL1 se skládá ze symbolů:
proměnné X, Y, . . . označují libovolný objekt z daného oboru
funkční symboly f, g, . . . označují operace (příklad: +, × )
arita = počet argumentů, n-ární symbol, značíme f/n
nulární funkční symboly ­ konstanty: označují význačné objekty (příklad: 0, 1, . . . )
predikátové symboly p,q, . . . pro vyjádření vlastností a vztahů mezi objekty
arita = počet argumentů, n-ární symbol, značíme p/n příklad: <, 
Hana Rudová, Logické programování I, 17. května 2007 100 Predikátová logika
Predikátová logika I. řádu (PL1)
Abeceda A jazyka L PL1 se skládá ze symbolů:
proměnné X, Y, . . . označují libovolný objekt z daného oboru
funkční symboly f, g, . . . označují operace (příklad: +, × )
arita = počet argumentů, n-ární symbol, značíme f/n
nulární funkční symboly ­ konstanty: označují význačné objekty (příklad: 0, 1, . . . )
predikátové symboly p,q, . . . pro vyjádření vlastností a vztahů mezi objekty
arita = počet argumentů, n-ární symbol, značíme p/n příklad: <, 
logické spojky , , , , 
Hana Rudová, Logické programování I, 17. května 2007 100 Predikátová logika
Predikátová logika I. řádu (PL1)
Abeceda A jazyka L PL1 se skládá ze symbolů:
proměnné X, Y, . . . označují libovolný objekt z daného oboru
funkční symboly f, g, . . . označují operace (příklad: +, × )
arita = počet argumentů, n-ární symbol, značíme f/n
nulární funkční symboly ­ konstanty: označují význačné objekty (příklad: 0, 1, . . . )
predikátové symboly p,q, . . . pro vyjádření vlastností a vztahů mezi objekty
arita = počet argumentů, n-ární symbol, značíme p/n příklad: <, 
logické spojky , , , , 
kvantifikátory , 
logika I. řádu používá kvantifikaci pouze pro individua (odlišnost od logik vyššího řádu)
v logice 1. řádu nelze: v R : A  R, f : R  R
Hana Rudová, Logické programování I, 17. května 2007 100 Predikátová logika
Predikátová logika I. řádu (PL1)
Abeceda A jazyka L PL1 se skládá ze symbolů:
proměnné X, Y, . . . označují libovolný objekt z daného oboru
funkční symboly f, g, . . . označují operace (příklad: +, × )
arita = počet argumentů, n-ární symbol, značíme f/n
nulární funkční symboly ­ konstanty: označují význačné objekty (příklad: 0, 1, . . . )
predikátové symboly p,q, . . . pro vyjádření vlastností a vztahů mezi objekty
arita = počet argumentů, n-ární symbol, značíme p/n příklad: <, 
logické spojky , , , , 
kvantifikátory , 
logika I. řádu používá kvantifikaci pouze pro individua (odlišnost od logik vyššího řádu)
v logice 1. řádu nelze: v R : A  R, f : R  R
závorky: ),(
Hana Rudová, Logické programování I, 17. května 2007 100 Predikátová logika
Jazyky PL1
Specifikace jazyka L je definována funkčními a predikátovými symboly
symboly tedy určují oblast, kterou jazyk popisuje
Jazyky s rovností: obsahují predikátový symbol pro rovnost ,,="
Hana Rudová, Logické programování I, 17. května 2007 101 Predikátová logika
Jazyky PL1
Specifikace jazyka L je definována funkčními a predikátovými symboly
symboly tedy určují oblast, kterou jazyk popisuje
Jazyky s rovností: obsahují predikátový symbol pro rovnost ,,="
Příklady
jazyk teorie uspořádání
jazyk s =, binární prediátový symbol <
Hana Rudová, Logické programování I, 17. května 2007 101 Predikátová logika
Jazyky PL1
Specifikace jazyka L je definována funkčními a predikátovými symboly
symboly tedy určují oblast, kterou jazyk popisuje
Jazyky s rovností: obsahují predikátový symbol pro rovnost ,,="
Příklady
jazyk teorie uspořádání
jazyk s =, binární prediátový symbol <
jazyk teorie množin
jazyk s =, binární predikátový symbol 
Hana Rudová, Logické programování I, 17. května 2007 101 Predikátová logika
Jazyky PL1
Specifikace jazyka L je definována funkčními a predikátovými symboly
symboly tedy určují oblast, kterou jazyk popisuje
Jazyky s rovností: obsahují predikátový symbol pro rovnost ,,="
Příklady
jazyk teorie uspořádání
jazyk s =, binární prediátový symbol <
jazyk teorie množin
jazyk s =, binární predikátový symbol 
jazyk elementární aritmetiky
jazyk s =, nulární funkční symbol 0 pro nulu,
unární funkční symbol s pro operaci následníka,
binární funkční symboly pro sčítání + a násobení ×
Hana Rudová, Logické programování I, 17. května 2007 101 Predikátová logika
Term, atomická formule, formule
Term nad abecedou A
každá proměnná z A je term
je-li f/n z A a t1, . . . , tn jsou termy, pak f(t1, . . . , tn) je také term
každý term vznikne konečným počtem užití přechozích kroků f( X, g(X,0) )
Hana Rudová, Logické programování I, 17. května 2007 102 Predikátová logika
Term, atomická formule, formule
Term nad abecedou A
každá proměnná z A je term
je-li f/n z A a t1, . . . , tn jsou termy, pak f(t1, . . . , tn) je také term
každý term vznikne konečným počtem užití přechozích kroků f( X, g(X,0) )
Atomická formule (atom) nad abecedou A
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, 17. května 2007 102 Predikátová logika
Term, atomická formule, formule
Term nad abecedou A
každá proměnná z A je term
je-li f/n z A a t1, . . . , tn jsou termy, pak f(t1, . . . , tn) je také term
každý term vznikne konečným počtem užití přechozích kroků f( X, g(X,0) )
Atomická formule (atom) nad abecedou A
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
každá atomická formule je formule
jsou-li F a G formule, pak také (F), (F  G), (F  G), (F  G), (F  G) jsou formule
je-li X proměnná a F formule, pak také (X F) a (X F) jsou formule
každá formule vznikne konečným počtem užití přechozích kroků (X ((f(X) = 0)  p(0)))
Hana Rudová, Logické programování I, 17. května 2007 102 Predikátová logika
Interpretace
Interpretace I jazyka L nad abecedou A je dána
neprázdnou množinou D (také značíme |I|, nazývá se univerzum) a
zobrazením, které
každé konstantě c  A přiřadí nějaký prvek D
každému funkčnímu symbolu f/n  A přiřadí n-ární operaci nad D
každému predikátovému symbolu p/n  A přiřadí n-ární relaci nad D
Hana Rudová, Logické programování I, 17. května 2007 103 Predikátová logika
Interpretace
Interpretace I jazyka L nad abecedou A je dána
neprázdnou množinou D (také značíme |I|, nazývá se univerzum) a
zobrazením, které
každé konstantě c  A přiřadí nějaký prvek D
každému funkčnímu symbolu f/n  A přiřadí n-ární operaci nad D
každému predikátovému symbolu p/n  A přiřadí n-ární relaci nad D
Příklad: uspořádání na R
jazyk: predikátový symbol mensi/2
interpretace: univerzum R; zobrazení: mensi(x, y) := x < y
Hana Rudová, Logické programování I, 17. května 2007 103 Predikátová logika
Interpretace
Interpretace I jazyka L nad abecedou A je dána
neprázdnou množinou D (také značíme |I|, nazývá se univerzum) a
zobrazením, které
každé konstantě c  A přiřadí nějaký prvek D
každému funkčnímu symbolu f/n  A přiřadí n-ární operaci nad D
každému predikátovému symbolu p/n  A přiřadí n-ární relaci nad D
Příklad: uspořádání na R
jazyk: predikátový symbol mensi/2
interpretace: univerzum R; zobrazení: mensi(x, y) := x < y
Příklad: elementární aritmetika nad množinou N (včetně 0)
jazyk: konstanta zero, funční symboly s/1, plus/2
interpretace:
univerzum N; zobrazení: zero := 0, s(x) := 1 + x, plus(x, y) := x + y
Hana Rudová, Logické programování I, 17. května 2007 103 Predikátová logika
Sémantika formulí
Ohodnocení proměnné (X): každé proměnné X je přiřazen prvek |I|
Hodnota termu (t): každému termu je přiřazen prvek univerza
příklad: necht' (X) := 0
(plus(s(zero), X)) =
Hana Rudová, Logické programování I, 17. května 2007 104 Predikátová logika
Sémantika formulí
Ohodnocení proměnné (X): každé proměnné X je přiřazen prvek |I|
Hodnota termu (t): každému termu je přiřazen prvek univerza
příklad: necht' (X) := 0
(plus(s(zero), X)) = (s(zero)) + (X) =
Hana Rudová, Logické programování I, 17. května 2007 104 Predikátová logika
Sémantika formulí
Ohodnocení proměnné (X): každé proměnné X je přiřazen prvek |I|
Hodnota termu (t): každému termu je přiřazen prvek univerza
příklad: necht' (X) := 0
(plus(s(zero), X)) = (s(zero)) + (X) = (1 + (zero)) + 0 =
Hana Rudová, Logické programování I, 17. května 2007 104 Predikátová logika
Sémantika formulí
Ohodnocení proměnné (X): každé proměnné X je přiřazen prvek |I|
Hodnota termu (t): každému termu je přiřazen prvek univerza
příklad: necht' (X) := 0
(plus(s(zero), X)) = (s(zero)) + (X) = (1 + (zero)) + 0 = (1 + 0) + 0 = 1
Hana Rudová, Logické programování I, 17. května 2007 104 Predikátová logika
Sémantika formulí
Ohodnocení proměnné (X): každé proměnné X je přiřazen prvek |I|
Hodnota termu (t): každému termu je přiřazen prvek univerza
příklad: necht' (X) := 0
(plus(s(zero), X)) = (s(zero)) + (X) = (1 + (zero)) + 0 = (1 + 0) + 0 = 1
Každá dobře utvořená formule označuje pravdivostní hodnotu
(PRAVDA, NEPRAVDA) v závislosti na své struktuře a interpretaci
Pravdivá formule I  Q: formule Q označena PRAVDA
Neravdivá formule I  Q: formule Q označena NEPRAVDA
Hana Rudová, Logické programování I, 17. května 2007 104 Predikátová logika
Sémantika formulí
Ohodnocení proměnné (X): každé proměnné X je přiřazen prvek |I|
Hodnota termu (t): každému termu je přiřazen prvek univerza
příklad: necht' (X) := 0
(plus(s(zero), X)) = (s(zero)) + (X) = (1 + (zero)) + 0 = (1 + 0) + 0 = 1
Každá dobře utvořená formule označuje pravdivostní hodnotu
(PRAVDA, NEPRAVDA) v závislosti na své struktuře a interpretaci
Pravdivá formule I  Q: formule Q označena PRAVDA
Neravdivá formule I  Q: formule Q označena NEPRAVDA
příklad: p/1 predikátový symbol, tj. p  |I| p := { 1 , 3 , 5 , . . .}
I p(zero)  p(s(zero))
Hana Rudová, Logické programování I, 17. května 2007 104 Predikátová logika
Sémantika formulí
Ohodnocení proměnné (X): každé proměnné X je přiřazen prvek |I|
Hodnota termu (t): každému termu je přiřazen prvek univerza
příklad: necht' (X) := 0
(plus(s(zero), X)) = (s(zero)) + (X) = (1 + (zero)) + 0 = (1 + 0) + 0 = 1
Každá dobře utvořená formule označuje pravdivostní hodnotu
(PRAVDA, NEPRAVDA) v závislosti na své struktuře a interpretaci
Pravdivá formule I  Q: formule Q označena PRAVDA
Neravdivá formule I  Q: formule Q označena NEPRAVDA
příklad: p/1 predikátový symbol, tj. p  |I| p := { 1 , 3 , 5 , . . .}
I p(zero)  p(s(zero)) iff I p(zero) a I p(s(zero))
Hana Rudová, Logické programování I, 17. května 2007 104 Predikátová logika
Sémantika formulí
Ohodnocení proměnné (X): každé proměnné X je přiřazen prvek |I|
Hodnota termu (t): každému termu je přiřazen prvek univerza
příklad: necht' (X) := 0
(plus(s(zero), X)) = (s(zero)) + (X) = (1 + (zero)) + 0 = (1 + 0) + 0 = 1
Každá dobře utvořená formule označuje pravdivostní hodnotu
(PRAVDA, NEPRAVDA) v závislosti na své struktuře a interpretaci
Pravdivá formule I  Q: formule Q označena PRAVDA
Neravdivá formule I  Q: formule Q označena NEPRAVDA
příklad: p/1 predikátový symbol, tj. p  |I| p := { 1 , 3 , 5 , . . .}
I p(zero)  p(s(zero)) iff I p(zero) a I p(s(zero))
iff (zero)  p a (s(zero))  p
Hana Rudová, Logické programování I, 17. května 2007 104 Predikátová logika
Sémantika formulí
Ohodnocení proměnné (X): každé proměnné X je přiřazen prvek |I|
Hodnota termu (t): každému termu je přiřazen prvek univerza
příklad: necht' (X) := 0
(plus(s(zero), X)) = (s(zero)) + (X) = (1 + (zero)) + 0 = (1 + 0) + 0 = 1
Každá dobře utvořená formule označuje pravdivostní hodnotu
(PRAVDA, NEPRAVDA) v závislosti na své struktuře a interpretaci
Pravdivá formule I  Q: formule Q označena PRAVDA
Neravdivá formule I  Q: formule Q označena NEPRAVDA
příklad: p/1 predikátový symbol, tj. p  |I| p := { 1 , 3 , 5 , . . .}
I p(zero)  p(s(zero)) iff I p(zero) a I p(s(zero))
iff (zero)  p a (s(zero))  p
iff (zero)  p a (1 + (zero)  p
Hana Rudová, Logické programování I, 17. května 2007 104 Predikátová logika
Sémantika formulí
Ohodnocení proměnné (X): každé proměnné X je přiřazen prvek |I|
Hodnota termu (t): každému termu je přiřazen prvek univerza
příklad: necht' (X) := 0
(plus(s(zero), X)) = (s(zero)) + (X) = (1 + (zero)) + 0 = (1 + 0) + 0 = 1
Každá dobře utvořená formule označuje pravdivostní hodnotu
(PRAVDA, NEPRAVDA) v závislosti na své struktuře a interpretaci
Pravdivá formule I  Q: formule Q označena PRAVDA
Neravdivá formule I  Q: formule Q označena NEPRAVDA
příklad: p/1 predikátový symbol, tj. p  |I| p := { 1 , 3 , 5 , . . .}
I p(zero)  p(s(zero)) iff I p(zero) a I p(s(zero))
iff (zero)  p a (s(zero))  p
iff (zero)  p a (1 + (zero)  p
iff 0  p a 1  p
1  p ale 0  p, tedy formule je nepravdivá v I
Hana Rudová, Logické programování I, 17. května 2007 104 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řiřazením s/1: s(x):=x není modelem této formule
Hana Rudová, Logické programování I, 17. května 2007 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řiřazení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 axiomů teorie elementární aritmetiky
Hana Rudová, Logické programování I, 17. května 2007 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řiřazení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 axiomů teorie elementární aritmetiky
Model teorie: libovolná interpretace, která je modelem všech jejích axiomů
všechny axiomy teorie musí být v této interpretaci pravdivé
Hana Rudová, Logické programování I, 17. května 2007 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řiřazení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 axiomů teorie elementární aritmetiky
Model teorie: libovolná interpretace, která je modelem všech jejích axiomů
všechny axiomy teorie musí být v této interpretaci pravdivé
Pravdivá formule v teorii T F: pravdivá v každém z modelů teorie T
říkáme také formule platí v teorii nebo je splněna v teorii
formule 1 + s(0) = s(s(0)) je pravdivá v teorii elementárních čísel
Hana Rudová, Logické programování I, 17. května 2007 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řiřazení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 axiomů teorie elementární aritmetiky
Model teorie: libovolná interpretace, která je modelem všech jejích axiomů
všechny axiomy teorie musí být v této interpretaci pravdivé
Pravdivá formule v teorii T F: pravdivá v každém z modelů teorie T
říkáme také formule platí v teorii nebo je splněna v teorii
formule 1 + s(0) = s(s(0)) je pravdivá v teorii elementárních čísel
Logicky pravdivá formule F: libovolná interpretace je jejím modelem
nebo-li F je pravdivá v každém modelu libovolné teorie
formule G   G je logicky pravdivá, formule 1 + s(0) = s(s(0)) není logicky pravdivá
Hana Rudová, Logické programování I, 17. května 2007 105 Predikátová logika
Zkoumání pravdivosti formulí
Zjištění pravdivosti provádíme důkazem
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 určitých odvozovacích pravidel
Hana Rudová, Logické programování I, 17. května 2007 106 Predikátová logika
Zkoumání pravdivosti formulí
Zjištění pravdivosti provádíme důkazem
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 určitých odvozovacích pravidel
Odvozovací pravidla ­ příklady
pravidlo modus ponens: z formulí F a F  G lze odvodit G
Hana Rudová, Logické programování I, 17. května 2007 106 Predikátová logika
Zkoumání pravdivosti formulí
Zjištění pravdivosti provádíme důkazem
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 určitých odvozovacích pravidel
Odvozovací pravidla ­ příklady
pravidlo modus ponens: z formulí F a F  G lze odvodit G
rezoluční princip: z formulí F  A, G  A odvodit F  G
Hana Rudová, Logické programování I, 17. května 2007 106 Predikátová logika
Zkoumání pravdivosti formulí
Zjištění pravdivosti provádíme důkazem
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 určitých odvozovacích pravidel
Odvozovací pravidla ­ příklady
pravidlo modus ponens: z formulí F a F  G lze odvodit G
rezoluční princip: z formulí F  A, G  A odvodit F  G
F je dokazatelná z formulí A1,    , An A1,    , An F
existuje-li důkaz F z A1,    , An
Hana Rudová, Logické programování I, 17. května 2007 106 Predikátová logika
Zkoumání pravdivosti formulí
Zjištění pravdivosti provádíme důkazem
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 určitých odvozovacích pravidel
Odvozovací pravidla ­ příklady
pravidlo modus ponens: z formulí F a F  G lze odvodit G
rezoluční princip: z formulí F  A, G  A odvodit F  G
F je dokazatelná z formulí A1,    , An A1,    , An 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, 17. května 2007 106 Predikátová logika
Korektnost a úplnost
Uzavřená formule: neobsahuje volnou proměnnou (bez kvantifikace)
Y ( (0 < Y)  ( X (X < Y) ) ) je uzavřená formule
( X (X < Y) ) není uzavřená formule
Hana Rudová, Logické programování I, 17. května 2007 107 Predikátová logika
Korektnost a úplnost
Uzavřená formule: neobsahuje volnou proměnnou (bez kvantifikace)
Y ( (0 < Y)  ( X (X < Y) ) ) je uzavřená formule
( X (X < Y) ) není uzavřená formule
Množina odvozovacích pravidel se nazývá korektní, jestliže pro každou
množinu uzavřených formulí P a každou uzavřenou formuli F platí:
jestliže P F pak P F (jestliže je něco dokazatelné, pak to platí)
Hana Rudová, Logické programování I, 17. května 2007 107 Predikátová logika
Korektnost a úplnost
Uzavřená formule: neobsahuje volnou proměnnou (bez kvantifikace)
Y ( (0 < Y)  ( X (X < Y) ) ) je uzavřená formule
( X (X < Y) ) není uzavřená formule
Množina odvozovacích pravidel se nazývá korektní, jestliže pro každou
množinu uzavřených formulí P a každou uzavřenou formuli F platí:
jestliže P F pak P F (jestliže je něco dokazatelné, pak to platí)
Odvozovací pravidla jsou úplná, jestliže
jestliže P F pak P F (jestliže něco platí, pak je to dokazatelné)
Hana Rudová, Logické programování I, 17. května 2007 107 Predikátová logika
Korektnost a úplnost
Uzavřená formule: neobsahuje volnou proměnnou (bez kvantifikace)
Y ( (0 < Y)  ( X (X < Y) ) ) je uzavřená formule
( X (X < Y) ) není uzavřená formule
Množina odvozovacích pravidel se nazývá korektní, jestliže pro každou
množinu uzavřených formulí P a každou uzavřenou formuli F platí:
jestliže P F pak P F (jestliže je něco dokazatelné, pak to platí)
Odvozovací pravidla jsou úplná, jestliže
jestliže P F pak P F (jestliže něco platí, pak je to dokazatelné)
PL1: úplná a korektní dokazatelnost, tj.
pro teorii T s množinou axiomů A platí: T F právě když A F
Hana Rudová, Logické programování I, 17. května 2007 107 Predikátová logika
Rezoluce v predikátové logice I. řádu
Rezoluce
rezoluční princip: z F  A, G  A odvodit F  G
dokazovací metoda používaná
v Prologu
ve většině systémů pro automatické dokazování
Hana Rudová, Logické programování I, 17. května 2007 109 Rezoluce v PL1
Rezoluce
rezoluční princip: z F  A, G  A odvodit F  G
dokazovací metoda používaná
v Prologu
ve většině systémů pro automatické dokazování
procedura pro vyvrácení
hledáme důkaz pro negaci formule
snažíme se dokázat, že negace formule je nesplnitelná
= formule je vždy pravdivá
Hana Rudová, Logické programování I, 17. května 2007 109 Rezoluce v PL1
Formule
literál l
pozitivní literál = atomická formule p(t1,    , tn)
negativní literál = negace atomické formule p(t1,    , tn)
Hana Rudová, Logické programování I, 17. května 2007 110 Rezoluce v PL1
Formule
literál l
pozitivní literál = atomická formule p(t1,    , tn)
negativní literál = negace atomické formule p(t1,    , tn)
klauzule C = konečná množina literálů reprezentující jejich disjunkci
příklad: p(X)  q(a, f)  p(Y) notace: {p(X), q(a, f), p(Y)}
klauzule je pravdivá  je pravdivý alespoň jeden z jejích literálů
prázdná klauzule se značí a je vždy nepravdivá (neexistuje v ní pravdivý literál)
Hana Rudová, Logické programování I, 17. května 2007 110 Rezoluce v PL1
Formule
literál l
pozitivní literál = atomická formule p(t1,    , tn)
negativní literál = negace atomické formule p(t1,    , tn)
klauzule C = konečná množina literálů reprezentující jejich disjunkci
příklad: p(X)  q(a, f)  p(Y) notace: {p(X), q(a, f), p(Y)}
klauzule je pravdivá  je pravdivý alespoň jeden z jejích literálů
prázdná klauzule se značí 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í formě (konjunkce disjunkcí)
příklad: (p  q)  (p)  (p  q  r) notace: {{p, q}, {p}, {p, q, r}}
Hana Rudová, Logické programování I, 17. května 2007 110 Rezoluce v PL1
Formule
literál l
pozitivní literál = atomická formule p(t1,    , tn)
negativní literál = negace atomické formule p(t1,    , tn)
klauzule C = konečná množina literálů reprezentující jejich disjunkci
příklad: p(X)  q(a, f)  p(Y) notace: {p(X), q(a, f), p(Y)}
klauzule je pravdivá  je pravdivý alespoň jeden z jejích literálů
prázdná klauzule se značí 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í formě (konjunkce disjunkcí)
příklad: (p  q)  (p)  (p  q  r) notace: {{p, q}, {p}, {p, q, r}}
formule je pravdivá  všechny klauzule jsou pravdivé
prázdná formule je vždy pravdivá (neexistuje klauzule, která by byla nepravdivá)
Hana Rudová, Logické programování I, 17. května 2007 110 Rezoluce v PL1
Formule
literál l
pozitivní literál = atomická formule p(t1,    , tn)
negativní literál = negace atomické formule p(t1,    , tn)
klauzule C = konečná množina literálů reprezentující jejich disjunkci
příklad: p(X)  q(a, f)  p(Y) notace: {p(X), q(a, f), p(Y)}
klauzule je pravdivá  je pravdivý alespoň jeden z jejích literálů
prázdná klauzule se značí 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í formě (konjunkce disjunkcí)
příklad: (p  q)  (p)  (p  q  r) notace: {{p, q}, {p}, {p, q, r}}
formule je pravdivá  všechny klauzule jsou pravdivé
prázdná formule je vždy pravdivá (neexistuje klauzule, která by byla nepravdivá)
množinová notace: literál je prvek klauzule, klauzule je prvek formule, . . .
Hana Rudová, Logické programování I, 17. května 2007 110 Rezoluce v PL1
Splnitelnost
[ Opakování: ] 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.
příklad: F = {{f(a, b) = f (b, a)}, {f(f(a, a), b) = a}}
interpretace I1: D = Z, a := 1, b := -1, f := " + "
Hana Rudová, Logické programování I, 17. května 2007 111 Rezoluce v PL1
Splnitelnost
[ Opakování: ] 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.
příklad: F = {{f(a, b) = f (b, a)}, {f(f(a, a), b) = a}}
interpretace I1: D = Z, a := 1, b := -1, f := " + "
Formule je splnitelná, existuje-li interpretace, pro kterou je pravdivá
formule je konjunkce klauzulí, tj. všechny klauzule musí být v dané interpretaci pravdivé
příklad (pokrač.): F je splnitelná (je pravdivá v I1)
Hana Rudová, Logické programování I, 17. května 2007 111 Rezoluce v PL1
Splnitelnost
[ Opakování: ] 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.
příklad: F = {{f(a, b) = f (b, a)}, {f(f(a, a), b) = a}}
interpretace I1: D = Z, a := 1, b := -1, f := " + "
Formule je splnitelná, existuje-li interpretace, pro kterou je pravdivá
formule je konjunkce klauzulí, tj. všechny klauzule musí být v dané interpretaci pravdivé
příklad (pokrač.): F je splnitelná (je pravdivá v I1)
Formule je nesplnitelná, neexistuje-li interpretace, pro kterou je pravdivá
tj. formule je ve všech iterpretacích nepravdivá
tj. neexistuje interpretace, ve které by byly všechny klauzule pravdivé
příklad: G = {{p(b)}, {p(a)}, {p(a)}} je nesplnitelná
({p(a)} a {p(a)} nemohou být zároveň pravdivé)
Hana Rudová, Logické programování I, 17. května 2007 111 Rezoluce v PL1
Rezoluční princip ve výrokové logice
Rezoluční princip = pravidlo, které umožňuje odvodit
z klauzulí C1  {l} a {l}  C2 klauzuli C1  C2
C1  {l} {l}  C2
C1  C2
C1  C2 se nazývá rezolventou původních klauzulí
Hana Rudová, Logické programování I, 17. května 2007 112 Rezoluce v PL1
Rezoluční princip ve výrokové logice
Rezoluční princip = pravidlo, které umožňuje odvodit
z klauzulí C1  {l} a {l}  C2 klauzuli C1  C2
C1  {l} {l}  C2
C1  C2
C1  C2 se nazývá rezolventou původních klauzulí
příklad:
{p, r} {r, s}
{p, s}
(p  r)  (r  s)
p  s
Hana Rudová, Logické programování I, 17. května 2007 112 Rezoluce v PL1
Rezoluční princip ve výrokové logice
Rezoluční princip = pravidlo, které umožňuje odvodit
z klauzulí C1  {l} a {l}  C2 klauzuli C1  C2
C1  {l} {l}  C2
C1  C2
C1  C2 se nazývá rezolventou původních klauzulí
příklad:
{p, r} {r, s}
{p, s}
(p  r)  (r  s)
p  s
obě klauzule (p  r) a (r  s) musí být pravdivé
protože r nestačí k pravdivosti obou klauzulí,
musí být pravdivé p (pokud je pravdivé r) nebo s (pokud je pravdivé r),
tedy platí klauzule p  s
Hana Rudová, Logické programování I, 17. května 2007 112 Rezoluce v PL1
Rezoluční důkaz
rezoluční důkaz klauzule C z formule F je konečná posloupnost
C1, . . . , 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, 17. května 2007 113 Rezoluce v PL1
Rezoluční důkaz
rezoluční důkaz klauzule C z formule F je konečná posloupnost
C1, . . . , Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo
rezolventa Cj, Ck pro k, j < i.
příklad: rezoluční důkaz {p} z formule F = {{p, r}, {q, r}, {q}}
Hana Rudová, Logické programování I, 17. května 2007 113 Rezoluce v PL1
Rezoluční důkaz
rezoluční důkaz klauzule C z formule F je konečná posloupnost
C1, . . . , Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo
rezolventa Cj, Ck pro k, j < i.
příklad: rezoluční důkaz {p} z formule F = {{p, r}, {q, r}, {q}}
C1 = {p, r} klauzule z F
Hana Rudová, Logické programování I, 17. května 2007 113 Rezoluce v PL1
Rezoluční důkaz
rezoluční důkaz klauzule C z formule F je konečná posloupnost
C1, . . . , Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo
rezolventa Cj, Ck pro k, j < i.
příklad: rezoluční 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, 17. května 2007 113 Rezoluce v PL1
Rezoluční důkaz
rezoluční důkaz klauzule C z formule F je konečná posloupnost
C1, . . . , Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo
rezolventa Cj, Ck pro k, j < i.
příklad: rezoluční 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, 17. května 2007 113 Rezoluce v PL1
Rezoluční důkaz
rezoluční důkaz klauzule C z formule F je konečná posloupnost
C1, . . . , Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo
rezolventa Cj, Ck pro k, j < i.
příklad: rezoluční 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, 17. května 2007 113 Rezoluce v PL1
Rezoluční důkaz
rezoluční důkaz klauzule C z formule F je konečná posloupnost
C1, . . . , Cn = C klauzulí taková, že Ci je bud' klauzule z F nebo
rezolventa Cj, Ck pro k, j < i.
příklad: rezoluční 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
C5 = {p} = C rezolventa C3 a C4
Hana Rudová, Logické programování I, 17. května 2007 113 Rezoluce v PL1
Rezoluční vyvrácení
rezoluční důkaz formule F spočí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, 17. května 2007 114 Rezoluce v PL1
Rezoluční vyvrácení
rezoluční důkaz formule F spočívá v demonstraci nesplnitelnosti F
F nesplnitelná  F je nepravdivá ve všech interpretacích  F je vždy pravdivá
začneme-li z klauzulí reprezentujících F, musíme postupným uplatňováním
rezolučního principu dospět k prázdné klauzuli
Příklad:
F . . . a  a
Hana Rudová, Logické programování I, 17. května 2007 114 Rezoluce v PL1
Rezoluční vyvrácení
rezoluční důkaz formule F spočívá v demonstraci nesplnitelnosti F
F nesplnitelná  F je nepravdivá ve všech interpretacích  F je vždy pravdivá
začneme-li z klauzulí reprezentujících F, musíme postupným uplatňováním
rezolučního principu dospět k prázdné klauzuli
Příklad:
F . . . a  a
F . . . a  a
F . . . {{a}, {a}}
Hana Rudová, Logické programování I, 17. května 2007 114 Rezoluce v PL1
Rezoluční vyvrácení
rezoluční důkaz formule F spočívá v demonstraci nesplnitelnosti F
F nesplnitelná  F je nepravdivá ve všech interpretacích  F je vždy pravdivá
začneme-li z klauzulí reprezentujících F, musíme postupným uplatňováním
rezolučního principu dospět k prázdné klauzuli
Příklad:
F . . . a  a
F . . . a  a
F . . . {{a}, {a}}
C1 = {a}, C2 = {a}
rezolventa C1 a C2 je , tj. F je vždy pravdivá
rezoluční důkaz z formule F se nazývá rezoluční vyvrácení formule F
Hana Rudová, Logické programování I, 17. května 2007 114 Rezoluce v PL1
Strom rezolučního důkazu
strom rezolučního důkazu klauzule C z formule F je binární strom:
kořen je označen klauzulí C,
listy jsou označeny klauzulemi z F a
každý uzel, který není listem,
má bezprostředními potomky označené klauzulemi C1 a C2
je označen rezolventou klauzulí C1 a C2
příklad: F = {{p, r}, {q, r}, {q}, {p}} C =
{p, r} {q, r} {q} {p}
{p, q}
{p}
d
d
d
d 
 
 
 




7
7
7
7
7
7
7
7
7
7
t
t
t
t
t(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
strom rezolučního vyvrácení
(rezoluční důkaz z F)
Hana Rudová, Logické programování I, 17. května 2007 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:
kořen je označen klauzulí C,
listy jsou označeny klauzulemi z F a
každý uzel, který není listem,
má bezprostředními potomky označené klauzulemi C1 a C2
je označen rezolventou klauzulí C1 a C2
příklad: F = {{p, r}, {q, r}, {q}, {p}} C =
{p, r} {q, r} {q} {p}
{p, q}
{p}
d
d
d
d 
 
 
 




7
7
7
7
7
7
7
7
7
7
t
t
t
t
t(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
strom rezolučního vyvrácení
(rezoluční důkaz z F)
příklad: {{p, r}, {q, r}, {q}, {p, t}, {s}, {s, t}}
Hana Rudová, Logické programování I, 17. května 2007 115 Rezoluce v PL1
Substituce
co s proměnný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, 17. května 2007 116 Rezoluce v PL1
Substituce
co s proměnný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  zobrazující výrazy do výrazů tak, že platí
(E) = E pro libovolnou konstantu E
(f (E1,    , En)) = f((E1),    , (En)) pro libovolný funkční symbol f
(p(E1,    , En)) = p((E1),    , (En)) pro libovolný predik. symbol p
substituce je tedy homomorfismus výrazů, který zachová vše kromě
proměnných ­ ty lze nahradit čímkoliv
substituce zapisujeme zpravidla ve tvaru seznamu [X1/1,    , Xn/n]
kde Xi jsou proměnné a i substituované termy
příklad: p(X)[X/f(a)]  p(f (a))
Hana Rudová, Logické programování I, 17. května 2007 116 Rezoluce v PL1
Substituce
co s proměnný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  zobrazující výrazy do výrazů tak, že platí
(E) = E pro libovolnou konstantu E
(f (E1,    , En)) = f((E1),    , (En)) pro libovolný funkční symbol f
(p(E1,    , En)) = p((E1),    , (En)) pro libovolný predik. symbol p
substituce je tedy homomorfismus výrazů, který zachová vše kromě
proměnných ­ ty lze nahradit čímkoliv
substituce zapisujeme zpravidla ve tvaru seznamu [X1/1,    , Xn/n]
kde Xi jsou proměnné a i substituované termy
příklad: p(X)[X/f(a)]  p(f (a))
přejmenování proměnných: speciální náhrada proměnných proměnnými
příklad: p(X)[X/Y]  p(Y)
Hana Rudová, Logické programování I, 17. května 2007 116 Rezoluce v PL1
Unifikace
Ztotožnění dvou literálů p, q pomocí vhodné substituce  takové, že p = q
nazýváme unifikací a příslušnou substituci unifikátorem.
Unifikátorem množiny S literálů nazýváme substituce  takovou, že množina
S = {t|t  S}
má jediný prvek.
Hana Rudová, Logické programování I, 17. května 2007 117 Rezoluce v PL1
Unifikace
Ztotožnění dvou literálů p, q pomocí vhodné substituce  takové, že p = q
nazýváme unifikací a příslušnou substituci unifikátorem.
Unifikátorem množiny S literálů nazýváme substituce  takovou, že množina
S = {t|t  S}
má jediný prvek.
příklad: S = { datum( D1, M1, 2003 ), datum( 1, M2, Y2) }
unifikátor  = [D1/1, M1/2, M2/2, Y2/2003] S = { datum( 1, 2, 2003 ) }
Hana Rudová, Logické programování I, 17. května 2007 117 Rezoluce v PL1
Unifikace
Ztotožnění dvou literálů p, q pomocí vhodné substituce  takové, že p = q
nazýváme unifikací a příslušnou substituci unifikátorem.
Unifikátorem množiny S literálů nazýváme substituce  takovou, že množina
S = {t|t  S}
má jediný prvek.
příklad: S = { datum( D1, M1, 2003 ), datum( 1, M2, Y2) }
unifikátor  = [D1/1, M1/2, M2/2, Y2/2003] S = { datum( 1, 2, 2003 ) }
Unifikátor  množiny S nazýváme nejobecnějším unifikátorem (mgu ­ most
general unifier), jestliže pro libovolný unifikátor  existuje substituce 
taková, že  = .
Hana Rudová, Logické programování I, 17. května 2007 117 Rezoluce v PL1
Unifikace
Ztotožnění dvou literálů p, q pomocí vhodné substituce  takové, že p = q
nazýváme unifikací a příslušnou substituci unifikátorem.
Unifikátorem množiny S literálů nazýváme substituce  takovou, že množina
S = {t|t  S}
má jediný prvek.
příklad: S = { datum( D1, M1, 2003 ), datum( 1, M2, Y2) }
unifikátor  = [D1/1, M1/2, M2/2, Y2/2003] S = { datum( 1, 2, 2003 ) }
Unifikátor  množiny S nazýváme nejobecnějším unifikátorem (mgu ­ most
general unifier), jestliže pro libovolný unifikátor  existuje substituce 
taková, že  = .
příklad (pokrač.): nejobecnější unifikátor  = [D1/1, Y2/2003, M1/M2],
Hana Rudová, Logické programování I, 17. května 2007 117 Rezoluce v PL1
Unifikace
Ztotožnění dvou literálů p, q pomocí vhodné substituce  takové, že p = q
nazýváme unifikací a příslušnou substituci unifikátorem.
Unifikátorem množiny S literálů nazýváme substituce  takovou, že množina
S = {t|t  S}
má jediný prvek.
příklad: S = { datum( D1, M1, 2003 ), datum( 1, M2, Y2) }
unifikátor  = [D1/1, M1/2, M2/2, Y2/2003] S = { datum( 1, 2, 2003 ) }
Unifikátor  množiny S nazýváme nejobecnějším unifikátorem (mgu ­ most
general unifier), jestliže pro libovolný unifikátor  existuje substituce 
taková, že  = .
příklad (pokrač.): nejobecnější unifikátor  = [D1/1, Y2/2003, M1/M2], =[M2/2]
Hana Rudová, Logické programování I, 17. května 2007 117 Rezoluce v PL1
Rezoluční princip v PL1
základ:
rezoluční princip ve výrokové logice
C1  {l} {l}  C2
C1  C2
substituce, unifikátor, nejobecnější unifikátor
Hana Rudová, Logické programování I, 17. května 2007 118 Rezoluce v PL1
Rezoluční princip v PL1
základ:
rezoluční princip ve výrokové logice
C1  {l} {l}  C2
C1  C2
substituce, unifikátor, nejobecnější unifikátor
rezoluční princip v PL1 je pravidlo, které
připraví příležitost pro uplatnění vlastního rezolučního pravidla
nalezením vhodného unifikátoru
provede rezoluci a získá rezolventu
Hana Rudová, Logické programování I, 17. května 2007 118 Rezoluce v PL1
Rezoluční princip v PL1
základ:
rezoluční princip ve výrokové logice
C1  {l} {l}  C2
C1  C2
substituce, unifikátor, nejobecnější unifikátor
rezoluční princip v PL1 je pravidlo, které
připraví příležitost pro uplatnění vlastního rezolučního pravidla
nalezením vhodného unifikátoru
provede rezoluci a získá rezolventu
C1  {A} {B}  C2
C1  C2
kde  je přejmenováním proměnných takové,
že klauzule (C1  A) a {B}  C2 nemají společné proměnné
 je nejobecnější unifikátor klauzulí A a B
Hana Rudová, Logické programování I, 17. května 2007 118 Rezoluce v PL1
Příklad: rezoluce v PL1
příklad: C1 = {p(X, Y), q(Y)} C2 = {q(a), s(X, W)}
Hana Rudová, Logické programování I, 17. května 2007 119 Rezoluce v PL1
Příklad: rezoluce v PL1
příklad: C1 = {p(X, Y), q(Y)} C2 = {q(a), s(X, W)}
přejmenování proměnných:  = [X/Z]
C1 = {p(Z, Y), q(Y)} C2 = {q(a), s(X, W)}
Hana Rudová, Logické programování I, 17. května 2007 119 Rezoluce v PL1
Příklad: rezoluce v PL1
příklad: C1 = {p(X, Y), q(Y)} C2 = {q(a), s(X, W)}
přejmenování proměnných:  = [X/Z]
C1 = {p(Z, Y), q(Y)} C2 = {q(a), s(X, W)}
nejobecnější unifikátor:  = [Y/a]
C1 = {p(Z, a), q(a)} C2 = {q(a), s(X, W)}
Hana Rudová, Logické programování I, 17. května 2007 119 Rezoluce v PL1
Příklad: rezoluce v PL1
příklad: C1 = {p(X, Y), q(Y)} C2 = {q(a), s(X, W)}
přejmenování proměnných:  = [X/Z]
C1 = {p(Z, Y), q(Y)} C2 = {q(a), s(X, W)}
nejobecnější unifikátor:  = [Y/a]
C1 = {p(Z, a), q(a)} C2 = {q(a), s(X, W)}
rezoluční princip: C = {p(Z, a), s(X, W)}
Hana Rudová, Logické programování I, 17. května 2007 119 Rezoluce v PL1
Příklad: rezoluce v PL1
příklad: C1 = {p(X, Y), q(Y)} C2 = {q(a), s(X, W)}
přejmenování proměnných:  = [X/Z]
C1 = {p(Z, Y), q(Y)} C2 = {q(a), s(X, W)}
nejobecnější unifikátor:  = [Y/a]
C1 = {p(Z, a), q(a)} C2 = {q(a), s(X, W)}
rezoluční 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(a), f(a)), p(f(W), f(W)}
Hana Rudová, Logické programování I, 17. května 2007 119 Rezoluce v PL1
Rezoluce v PL1
Obecný rezoluční princip v PL1
C1  {A1,    , Am} {B1,    , Bn}  C2
C1  C2
kde  je přejmenováním proměnných takové, že množiny klauzulí
{A1,    , Am} a {B1,    , Bn} nemají společné proměnné
 je nejobecnější unifikátor množiny {A1,    , Am, B1,    , Bn}
Hana Rudová, Logické programování I, 17. května 2007 120 Rezoluce v PL1
Rezoluce v PL1
Obecný rezoluční princip v PL1
C1  {A1,    , Am} {B1,    , Bn}  C2
C1  C2
kde  je přejmenováním proměnných takové, že množiny klauzulí
{A1,    , Am} a {B1,    , Bn} nemají společné proměnné
 je nejobecnější unifikátor množiny {A1,    , Am, B1,    , Bn}
příklad: A1 = a(X) vs. {B1, B2} = {a(b), a(Z)}
v jednom kroku potřebuji vyrezolvovat zároveň B1 i B2
Hana Rudová, Logické programování I, 17. května 2007 120 Rezoluce v PL1
Rezoluce v PL1
Obecný rezoluční princip v PL1
C1  {A1,    , Am} {B1,    , Bn}  C2
C1  C2
kde  je přejmenováním proměnných takové, že množiny klauzulí
{A1,    , Am} a {B1,    , Bn} nemají společné proměnné
 je nejobecnější unifikátor množiny {A1,    , Am, B1,    , Bn}
příklad: A1 = a(X) vs. {B1, B2} = {a(b), a(Z)}
v jednom kroku potřebuji vyrezolvovat zároveň B1 i B2
Rezoluce v PL1
korektní: jestliže existuje rezoluční vyvrácení F, pak F je nesplnitelná
úplná: jestliže F je nesplnitelná, pak existuje rezoluční vyvrácení F
Hana Rudová, Logické programování I, 17. května 2007 120 Rezoluce v PL1
Zefektivnění rezoluce
rezoluce je intuitivně efektivnější než axiomatické systémy
axiomatické systémy: který z axiomů a pravidel použít?
rezoluce: pouze jedno pravidlo
Hana Rudová, Logické programování I, 17. května 2007 121 Rezoluce v PL1
Zefektivnění rezoluce
rezoluce je intuitivně efektivnější než axiomatické systémy
axiomatické systémy: který z axiomů a pravidel použít?
rezoluce: pouze jedno pravidlo
stále ale příliš mnoho možností, jak hledat důkaz v prohledávacím prostoru
problém SAT= {S|S je splnitelná } NP úplný,
nicméně: menší prohledávací prostor vede k rychlejšímu nalezení řešení
strategie pro zefektivnění prohledávání  varianty rezoluční metody
Hana Rudová, Logické programování I, 17. května 2007 121 Rezoluce v PL1
Zefektivnění rezoluce
rezoluce je intuitivně efektivnější než axiomatické systémy
axiomatické systémy: který z axiomů a pravidel použít?
rezoluce: pouze jedno pravidlo
stále ale příliš mnoho možností, jak hledat důkaz v prohledávacím prostoru
problém SAT= {S|S je splnitelná } NP úplný,
nicméně: menší prohledávací prostor vede k rychlejšímu nalezení řešení
strategie pro zefektivnění prohledávání  varianty rezoluční metody
vylepšení prohledávání
zastavit prohledávání cest, které nejsou slibné
specifikace pořadí, jak procházíme alternativními cestami
Hana Rudová, Logické programování I, 17. května 2007 121 Rezoluce v PL1
Varianty rezoluční metody
Věta: Každé omezení rezoluce je korektní.
stále víme, že to, co jsme dokázali, platí
Hana Rudová, Logické programování I, 17. května 2007 122 Rezoluce v PL1
Varianty rezoluční metody
Věta: Každé omezení rezoluce je korektní.
stále víme, že to, co jsme dokázali, platí
T-rezoluce: klauzule učastnící se rezoluce nejsou tautologie úplná
tautologie nepomůže ukázat, že formule je nesplnitelná
Hana Rudová, Logické programování I, 17. května 2007 122 Rezoluce v PL1
Varianty rezoluční metody
Věta: Každé omezení rezoluce je korektní.
stále víme, že to, co jsme dokázali, platí
T-rezoluce: klauzule učastnící se rezoluce nejsou tautologie úplná
tautologie nepomůž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ž alespoň jedna je v této interpretaci nepravdivá
pokud jsou obě klauzule pravdivé, těžko odvodíme nesplnitelnost formule
Hana Rudová, Logické programování I, 17. května 2007 122 Rezoluce v PL1
Varianty rezoluční metody
Věta: Každé omezení rezoluce je korektní.
stále víme, že to, co jsme dokázali, platí
T-rezoluce: klauzule učastnící se rezoluce nejsou tautologie úplná
tautologie nepomůž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ž alespoň jedna je v této interpretaci nepravdivá
pokud jsou obě klauzule pravdivé, těžko odvodíme nesplnitelnost formule
vstupní (input) rezoluce: neúplná
alespoň jedna z klauzulí, použitá při rezoluci, je z výchozí vstupní množiny S
Hana Rudová, Logické programování I, 17. května 2007 122 Rezoluce v PL1
Varianty rezoluční metody
Věta: Každé omezení rezoluce je korektní.
stále víme, že to, co jsme dokázali, platí
T-rezoluce: klauzule učastnící se rezoluce nejsou tautologie úplná
tautologie nepomůž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ž alespoň jedna je v této interpretaci nepravdivá
pokud jsou obě klauzule pravdivé, těžko odvodíme nesplnitelnost formule
vstupní (input) rezoluce: neúplná
alespoň jedna z klauzulí, použitá při rezoluci, je z výchozí vstupní množiny S
{{p, q}, {p, q}, {p, q}, {p, q}}
existuje rezoluční vyvrácení
neexistuje rezoluční vyvrácení pomocí vstupní rezoluce
Hana Rudová, Logické programování I, 17. května 2007 122 Rezoluce v PL1
Rezoluce a logické programování
Lineární rezoluce
varianta rezoluční metody
snaha o generování lineární posloupnosti místo stromu
v každém kroku kromě prvního můžeme použít bezprostředně předcházející rezolventu
a k tomu bud' některou z klauzulí vstupní množiny S
nebo některou z předcházejících rezolvent
C
C
0
1
C2
C
C
n
B
Bn
1B
B0
2
Hana Rudová, Logické programování I, 17. května 2007 124 Rezoluce a logické programování
Lineární rezoluce
varianta rezoluční metody
snaha o generování lineární posloupnosti místo stromu
v každém kroku kromě prvního můžeme použít bezprostředně předcházející rezolventu
a k tomu bud' některou z klauzulí vstupní množiny S
nebo některou z předcházejících rezolvent
C
C
0
1
C2
C
C
n
B
Bn
1B
B0
2
lineární rezoluční důkaz C z S je posloupnost dvojic
C0, B0 , . . . Cn, Bn taková, že C = Cn+1 a
C0 a každá Bi jsou prvky S nebo některé Cj, j < i
každá Ci+1, i  n je rezolventa Ci a Bi
Hana Rudová, Logické programování I, 17. května 2007 124 Rezoluce a logické programování
Lineární rezoluce
varianta rezoluční metody
snaha o generování lineární posloupnosti místo stromu
v každém kroku kromě prvního můžeme použít bezprostředně předcházející rezolventu
a k tomu bud' některou z klauzulí vstupní množiny S
nebo některou z předcházejících rezolvent
C
C
0
1
C2
C
C
n
B
Bn
1B
B0
2
lineární rezoluční důkaz C z S je posloupnost dvojic
C0, B0 , . . . Cn, Bn taková, že C = Cn+1 a
C0 a každá Bi jsou prvky S nebo některé Cj, j < i
každá Ci+1, i  n je rezolventa Ci a Bi
lineární vyvrácení S = lineární rezoluční důkaz z S
Hana Rudová, Logické programování I, 17. května 2007 124 Rezoluce a logické programování
Lineární rezoluce II.
příklad: S = {A1, A2, A3, A4}
A1 = {p, q}
A2 = {p, q}
A3 = {p, q}
A4 = {p, q}
Hana Rudová, Logické programování I, 17. května 2007 125 Rezoluce a logické programování
Lineární rezoluce II.
příklad: S = {A1, A2, A3, A4}
Ci Bi
{q} { p, q}
{ p,q}
{p,q}
{p}
{p, q}
{p}{ p}
A1 = {p, q}
A2 = {p, q}
A3 = {p, q}
A4 = {p, q}
Hana Rudová, Logické programování I, 17. května 2007 125 Rezoluce a logické programování
Lineární rezoluce II.
příklad: S = {A1, A2, A3, A4}
Ci Bi
{q} { p, q}
{ p,q}
{p,q}
{p}
{p, q}
{p}{ p}
A1 = {p, q}
A2 = {p, q}
A3 = {p, q}
A4 = {p, q}
S: vstupní množina klauzulí
Ci: střední klauzule
Bi: boční klauzule
Hana Rudová, Logické programování I, 17. května 2007 125 Rezoluce a logické programování
Prologovská notace
Klauzule v matematické logice
{H1,    , Hm, T1,    , Tn} H1      Hm  T1      Tn
Hana Rudová, Logické programování I, 17. května 2007 126 Rezoluce a logické programování
Prologovská notace
Klauzule v matematické logice
{H1,    , Hm, T1,    , Tn} H1      Hm  T1      Tn
Hornova klauzule: nejvýše jeden pozitivní literál
{H, T1, . . . , Tn} {H} {T1, . . . , Tn}
H  T1      Tn H T1      Tn
Hana Rudová, Logické programování I, 17. května 2007 126 Rezoluce a logické programování
Prologovská notace
Klauzule v matematické logice
{H1,    , Hm, T1,    , Tn} H1      Hm  T1      Tn
Hornova klauzule: nejvýše jeden pozitivní literál
{H, T1, . . . , Tn} {H} {T1, . . . , Tn}
H  T1      Tn H T1      Tn
Pravidlo: jeden pozitivní a alespoň jeden negativní literál
Prolog: H : - T1,    , Tn.
Hana Rudová, Logické programování I, 17. května 2007 126 Rezoluce a logické programování
Prologovská notace
Klauzule v matematické logice
{H1,    , Hm, T1,    , Tn} H1      Hm  T1      Tn
Hornova klauzule: nejvýše jeden pozitivní literál
{H, T1, . . . , Tn} {H} {T1, . . . , Tn}
H  T1      Tn H T1      Tn
Pravidlo: jeden pozitivní a alespoň jeden negativní literál
Prolog: H : - T1,    , Tn. Matematická logika: H  T1      Tn
Hana Rudová, Logické programování I, 17. května 2007 126 Rezoluce a logické programování
Prologovská notace
Klauzule v matematické logice
{H1,    , Hm, T1,    , Tn} H1      Hm  T1      Tn
Hornova klauzule: nejvýše jeden pozitivní literál
{H, T1, . . . , Tn} {H} {T1, . . . , Tn}
H  T1      Tn H T1      Tn
Pravidlo: jeden pozitivní a alespoň jeden negativní literál
Prolog: H : - T1,    , Tn. Matematická logika: H  T1      Tn
H  T
Hana Rudová, Logické programování I, 17. května 2007 126 Rezoluce a logické programování
Prologovská notace
Klauzule v matematické logice
{H1,    , Hm, T1,    , Tn} H1      Hm  T1      Tn
Hornova klauzule: nejvýše jeden pozitivní literál
{H, T1, . . . , Tn} {H} {T1, . . . , Tn}
H  T1      Tn H T1      Tn
Pravidlo: jeden pozitivní a alespoň jeden negativní literál
Prolog: H : - T1,    , Tn. Matematická logika: H  T1      Tn
H  T H  T
Hana Rudová, Logické programování I, 17. května 2007 126 Rezoluce a logické programování
Prologovská notace
Klauzule v matematické logice
{H1,    , Hm, T1,    , Tn} H1      Hm  T1      Tn
Hornova klauzule: nejvýše jeden pozitivní literál
{H, T1, . . . , Tn} {H} {T1, . . . , Tn}
H  T1      Tn H T1      Tn
Pravidlo: jeden pozitivní a alespoň jeden negativní literál
Prolog: H : - T1,    , Tn. Matematická logika: H  T1      Tn
H  T H  T H  T1      Tn
Hana Rudová, Logické programování I, 17. května 2007 126 Rezoluce a logické programování
Prologovská notace
Klauzule v matematické logice
{H1,    , Hm, T1,    , Tn} H1      Hm  T1      Tn
Hornova klauzule: nejvýše jeden pozitivní literál
{H, T1, . . . , Tn} {H} {T1, . . . , Tn}
H  T1      Tn H T1      Tn
Pravidlo: jeden pozitivní a alespoň jeden negativní literál
Prolog: H : - T1,    , Tn. Matematická logika: H  T1      Tn
H  T H  T H  T1      Tn Klauzule: {H, T1, . . . , Tn}
Hana Rudová, Logické programování I, 17. května 2007 126 Rezoluce a logické programování
Prologovská notace
Klauzule v matematické logice
{H1,    , Hm, T1,    , Tn} H1      Hm  T1      Tn
Hornova klauzule: nejvýše jeden pozitivní literál
{H, T1, . . . , Tn} {H} {T1, . . . , Tn}
H  T1      Tn H T1      Tn
Pravidlo: jeden pozitivní a alespoň jeden negativní literál
Prolog: H : - T1,    , Tn. Matematická logika: H  T1      Tn
H  T H  T H  T1      Tn Klauzule: {H, T1, . . . , Tn}
Fakt: pouze jeden pozitivní literál
Prolog: H. Matematická logika: H Klauzule: {H}
Hana Rudová, Logické programování I, 17. května 2007 126 Rezoluce a logické programování
Prologovská notace
Klauzule v matematické logice
{H1,    , Hm, T1,    , Tn} H1      Hm  T1      Tn
Hornova klauzule: nejvýše jeden pozitivní literál
{H, T1, . . . , Tn} {H} {T1, . . . , Tn}
H  T1      Tn H T1      Tn
Pravidlo: jeden pozitivní a alespoň jeden negativní literál
Prolog: H : - T1,    , Tn. Matematická logika: H  T1      Tn
H  T H  T H  T1      Tn Klauzule: {H, T1, . . . , Tn}
Fakt: pouze jeden pozitivní literál
Prolog: H. Matematická logika: H Klauzule: {H}
Cílová klauzule: žádný pozitivní literál
Prolog: : - T1, . . . Tn. Matematická logika: T1      Tn Klauzule: {T1,    Tn}
Hana Rudová, Logické programování I, 17. května 2007 126 Rezoluce a logické programování
Logický program
Programová klauzule: právě jeden pozitivní literál (fakt nebo pravidlo)
Logický program: konečná množina programových klauzulí
Příklad:
logický program jako množina klauzulí:
P = {P1, P2, P3}
P1 = {p}, P2 = {p, q}, P3 = {q}
Hana Rudová, Logické programování I, 17. května 2007 127 Rezoluce a logické programování
Logický program
Programová klauzule: právě jeden pozitivní literál (fakt nebo pravidlo)
Logický program: konečná množina programových klauzulí
Příklad:
logický program jako množina klauzulí:
P = {P1, P2, P3}
P1 = {p}, P2 = {p, q}, P3 = {q}
logický program v prologovské notaci:
p.
p : -q.
q.
cílová klauzule: G = {q, p} : -q, p.
Hana Rudová, Logické programování I, 17. května 2007 127 Rezoluce a logické programování
Lineární rezoluce pro Hornovy klauzule
Začneme s cílovou klauzulí: C0 = G
Boční 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.
Hana Rudová, Logické programování I, 17. května 2007 128 Rezoluce a logické programování
Lineární rezoluce pro Hornovy klauzule
Začneme s cílovou klauzulí: C0 = G
Boční 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.
{ q, p}
{ p}
{q}
{p}
Hana Rudová, Logické programování I, 17. května 2007 128 Rezoluce a logické programování
Lineární rezoluce pro Hornovy klauzule
Začneme s cílovou klauzulí: C0 = G
Boční 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.
{ q, p}
{ p}
{q}
{p}
{ q, p}
{ p} {p, q}
{q}
{ q} {q}
Hana Rudová, Logické programování I, 17. května 2007 128 Rezoluce a logické programování
Lineární rezoluce pro Hornovy klauzule
Začneme s cílovou klauzulí: C0 = G
Boční 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.
{ q, p}
{ p}
{q}
{p}
{ q, p}
{ p} {p, q}
{q}
{ q} {q}
Střední klauzule jsou cílové klauzule
Hana Rudová, Logické programování I, 17. května 2007 128 Rezoluce a logické programování
Lineární vstupní rezoluce
Vstupní rezoluce na P  {G}
(opakování:) alespoň jedna z klauzulí použitá při rezoluci je z výchozí vstupní množiny
začneme s cílovou klauzulí: C0 = G
boční klauzule jsou vždy z P (tj. jsou to programové klauzule)
Hana Rudová, Logické programování I, 17. května 2007 129 Rezoluce a logické programování
Lineární vstupní rezoluce
Vstupní rezoluce na P  {G}
(opakování:) alespoň jedna z klauzulí použitá při rezoluci je z výchozí vstupní množiny
začneme s cílovou klauzulí: C0 = G
boční klauzule jsou vždy z P (tj. jsou to programové klauzule)
(Opakování:) Lineární rezoluční důkaz C z S je posloupnost dvojic
C0, B0 , . . . Cn, Bn taková, že C = Cn+1 a
C0 a každá Bi jsou prvky S nebo některé Cj, j < i
každá Ci+1, i  n je rezolventa Ci a Bi
Hana Rudová, Logické programování I, 17. května 2007 129 Rezoluce a logické programování
Lineární vstupní rezoluce
Vstupní rezoluce na P  {G}
(opakování:) alespoň jedna z klauzulí použitá při rezoluci je z výchozí vstupní množiny
začneme s cílovou klauzulí: C0 = G
boční klauzule jsou vždy z P (tj. jsou to programové klauzule)
(Opakování:) Lineární rezoluční důkaz C z S je posloupnost dvojic
C0, B0 , . . . Cn, Bn taková, že C = Cn+1 a
C0 a každá Bi jsou prvky S nebo některé Cj, j < i
každá Ci+1, i  n je rezolventa Ci a Bi
Lineární vstupní (Linear Input) rezoluce (LI­rezoluce) C z P  {G}
posloupnost dvojic C0, B0 , . . . Cn, Bn taková, že C = Cn+1 a
C0 = G a každá Bi jsou prvky P lineární rezoluce + vstupní rezoluce
každá Ci+1, i  n je rezolventa Ci a Bi
Hana Rudová, Logické programování I, 17. května 2007 129 Rezoluce a logické programování
Cíle a fakta při lineární rezoluci
Věta: Je-li S nesplnitelná množina Hornových klauzulí, pak S obsahuje alespoň
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 alespoň
jeden negat. literál), při rezoluci mi stále zůstává alespoň jeden pozit. literál
Hana Rudová, Logické programování I, 17. května 2007 130 Rezoluce a logické programování
Cíle a fakta při lineární rezoluci
Věta: Je-li S nesplnitelná množina Hornových klauzulí, pak S obsahuje alespoň
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 alespoň
jeden negat. literál), při rezoluci mi stále zůstává alespoň jeden pozit. literál
pokud nepoužiji fakt, mám pouze cíle (negat.literály) a pravidla (1 pozit.literál a alespoň
jeden negat. literál), v rezolventě mi stále zůstávají negativní literály
Hana Rudová, Logické programování I, 17. května 2007 130 Rezoluce a logické programování
Cíle a fakta při lineární rezoluci
Věta: Je-li S nesplnitelná množina Hornových klauzulí, pak S obsahuje alespoň
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 alespoň
jeden negat. literál), při rezoluci mi stále zůstává alespoň jeden pozit. literál
pokud nepoužiji fakt, mám pouze cíle (negat.literály) a pravidla (1 pozit.literál a alespoň
jeden negat. literál), v rezolventě mi stále zůstávají negativní literály
Věta: Existuje-li rezoluční důkaz prázdné množiny z množiny S Hornových
klauzulí, pak tento rezoluční strom má v listech jedinou cílovou klauzuli.
pokud začnu důkaz pravidlem a faktem, pak dostanu zase pravidlo
pokud začnu důkaz dvěma pravidly, pak dostanu zase pravidlo
na dvou faktech rezolvovat nelze
Hana Rudová, Logické programování I, 17. května 2007 130 Rezoluce a logické programování
Cíle a fakta při lineární rezoluci
Věta: Je-li S nesplnitelná množina Hornových klauzulí, pak S obsahuje alespoň
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 alespoň
jeden negat. literál), při rezoluci mi stále zůstává alespoň jeden pozit. literál
pokud nepoužiji fakt, mám pouze cíle (negat.literály) a pravidla (1 pozit.literál a alespoň
jeden negat. literál), v rezolventě mi stále zůstávají negativní literály
Věta: Existuje-li rezoluční důkaz prázdné množiny z množiny S Hornových
klauzulí, pak tento rezoluční strom má v listech jedinou cílovou klauzuli.
pokud začnu důkaz pravidlem a faktem, pak dostanu zase pravidlo
pokud začnu důkaz dvěma pravidly, pak dostanu zase pravidlo
na dvou faktech rezolvovat nelze
 dokud nepoužiji cíl pracuji stále s množinou faktů a pravidel
Hana Rudová, Logické programování I, 17. května 2007 130 Rezoluce a logické programování
Cíle a fakta při lineární rezoluci
Věta: Je-li S nesplnitelná množina Hornových klauzulí, pak S obsahuje alespoň
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 alespoň
jeden negat. literál), při rezoluci mi stále zůstává alespoň jeden pozit. literál
pokud nepoužiji fakt, mám pouze cíle (negat.literály) a pravidla (1 pozit.literál a alespoň
jeden negat. literál), v rezolventě mi stále zůstávají negativní literály
Věta: Existuje-li rezoluční důkaz prázdné množiny z množiny S Hornových
klauzulí, pak tento rezoluční strom má v listech jedinou cílovou klauzuli.
pokud začnu důkaz pravidlem a faktem, pak dostanu zase pravidlo
pokud začnu důkaz dvěma pravidly, pak dostanu zase pravidlo
na dvou faktech rezolvovat nelze
 dokud nepoužiji cíl pracuji stále s množinou faktů a pravidel
pokud použiji v důkazu cílovou klauzulí,
fakta mi ubírají negat.literály, pravidla mi je přidávají,
v rezolventě mám stále samé negativní literály, tj. nelze rezolvovat s dalším cílem
Hana Rudová, Logické programování I, 17. května 2007 130 Rezoluce a logické programování
Korektnost a úplnost
Věta: Množina S Hornových klauzulí je nesplnitelná, právě když existuje
rezoluční vyvrácení S pomocí vstupní rezoluce.
Korektnost platí stejně 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  {G} Hornových klauzulí nesplnitelná,
pak existuje rezoluční vyvrácení P  {G} pomocí LI­rezoluce.
vstupní rezoluce pro (obecnou) formuli sama o sobě není úplná
= LI­rezoluce aplikovaná na (obecnou) formuli nezaručuje,
že nalezeneme důkaz, i když formule platí!
Hana Rudová, Logické programování I, 17. května 2007 131 Rezoluce a logické programování
Korektnost a úplnost
Věta: Množina S Hornových klauzulí je nesplnitelná, právě když existuje
rezoluční vyvrácení S pomocí vstupní rezoluce.
Korektnost platí stejně 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  {G} Hornových klauzulí nesplnitelná,
pak existuje rezoluční vyvrácení P  {G} pomocí LI­rezoluce.
vstupní rezoluce pro (obecnou) formuli sama o sobě není úplná
= LI­rezoluce aplikovaná na (obecnou) formuli nezaručuje,
že nalezeneme důkaz, i když formule platí!
Význam LI­rezoluce pro Hornovy klauzule:
P = {P1, . . . , Pn}, G = {G1, . . . , Gm}
LI­rezolucí ukážeme nesplnitelnost P1      Pn  (G1      Gm)
Hana Rudová, Logické programování I, 17. května 2007 131 Rezoluce a logické programování
Korektnost a úplnost
Věta: Množina S Hornových klauzulí je nesplnitelná, právě když existuje
rezoluční vyvrácení S pomocí vstupní rezoluce.
Korektnost platí stejně 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  {G} Hornových klauzulí nesplnitelná,
pak existuje rezoluční vyvrácení P  {G} pomocí LI­rezoluce.
vstupní rezoluce pro (obecnou) formuli sama o sobě není úplná
= LI­rezoluce aplikovaná na (obecnou) formuli nezaručuje,
že nalezeneme důkaz, i když formule platí!
Význam LI­rezoluce pro Hornovy klauzule:
P = {P1, . . . , Pn}, G = {G1, . . . , Gm}
LI­rezolucí ukážeme nesplnitelnost P1      Pn  (G1      Gm)
pokud tedy předpokládáme, že program {P1, . . . , Pn} platí,
tak musí být nepravdivá (G1      Gm), tj. musí platit G1      Gm
Hana Rudová, Logické programování I, 17. května 2007 131 Rezoluce a logické programování
Uspořádané klauzule (definite clauses)
Klauzule = množina literálů
Uspořádáná klauzule (definite clause) = posloupnost literálů
nelze volně měnit pořadí literálů
Rezoluční princip pro uspořádané klauzule:
{A0, . . . , An} {B, B0, . . . , Bm}
{A0, . . . , Ai-1, B0, . . . , Bm,Ai+1, . . . , An}
uspořádaná rezolventa: {A0, . . . , Ai-1, B0, . . . , Bm,Ai+1, . . . , An}
 je přejmenování proměnných takové, že klauzule {A0, . . . , An} a {B, B0, . . . , Bm} nemají
společné proměnné
 je nejobecnější unifikátor pro Ai a B
Hana Rudová, Logické programování I, 17. května 2007 132 Rezoluce a logické programování
Uspořádané klauzule (definite clauses)
Klauzule = množina literálů
Uspořádáná klauzule (definite clause) = posloupnost literálů
nelze volně měnit pořadí literálů
Rezoluční princip pro uspořádané klauzule:
{A0, . . . , An} {B, B0, . . . , Bm}
{A0, . . . , Ai-1, B0, . . . , Bm,Ai+1, . . . , An}
uspořádaná rezolventa: {A0, . . . , Ai-1, B0, . . . , Bm,Ai+1, . . . , An}
 je přejmenování proměnných takové, že klauzule {A0, . . . , An} a {B, B0, . . . , Bm} nemají
společné proměnné
 je nejobecnější unifikátor pro Ai a B
rezoluce je realizována na literálech Ai a B
je dodržováno pořadí literálů, tj.
{B0, . . . , Bm} jde do uspořádané rezolventy přesně na pozici Ai
Hana Rudová, Logické programování I, 17. května 2007 132 Rezoluce a logické programování
Uspořádané klauzule II.
Uspořádáné klauzule
{A0, . . . , An} {B, B0, . . . , Bm}
{A0, . . . , Ai-1, B0, . . . , Bm,Ai+1, . . . , An}
Hornovy klauzule
: -A0, . . . , An. B : -B0, . . . , Bm.
: -(A0, . . . , Ai-1, B0, . . . , Bm,Ai+1, . . . , An).
Hana Rudová, Logické programování I, 17. května 2007 133 Rezoluce a logické programování
Uspořádané klauzule II.
Uspořádáné klauzule
{A0, . . . , An} {B, B0, . . . , Bm}
{A0, . . . , Ai-1, B0, . . . , Bm,Ai+1, . . . , An}
Hornovy klauzule
: -A0, . . . , An. B : -B0, . . . , Bm.
: -(A0, . . . , Ai-1, B0, . . . , Bm,Ai+1, . . . , An).
Příklad:
{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).
 = [X/A]  = [Z/1]
Hana Rudová, Logické programování I, 17. května 2007 133 Rezoluce a logické programování
LD-rezoluce
LD-rezoluční vyvrácení množiny uspořádaných klauzulí P  {G} je
posloupnost G0, C0 , . . . , Gn, Cn taková, že
Gi, Ci jsou uspořádané klauzule
G = G0
Gn+1 =
Gi je uspořádaná cílová klauzule
Ci je přejmenování klauzule z P
Ci neobsahuje proměnné, které jsou v Gj, j  i nebo v Ck, k  i
Gi+1, 0  i  n je uspořádaná rezolventa Gi a Ci
Hana Rudová, Logické programování I, 17. května 2007 134 Rezoluce a logické programování
LD-rezoluce
LD-rezoluční vyvrácení množiny uspořádaných klauzulí P  {G} je
posloupnost G0, C0 , . . . , Gn, Cn taková, že
Gi, Ci jsou uspořádané klauzule
G = G0
Gn+1 =
Gi je uspořádaná cílová klauzule
Ci je přejmenování klauzule z P
Ci neobsahuje proměnné, které jsou v Gj, j  i nebo v Ck, k  i
Gi+1, 0  i  n je uspořádaná rezolventa Gi a Ci
LD-rezoluce: korektní a úplná
Hana Rudová, Logické programování I, 17. května 2007 134 Rezoluce a logické programování
SLD-rezoluce
Lineární rezoluce se selekčním pravidlem = SLD-rezoluce
(Selected Linear resolution for Definite clauses)
rezoluce
Selekční pravidlo
Lineární rezoluce
Definite (uspořádané) klauzule
vstupní rezoluce
Hana Rudová, Logické programování I, 17. května 2007 135 Rezoluce a logické programování
SLD-rezoluce
Lineární rezoluce se selekčním pravidlem = SLD-rezoluce
(Selected Linear resolution for Definite clauses)
rezoluce
Selekční pravidlo
Lineární rezoluce
Definite (uspořádané) klauzule
vstupní rezoluce
Selekční pravidlo R je funkce, která každé neprázdné klauzuli C přiřazuje
nějaký z jejích literálů R(C)  C
při rezoluci vybírám s klauzule literál určený selekčním pravidlem
Hana Rudová, Logické programování I, 17. května 2007 135 Rezoluce a logické programování
SLD-rezoluce
Lineární rezoluce se selekčním pravidlem = SLD-rezoluce
(Selected Linear resolution for Definite clauses)
rezoluce
Selekční pravidlo
Lineární rezoluce
Definite (uspořádané) klauzule
vstupní rezoluce
Selekční pravidlo R je funkce, která každé neprázdné klauzuli C přiřazuje
nějaký z jejích literálů R(C)  C
při rezoluci vybírám s klauzule literál určený selekčním pravidlem
Pokud se R neuvádí, pak se předpokládá výběr nejlevějšího literálu
nejlevější literál vybírá i Prolog
Hana Rudová, Logické programování I, 17. května 2007 135 Rezoluce a logické programování
Lineární rezoluce se selekčním pravidlem
P = {{p}, {p, q}, {q}}, G = {q, p}
výběr
nejlevějšího
literálu
{ q, p}
{ p}
{q}
{p}
výběr
nejpravějšího
literálu
{ q, p}
{ q}
{p}
{q}
Hana Rudová, Logické programování I, 17. května 2007 136 Rezoluce a logické programování
Lineární rezoluce se selekčním pravidlem
P = {{p}, {p, q}, {q}}, G = {q, p}
výběr
nejlevějšího
literálu
{ q, p}
{ p}
{q}
{p}
výběr
nejpravějšího
literálu
{ q, p}
{ q}
{p}
{q}
SLD-rezoluční vyvrácení P  {G} pomocí selekčního pravidla R je
LD-rezoluční vyvrácení G0, C0 , . . . , Gn, Cn takové, že G = G0, Gn+1 = a
R(Gi) je literál rezolvovaný v kroku i
Hana Rudová, Logické programování I, 17. května 2007 136 Rezoluce a logické programování
Lineární rezoluce se selekčním pravidlem
P = {{p}, {p, q}, {q}}, G = {q, p}
výběr
nejlevějšího
literálu
{ q, p}
{ p}
{q}
{p}
výběr
nejpravějšího
literálu
{ q, p}
{ q}
{p}
{q}
SLD-rezoluční vyvrácení P  {G} pomocí selekčního pravidla R je
LD-rezoluční vyvrácení G0, C0 , . . . , Gn, Cn takové, že G = G0, Gn+1 = a
R(Gi) je literál rezolvovaný v kroku i
SLD-rezoluce ­ korektní, úplná
Efektivita SLD-rezoluce je závislá na
selekčním pravidle R
způsobu výběru příslušné programové klauzule pro tvorbu rezolventy
v Prologu se vybírá vždy klauzule, která je v programu první
Hana Rudová, Logické programování I, 17. května 2007 136 Rezoluce a logické programování
Příklad: SLD-strom
fail fail
(1) (2)
(6)
(7)(5)
(3) (4)
:- q,v,r.
:- v,r. :- w,r.
:- u,w,r.
:- t.
:- s.:- p,r.
t : -p, r. (1)
t : -s. (2)
p : -q, v. (3)
p : -u, w. (4)
q. (5)
s. (6)
u. (7)
: -t.
Hana Rudová, Logické programování I, 17. května 2007 137 Rezoluce a logické programování
Strom výpočtu (SLD-strom)
SLD-strom je strom tvořený všemi možnými výpočetními posloupnostmi
logického programu P vzhledem k cíli G
Hana Rudová, Logické programování I, 17. května 2007 138 Rezoluce a logické programování
Strom výpočtu (SLD-strom)
SLD-strom je strom tvořený všemi možnými výpočetními posloupnostmi
logického programu P vzhledem k cíli G
kořeny stromy jsou programové klauzule a cílová klauzule G
v uzlech jsou rezolventy
výchozím kořenem rezoluce je cílová klauzule G
Hana Rudová, Logické programování I, 17. května 2007 138 Rezoluce a logické programování
Strom výpočtu (SLD-strom)
SLD-strom je strom tvořený všemi možnými výpočetními posloupnostmi
logického programu P vzhledem k cíli G
kořeny stromy jsou programové klauzule a cílová klauzule G
v uzlech jsou rezolventy
výchozím kořenem rezoluce je cílová klauzule G
listy jsou dvojího druhu:
označené prázdnou klauzulí ­ jedná se o úspěšné uzly (succes nodes)
označené neprázdnou klauzulí ­ jedná se o neúspěšné uzly (failure nodes)
Hana Rudová, Logické programování I, 17. května 2007 138 Rezoluce a logické programování
Strom výpočtu (SLD-strom)
SLD-strom je strom tvořený všemi možnými výpočetními posloupnostmi
logického programu P vzhledem k cíli G
kořeny stromy jsou programové klauzule a cílová klauzule G
v uzlech jsou rezolventy
výchozím kořenem rezoluce je cílová klauzule G
listy jsou dvojího druhu:
označené prázdnou klauzulí ­ jedná se o úspěšné uzly (succes nodes)
označené neprázdnou klauzulí ­ jedná se o neúspěšné uzly (failure nodes)
úplnost SLD-rezoluce zaručuje existenci cesty od kořene k úspěšnému uzlu
pro každý možný výsledek příslušející cíli G
Hana Rudová, Logické programování I, 17. května 2007 138 Rezoluce a logické programování
Příklad: SLD­strom a výsledná substituce
(1)
fail
(2)
(5)
:- c(3). :- c(2).
:- a(Z).
:- b(Z,Y), c(Y).
(4) [Z/1,Y/2][Z/2,Y/3] (3)
:- c(Z).
(5) [Z/2]
[Z/2]
[Z/1]
: -a(Z).
a(X) : -b(X, Y), c(Y). (1)
a(X) : -c(X). (2)
b(2, 3). (3)
b(1, 2). (4)
c(2). (5)
Hana Rudová, Logické programování I, 17. května 2007 139 Rezoluce a logické programování
Příklad: SLD­strom a výsledná substituce
(1)
fail
(2)
(5)
:- c(3). :- c(2).
:- a(Z).
:- b(Z,Y), c(Y).
(4) [Z/1,Y/2][Z/2,Y/3] (3)
:- c(Z).
(5) [Z/2]
[Z/2]
[Z/1]
: -a(Z).
a(X) : -b(X, Y), c(Y). (1)
a(X) : -c(X). (2)
b(2, 3). (3)
b(1, 2). (4)
c(2). (5)
Cvičení:
p(B) : -q(A, B), r(B). ve výsledné substituci jsou pouze proměnné z dotazu, tj.
p(A) : -q(A, A). výsledné substituce jsou [Z/1] a [Z/2]
q(a, a). nezajímá mě substituce [Y/2]
q(a, b).
r(b).
Hana Rudová, Logické programování I, 17. května 2007 139 Rezoluce a logické programování
Výsledná substituce (answer substitution)
:-q(X), p(X,Y).
X=a, Y=b
q(a).
p(a,b).
[Y/b]
[X/a]
[X/a,Y/b]
q(a).
p(a,b).
:- q(X), p(X,Y).
:- p(a,Y).
Hana Rudová, Logické programování I, 17. května 2007 140 Rezoluce a logické programování
Výsledná substituce (answer substitution)
:-q(X), p(X,Y).
X=a, Y=b
q(a).
p(a,b).
[Y/b]
[X/a]
[X/a,Y/b]
q(a).
p(a,b).
:- q(X), p(X,Y).
:- p(a,Y).
Každý krok SLD-rezoluce vytváří novou unifikační substituci i
 potenciální instanciace proměnné ve vstupní cílové klauzuli
Výsledná substituce (answer substitution)
 = 01    n složení unifikací
Hana Rudová, Logické programování I, 17. května 2007 140 Rezoluce a logické programování
Význam SLD-rezolučního vyvrácení P  {G}
Množina P programových klauzulí, cílová klauzule G
Dokazujeme nesplnitelnost
(1) P  (X)(G1(X)  G2(X)      Gn(X))
kde G = {G1, G2,    , Gn} a X je vektor proměnných v G
Hana Rudová, Logické programování I, 17. května 2007 141 Rezoluce a logické programování
Význam SLD-rezolučního vyvrácení P  {G}
Množina P programových klauzulí, cílová klauzule G
Dokazujeme nesplnitelnost
(1) P  (X)(G1(X)  G2(X)      Gn(X))
kde G = {G1, G2,    , Gn} a X je vektor proměnných v G
nesplnitelnost (1) je ekvivalentní tvrzení (2) a (3)
(2) P G
(3) P (X)(G1(X)      Gn(X))
Hana Rudová, Logické programování I, 17. května 2007 141 Rezoluce a logické programování
Význam SLD-rezolučního vyvrácení P  {G}
Množina P programových klauzulí, cílová klauzule G
Dokazujeme nesplnitelnost
(1) P  (X)(G1(X)  G2(X)      Gn(X))
kde G = {G1, G2,    , Gn} a X je vektor proměnných v G
nesplnitelnost (1) je ekvivalentní tvrzení (2) a (3)
(2) P G
(3) P (X)(G1(X)      Gn(X))
a jedná se tak o důkaz existence vhodných objektů, které na základě
vlastností množiny P splňují konjunkci literálů v cílové klauzuli
Hana Rudová, Logické programování I, 17. května 2007 141 Rezoluce a logické programování
Význam SLD-rezolučního vyvrácení P  {G}
Množina P programových klauzulí, cílová klauzule G
Dokazujeme nesplnitelnost
(1) P  (X)(G1(X)  G2(X)      Gn(X))
kde G = {G1, G2,    , Gn} a X je vektor proměnných v G
nesplnitelnost (1) je ekvivalentní tvrzení (2) a (3)
(2) P G
(3) P (X)(G1(X)      Gn(X))
a jedná se tak o důkaz existence vhodných objektů, které na základě
vlastností množiny P splňují konjunkci literálů v cílové klauzuli
Důkaz nesplnitelnosti P  {G} znamená nalezení protipříkladu
ten pomocí SLD-stromu konstruuje termy (odpověd') splňující konjunkci v (3)
Hana Rudová, Logické programování I, 17. května 2007 141 Rezoluce a logické programování
Výpočetní strategie
Korektní výpočetní strategie prohledávání stromu výpočtu musí zaručit, že
se každý (konečný) výsledek nalézt v konečném čase
Hana Rudová, Logické programování I, 17. května 2007 142 Rezoluce a logické programování
Výpočetní strategie
Korektní výpočetní strategie prohledávání stromu výpočtu musí zaručit, že
se každý (konečný) výsledek nalézt v konečném čase
Korektní výpočetní strategie = prohledávání stromu do šířky
exponenciální pamět'ová náročnost
složité řídící struktury
Hana Rudová, Logické programování I, 17. května 2007 142 Rezoluce a logické programování
Výpočetní strategie
Korektní výpočetní strategie prohledávání stromu výpočtu musí zaručit, že
se každý (konečný) výsledek nalézt v konečném čase
Korektní výpočetní strategie = prohledávání stromu do šířky
exponenciální pamět'ová náročnost
složité řídící struktury
Použitelná výpočetní strategie = prohledávání stromu do hloubky
jednoduché řídící struktury (zásobník)
lineární pamět'ová náročnost
není ale úplná: nenalezne vyvrácení i když existuje
procházení nekonečné větve stromu výpočtu
 na nekonečných stromech dojde k zacyklení
nedostaneme se tak na jiné existující úspěšné uzly
Hana Rudová, Logické programování I, 17. května 2007 142 Rezoluce a logické programování
SLD-rezoluce v Prologu: úplnost
Prolog: prohledávání stromu do hloubky
 neúplnost použité výpočetní strategie
(1) (3)
(2)
:- q.
:- r.
:- q.
Implementace SLD-rezoluce v Prologu
není úplná
logický program: q : -r. (1)
r : -q. (2)
q. (3)
dotaz: : -q.
Hana Rudová, Logické programování I, 17. května 2007 143 Rezoluce a logické programování
Test výskytu
Kontrola, zda se proměnná vyskytuje v termu, kterým ji substituujeme
dotaz : -a(B, B).
logický program: a(X, f (X)).
vede k: [B/X], [X/f(X)]
Unifikátor pro g(X1, . . . , Xn) a g(f(X0, X0), f(X1, X1), . . . , f(Xn-1, Xn-1))
X1 = f(X0, X0), X2 = f(X1, X1), . . . , Xn = f(Xn-1, Xn-1)
X2 = f(f(X0, X0), f(X0, X0)), . . .
délka termu pro Xk exponenciálně narůstá
Hana Rudová, Logické programování I, 17. května 2007 144 Rezoluce a logické programování
Test výskytu
Kontrola, zda se proměnná vyskytuje v termu, kterým ji substituujeme
dotaz : -a(B, B).
logický program: a(X, f (X)).
vede k: [B/X], [X/f(X)]
Unifikátor pro g(X1, . . . , Xn) a g(f(X0, X0), f(X1, X1), . . . , f(Xn-1, Xn-1))
X1 = f(X0, X0), X2 = f(X1, X1), . . . , Xn = f(Xn-1, Xn-1)
X2 = f(f(X0, X0), f(X0, X0)), . . .
délka termu pro Xk exponenciálně narůstá
= exponenciální složitost na ověření kontroly výskytu
Test výskytu se při unifikaci v Prologu neprovádí
Důsledek: ? - X = f (X) uspěje s X = f(f(f(f(f(f(f (f(f(f(...))))))))))
Hana Rudová, Logické programování I, 17. května 2007 144 Rezoluce 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í
Hana Rudová, Logické programování I, 17. května 2007 145 Rezoluce 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). : -t.
p(X, f(X)). yes dokazovací systém nehledá unifikátor pro X a f(X)
Hana Rudová, Logické programování I, 17. května 2007 145 Rezoluce 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). : -t.
p(X, f(X)). yes dokazovací systém nehledá unifikátor pro X a f(X)
Řešení: problém typu (2) převést na problém typu (1) ?
Hana Rudová, Logické programování I, 17. května 2007 145 Rezoluce 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). : -t.
p(X, f(X)). yes dokazovací systém nehledá unifikátor pro X a f(X)
Řešení: problém typu (2) převést na problém typu (1) ?
každá proměnná v hlavě klauzule se objeví i v těle, aby se vynutilo hledání
unifikátoru (přidáme X = X pro každou X, která se vyskytuje pouze v hlavě)
t : -p(X, X).
p(X, f(X)) : -X = X.
Hana Rudová, Logické programování I, 17. května 2007 145 Rezoluce 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). : -t.
p(X, f(X)). yes dokazovací systém nehledá unifikátor pro X a f(X)
Řešení: problém typu (2) převést na problém typu (1) ?
každá proměnná v hlavě klauzule se objeví i v těle, aby se vynutilo hledání
unifikátoru (přidáme X = X pro každou X, která se vyskytuje pouze v hlavě)
t : -p(X, X).
p(X, f(X)) : -X = X.
optimalizace v kompilátoru mohou způsobit opět odpověd' ,,yes"
Hana Rudová, Logické programování I, 17. května 2007 145 Rezoluce a logické programování
Řízení implementace: řez
řez se syntakticky chová jako kterýkoliv jiný literál
:- p.
:- q,!,v.
ořezání
upnutí
nemá ale žádnou deklarativní sémantiku
místo toho mění implementaci programu
p : -q, !, v.
Hana Rudová, Logické programování I, 17. května 2007 146 Rezoluce a logické programování
Řízení implementace: řez
řez se syntakticky chová jako kterýkoliv jiný literál
:- p.
:- q,!,v.
ořezání
upnutí
nemá ale žádnou deklarativní sémantiku
místo toho mění implementaci programu
p : -q, !, v.
snažíme se splnit q
pokud uspěji
 přeskočím řez a pokračuji jako by tam řez nebyl
pokud ale neuspěji (a tedy i při backtrackingu) a vracím se přes řez
 vracím se až na rodiče : -p. a zkouším další větev
Hana Rudová, Logické programování I, 17. května 2007 146 Rezoluce a logické programování
Řízení implementace: řez
řez se syntakticky chová jako kterýkoliv jiný literál
:- p.
:- q,!,v.
ořezání
upnutí
nemá ale žádnou deklarativní sémantiku
místo toho mění implementaci programu
p : -q, !, v.
snažíme se splnit q
pokud uspěji
 přeskočím řez a pokračuji jako by tam řez nebyl
pokud ale neuspěji (a tedy i při backtrackingu) a vracím se přes řez
 vracím se až na rodiče : -p. a zkouším další větev
 nezkouším tedy další možnosti, jak splnit p upnutí
 a nezkouším ani další možnosti, jak splnit q v SLD-stromu ořezání
Hana Rudová, Logické programování I, 17. května 2007 146 Rezoluce a logické programování
Příklad: řez
(1) (2)
(7)
(5)
(3)
fail
(!)
[X/a]
:- s.:- p,r.
:- !,v,r.
:- v,r.
:- t.
:- q(X),!,v,r.
t : -p, r. (1)
t : -s. (2)
p : -q(X), !, v. (3)
p : -u, w. (4)
q(a). (5)
q(b). (6)
s. (7)
u. (8)
Hana Rudová, Logické programování I, 17. května 2007 147 Rezoluce a logické programování
Příklad: řez II
(1)
(6) (7)
[X/2,Y/3] (3)
fail
(rez)
:- c(3).
:- !,c(3).
:- b(X,Y),!,c(Y).
:- a(X).
:- s(X).
a(X) : -b(X, Y), !, c(Y). (1)
a(X) : -c(X). (2)
b(2, 3). (3)
b(1, 2). (4)
c(2). (5)
s(X) : -a(X). (6)
s(X) : -p(X). (7)
p(B) : -q(A, B), r(B). (8)
p(A) : -q(A, A). (9)
q(a, a). (10)
q(a, b). (11)
r(b). (12)
Hana Rudová, Logické programování I, 17. května 2007 148 Rezoluce a logické programování
Příklad: řez III
(1)
fail
(6)
(rez)
(5)
(7)
(4) [X/1,Y/2][X/2,Y/3] (3)
[X/1]
:- b(X,Y),c(Y),!.
:- c(3),!.
:- !.
:- a(X).
:- s(X).
:- c(2),!.
a(X) : -b(X, Y), c(Y), !. (1)
a(X) : -c(X). (2)
b(2, 3). (3)
b(1, 2). (4)
c(2). (5)
s(X) : -a(X). (6)
s(X) : -p(X). (7)
p(B) : -q(A, B), r(B). (8)
p(A) : -q(A, A). (9)
q(a, a). (10)
q(a, b). (11)
r(b). (12)
Hana Rudová, Logické programování I, 17. května 2007 149 Rezoluce a logické programování
Operační a deklarativní semantika
Operační sémantika
Operační sémantikou logického programu P rozumíme množinu O(P) všech
atomických formulí bez proměnných, které lze pro nějaký cíl G1
odvodit
nějakým rezolučním důkazem ze vstupní množiny P  {G}.
1
tímto výrazem jsou míněny všechny cíle, pro něž zmíněný rezoluční důkaz
existuje.
Hana Rudová, Logické programování I, 17. května 2007 151 Sémantiky
Operační sémantika
Operační sémantikou logického programu P rozumíme množinu O(P) všech
atomických formulí bez proměnných, které lze pro nějaký cíl G1
odvodit
nějakým rezolučním důkazem ze vstupní množiny P  {G}.
1
tímto výrazem jsou míněny všechny cíle, pro něž zmíněný rezoluční důkaz
existuje.
Deklarativní sémantika logického programu P ???
Hana Rudová, Logické programování I, 17. května 2007 151 Sémantiky
Opakování: interpretace
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.
příklad: F = {{f(a, b) = f (b, a)}, {f(f(a, a), b) = a}}
interpretace I1: D = Z, a := 1, b := -1, f := " + "
Hana Rudová, Logické programování I, 17. května 2007 152 Sémantiky
Opakování: interpretace
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.
příklad: F = {{f(a, b) = f (b, a)}, {f(f(a, a), b) = a}}
interpretace I1: 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, 17. května 2007 152 Sémantiky
Herbrandovy interpretace
Omezení na obor skládající se ze symbolických výrazů tvořených
z predikátových a funkčních symbolů daného jazyka
při zkoumání pravdivosti není nutné uvažovat modely nad všemi interpretacemi
Hana Rudová, Logické programování I, 17. května 2007 153 Sémantiky
Herbrandovy interpretace
Omezení na obor skládající se ze symbolických výrazů tvořených
z predikátových a funkčních symbolů daného jazyka
při zkoumání pravdivosti není nutné uvažovat modely nad všemi interpretacemi
Herbrandovo univerzum: množina všech termů bez proměnných, které
mohou být tvořeny funkčními symboly a konstantami daného jazyka
Herbrandova interpretace: libovolná interpretace, která přiřazuje
proměnným prvky Herbrandova univerza
konstantám sebe samé
funkčním symbolům funkce, které symbolu f pro argumenty t1,    , tn přiřadí term
f(t1,    , tn)
predikátovým symbolům libovolnou funkci z Herbrand. univerza do pravdivostních hodnot
Hana Rudová, Logické programování I, 17. května 2007 153 Sémantiky
Herbrandovy interpretace
Omezení na obor skládající se ze symbolických výrazů tvořených
z predikátových a funkčních symbolů daného jazyka
při zkoumání pravdivosti není nutné uvažovat modely nad všemi interpretacemi
Herbrandovo univerzum: množina všech termů bez proměnných, které
mohou být tvořeny funkčními symboly a konstantami daného jazyka
Herbrandova interpretace: libovolná interpretace, která přiřazuje
proměnným prvky Herbrandova univerza
konstantám sebe samé
funkčním symbolům funkce, které symbolu f pro argumenty t1,    , tn přiřadí term
f(t1,    , tn)
predikátovým symbolům libovolnou funkci z Herbrand. univerza do pravdivostních hodnot
Herbrandův model množiny uzavřených formulí P:
Herbrandova interpretace taková, že každá formule z P je v ní pravdivá.
Hana Rudová, Logické programování I, 17. května 2007 153 Sémantiky
Specifikace Herbrandova modelu
Herbrandovy interpretace mají předdefinovaný význam funktorů a konstant
Pro specifikaci Herbrandovy interpretace tedy stačí zadat
relace pro každý predikátový symbol
Hana Rudová, Logické programování I, 17. května 2007 154 Sémantiky
Specifikace Herbrandova modelu
Herbrandovy interpretace mají předdefinovaný význam funktorů a konstant
Pro specifikaci Herbrandovy interpretace tedy stačí zadat
relace pro každý predikátový symbol
Příklad: Herbrandova interpretace a Herbrandův model množiny formulí
lichy(s(0)). % (1)
lichy(s(s(X))) :- lichy(X). % (2)
Hana Rudová, Logické programování I, 17. května 2007 154 Sémantiky
Specifikace Herbrandova modelu
Herbrandovy interpretace mají předdefinovaný význam funktorů a konstant
Pro specifikaci Herbrandovy interpretace tedy stačí zadat
relace pro každý predikátový symbol
Příklad: Herbrandova interpretace a Herbrandův model množiny formulí
lichy(s(0)). % (1)
lichy(s(s(X))) :- lichy(X). % (2)
I1 =  není model (1)
Hana Rudová, Logické programování I, 17. května 2007 154 Sémantiky
Specifikace Herbrandova modelu
Herbrandovy interpretace mají předdefinovaný význam funktorů a konstant
Pro specifikaci Herbrandovy interpretace tedy stačí zadat
relace pro každý predikátový symbol
Příklad: Herbrandova interpretace a Herbrandův model množiny formulí
lichy(s(0)). % (1)
lichy(s(s(X))) :- lichy(X). % (2)
I1 =  není model (1)
I2 = {lichy(s(0))} není model (2)
Hana Rudová, Logické programování I, 17. května 2007 154 Sémantiky
Specifikace Herbrandova modelu
Herbrandovy interpretace mají předdefinovaný význam funktorů a konstant
Pro specifikaci Herbrandovy interpretace tedy stačí zadat
relace pro každý predikátový symbol
Příklad: Herbrandova interpretace a Herbrandův model množiny formulí
lichy(s(0)). % (1)
lichy(s(s(X))) :- lichy(X). % (2)
I1 =  není model (1)
I2 = {lichy(s(0))} není model (2)
I3 = {lichy(s(0)), lichy(s(s(s(0))))} není model (2)
Hana Rudová, Logické programování I, 17. května 2007 154 Sémantiky
Specifikace Herbrandova modelu
Herbrandovy interpretace mají předdefinovaný význam funktorů a konstant
Pro specifikaci Herbrandovy interpretace tedy stačí zadat
relace pro každý predikátový symbol
Příklad: Herbrandova interpretace a Herbrandův model množiny formulí
lichy(s(0)). % (1)
lichy(s(s(X))) :- lichy(X). % (2)
I1 =  není model (1)
I2 = {lichy(s(0))} není model (2)
I3 = {lichy(s(0)), lichy(s(s(s(0))))} není model (2)
I4 = {lichy(sn
(0))|n  {1, 3, 5, 7, . . .}} Herbrandův model (1) i (2)
Hana Rudová, Logické programování I, 17. května 2007 154 Sémantiky
Specifikace Herbrandova modelu
Herbrandovy interpretace mají předdefinovaný význam funktorů a konstant
Pro specifikaci Herbrandovy interpretace tedy stačí zadat
relace pro každý predikátový symbol
Příklad: Herbrandova interpretace a Herbrandův model množiny formulí
lichy(s(0)). % (1)
lichy(s(s(X))) :- lichy(X). % (2)
I1 =  není model (1)
I2 = {lichy(s(0))} není model (2)
I3 = {lichy(s(0)), lichy(s(s(s(0))))} není model (2)
I4 = {lichy(sn
(0))|n  {1, 3, 5, 7, . . .}} Herbrandův model (1) i (2)
I5 = {lichy(sn
(0))|n  N}} Herbrandův model (1) i (2)
Hana Rudová, Logické programování I, 17. května 2007 154 Sémantiky
Příklad: Herbrandovy interpretace
rodic(a,b).
rodic(b,c).
predek(X,Y) :- rodic(X,Y).
predek(X,Z) :- rodic(X,Y), predek(Y,Z).
Hana Rudová, Logické programování I, 17. května 2007 155 Sémantiky
Příklad: Herbrandovy interpretace
rodic(a,b).
rodic(b,c).
predek(X,Y) :- rodic(X,Y).
predek(X,Z) :- rodic(X,Y), predek(Y,Z).
I1 = {rodic(a, b), rodic(b, c), predek(a, b), predek(b, c), predek(a, c)}
I2 = {rodic(a, b), rodic(b, c),
predek(a, b), predek(b, c), predek(a, c), predek(a, a)}
I1 i I2 jsou Herbrandovy modely klauzulí
Hana Rudová, Logické programování I, 17. května 2007 155 Sémantiky
Deklarativní a operační sémantika
Je-li S množina programových klauzulí a M libovolná množina Herbrandových
modelů S, pak průnik těchto modelů je opět Herbrandův model množiny S.
Důsledek:
Existuje nejmenší Herbrandův model množiny S, který značíme M(S).
Hana Rudová, Logické programování I, 17. května 2007 156 Sémantiky
Deklarativní a operační sémantika
Je-li S množina programových klauzulí a M libovolná množina Herbrandových
modelů S, pak průnik těchto modelů je opět Herbrandův model množiny S.
Důsledek:
Existuje nejmenší Herbrandův model množiny S, který značí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, 17. května 2007 156 Sémantiky
Deklarativní a operační sémantika
Je-li S množina programových klauzulí a M libovolná množina Herbrandových
modelů S, pak průnik těchto modelů je opět Herbrandův model množiny S.
Důsledek:
Existuje nejmenší Herbrandův model množiny S, který značíme M(S).
Deklarativní sémantikou logického programu P rozumíme jeho minimální
Herbrandův model M(P).
Operační sémantikou logického programu P rozumíme množinu O(P) všech
atomických formulí bez proměnných, které lze pro nějaký cíl G1
odvodit
nějakým rezolučním důkazem ze vstupní množiny P  {G}.
1
tímto výrazem jsou míněny všechny cíle, pro něž zmíněný rezoluční důkaz
existuje.
Hana Rudová, Logické programování I, 17. května 2007 156 Sémantiky
Deklarativní a operační sémantika
Je-li S množina programových klauzulí a M libovolná množina Herbrandových
modelů S, pak průnik těchto modelů je opět Herbrandův model množiny S.
Důsledek:
Existuje nejmenší Herbrandův model množiny S, který značíme M(S).
Deklarativní sémantikou logického programu P rozumíme jeho minimální
Herbrandův model M(P).
Operační sémantikou logického programu P rozumíme množinu O(P) všech
atomických formulí bez proměnných, které lze pro nějaký cíl G1
odvodit
nějakým rezolučním důkazem ze vstupní množiny P  {G}.
1
tímto výrazem jsou míněny všechny cíle, pro něž zmíněný rezoluční důkaz
existuje.
Pro libovolný logický program P platí M(P) = O(P)
Hana Rudová, Logické programování I, 17. května 2007 156 Sémantiky
Negace v logickém programování
Negativní znalost
logické programy vyjadřují pozitivní znalost
negativní literály: pozice určena definicí Hornových klauzulí
 nelze vyvodit negativní informaci z logického programu
každý predikát definuje úplnou relaci
negativní literál není logickým důsledkem programu
Hana Rudová, Logické programování I, 17. května 2007 158 Negace v logickém programování
Negativní znalost
logické programy vyjadřují pozitivní znalost
negativní literály: pozice určena definicí Hornových klauzulí
 nelze vyvodit negativní informaci z logického programu
každý predikát definuje úplnou relaci
negativní literál není logickým důsledkem programu
relace vyjádřeny explicitně v nejmenším Herbrandově modelu
nad(X, Y) : -na(X, Y). na(c, b).
nad(X, Y) : -na(X, Z), nad(Z, Y). na(b, a).
nejmenší Herbrandův model: {na(b, a), na(c, b), nad(b, a), nad(c, b), nad(c, a)}
Hana Rudová, Logické programování I, 17. května 2007 158 Negace v logickém programování
Negativní znalost
logické programy vyjadřují pozitivní znalost
negativní literály: pozice určena definicí Hornových klauzulí
 nelze vyvodit negativní informaci z logického programu
každý predikát definuje úplnou relaci
negativní literál není logickým důsledkem programu
relace vyjádřeny explicitně v nejmenším Herbrandově modelu
nad(X, Y) : -na(X, Y). na(c, b).
nad(X, Y) : -na(X, Z), nad(Z, Y). na(b, a).
nejmenší Herbrandův model: {na(b, a), na(c, b), nad(b, a), nad(c, b), nad(c, a)}
ani program ani model nezahrnují negativní informaci
a není nad c, a není na c
i v realitě je negativní informace vyjadřena explicitně zřídka, např. jízdní řád
Hana Rudová, Logické programování I, 17. května 2007 158 Negace v logickém programování
Předpoklad uzavřeného světa
neexistence informace chápána jako opak:
předpoklad uzavřeného světa (closed world assumption, CWA)
převzato z databází
určitý vztah platí pouze když je vyvoditelný z programu.
,,odvozovací pravidlo" (A je (uzavřený) term):
P A
A
(CWA)
Hana Rudová, Logické programování I, 17. května 2007 159 Negace v logickém programování
Předpoklad uzavřeného světa
neexistence informace chápána jako opak:
předpoklad uzavřeného světa (closed world assumption, CWA)
převzato z databází
určitý vztah platí pouze když je vyvoditelný z programu.
,,odvozovací pravidlo" (A je (uzavřený) term):
P A
A
(CWA)
pro SLD-rezoluci: P nad(a, c), tedy lze podle CWA odvodit nad(a, c)
Hana Rudová, Logické programování I, 17. května 2007 159 Negace v logickém programování
Předpoklad uzavřeného světa
neexistence informace chápána jako opak:
předpoklad uzavřeného světa (closed world assumption, CWA)
převzato z databází
určitý vztah platí pouze když je vyvoditelný z programu.
,,odvozovací pravidlo" (A je (uzavřený) term):
P A
A
(CWA)
pro SLD-rezoluci: P nad(a, c), tedy lze podle CWA odvodit nad(a, c)
problém: není rozhodnutelné, zda daná atomická formule je logickým
důsledkem daného logického programu.
nelze tedy určit, zda pravidlo CWA je aplikovatelné nebo ne
CWA v logickém programování obecně nepoužitelná.
Hana Rudová, Logické programování I, 17. května 2007 159 Negace v logickém programování
Negace jako neúspěch (negation as failure)
slabší verze CWA: definitivně neúspěšný (finitely failed) SLD-strom cíle : -A
: -A má definitivně (konečně) neúspěš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, 17. května 2007 160 Negace v logickém programování
Negace jako neúspěch (negation as failure)
slabší verze CWA: definitivně neúspěšný (finitely failed) SLD-strom cíle : -A
: -A má definitivně (konečně) neúspěš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).
rozdíl mezi CWA a NF
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 nekonečný
existuje odvození cíle podle CWA, protože neexistuje vyvrácení : -nad(b, c)
Hana Rudová, Logické programování I, 17. května 2007 160 Negace v logickém programování
Negace jako neúspěch (negation as failure)
slabší verze CWA: definitivně neúspěšný (finitely failed) SLD-strom cíle : -A
: -A má definitivně (konečně) neúspěš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).
rozdíl mezi CWA a NF
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 nekonečný
existuje odvození cíle podle CWA, protože neexistuje vyvrácení : -nad(b, c)
CWA i NF jsou nekorektní: A není logickým důsledkem programu P
řešení: definovat programy tak, aby jejich důsledkem byly i negativní literály
zúplnění logického programu
Hana Rudová, Logické programování I, 17. května 2007 160 Negace v logickém programování
Podstata zúplnění logického programu
převod všech if příkazů v logickém programu na iff
nad(X, Y) : -na(X, Y).
nad(X, Y) : -na(X, Z), nad(Z, Y).
lze psát jako: nad(X, Y) : -(na(X, Y))  (na(X, Z), nad(Z, Y)).
zúplnění: nad(X, Y)  (na(X, Y))  (na(X, Z), nad(Z, Y)).
Hana Rudová, Logické programování I, 17. května 2007 161 Negace v logickém programování
Podstata zúplnění logického programu
převod všech if příkazů v logickém programu na iff
nad(X, Y) : -na(X, Y).
nad(X, Y) : -na(X, Z), nad(Z, Y).
lze psát jako: nad(X, Y) : -(na(X, Y))  (na(X, Z), nad(Z, Y)).
zúplnění: nad(X, Y)  (na(X, Y))  (na(X, Z), nad(Z, Y)).
X je nad Y právě tehdy, když alespoň jedna z podmínek platí
tedy pokud žádná z podmínek neplatí, X není nad Y
Hana Rudová, Logické programování I, 17. května 2007 161 Negace v logickém programování
Podstata zúplnění logického programu
převod všech if příkazů v logickém programu na iff
nad(X, Y) : -na(X, Y).
nad(X, Y) : -na(X, Z), nad(Z, Y).
lze psát jako: nad(X, Y) : -(na(X, Y))  (na(X, Z), nad(Z, Y)).
zúplnění: nad(X, Y)  (na(X, Y))  (na(X, Z), nad(Z, Y)).
X je nad Y právě tehdy, když alespoň jedna z podmínek platí
tedy pokud žádná z podmínek neplatí, X není nad Y
kombinace klauzulí je možná pouze pokud mají identické hlavy
na(c, b).
na(b, a).
lze psát jako: na(X1, X2) : -X1 = c, X2 = b.
na(X1, X2) : -X1 = b, X2 = a.
zúplnění: na(X1, X2) : -(X1 = c, X2 = b)  (X1 = b, X2 = a).
Hana Rudová, Logické programování I, 17. května 2007 161 Negace v logickém programování
Zúplnění programu
Zúplnění programu P je: comp(P) := IFF(P)  CET
Základní vlastnosti:
comp(P) P
do programu je přidána pouze negativní informace
Hana Rudová, Logické programování I, 17. května 2007 162 Negace v logickém programování
Zúplnění programu
Zúplnění programu P je: comp(P) := IFF(P)  CET
Základní vlastnosti:
comp(P) P
do programu je přidá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
def(p/n) predikátu p/n množina všech klauzulí predikátu p/n
Hana Rudová, Logické programování I, 17. května 2007 162 Negace v logickém programování
IF(q, P)
na(X1, X2) : -Y(X1 = c, X2 = b, f(Y))  (X1 = b, X2 = a, g).
na(c, b) : -f(Y). na(b, a) : -g.
q/n predikátový symbol programu P
X1, . . . , Xn jsou ,,nové" proměnné, které se nevyskytují nikde v P
Necht' C je klauzule ve tvaru
q(t1, . . . , tn) : -L1, . . . , Lm
kde m  0, t1, . . . , tn jsou termy a L1, . . . , Lm jsou literály.
Pak označme E(C) výraz Y1, . . . , Yk(X1 = t1, . . . , Xn = tn, L1, . . . , Lm)
kde Y1, . . . , Yk jsou všechny proměnné v C.
Hana Rudová, Logické programování I, 17. května 2007 163 Negace v logickém programování
IF(q, P)
na(X1, X2) : -Y(X1 = c, X2 = b, f(Y))  (X1 = b, X2 = a, g).
na(c, b) : -f(Y). na(b, a) : -g.
q/n predikátový symbol programu P
X1, . . . , Xn jsou ,,nové" proměnné, které se nevyskytují nikde v P
Necht' C je klauzule ve tvaru
q(t1, . . . , tn) : -L1, . . . , Lm
kde m  0, t1, . . . , tn jsou termy a L1, . . . , Lm jsou literály.
Pak označme E(C) výraz Y1, . . . , Yk(X1 = t1, . . . , Xn = tn, L1, . . . , Lm)
kde Y1, . . . , Yk jsou všechny proměnné v C.
Necht' def(q/n) = {C1, . . . , Cn}.
Pak formuli IF(q, P) získáme následujícím postupem:
q(X1, . . . , Xn) : -E(C1)  E(C2)      E(Cj) pro j > 0 a
q(X1, . . . , Xn) : - pro j = 0 [q/n není v programu P]
Hana Rudová, Logické programování I, 17. května 2007 163 Negace v logickém programování
Clarkova Teorie Rovnosti (CET)
všechny formule jsou univerzálně kvantifikovány:
1. X = X
2. X = Y  Y = X
3. X = Y  Y = Z  X = Z
4. pro každý f/m: X1 = Y1      Xm = Ym  f(X1, . . . , Xm) = f(Y1, . . . , Ym)
5. pro každý p/m: X1 = Y1      Xm = Ym  (p(X1, . . . , Xm)  p(Y1, . . . , Ym))
6. pro všechny různé f/m a g/n, (m, n  0): f(X1, . . . , Xm) = g(Y1, . . . , Yn)
7. pro každý f/m: f(X1, . . . , Xm) = f(Y1, . . . , Ym)  X1 = Y1      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, 17. května 2007 164 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á definitivně neúspěšný SLD-strom,
pak (A) je logickým důsledkem comp(P) (nebo-li comp(P) (A))
Hana Rudová, Logické programování I, 17. května 2007 165 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á definitivně neúspěšný SLD-strom,
pak (A) je logickým důsledkem comp(P) (nebo-li comp(P) (A))
Úplnost NF pravidla: Necht' P je logický program. Jestliže comp(P) (A),
pak existuje definitivně neúspěšný SLD-strom : -A.
zůstává problém: není rozhodnutelné, zda daná atomická formule je logickým důsledkem
daného logického programu.
teorém mluví pouze o existenci definitivně neúspěšného SLD-stromu
definitivně (konečně) neúspěšný SLD-strom sice existuje, ale nemusíme ho nalézt
např. v Prologu: může existovat konečné odvození, ale program přesto cyklí (Prolog
nenajde definitivně neúspěšný strom)
Hana Rudová, Logické programování I, 17. května 2007 165 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á definitivně neúspěšný SLD-strom,
pak (A) je logickým důsledkem comp(P) (nebo-li comp(P) (A))
Úplnost NF pravidla: Necht' P je logický program. Jestliže comp(P) (A),
pak existuje definitivně neúspěšný SLD-strom : -A.
zůstává problém: není rozhodnutelné, zda daná atomická formule je logickým důsledkem
daného logického programu.
teorém mluví pouze o existenci definitivně neúspěšného SLD-stromu
definitivně (konečně) neúspěšný SLD-strom sice existuje, ale nemusíme ho nalézt
např. v Prologu: může existovat konečné odvození, ale program přesto cyklí (Prolog
nenajde definitivně neúspěšný strom)
Odvození pomocí NF pouze test, nelze konstruovat výslednou substituci
v (comp(P) (A)) je A všeob. kvantifikováno, v (A) nejsou volné proměnné
Hana Rudová, Logické programování I, 17. května 2007 165 Negace v logickém programování
Normální a stratifikované programy
normální program: obsahuje negativní literály v pravidlech
problém: existence zúplnění, která nemají žádný model
p : -p. zúplnění: p  p
rozdělení programu na vrstvy
vynucují použití negace relace pouze tehdy pokud je relace úplně definovaná
Hana Rudová, Logické programování I, 17. května 2007 166 Negace v logickém programování
Normální a stratifikované programy
normální program: obsahuje negativní literály v pravidlech
problém: existence zúplnění, která nemají žádný model
p : -p. zúplnění: p  p
rozdělení programu na vrstvy
vynucují použití negace relace pouze tehdy pokud je relace úplně definovaná
a. a.
a : -b, a. a : -b, a.
b. b : -a.
Hana Rudová, Logické programování I, 17. května 2007 166 Negace v logickém programování
Normální a stratifikované programy
normální program: obsahuje negativní literály v pravidlech
problém: existence zúplnění, která nemají žádný model
p : -p. zúplnění: p  p
rozdělení programu na vrstvy
vynucují použití negace relace pouze tehdy pokud je relace úplně definovaná
a. a.
a : -b, a. a : -b, a.
b. b : -a.
stratifikovaný není stratifikovaný
Hana Rudová, Logické programování I, 17. května 2007 166 Negace v logickém programování
Normální a stratifikované programy
normální program: obsahuje negativní literály v pravidlech
problém: existence zúplnění, která nemají žádný model
p : -p. zúplnění: p  p
rozdělení programu na vrstvy
vynucují použití negace relace pouze tehdy pokud je relace úplně 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 symbolů
programu lze rozdělit do disjunktních množin S0, . . . , Sm (Si  stratum)
p(. . .) : - . . . , q(. . .), . . .  P, p  Sk = q  S0  . . .  Sk
p(. . .) : - . . . , q(. . .), . . .  P, p  Sk = q  S0  . . .  Sk-1
Hana Rudová, Logické programování I, 17. května 2007 166 Negace v logickém programování
Stratifikované programy II
program je m-stratifikovaný  m je nejmenší index takový,
že S0  . . .  Sm je množina všech predikátových symbolů z P
Věta: Zúplnění každého stratifikovaného programu má Herbrandův model.
p : -p. nemá Herbrandův model
p : -p. ale není stratifikovaný
Hana Rudová, Logické programování I, 17. května 2007 167 Negace v logickém programování
Stratifikované programy II
program je m-stratifikovaný  m je nejmenší index takový,
že S0  . . .  Sm je množina všech predikátových symbolů z P
Věta: Zúplnění každého stratifikovaného programu má Herbrandův model.
p : -p. nemá Herbrandův model
p : -p. ale není stratifikovaný
stratifikované programy nemusí mít jedinečný minimální Herbrandův model
cykli : -zastavi.
dva minimální Herbrandovy modely: {cykli}, {zastavi}
důsledek toho, že cykli : -zastavi. je ekvivalentní cykli  zastavi
Hana Rudová, Logické programování I, 17. května 2007 167 Negace v logickém programování
SLDNF rezoluce: úspěšné odvození
NF pravidlo: : - C. má konečně neúspěšný SLD-strom
C
Pokud máme negativní podcíl C v dotazu G, pak hledáme důkaz pro C
Pokud odvození C selže (strom pro C je konečně neúspěšný),
pak je odvození G (i C) celkově úspěšné
nahore(X) : -blokovany(X).
blokovany(X) : -na(Y, X).
na(a, b).
Hana Rudová, Logické programování I, 17. května 2007 168 Negace v logickém programování
SLDNF rezoluce: úspěšné odvození
NF pravidlo: : - C. má konečně neúspěšný SLD-strom
C
Pokud máme negativní podcíl C v dotazu G, pak hledáme důkaz pro C
Pokud odvození C selže (strom pro C je konečně neúspěšný),
pak je odvození G (i C) celkově úspěšné
nahore(X) : -blokovany(X).
blokovany(X) : -na(Y, X).
na(a, b).
: -nahore(c).
yes
FAIL
:- nahore(c). :- blokovany(c).
:- na(Y,c).:- blokovany(c).
 uspěšné odvození
Hana Rudová, Logické programování I, 17. května 2007 168 Negace v logickém programování
SLDNF rezoluce: neúspěšné odvození
NF pravidlo: : - C. má konečně neúspěšný SLD-strom
C
Pokud máme negativní podcíl C v dotazu G, pak hledáme důkaz pro C
Pokud existuje vyvrácení C s prázdnou substitucí (strom pro C je konečně
úspěšný), pak je odvození G (i C) celkově neúspěšné
nahore(X) : -blokovany(X).
blokovany(X) : -na(Y, X).
na(_, _).
Hana Rudová, Logické programování I, 17. května 2007 169 Negace v logickém programování
SLDNF rezoluce: neúspěšné odvození
NF pravidlo: : - C. má konečně neúspěšný SLD-strom
C
Pokud máme negativní podcíl C v dotazu G, pak hledáme důkaz pro C
Pokud existuje vyvrácení C s prázdnou substitucí (strom pro C je konečně
úspěšný), pak je odvození G (i C) celkově neúspěšné
nahore(X) : -blokovany(X).
blokovany(X) : -na(Y, X).
na(_, _).
: -nahore(X).
no
:- nahore(X).
:- blokovany(X).
:- blokovany(X).
:- na(Y,X).
 neúspěšné odvození
Hana Rudová, Logické programování I, 17. května 2007 169 Negace v logickém programování
SLDNF rezoluce: uvázlé odvození
NF pravidlo: : - C. má konečně neúspěšný SLD-strom
C
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
konečně úspěšný), pak je odvození G (i C) uvázlé
nahore(X) : -blokovany(X).
blokovany(X) : -na(Y, X).
na(a, b).
Hana Rudová, Logické programování I, 17. května 2007 170 Negace v logickém programování
SLDNF rezoluce: uvázlé odvození
NF pravidlo: : - C. má konečně neúspěšný SLD-strom
C
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
konečně úspěšný), pak je odvození G (i C) uvázlé
nahore(X) : -blokovany(X).
blokovany(X) : -na(Y, X).
na(a, b).
: -nahore(X).
[Y/a,X/b]
[X/b]
:- nahore(X).
:- blokovany(X).
:- blokovany(X).
:- na(Y,X).
 uvázlé odvození
Hana Rudová, Logické programování I, 17. května 2007 170 Negace v logickém programování
SLD+
odvození
P je normální program, G0 normální cíl, R selekční pravidlo:
SLD+
-odvození G0 je bud' konečná posloupnost
G0; C0 , . . . , Gi-1; Ci-1 , Gi
nebo nekonečná posloupnost
G0; C0 , G1; C1 , G2; C2 , . . .
kde v každém kroku m + 1(m  0), R vybírá pozitivní literál v Gm a dospívá
k Gm+1 obvyklým způsobem.
Hana Rudová, Logické programování I, 17. května 2007 171 Negace v logickém programování
SLD+
odvození
P je normální program, G0 normální cíl, R selekční pravidlo:
SLD+
-odvození G0 je bud' konečná posloupnost
G0; C0 , . . . , Gi-1; Ci-1 , Gi
nebo nekonečná posloupnost
G0; C0 , G1; C1 , G2; C2 , . . .
kde v každém kroku m + 1(m  0), R vybírá pozitivní literál v Gm a dospívá
k Gm+1 obvyklým způsobem.
konečné SLD+
-odvození může být:
1. úspěšné: Gi =
2. neúspěšné
3. blokované: Gi je negativní (např. A)
Hana Rudová, Logické programování I, 17. května 2007 171 Negace v logickém programování
SLDNF rezoluce: pojmy
Úroveň cíle
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
k + 1  maximální úroveň cílů : -A,
které ve tvaru A blokují SLD+
-odvození G0, je k
nekonečná úroveň cíle: blokované SLDNF odvození
Hana Rudová, Logické programování I, 17. května 2007 172 Negace v logickém programování
SLDNF rezoluce: pojmy
Úroveň cíle
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
k + 1  maximální úroveň cílů : -A,
které ve tvaru A blokují SLD+
-odvození G0, je k
nekonečná úroveň cíle: blokované SLDNF odvození
Množina SLDNF odvození = {(SLDNF odvození G0)  (SLDNF odvození : -A)}
při odvozování G0 jsme se dostali k cíli A
SLDNF odvození cíle G ?
Hana Rudová, Logické programování I, 17. května 2007 172 Negace v logickém programování
SLDNF rezoluce
P normální program, G0 normální cíl, R selekční pravidlo:
množina SLDNF odvození a podmnožina neúspěš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 : - L1, . . . , Lm-1, A, Lm+1, . . . , Ln
pak
Hana Rudová, Logické programování I, 17. května 2007 173 Negace v logickém programování
SLDNF rezoluce
P normální program, G0 normální cíl, R selekční pravidlo:
množina SLDNF odvození a podmnožina neúspěš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 : - L1, . . . , Lm-1, A, Lm+1, . . . , Ln
pak
existuje-li SLDNF odvození : -A (pod R) s prázdnou cílovou substitucí, pak
G0; C0 , . . . , Gi je neúspěšné SLDNF odvození
Hana Rudová, Logické programování I, 17. května 2007 173 Negace v logickém programování
SLDNF rezoluce
P normální program, G0 normální cíl, R selekční pravidlo:
množina SLDNF odvození a podmnožina neúspěš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 : - L1, . . . , Lm-1, A, Lm+1, . . . , Ln
pak
existuje-li SLDNF odvození : -A (pod R) s prázdnou cílovou substitucí, pak
G0; C0 , . . . , Gi je neúspěšné SLDNF odvození
je-li každé úplné SLDNF odvození : -A (pod R) neúspěšné pak
G0; C0 , . . . , Gi, , (: - L1, . . . , Lm-1, Lm+1, . . . , Ln) je
(úspěšné) SLDNF odvození cíle G0
označuje prázdnou cílovou substituci
Hana Rudová, Logické programování I, 17. května 2007 173 Negace v logickém programování
SLDNF rezoluce
P normální program, G0 normální cíl, R selekční pravidlo:
množina SLDNF odvození a podmnožina neúspěš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 : - L1, . . . , Lm-1, A, Lm+1, . . . , Ln
pak
existuje-li SLDNF odvození : -A (pod R) s prázdnou cílovou substitucí, pak
G0; C0 , . . . , Gi je neúspěšné SLDNF odvození
je-li každé úplné SLDNF odvození : -A (pod R) neúspěšné pak
G0; C0 , . . . , Gi, , (: - L1, . . . , Lm-1, Lm+1, . . . , Ln) je
(úspěšné) SLDNF odvození cíle G0
označuje prázdnou cílovou substituci
Hana Rudová, Logické programování I, 17. května 2007 173 Negace v logickém programování
Typy SLDNF odvození
Konečné SLDNF-odvození může být:
1. úspěšné: Gi =
2. neúspěšné
3. uvázlé (flounder):
Gi je negativní (A) a : -A je úspěšné s neprázdnou cílovou substitucí
4. blokované: Gi je negativní (A) a : -A nemá konečnou úroveň.
Hana Rudová, Logické programování I, 17. května 2007 174 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 selekční pravidlo:
je-li  cílová substituce SLDNF-odvození cíle : -G, pak
G je logickým důsledkem comp(P)
Hana Rudová, Logické programování I, 17. května 2007 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 selekční pravidlo:
je-li  cílová substituce SLDNF-odvození cíle : -G, pak
G je logickým důsledkem comp(P)
implementace SLDNF v Prologu není korektní
Prolog neřeší uvázlé SLDNF-odvození (neprázdná substituce)
použití bezpečných cílů (negace neobsahuje proměnné)
Hana Rudová, Logické programování I, 17. května 2007 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 selekční pravidlo:
je-li  cílová substituce SLDNF-odvození cíle : -G, pak
G je logickým důsledkem comp(P)
implementace SLDNF v Prologu není korektní
Prolog neřeší uvázlé SLDNF-odvození (neprázdná substituce)
použití bezpečných cílů (negace neobsahuje proměnné)
úplnost SLDNF-odvození: SLDNF-odvození není úplné
pokud existuje konečný neúspěšný strom : -A, pak A platí
ale místo toho se odvozování : -A může zacyklit, tj. SLDNF rezoluce A neodvodí
 A tedy sice platí, ale SLDNF rezoluce ho nedokáže odvodit
Hana Rudová, Logické programování I, 17. května 2007 175 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.
http://www.ics.uci.edu/~dechter/ics-275a/fall-2001/readings.html
Barták R. Přednáška Omezující podmínky na MFF UK, Praha.
http://kti.ms.mff.cuni.cz/~bartak/podminky/prednaska.html
SICStus Prolog User's Manual, 2004. Kapitola o CLP(FD).
http://www.fi.muni.cz/~hanka/sicstus/doc/html/
Příklady v distribuci SICStus Prologu: cca 25 příkladů, zdrojový kód
aisa:/software/sicstus-3.10.1/lib/sicstus-3.10.1/library/clpfd/examples/
Constraint Programming Online
http://slash.math.unipd.it/cp/index.php
Hana Rudová, Logické programování I, 17. května 2007 177 Logické programování s omezujícími podmínkami
Probírané oblasti
Obsah
úvod: od LP k CLP
základy programování
základní algoritmy pro řešení problémů s omezujícími podmínkami
Hana Rudová, Logické programování I, 17. května 2007 178 Logické programování s omezujícími podmínkami
Probírané oblasti
Obsah
úvod: od LP k CLP
základy programování
základní algoritmy pro řešení problémů s omezujícími podmínkami
Příbuzné přednášky na FI
PA163 Programování s omezujícími podmínkami
http://www.fi.muni.cz/~hanka/cp
PA167 Rozvrhování
http://www.fi.muni.cz/~hanka/rozvrhovani
zahrnuty CP techniky pro řešení rozvrhovacích problémů
Hana Rudová, Logické programování I, 17. května 2007 178 Logické programování s omezujícími podmínkami
Historie a současnost
1963 interaktivní grafika (Sutherland: Sketchpad)
Polovina 80. let: logické programování omezujícími podmínkami
Od 1990: komerční využití
Už v roce 1996: výnos řádově stovky milionů dolarů
Aplikace ­ příklady
Lufthansa: krátkodobé personální plánování
reakce na změny při dopravě (zpoždění letadla, . . . )
minimalizace změny v rozvrhu, minimalizace ceny
Nokia: automatická konfigurace sw pro mobilní telefony
Renault: krátkodobé plánování výroby, funkční od roku 1995
Hana Rudová, Logické programování I, 17. května 2007 179 Logické programování s omezujícími podmínkami
Omezení (constraint)
Dána
množina (doménových) proměnných Y = {y1, . . . , yk}
konečná množina hodnot (doména) D = {D1, . . . , Dk}
Omezení c na Y je podmnožina D1 × . . . × Dk
omezuje hodnoty, kterých mohou proměnné nabývat současně
Hana Rudová, Logické programování I, 17. května 2007 180 Logické programování s omezujícími podmínkami
Omezení (constraint)
Dána
množina (doménových) proměnných Y = {y1, . . . , yk}
konečná množina hodnot (doména) D = {D1, . . . , Dk}
Omezení c na Y je podmnožina D1 × . . . × Dk
omezuje hodnoty, kterých mohou proměnné nabývat současně
Příklad:
proměnné: A,B
domény: {0,1} pro A {1,2} pro B
omezení: A=B nebo (A,B)  {(0,1),(0,2),(1,2)}
Hana Rudová, Logické programování I, 17. května 2007 180 Logické programování s omezujícími podmínkami
Omezení (constraint)
Dána
množina (doménových) proměnných Y = {y1, . . . , yk}
konečná množina hodnot (doména) D = {D1, . . . , Dk}
Omezení c na Y je podmnožina D1 × . . . × Dk
omezuje hodnoty, kterých mohou proměnné nabývat současně
Příklad:
proměnné: A,B
domény: {0,1} pro A {1,2} pro B
omezení: A=B nebo (A,B)  {(0,1),(0,2),(1,2)}
Omezení c definováno na y1, . . . yk je splněno,
pokud pro d1  D1, . . . dk  Dk platí (d1, . . . dk)  c
Hana Rudová, Logické programování I, 17. května 2007 180 Logické programování s omezujícími podmínkami
Omezení (constraint)
Dána
množina (doménových) proměnných Y = {y1, . . . , yk}
konečná množina hodnot (doména) D = {D1, . . . , Dk}
Omezení c na Y je podmnožina D1 × . . . × Dk
omezuje hodnoty, kterých mohou proměnné nabývat současně
Příklad:
proměnné: A,B
domény: {0,1} pro A {1,2} pro B
omezení: A=B nebo (A,B)  {(0,1),(0,2),(1,2)}
Omezení c definováno na y1, . . . yk je splněno,
pokud pro d1  D1, . . . dk  Dk platí (d1, . . . dk)  c
příklad (pokračování): omezení splněno pro (0, 1), (0, 2), (1, 2), není splněno pro (1, 1)
Hana Rudová, Logické programování I, 17. května 2007 180 Logické programování s omezujícími podmínkami
Problém splňování podmínek (CSP)
Dána
konečná množina proměnných X = {x1, . . . , xn}
konečná množina hodnot (doména) D = {D1, . . . , Dn}
konečná množina omezení C = {c1, . . . , cm}
omezení je definováno na podmnožině X
Problém splňování podmínek je trojice (X, D, C)
(constraint satisfaction problem)
Hana Rudová, Logické programování I, 17. května 2007 181 Logické programování s omezujícími podmínkami
Problém splňování podmínek (CSP)
Dána
konečná množina proměnných X = {x1, . . . , xn}
konečná množina hodnot (doména) D = {D1, . . . , Dn}
konečná množina omezení C = {c1, . . . , cm}
omezení je definováno na podmnožině X
Problém splňování podmínek je trojice (X, D, C)
(constraint satisfaction problem)
Příklad:
proměnné: A,B,C
domény: {0,1} pro A {1,2} pro B {0,2} pro C
omezení: A=B, B=C
Hana Rudová, Logické programování I, 17. května 2007 181 Logické programování s omezujícími podmínkami
Řešení CSP
Částečné ohodnocení proměnných (d1, . . . , dk), k < n
některé proměnné mají přiřazenu hodnotu
Úplné ohodnocení proměnných (d1, . . . , dn)
všechny proměnné mají přiřazenu hodnotu
Hana Rudová, Logické programování I, 17. května 2007 182 Logické programování s omezujícími podmínkami
Řešení CSP
Částečné ohodnocení proměnných (d1, . . . , dk), k < n
některé proměnné mají přiřazenu hodnotu
Úplné ohodnocení proměnných (d1, . . . , dn)
všechny proměnné mají přiřazenu hodnotu
Řešení CSP
úplné ohodnocení proměnných, které splňuje všechna omezení
(d1, . . . , dn)  D1 × . . . × Dn je řešení (X, D, C)
pro každé ci  C na xi1, . . . xik
platí (di1, . . . dik
)  ci
Hana Rudová, Logické programování I, 17. května 2007 182 Logické programování s omezujícími podmínkami
Řešení CSP
Částečné ohodnocení proměnných (d1, . . . , dk), k < n
některé proměnné mají přiřazenu hodnotu
Úplné ohodnocení proměnných (d1, . . . , dn)
všechny proměnné mají přiřazenu hodnotu
Řešení CSP
úplné ohodnocení proměnných, které splňuje všechna omezení
(d1, . . . , dn)  D1 × . . . × Dn je řešení (X, D, C)
pro každé ci  C na xi1, . . . xik
platí (di1, . . . dik
)  ci
Hledáme: jedno nebo
všechna řešení nebo
optimální řešení (vzhledem k objektivní funkci)
Hana Rudová, Logické programování I, 17. května 2007 182 Logické programování s omezujícími podmínkami
Příklad: jednoduchý školní rozvrh
proměnné: Jan, Petr, ...
učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
domény: {3, 4, 5, 6}, {3, 4}, . . .
omezení: all_distinct([Jan,Petr,...])
Hana Rudová, Logické programování I, 17. května 2007 183 Logické programování s omezujícími podmínkami
Příklad: jednoduchý školní rozvrh
proměnné: Jan, Petr, ...
učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
domény: {3, 4, 5, 6}, {3, 4}, . . .
omezení: all_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
Hana Rudová, Logické programování I, 17. května 2007 183 Logické programování s omezujícími podmínkami
Příklad: jednoduchý školní rozvrh
proměnné: Jan, Petr, ...
učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
domény: {3, 4, 5, 6}, {3, 4}, . . .
omezení: all_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
řešení CSP:
Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Marie=1
všechna řešení: ještě Jan=6, Petr=4, Anna=5, Ota=2, Eva=3, Marie=1
Hana Rudová, Logické programování I, 17. května 2007 183 Logické programování s omezujícími podmínkami
Příklad: jednoduchý školní rozvrh
proměnné: Jan, Petr, ...
učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
domény: {3, 4, 5, 6}, {3, 4}, . . .
omezení: all_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
řešení CSP:
Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Marie=1
všechna řešení: ještě Jan=6, Petr=4, Anna=5, Ota=2, Eva=3, Marie=1
optimálizace: ženy učí co nejdříve
Hana Rudová, Logické programování I, 17. května 2007 183 Logické programování s omezujícími podmínkami
Příklad: jednoduchý školní rozvrh
proměnné: Jan, Petr, ...
učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
domény: {3, 4, 5, 6}, {3, 4}, . . .
omezení: all_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
řešení CSP:
Jan=6, Petr=3, Anna=5, Ota=2, Eva=4, Marie=1
všechna řešení: ještě Jan=6, Petr=4, Anna=5, Ota=2, Eva=3, Marie=1
optimálizace: ženy učí co nejdříve
Anna+Eva+Marie #= Cena minimalizace hodnoty proměnné Cena
optimální řešení: Jan=6, Petr=4, Anna=5, Ota=2, Eva=3, Marie=1
Hana Rudová, Logické programování I, 17. května 2007 183 Logické programování s omezujícími podmínkami
CLP(FD) program
Základní struktura CLP programu
1. definice proměnných a jejich domén
2. definice omezení
3. hledání řešení
Hana Rudová, Logické programování I, 17. května 2007 184 Logické programování s omezujícími podmínkami
CLP(FD) program
Základní struktura CLP programu
1. definice proměnných a jejich domén
2. definice omezení
3. hledání řešení
(1) a (2) deklarativní část
modelování problému
vyjádření problému splňování podmínek
Hana Rudová, Logické programování I, 17. května 2007 184 Logické programování s omezujícími podmínkami
CLP(FD) program
Základní struktura CLP programu
1. definice proměnných a jejich domén
2. definice omezení
3. hledání řešení
(1) a (2) deklarativní část
modelování problému
vyjádření problému splňování podmínek
(3) řídící část
prohledávání stavového prostoru řešení
procedura pro hledání řešení (enumeraci) se nazývá labeling
umožní nalézt jedno, všechna nebo optimální řešení
Hana Rudová, Logické programování I, 17. května 2007 184 Logické programování s omezujícími podmínkami
Kód CLP(FD) programu
% základní struktura CLP programu
solve( Variables ) :-
declare_variables( Variables ), domain([Jan],3,6], ...
Hana Rudová, Logické programování I, 17. května 2007 185 Logické programování s omezujícími podmínkami
Kód CLP(FD) programu
% základní struktura CLP programu
solve( Variables ) :-
declare_variables( Variables ), domain([Jan],3,6], ...
post_constraints( Variables ), all_distinct([Jan,Petr,...])
Hana Rudová, Logické programování I, 17. května 2007 185 Logické programování s omezujícími podmínkami
Kód CLP(FD) programu
% základní struktura CLP programu
solve( Variables ) :-
declare_variables( Variables ), domain([Jan],3,6], ...
post_constraints( Variables ), all_distinct([Jan,Petr,...])
labeling( Variables ).
Hana Rudová, Logické programování I, 17. května 2007 185 Logické programování s omezujícími podmínkami
Kód CLP(FD) programu
% základní struktura CLP programu
solve( Variables ) :-
declare_variables( Variables ), domain([Jan],3,6], ...
post_constraints( Variables ), all_distinct([Jan,Petr,...])
labeling( Variables ).
% triviální labeling
labeling( [] ).
labeling( [Var|Rest] ) :-
fd_min(Var,Min), % výběr nejmenší hodnoty z domény
( Var#=Min, labeling( Rest )
Hana Rudová, Logické programování I, 17. května 2007 185 Logické programování s omezujícími podmínkami
Kód CLP(FD) programu
% základní struktura CLP programu
solve( Variables ) :-
declare_variables( Variables ), domain([Jan],3,6], ...
post_constraints( Variables ), all_distinct([Jan,Petr,...])
labeling( Variables ).
% triviální labeling
labeling( [] ).
labeling( [Var|Rest] ) :-
fd_min(Var,Min), % výběr nejmenší hodnoty z domény
( Var#=Min, labeling( Rest )
;
Var#>Min , labeling( [Var|Rest] )
).
Hana Rudová, Logické programování I, 17. května 2007 185 Logické programování s omezujícími podmínkami
Příklad: algebrogram
Přiřad'te cifry 0, . . . 9 písmenům S, E, N, D, M, O, R, Y tak, aby platilo:
SEND + MORE = MONEY
různá písmena mají přiřazena různé cifry
S a M nejsou 0
Hana Rudová, Logické programování I, 17. května 2007 186 Logické programování s omezujícími podmínkami
Příklad: algebrogram
Přiřad'te cifry 0, . . . 9 písmenům S, E, N, D, M, O, R, Y tak, aby platilo:
SEND + MORE = MONEY
různá písmena mají přiřazena různé cifry
S a M nejsou 0
domain([E,N,D,O,R,Y], 0, 9), domain([S,M],1,9)
Hana Rudová, Logické programování I, 17. května 2007 186 Logické programování s omezujícími podmínkami
Příklad: algebrogram
Přiřad'te cifry 0, . . . 9 písmenům S, E, N, D, M, O, R, Y tak, aby platilo:
SEND + MORE = MONEY
různá písmena mají přiřazena různé cifry
S 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*O + 10*R + E
#= 10000*M + 1000*O + 100*N + 10*E + Y
Hana Rudová, Logické programování I, 17. května 2007 186 Logické programování s omezujícími podmínkami
Příklad: algebrogram
Přiřad'te cifry 0, . . . 9 písmenům S, E, N, D, M, O, R, Y tak, aby platilo:
SEND + MORE = MONEY
různá písmena mají přiřazena různé cifry
S 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*O + 10*R + E
#= 10000*M + 1000*O + 100*N + 10*E + Y
all_distinct( [S,E,N,D,M,O,R,Y] )
Hana Rudová, Logické programování I, 17. května 2007 186 Logické programování s omezujícími podmínkami
Příklad: algebrogram
Přiřad'te cifry 0, . . . 9 písmenům S, E, N, D, M, O, R, Y tak, aby platilo:
SEND + MORE = MONEY
různá písmena mají přiřazena různé cifry
S 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*O + 10*R + E
#= 10000*M + 1000*O + 100*N + 10*E + Y
all_distinct( [S,E,N,D,M,O,R,Y] )
labeling( [S,E,N,D,M,O,R,Y] )
Hana Rudová, Logické programování I, 17. května 2007 186 Logické programování s omezujícími podmínkami
Od LP k CLP I.
CLP: rozšíření logického programování o omezující podmínky
CLP systémy se liší podle typu domény
CLP(A) generický jazyk
CLP(FD) domény proměnných jsou konečné (Finite Domains)
CLP(R) doménou proměnných je množina reálných čísel
Hana Rudová, Logické programování I, 17. května 2007 187 Logické programování s omezujícími podmínkami
Od LP k CLP I.
CLP: rozšíření logického programování o omezující podmínky
CLP systémy se liší podle typu domény
CLP(A) generický jazyk
CLP(FD) domény proměnných jsou konečné (Finite Domains)
CLP(R) doménou proměnných je množina reálných čísel
Cíl
využít syntaktické a výrazové přednosti LP
dosáhnout větší efektivity
Hana Rudová, Logické programování I, 17. května 2007 187 Logické programování s omezujícími podmínkami
Od LP k CLP I.
CLP: rozšíření logického programování o omezující podmínky
CLP systémy se liší podle typu domény
CLP(A) generický jazyk
CLP(FD) domény proměnných jsou konečné (Finite Domains)
CLP(R) doménou proměnných je množina reálných čísel
Cíl
využít syntaktické a výrazové přednosti LP
dosáhnout větší efektivity
Unifikace v LP je nahrazena splňováním podmínek
unifikace se chápe jako jedna z podmínek
A = B
A #< B, A in 0..9, domain([A,B],0,9), all_distinct([A,B,C])
Hana Rudová, Logické programování I, 17. května 2007 187 Logické programování s omezujícími podmínkami
Od LP k CLP II.
Pro řešení podmínek se používají konzistenční techniky
consistency techniques, propagace omezení (constraint propagation)
omezení: A in 0..2, B in 0..2, B #< A
Hana Rudová, Logické programování I, 17. května 2007 188 Logické programování s omezujícími podmínkami
Od LP k CLP II.
Pro řešení podmínek se používají konzistenční techniky
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, 17. května 2007 188 Logické programování s omezujícími podmínkami
Od LP k CLP II.
Pro řešení podmínek se používají konzistenční techniky
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
Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky
Hana Rudová, Logické programování I, 17. května 2007 188 Logické programování s omezujícími podmínkami
Od LP k CLP II.
Pro řešení podmínek se používají konzistenční techniky
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
Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky
Prohledávání doplněno konzistenčními technikami
A in 1..2, B in 0..1, B #< A
Hana Rudová, Logické programování I, 17. května 2007 188 Logické programování s omezujícími podmínkami
Od LP k CLP II.
Pro řešení podmínek se používají konzistenční techniky
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
Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky
Prohledávání doplněno konzistenčními technikami
A in 1..2, B in 0..1, B #< A
po provedení A #= 1 se z B #< A se odvodí: B #= 0
Hana Rudová, Logické programování I, 17. května 2007 188 Logické programování s omezujícími podmínkami
Od LP k CLP II.
Pro řešení podmínek se používají konzistenční techniky
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
Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky
Prohledávání doplněno konzistenčními technikami
A in 1..2, B in 0..1, B #< A
po provedení A #= 1 se z B #< A se odvodí: B #= 0
Podmínky jako výstup
kompaktní reprezentace nekonečného počtu řešení, výstup lze použít jako vstup
Hana Rudová, Logické programování I, 17. května 2007 188 Logické programování s omezujícími podmínkami
Od LP k CLP II.
Pro řešení podmínek se používají konzistenční techniky
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
Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky
Prohledávání doplněno konzistenčními technikami
A in 1..2, B in 0..1, B #< A
po provedení A #= 1 se z B #< A se odvodí: B #= 0
Podmínky jako výstup
kompaktní reprezentace nekonečného počtu řešení, výstup lze použít jako vstup
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, 17. května 2007 188 Logické programování s omezujícími podmínkami
Od LP k CLP II.
Pro řešení podmínek se používají konzistenční techniky
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
Podmínky jsou deterministicky vyhodnoceny v okamžiku volání podmínky
Prohledávání doplněno konzistenčními technikami
A in 1..2, B in 0..1, B #< A
po provedení A #= 1 se z B #< A se odvodí: B #= 0
Podmínky jako výstup
kompaktní reprezentace nekonečného počtu řešení, výstup lze použít jako vstup
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, 17. května 2007 188 Logické programování s omezujícími podmínkami
Syntaxe CLP
Výběr jazyka omezení
CLP klauzule
jako LP klauzule, ale její tělo může obsahovat omezení daného jazyka
p(X,Y) :- X #< Y+1, q(X), r(X,Y,Z).
Rezoluční krok v LP
kontrola existence mgu mezi cílem a hlavou
Krok odvození v CLP také zahrnuje
kontrola konzistence aktuální množiny omezení s omezeními v těle klauzule
 Vyvolání dvou řešičů: unifikace + řešič omezení
Hana Rudová, Logické programování I, 17. května 2007 189 Logické programování s omezujícími podmínkami
Operační sémantika CLP
CLP výpočet cíle G
Store množina aktivních omezení  prostor omezení (constraint store)
inicializace Store = 
seznamy cílů v G prováděny v obvyklém pořadí
pokud narazíme na cíl s omezením c: NewStore = Store  {c}
snažíme se splnit c vyvoláním jeho řešiče
při neúspěchu se vyvolá backtracking
při úspěchu se podmínky v NewStore zjednoduší propagací omezení
zbývající cíle jsou prováděny s upraveným NewStore
CLP výpočet cíle G je úspěšný, pokud se dostaneme z iniciálního stavu G, 
do stavu G , Store , kde G je prázdný cíl a Store je splnitelná.
Hana Rudová, Logické programování I, 17. května 2007 190 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
silná CLP(FD) knihovna, komerční i akademické použití pro širokou škálu platforem
Hana Rudová, Logické programování I, 17. května 2007 192 CLP(FD) v SICStus Prologu
Nejpoužívanější systémy a jazyky pro CP
Swedish Institute of Computer Science: SICStus Prolog 1985
silná CLP(FD) knihovna, komerční i akademické použití pro širokou škálu platforem
IC-PARC, Imperial College London, Cisco Systems: ECLi
PSe
1984
široké možnosti kooperace mezi různými řešičemi: konečné domény, reálná čísla, repair
od 2004 vlastní Cisco Systems volně dostupné pro akademické použití, rozvoj na
IC-PARC, platformy: Windows, Linux, Solaris
Hana Rudová, Logické programování I, 17. května 2007 192 CLP(FD) v SICStus Prologu
Nejpoužívanější systémy a jazyky pro CP
Swedish Institute of Computer Science: SICStus Prolog 1985
silná CLP(FD) knihovna, komerční i akademické použití pro širokou škálu platforem
IC-PARC, Imperial College London, Cisco Systems: ECLi
PSe
1984
široké možnosti kooperace mezi různými řešičemi: konečné domény, reálná čísla, repair
od 2004 vlastní Cisco Systems volně dostupné pro akademické použití, rozvoj na
IC-PARC, platformy: Windows, Linux, Solaris
ILOG, omezující podmínky v C++ 1987
komerční společnost, vznik ve Francie, nyní rozšířená po celém světě
implementace podmínek založena na objektově orientovaném programování
Hana Rudová, Logické programování I, 17. května 2007 192 CLP(FD) v SICStus Prologu
Nejpoužívanější systémy a jazyky pro CP
Swedish Institute of Computer Science: SICStus Prolog 1985
silná CLP(FD) knihovna, komerční i akademické použití pro širokou škálu platforem
IC-PARC, Imperial College London, Cisco Systems: ECLi
PSe
1984
široké možnosti kooperace mezi různými řešičemi: konečné domény, reálná čísla, repair
od 2004 vlastní Cisco Systems volně dostupné pro akademické použití, rozvoj na
IC-PARC, platformy: Windows, Linux, Solaris
ILOG, omezující podmínky v C++ 1987
komerční společnost, vznik ve Francie, nyní rozšířená po celém světě
implementace podmínek založena na objektově orientovaném programování
http://www.fi.muni.cz/~hanka/bookmarks.html#tools
cca 50 odkazů na nejrůznější systémy: Prolog, C++, Java, Lisp, . . .
COSYTEC: CHIP, PrologIA: Prolog IV, Siemens: IF Prolog,
akademický: Mozart (objektově orientované, deklarativní programování, concurrency), . . .
Hana Rudová, Logické programování I, 17. května 2007 192 CLP(FD) v SICStus Prologu
CLP(FD) v SICStus Prologu
CLP není dostupné v SWI Prologu
CLP knihovna v ECLiPSe se liší
Vestavěné predikáty jsou dostupné v separátním modulu (knihovně)
:- use_module(library(clpfd)).
Obecné principy platné všude
Stejné/podobné vestavěné predikáty existují i jinde
Hana Rudová, Logické programování I, 17. května 2007 193 CLP(FD) v SICStus Prologu
Příslušnost k doméně: Range termy
?- domain( [A,B], 1,3). domain( +Variables, +Min, +Max)
A in 1..3
B in 1..3
Hana Rudová, Logické programování I, 17. května 2007 194 CLP(FD) v SICStus Prologu
Příslušnost k doméně: Range termy
?- domain( [A,B], 1,3). domain( +Variables, +Min, +Max)
A in 1..3
B in 1..3
?- A in 1..8, A #\= 4. ?X in +Min..+Max
A in (1..3) \/ (5..8)
Hana Rudová, Logické programování I, 17. května 2007 194 CLP(FD) v SICStus Prologu
Příslušnost k doméně: Range termy
?- domain( [A,B], 1,3). domain( +Variables, +Min, +Max)
A in 1..3
B in 1..3
?- 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 čísel
?- A in (1..3) \/ (8..15) \/ (5..9) \/ {100}. ?X in +Range
A in (1..3) \/ (5..15) \/ {100}
Hana Rudová, Logické programování I, 17. května 2007 194 CLP(FD) v SICStus Prologu
Příslušnost k doméně: Range termy
?- domain( [A,B], 1,3). domain( +Variables, +Min, +Max)
A in 1..3
B in 1..3
?- 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 čísel
?- A in (1..3) \/ (8..15) \/ (5..9) \/ {100}. ?X in +Range
A in (1..3) \/ (5..15) \/ {100}
Zjištění domény Range proměnné 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, 17. května 2007 194 CLP(FD) v SICStus Prologu
Příslušnost k doméně: Range termy
?- domain( [A,B], 1,3). domain( +Variables, +Min, +Max)
A in 1..3
B in 1..3
?- 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 čísel
?- A in (1..3) \/ (8..15) \/ (5..9) \/ {100}. ?X in +Range
A in (1..3) \/ (5..15) \/ {100}
Zjištění domény Range proměnné 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
Hana Rudová, Logické programování I, 17. května 2007 194 CLP(FD) v SICStus Prologu
Příslušnost k doméně: Range termy
?- domain( [A,B], 1,3). domain( +Variables, +Min, +Max)
A in 1..3
B in 1..3
?- 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 čísel
?- A in (1..3) \/ (8..15) \/ (5..9) \/ {100}. ?X in +Range
A in (1..3) \/ (5..15) \/ {100}
Zjištění domény Range proměnné 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 Rudová, Logické programování I, 17. května 2007 194 CLP(FD) v SICStus Prologu
Příslušnost k doméně: FDSet termy
FDSet term: reprezentace závislá na implementaci
?- A in 1..8, A #\= 4, fd_set(A,FDSet). fd_set(?Var,?FDSet)
A in (1..3) \/ (5..8)
FDSet = [[1|3],[5|8]]
Hana Rudová, Logické programování I, 17. května 2007 195 CLP(FD) v SICStus Prologu
Příslušnost k doméně: FDSet termy
FDSet term: reprezentace závislá na implementaci
?- A in 1..8, A #\= 4, fd_set(A,FDSet). fd_set(?Var,?FDSet)
A in (1..3) \/ (5..8)
FDSet = [[1|3],[5|8]]
?- A in 1..8,A #\= 4, fd_set(A,FDSet),B in_set FDSet. ?X in_set +FDSet
A in (1..3) \/ (5..8)
FDSet = [[1|3],[5|8]]
B in (1..3) \/ (5..8)
Hana Rudová, Logické programování I, 17. května 2007 195 CLP(FD) v SICStus Prologu
Příslušnost k doméně: FDSet termy
FDSet term: reprezentace závislá na implementaci
?- A in 1..8, A #\= 4, fd_set(A,FDSet). fd_set(?Var,?FDSet)
A in (1..3) \/ (5..8)
FDSet = [[1|3],[5|8]]
?- A in 1..8,A #\= 4, fd_set(A,FDSet),B in_set FDSet. ?X in_set +FDSet
A in (1..3) \/ (5..8)
FDSet = [[1|3],[5|8]]
B in (1..3) \/ (5..8)
FDSet termy představují nízko-úrovňovou implementaci
FDSet termy nedoporučeny v programech
používat pouze predikáty pro manipulaci s nimi
omezit použití A in_set [[1|2],[6|9]]
Range termy preferovány
Hana Rudová, Logické programování I, 17. května 2007 195 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á proměnná?
fd_min(?Var,?Min) nejmenší hodnota v doméně
fd_max(?Var,?Max) největší hodnota v doméně
fd_size(?Var,?Size) velikost domény
fd_degree(?Var,?Degree) počet navázaných omezení na proměnné
Hana Rudová, Logické programování I, 17. května 2007 196 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á proměnná?
fd_min(?Var,?Min) nejmenší hodnota v doméně
fd_max(?Var,?Max) největší hodnota v doméně
fd_size(?Var,?Size) velikost domény
fd_degree(?Var,?Degree) počet navázaných omezení na proměnné
mění se během výpočtu: pouze aktivní omezení, i odvozená aktivní omezení
Hana Rudová, Logické programování I, 17. května 2007 196 CLP(FD) v SICStus Prologu
Aritmetická omezení
Expr RelOp Expr
RelOp -> #= | #\= | #< | #=< | #> | #>=
A + B #=< 3,
A #\= (C - 4) * ( D - 5), A/2 #= 4
Hana Rudová, Logické programování I, 17. května 2007 197 CLP(FD) v SICStus Prologu
Aritmetická omezení
Expr RelOp Expr
RelOp -> #= | #\= | #< | #=< | #> | #>=
A + B #=< 3,
A #\= (C - 4) * ( D - 5), A/2 #= 4
sum(Variables,RelOp,Suma)
domain([A,B,C,F],1,3),
sum([A,B,C],#= ,F)
Hana Rudová, Logické programování I, 17. května 2007 197 CLP(FD) v SICStus Prologu
Aritmetická omezení
Expr RelOp Expr
RelOp -> #= | #\= | #< | #=< | #> | #>=
A + B #=< 3,
A #\= (C - 4) * ( D - 5), A/2 #= 4
sum(Variables,RelOp,Suma)
domain([A,B,C,F],1,3),
sum([A,B,C],#= ,F)
scalar_product(Coeffs,Variables,RelOp,ScalarProduct)
domain([A,B,C,F],1,6),
scalar_product( [1,2,3],[A,B,C],#= ,F)
Hana Rudová, Logické programování I, 17. května 2007 197 CLP(FD) v SICStus Prologu
Výroková omezení, reifikace
Výroková omezení pozor na efektivitu
\# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6
Hana Rudová, Logické programování I, 17. května 2007 198 CLP(FD) v SICStus Prologu
Výroková omezení, reifikace
Výroková omezení pozor na efektivitu
\# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6
za předpokladu A in 1..4:
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
Hana Rudová, Logické programování I, 17. května 2007 198 CLP(FD) v SICStus Prologu
Výroková omezení, reifikace
Výroková omezení pozor na efektivitu
\# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6
za předpokladu A in 1..4:
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říliš slabá (propagační algoritmy příliš obecné)
Hana Rudová, Logické programování I, 17. května 2007 198 CLP(FD) v SICStus Prologu
Výroková omezení, reifikace
Výroková omezení pozor na efektivitu
\# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6
za předpokladu A in 1..4:
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říliš slabá (propagační algoritmy příliš obecné)
Reifikace pozor na efektivitu
Constraint #<=> Bool
Bool in 0..1 v závislosti na tom, zda je Constraint splněn
příklad: A in 1..10 #<=> Bool
Hana Rudová, Logické programování I, 17. května 2007 198 CLP(FD) v SICStus Prologu
Výroková omezení, reifikace
Výroková omezení pozor na efektivitu
\# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6
za předpokladu A in 1..4:
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říliš slabá (propagační algoritmy příliš obecné)
Reifikace pozor na efektivitu
Constraint #<=> Bool
Bool in 0..1 v závislosti na tom, zda je Constraint splněn
příklad: A in 1..10 #<=> Bool
za předpokladu 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, 17. května 2007 198 CLP(FD) v SICStus Prologu
Výroková omezení, reifikace
Výroková omezení pozor na efektivitu
\# negace, #/\ konjunkce, #\/ disjunkce, #<=> ekvivalence, ...
X #> 4 #/\ Y #< 6
za předpokladu A in 1..4:
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říliš slabá (propagační algoritmy příliš obecné)
Reifikace pozor na efektivitu
Constraint #<=> Bool
Bool in 0..1 v závislosti na tom, zda je Constraint splněn
příklad: A in 1..10 #<=> Bool
za předpokladu 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, 17. května 2007 198 CLP(FD) v SICStus Prologu
Příklad: reifikace
Přesně N prvků v seznamu S je rovno X: exactly(X,S,N)
Hana Rudová, Logické programování I, 17. května 2007 199 CLP(FD) v SICStus Prologu
Příklad: reifikace
Přesně N prvků v seznamu S je rovno X: exactly(X,S,N)
exactly(_, [], 0).
Hana Rudová, Logické programování I, 17. května 2007 199 CLP(FD) v SICStus Prologu
Příklad: reifikace
Přesně N prvků v seznamu S je rovno X: exactly(X,S,N)
exactly(_, [], 0).
exactly(X, [Y|L], N) :-
X #= Y #<=> B, % reifikace
Hana Rudová, Logické programování I, 17. května 2007 199 CLP(FD) v SICStus Prologu
Příklad: reifikace
Přesně N prvků v seznamu S je rovno X: exactly(X,S,N)
exactly(_, [], 0).
exactly(X, [Y|L], N) :-
X #= Y #<=> B, % reifikace
N #= M+B, % doménová proměnná místo akumulátoru
exactly(X, L, M).
Hana Rudová, Logické programování I, 17. května 2007 199 CLP(FD) v SICStus Prologu
Příklad: reifikace
Přesně N prvků v seznamu S je rovno X: exactly(X,S,N)
exactly(_, [], 0).
exactly(X, [Y|L], N) :-
X #= Y #<=> B, % reifikace
N #= M+B, % doménová proměnná místo akumulátoru
exactly(X, L, M).
| ?- domain([A,B,C,D,E,N],1,2), exactly(1,[A,B,C,D,E],N),
Hana Rudová, Logické programování I, 17. května 2007 199 CLP(FD) v SICStus Prologu
Příklad: reifikace
Přesně N prvků v seznamu S je rovno X: exactly(X,S,N)
exactly(_, [], 0).
exactly(X, [Y|L], N) :-
X #= Y #<=> B, % reifikace
N #= M+B, % doménová proměnná místo akumulátoru
exactly(X, L, M).
| ?- domain([A,B,C,D,E,N],1,2), exactly(1,[A,B,C,D,E],N),A#< 2,
Hana Rudová, Logické programování I, 17. května 2007 199 CLP(FD) v SICStus Prologu
Příklad: reifikace
Přesně N prvků v seznamu S je rovno X: exactly(X,S,N)
exactly(_, [], 0).
exactly(X, [Y|L], N) :-
X #= Y #<=> B, % reifikace
N #= M+B, % doménová proměnná místo akumulátoru
exactly(X, L, M).
| ?- domain([A,B,C,D,E,N],1,2), exactly(1,[A,B,C,D,E],N),A#< 2,B#< 2.
Hana Rudová, Logické programování I, 17. května 2007 199 CLP(FD) v SICStus Prologu
Příklad: reifikace
Přesně N prvků v seznamu S je rovno X: exactly(X,S,N)
exactly(_, [], 0).
exactly(X, [Y|L], N) :-
X #= Y #<=> B, % reifikace
N #= M+B, % doménová proměnná místo akumulátoru
exactly(X, L, M).
| ?- domain([A,B,C,D,E,N],1,2), exactly(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, 17. května 2007 199 CLP(FD) v SICStus Prologu
Příklad: reifikace
Přesně N prvků v seznamu S je rovno X: exactly(X,S,N)
exactly(_, [], 0).
exactly(X, [Y|L], N) :-
X #= Y #<=> B, % reifikace
N #= M+B, % doménová proměnná místo akumulátoru
exactly(X, L, M).
| ?- domain([A,B,C,D,E,N],1,2), exactly(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
greaters(X,S,N): přesně N prvků v seznamu S je větší než X
atleast(X,S,N): alespoň N prvků v seznamu S je rovno X
atmost(X,S,N): nejvýše N prvků v seznamu S je rovno X
Hana Rudová, Logické programování I, 17. května 2007 199 CLP(FD) v SICStus Prologu
Základní kombinatorická omezení
element(N,List,X)
omezení na konkrétní prvek seznamu
all_distinct(List)
všechny proměnné různé
Hana Rudová, Logické programování I, 17. května 2007 200 CLP(FD) v SICStus Prologu
Základní kombinatorická omezení
element(N,List,X)
omezení na konkrétní prvek seznamu
all_distinct(List)
všechny proměnné různé
serialized(Starts,Durations)
disjunktivní rozvrhování
disjoint2(Rectangles)
nepřekrývání obdélníků
cumulative(Starts,Durations,Resources,Limit)
kumulativní rozvrhování
Hana Rudová, Logické programování I, 17. května 2007 200 CLP(FD) v SICStus Prologu
Výskyty prvků v seznamu
element(N,List,X)
N-tý prvek v seznamu List je roven X
| ?- A in 2..10, B in 1..3, element( N, [A,B], X ),
Hana Rudová, Logické programování I, 17. května 2007 201 CLP(FD) v SICStus Prologu
Výskyty prvků v seznamu
element(N,List,X)
N-tý prvek v seznamu List je roven X
| ?- A in 2..10, B in 1..3, element( N, [A,B], X ), X#< 2.
B = 1, N = 2, X = 1, A in 2..10
Hana Rudová, Logické programování I, 17. května 2007 201 CLP(FD) v SICStus Prologu
Výskyty prvků v seznamu
element(N,List,X)
N-tý prvek v seznamu List je roven X
| ?- A in 2..10, B in 1..3, element( N, [A,B], X ), X#< 2.
B = 1, N = 2, X = 1, A in 2..10
Hana Rudová, Logické programování I, 17. května 2007 201 CLP(FD) v SICStus Prologu
Všechny proměnné různé
all_distinct(Variables), all_different(Variables)
Proměnné v seznamu Variables jsou různé
all_distinct a all_different se liší úrovní propagace
all_distinct má úplnou propagaci
all_different má slabší (neúplnou) propagaci
Hana Rudová, Logické programování I, 17. května 2007 202 CLP(FD) v SICStus Prologu
Všechny proměnné různé
all_distinct(Variables), all_different(Variables)
Proměnné v seznamu Variables jsou různé
all_distinct a all_different se liší úrovní propagace
all_distinct má úplnou propagaci
all_different má slabší (neúplnou) propagaci
učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
Příklad: učitelé musí učit v různé hodiny
Hana Rudová, Logické programování I, 17. května 2007 202 CLP(FD) v SICStus Prologu
Všechny proměnné různé
all_distinct(Variables), all_different(Variables)
Proměnné v seznamu Variables jsou různé
all_distinct a all_different se liší úrovní propagace
all_distinct má úplnou propagaci
all_different má slabší (neúplnou) propagaci
učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
Příklad: učitelé musí učit v různé hodiny
all_distinct([Jan,Petr,Anna,Ota,Eva,Marie])
Jan = 6, Ota = 2, Anna = 5,
Marie = 1, Petr in 3..4, Eva in 3..4
Hana Rudová, Logické programování I, 17. května 2007 202 CLP(FD) v SICStus Prologu
Všechny proměnné různé
all_distinct(Variables), all_different(Variables)
Proměnné v seznamu Variables jsou různé
all_distinct a all_different se liší úrovní propagace
all_distinct má úplnou propagaci
all_different má slabší (neúplnou) propagaci
učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
Příklad: učitelé musí učit v různé hodiny
all_distinct([Jan,Petr,Anna,Ota,Eva,Marie])
Jan = 6, Ota = 2, Anna = 5,
Marie = 1, Petr in 3..4, Eva in 3..4
all_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
Hana Rudová, Logické programování I, 17. května 2007 202 CLP(FD) v SICStus Prologu
Disjunktivní rozvrhování
serialized(Starts,Durations)
Rozvržení úloh zadaných startovním časem (seznam Starts)
a dobou trvání (seznam nezáporných Durations) tak, aby se nepřekrývaly
Hana Rudová, Logické programování I, 17. května 2007 203 CLP(FD) v SICStus Prologu
Disjunktivní rozvrhování
serialized(Starts,Durations)
Rozvržení úloh zadaných startovním časem (seznam Starts)
a dobou trvání (seznam nezáporných Durations) tak, aby se nepřekrývaly
příklad s konstantami: serialized([0,3,5],[2,1,1])
Hana Rudová, Logické programování I, 17. května 2007 203 CLP(FD) v SICStus Prologu
Disjunktivní rozvrhování
serialized(Starts,Durations)
Rozvržení úloh zadaných startovním časem (seznam Starts)
a dobou trvání (seznam nezáporných Durations) tak, aby se nepřekrývaly
příklad s konstantami: serialized([0,3,5],[2,1,1])
příklad: vytvoření rozvrhu, za předpokladu, že doba trvání hodin není stejná
Hana Rudová, Logické programování I, 17. května 2007 203 CLP(FD) v SICStus Prologu
Disjunktivní rozvrhování
serialized(Starts,Durations)
Rozvržení úloh zadaných startovním časem (seznam Starts)
a dobou trvání (seznam nezáporných Durations) tak, aby se nepřekrývaly
příklad s konstantami: serialized([0,3,5],[2,1,1])
příklad: vytvoření rozvrhu, za předpokladu, že doba trvání hodin není stejná
D in 1..2, C = 3,
serialized([Jan,Petr,Anna,Ota,Eva,Marie], [D,D,D,C,C,C])
Hana Rudová, Logické programování I, 17. května 2007 203 CLP(FD) v SICStus Prologu
Nepřekrývání obdélníků
disjoint2(Rectangles) disjoint1(Lines)
disjoint2( [Name(X, Delka, Y, Vyska) | _ ] )
umístění obdélníků ve dvourozměrném prostoru
doménové proměnné X,Y,Delka,Vyska mohou být z oboru celých čísel
Hana Rudová, Logické programování I, 17. května 2007 204 CLP(FD) v SICStus Prologu
Nepřekrývání obdélníků
disjoint2(Rectangles) disjoint1(Lines)
disjoint2( [Name(X, Delka, Y, Vyska) | _ ] )
umístění obdélníků ve dvourozměrném prostoru
doménové proměnné X,Y,Delka,Vyska mohou být z oboru celých čísel
příklad s konstantami:
disjoint2([rect(0,3,0,1),rect(1,3,1,2),rect(4,2,2,-2)])
3 4 5 6
2
3
2
1
1
1
3
2
Hana Rudová, Logické programování I, 17. května 2007 204 CLP(FD) v SICStus Prologu
Nepřekrývání obdélníků
disjoint2(Rectangles) disjoint1(Lines)
disjoint2( [Name(X, Delka, Y, Vyska) | _ ] )
umístění obdélníků ve dvourozměrném prostoru
doménové proměnné X,Y,Delka,Vyska mohou být z oboru celých čísel
příklad s konstantami:
disjoint2([rect(0,3,0,1),rect(1,3,1,2),rect(4,2,2,-2)])
3 4 5 6
2
3
2
1
1
1
3
2
příklad: vytvoření rozvrhu za předpokladu, že učitelé učí v různých místnostech
D in 1..2, C = 3,
disjoint2( class(Jan,D,M1,1), class(Petr,D,M2,1), class(Petr,D,M3,1), ...] )
Hana Rudová, Logické programování I, 17. května 2007 204 CLP(FD) v SICStus Prologu
Kumulativní rozvrhování
cumulative(Starts,Durations,Resources,Limit)
Úlohy jsou zadány startovním časem (seznam Starts), dobou trvání (seznam
Durations) a požadovanou kapacitou zdroje (seznam Resources)
Rozvržení úloh tak, aby celková kapacita zdroje nikdy nepřekročila Limit
Hana Rudová, Logické programování I, 17. května 2007 205 CLP(FD) v SICStus Prologu
Kumulativní rozvrhování
cumulative(Starts,Durations,Resources,Limit)
Úlohy jsou zadány startovním časem (seznam Starts), dobou trvání (seznam
Durations) a požadovanou kapacitou zdroje (seznam Resources)
Rozvržení úloh tak, aby celková kapacita zdroje nikdy nepřekročila Limit
Příklad s konstantami: cumulative([0,1,3],[4,2,3],[1,2,2],3)
Hana Rudová, Logické programování I, 17. května 2007 205 CLP(FD) v SICStus Prologu
Příklad: kumulativní rozvrhování
Vytvořte rozvrh pro následující
úlohy, tak aby nebyla překročena
kapacita 13 zdroje, a minimalizujte
celkovou dobu trvání
úloha doba trvání kapacita
t1 16 2
t2 6 9
t3 13 3
t4 7 7
t5 5 10
t6 18 1
t7 4 11
Hana Rudová, Logické programování I, 17. května 2007 206 CLP(FD) v SICStus Prologu
Příklad: kumulativní rozvrhování
Vytvořte rozvrh pro následující
úlohy, tak aby nebyla překročena
kapacita 13 zdroje, a minimalizujte
celkovou dobu trvání
úloha doba trvání kapacita
t1 16 2
t2 6 9
t3 13 3
t4 7 7
t5 5 10
t6 18 1
t7 4 11
schedule(Ss, End) :-
Hana Rudová, Logické programování I, 17. května 2007 206 CLP(FD) v SICStus Prologu
Příklad: kumulativní rozvrhování
Vytvořte rozvrh pro následující
úlohy, tak aby nebyla překročena
kapacita 13 zdroje, a minimalizujte
celkovou dobu trvání
úloha doba trvání kapacita
t1 16 2
t2 6 9
t3 13 3
t4 7 7
t5 5 10
t6 18 1
t7 4 11
schedule(Ss, End) :-
length(Ss, 7),
Hana Rudová, Logické programování I, 17. května 2007 206 CLP(FD) v SICStus Prologu
Příklad: kumulativní rozvrhování
Vytvořte rozvrh pro následující
úlohy, tak aby nebyla překročena
kapacita 13 zdroje, a minimalizujte
celkovou dobu trvání
úloha doba trvání kapacita
t1 16 2
t2 6 9
t3 13 3
t4 7 7
t5 5 10
t6 18 1
t7 4 11
schedule(Ss, End) :-
length(Ss, 7),
Ds = [16, 6, 13, 7, 5, 18, 4],
Rs = [ 2, 9, 3, 7, 10, 1, 11],
Hana Rudová, Logické programování I, 17. května 2007 206 CLP(FD) v SICStus Prologu
Příklad: kumulativní rozvrhování
Vytvořte rozvrh pro následující
úlohy, tak aby nebyla překročena
kapacita 13 zdroje, a minimalizujte
celkovou dobu trvání
úloha doba trvání kapacita
t1 16 2
t2 6 9
t3 13 3
t4 7 7
t5 5 10
t6 18 1
t7 4 11
schedule(Ss, End) :-
length(Ss, 7),
Ds = [16, 6, 13, 7, 5, 18, 4],
Rs = [ 2, 9, 3, 7, 10, 1, 11],
domain(Ss, 0, 51),
domain([End], 0, 69),
Hana Rudová, Logické programování I, 17. května 2007 206 CLP(FD) v SICStus Prologu
Příklad: kumulativní rozvrhování
Vytvořte rozvrh pro následující
úlohy, tak aby nebyla překročena
kapacita 13 zdroje, a minimalizujte
celkovou dobu trvání
úloha doba trvání kapacita
t1 16 2
t2 6 9
t3 13 3
t4 7 7
t5 5 10
t6 18 1
t7 4 11
schedule(Ss, End) :-
length(Ss, 7),
Ds = [16, 6, 13, 7, 5, 18, 4],
Rs = [ 2, 9, 3, 7, 10, 1, 11],
domain(Ss, 0, 51),
domain([End], 0, 69),
after(Ss, Ds, End), % koncový čas
Hana Rudová, Logické programování I, 17. května 2007 206 CLP(FD) v SICStus Prologu
Příklad: kumulativní rozvrhování
Vytvořte rozvrh pro následující
úlohy, tak aby nebyla překročena
kapacita 13 zdroje, a minimalizujte
celkovou dobu trvání
úloha doba trvání kapacita
t1 16 2
t2 6 9
t3 13 3
t4 7 7
t5 5 10
t6 18 1
t7 4 11
schedule(Ss, End) :-
length(Ss, 7),
Ds = [16, 6, 13, 7, 5, 18, 4],
Rs = [ 2, 9, 3, 7, 10, 1, 11],
domain(Ss, 0, 51),
domain([End], 0, 69),
after(Ss, Ds, End), % koncový čas
cumulative(Ss, Ds, Rs, 13),
Hana Rudová, Logické programování I, 17. května 2007 206 CLP(FD) v SICStus Prologu
Příklad: kumulativní rozvrhování
Vytvořte rozvrh pro následující
úlohy, tak aby nebyla překročena
kapacita 13 zdroje, a minimalizujte
celkovou dobu trvání
úloha doba trvání kapacita
t1 16 2
t2 6 9
t3 13 3
t4 7 7
t5 5 10
t6 18 1
t7 4 11
schedule(Ss, End) :-
length(Ss, 7),
Ds = [16, 6, 13, 7, 5, 18, 4],
Rs = [ 2, 9, 3, 7, 10, 1, 11],
domain(Ss, 0, 51),
domain([End], 0, 69),
after(Ss, Ds, End), % koncový čas
cumulative(Ss, Ds, Rs, 13),
append(Ss, [End], Vars),
labeling([minimize(End)], Vars).
Hana Rudová, Logické programování I, 17. května 2007 206 CLP(FD) v SICStus Prologu
Příklad: kumulativní rozvrhování
Vytvořte rozvrh pro následující
úlohy, tak aby nebyla překročena
kapacita 13 zdroje, a minimalizujte
celkovou dobu trvání
úloha doba trvání kapacita
t1 16 2
t2 6 9
t3 13 3
t4 7 7
t5 5 10
t6 18 1
t7 4 11
schedule(Ss, End) :-
length(Ss, 7),
Ds = [16, 6, 13, 7, 5, 18, 4],
Rs = [ 2, 9, 3, 7, 10, 1, 11],
domain(Ss, 0, 51),
domain([End], 0, 69),
after(Ss, Ds, End), % koncový čas
cumulative(Ss, Ds, Rs, 13),
append(Ss, [End], Vars),
labeling([minimize(End)], Vars).
after([], [], _).
after([S|Ss], [D|Ds], E) :-
E #>= S+D, after(Ss, Ds, E).
Hana Rudová, Logické programování I, 17. května 2007 206 CLP(FD) v SICStus Prologu
Příklad: kumulativní rozvrhování
Vytvořte rozvrh pro následující
úlohy, tak aby nebyla překročena
kapacita 13 zdroje, a minimalizujte
celkovou dobu trvání
úloha doba trvání kapacita
t1 16 2
t2 6 9
t3 13 3
t4 7 7
t5 5 10
t6 18 1
t7 4 11
schedule(Ss, End) :-
length(Ss, 7),
Ds = [16, 6, 13, 7, 5, 18, 4],
Rs = [ 2, 9, 3, 7, 10, 1, 11],
domain(Ss, 0, 51),
domain([End], 0, 69),
after(Ss, Ds, End), % koncový čas
cumulative(Ss, Ds, Rs, 13),
append(Ss, [End], Vars),
labeling([minimize(End)], Vars).
after([], [], _).
after([S|Ss], [D|Ds], E) :-
E #>= S+D, after(Ss, Ds, E).
| ?- schedule(Ss, End).
Ss = Ss = [0,16,9,9,4,4,0], End = 22 ?
Hana Rudová, Logické programování I, 17. května 2007 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 při backtrackingu ve vzrůstajícím pořadí
?- X in 4..5, indomain(X).
X = 4 ? ;
X = 5 ?
Hana Rudová, Logické programování I, 17. května 2007 207 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 při backtrackingu ve vzrůstajícím pořadí
?- X in 4..5, indomain(X).
X = 4 ? ;
X = 5 ?
labeling( [] ).
labeling( [Var|Rest] ) :- % výběr nejlevější proměnné k instanciaci
indomain( Var ), % výběr hodnot ve vzrůstajícím pořadí
labeling( Rest ).
Hana Rudová, Logické programování I, 17. května 2007 207 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 při backtrackingu ve vzrůstajícím pořadí
?- X in 4..5, indomain(X).
X = 4 ? ;
X = 5 ?
labeling( [] ).
labeling( [Var|Rest] ) :- % výběr nejlevější proměnné k instanciaci
indomain( Var ), % výběr hodnot ve vzrůstajícím pořadí
labeling( Rest ).
labeling( Options, Variables )
?- A in 0..2, B in 0..2, B#< A, labeling([], [A,B]).
Hana Rudová, Logické programování I, 17. května 2007 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
Určují je heuristiky výběru hodnot a výběru proměnných
labeling( [] ).
labeling( Variables ) :-
select_variable(Variables,Var,Rest),
select_value(Var,Value),
Hana Rudová, Logické programování I, 17. května 2007 208 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_variable(Variables,Var,Rest),
select_value(Var,Value),
( Var #= Value,
labeling( Rest )
Hana Rudová, Logické programování I, 17. května 2007 208 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_variable(Variables,Var,Rest),
select_value(Var,Value),
( Var #= Value,
labeling( Rest )
;
Var #\= Value , % nemusí dojít k instanciaci Var
labeling( Variables ) % proto pokračujeme se všemi proměnnými včetně Var
).
Hana Rudová, Logické programování I, 17. května 2007 208 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_variable(Variables,Var,Rest),
select_value(Var,Value),
( Var #= Value,
labeling( Rest )
;
Var #\= Value , % nemusí dojít k instanciaci Var
labeling( Variables ) % proto pokračujeme se všemi proměnnými včetně Var
).
Statické uspořádání: určeno už před prohledáváním
Dynamické uspořádání: počítá se během prohledávání
Hana Rudová, Logické programování I, 17. května 2007 208 CLP(FD) v SICStus Prologu
Výběr hodnoty
Obecný princip výběru hodnoty: první úspěch (succeed first)
volíme pořadí tak, abychom výběr nemuseli opakovat
?- domain([A,B,C],1,2), A#=B+C.
Hana Rudová, Logické programování I, 17. května 2007 209 CLP(FD) v SICStus Prologu
Výběr hodnoty
Obecný princip výběru hodnoty: první úspěch (succeed first)
volíme pořadí tak, abychom výběr nemuseli opakovat
?- domain([A,B,C],1,2), A#=B+C. optimální výběr A=2,B=1,C=1 je bez backtrackingu
Hana Rudová, Logické programování I, 17. května 2007 209 CLP(FD) v SICStus Prologu
Výběr hodnoty
Obecný princip výběru hodnoty: první úspěch (succeed first)
volíme pořadí tak, abychom výběr nemuseli opakovat
?- domain([A,B,C],1,2), A#=B+C. optimální výběr A=2,B=1,C=1 je bez backtrackingu
Parametry labeling/2 ovlivňující výběr hodnoty př. labeling([down], Vars)
up: doména procházena ve vzrůstajícím pořadí (default)
down: doména procházena v klesajícím pořadí
Hana Rudová, Logické programování I, 17. května 2007 209 CLP(FD) v SICStus Prologu
Výběr hodnoty
Obecný princip výběru hodnoty: první úspěch (succeed first)
volíme pořadí tak, abychom výběr nemuseli opakovat
?- domain([A,B,C],1,2), A#=B+C. optimální výběr A=2,B=1,C=1 je bez backtrackingu
Parametry labeling/2 ovlivňující výběr hodnoty př. labeling([down], Vars)
up: doména procházena ve vzrůstajícím pořadí (default)
down: doména procházena v klesajícím pořadí
Parametry labeling/2 řídící, jak je výběr hodnoty realizován
step: volba mezi X #= M, X #\= M (default)
viz dřívější příklad u "Uspořádání hodnot a proměnných"
enum: vícenásobná volba mezi všemi hodnotami v doméně
podobně jako při indomain/1
bisect: volba mezi X #=< Mid, X #> Mid
v jednom kroku labelingu nedochází nutně k instanciaci proměnné
Hana Rudová, Logické programování I, 17. května 2007 209 CLP(FD) v SICStus Prologu
Výběr proměnné
Obecný princip výběru proměnné: first-fail
výběr proměnné, pro kterou je nejobtížnější nalézt správnou hodnotu
pozdější výběr hodnoty pro tuto proměnnou by snadněji vedl k failu
výbereme proměnnou s nejmenší doménou
?- domain([A,B,C],1,3), A#<3, A#=B+C.
Hana Rudová, Logické programování I, 17. května 2007 210 CLP(FD) v SICStus Prologu
Výběr proměnné
Obecný princip výběru proměnné: first-fail
výběr proměnné, pro kterou je nejobtížnější nalézt správnou hodnotu
pozdější výběr hodnoty pro tuto proměnnou by snadněji vedl k failu
výbereme proměnnou s nejmenší doménou
?- domain([A,B,C],1,3), A#<3, A#=B+C. nejlépe je začít s výběrem A
Hana Rudová, Logické programování I, 17. května 2007 210 CLP(FD) v SICStus Prologu
Výběr proměnné
Obecný princip výběru proměnné: first-fail
výběr proměnné, pro kterou je nejobtížnější nalézt správnou hodnotu
pozdější výběr hodnoty pro tuto proměnnou by snadněji vedl k failu
výbereme proměnnou s nejmenší doménou
?- domain([A,B,C],1,3), A#<3, A#=B+C. nejlépe je začít s výběrem A
Parametry labeling/2 ovlivňující výběr proměnné
leftmost: nejlevější (default)
ff: s (a) nejmenší velikostí domény fd_size(Var,Size)
(b) nejlevější z nich
Hana Rudová, Logické programování I, 17. května 2007 210 CLP(FD) v SICStus Prologu
Výběr proměnné
Obecný princip výběru proměnné: first-fail
výběr proměnné, pro kterou je nejobtížnější nalézt správnou hodnotu
pozdější výběr hodnoty pro tuto proměnnou by snadněji vedl k failu
výbereme proměnnou s nejmenší doménou
?- domain([A,B,C],1,3), A#<3, A#=B+C. nejlépe je začít s výběrem A
Parametry labeling/2 ovlivňující výběr proměnné
leftmost: nejlevější (default)
ff: s (a) nejmenší velikostí domény fd_size(Var,Size)
(b) nejlevější z nich
ffc: s (a) nejmenší velikostí domény
(b) největším množstvím omezením ,,čekajících" na proměnné fd_degree(Var,Size)
(c) nejlevější z nich
min/max: s (a) nejmenší/největší hodnotou v doméně proměnné
(b) nejlevnější z nich fd_min(Var,Min)/fd_max(Var,Max)
Hana Rudová, Logické programování I, 17. května 2007 210 CLP(FD) v SICStus Prologu
Hledání optimálního řešení (předpokládejme minimalizaci)
Parametry labeling/2 pro optimalizaci: minimize(F)/maximize(F)
Cena #= A+B+C, labeling([minimize(Cena)], [A,B,C])
Metoda větví a mezí (branch&bound)
uvažujeme nejhorší možnou cenu řešení UB (např. cena už nalezeného řešení)
počítáme dolní odhad LB ceny částečného řešení
LB je tedy nejlepší možná cena pro rozšíření tohoto řešení
procházíme strom a vyžadujeme, aby prozkoumávaná větev měla cenu LB < UB
pokud je LB  UB, tak víme, že v této větvi není lepší řešení a odřízneme ji
Hana Rudová, Logické programování I, 17. května 2007 211 CLP(FD) v SICStus Prologu
Hledání optimálního řešení (předpokládejme minimalizaci)
Parametry labeling/2 pro optimalizaci: minimize(F)/maximize(F)
Cena #= A+B+C, labeling([minimize(Cena)], [A,B,C])
Metoda větví a mezí (branch&bound)
uvažujeme nejhorší možnou cenu řešení UB (např. cena už nalezeného řešení)
počítáme dolní odhad LB ceny částečného řešení
LB je tedy nejlepší možná cena pro rozšíření tohoto řešení
procházíme strom a vyžadujeme, aby prozkoumávaná větev měla cenu LB < UB
pokud je LB  UB, tak víme, že v této větvi není lepší řešení a odřízneme ji
Hana Rudová, Logické programování I, 17. května 2007 211 CLP(FD) v SICStus Prologu
Algoritmy pro řešení
problému splňování podmínek (CSP)
Grafová reprezentace CSP
Reprezentace podmínek
intenzionální (matematická/logická formule)
extenzionální (výčet k-tic kompatibilních hodnot, 0-1 matice)
Hana Rudová, Logické programování I, 17. května 2007 213 Algoritmy pro CSP
Grafová reprezentace CSP
Reprezentace podmínek
intenzionální (matematická/logická formule)
extenzionální (výčet k-tic kompatibilních hodnot, 0-1 matice)
Graf: vrcholy, hrany (hrana spojuje dva vrcholy)
Hypergraf: vrcholy, hrany (hrana spojuje množinu vrcholů)
Reprezentace CSP pomocí hypergrafu podmínek
vrchol = proměnná, hyperhrana = podmínka
Hana Rudová, Logické programování I, 17. května 2007 213 Algoritmy pro CSP
Grafová reprezentace CSP
Reprezentace podmínek
intenzionální (matematická/logická formule)
extenzionální (výčet k-tic kompatibilních hodnot, 0-1 matice)
Graf: vrcholy, hrany (hrana spojuje dva vrcholy)
Hypergraf: vrcholy, hrany (hrana spojuje množinu vrcholů)
Reprezentace CSP pomocí hypergrafu podmínek
vrchol = proměnná, hyperhrana = podmínka
Příklad
proměnné 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, 17. května 2007 213 Algoritmy pro CSP
Binární CSP
Binární CSP
CSP, ve kterém jsou pouze binární podmínky
unární podmínky zakódovány do domény proměnné
Graf podmínek pro binární CSP
není nutné uvažovat hypergraf, stačí graf (podmínka spojuje pouze dva vrcholy)
Hana Rudová, Logické programování I, 17. května 2007 214 Algoritmy pro CSP
Binární CSP
Binární CSP
CSP, ve kterém jsou pouze binární podmínky
unární podmínky zakódovány do domény proměnné
Graf podmínek pro binární CSP
není nutné uvažovat hypergraf, stačí graf (podmínka spojuje pouze dva vrcholy)
Každý CSP lze transformovat na "korespondující" binární CSP
Výhody a nevýhody binarizace
získáváme unifikovaný tvar CSP problému, řada algoritmů navržena pro binární CSP
bohužel ale značné zvětšení velikosti problému
Hana Rudová, Logické programování I, 17. května 2007 214 Algoritmy pro CSP
Binární CSP
Binární CSP
CSP, ve kterém jsou pouze binární podmínky
unární podmínky zakódovány do domény proměnné
Graf podmínek pro binární CSP
není nutné uvažovat hypergraf, stačí graf (podmínka spojuje pouze dva vrcholy)
Každý CSP lze transformovat na "korespondující" binární CSP
Výhody a nevýhody binarizace
získáváme unifikovaný tvar CSP problému, řada algoritmů navržena pro binární CSP
bohužel ale značné zvětšení velikosti problému
Nebinární podmínky
složitější propagační algoritmy
lze využít jejich sémantiky pro lepší propagaci
příklad: all_different vs. množina binárních nerovností
Hana Rudová, Logické programování I, 17. května 2007 214 Algoritmy pro CSP
Vrcholová a hranová konzistence
Vrcholová konzistence (node consistency) NC
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, 17. května 2007 215 Algoritmy pro CSP
Vrcholová a hranová konzistence
Vrcholová konzistence (node consistency) NC
každá hodnota z aktuální domény Vi proměnné splňuje všechny unární
podmínky s proměnnou Vi
Hranová konzistence (arc consistency) AC pro binární CSP
hrana (Vi, Vj) je hranově konzistentní, právě když
pro každou hodnotu x z aktuální domény Di existuje hodnota y tak, že
ohodnocení [Vi = x, Vj = y] splňuje všechny binární podmínky nad Vi, Vj.
Hana Rudová, Logické programování I, 17. května 2007 215 Algoritmy pro CSP
Vrcholová a hranová konzistence
Vrcholová konzistence (node consistency) NC
každá hodnota z aktuální domény Vi proměnné splňuje všechny unární
podmínky s proměnnou Vi
Hranová konzistence (arc consistency) AC pro binární CSP
hrana (Vi, Vj) je hranově konzistentní, právě když
pro každou hodnotu x z aktuální domény Di existuje hodnota y tak, že
ohodnocení [Vi = x, Vj = y] splňuje všechny binární podmínky nad Vi, Vj.
hranová konzistence je směrová
konzistence hrany (Vi, Vj) nezaručuje konzistenci hrany (Vj, Vi)
1..5 B
A<B A<B
A 3..4 4..5 BA 3..4
konzistence (A,B) konzistence (A,B) i (B,A)
A 3..7 1..5 B
A<B
Hana Rudová, Logické programování I, 17. května 2007 215 Algoritmy pro CSP
Vrcholová a hranová konzistence
Vrcholová konzistence (node consistency) NC
každá hodnota z aktuální domény Vi proměnné splňuje všechny unární
podmínky s proměnnou Vi
Hranová konzistence (arc consistency) AC pro binární CSP
hrana (Vi, Vj) je hranově konzistentní, právě když
pro každou hodnotu x z aktuální domény Di existuje hodnota y tak, že
ohodnocení [Vi = x, Vj = y] splňuje všechny binární podmínky nad Vi, Vj.
hranová konzistence je směrová
konzistence hrany (Vi, Vj) nezaručuje konzistenci hrany (Vj, Vi)
1..5 B
A<B A<B
A 3..4 4..5 BA 3..4
konzistence (A,B) konzistence (A,B) i (B,A)
A 3..7 1..5 B
A<B
CSP je hranově konzistentní, právě když
jsou všechny jeho hrany (v obou směrech) hranově konzistentní
Hana Rudová, Logické programování I, 17. května 2007 215 Algoritmy pro CSP
Je hranová konzistence dostatečná?
Použitím AC odstraníme mnoho nekompatibilních hodnot
Dostaneme potom řešení problému? NE
Víme alespoň zda řešení existuje? NE
Hana Rudová, Logické programování I, 17. května 2007 216 Algoritmy pro CSP
Je hranová konzistence dostatečná?
Použitím AC odstraníme mnoho nekompatibilních hodnot
Dostaneme potom řešení problému? NE
Víme alespoň zda řešení existuje? NE
domain([X,Y,Z],1,2), X#\= Y, Y#\= Z, Z#\= X
hranově konzistentní
nemá žádné řešení
Hana Rudová, Logické programování I, 17. května 2007 216 Algoritmy pro CSP
Je hranová konzistence dostatečná?
Použitím AC odstraníme mnoho nekompatibilních hodnot
Dostaneme potom řešení problému? NE
Víme alespoň zda řešení existuje? NE
domain([X,Y,Z],1,2), X#\= Y, Y#\= Z, Z#\= X
hranově konzistentní
nemá žádné řešení
Jaký je tedy význam AC?
někdy dá řešení přímo
nějaká doména se vyprázdní  řešení neexistuje
všechny domény jsou jednoprvkové  máme řešení
v obecném případě se alespoň zmenší prohledávaný prostor
Hana Rudová, Logické programování I, 17. května 2007 216 Algoritmy pro CSP
Řešení nebinárních podmínek
S n-árními podmínkami se pracuje přímo
Podmínka je obecně hranově konzistentní (GAC), právě když pro každou
proměnnou Vi z této podmínky a každou hodnou x  Di existuje ohodnocení
zbylých proměnných v podmínce tak, že podmínka platí
A + B = C, A in 1..3, B in 2..4, C in 3..7 je obecně hranově konzistentní
Hana Rudová, Logické programování I, 17. května 2007 217 Algoritmy pro CSP
Řešení nebinárních podmínek
S n-árními podmínkami se pracuje přímo
Podmínka je obecně hranově konzistentní (GAC), právě když pro každou
proměnnou Vi z této podmínky a každou hodnou x  Di existuje ohodnocení
zbylých proměnných v podmínce tak, že podmínka platí
A + B = C, A in 1..3, B in 2..4, C in 3..7 je obecně hranově konzistentní
Využívá se sémantika podmínek
speciální typy konzistence pro globální omezení
viz all_distinct
konzistence mezí
propagace pouze při změně nejmenší a největší hodnoty v doméně proměnné
Pro různé podmínky lze použít různý druh konzistence
A#<B: hranová konzistence, konzistence mezí
Hana Rudová, Logické programování I, 17. května 2007 217 Algoritmy pro CSP
Konzistenční algoritmus pro nebinární podmínky
Algoritmus s frontou proměnných (někdy též nazýván AC-8)
opakovaně se provádí revize podmínek, dokud se mění domény
procedure Nonbinary-AC-3-with-Variables(Q)
while Q non empty do
vyber a smaž Vj  Q
for  C takové, že Vj  scope(C) do
W := revise(Vj, C)
// W je množina proměnných jejichž, doména se změnila
if  Vi  W taková, že Di =  then return fail
Q := Q  {W}
end Non-binary-consistency
rozsah omezení scope(C): množina proměnných, na nichž je C definováno
Hana Rudová, Logické programování I, 17. května 2007 218 Algoritmy pro CSP
Konzistenční algoritmus pro nebinární podmínky
Algoritmus s frontou proměnných (někdy též nazýván AC-8)
opakovaně se provádí revize podmínek, dokud se mění domény
procedure Nonbinary-AC-3-with-Variables(Q)
while Q non empty do
vyber a smaž Vj  Q
for  C takové, že Vj  scope(C) do
W := revise(Vj, C)
// W je množina proměnných jejichž, doména se změnila
if  Vi  W taková, že Di =  then return fail
Q := Q  {W}
end Non-binary-consistency
rozsah omezení scope(C): množina proměnných, na nichž je C definováno
Implementace
u každé proměnné je seznam vybraných podmínek pro propagaci
REVISE procedury pro tyto podmínky definuje uživatel v závislosti na typu podmínky
Hana Rudová, Logické programování I, 17. května 2007 218 Algoritmy pro CSP
Revize podmínky pro hranovou konzistenci
Jak udělat podmínku c(Vj, Vi) na hraně (Vj, Vi) hranově konzistentní vůči Vj?
Z domény Dj vyřadím takové hodnoty x, které nejsou konzistentní s aktuální
doménou Di (pro x neexistuje žádá hodnoty y v Di tak, aby ohodnocení
Vj = x a Vi = y splňovalo binární podmínku c(Vj, Vi) mezi Vj a Vi)
Hana Rudová, Logické programování I, 17. května 2007 219 Algoritmy pro CSP
Revize podmínky pro hranovou konzistenci
Jak udělat podmínku c(Vj, Vi) na hraně (Vj, Vi) hranově konzistentní vůči Vj?
Z domény Dj vyřadím takové hodnoty x, které nejsou konzistentní s aktuální
doménou Di (pro x neexistuje žádá hodnoty y v Di tak, aby ohodnocení
Vj = x a Vi = y splňovalo binární podmínku c(Vj, Vi) mezi Vj a Vi)
procedure revise(Vj,c(Vj, Vi))
Deleted := false
for  x in Dj do
if neexistuje y  Di takové, že (x, y) je konzistentní
then Dj := Dj - {x}
Deleted := true
end if
return Deleted
end revise
Hana Rudová, Logické programování I, 17. května 2007 219 Algoritmy pro CSP
Revize podmínky pro hranovou konzistenci
Jak udělat podmínku c(Vj, Vi) na hraně (Vj, Vi) hranově konzistentní vůči Vj?
Z domény Dj vyřadím takové hodnoty x, které nejsou konzistentní s aktuální
doménou Di (pro x neexistuje žádá hodnoty y v Di tak, aby ohodnocení
Vj = x a Vi = y splňovalo binární podmínku c(Vj, Vi) mezi Vj a Vi)
procedure revise(Vj,c(Vj, Vi))
Deleted := false
for  x in Dj do
if neexistuje y  Di takové, že (x, y) je konzistentní
then Dj := Dj - {x}
Deleted := true
end if
return Deleted
end revise
domain([V1, V2],2,4), V1#< V2
Hana Rudová, Logické programování I, 17. května 2007 219 Algoritmy pro CSP
Revize podmínky pro hranovou konzistenci
Jak udělat podmínku c(Vj, Vi) na hraně (Vj, Vi) hranově konzistentní vůči Vj?
Z domény Dj vyřadím takové hodnoty x, které nejsou konzistentní s aktuální
doménou Di (pro x neexistuje žádá hodnoty y v Di tak, aby ohodnocení
Vj = x a Vi = y splňovalo binární podmínku c(Vj, Vi) mezi Vj a Vi)
procedure revise(Vj,c(Vj, Vi))
Deleted := false
for  x in Dj do
if neexistuje y  Di takové, že (x, y) je konzistentní
then Dj := Dj - {x}
Deleted := true
end if
return Deleted
end revise
domain([V1, V2],2,4), V1#< V2 revise(V1, V1#< V2) smaže 4 z D1,
Hana Rudová, Logické programování I, 17. května 2007 219 Algoritmy pro CSP
Revize podmínky pro hranovou konzistenci
Jak udělat podmínku c(Vj, Vi) na hraně (Vj, Vi) hranově konzistentní vůči Vj?
Z domény Dj vyřadím takové hodnoty x, které nejsou konzistentní s aktuální
doménou Di (pro x neexistuje žádá hodnoty y v Di tak, aby ohodnocení
Vj = x a Vi = y splňovalo binární podmínku c(Vj, Vi) mezi Vj a Vi)
procedure revise(Vj,c(Vj, Vi))
Deleted := false
for  x in Dj do
if neexistuje y  Di takové, že (x, y) je konzistentní
then Dj := Dj - {x}
Deleted := true
end if
return Deleted
end revise
domain([V1, V2],2,4), V1#< V2 revise(V1, V1#< V2) smaže 4 z D1,D2 se nezmění
Hana Rudová, Logické programování I, 17. května 2007 219 Algoritmy pro CSP
Konzistence mezí
Bounds consistency BC: slabší než obecná hranová konzistence
podmínka má konzistentní meze (BC), právě když pro každou proměnnou
Vj z této podmínky a každou hodnou x  Dj existuje ohodnocení zbylých
proměnných v podmínce tak, že je podmínka splněna a pro vybrané
ohodnocení yi proměnné Vi platí min(Di)  yi  max(Di)
Hana Rudová, Logické programování I, 17. května 2007 220 Algoritmy pro CSP
Konzistence mezí
Bounds consistency BC: slabší než obecná hranová konzistence
podmínka má konzistentní meze (BC), právě když pro každou proměnnou
Vj z této podmínky a každou hodnou x  Dj existuje ohodnocení zbylých
proměnných v podmínce tak, že je podmínka splněna a pro vybrané
ohodnocení yi proměnné Vi platí min(Di)  yi  max(Di)
stačí propagace pouze při změně minimální nebo maximální hodnoty
(při změně mezí) v doméně proměnné
Konzistence mezí pro nerovnice
A #> B => min(A) = min(B)+1, max(B) = max(A)-1
pří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, 17. května 2007 220 Algoritmy pro CSP
Konzistence mezí
Bounds consistency BC: slabší než obecná hranová konzistence
podmínka má konzistentní meze (BC), právě když pro každou proměnnou
Vj z této podmínky a každou hodnou x  Dj existuje ohodnocení zbylých
proměnných v podmínce tak, že je podmínka splněna a pro vybrané
ohodnocení yi proměnné Vi platí min(Di)  yi  max(Di)
stačí propagace pouze při změně minimální nebo maximální hodnoty
(při změně mezí) v doméně proměnné
Konzistence mezí pro nerovnice
A #> B => min(A) = min(B)+1, max(B) = max(A)-1
pří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
podobně: A #< B, A #>= B, A #=< B
Hana Rudová, Logické programování I, 17. května 2007 220 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, 17. května 2007 221 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)
změna min(A)vyvolá pouze změnu min(B) a min(C)
změna max(A)vyvolá pouze změnu max(B) a max(C), ...
Hana Rudová, Logické programování I, 17. května 2007 221 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)
změna min(A)vyvolá pouze změnu min(B) a min(C)
změna max(A)vyvolá pouze změnu max(B) a max(C), ...
Pří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, 17. května 2007 221 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)
změna min(A)vyvolá pouze změnu min(B) a min(C)
změna max(A)vyvolá pouze změnu max(B) a max(C), ...
Pří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, 17. května 2007 221 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)
změna min(A)vyvolá pouze změnu min(B) a min(C)
změna max(A)vyvolá pouze změnu max(B) a max(C), ...
Pří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, 17. května 2007 221 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)
změna min(A)vyvolá pouze změnu min(B) a min(C)
změna max(A)vyvolá pouze změnu max(B) a max(C), ...
Pří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, 17. května 2007 221 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)
změna min(A)vyvolá pouze změnu min(B) a min(C)
změna max(A)vyvolá pouze změnu max(B) a max(C), ...
Pří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)
Vyzkoušejte si: A #= B - C, A #>= B + C
Hana Rudová, Logické programování I, 17. května 2007 221 Algoritmy pro CSP
Globální podmínky
Propagace je lokální
pracuje se s jednotlivými podmínkami
interakce mezi podmínkami je pouze přes domény proměnných
Jak dosáhnout více, když je silnější propagace drahá?
Seskupíme několik podmínek do jedné tzv. globální podmínky
Propagaci přes globální podmínku řešíme
speciálním algoritmem navrženým pro danou podmínku
Příklady:
all_different omezení: hodnoty všech proměnných různé
serialized omezení:
rozvržení úloh zadaných startovním časem a dobou trvání tak, aby se nepřekrývaly
Hana Rudová, Logické programování I, 17. května 2007 222 Algoritmy pro CSP
Propagace pro all_distinct
U = {X2, X4, X5}, dom(U) = {2, 3, 4}: učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
{2,3,4} nelze pro X1, X3, X6
Hana Rudová, Logické programování I, 17. května 2007 223 Algoritmy pro CSP
Propagace pro all_distinct
U = {X2, X4, X5}, dom(U) = {2, 3, 4}: učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
{2,3,4} nelze pro X1, X3, X6
X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6)
Hana Rudová, Logické programování I, 17. května 2007 223 Algoritmy pro CSP
Propagace pro all_distinct
U = {X2, X4, X5}, dom(U) = {2, 3, 4}: učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
{2,3,4} nelze pro X1, X3, X6
X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6)
Konzistence: {X1, . . . , Xk}  V : card{D1      Dk}  k
Hana Rudová, Logické programování I, 17. května 2007 223 Algoritmy pro CSP
Propagace pro all_distinct
U = {X2, X4, X5}, dom(U) = {2, 3, 4}: učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
{2,3,4} nelze pro X1, X3, X6
X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6)
Konzistence: {X1, . . . , Xk}  V : card{D1      Dk}  k
stačí hledat Hallův interval I: velikost intervalu I je rovna
počtu proměnných, jejichž doména je v I
Hana Rudová, Logické programování I, 17. května 2007 223 Algoritmy pro CSP
Propagace pro all_distinct
U = {X2, X4, X5}, dom(U) = {2, 3, 4}: učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
{2,3,4} nelze pro X1, X3, X6
X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6)
Konzistence: {X1, . . . , Xk}  V : card{D1      Dk}  k
stačí hledat Hallův interval I: velikost intervalu I je rovna
počtu proměnných, jejichž doména je v I
Inferenční pravidlo
U = {X1, . . . , Xk}, dom(U) = {D1      Dk}
card(U) = card(dom(U))  v  dom(U), X  (V - U), X = v
Hana Rudová, Logické programování I, 17. května 2007 223 Algoritmy pro CSP
Propagace pro all_distinct
U = {X2, X4, X5}, dom(U) = {2, 3, 4}: učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
{2,3,4} nelze pro X1, X3, X6
X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6)
Konzistence: {X1, . . . , Xk}  V : card{D1      Dk}  k
stačí hledat Hallův interval I: velikost intervalu I je rovna
počtu proměnných, jejichž doména je v I
Inferenční pravidlo
U = {X1, . . . , Xk}, dom(U) = {D1      Dk}
card(U) = card(dom(U))  v  dom(U), X  (V - U), X = v
hodnoty v Hallově intervalu jsou pro ostatní proměnné nedostupné
Hana Rudová, Logické programování I, 17. května 2007 223 Algoritmy pro CSP
Propagace pro all_distinct
U = {X2, X4, X5}, dom(U) = {2, 3, 4}: učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
{2,3,4} nelze pro X1, X3, X6
X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6)
Konzistence: {X1, . . . , Xk}  V : card{D1      Dk}  k
stačí hledat Hallův interval I: velikost intervalu I je rovna
počtu proměnných, jejichž doména je v I
Inferenční pravidlo
U = {X1, . . . , Xk}, dom(U) = {D1      Dk}
card(U) = card(dom(U))  v  dom(U), X  (V - U), X = v
hodnoty v Hallově intervalu jsou pro ostatní proměnné nedostupné
Složitost: O(2n
) ­ hledání všech podmnožin množiny n proměnných (naivní)
Hana Rudová, Logické programování I, 17. května 2007 223 Algoritmy pro CSP
Propagace pro all_distinct
U = {X2, X4, X5}, dom(U) = {2, 3, 4}: učitel min max
Jan 3 6
Petr 3 4
Anna 2 5
Ota 2 4
Eva 3 4
Marie 1 6
{2,3,4} nelze pro X1, X3, X6
X1 in 5..6, X3 = 5, X6 in {1} \/ (5..6)
Konzistence: {X1, . . . , Xk}  V : card{D1      Dk}  k
stačí hledat Hallův interval I: velikost intervalu I je rovna
počtu proměnných, jejichž doména je v I
Inferenční pravidlo
U = {X1, . . . , Xk}, dom(U) = {D1      Dk}
card(U) = card(dom(U))  v  dom(U), X  (V - U), X = v
hodnoty v Hallově intervalu jsou pro ostatní proměnné nedostupné
Složitost: O(2n
) ­ hledání všech podmnožin množiny n proměnných (naivní)
O(n log n) ­ kontrola hraničních bodů Hallových intervalů (1998)
Hana Rudová, Logické programování I, 17. května 2007 223 Algoritmy pro CSP
Prohledávání + konzistence
Splňování podmínek prohledáváním prostoru řešení
podmínky jsou užívány pasivně jako test
přiřazuji hodnoty proměnných a zkouším co se stane
vestavěný prohledávací algoritmus Prologu: backtracking, triviální: generuj & testuj
Hana Rudová, Logické programování I, 17. května 2007 224 Algoritmy pro CSP
Prohledávání + konzistence
Splňování podmínek prohledáváním prostoru řešení
podmínky jsou užívány pasivně jako test
přiřazuji hodnoty proměnných a zkouším co se stane
vestavěný prohledávací algoritmus Prologu: backtracking, triviální: generuj & testuj
úplná metoda (nalezneme řešení nebo dokážeme jeho neexistenci)
zbytečně pomalé (exponenciální): procházím i ,,evidentně" špatná ohodnocení
Hana Rudová, Logické programování I, 17. května 2007 224 Algoritmy pro CSP
Prohledávání + konzistence
Splňování podmínek prohledáváním prostoru řešení
podmínky jsou užívány pasivně jako test
přiřazuji hodnoty proměnných a zkouším co se stane
vestavěný prohledávací algoritmus Prologu: backtracking, triviální: generuj & testuj
úplná metoda (nalezneme řešení nebo dokážeme jeho neexistenci)
zbytečně pomalé (exponenciální): procházím i ,,evidentně" špatná ohodnocení
Konzistenční (propagační) techniky
umožňují odstranění nekonzistentních hodnot z domény proměnných
neúplná metoda (v doméně zůstanou ještě nekonzistentní hodnoty)
relativně rychlé (polynomiální)
Hana Rudová, Logické programování I, 17. května 2007 224 Algoritmy pro CSP
Prohledávání + konzistence
Splňování podmínek prohledáváním prostoru řešení
podmínky jsou užívány pasivně jako test
přiřazuji hodnoty proměnných a zkouším co se stane
vestavěný prohledávací algoritmus Prologu: backtracking, triviální: generuj & testuj
úplná metoda (nalezneme řešení nebo dokážeme jeho neexistenci)
zbytečně pomalé (exponenciální): procházím i ,,evidentně" špatná ohodnocení
Konzistenční (propagační) techniky
umožňují odstranění nekonzistentních hodnot z domény proměnných
neúplná metoda (v doméně zůstanou ještě nekonzistentní hodnoty)
relativně rychlé (polynomiální)
Používá se kombinace obou metod
postupné přiřazování hodnot proměnným
po přiřazení hodnoty odstranění nekonzistentních hodnot konzistenčními technikami
Hana Rudová, Logické programování I, 17. května 2007 224 Algoritmy pro CSP
Prohledávání s navracením
Základní prohledávací algoritmus pro problémy splňování podmínek
Prohledávání stavového prostoru do hloubky
Dvě fáze prohledávání s navracením
dopředná fáze: proměnné jsou postupně vybírány, rozšiřuje se částečné
řešení přiřazením konzistení hodnoty (pokud existuje) další proměnné
po vybrání hodnoty testujeme konzistenci
zpětná fáze: pokud neexistuje konzistentní hodnota pro aktuální
proměnnou, algoritmus se vrací k předchozí přiřazené hodnotě
Hana Rudová, Logické programování I, 17. května 2007 225 Algoritmy pro CSP
Prohledávání s navracením
Základní prohledávací algoritmus pro problémy splňování podmínek
Prohledávání stavového prostoru do hloubky
Dvě fáze prohledávání s navracením
dopředná fáze: proměnné jsou postupně vybírány, rozšiřuje se částečné
řešení přiřazením konzistení hodnoty (pokud existuje) další proměnné
po vybrání hodnoty testujeme konzistenci
zpětná fáze: pokud neexistuje konzistentní hodnota pro aktuální
proměnnou, algoritmus se vrací k předchozí přiřazené hodnotě
Proměnné dělíme na
minulé ­ proměnné, které už byly vybrány (a mají přiřazenu hodnotu)
aktuální ­ proměnná, která je právě vybrána a je jí přiřazována hodnota
budoucí ­ proměnné, které budou vybrány v budoucnosti
Hana Rudová, Logické programování I, 17. května 2007 225 Algoritmy pro CSP
Přehled algoritmů
prirazene
(minule)
neprirazene
(budouci)
7
6
1
2
3
5
promenne
a aktualni4
n
FC
LA
BT
Backtracking (BT) kontroluje v kroku a podmínky
c(V1, Va), . . . , c(Va-1, Va)
z minulých proměnných do aktuální proměnné
Hana Rudová, Logické programování I, 17. května 2007 226 Algoritmy pro CSP
Přehled algoritmů
prirazene
(minule)
neprirazene
(budouci)
7
6
1
2
3
5
promenne
a aktualni4
n
FC
LA
BT
Backtracking (BT) kontroluje v kroku a podmínky
c(V1, 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, Va+1), . . . , c(Va, Vn)
z aktuální proměnné do budoucích proměnných
Hana Rudová, Logické programování I, 17. května 2007 226 Algoritmy pro CSP
Přehled algoritmů
prirazene
(minule)
neprirazene
(budouci)
7
6
1
2
3
5
promenne
a aktualni4
n
FC
LA
BT
Backtracking (BT) kontroluje v kroku a podmínky
c(V1, 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, Va+1), . . . , c(Va, Vn)
z aktuální proměnné do budoucích proměnných
Pohled dopředu (LA) kontroluje v kroku a podmínky
l(a  l  n), k(a  k  n), k = l : c(Vk, Vl)
z aktuální proměnné do budoucích proměnných
a mezi budoucími proměnnými
Hana Rudová, Logické programování I, 17. května 2007 226 Algoritmy pro CSP
Základní algoritmus prohledávání s navracením
Pro jednoduchost proměnné očíslujeme a ohodnocujeme je v daném pořadí
Na začátku voláno jako labeling(G,1)
procedure labeling(G,a)
if a > |uzly(G)| then return uzly(G)
for  x  Da do
if consistent(G,a) then % consistent(G,a) je nahrazeno FC, LA, ...
R := labeling(G,a + 1)
if R = fail then return R
return fail
end labeling
Po přiřazení všech proměnných vrátíme jejich ohodnocení
Procedury consistent uvedeme pouze pro binární podmínky
Hana Rudová, Logické programování I, 17. května 2007 227 Algoritmy pro CSP
Backtracking (BT)
Backtracking ověřuje v každém kroku konzistenci podmínek vedoucích
z minulých proměnných do aktuální proměnné
Backtracking tedy zajišt'uje konzistenci podmínek
na všech minulých proměnných
na podmínkách mezi minulými proměnnými a aktuální proměnnou
Hana Rudová, Logické programování I, 17. května 2007 228 Algoritmy pro CSP
Backtracking (BT)
Backtracking ověřuje v každém kroku konzistenci podmínek vedoucích
z minulých proměnných do aktuální proměnné
Backtracking tedy zajišt'uje konzistenci podmínek
na všech minulých proměnných
na podmínkách mezi minulými proměnnými a aktuální proměnnou
procedure BT(G,a)
Q:={(Vi, Va)  hrany(G), i < a} % hrany vedoucí do minulých proměnných
Consistent := true
while Q není prázdná  Consistent do
vyber a smaž libovolnou hranu (Vk, Vm) z Q
Consistent := not revise(Vk, Vm) % pokud vyřadíme prvek, bude doména prázdná
return Consistent
end BT
Hana Rudová, Logické programování I, 17. května 2007 228 Algoritmy pro CSP
Příklad: backtracking
Omezení: V1, V2, V3 in 1 . . . 3, V1# = 3 × V3
Stavový prostor:
V3
V1
V2
 
 

1 2 3 1 2 31 2 3
1 2 3
1 2 31 2 3
1 2 3 1 2 31 2 31 2 3 1 2 31 2 3
1 2 3
červené čtverečky: chybný pokus o instanciaci, řešení neexistuje
nevyplněná kolečka: nalezeno řešení
černá kolečka: vnitřní uzel, máme pouze částečné přiřazení
Hana Rudová, Logické programování I, 17. května 2007 229 Algoritmy pro CSP
Kontrola dopředu (FC ­ forward checking)
FC je rozšíření backtrackingu
FC navíc zajišt'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, 17. května 2007 230 Algoritmy pro CSP
Kontrola dopředu (FC ­ forward checking)
FC je rozšíření backtrackingu
FC navíc zajišt'uje konzistenci mezi aktuální proměnnou a budoucími
proměnnými, které jsou s ní spojeny dosud nesplněnými podmínkami
procedure FC(G,a)
Q:={(Vi, Va)  hrany(G), i > a} % přidání hran z aktuální proměnné do budoucích prom.
Consistent := true
while Q není prázdná  Consistent do
vyber a smaž libovolnou hranu (Vk, Vm) z Q
if revise((Vk, Vm)) then
Consistent := (|Dk| > 0) % vyprázdnění domény znamená nekonzistenci
return Consistent
end FC
Hrany z aktuální proměnné do minulých proměnných není nutno testovat
Hana Rudová, Logické programování I, 17. května 2007 230 Algoritmy pro CSP
Příklad: kontrola dopředu
Omezení: V1, V2, V3 in 1 . . . 3, V1# = 3 × V3
Stavový prostor:
1 2 3
V3
V1
V2
1 11
1 2 3
Hana Rudová, Logické programování I, 17. května 2007 231 Algoritmy pro CSP
Pohled dopředu (LA ­ looking ahead)
LA je rozšíření FC, LA zajišt'uje hranovou konzistenci
LA navíc ověřuje i konzistenci všech hran mezi budoucími proměnnými
procedure LA(G,a)
Q := {(Vi, Va)  hrany(G), i > a} % začínáme s hranami do a
Consistent := true
while Q není prázdná  Consistent do
vyber a smaž libovolnou hranu (Vk, Vm) z Q
if revise((Vk, Vm)) then
Q := Q  {(Vi, Vk)|(Vi, Vk)  hrany(G), i = k, i = m, i > a}
Consistent := (|Dk| > 0)
return Consistent
end LA
Hana Rudová, Logické programování I, 17. května 2007 232 Algoritmy pro CSP
Pohled dopředu (LA ­ looking ahead)
LA je rozšíření FC, LA zajišt'uje hranovou konzistenci
LA navíc ověřuje i konzistenci všech hran mezi budoucími proměnnými
procedure LA(G,a)
Q := {(Vi, Va)  hrany(G), i > a} % začínáme s hranami do a
Consistent := true
while Q není prázdná  Consistent do
vyber a smaž libovolnou hranu (Vk, Vm) z Q
if revise((Vk, Vm)) then
Q := Q  {(Vi, Vk)|(Vi, Vk)  hrany(G), i = k, i = m, i > a}
Consistent := (|Dk| > 0)
return Consistent
end LA
Hrany z aktuální proměnné do minulých proměnných opět netestujeme
Hana Rudová, Logické programování I, 17. května 2007 232 Algoritmy pro CSP
Příklad: pohled dopředu
Omezení: V1, V2, V3 in 1 . . . 4, V1# > V2, V2# = 3 × V3
Stavový prostor:
V3
V1
V2
1 2 3 4
3
1
Hana Rudová, Logické programování I, 17. května 2007 233 Algoritmy pro CSP
Implementace Prologu
Literatura:
Matyska L., Toman D.: Implementační techniky Prologu , Informační systémy,
(1990), 21­59. http://www.ics.muni.cz/people/matyska/vyuka/lp/lp.
html
Opakování: základní pojmy
Konečná množina klauzulí Hlava :- Tělo tvoří program P.
Hlava je literál
Tělo je (eventuálně prázdná) konjunkce literálů T1, . . . Ta, a  0
Literál
je tvořen m-árním predikátovým symbolem (m/p) a m termy (argumenty)
Term je konstanta, proměnná nebo složený term.
Složený term
a n termy na místě argumentů
Dotaz (cíl) je neprázdná množina literálů.
Hana Rudová, Logické programování I, 17. května 2007 235 Implementace Prologu
Interpretace
Deklarativní sémantika:
Hlava platí, platí-li jednotlivé literály těla.
Hana Rudová, Logické programování I, 17. května 2007 236 Implementace Prologu
Interpretace
Deklarativní sémantika:
Hlava platí, platí-li jednotlivé literály těla.
Procedurální (imperativní) sémantika:
Entry: Hlava::
{
call T1
...
call Ta
}
Volání procedury s názvem Hlava uspěje, pokud uspěje volání všech procedur
(literálů) v těle.
Hana Rudová, Logické programování I, 17. května 2007 236 Implementace Prologu
Interpretace
Deklarativní sémantika:
Hlava platí, platí-li jednotlivé literály těla.
Procedurální (imperativní) sémantika:
Entry: Hlava::
{
call T1
...
call Ta
}
Volání procedury s názvem Hlava uspěje, pokud uspěje volání všech procedur
(literálů) v těle.
Procedurální sémantika = podklad pro implementaci
Hana Rudová, Logické programování I, 17. května 2007 236 Implementace Prologu
Abstraktní interpret
Vstup: Logický program P a dotaz G.
1. Inicializuj množinu cílů S literály z dotazu G; S:=G
2. while ( S != empty ) do
3. Vyber AS a dále vyber klauzuli A':-B1,...,Bn (n  0) z programu P
takovou, že  : A = A';  je nejobecnější unifikátor.
Pokud neexistuje A' nebo , ukonči cyklus.
Hana Rudová, Logické programování I, 17. května 2007 237 Implementace Prologu
Abstraktní interpret
Vstup: Logický program P a dotaz G.
1. Inicializuj množinu cílů S literály z dotazu G; S:=G
2. while ( S != empty ) do
3. Vyber AS a dále vyber klauzuli A':-B1,...,Bn (n  0) z programu P
takovou, že  : A = A';  je nejobecnější unifikátor.
Pokud neexistuje A' nebo , ukonči cyklus.
4. Nahrad' A v S cíli B1 až Bn.
5. Aplikuj  na G a S.
6. end while
7. Pokud S==empty, pak výpočet úspěšně skončil a výstupem je G se všemi
aplikovanými substitucemi.
Pokud S!=empty, výpočet končí neúspěchem.
Hana Rudová, Logické programování I, 17. května 2007 237 Implementace Prologu
Abstraktní interpret ­ pokračování
Kroky (3) až (5) představují redukci (logickou inferenci) cíle A.
Počet redukcí za sekundu (LIPS) == indikátor výkonu implementace
Hana Rudová, Logické programování I, 17. května 2007 238 Implementace Prologu
Abstraktní interpret ­ pokračování
Kroky (3) až (5) představují redukci (logickou inferenci) cíle A.
Počet redukcí za sekundu (LIPS) == indikátor výkonu implementace
Věta
Existuje-li instance G' dotazu G, odvoditelná z programu P v konečném počtu
kroků, pak bude tímto interpretem nalezena.
Hana Rudová, Logické programování I, 17. května 2007 238 Implementace Prologu
Nedeterminismus interpetu
1. Selekční pravidlo: výběr cíle A z množiny cílů S
neovlivňuje výrazně výsledek chování interpretu
2. Způsob prohledávání stromu výpočtu: výběr klauzule A' z programu P
je velmi důležitý, všechny klauzule totiž nevedou k úspěšnému řešení
Hana Rudová, Logické programování I, 17. května 2007 239 Implementace Prologu
Nedeterminismus interpetu
1. Selekční pravidlo: výběr cíle A z množiny cílů S
neovlivňuje výrazně výsledek chování interpretu
2. Způsob prohledávání stromu výpočtu: výběr klauzule A' z programu P
je velmi důležitý, všechny klauzule totiž nevedou k úspěšnému řešení
Vztah k úplnosti:
1. Selekční pravidlo neovlivňuje úplnost
možno zvolit libovolné v rámci SLD rezoluce
2. Prohledávání stromu výpočtu do šířky nebo do hloubky
Hana Rudová, Logické programování I, 17. května 2007 239 Implementace Prologu
Nedeterminismus interpetu
1. Selekční pravidlo: výběr cíle A z množiny cílů S
neovlivňuje výrazně výsledek chování interpretu
2. Způsob prohledávání stromu výpočtu: výběr klauzule A' z programu P
je velmi důležitý, všechny klauzule totiž nevedou k úspěšnému řešení
Vztah k úplnosti:
1. Selekční pravidlo neovlivňuje úplnost
možno zvolit libovolné v rámci SLD rezoluce
2. Prohledávání stromu výpočtu do šířky nebo do hloubky
,,Prozření" ­ automatický výběr správné klauzule
vlastnost abstraktního interpretu, kterou ale reálné interprety nemají
Hana Rudová, Logické programování I, 17. května 2007 239 Implementace Prologu
Prohledávání do šířky
1. Vybereme všechny klauzule Ai, které je možno unifikovat s literálem A
necht' je těchto klauzulí q
2. Vytvoříme q kopií množiny S
3. V každé kopii redukujeme A jednou z klauzulí Ai.
aplikujeme příslušný nejobecnější unifikátor
Hana Rudová, Logické programování I, 17. května 2007 240 Implementace Prologu
Prohledávání do šířky
1. Vybereme všechny klauzule Ai, které je možno unifikovat s literálem A
necht' je těchto klauzulí q
2. Vytvoříme q kopií množiny S
3. V každé kopii redukujeme A jednou z klauzulí Ai.
aplikujeme příslušný nejobecnější unifikátor
4. V následujících krocích redukujeme všechny množiny Si současně.
Hana Rudová, Logické programování I, 17. května 2007 240 Implementace Prologu
Prohledávání do šířky
1. Vybereme všechny klauzule Ai, které je možno unifikovat s literálem A
necht' je těchto klauzulí q
2. Vytvoříme q kopií množiny S
3. V každé kopii redukujeme A jednou z klauzulí Ai.
aplikujeme příslušný nejobecnější unifikátor
4. V následujících krocích redukujeme všechny množiny Si současně.
5. Výpočet ukončíme úspěchem, pokud se alespoň jedna z množin Si stane
prázdnou.
Hana Rudová, Logické programování I, 17. května 2007 240 Implementace Prologu
Prohledávání do šířky
1. Vybereme všechny klauzule Ai, které je možno unifikovat s literálem A
necht' je těchto klauzulí q
2. Vytvoříme q kopií množiny S
3. V každé kopii redukujeme A jednou z klauzulí Ai.
aplikujeme příslušný nejobecnější unifikátor
4. V následujících krocích redukujeme všechny množiny Si současně.
5. Výpočet ukončíme úspěchem, pokud se alespoň jedna z množin Si stane
prázdnou.
Ekvivalence s abstraktnímu interpretem
pokud jeden interpret neuspěje, pak neuspěje i druhý
pokud jeden interpret uspěje, pak uspěje i druhý
Hana Rudová, Logické programování I, 17. května 2007 240 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, 17. května 2007 241 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 nějakém kroku nenajdeme vhodnou klauzuli A', vrátíme se
k předchozímu stavu (tedy anulujeme aplikace posledního unifikátoru )
a vybereme ze zásobníku další klauzuli.
Hana Rudová, Logické programování I, 17. května 2007 241 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 nějakém kroku nenajdeme vhodnou klauzuli A', vrátíme se
k předchozímu stavu (tedy anulujeme aplikace posledního unifikátoru )
a vybereme ze zásobníku další klauzuli.
5. Pokud je zásobník prázdný, končí výpočet neúspěchem.
6. Pokud naopak zredukujeme všechny literály v S, výpočet končí úspěchem.
Hana Rudová, Logické programování I, 17. května 2007 241 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 nějakém kroku nenajdeme vhodnou klauzuli A', vrátíme se
k předchozímu stavu (tedy anulujeme aplikace posledního unifikátoru )
a vybereme ze zásobníku další klauzuli.
5. Pokud je zásobník prázdný, končí výpočet neúspěchem.
6. Pokud naopak zredukujeme všechny literály v S, výpočet končí úspěchem.
Není úplné, tj. nemusí najít všechna řešení
Nižší pamět'ová náročnost než prohledávání do šířky
Používá se v Prologu
Hana Rudová, Logické programování I, 17. května 2007 241 Implementace Prologu
Reprezentace objektů
Beztypový jazyk
Kontrola ,,typů" za běhu výpočtu
Informace o struktuře součástí objektu
Hana Rudová, Logické programování I, 17. května 2007 242 Implementace Prologu
Reprezentace objektů
Beztypový jazyk
Kontrola ,,typů" za běhu výpočtu
Informace o struktuře součástí objektu
Typy objektů
Primitivní objekty:
konstanta
číslo
volná proměnná
odkaz (reference)
Hana Rudová, Logické programování I, 17. května 2007 242 Implementace Prologu
Reprezentace objektů
Beztypový jazyk
Kontrola ,,typů" za běhu výpočtu
Informace o struktuře součástí objektu
Typy objektů
Primitivní objekty:
konstanta
číslo
volná proměnná
odkaz (reference)
Složené (strukturované) objekty:
struktura
seznam
Hana Rudová, Logické programování I, 17. května 2007 242 Implementace Prologu
Reprezentace objektů II
Příznaky (tags):
Objekt Příznak
volná proměnná FREE
konstanta CONST
celé číslo INT
odkaz REF
složený term FUNCT
Hana Rudová, Logické programování I, 17. května 2007 243 Implementace Prologu
Reprezentace objektů II
Příznaky (tags):
Objekt Příznak
volná proměnná FREE
konstanta CONST
celé číslo INT
odkaz REF
složený term FUNCT
Obsah adresovatelného slova: hodnota a příznak.
Hana Rudová, Logické programování I, 17. května 2007 243 Implementace Prologu
Reprezentace objektů II
Příznaky (tags):
Objekt Příznak
volná proměnná FREE
konstanta CONST
celé číslo INT
odkaz REF
složený term FUNCT
Obsah adresovatelného slova: hodnota a příznak.
Primitivní objekty uloženy přímo ve slově
Hana Rudová, Logické programování I, 17. května 2007 243 Implementace Prologu
Reprezentace objektů II
Příznaky (tags):
Objekt Příznak
volná proměnná FREE
konstanta CONST
celé číslo INT
odkaz REF
složený term FUNCT
Obsah adresovatelného slova: hodnota a příznak.
Primitivní objekty uloženy přímo ve slově
Složené objekty
jsou instance termu ve zdrojovém textu, tzv. zdrojového termu
zdrojový term bez proměnných = každá instanciace ekvivalentní zdrojovému termu
zdrojový term s proměnnými = dvě instance se mohou lišit aktuálními hodnotami
proměnných, jedinečnost zajišt'uje kopírování struktur nebo sdílení struktur
Hana Rudová, Logické programování I, 17. května 2007 243 Implementace Prologu
Kopírování struktur
Příklad:
a(b(X),c(X,Y),d),
FUNCT a/3
REF
REF
CONST d
FUNCT c/2
REF
FREE Y
FUNCT b/1
FREE X
'
'
E
Hana Rudová, Logické programování I, 17. května 2007 244 Implementace Prologu
Kopírování struktur II
Term F s aritou A reprezentován A+1 slovy:
funktor a arita v prvním slově
2. slovo nese první argument (resp. odkaz na jeho hodnotu)
...
A+1 slovo nese hodnotu A-tého argumentu
Reprezentace vychází z orientovaných acyklických grafů:
a/3 d
c/2 Y
b/1 X
c
c
c
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, 17. května 2007 245 Implementace Prologu
Sdílení struktur
Vychází z myšlenky, že při reprezentaci je třeba řešit přítomnost proměnných
Instance termu
< kostra_termu; rámec >
kostra_termu je zdrojový term s očíslovanými proměnnými
rámec je vektor aktuálních hodnot těchto proměnných
i-tá položka nese hodnotu i-té proměnné v původním termu
Hana Rudová, Logické programování I, 17. května 2007 246 Implementace Prologu
Sdílení struktur II
Příklad:
a(b(X),c(X,Y),d)
reprezentuje
< a(b($1),c($1,$2),d) ; [FREE, FREE] >
kde symbolem $i označujeme i-tou proměnnou.
Hana Rudová, Logické programování I, 17. května 2007 247 Implementace Prologu
Sdílení struktur II
Příklad:
a(b(X),c(X,Y),d)
reprezentuje
< a(b($1),c($1,$2),d) ; [FREE, FREE] >
kde symbolem $i označujeme i-tou proměnnou.
Implementace:
< &kostra_termu; &rámec > (& vrací adresu objektu)
Všechny instance sdílí společnou kostru_termu  sdílení struktur
Hana Rudová, Logické programování I, 17. května 2007 247 Implementace Prologu
Srovnání: příklad
Naivní srovnání: sdílení pamět'ově méně náročné
Hana Rudová, Logické programování I, 17. května 2007 248 Implementace Prologu
Srovnání: příklad
Naivní srovnání: sdílení pamět'ově méně náročné
Platí ale pouze pro rozsáhlé termy přítomné ve zdrojovém kódu
Hana Rudová, Logické programování I, 17. května 2007 248 Implementace Prologu
Srovnání: příklad
Naivní srovnání: sdílení pamět'ově méně náročné
Platí ale pouze pro rozsáhlé termy pří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
L
K
M:d
kostra_b
kostra_c
X
Y
E
E E
E
E
E
'
Hana Rudová, Logické programování I, 17. května 2007 248 Implementace Prologu
Srovnání: příklad ­ pokračování
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
'
'
E
Hana Rudová, Logické programování I, 17. května 2007 249 Implementace Prologu
Srovnání: příklad ­ pokračování
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
'
'
E
tj. identické jako přímé vytvoření termu a(b(X),c(X,Y),d)
Hana Rudová, Logické programování I, 17. května 2007 249 Implementace Prologu
Srovnání II
Složitost algoritmů pro přístup k jednotlivým argumentům
sdílení struktur: nutná víceúrovňová nepřímá adresace
kopírování struktur: bez problémů
jednodušší algoritmy usnadňují i optimalizace
Hana Rudová, Logické programování I, 17. května 2007 250 Implementace Prologu
Srovnání II
Složitost algoritmů pro přístup k jednotlivým argumentům
sdílení struktur: nutná víceúrovňová nepřímá adresace
kopírování struktur: bez problémů
jednodušší algoritmy usnadňují i optimalizace
Lokalita přístupů do paměti
sdílení struktur: přístupy rozptýleny po paměti
kopírování struktur: lokalizované přístupy
při stránkování paměti ­ rozptýlení vyžaduje přístup k více stránkám
Hana Rudová, Logické programování I, 17. května 2007 250 Implementace Prologu
Srovnání II
Složitost algoritmů pro přístup k jednotlivým argumentům
sdílení struktur: nutná víceúrovňová nepřímá adresace
kopírování struktur: bez problémů
jednodušší algoritmy usnadňují i optimalizace
Lokalita přístupů do paměti
sdílení struktur: přístupy rozptýleny po paměti
kopírování struktur: lokalizované přístupy
při stránkování paměti ­ rozptýlení vyžaduje přístup k více stránkám
Z praktického hlediska neexistuje mezi těmito přístupy zásadní rozdíl
Hana Rudová, Logické programování I, 17. května 2007 250 Implementace Prologu
Řízení výpočtu
Dopředný výpočet
po úspěchu (úspěšná redukce)
jednotlivá volání procedur skončí úspěchem
klasické volání rekurzivních procedur
Hana Rudová, Logické programování I, 17. května 2007 251 Implementace Prologu
Řízení výpočtu
Dopředný výpočet
po úspěchu (úspěšná redukce)
jednotlivá volání procedur skončí úspěchem
klasické volání rekurzivních procedur
Zpětný výpočet (backtracking)
po neúspěchu vyhodnocení literálu (neúspěšná redukce)
nepodaří se unifikace aktuálních a formálních parametrů hlavy
návrat do bodu, kde zústala nevyzkoušená alternativa výpočtu
je nutná obnova původních hodnot jednotlivých proměnných
po nalezení místa s dosud nevyzkoušenou klauzulí pokračuje dále dopředný výpočet
Hana Rudová, Logické programování I, 17. května 2007 251 Implementace Prologu
Aktivační záznam
Volání (=aktivace) procedury
Aktivace sdílí společný kód, liší se obsahem aktivačního záznamu
Aktivační záznam uložen na lokálním zásobníku
Hana Rudová, Logické programování I, 17. května 2007 252 Implementace Prologu
Aktivační záznam
Volání (=aktivace) procedury
Aktivace sdílí společný kód, liší se obsahem aktivačního záznamu
Aktivační záznam uložen na lokálním zásobníku
Dopředný výpočet
stav výpočtu v okamžiku volání procedury
aktuální parametry
lokální proměnné
pomocné proměnné (`a la registry)
Hana Rudová, Logické programování I, 17. května 2007 252 Implementace Prologu
Aktivační záznam
Volání (=aktivace) procedury
Aktivace sdílí společný kód, liší se obsahem aktivačního záznamu
Aktivační záznam uložen na lokálním zásobníku
Dopředný výpočet
stav výpočtu v okamžiku volání procedury
aktuální parametry
lokální proměnné
pomocné proměnné (`a la registry)
Zpětný výpočet (backtracking)
hodnoty parametrů v okamžiku zavolání procedury
následující klauzule pro zpracování při neúspěchu
Hana Rudová, Logické programování I, 17. května 2007 252 Implementace Prologu
Aktivační záznam a roll-back
Neúspěšná klauzule mohla nainstanciovat nelokální proměnné
a(X) :- X = b(c,Y), Y = d. ?- W = b(Z,e), a(W).
Hana Rudová, Logické programování I, 17. května 2007 253 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, 17. května 2007 253 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)
Při návratu je třeba obnovit (roll-back) původní hodnoty proměnných
Využijeme vlastností logických proměnných
instanciovat lze pouze volnou proměnnou
jakmile proměnná získá hodnotu, nelze ji změnit jinak než návratem výpočtu
= původní hodnoty všech proměnných odpovídají volné proměnné
Hana Rudová, Logické programování I, 17. května 2007 253 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)
Při návratu je třeba obnovit (roll-back) původní hodnoty proměnných
Využijeme vlastností logických proměnných
instanciovat lze pouze volnou proměnnou
jakmile proměnná získá hodnotu, nelze ji změnit jinak než návratem výpočtu
= původní hodnoty všech proměnných odpovídají volné proměnné
Stopa (trail): zásobník s adresami instanciovaných proměnných
ukazatel na aktuální vrchol zásobníku uchováván v aktivačním záznamu
při neúspěchu jsou hodnoty proměnných na stopě v úseku mezi aktuálním a uloženým
vrcholem zásobníku změněny na ,,volná"
Hana Rudová, Logické programování I, 17. května 2007 253 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)
Při návratu je třeba obnovit (roll-back) původní hodnoty proměnných
Využijeme vlastností logických proměnných
instanciovat lze pouze volnou proměnnou
jakmile proměnná získá hodnotu, nelze ji změnit jinak než návratem výpočtu
= původní hodnoty všech proměnných odpovídají volné proměnné
Stopa (trail): zásobník s adresami instanciovaných proměnných
ukazatel na aktuální vrchol zásobníku uchováván v aktivačním záznamu
při neúspěchu jsou hodnoty proměnných na stopě v úseku mezi aktuálním a uloženým
vrcholem zásobníku změněny na ,,volná"
Globální zásobník: pro uložení složených termů
ukazatel na aktuální vrchol zásobníku uchováván v aktivačním záznamu
při neúspěchu vrchol zásobníku snížen podle uschované hodnoty v aktivačním záznamu
Hana Rudová, Logické programování I, 17. května 2007 253 Implementace Prologu
Okolí a bod volby
Aktivační záznam úspěšně ukončené procedury nelze odstranit z lokálního
zásobníku = rozdělení aktivačního záznamu:
okolí (environment) ­ informace nutné pro dopředný běh programu
bod volby (choice point) ­ informace nezbytné pro zotavení po neúspěchu
Hana Rudová, Logické programování I, 17. května 2007 254 Implementace Prologu
Okolí a bod volby
Aktivační záznam úspěšně ukončené procedury nelze odstranit z lokálního
zásobníku = rozdělení aktivačního záznamu:
okolí (environment) ­ informace nutné pro dopředný běh programu
bod volby (choice point) ­ informace nezbytné pro zotavení po neúspěchu
ukládány na lokální zásobník
samostatně provázány (odkaz na předchozí okolí resp. bod volby)
Hana Rudová, Logické programování I, 17. května 2007 254 Implementace Prologu
Okolí a bod volby
Aktivační záznam úspěšně ukončené procedury nelze odstranit z lokálního
zásobníku = rozdělení aktivačního záznamu:
okolí (environment) ­ informace nutné pro dopředný běh programu
bod volby (choice point) ­ informace nezbytné pro zotavení po neúspěchu
ukládány na lokální zásobník
samostatně provázány (odkaz na předchozí okolí resp. bod volby)
Důsledky:
samostatná práce s každou částí aktivačního záznamu (optimalizace)
Hana Rudová, Logické programování I, 17. května 2007 254 Implementace Prologu
Okolí a bod volby
Aktivační záznam úspěšně ukončené procedury nelze odstranit z lokálního
zásobníku = rozdělení aktivačního záznamu:
okolí (environment) ­ informace nutné pro dopředný běh programu
bod volby (choice point) ­ informace nezbytné pro zotavení po neúspěchu
ukládány na lokální zásobník
samostatně provázány (odkaz na předchozí okolí resp. bod volby)
Důsledky:
samostatná práce s každou částí aktivačního záznamu (optimalizace)
alokace pouze okolí pro deterministické procedury
Hana Rudová, Logické programování I, 17. května 2007 254 Implementace Prologu
Okolí a bod volby
Aktivační záznam úspěšně ukončené procedury nelze odstranit z lokálního
zásobníku = rozdělení aktivačního záznamu:
okolí (environment) ­ informace nutné pro dopředný běh programu
bod volby (choice point) ­ informace nezbytné pro zotavení po neúspěchu
ukládány na lokální zásobník
samostatně provázány (odkaz na předchozí okolí resp. bod volby)
Důsledky:
samostatná práce s každou částí aktivačního záznamu (optimalizace)
alokace pouze okolí pro deterministické procedury
možnost odstranění okolí po úspěš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, 17. května 2007 254 Implementace Prologu
Řez
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).
Hana Rudová, Logické programování I, 17. května 2007 255 Implementace Prologu
Řez
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 dopředný výpočet, má vliv pouze na zpětný výpočet
Odstranění alternativních větví výpočtu
 odstranění odpovídajících bodů volby
tj. odstranění bodů volby mezi současným vrcholem zásobníku a bodem volby
procedury, která řez vyvolala (včetně bodu volby procedury s řezem)
 změna ukazatele na ,,nejmladší" bod volby
Hana Rudová, Logické programování I, 17. května 2007 255 Implementace Prologu
Řez
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 dopředný výpočet, má vliv pouze na zpětný výpočet
Odstranění alternativních větví výpočtu
 odstranění odpovídajících bodů volby
tj. odstranění bodů volby mezi současným vrcholem zásobníku a bodem volby
procedury, která řez vyvolala (včetně bodu volby procedury s řezem)
 změna ukazatele na ,,nejmladší" bod volby
 Vytváření deterministických procedur
 Optimalizace využití zásobníku
Hana Rudová, Logické programování I, 17. května 2007 255 Implementace Prologu
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 vestavěné predikátý (nemění se)
obsahuje rovněž všechny statické objekty (texty atomů a funktorů apod.)
Lokální zásobník (Stack)
Stopa (Trail)
Globální zásobník n. halda(Heap)
Pomocný zásobník (Push Down List, PDL)
pracovní pamět' abstraktního počítače
použitý v unifikaci, syntaktické analýze apod.
Hana Rudová, Logické programování I, 17. května 2007 256 Implementace Prologu
Rozmístění datových oblastí
Příklad konfigurace
Halda
Stopa
Zásobník
PDL
Oblast kodu
Halda i lokální zásobník musí růst stejným směrem
lze jednoduše porovnat stáří dvou proměnných srovnáním adres
využívá se při zabránění vzniku visících odkazů
Hana Rudová, Logické programování I, 17. května 2007 257 Implementace Prologu
Registry WAMu
Stavové registry:
P čitač 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ý při analýze složených termů (Structure pointer)
CUT ukazatel na bod volby, na který se řezem zařízne zásobník
Argumentové registry: A1,A2,... (při předávání parametrů n. pracovní registry)
Registry pro lokální proměnné: Y1,Y2,...
abstraktní znázornění lok. proměnných na zásobníku
Hana Rudová, Logické programování I, 17. května 2007 258 Implementace Prologu
Typy instrukcí WAMu
put instrukce ­ příprava argumentů před voláním podcíle
žádná z těchto instrukcí nevolá obecný unifikační algoritmus
get instrukce ­ unifikace aktuálních a formálních parametrů
obecná unifikace pouze při get_value
unify instrukce ­ zpracování složených termů
jednoargumentové instrukce, používají registr S jako druhý argument
počáteční hodnota S je odkaz na 1. argument
volání instrukce unify zvětší hodnotu S o jedničku
obecná unifikace pouze při unify_value a unify_local_value
Indexační instrukce ­ indexace klauzulí a manipulace s body volby
Instrukce řízení běhu ­ předávání řízení a explicitní manipulace s okolím
Hana Rudová, Logické programování I, 17. května 2007 259 Implementace Prologu
Instrukce put a get: příklad
Pří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, 17. května 2007 260 Implementace Prologu
Instrukce WAMu
get instrukce put instrukce unify instrukce
get_var Ai,Y put_var Ai,Y unify_var Y
get_value Ai,Y put_value Ai,Y unify_value Y
get_const Ai,C put_unsafe_value Ai,Y unify_local_value Y
get_nil Ai put_const Ai,C unify_const C
get_struct Ai,F/N put_nil Ai unify_nil
get_list Ai put_struct Ai,F/N unify_void N
put_list Ai
instrukce řízení indexační instrukce
allocate try_me_else Next try Next
deallocate retry_me_else Next retry Next
call Proc/N,A trust_me_else fail trust fail
execute Proc/N
proceed cut_last switch_on_term Var,Const,List,Struct
save_cut Y switch_on_const Table
load_cut Y switch_on_struct Table
Hana Rudová, Logické programování I, 17. května 2007 261 Implementace Prologu
WAM ­ indexace
Provázání klauzulí: instrukce XX_me_else:
první klauzule: try_me_else; založí bod volby
poslední klauzule: trust_me_else; zruší nejmladší bod volby
ostatní klauzule: retry_me_else; znovu použije nejmladší bod volby po neúspěchu
Hana Rudová, Logické programování I, 17. května 2007 262 Implementace Prologu
WAM ­ indexace
Provázání klauzulí: instrukce XX_me_else:
první klauzule: try_me_else; založí bod volby
poslední klauzule: trust_me_else; zruší nejmladší bod volby
ostatní klauzule: retry_me_else; znovu použije nejmladší bod volby po neúspěchu
Provázání podmnožiny klauzulí (podle argumentu):
try
retry
trust
Hana Rudová, Logické programování I, 17. května 2007 262 Implementace Prologu
WAM ­ indexace
Provázání klauzulí: instrukce XX_me_else:
první klauzule: try_me_else; založí bod volby
poslední klauzule: trust_me_else; zruší nejmladší bod volby
ostatní klauzule: retry_me_else; znovu použije nejmladší bod volby po neúspěchu
Provázání podmnožiny klauzulí (podle argumentu):
try
retry
trust
,,Rozskokové" instrukce (dle typu a hodnoty argumentu):
switch_on_term Var, Const, List, Struct
výpočet následuje uvedeným návěstím podle typu prvního argumentu
switch_on_YY: hashovací tabulka pro konkrétní typ (konstanta, struktura)
Hana Rudová, Logické programování I, 17. května 2007 262 Implementace Prologu
Příklad indexace instrukcí
Proceduře
a(atom) :- body1.
a(1) :- body2.
a(2) :- body3.
a([X|Y]) :- body4.
a([X|Y]) :- body5.
a(s(N)) :- body6.
a(f(N)) :- body7.
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
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
Hana Rudová, Logické programování I, 17. května 2007 263 Implementace Prologu
WAM ­ řízení výpočtu
execute Proc: ekvivalentní příkazu goto
Hana Rudová, Logické programování I, 17. května 2007 264 Implementace Prologu
WAM ­ řízení výpočtu
execute Proc: ekvivalentní příkazu goto
proceed: zpracování faktů
Hana Rudová, Logické programování I, 17. května 2007 264 Implementace Prologu
WAM ­ řízení výpočtu
execute Proc: ekvivalentní příkazu goto
proceed: zpracování faktů
allocate: alokuje okolí (pro některé klauzule netřeba, proto explicitně generováno)
Hana Rudová, Logické programování I, 17. května 2007 264 Implementace Prologu
WAM ­ řízení výpočtu
execute Proc: ekvivalentní příkazu goto
proceed: zpracování faktů
allocate: alokuje okolí (pro některé klauzule netřeba, proto explicitně 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á počet lok. proměnných (odpovídá velikosti zásobníku)
Hana Rudová, Logické programování I, 17. května 2007 264 Implementace Prologu
WAM ­ řízení výpočtu
execute Proc: ekvivalentní příkazu goto
proceed: zpracování faktů
allocate: alokuje okolí (pro některé klauzule netřeba, proto explicitně 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á počet lok. proměnných (odpovídá velikosti zásobníku)
Možná optimalizace: vhodným uspořádáním proměnný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, 17. května 2007 264 Implementace Prologu
WAM ­ řez
Implementace řezu (opakování): odstranění bodů volby mezi současným vrcholem zásobníku a
bodem volby procedury, která řez vyvolala (včetně bodu volby procedury s řezem)
Indexační instrukce znemožňují v době překladu rozhodnout, zda bude alokován bod volby
příklad: ?- a(X). může být nedeterministické, ale ?- a(1). může být deterministické
Hana Rudová, Logické programování I, 17. května 2007 265 Implementace Prologu
WAM ­ řez
Implementace řezu (opakování): odstranění bodů volby mezi současným vrcholem zásobníku a
bodem volby procedury, která řez vyvolala (včetně bodu volby procedury s řezem)
Indexační instrukce znemožňují v době překladu rozhodnout, zda bude alokován bod volby
příklad: ?- a(X). může být nedeterministické, ale ?- a(1). může být deterministické
cut_last: B := CUT save_cut Y: Y := CUT load_cut Y: B := Y
Hana Rudová, Logické programování I, 17. května 2007 265 Implementace Prologu
WAM ­ řez
Implementace řezu (opakování): odstranění bodů volby mezi současným vrcholem zásobníku a
bodem volby procedury, která řez vyvolala (včetně bodu volby procedury s řezem)
Indexační instrukce znemožňují v době překladu rozhodnout, zda bude alokován bod volby
příklad: ?- a(X). může být nedeterministické, ale ?- a(1). můž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 řez prvním predikátem klauzule, použije se rovnou cut_last. V opačném případě se použije
jako první instrukce save_cut Y a v místě skutečného volání řezu se použije load_cut Y.
Hana Rudová, Logické programování I, 17. května 2007 265 Implementace Prologu
WAM ­ řez
Implementace řezu (opakování): odstranění bodů volby mezi současným vrcholem zásobníku a
bodem volby procedury, která řez vyvolala (včetně bodu volby procedury s řezem)
Indexační instrukce znemožňují v době překladu rozhodnout, zda bude alokován bod volby
příklad: ?- a(X). může být nedeterministické, ale ?- a(1). můž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 řez prvním predikátem klauzule, použije se rovnou cut_last. V opačném případě se použije
jako první instrukce save_cut Y a v místě skutečného volání řezu se použije load_cut Y.
Pří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, 17. května 2007 265 Implementace Prologu
WAM ­ optimalizace
1. Indexace klauzulí
2. Generování optimální posloupnosti instrukcí WAMu
3. Odstranění redundancí při generování cílového kódu.
Hana Rudová, Logické programování I, 17. května 2007 266 Implementace Prologu
WAM ­ optimalizace
1. Indexace klauzulí
2. Generování optimální posloupnosti instrukcí WAMu
3. Odstranění redundancí při generování cílového kódu.
Příklad: a(X,Y,Z) :- b(f,X,Y,Z).
naivní kód (vytvoří kompilátor pracující striktně zleva doprava) vs.
optimalizovaný kód (počet registrů a tedy i počet instrukcí/přesunů v paměti 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, 17. května 2007 266 Implementace Prologu