Prolog

Z Wikipedii, wolnej encyklopedii.

Prolog (od francuskiego 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

1 Fakty

2 Reguły

3 Przykłady

3.1 Operacje na listach

4 Łącza zewnętrzne

Fakty

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ło by 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

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

Operacje na listach

% 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 rekursji ogonowej
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).

Łącza zewnętrzne

	Strona główna \| Ostatnie zmiany \| Edytuj \| Historia strony Wersja do druku \| Informacje prawne	Brak logowania Zaloguj mnie \| Pomoc
	W innych językach: English \| Esperanto \| Français \| Español \| Nederlands \| 日本語 \| Deutsch \| Italiano