Wstęp do programowania Wykład 10 Programowanie w logice

Programowanie deklaratywne W odróżnieniu od programowania imperatywnego, gdzie programista definiuje sekwencję kroków, która prowadzi do rozwiązania problemu, w programowaniu deklaratywnym programista definiuje szczegółowe warunki, które musi spełniać rozwiązanie. Programowanie imperatywne – jak to zrobić? Programowanie deklaratywne – co chcemy osiągnąć? Rodzaje programowania deklaratywnego: programowanie w logice i programowanie funkcyjne.

Prolog Programowanie funkcyjne opiera się na pojęciu funkcji, programowanie w logice opiera się na pojęciu relacji. Pierwszym językiem programowania w logice był Prolog. Prolog = Programmation en Logique 1972 Alain Colmerauer i Philipp. Roussel, Uniwersytet w Marsylii. Robert Kowalski, Uniwersytet w Edynburgu.

Prolog Obiekt występujący w Prologu jest abstrakcyjnym bytem. Nie mówimy z czego się składa i co można z nim robić. Opisujemy tylko relacje jakim podlega. cięższy(słoń, pies). cięższy(pies, mrówka). Powyższe dwa fakty (a nawet dowolny jeden nich) stanowią poprawny, choć mało interesujący, program w Prologu.

Program w Prologu Program w Prologu to skończony zbiór faktów i reguł. większy(słoń, pies). (fakt) większy(pies,mrówka). (fakt) większy(X,Y):-większy(X,Z),większy(Z,Y). (reguła) Z formalnego punktu widzenia program w Prologu jest dedukcyjną bazą danych! Dane do programu to zapytanie do bazy danych! Na ogół wiele zapytań pasuje do danej bazy danych. Dlatego jeden program w Prologu może być użyty do rozwiązania wielu, pozornie różnych, zadań.

Zapytania większy(słoń, pies). większy(pies,mrówka). większy(X,Y):-większy(X,Z),większy(Z,Y). większy(słoń, mrówka). – czy słoń jest większy od mrówki? większy(X,mrówka). – znajdź taki X, że X większy od mrówka większy(słoń, X), większy(X, mrówka) – znajdż takie X, słoń większy od X i X większy od mrówka. większy(X,homar). Wszystkie zapytania się pętlą, ponieważ reguła woła rekurencyjnie samą siebie nieskończenie wiele razy.

Dlaczego pętla? Zapytanie większy(X,homar). Ponieważ żadna odpowiedź nie wynika z faktów, będzie użyta reguła. Według reguły musimy pokazać: większy(X,Z) oraz większy(Z, homar). Czyli pętla. Jak uniknąć pętli? większy(słoń, pies). większy(pies,mrówka). jestwiększy(X,Y) :- większy(X,Y). jestwiększy(X,Y):-większy(X,Z), jestwiększy(Z,Y).

Silnik Prologu Prolog opiera się na automatycznym dowodzeniu twierdzeń metodą rezolucji w logice pierwszego rzędu. Rezolucja działa metodą sprowadzenia do sprzeczności. Pokazuje się, że dodanie do programu negacji zapytania daje sprzeczność. Rezolucja ma ponadto własność, że przy okazji konstruuje kontrprzykład, który jest odpowiedzią na zapytanie.

Listy Listy stanowią podstawową strukturę danych w prologu. Lista jest to skończony ciąg elementów. [] -- lista pusta [a,b,7] Każda lista składa się z głowy, czyli pierwszego elementu i ogona, czyli reszty listy. Do rozdzielenia głowy i ogona służy symbol |. Listę [a,b,7] możemy równoważnie zapisać jako [a|[b,7]] lub [a|[b|[7]].

Łączenie list append(X,Y,Z) lista Z jest złączeniem list X i Y. X Y Z [] [] [] [] [a] [a] [a,b] [c,d] [a,b,c,d] [7|[x,2]] [8,9] [7,x,2,8,9] append([],Y,Y). append([H|X],Y,[H|Z]):- append(X,Y,Z).

Przynależność do listy Czy element X należy do listy? (podkreślenie to zmienna anonimowa) należy(X,[X|_]). należy(X,[_|T]):- należy(X,T).

Odwracanie listy odwróć(X,Y) – Y jest odwróceniem listy X odwroc([],[]). odwroc([A|X], Z):- odwroc(X,Y), append(Y,[A],Z).

Długość listy dlugosc([],0). dlugosc([_|Ogon],Dlug) :- dlugosc(Ogon,X), Dlug is X+1.

Świat klocków Stan początkowy ab c Stan końcowy b a c Działania (akcje): move(X,Y,Z) – przenieś X z Y na Z X – klocek, Y,Z – klocek lub podłoga podłoga Warunki początkowe: X leży na Y; nic nie leży na X; nic nie leży na Z (warunki początkowe muszą zajść, aby można było wykonać działanie).

Działania jako transformatory stanów ab c move(b,floor,a)ab c move(c,a,b) c ba Język do opisu stanów: on(X,Y) – X leży na Y clearX) – na X nic nie leży ab c a b c on(a,floor) on(c,a) on(b,floor) clear(c) clear(b) on(a,floor) on(c,b) on(b,floor) clear(a) clear(c) move(c,a,b)

Planowanie działań Dane są: Stan początkowy. Stan końcowy. Zbiór możliwych działań (akcji). Zadanie: znaleźć sekwencję działań przeprowadzjącą stan początkowy w stan końcowy.

