Prolog Language Tutorial
Iniziare con Prolog Language

Osservazioni

Installazione o configurazione

SWI-Prolog

Windows e Mac:

• Scarica SWI-Prolog dal sito ufficiale
• Basta installare seguendo le istruzioni di installazione.

Linux (PPA):

• Aggiungi il ppa:swi-prolog/stable alle sorgenti software del tuo sistema (gli sviluppatori possono scegliere per ppa:swi-prolog/devel ):

  • Aprire un terminale (Ctrl + Alt + T) e digitare: sudo add-apt-repository ppa:swi-prolog/stable

  • Successivamente, aggiorna le informazioni sul pacchetto: sudo apt-get update

• Ora installa SWI-Prolog tramite il gestore pacchetti: sudo apt-get install swi-prolog

• È ora possibile avviare SWI-Prolog tramite la riga di comando con il comando swipl

aggiungere / 3

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

append/3 è una delle relazioni Prolog più conosciute. Definisce una relazione tra tre argomenti ed è vera se il terzo argomento è una lista che denota la concatenazione delle liste che sono specificate nel primo e nel secondo argomento.

In particolare, e come è tipico per il buon codice Prolog, append/3 può essere utilizzato in più direzioni : Può essere usato per:

• aggiungere due elenchi completamente o parzialmente istanziati:

    ?- 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].
  

• controlla se la relazione è vera per tre elenchi completamente istanziati:

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

• generare tutti i modi possibili per aggiungere due elenchi a una determinata lista:

    ?- 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.
  

Vincoli CLP (FD)

I vincoli CLP (FD) sono forniti da tutte le implementazioni seria di Prolog. Ci permettono di ragionare sugli interi in modo puro.

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

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

Programmazione del database

Prolog classifica tutto in:

• Atomi - Qualsiasi sequenza di caratteri che non iniziano con un alfabeto maiuscolo. Ad esempio - a , b , okay
• Numeri - Non esiste una sintassi speciale per i numeri, non è richiesta alcuna dichiarazione. Ad esempio 1 , 22 , 35.8
• Variabili - Una stringa che inizia con un carattere maiuscolo o underscore ( _ ). Ad esempio X , Y , Abc , AA
• Termini complessi : sono costituiti da un funtore e da una sequenza di argomenti . Il nome di un termine complesso è sempre un atomo, mentre gli argomenti possono essere atomi o variabili. Ad es. father(john,doe) , relative(a) , mother(X,Y) .

Un database logico contiene un insieme di fatti e regole .

Un termine complesso con solo gli atomi come argomenti è chiamato un fatto, mentre un termine complesso con variabili come argomenti è chiamato una regola.

Esempio di fatti in Prolog:

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

Esempio di una regola in Prolog:

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

Si noti che il ; qui è come l'operatore or in altre lingue.

Prolog è un linguaggio dichiarativo e puoi leggere questo database come segue:

fred è il padre di susan

hillary è la madre di joe.

Per tutti X e Y , X è figlio di Y se Y è padre di X o Y è madre di X

In effetti, un insieme finito di fatti e / o regole costituisce un programma logico.

L'uso di tale programma è dimostrato facendo domande . Le query ti consentono di recuperare informazioni da un programma di logica.

Per caricare il database nell'interprete (supponendo di aver salvato il database nella directory in cui stai eseguendo l'interprete), inserisci semplicemente:

?- [nameofdatabase].

sostituendo nameofdatabase con il nome file effettivo (si noti che qui si esclude l'estensione .pl al nome file).

Esempio di query nell'interprete per il programma sopra e i risultati:

?- 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.

Le domande sopra e le loro risposte possono essere lette come segue:

è Susan un figlio di Fred? - vero

è un figlio di Hillary? - vero

Fred è figlio di Susan? - falso

è Susan un figlio di Hillary? - falso

di chi è Susan? - Fred

Ecco come programmiamo la logica in Prolog. Un programma logico è più formalmente: un insieme di assiomi, o regole, che definiscono le relazioni (noti come predicati) tra gli oggetti. Un modo alternativo di interpretare il database in un modo logico più formale è:

La relazione father_child tiene tra fred e susan

La relazione mother_child tiene tra hillary e joe

Per tutte le X e Y la relazione child_of tiene tra X e Y se la relazione father_child contiene tra Y e X , o la relazione mother_child contiene tra Y e X

Ciao mondo

Ciao, Mondo nell'interprete interattivo

Per stampare "Hello, World!" nell'interprete Prolog (qui stiamo usando swipl , la shell per SWI Prolog):

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

?- è il prompt di sistema: indica che il sistema è pronto per l'utente per inserire una sequenza di obiettivi (cioè una query ) che deve essere terminata con a . (punto).

Qui la query write('Hello World!'), nl ha due obiettivi:

• write('Hello World!') : 'Hello World!' deve essere visualizzato e ( , )
• una nuova linea ( nl ) deve seguire.

write/1 (il /1 è usato per indicare che il predicato accetta un argomento) e nl/0 sono predicati incorporati (la definizione è fornita in anticipo dal sistema Prolog). I predicati incorporati forniscono strutture che non possono essere ottenute con la pura definizione Prolog o per evitare che il programmatore debba definirle.

L'output:

Ciao mondo!

sì

termina con yes il che significa che la query è riuscita. In alcuni sistemi è stampato true invece di yes .

Ciao, Mondo da un file

Apri un nuovo file chiamato hello_world.pl e inserisci il seguente testo:

:- initialization hello_world, halt.

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

La direttiva di initialization specifica che l'obiettivo hello_world, halt dovrebbe essere chiamato quando il file viene caricato. halt termina il programma.

Questo file può quindi essere eseguito dal tuo eseguibile Prolog. Le bandiere esatte dipendono dal sistema Prolog. Se stai usando SWI Prolog:

$ swipl -q -l hello_world.pl 

Questo produrrà l'output Hello, World! . Il flag -q sopprime il banner che di solito viene visualizzato quando chiami esegui swipl . -l specifica un file da caricare.