Spis treści Fakty [edytuj] Reguły [edytuj]

Prolog (Programmation en Logique) to język programowania logicznego - program w
Prologu to opis reguły wnioskowania oraz celu do którego zmierzamy, a rola komputera
polega na odpowiednim zastosowaniu reguł aby znaleźć rozwiązanie.
Prolog został stworzony w 1971 roku przez Alaina Colmeraurera i Phillipe'a Roussela.
Używany w wielu programach z zakresu sztucznej inteligencji.
Prolog opiera się o rachunek predykatowy pierwszego rzędu, jednak ogranicza się tylko do
klauzul Horna.
Spis treści
[ukryj]
1 Fakty
2 Reguły
3 Przykłady
o 3.1 Operacje na listach
4 Zobacz też
5 Linki zewnętrzne
Fakty [edytuj]
Programowanie w Prologu bardzo różni się od programowania w ję zykach algorytmicznych.
W Prologu podaje się bazę faktów i reguł. Potem można wykonywać zapytania na tej bazie.
Podstawową jednostką w Prologu jest predykat. Predykat składa się z nagłówka i
argumentów, na przykład: ojciec(tomasz, agata), gdzie ojciec to nagłówek a tomasz i
agata to argumenty. Predykat może zostać użyty do wyrażenia pewnych faktów o świecie,
które są znane dla programu. W tym przypadku programista musi nadać im znaczenie. Jedną
z interpretacji zdania ojciec(tomasz, agata) jest "tomasz to ojciec agaty". Jednak równie
dobrze mogłoby to znaczyć "ojcem tomasza jest agata". Prolog nie ma pojęcia, co oznaczają
te stwierdzenia. Wszystko co robi to manipulacja symbolami w oparciu o reguły. Dlatego
można wybrać dowolny sposób zapisu tego, że "tomasz to ojciec agaty", pod warunkiem
konsekwentnego przestrzegania kolejności argumentów w całym programie.
Pewne predykaty mogą oprócz wyrażania faktów mieć skutki uboczne, jak na przykład
wbudowany predykat
write('Cześć').
który wypisuje na ekranie 'Cześć'.
Reguły [edytuj]
Baza danych Prologu może też zawierać reguły. Przykład reguły to:
jest(światło) :- włączony(przycisk).
Zapis :- oznacza "wtedy, gdy" lub "jeśli". Ta reguła oznacza, że zdanie jest(światło) jest
prawdziwe wtedy, gdy prawdziwe jest zdanie włączony(przycisk). Reguły mogą używać
zmiennych. Zmienne zapisuje się zaczynając od wielkiej litery, dla odróżnienia od stałych,
zaczynających się z małej. Na przykład:
ojciec(X, Y) :- rodzic(X, Y), jest_rodzaju_męskiego(Y).
To oznacza: "dla każdych X i Y, jeśli rodzic(X,Y) i jest_rodzaju_męskiego(Y) to ojciec(X,
Y). Przesłanka i wniosek są zapisane w odwrotnej kolejności niż zwykle w logice. Co więcej,
reguły muszą mieć predykat jako wniosek. Można umieścić wiele predykatów we wniosku,
połączonych koniunkcją, na przykład:
a,b,c :- d.
ale oznacza to tyle samo, co trzy oddzielne reguły:
a :- d.
b :- d.
c :- d.
Nie można napisać reguły "a;b :- c", czyli "jeśli c to (a lub b)". Wynika to z ograniczenia
zapisu do klauzul Horna.
Przykłady [edytuj]
Operacje na listach [edytuj]
% list_member(X,Y) = X należy do listy Y
% reimplementacja standardowego member(X,Y)
list_member(X, [X|_]).
list_member(X, [_|Y]) :list_member(X, Y).
% list_append(X,Y,Z) = Z powstaje ze sklejenia X i Y
% reimplementacja standardowego append(X,Y,Z)
list_append([], X, X).
list_append([H|T], X, [H|Y]) :list_append(T, X, Y).
% suma_elementow_listy(Lista, N) = N jest sumą elementów należących do
Listy
suma_elementow_listy([], 0).
suma_elementow_listy([H|T], Wynik) :suma_elementow_listy(T, Tmp),
Wynik is H+Tmp.
% jak wyżej, lecz z użyciem rekurencji prawostronnej
suma_elementow_listy_tail(Lista, Wynik) :suma_elementow_listy_tail(Lista, 0, Wynik).
suma_elementow_listy_tail([], Wynik, Wynik).
suma_elementow_listy_tail([H|T], Akumulator, Wynik) :Akumulator2 is H+Akumulator, suma_elementow_listy_tail(T,
Akumulator2, Wynik).