Prolog Language Samouczek
Rozpoczęcie pracy z językiem Prolog

Uwagi

Instalacja lub konfiguracja

SWI-Prolog

Windows i Mac:

• Pobierz SWI-Prolog z oficjalnej strony internetowej
• Wystarczy zainstalować, postępując zgodnie z instrukcjami instalatora.

Linux (PPA):

• Dodaj PPA ppa:swi-prolog/stable do źródeł oprogramowania systemu (programiści mogą wybrać dla ppa:swi-prolog/devel ):

  • Otwórz terminal (Ctrl + Alt + T) i wpisz: sudo add-apt-repository ppa:swi-prolog/stable

  • Następnie zaktualizuj informacje o pakiecie: sudo apt-get update

• Teraz zainstaluj SWI-Prolog za pomocą menedżera pakietów: sudo apt-get install swi-prolog

• Możesz teraz uruchomić SWI-Prolog za pomocą wiersza polecenia z poleceniem swipl

append / 3

append([], Bs, Bs).
append([A|As], Bs, [A|Cs]) :-
    append(As, Bs, Cs).

append/3 to jedna z najbardziej znanych relacji Prolog. Definiuje relację między trzema argumentami i jest prawdą, jeśli trzeci argument jest listą oznaczającą konkatenację list określonych w pierwszym i drugim argumencie.

Warto zauważyć, i jak to jest typowe dla dobrego kodu Prolog, append/3 może być używany w kilku kierunkach : Można go użyć do:

• dołącz dwie w pełni lub częściowo utworzone instancje:

    ?- A = [1, 2, 3], B=[4, 5, 6], append(A, B, Y)
    Output:
    A = [1, 2, 3],
    B = [4, 5, 6],
    Y = [1, 2, 3, 4, 5, 6].
  

• sprawdź, czy relacja jest prawdziwa dla trzech w pełni utworzonych list:

    ?- A = [1, 2, 3], B = [4, 5], C = [1, 2, 3, 4, 5, 6], append(A, B, C)
    Output:
    false
  

• wygeneruj wszystkie możliwe sposoby dołączenia dwóch list do danej listy:

    ?- append(A, B, [1, 2, 3, 4]).
    Output:
    A = [],
    B = [1, 2, 3, 4] ;
    A = [1],
    B = [2, 3, 4] ;
    A = [1, 2],
    B = [3, 4] ;
    A = [1, 2, 3],
    B = [4] ;
    A = [1, 2, 3, 4],
    B = [] ;
    false.
  

Ograniczenia CLP (FD)

Ograniczenia CLP (FD) są zapewniane przez wszystkie poważne implementacje Prolog. Pozwalają nam rozumować liczby całkowite w czysty sposób.

?- X #= 1 + 2.
X = 3.

?- 5 #= Y + 2.
Y = 3.

Programowanie baz danych

Prolog dzieli wszystko na:

• Atomy - dowolna sekwencja znaków, które nie zaczynają się od wielkich liter. Np. a , b , w okay
• Liczby - nie ma specjalnej składni liczb, deklaracja nie jest wymagana. Np. 1 , 22 , 35.8
• Zmienne - ciąg znaków rozpoczynający się od dużej litery lub podkreślenia ( _ ). Np. X , Y , Abc , AA
• Złożone warunki - składają się z funktora i sekwencji argumentów . Nazwa złożonego terminu jest zawsze atomem, podczas gdy argumentami mogą być atomy lub zmienne. Np. father(john,doe) , relative(a) , mother(X,Y) .

Logiczna baza danych zawiera zestaw faktów i reguł .

Złożony termin z tylko atomami jako argumentami nazywa się faktem, a złożony termin ze zmiennymi jako argumentami nazywa się regułą.

Przykład faktów w Prologu:

father_child(fred, susan).
mother_child(hillary, joe).

Przykład reguły w Prologu:

child_of(X,Y):-
    father_child(Y,X)
    ;
    mother_child(Y,X).

Zauważ, że ; tutaj jest jak or operator w innych językach.

Prolog jest językiem deklaratywnym i możesz przeczytać tę bazę danych w następujący sposób:

