caricato da Utente3849

Prolog 01

annuncio pubblicitario
Prolog: materiale didattico
Qualunque testo di introduzione al Prolog, ad esempio:
I. Bratko. Programmare in Prolog per l’Intelligenza Artificiale. Masson Addison Wesley, 1988.
W. F. Clocksin and C. S. Mellish. Programmare in Prolog. Franco Angeli,
1993.
L. Console, E. Lamma, P. Mello, M. Milano. Programmazione Logica e
Prolog. UTET Libreria, 1997.
Si può trovare materiale utile anche online.
Compilatore SWI-Prolog: http://www.swi-prolog.org/
(Logica per l’Informatica)
01: PROgramming in LOGic
1 / 29
Prolog: PROgramming in LOGic
Anni 70-80: ideato da Robert Kowalski; primo interprete Prolog (Alain
Colmerauer, 1972); primo compilatore Prolog (Warren, 1983, tramite la
Warren Abstract Machine).
È molto diverso dagli altri linguaggi di programmazione
Dichiarativo (non procedurale)
Ricorsione (niente cicli “for” o “while”)
I costrutti di base sono relazioni (non comandi né funzioni)
Concetti fondamentali: unificazione e backtracking
Un programma logico consiste di formule logiche e il calcolo è il processo di
derivare conseguenze dal programma (costruzione di dimostrazioni)
Idea di base:
Descrivere la situazione di interesse (programma)
Fare una domanda (query)
Il Prolog deduce nuovi fatti dal programma e risponde alla domanda
(Logica per l’Informatica)
01: PROgramming in LOGic
2 / 29
Programmare in Prolog
Un programma logico
ha un significato dichiarativo: un programma consiste di fatti e regole
che definiscono relazioni .
ha un significato operazionale: meccanismo di esecuzione
( motore di inferenza ), basato sull’unificazione e la risoluzione, per
estrarre conseguenze implicite nel programma
Per programmare in Prolog si devono avere presenti entrambi gli aspetti.
Conseguenze
Cambiare modo di pensare: dichiarativamente, non proceduralmente.
Linguaggio di alto livello
Non è efficiente quanto, ad esempio, il C
Ottimo per il “rapid prototyping”
Utile in molte applicazioni di Intelligenza Artificiale (rappresentazione della
conoscenza, deduzione, analisi del linguaggio naturale...)
(Logica per l’Informatica)
01: PROgramming in LOGic
3 / 29
Programma Prolog: Fatti
/* Definizione del predicato amico
(questo e’ un commento) */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
amico è un predicato.
antonio,bianca,carla,... sono costanti.
(Logica per l’Informatica)
01: PROgramming in LOGic
4 / 29
Programma Prolog: Fatti
/* Definizione del predicato amico
(questo e’ un commento) */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
%%% antonio e‘ amico di tutti (questo e’ un commento)
amico(antonio,Chiunque).
amico è un predicato.
antonio,bianca,carla,... sono costanti.
Chiunque è una variabile.
(Logica per l’Informatica)
01: PROgramming in LOGic
4 / 29
Programma Prolog: Fatti
/* Definizione del predicato amico
(questo e’ un commento) */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
%%% antonio e‘ amico di tutti (questo e’ un commento)
amico(antonio,Chiunque).
amico è un predicato.
antonio,bianca,carla,... sono costanti.
Chiunque è una variabile.
Queries
?- amico(antonio,enrico).
true
(Logica per l’Informatica)
01: PROgramming in LOGic
4 / 29
Programma Prolog: Fatti
/* Definizione del predicato amico
(questo e’ un commento) */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
%%% antonio e‘ amico di tutti (questo e’ un commento)
amico(antonio,Chiunque).
amico è un predicato.
antonio,bianca,carla,... sono costanti.
Chiunque è una variabile.
Queries
?- amico(dario,bianca).
false.
(Logica per l’Informatica)
01: PROgramming in LOGic
4 / 29
Programma Prolog: Fatti
/* Definizione del predicato amico
(questo e’ un commento) */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
%%% antonio e‘ amico di tutti (questo e’ un commento)
amico(antonio,Chiunque).
amico è un predicato.
antonio,bianca,carla,... sono costanti.
Chiunque è una variabile.
Queries
?- amico(antonio,100).
true.
(Logica per l’Informatica)
01: PROgramming in LOGic
4 / 29
Programma Prolog: Regole
/* Definizione del predicato amico */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
amico(antonio,Chiunque).
/* Definizione del predicato conosce */
conosce(dario,enrico).
conosce(X,Y) :- amico(X,Y).
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
conosce(X,Y)
testa della regola
amico(X,Qualcuno), amico(Qualcuno,Y) corpo della regola
La virgola in Prolog rappresenta la congiunzione (∧)
(Logica per l’Informatica)
01: PROgramming in LOGic
5 / 29
Programma Prolog: Regole
/* Definizione del predicato amico */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
amico(antonio,Chiunque).
/* Definizione del predicato conosce */
conosce(dario,enrico).
conosce(X,Y) :- amico(X,Y).
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
conosce(X,Y)
testa della regola
amico(X,Qualcuno), amico(Qualcuno,Y) corpo della regola
La virgola in Prolog rappresenta la congiunzione (∧)
?- conosce(bianca,dario).
true
(Logica per l’Informatica)
01: PROgramming in LOGic
5 / 29
Programma Prolog: Regole
/* Definizione del predicato amico */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
amico(antonio,Chiunque).
/* Definizione del predicato conosce */
conosce(dario,enrico).
conosce(X,Y) :- amico(X,Y).
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
conosce(X,Y)
testa della regola
amico(X,Qualcuno), amico(Qualcuno,Y) corpo della regola
La virgola in Prolog rappresenta la congiunzione (∧)
?- conosce(bianca,carla).
true.
(Logica per l’Informatica)
01: PROgramming in LOGic
5 / 29
Programma Prolog: Regole
/* Definizione del predicato amico */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
amico(antonio,Chiunque).
/* Definizione del predicato conosce */
conosce(dario,enrico).
conosce(X,Y) :- amico(X,Y).
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
conosce(X,Y)
testa della regola
amico(X,Qualcuno), amico(Qualcuno,Y) corpo della regola
La virgola in Prolog rappresenta la congiunzione (∧)
?- conosce(bianca,enrico).
false.
(Logica per l’Informatica)
01: PROgramming in LOGic
5 / 29
La disgiunzione in Prolog
/* Definizione del predicato amico */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
amico(antonio,Chiunque).
/* Definizione del predicato conosce */
conosce(dario,enrico).
conosce(X,Y) :- amico(X,Y) ; amico(Y,X).
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
Il punto e virgola in Prolog rappresenta la disgiunzione (∨)
(Logica per l’Informatica)
01: PROgramming in LOGic
6 / 29
La disgiunzione in Prolog
/* Definizione del predicato amico */
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
amico(antonio,Chiunque).
/* Definizione del predicato conosce */
conosce(dario,enrico).
conosce(X,Y) :- amico(X,Y) ; amico(Y,X).
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
Il punto e virgola in Prolog rappresenta la disgiunzione (∨)
?- conosce(bianca,enrico).
true.
(Logica per l’Informatica)
01: PROgramming in LOGic
6 / 29
Generazione di valori di risposta
Torniamo al programma senza disgiunzione
%% amico
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
amico(antonio,Chiunque).
%% conosce
conosce(dario,enrico).
conosce(X,Y) :- amico(X,Y).
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
Queries con variabili
?- conosce(bianca,X).
X = dario
(Logica per l’Informatica)
01: PROgramming in LOGic
7 / 29
Generazione di valori di risposta
Torniamo al programma senza disgiunzione
%% amico
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
amico(antonio,Chiunque).
%% conosce
conosce(dario,enrico).
conosce(X,Y) :- amico(X,Y).
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
Queries con variabili
?- conosce(bianca,X).
X = dario ;
(Logica per l’Informatica)
01: PROgramming in LOGic
7 / 29
Generazione di valori di risposta
Torniamo al programma senza disgiunzione
%% amico
amico(antonio,bianca).
amico(antonio,enrico).
amico(bianca,dario).
amico(dario,carla).
amico(enrico,bianca).
amico(antonio,Chiunque).
%% conosce
conosce(dario,enrico).
conosce(X,Y) :- amico(X,Y).
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
Queries con variabili
?- conosce(bianca,X).
X = dario ;
X = carla.
(Logica per l’Informatica)
01: PROgramming in LOGic
7 / 29
Prolog e logica
Fatti e regole sono clausole.
Implicazione
Congiunzione
Disgiunzione
(Logica per l’Informatica)
Prolog
A :- B
A , B
A ; B
01: PROgramming in LOGic
Logica
B→A
A∧B
A∨B
8 / 29
Prolog e logica: le variabili
Variabili in un fatto:
amico(antonio,X): antonio e‘ amico di tutti (per ogni X, antonio e‘
amico di X).
pred(c1,...,cn,X1,...,Xn)
∀x1 . . . ∀xn pred(c1 , . . . , cn , x1 , . . . , xn )
(Logica per l’Informatica)
01: PROgramming in LOGic
9 / 29
Prolog e logica: le variabili
Variabili in un fatto:
amico(antonio,X): antonio e‘ amico di tutti (per ogni X, antonio e‘
amico di X).
pred(c1,...,cn,X1,...,Xn)
∀x1 . . . ∀xn pred(c1 , . . . , cn , x1 , . . . , xn )
Variabili in una regola
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
Per ogni X e per ogni Y,
X conosce Y se esiste Qualcuno conosciuto da X che conosce Y.
A(X1,...,Xn) :- B(X1,...,Xn,Y1,...,Yn).
∀x1 . . . ∀xn (∃y1 . . . ∃yn B(x1 , . . . , xn , y1 , . . . , yn ) → A(x1 , . . . , xn ))
(Logica per l’Informatica)
01: PROgramming in LOGic
9 / 29
Prolog e logica: le variabili
Variabili in un fatto:
amico(antonio,X): antonio e‘ amico di tutti (per ogni X, antonio e‘
amico di X).
pred(c1,...,cn,X1,...,Xn)
∀x1 . . . ∀xn pred(c1 , . . . , cn , x1 , . . . , xn )
Variabili in una regola
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
Per ogni X e per ogni Y,
X conosce Y se esiste Qualcuno conosciuto da X che conosce Y.
A(X1,...,Xn) :- B(X1,...,Xn,Y1,...,Yn).
∀x1 . . . ∀xn (∃y1 . . . ∃yn B(x1 , . . . , xn , y1 , . . . , yn ) → A(x1 , . . . , xn ))
∀x1 . . . ∀xn ∀y1 . . . ∀yn (B(x1 , . . . , xn , y1 , . . . , yn ) → A(x1 , . . . , xn ))
(Logica per l’Informatica)
01: PROgramming in LOGic
9 / 29
Prolog e logica: le variabili
Variabili in un fatto:
amico(antonio,X): antonio e‘ amico di tutti (per ogni X, antonio e‘
amico di X).
pred(c1,...,cn,X1,...,Xn)
∀x1 . . . ∀xn pred(c1 , . . . , cn , x1 , . . . , xn )
Variabili in una regola
conosce(X,Y) :- amico(X,Qualcuno), amico(Qualcuno,Y).
Per ogni X e per ogni Y,
X conosce Y se esiste Qualcuno conosciuto da X che conosce Y.
A(X1,...,Xn) :- B(X1,...,Xn,Y1,...,Yn).
∀x1 . . . ∀xn (∃y1 . . . ∃yn B(x1 , . . . , xn , y1 , . . . , yn ) → A(x1 , . . . , xn ))
∀x1 . . . ∀xn ∀y1 . . . ∀yn (B(x1 , . . . , xn , y1 , . . . , yn ) → A(x1 , . . . , xn ))
Variabili in una query
?- conosce(bianca,X). esiste X conosciuto da bianca?
?- goal(X1,...,Xn).
∃x1 . . . ∃xn goal(x1 . . . xn )
e‘ derivabile dal programma?
Se lo e‘, per quali valori di x1 . . . xn ?
(Logica per l’Informatica)
01: PROgramming in LOGic
9 / 29
Procedure
Premessa: un fatto si può considerare come una regola il cui corpo è true, e
la testa è il fatto stesso:
amico(antonio,bianca).
amico(antonio,bianca) :- true.
Sia pred un predicato a n argomenti e P un programma Prolog.
L’insieme di fatti e regole in P la cui testa ha la forma
pred(termine1 ,. . . ,terminen )
costituisce la procedura pred.
colore(tavolo,bianco).
colore(penna,rosso).
colore(X,Y) :- vicino(X,Z), colore(Z,Y).
Le clausole di una procedura rappresentano modi alternativi di risolvere
problemi della stessa forma (colore(. . . ,. . . )).
(Logica per l’Informatica)
01: PROgramming in LOGic
10 / 29
Il motore di inferenza del Prolog
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,bianca).
Goal
nonno(tommaso,bianca)
(Logica per l’Informatica)
01: PROgramming in LOGic
11 / 29
Il motore di inferenza del Prolog
=⇒
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,bianca).
Legami
X=tommaso, Y=bianca (Logica per l’Informatica)
01: PROgramming in LOGic
Goal
nonno(tommaso,bianca)
genitore(X,Z), genitore(Z,Y).
11 / 29
Il motore di inferenza del Prolog
=⇒
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,bianca).
Legami
Goal
nonno(tommaso,bianca)
X=tommaso, Y=bianca
genitore(X,Z), genitore(Z,Y).
X=tommaso, Y=bianca, Z=francesca
genitore(Z,Y): false
(Logica per l’Informatica)
01: PROgramming in LOGic
11 / 29
Il motore di inferenza del Prolog
=⇒
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,bianca).
Legami
Backtrack:
Goal
nonno(tommaso,bianca)
X=tommaso, Y=bianca
genitore(X,Z), genitore(Z,Y).
X=tommaso, Y=bianca, Z=francesca
genitore(Z,Y): false
genitore(Z,Y)
X=tommaso, Y=bianca, Z=vittorio (Logica per l’Informatica)
01: PROgramming in LOGic
11 / 29
Il motore di inferenza del Prolog
=⇒
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,bianca).
true.
Legami
Backtrack:
Goal
nonno(tommaso,bianca)
X=tommaso, Y=bianca
genitore(X,Z), genitore(Z,Y).
X=tommaso, Y=bianca, Z=francesca
genitore(Z,Y): false
X=tommaso, Y=bianca, Z=vittorio
genitore(Z,Y)
X=tommaso, Y=bianca, Z=vittorio
true
(Logica per l’Informatica)
01: PROgramming in LOGic
11 / 29
Il motore di inferenza del Prolog
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Goal
nonno(tommaso,Chi)
(Logica per l’Informatica)
01: PROgramming in LOGic
12 / 29
Il motore di inferenza del Prolog
=⇒
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Legami
X=tommaso,Chi=Y (Logica per l’Informatica)
Goal
nonno(tommaso,Chi)
genitore(X,Z), genitore(Z,Y).
01: PROgramming in LOGic
12 / 29
Il motore di inferenza del Prolog
=⇒
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Legami
X=tommaso,Chi=Y X=tommaso, Chi=Y, Z=francesca (Logica per l’Informatica)
Goal
nonno(tommaso,Chi)
genitore(X,Z), genitore(Z,Y).
genitore(Z,Y)
01: PROgramming in LOGic
12 / 29
Il motore di inferenza del Prolog
=⇒
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Chi=linda
Legami
Goal
nonno(tommaso,Chi)
genitore(X,Z), genitore(Z,Y).
X=tommaso,Chi=Y X=tommaso, Chi=Y, Z=francesca
genitore(Z,Y)
X=tommaso, Chi=Y=linda, Z=francesca true
(Logica per l’Informatica)
01: PROgramming in LOGic
Risposta
Chi=linda
12 / 29
Il motore di inferenza del Prolog
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Chi=linda ; ⇐=
Legami
Goal
nonno(tommaso,Chi)
genitore(X,Z), genitore(Z,Y).
X=tommaso,Chi=Y X=tommaso, Chi=Y, Z=francesca
genitore(Z,Y)
X=tommaso, Chi=Y=linda, Z=francesca true
Backtrack: X=tommaso,Chi=Y genitore(X,Z), genitore(Z,Y).
(Logica per l’Informatica)
01: PROgramming in LOGic
Risposta
Chi=linda
12 / 29
Il motore di inferenza del Prolog
=⇒
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Chi=linda ;
Legami
Goal
nonno(tommaso,Chi)
genitore(X,Z), genitore(Z,Y).
X=tommaso,Chi=Y X=tommaso, Chi=Y, Z=francesca
genitore(Z,Y)
X=tommaso, Chi=Y=linda, Z=francesca true
Backtrack:
genitore(X,Z), genitore(Z,Y).
X=tommaso,Chi=Y genitore(Z,Y)
X=tommaso, Chi=Y, Z=vittorio (Logica per l’Informatica)
01: PROgramming in LOGic
Risposta
Chi=linda
12 / 29
Il motore di inferenza del Prolog
=⇒
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(vittorio,bianca).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Chi=linda ;
Chi=bianca
Legami
Goal
nonno(tommaso,Chi)
genitore(X,Z), genitore(Z,Y).
X=tommaso,Chi=Y X=tommaso, Chi=Y, Z=francesca
genitore(Z,Y)
X=tommaso, Chi=Y=linda, Z=francesca true
Backtrack:
genitore(X,Z), genitore(Z,Y).
X=tommaso,Chi=Y genitore(Z,Y)
X=tommaso, Chi=Y, Z=vittorio X=tommaso, Chi=Y=bianca, Z=vittorio
true
(Logica per l’Informatica)
01: PROgramming in LOGic
Risposta
Chi=linda
Chi=bianca
12 / 29
Il backtracking
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(francesca,leonardo).
genitore(vittorio,bianca).
genitore(vittorio,andrea).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
(Logica per l’Informatica)
01: PROgramming in LOGic
13 / 29
Il backtracking
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(francesca,leonardo).
genitore(vittorio,bianca).
genitore(vittorio,andrea).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Chi = linda
(Logica per l’Informatica)
01: PROgramming in LOGic
13 / 29
Il backtracking
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(francesca,leonardo).
genitore(vittorio,bianca).
genitore(vittorio,andrea).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Chi = linda ;
Chi = leonardo
(Logica per l’Informatica)
01: PROgramming in LOGic
13 / 29
Il backtracking
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(francesca,leonardo).
genitore(vittorio,bianca).
genitore(vittorio,andrea).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Chi = linda ;
Chi = leonardo ;
Chi = bianca
(Logica per l’Informatica)
01: PROgramming in LOGic
13 / 29
Il backtracking
genitore(tommaso,francesca).
genitore(tommaso,vittorio).
genitore(francesca,linda).
genitore(francesca,leonardo).
genitore(vittorio,bianca).
genitore(vittorio,andrea).
nonno(X,Y) :- genitore(X,Z), genitore(Z,Y).
?- nonno(tommaso,Chi).
Chi = linda ;
Chi = leonardo ;
Chi = bianca ;
Chi = andrea.
(Logica per l’Informatica)
01: PROgramming in LOGic
13 / 29
L’albero di ricerca
nonno(tommaso,Chi)
X=tommaso,Chi=Y genitore(X,Z),genitore(Z,Y)
X=tommaso,Chi=Y,
Z=vittorio
X=tommaso,Chi=Y,
Z=francesca
genitore(Z,Y)
genitore(Z,Y)
X=tommaso,
Chi=Y=linda,
Z=francesca
X=tommaso,
Chi=Y=leonardo,
Z=francesca
true
(Logica per l’Informatica)
true
X=tommaso,
Chi=Y=bianca,
Z=vittorio
true
01: PROgramming in LOGic
X=tommaso,
Chi=Y=andrea,
Z=vittorio
true
14 / 29
Il backtracking
likes(mary,food).
likes(mary,wine).
likes(john,beer).
likes(john,wine).
likes(john,mary).
%
%
%
%
%
clausola
clausola
clausola
clausola
clausola
1
2
3
4
5
?- likes(mary,X), likes(john,X).
Goal: likes(mary,X), likes(john,X).
(Logica per l’Informatica)
01: PROgramming in LOGic
15 / 29
Il backtracking
likes(mary,food).
likes(mary,wine).
likes(john,beer).
likes(john,wine).
likes(john,mary).
%
%
%
%
%
clausola
clausola
clausola
clausola
clausola
1
2
3
4
5
?- likes(mary,X), likes(john,X).
Goal: likes(mary,X), likes(john,X).
Sottogoal 1: likes(mary,X). Clausola usata: 1, legami: X=food Puntatore alla prossima clausola: 2.
(Logica per l’Informatica)
01: PROgramming in LOGic
15 / 29
Il backtracking
likes(mary,food).
likes(mary,wine).
likes(john,beer).
likes(john,wine).
likes(john,mary).
%
%
%
%
%
clausola
clausola
clausola
clausola
clausola
1
2
3
4
5
?- likes(mary,X), likes(john,X).
Goal: likes(mary,X), likes(john,X).
Sottogoal 1: likes(mary,X). Clausola usata: 1, legami: X=food Puntatore alla prossima clausola: 2.
Sottogoal 2: likes(john,food).
(Logica per l’Informatica)
01: PROgramming in LOGic
15 / 29
Il backtracking
likes(mary,food).
likes(mary,wine).
likes(john,beer).
likes(john,wine).
likes(john,mary).
%
%
%
%
%
clausola
clausola
clausola
clausola
clausola
1
2
3
4
5
?- likes(mary,X), likes(john,X).
Goal: likes(mary,X), likes(john,X).
Sottogoal 1: likes(mary,X). Clausola usata: 1, legami: X=food Puntatore alla prossima clausola: 2.
Sottogoal 2: likes(john,food).
(Logica per l’Informatica)
01: PROgramming in LOGic
15 / 29
Il backtracking
likes(mary,food).
likes(mary,wine).
likes(john,beer).
likes(john,wine).
likes(john,mary).
%
%
%
%
%
clausola
clausola
clausola
clausola
clausola
1
2
3
4
5
?- likes(mary,X), likes(john,X).
Goal: likes(mary,X), likes(john,X).
Sottogoal 1: likes(mary,X). Clausola usata: 1, legami: X=food Puntatore alla prossima clausola: 2.
Sottogoal 2: likes(john,food).
false.
Backtrack.
(Logica per l’Informatica)
01: PROgramming in LOGic
15 / 29
Il backtracking
likes(mary,food).
likes(mary,wine).
likes(john,beer).
likes(john,wine).
likes(john,mary).
%
%
%
%
%
clausola
clausola
clausola
clausola
clausola
1
2
3
4
5
?- likes(mary,X), likes(john,X).
Goal: likes(mary,X), likes(john,X).
Sottogoal 1: likes(mary,X). Clausola usata: 1, legami: X=food Puntatore alla prossima clausola: 2.
Backtracking: Clausola usata: 2, legami: X=wine Sottogoal 2: likes(john,food).
false.
Backtrack.
(Logica per l’Informatica)
01: PROgramming in LOGic
15 / 29
Il backtracking
likes(mary,food).
likes(mary,wine).
likes(john,beer).
likes(john,wine).
likes(john,mary).
%
%
%
%
%
clausola
clausola
clausola
clausola
clausola
1
2
3
4
5
?- likes(mary,X), likes(john,X).
Goal: likes(mary,X), likes(john,X).
Sottogoal 1: likes(mary,X). Clausola usata: 1, legami: X=food Puntatore alla prossima clausola: 2.
Backtracking: Clausola usata: 2, legami: X=wine Sottogoal 2: likes(john,food).
false.
Backtrack.
Sottogoal 2: likes(john,wine).
(Logica per l’Informatica)
01: PROgramming in LOGic
15 / 29
Il backtracking
likes(mary,food).
likes(mary,wine).
likes(john,beer).
likes(john,wine).
likes(john,mary).
%
%
%
%
%
clausola
clausola
clausola
clausola
clausola
1
2
3
4
5
?- likes(mary,X), likes(john,X).
Goal: likes(mary,X), likes(john,X).
Sottogoal 1: likes(mary,X). Clausola usata: 1, legami: X=food Puntatore alla prossima clausola: 2.
Backtracking: Clausola usata: 2, legami: X=wine Sottogoal 2: likes(john,food).
false.
Backtrack.
Sottogoal
2: likes(john,wine).
true: X=wine (Logica per l’Informatica)
01: PROgramming in LOGic
15 / 29
I termini Prolog
Fatti, regole e queries sono costruiti sulla base di termini
termini
termini semplici
costanti
termini complessi
variabili
atomi numeri
Atomi: tommaso, toMMaso_27, 'Tommaso d\'Aquino'.
Sequenze di caratteri speciali: : , ; . :Numeri: 12, -34, 345.01, 0.328
Variabili: iniziano con lettera maiuscola o underscore: X, Y, Chi, _variabile
(Logica per l’Informatica)
01: PROgramming in LOGic
16 / 29
Classificazione dei termini
Il Prolog è un linguaggio a tipizzazione dinamica
Predicati predefiniti per riconoscere il tipo di un termine
var, nonvar
?- var(X).
true.
?- var(padre(X)).
false.
?- X=Y, Y=23, var(X).
false.
(Logica per l’Informatica)
integer, float, number
atom, atomic
?- atom(pippo).
true.
?- atom(3).
false.
?- atomic(3).
true.
01: PROgramming in LOGic
17 / 29
Termini complessi (o strutture)
Sono costruiti da un funtore (atomo) applicato a una sequenza di argomenti
(altri termini, semplici o complessi):
funtore(termine1 ,. . . ,terminen )
Esempi:
libro(’Le tigri di Mompracem’,autore(emilio,salgari))
padre(padre(antonio))
3+2
(Logica per l’Informatica)
01: PROgramming in LOGic
18 / 29
Termini complessi (o strutture)
Sono costruiti da un funtore (atomo) applicato a una sequenza di argomenti
(altri termini, semplici o complessi):
funtore(termine1 ,. . . ,terminen )
Esempi:
libro(’Le tigri di Mompracem’,autore(emilio,salgari))
padre(padre(antonio))
3+2
nonno(X,maria)
antenato(padre(padre(antonio)),madre(clara))
anche i fatti sono strutture
(Logica per l’Informatica)
01: PROgramming in LOGic
18 / 29
Termini complessi (o strutture)
Sono costruiti da un funtore (atomo) applicato a una sequenza di argomenti
(altri termini, semplici o complessi):
funtore(termine1 ,. . . ,terminen )
Esempi:
libro(’Le tigri di Mompracem’,autore(emilio,salgari))
padre(padre(antonio))
3+2
nonno(X,maria)
antenato(padre(padre(antonio)),madre(clara))
anche i fatti sono strutture
genitore(X,Y), genitore(Y,Z)
anche una sequenza di goal è una struttura
la virgola è l’operatore funtore principale
(Logica per l’Informatica)
01: PROgramming in LOGic
18 / 29
Termini complessi (o strutture)
Sono costruiti da un funtore (atomo) applicato a una sequenza di argomenti
(altri termini, semplici o complessi):
funtore(termine1 ,. . . ,terminen )
Esempi:
libro(’Le tigri di Mompracem’,autore(emilio,salgari))
padre(padre(antonio))
3+2
nonno(X,maria)
antenato(padre(padre(antonio)),madre(clara))
anche i fatti sono strutture
genitore(X,Y), genitore(Y,Z)
anche una sequenza di goal è una struttura
la virgola è l’operatore funtore principale
figlio(X,Y) :- genitore(Y,X)
anche una clausola è una struttura
l’operatore principale è :Non c’è differenza sintattica tra fatti, regole, goal e strutture che possono
essere argomenti di un funtore.
(Logica per l’Informatica)
01: PROgramming in LOGic
18 / 29
Unificazione
Due termini sono unificabili se:
sono lo stesso termine, oppure
contengono variabili che possono essere istanziate (sostituite) con
termini in modo tale da rendere uguali i due termini
(Logica per l’Informatica)
01: PROgramming in LOGic
19 / 29
Unificazione
Due termini sono unificabili se:
sono lo stesso termine, oppure
contengono variabili che possono essere istanziate (sostituite) con
termini in modo tale da rendere uguali i due termini
Unificabili
termini
tommaso
tommaso
nonno(X,Y)
nonno(tommaso,X)
(Logica per l’Informatica)
sostituzione
tommaso
X
nonno(tommaso,Z)
nonno(Y,linda)
01: PROgramming in LOGic
X=tommaso
X=tommaso, Y=Z
Y=tommaso, X=linda
19 / 29
Unificazione
Due termini sono unificabili se:
sono lo stesso termine, oppure
contengono variabili che possono essere istanziate (sostituite) con
termini in modo tale da rendere uguali i due termini
Unificabili
termini
tommaso
tommaso
nonno(X,Y)
nonno(tommaso,X)
sostituzione
tommaso
X
nonno(tommaso,Z)
nonno(Y,linda)
X=tommaso
X=tommaso, Y=Z
Y=tommaso, X=linda
Non unificabili
tommaso
vittorio
nonno(tommaso,X) nonno(vittorio,linda)
nonno(tommaso,X)
nonno(X,linda)
(Logica per l’Informatica)
01: PROgramming in LOGic
19 / 29
Unificazione e uguaglianza
?- tommaso=tommaso.
true.
(Logica per l’Informatica)
01: PROgramming in LOGic
20 / 29
Unificazione e uguaglianza
?- tommaso=tommaso.
true.
?- tommaso=X.
X = tommaso.
(Logica per l’Informatica)
01: PROgramming in LOGic
20 / 29
Unificazione e uguaglianza
?- tommaso=tommaso.
true.
?- tommaso=X.
X = tommaso.
?- nonno(X,Y), nonno(tommaso,Z).
X = tommaso,
Y = linda,
Z = linda.
(Logica per l’Informatica)
01: PROgramming in LOGic
20 / 29
Unificazione e uguaglianza
?- tommaso=tommaso.
true.
?- tommaso=X.
X = tommaso.
?- nonno(X,Y), nonno(tommaso,Z).
X = tommaso,
Y = linda,
Z = linda.
?- nonno(X,Y) = nonno(tommaso,Z).
X = tommaso,
Y = Z.
(Logica per l’Informatica)
01: PROgramming in LOGic
20 / 29
Unificazione e uguaglianza
?- tommaso=tommaso.
true.
?- tommaso=X.
X = tommaso.
?- nonno(X,Y), nonno(tommaso,Z).
X = tommaso,
Y = linda,
Z = linda.
?- nonno(X,Y) = nonno(tommaso,Z).
X = tommaso,
Y = Z.
?- nonno(tommaso,X) = nonno(Y,linda).
X = linda,
Y = tommaso.
(Logica per l’Informatica)
01: PROgramming in LOGic
20 / 29
Unificazione e uguaglianza
?- nonno(tommaso,X) = nonno(X,linda).
false.
L’algortimo di unificazione sostituisce le variabili via via che trova come
rendere uguali dei sottotermini
(Logica per l’Informatica)
01: PROgramming in LOGic
21 / 29
Unificazione e uguaglianza
?- nonno(tommaso,X) = nonno(X,linda).
false.
L’algortimo di unificazione sostituisce le variabili via via che trova come
rendere uguali dei sottotermini
nonno(tommaso,X)
nonno(X,linda)
(Logica per l’Informatica)
=⇒ X=tommaso
01: PROgramming in LOGic
21 / 29
Unificazione e uguaglianza
?- nonno(tommaso,X) = nonno(X,linda).
false.
L’algortimo di unificazione sostituisce le variabili via via che trova come
rendere uguali dei sottotermini
nonno(tommaso,tommaso)
nonno(tommaso,linda)
=⇒ X=tommaso, NO
?- X=tommaso, X=vittorio.
false.
Quando due termini vengono unificati, il Prolog applica le sostituzioni
dappertutto (fino alla fine del goal).
X=tommaso, X=vittorio
X=tommaso X=vittorio (tommaso=vittorio) ⇒ false
(Logica per l’Informatica)
01: PROgramming in LOGic
21 / 29
Algoritmo di unificazione (intuizione)
p(X,f(c),X)
=⇒ X=f(Y)
p(f(Y),Y,Z)
nuovo problema:
(Logica per l’Informatica)
p(f(Y),f(c),f(Y))
p(f(Y),Y,Z)
01: PROgramming in LOGic
22 / 29
Algoritmo di unificazione (intuizione)
p(X,f(c),X)
=⇒ X=f(Y)
p(f(Y),Y,Z)
nuovo problema:
p(f(Y),f(c),f(Y))
p(f(Y),Y,Z)
p(f(Y),f(c),f(Y))
=⇒ Y=f(c), X=f(f(c))
p(f(Y),Y,Z)
nuovo problema:
(Logica per l’Informatica)
p(f(f(c)),f(c),f(f(c)))
p(f(f(c)),f(c),Z)
01: PROgramming in LOGic
22 / 29
Algoritmo di unificazione (intuizione)
p(X,f(c),X)
=⇒ X=f(Y)
p(f(Y),Y,Z)
nuovo problema:
p(f(Y),f(c),f(Y))
p(f(Y),Y,Z)
p(f(Y),f(c),f(Y))
=⇒ Y=f(c), X=f(f(c))
p(f(Y),Y,Z)
nuovo problema:
p(f(f(c)),f(c),f(f(c)))
p(f(f(c)),f(c),Z)
p(f(f(c)),f(c),f(f(c)))
=⇒ Z=f(f(c)), Y=f(c), X=f(f(c))
p(f(f(c)),f(c),Z)
(Logica per l’Informatica)
01: PROgramming in LOGic
22 / 29
Algoritmo di unificazione (intuizione)
p(X,f(c),X)
=⇒ X=f(Y)
p(f(Y),Y,Z)
nuovo problema:
p(f(Y),f(c),f(Y))
p(f(Y),Y,Z)
p(f(Y),f(c),f(Y))
=⇒ Y=f(c), X=f(f(c))
p(f(Y),Y,Z)
nuovo problema:
p(f(f(c)),f(c),f(f(c)))
p(f(f(c)),f(c),Z)
p(f(f(c)),f(c),f(f(c)))
=⇒ Z=f(f(c)), Y=f(c), X=f(f(c))
p(f(f(c)),f(c),Z)
nuovo problema:
(Logica per l’Informatica)
p(f(f(c)),f(c),f(f(c)))
p(f(f(c)),f(c),f(f(c)))
01: PROgramming in LOGic
22 / 29
Occur check
X e padre(X) sono unificabili?
(Logica per l’Informatica)
01: PROgramming in LOGic
23 / 29
Occur check
X e padre(X) sono unificabili?
X
=⇒ X=padre(X) ?
padre(X)
nuovo problema:
padre(X)
padre(padre(X))
padre(X)
=⇒ X=padre(padre(X)) ?
padre(padre(X))
Occur check: è possibile unificare una variabile X con un termine solo se X
non occorre nel termine.
(Logica per l’Informatica)
01: PROgramming in LOGic
23 / 29
Occur check
X e padre(X) sono unificabili?
X
=⇒ X=padre(X) ?
padre(X)
nuovo problema:
padre(X)
padre(padre(X))
padre(X)
=⇒ X=padre(padre(X)) ?
padre(padre(X))
Occur check: è possibile unificare una variabile X con un termine solo se X
non occorre nel termine.
Ma l’unificazione del Prolog non esegue l’occur check:
?- X = padre(X).
X=padre(padre(padre(...))).
(Logica per l’Informatica)
01: PROgramming in LOGic
23 / 29
Occur check
X e padre(X) sono unificabili?
X
=⇒ X=padre(X) ?
padre(X)
nuovo problema:
padre(X)
padre(padre(X))
padre(X)
=⇒ X=padre(padre(X)) ?
padre(padre(X))
Occur check: è possibile unificare una variabile X con un termine solo se X
non occorre nel termine.
Ma l’unificazione del Prolog non esegue l’occur check:
?- X = padre(X).
X = padre(**).
(Logica per l’Informatica)
01: PROgramming in LOGic
23 / 29
Occur check
X e padre(X) sono unificabili?
X
=⇒ X=padre(X) ?
padre(X)
nuovo problema:
padre(X)
padre(padre(X))
padre(X)
=⇒ X=padre(padre(X)) ?
padre(padre(X))
Occur check: è possibile unificare una variabile X con un termine solo se X
non occorre nel termine.
Ma l’unificazione del Prolog non esegue l’occur check:
?- X = padre(X).
X = padre(**).
?- unify_with_occurs_check(X,padre(X)).
false.
(Logica per l’Informatica)
01: PROgramming in LOGic
23 / 29
Programmare con l’unificazione
vertical(line(point(X,Y),point(X,Z))).
horizontal(line(point(X,Y),point(Z,Y))).
(Logica per l’Informatica)
01: PROgramming in LOGic
24 / 29
Programmare con l’unificazione
vertical(line(point(X,Y),point(X,Z))).
horizontal(line(point(X,Y),point(Z,Y))).
?- vertical(line(point(1,1),point(1,3))).
true.
(Logica per l’Informatica)
01: PROgramming in LOGic
24 / 29
Programmare con l’unificazione
vertical(line(point(X,Y),point(X,Z))).
horizontal(line(point(X,Y),point(Z,Y))).
?- vertical(line(point(1,1),point(1,3))).
true.
?- vertical(line(point(1,1),point(3,2))).
false.
(Logica per l’Informatica)
01: PROgramming in LOGic
24 / 29
Programmare con l’unificazione
vertical(line(point(X,Y),point(X,Z))).
horizontal(line(point(X,Y),point(Z,Y))).
?- vertical(line(point(1,1),point(1,3))).
true.
?- vertical(line(point(1,1),point(3,2))).
false.
?- horizontal(line(point(1,1),point(1,Y))).
Y = 1.
(Logica per l’Informatica)
01: PROgramming in LOGic
24 / 29
Programmare con l’unificazione
vertical(line(point(X,Y),point(X,Z))).
horizontal(line(point(X,Y),point(Z,Y))).
?- vertical(line(point(1,1),point(1,3))).
true.
?- vertical(line(point(1,1),point(3,2))).
false.
?- horizontal(line(point(1,1),point(1,Y))).
Y = 1.
?- horizontal(line(point(2,3),Point)).
Point = point(_G650, 3).
(Logica per l’Informatica)
01: PROgramming in LOGic
24 / 29
L’aritmetica in Prolog
?- 3+2 = X.
X = 3+2.
(Logica per l’Informatica)
?- 3+2 = 5.
false.
01: PROgramming in LOGic
25 / 29
L’aritmetica in Prolog
?- 3+2 = X.
X = 3+2.
?- X is 3+2.
X = 5.
?- 3+2 = 5.
false.
/* is e non = */
?- 5 is 3+2.
true.
?- X is 3.0 + 2.0.
X = 5.0.
?- X is 3.0 + 2.
X = 5.0.
(Logica per l’Informatica)
01: PROgramming in LOGic
25 / 29
L’aritmetica in Prolog
?- 3+2 = X.
X = 3+2.
?- X is 3+2.
X = 5.
?- 3+2 = 5.
false.
/* is e non = */
?- 5 is 3+2.
true.
?- X is 3.0 + 2.0.
X = 5.0.
?- X is 3.0 + 2.
X = 5.0.
?- 5 is 3+X.
ERROR: is/2: Arguments are not sufficiently instantiated
(Logica per l’Informatica)
01: PROgramming in LOGic
25 / 29
Procedure ricorsive
vicino(tavolo,penna).
vicino(penna,pc).
colore(tavolo,bianco).
colore(penna,rosso).
colore(pc,verde).
colore(X,Y) :- vicino(X,Z), colore(Z,Y).
?- colore(tavolo,C).
C = bianco ;
C = rosso ;
C = verde ;
false.
(Logica per l’Informatica)
01: PROgramming in LOGic
26 / 29
L’abero di ricerca
vicino(tavolo,penna).
vicino(penna,pc).
colore(tavolo,bianco). colore(penna,rosso).
colore(X,Y) :- vicino(X,Z), colore(Z,Y).
C=bianco
colore(tavolo,C)
_X1=tavolo, C=_Y1 vicino(_X1,_Z1),
colore(_Z1,_Y1)
_Z1=penna
colore(_Z1,_Y1)
true
C=_Y1=rosso
true
colore(pc,verde).
_X2=_Z1=penna, C=Y_1=_Y2
vicino(_X2,_Z2),
colore(_Z2,_Y2)
_Z2=pc
colore(_Z2,_Y2)
_X3=_Z2=pc
C=Y_1=_Y2=verde
true
vicino(_X3,_Z3),
colore(_Z3,_Y3)
false
(Logica per l’Informatica)
01: PROgramming in LOGic
27 / 29
Reversibilità dei programmi
vicino(tavolo,penna).
vicino(penna,pc).
colore(tavolo,bianco). colore(penna,rosso).
colore(X,Y) :- vicino(X,Z), colore(Z,Y).
colore(pc,verde).
?- colore(X,rosso).
X = penna ;
X = tavolo ;
false.
?- colore(X,Y).
X = tavolo,
Y = bianco ;
X = penna,
Y = rosso ;
X = pc,
Y = verde ;
X = tavolo,
Y = rosso ;
..........
(Logica per l’Informatica)
01: PROgramming in LOGic
28 / 29
La strategia di ricerca del Prolog
La strategia di ricerca del Prolog visita l’albero di ricerca in profondità:
considera le clausole del programma dall’alto in basso
considera il corpo delle clausole da sinistra a destra
torna indietro (backtrack) sulle scelte sbagliate
Il significato dichiarativo e quello procedurale di un programma possono non
coincidere: il Prolog può espandere un cammino infinito e non trovare mai
una soluzione, anche se una soluzione esiste.
È importante:
l’ordine delle clausole nel programma
l’ordine dei sottogoal nel corpo delle regole
Regole di programmazione:
In una procedura: prima i fatti, poi le regole
Nel corpo di una regola: prima i goal più facili da dimostrare o refutare,
poi quelli più difficili
(Logica per l’Informatica)
01: PROgramming in LOGic
29 / 29
Scarica
Random flashcards
Prova Lavoro

2 Carte nandoperna1

biologia

5 Carte patty28

Triangoli

2 Carte oauth2_google_d2543822-c1b0-4efc-972b-1e120768c5d0

il condizionale

2 Carte oauth2_google_2e587b98-d636-4423-a451-84f012b884f0

economia

2 Carte oauth2_google_89e9ca76-2f16-41bf-8eae-db925cb2be4b

creare flashcard