Strips Stanford Research Institute Problem Solver (1971) Do dzisiaj większość zaawansowanych systemów planujących opiera się na koncepcji systemu STRIPS. Stany opisywane są przez zbiory faktów. Każde działanie może być wykonane jeśli spełnione są jego warunki wstępne. W wyniku wykonania działania otrzymujemy nowy stan. Stan ten powstaje ze stanu poprzedniego poprzez usunięcie pewnych faktów i dodanie pewnych faktów.

Opis świata klocków dla systemu Warrena always(true):- fail. add(on(U,W),move(U,V,W)). add(clear(V),move(U,V,W)). del(on(U,V),move(U,V,W)). del(clear(W),move(U,V,W)). can(move(U,V,floor),on(U,V)&not_equal(V,floor)&clear(U)). can(move(U,V,W),clear(W)&on(U,V)&not_equal(U,W)&clear(U)).

Opis świata klocków dla systemu Warrena imposs(on(X,Y)&clear(Y)). imposs(on(X,Y)&on(X,Z)&not_equal(Y,Z)). imposs(on(X,Z)&on(Y,Z)&not_equal(Z,floor)&not_equal(X,Y)). imposs(on(X,X)). given(start,on(a,floor)). given(start,on(b,floor)). given(start,on(c,a)). given(start,clear(b)). given(start,clear(c)). Zapytanie: plans(on(c,a)&on(a,b),start).

Małżeństwa i rozwody Działania: ślub(X,Y), rozwód(X,Y) Relacje: małżeństwo(X,Y), wolny(X) Warunki wstępne działań: ślub(X,Y) – wolny(X), wolny(Y) rozwód(X,Y) – małżeństwo(X,Y). Efekty działań: ślub(X,Y) – małżeństwo(X,Y) /*usuwamy wolny(X), wolny(Y) rozwód(X,Y) – wolny(X), wolny(Y) /*usuwamymałżeństwo(X,Y)

Małżeństwa i rozwody w systemie Warrena always(true):- fail. add(malzenstwo(X,Y),slub(X,Y)). add(wolny(X), rozwod(X,Y)). add(wolny(Y), rozwod(X,Y)). del(wolny(X), slub(X,Y)). del(wolny(Y),slub(X,Y)). del(malzenstwo(X,Y), rozwod(X,Y)).

Małżeństwa i rozwody w systemie Warrena can(slub(X,Y), wolny(X)&wolny(Y)). can(rozwod(X,Y), malzenstwo(X,Y)). imposs(malzenstwo(X,Y)&wolny(X)). imposs(malzenstwo(X,Y)&wolny(Y)). given(start,malzenstwo(a,b)). given(start,malzenstwo(c,d)). Zapytanie: plans(malzenstwo(a,c)&malzenstwo(b,d),start).

Robot R KO R – robot K – ksiązka O – okulary Działania: zapal(X) zgaś(X) idz(X,Y) weź(X) połóż(X,Y) Relacje: jasno(X) ciemno(X) w(X,Y) ma(X,Y) jasno ciemno

Robot Warunki wstępne działań zapal(X) – ciemno(X), w(robot,X) zgaś(X) – jasno(X), w(robot,X) idź(X,Y) – w(robot,X), drzwi(X,Y) weź(X) – w(X,Y), w(robot,Y), jasno(Y), X≠robot połóż(X,Y) – ma(robot, X), w(robot,Y) Efekty działań: zapal(X) – jasno(X) /* usuwamy ciemno(X) zgaś(X) – ciemno(X) /* usuwamy jasno(X) idź(X,Y) – w(robot,Y) /* usuwamy w(robot(X) weź(X) – ma(robot(X) /* usuwamy w(X,Y) połóż(X,Y) – w(X,Y) /* usuwamy ma(robot,X)

Robot w systemie Warrena add(jasno(X),zapal(X)). add(ciemno(X),zgas(X)). add(w(robot,Y), idz(X,Y)). add(ma(robot,X),wez(X)). add(w(X,Y),poloz(X,Y)). del(ciemno(X),zapal(X)). del(jasno(X),zgas(X)). del(w(robot,X),idz(X,Y)). del(ma(robot,X),poloz(X,Y)). del(w(X,Y),wez(X)).

Robot w systemie Warrena can(zapal(X),ciemno(X)&w(robot,X)). can(zgas(X),jasno(X)&w(robot,X)). can(idz(X,Y), w(robot,X)& drzwi(X,Y)). can(wez(X),w(X,Y)&w(robot,Y)&jasno(Y)&not_equal(robot,X)). can(poloz(X,Y), ma(robot,X)&w(robot,Y)). imposs(w(X,Y)&w(X,Z)&not_equal(Y,Z)). imposs(jasno(X)&ciemno(X)).

Robot w systemie Warrena given(start,w(robot,1)). given(start,jasno(1)). given(start, ciemno(2)). given(start, ciemno(3)). given(start, ciemno(4)). given(start, drzwi(1,3)). given(start, drzwi(1,2)). given(start, drzwi(3,1)). given(start, drzwi(2,1)). given(start, drzwi(4,3)). given(start, drzwi(3,4)). given(start,w(ksiazka,2)). given(start,w(okulary,2)).

Robot w systemie Warrena Zapytania: plans(w(książka,3)&w(okulary,3)&w(robot,3),start). plans(w(robot,3)&w(książka,3)&w(okulary,3), start). pętla