Fred jest ojcem Susan

Hillary jest matką Joe.

Dla wszystkich X i Y , X jest dzieckiem Y jeśli Y jest ojcem X lub Y jest matką X

W rzeczywistości skończony zestaw faktów i zasad stanowi program logiczny.

Zastosowanie takiego programu jest zademonstrowane poprzez wykonywanie zapytań . Zapytania umożliwiają pobieranie informacji z programu logicznego.

Aby załadować bazę danych do interpretera (zakładając, że zapisałeś bazę danych w katalogu, w którym uruchamiasz tłumacza), po prostu wpisz:

?- [nameofdatabase].

zastąpienie nazwy nameofdatabase danych rzeczywistą nazwą pliku (zwróć uwagę, że tutaj wykluczamy rozszerzenie .pl nazwy pliku).

Przykład zapytań interpretera dla powyższego programu i wyników:

?- child_of(susan,fred).
true

?- child_of(joe,hillary).
true

?- child_of(fred,susan).
false

?- child_of(susan,hillary).
false

?- child_of(susan,X).
X = fred

?- child_of(X,Y).
X = susan,
Y = fred ;
X = joe,
Y = hillary.

Powyższe zapytania i ich odpowiedzi można odczytać w następujący sposób:

czy Susan jest dzieckiem Freda? - prawdziwe

czy Joe jest dzieckiem Hillary? - prawdziwe

czy Fred jest dzieckiem Susan? - fałszywy

czy Susan jest dzieckiem Hillary? - fałszywy

Kim jest Susan? - Fred

W ten sposób programujemy logikę w Prologu. Program logiczny jest bardziej formalnie: zestaw aksjomatów lub reguł, definiujących relacje (inaczej predykaty) między obiektami. Alternatywnym sposobem interpretacji powyższej bazy danych w bardziej formalny sposób jest:

Relacja father_child utrzymuje między father_child

Relacja mother_child utrzymuje się między mother_child

Dla wszystkich X i Y relacja child_of utrzymuje się między X i Y jeśli relacja father_child utrzymuje się między Y i X , lub relacja mother_child utrzymuje między Y i X

Witaj świecie

Witaj, świecie w interaktywnym tłumaczu

Aby wydrukować „Witaj, świecie!” w interpretatorze Prolog (tutaj używamy swipl , powłoki dla SWI Prolog):

$ swipl
<...banner...>
?- write('Hello, World!'), nl.

?- czy monit systemowy: wskazuje, że system jest gotowy do wprowadzenia przez użytkownika sekwencji celów (tj. zapytania ), które należy zakończyć za pomocą . (kropka).

Tutaj zapytanie write('Hello World!'), nl ma dwa cele:

• write('Hello World!') : 'Hello World!' musi być wyświetlony i ( , )
• musi nastąpić nowy wiersz ( nl ).

write/1 ( /1 służy do wskazania, że predykat przyjmuje jeden argument), a nl/0 są wbudowanymi predykatami (definicja jest z góry podana przez system Prolog). Wbudowane predykaty zapewniają funkcje, których nie można uzyskać za pomocą czystej definicji Prologa lub aby uchronić programistę przed koniecznością ich definiowania.

Wyjście:

Witaj świecie!

tak

kończy się na yes co oznacza, że zapytanie się powiodło. W niektórych systemach true jest wypisywana zamiast yes .

Witaj, świecie z pliku

Otwórz nowy plik o nazwie hello_world.pl i wstaw następujący tekst:

:- initialization hello_world, halt.

hello_world :-
    write('Hello, World!'), nl.

Dyrektywa initialization określa, że cel hello_world, halt powinien być wywoływany podczas ładowania pliku. halt wychodzi z programu.

Ten plik może być następnie wykonany przez twój plik wykonywalny Prolog. Dokładne flagi zależą od systemu Prolog. Jeśli używasz SWI Prolog:

$ swipl -q -l hello_world.pl 

To da wynik Hello, World! . Flaga -q pomija baner, który zwykle wyświetla się, gdy wywołasz run swipl . -l określa plik do załadowania.