rtf - DISI

1
Appunti del corso:
Intelligenza Artificiale
Prof. Maurizio Martelli
DISI
Università di Genova
Anno Accademico 1998-99
2
3
AI: Intelligenza Artificiale:
Studio del comportamento intelligente
•
Teoria
dell'intelligenza
che
modelli
il
comportamento di entità naturali intelligenti
e che guidi alla creazione di entità artificiali
capaci di comportamenti intelligenti.
Aspetti ingegneristici:
costruzione di macchine, robot, programmi...
Aspetti scientifici:
rappresentazione della conoscenza, modelli
del cervello, scienze cognitive,...
Ipotesi del sistema di simboli fisico:
(Newell & Simon)
Un sistema di simboli fisico ha i mezzi
necessari
e
sufficienti
per
l'azione
intelligente generalizzata.
Knowledge (Conoscenza): Concetto chiave
procedurale
e
dichiarativo
(accessibile da programmi introspettivi)
vari approcci: logicistico,...
4
Intelligenza Artificiale:
Nascita: 1956, Workshop a Dartmouth College
(organizzato da Mc Carthy)
pattern recognition -> connectionism
manipolazione simbolica -> LISP
sistemi a produzioni, ricerche euristiche
logica-> dimostrazione di teoremi ->P.L.
giochi (ruolo importante)
Problem solving
Risoluzione di problemi con varie tecniche
(ricerca, euristica, ...)
Criteri di valutazione:
>tecniche usate
>risultati ottenuti sperimentalmente
>test di Turing
(distinguere un uomo da un
programma di AI solo attraverso
le risposte a delle domande)
5
Intelligenza Artificiale:
Sviluppo per Aree e Tecniche
Aree che non vedremo:
Elaborazione del Linguaggio Naturale:
HAMRPM (impiegato di un albergo)
GUS (prenotazione aerea)
>understanding, speech recognition,...
Deduzione Automatica:
Dimostratori di teoremi
>verifica di programmi, sintesi di pr.,
dimostratori per logiche non standard...
Visione
Robotica:
FREDDY (Edimburgo)
SHAKEY (Stanford)
6
Programmazione Logica e Prolog

• la PL nasce nei primi anni settanta da studi
sulla deduzione automatica ed un suo primo
prodotto (il Prolog) diventa negli anni molto
noto.
• la PL non è il Prolog ma un settore molto
ricco di studi che cerca di utilizzare la logica
matematica
come
linguaggio
di
programmazione.
• Obiettivi e ragioni di successo:
semplicità del formalismo
linguaggio 'vicino' all'utente
semantica chiara
efficienza
• Prolog è solo il primo passo.
• importanza dello studio della semantica della
PL per capire punti forti e debolezze dei vari
linguaggi e poter sfruttare a pieno le
potenzialità della PL.
7
Programmazione Logica e Prolog

• semantica chiara vs. efficienza
• Logica Matematica (Leibniz - Frege):
formalizzazione del ragionamento
• per anni studiata come formalismo per
studiare i fondamenti della matematica
• con l'avvento dell'informatica:
LM -> Dimostrazione automatica di teoremi
efficienza come problema
interpretazione procedurale di formule
logica come linguaggio di programmazione
• rivalutazione della logica per varie
applicazioni (dalle prove di correttezza dei
programmi alle specifiche, da linguaggio per
la rappresentazione della conoscenza in IA a
formalismo per DB)
8
Stile dichiarativo della PL

• orientato ad utenti non programmatori
• grande potere espressivo
• programma come insieme di formule
(assiomi)
• computazione come costruzione di una
dimostrazione di una formula (goal)
Calcolo dei predicati
del prim'ordine
sintassi
semantica
dim. di
--correttezza-> conseguenza
teoremi <-- copletezza-logica
• limitazione nel tipo di formule (clausole Horn)
e utilizzazione di particolare tecniche per la
dimostrazione di teoremi (unificazione e
risoluzione)
9
Calcolo dei predicati

• linguaggio per esprimere concetti e loro
relazioni
e
che
permette
di
inferire
proposizioni da altre considerate vere.
SINTASSI
(si prescinde dal significato)
• Alfabeto (a,b,...,A,B,...,(,),...,≤,
• Simboli:
- Costanti
di oggetti:

C (a,b,casa, 23, ...
di funzione: F (+,-, padre, ...) con arità
di predicato: P (<,=,pari,...) con arità
- Variabili: V (X,Y,...)
• Termini:
i) una variabile XV è un termine
ii) una costante cC è un termine
iii) l’applicazione (f(t1,...,tn)) di un simbolo di
funzione n-ario fF ad n termini t1,...,tn è un
termine
iv) non esistono altri termini
termine ground - senza variabili
(oggetti dell'Universo del discorso)
Es.: padre(padre(giovanni))
10
Calcolo dei predicati

• Atomi: {p(t1,..,tn) |p P, t1,..,tn termini}
Es.:
fattoriale (3,6)
uomo(paolo)
maggiore(X,3)
maggiore(più(X,1),Y)
ama(giovanni,maria)
ama(padre(giovanni),giovanni)
ama(padre(padre(giovanni)),giovanni)
maggiore(più(più(1,giovanni),Y),padre(3))
• Formule Ben Formate (fbf):
- Atomi
- frasi logiche: se F, F1, F2 sono fbf
- negazione ~F
- congiunzione F1 F2
- disgiunzione F1 F2
- implicazione F1 F2
- equivalenza F1 F2
- frasi quantificate: se Fè una fbf e X V
- universalmente (X.F)
- esistenzialmente (X.F)
- non esistono altre fbf
11
Calcolo dei predicati

• Il linguaggio del prim’ordine definito da un
alfabeto è l’insieme di tutte le fbf costruite con i
simboli dell’alfabeto
• Occorrenza di variabile vincolata
i) se compare all’interno di un quantificatore
ii) se compare nello scope di un
quantificatore per quella variabile
• Una variabile è libera in una fbf se
almeno una sua occorrenza è non vincolata
• Una formula è chiusa se non contiene
variabili libere
• Se f è una formula aperta, (f) e (f) denotano
le chiusure esistenziale e universale di f
• importanza dell' ordine dei quantificatori.
• Ordine: primo, secondo, ... omega
12
LINGUAGGI DEL PRIM’ORDINE:
SINTASSI, ESEMPI
• un esempio filosofico
(X)(uomo(X)  mortale(X))  uomo(socrate) 
mortale(socrate)
• due degli assiomi di base dei numeri naturali
(interpretare
• f e g come funzioni successore e
predecessore
• la costante 0 come zero
• il predicato u come uguaglianza )
(X)(Y)(u(Y,f(X))  (Z)(u(Z,f(X))  u(Y,Z)))
(X)( ~u(X,0) 
((Y)(u(Y,g(X))  (Z)(u(Z,g(X))  u(Y,Z)))))
• nella formula (X)p(X,Y), tutte le occorrenze di
X sono vincolate, mentre Y è libera
• Y è libera anche nella formula
(X)p(X,Y)  (Y)q(Y)
13
Calcolo dei predicati

SEMANTICA
(relazione tra frasi e concetti)
Dare una interpretazione alle espressioni
sintatticamente corrette. Definire se certe
espressioni sono vere o false in base al
significato che si dà ai componenti l'espressione.
• Interpretazione (I):
- Dominio D
CaD
funzione da F a (DnD)
funzione da P a (Dn{T,F})
- funzione da
-
• interpretazione intesa, altre int.
• assegnamento di variabili (U):
- funzione da V a D
• assegnamento di termini: (T)
combinazione di I ed U
14
Calcolo dei predicati

• soddisfacimento (  I ):  I F[U]
vale se F è vera per I e U, cioè interpretata
nel dominio D di I.
-  I p(t1,..,tn)[U] iff pI(T(t1),..,T(tn)) = T
-
I
~F[U] iff
F[U] non è vera
-
I
F1 F2[U] iff
I
-
I
F1 F2[U] iff
I

-
I
F1 F2[U] iff
I
F1[U] o non
I
I
F1 F2[U] iff
I
F1 F2[U] e
 I F2
-
I
-
I
I
F1[U] e
F1[U] o
I
I
F2[U]
F2[U]
F2[U]
F1[U]
(X.F)[U] iff per ogni d D  I F[V]
con V identica ad U tranne che V(X)=d.
(X.F)[U] iff per qualche d D  I F[V]
con V identica ad U tranne che V(X)=d.
• una interpretazione I che soddisfa F per tutti i
possibili assegnamenti di variabile si dice un
MODELLO di F:  I F
15
LINGUAGGI DEL PRIM’ORDINE:
SEMANTICA, ESEMPI
f
=
(X) p(X)  q(f(X),a)
un’interpretazione I
D = {1,2}
[a] = 1
[f(1)] = 2
[f(2)] = 1
[p(1)] = F
[p(2)] = T
[q(1,1)] = T[q(1,2)] = T
[q(2,1)] = F[q(2,2)] = T
la valutazione di f in I è T (I è un modello di f),
se X=1,
p(1)  q(f(1),a) =
p(1)  q(2,1) =
FF=T
se X=2,
p(2)  q(f(2),a) =
p(2)  q(1,1) =
TT=T
16
LINGUAGGI DEL PRIM’ORDINE:
SEMANTICA, ESEMPI
f
=
(X) (Y) p(X)  q(X,Y)
un’interpretazione I
D = {1,2}
[a] = 1
[f(1)] = 2
[f(2)] = 1
[p(1)] = F
[p(2)] = T
[q(1,1)] = T[q(1,2)] = T
[q(2,1)] = F[q(2,2)] = T
la valutazione di f in I è F (I non è un modello di
f),
se X=1,
se Y=1,
p(1)  q(1,1) = F
se Y=2,
p(1)  q(1,2) = F
17
Calcolo dei predicati

• una interpretazione I che soddisfa tutte le
formule di un insieme T (teoria) per tutti i
possibili assegnamenti di variabile si dice un
MODELLO di T:  I T
• F è conseguenza logica di una teoria T :
T F
iff ogni modello di T è anche modello di F
• T è soddisfacibile
iff
T ha almeno un modello
• T è insoddisfacibile (inconsistente)
iff
T non ha alcun modello
F
• F è valida
iff
F è soddisfatta per ogni I e per ogni U (ogni
interpretazione è un modello)
18
Calcolo dei predicati

• teoria assiomatica
- assiomi logici
(logicamente validi)
- assiomi non logici (conoscenza specifica)
- regole di inferenza (permettono di
ricavare nuove fbf da insiemi di fbf)
Es: Modus Ponens:
A
BA
B
• dimostrazione :
sequenza finita di fbf (f1,..,fn), ciascuna delle
quali è un assiomi o è derivata dalle precedenti
mediante una regola di inferenza.
• teorema: ultima formula di una dimostrazione
• se T è un insieme di formule (assiomi non
logici)  T A indica che A è un teorema per
la teoria T.
•
A indica che A è un teorema (formula
logicamente valida)

19
Equivalenza tra sintassi e semantica

• Correttezza:
i teoremi di una teoria sono veri in tutti i
modelli della teoria
• Completezza:
le fbf che sono vere in tutti i modelli della
teoria (seguono logicamente dagli assiomi)
sono teoremi della teoria.
• il calcolo dei predicati del prim'ordine è
corretto e completo (nel caso di assenza di
assiomi non logici, i teoremi coincidono con
le formule valide)
20
PROLOG
Fatti (DB)
padre (giovanni, maria).
padre (carlo, giulio).
madre(maria, ettore).
Domande (Queries)
?-padre (giovanni, maria).
risposta:
Yes
(cons. logica del DB)
?-padre (giovanni, carlo).
risposta:
No
(fallimento nella
dimostrazione)
Domande esistenziali (con variabili logiche)
?-padre (X, maria).
risposta:
X=giovanni
?-padre (X, Y).
risposte:
X=giovanni, Y= maria
X=carlo, Y= giulio
21
PROLOG
Fatti universali
più (0,X,X).
append(X,[],X).
Domande
?-più (0,2,2).
risposta:
Yes
risposta:
No
risposta:
X=3
risposta:
X=0, Y =3
?-più (0,2,1).
?-più (0,3,X).
?-più (X,3,Y).
Domande congiuntive e var. a comune
?-più (0,2,2),padre (giovanni, maria).
risposta: Yes
?-più (0,2,2),padre (giovanni, carlo).
risposta: No
?-più (0,0,X),più (X,Y,1).
risposta: X=0, Y =1
Regole (lettura procedurale e dichiarativa)
più (s(X),Y,s(Z)) :- più (X,Y,Z).
figlio(X,Y):-padre(Y,X),maschio(X).
figlia(X,Y):-padre(Y,X),femmina(X).
nonno(X,Y):-padre(X,Z),padre(Z,Y).
22
PROLOG
Programma logico
padre(terach,abramo).
padre(terach,nachor).
padre(terach,haran).
padre(abramo,isacco).
padre(haran,lot).
padre(haran,milcah).
padre(haran,yiscah).
maschio(terach).
maschio(abramo).
maschio(nachor).
maschio(haran).
maschio(isacco).
maschio(lot).
madre(sara,isacco).
femmina(milcah).
femmina(sara).
femmina(yiscah).
genitore(X,Y):-padre(X,Y).
genitore(X,Y):-madre(X,Y).
figlio(X,Y):-genitore(Y,X),maschio(X).
figlia(X,Y):-genitore(Y,X),femmina(X).
nonno/a(X,Y):-genitore(X,Z),genitore(Z,Y).
Domande
?-figlio(X,haran).
Albero SLD con regola di selezione leftmost
visitato in depth first
X=lot
23
Database programming
Schemi di relazioni (DB estensionale):
padre(Padre,Figlio/a)
madre(Madre,Figlio/a)
maschio(Persona)
femmina(Persona)
Altre relazioni (DB intensionale) derivate
procreato(Uomo,Donna):padre(Uomo,Figlio),madre(Donna,Figlio).
fratello(Fratello,Fra/Sor):genitore(Genitore,Fratello),
genitore(Genitore,Fra/Sor),
maschio(Fratello),
Fratello≠Fra/Sor.
(*)
(*) altrimenti ?-fratello(X,X). avrebbe successo,
≠ può essere definita con una tabella.
zio(Zio,Pers):-
fratello(Zio,P),genitore(P,Pers).
fra/sor(Per1,Per2):genitore(Genitore,Per1),
genitore(Genitore,Per2), Per1≠Per2.
cugino(Cug1,Cug2):genitore(Gen1,Cug1),genitore(Gen2,Cug2),
fra/sor(Genitore1,Genitore2).
madre(Donna):-madre(Donna,Figlio).
24
Database programming
Dati strutturati:
corso(lp,lunedì,14,15,maurizio,martelli,
matematica,aula-R).
corso(lp, orario(lunedì,14,15),
insegnante(maurizio,martelli),
luogo(matematica,aula-R)).
Programma:
insegna(Insegnante,Corso):corso(Corso,Orario,Insegnante,Luogo).
durata(Corso,Durata):corso(Corso,orario(Giorno,X,Y),
Insegnante,Luogo), +(X,Durata,Y).
occupato(Insegnante,Giorno):corso(Corso,orario(Giorno,X,Y),
Insegnante,Luogo).
stanza_occupata(Luogo,Giorno,Ora):corso(Corso,orario(Giorno,X,Y),
Insegnante,Luogo), X≤Ora, Ora≤Y.
25
Regole ricorsive
Antenato come chiusura transitiva di genitore
antenato(Antenato, Persona):genitore(Antenato, Persona).
antenato(Antenato, Persona):genitore(Antenato, Figlio),
antenato(Figlio, Persona).
Grafi:
edge(a,b).
edge(a,c).
edge(b,d).
edge(c,d).
edge(d,e).
edge(f,g).
connesso(Nodo1,Nodo2)
relazione tra due nodi connesi nel grafo
definito dalla relazione edge.
connesso(Nodo,Nodo).
connesso(Nodo1,Nodo2):edge(Nodo1,Nodo3),connesso(Nodo3,Nodo2).
26
UN ESEMPIO
Il programma
1. più (0,x,x) 
2. più (succ(x),y,succ(z) )  più (x,y,z)
• Una chiamata di procedura con i primi due
parametri come input:

più (succ(succ(0)),succ(0),z)
risposta:
z/succ(succ(succ(0)))
• Una chiamata di procedura
parametro come input:

con
l’ultimo
più (x,y,succ(0))
risposte:
x/0, y/succ(0)
x/succ(0), y/0
• Una chiamata di procedura con l’ultimo
parametro come input e il primo parzialmente
istanziato:

più (succ(x),y,succ(0))
risposta:
x/0, y/0
27
SOSTITUZIONI
• una sostituzione è un insieme finito della
forma
{v1  t1,…, vn  tn}
• vi è una variabile
• ti è un termine diverso da vi
• le variabili vi, i=1,…,n sono tra loro distinte
• una sostituzione è una funzione da variabili
a termini
• la sostituzione vuota è denotata da 
• una sostituzione è ground se tutti i ti,
i=1,…,n sono ground
• siano = {v1  t1,…, vn  tn} una
sostituzione ed E una espressione (termine,
atomo, insieme di termini, etc.)
• l’applicazione di  ad E è l’espressione
ottenuta da E sostituendo simultaneamente
ogni occorrenza della variabile vi, i=1,…,n con
il termine ti
• il risultato dell’applicazione (denotato da E)
è una istanza di E
• la sostituzione  è grounding per l'espressione
E se E è una istanza ground di E
28
SOSTITUZIONI
• siano  = {X1  t1,…, Xn  tn} e
= {Y1 u1,…, Ym  um} due sostituzioni
la composizione di e (denotata da ) è
la sostituzione così definita
i)
costruiamo l’insieme
{X1  t1,…, Xn 
um}
ii)
tn, Y1 u1,…, Ym

eliminiamo dall’insieme gli elementi
Xi  titali che
ti = Xi
iii) eliminiamo dall’insieme gli elementi
Yj  uj tali che
Yj occorre in {X1,…, Xn}
• anticipiamo alcune delle proprietà delle
sostituzioni, che studieremo più avanti
• la composizione di sostituzioni è
associativa
() =  ( )
• la sostituzione vuota è identità sia sinistra
che destra
 =  = 
29
SOSTITUZIONI: ESEMPIO
 = {X  f(Y), Y  Z}
= {X  a, Y  b, Z 
Y}
costruzione di 
i)
{X f(b), Y 
Y, X  a, Y  b, Z
ii)
{X  f(b), X 
iii)
{X  f(b), Z
costruzione di
a, Y  b, Z 

{X  a, Y b, Z
ii)
{X a, Y  b, X 
{X 
Y}
Y}
Y}

i)
Z}
iii)

a, Y  b}
 Z, X
f(Y), Y 
f(Y), Y 
Z}
30
UNIFICAZIONE DI INSIEMI DI
ESPRESSIONI
• sia dato un insieme di espressioni (termini,
atomi, etc.) {E1,…, Ek}
una sostituzione  è un unificatore per
{E1,…, Ek} se e solo se E1= E2 = …= Ek
• un insieme {E1,…, Ek} è unificabile se e solo
se esiste una sostituzione  tale che  è un
unificatore per {E1,…, Ek}
• l’insieme {p(a,Y), p(X,f(b))} è unificabile
dato che la sostituzione = {X  a, Y 
f(b)}
è un unificatore per l’insieme
• un unificatore  per l’insieme {E1,…, Ek} è
l’unificatore più generale (most general
unifier, mgu) se e solo se per ogni unificatore
 dell’insieme {E1,…, Ek} esiste una
sostituzione  tale che  = 
• esiste un algoritmo (algoritmo di
unificazione), che, dato un insieme di
espressioni E = {E1,…, Ek},
rivela la sua non unificabilità, oppure
calcola un unificatore più generale per E
31
MGU DI DUE ESPRESSIONI:
UN ALGORITMO NAïF
• inizia con t1 , t2 ed una sostituzione  0
inizialmente vuota; i:=0
• scandisci le due espressioni da sinistra a
destra
• se le due espressioni sono uguali, termina
con successo e restituisci la corrente
sostituzione  k (mgu di {t1 , t2})
• altrimenti, i:=i+1 e siano t1,i and t2,i le
prime due sottoespressioni diverse:
• se nè t1,i nè t2,i sono una variabile,
termina con fallimento
• altrimenti, supponiamo che t1,i sia la
variable V
• se t2,i contiene V, termina con fallimento
• altrimenti,
• applica la sostituzione {V  t2,i} a
t1 e t2
•  i =  i-1 {V  t2,i}
• riprendi la scansione delle
espressioni dove era stata sospesa
• da notare che le sostituzioni cicliche
causano fallimento (l’occur check è
necessario!)
• vedremo nel seguito un diverso algoritmo ed
il teorema di unificazione
32
MGU DI DUE ESPRESSIONI:
UN ESEMPIO
E = {p(a,X,f(g(Y))), p(Z,f(Z),f(U))}
 0 = 
t1,1 = a
t2,1
µ1 =   {Z a} = {Z  a}
E1 = {p(a,X,f(g(Y))), p(a,f(a),f(U))}
t1,2 = X
t2,2 = f(a)
µ2 = {Z  a}  {X  f(a)} = {Z  a, X  f(a)}
E2 = {p(a,f(a),f(g(Y))), p(a,f(a),f(U))}
t1,3 = g(Y)
µ3 = {Z a, X  f(a)}  {U  g(Y)} =
{Z  a, X  f(a), U g(Y)}
E3 = {p(a,f(a),f(g(Y))), p(a,f(a),f(g(Y)))}
µ3 è un mgu per E
Teorema
Se W è un insieme di espressioni finito, non
vuoto ma unificabile, allora l'algoritmo di
unificazione terminerà sempre al passo del
successo e l'ultima sostituzione finale è un m.g.u.
per W.
t2,3
33
Clausole

• disgiunzione di atomi o negazioni di atomi, in
cui le variabili sono implicitamente
quantificate universalmente
A1 A2 AnB1 B2 ~Bm
• clausola vuota [] corrisponde a F
• è equivalente a
(A1 A2 An)B1 B2 Bm)
che si scrive (conclusione premesse)
A1A2 AnB1 B2 Bm
• insieme di clausole: congiunzione di clausole.
34
IL PRINCIPIO DI RISOLUZIONE NEL
CALCOLO PROPOSIZIONALE
• siano c1 e c2 due clausole qualunque
c1 = a11  a21  …  an1
c2 = a12  a22  …  am2
tali che i letterali ai1 e aj2 sono complementari
• il risolvente di c1 e c2 è la clausola
a11 …  ai-11 ai+11 …  an1
a12…  aj-12 aj+12 …  an2
• disgiunzione delle clausole ottenute
eliminando i letterali complementari
• esempi
• c1 = p  r
c1,2 =r  q
• c1 = ~p  q  r
c2 = ~q  s
c1,2 = ~p  r  s
• c1 = ~p  q
c1,2 non esiste
• il risolvente, se esiste, di due clausole
unitarie è la clausola vuota []
c2 =
c2 =
35
Clausole Horn

• clausola con al più un letterale positivo
• clausole definite:
- regole
AB1 B2 Bm.
- fatti
A.
• clausole negative: (goal)
     B1 B2 Bm.
• clausole Horn sono un sottinsieme vero delle
clausole: non tutte le formule del calcolo dei
predicati del prim'ordine sono esprimibili con
esse.
• clausole definite esprimono 'conoscenza'
programma logico = insieme di cl. definite
• clausole negative:
domanda
X1Xn.B1 B2 Bm)
negazione per applicare la refutazione
~X1Xn.B1 B2 Bm)
X1Xn.B1 ~B2 ~Bm)
   B1 B2 Bm.
36
Risoluzione SLD

• risoluzione Lineare con funzione di Selezione
per clausole Definite.
• si parte da un insieme di clausole definite (il
programma P) ed un'unica clausola negativa
(il goal G)
• ogni risolvente è sempre ottenuto da una
clausola definita ed una negativa, riottenendo
così un'altra clausola negativa (il nuovo goal)
• si deve selezionare a quale letterale del goal
applicare la risoluzione (regola di sel. R).
• una derivazione SLD è una sequenza
massimale (finita o no) di goal (G0G1 di
clausole di P (c0 c1) e di sostituzioni (0
1):
- G0 è il goal iniziale G
- ci non ha variabili a comune con G,ci,...,ci-1
- Gi+1 è ottenuto da
Gi = A1 A2 Am e ci = AB1 B2
Bn
[Aj]i= [A]i
Gi+1 = [A1Aj-1B1 B2 BnAj+1 Am]i
37
Risoluzione SLD
• Esempio di derivazione SLD:
G •
G1 •
G •
2.
.
.
G
n-1
•
• C 
1
1
• C
2
 2
• Cn  n
Gn •
.
.
.
• una refutazione è una sequenza di goal che
termina con il goal vuoto.
• una derivazione finita che non termina con la
clausola vuota è detta fallita.
38
Risoluzione SLD
• le clausole utilizzate nella derivazione si
dicono di input e per evitare problemi sono
applicate dopo aver ridenominato tutte le
variabili.
• una sostituzione di risposta computata (c.a.s.)
per P  {G} è la sostituzione ottenuta
restringendo alle variabili di G01n in una
refutazione.
• è una vera computazione perchè non solo
dimostra una formula quantificata
esistenzialmente, ma costruisce un testimone
di questa prova.
• Sia P un programma, G il goal  A1, ..., An e
una risposta per P {G}. è una risposta
corretta per P {G} se (( A1  ... An)) è una
conseguenza logica di P.
39
REGOLA DI RICERCA

•
Sia P un programma, G un goal e R una regola
di selezione. Un albero SLD per P {G} via R è
definito come segue:
- ciascun nodo dell’albero è un goal
(possibilmente vuoto)
- la radice dell’albero è il goal G
- sia  A1 ,..., Am, ..., An un nodo nell’albero e
Am l’atomo selezionato da R. Allora questo
nodo ha un discendente per ciascuna
clausola A  B1, ..., Bq del programma tale
che A e Am sono unificabili. Il discendente
è  (A1 ,..., Am-1, B1, ..., Bq, Am+1 ..., An) ,
•
•
•
dove è un mgu tra Am e A.
Una regola di ricerca è un metodo di visita
degli alberi SLD per cercare i rami di successo.
Una procedura di refutazione SLD è specificata
da una regola di selezione e da una regola di
ricerca.
Regole di selezione diverse portano a differenti
alberi SLD.
• Il numero di cammini di successo è lo stesso in
tutti gli alberi SLD (se in numero finito).
40
•
La regola di selezione influenza solamente il
numero di cammini di fallimento (includendo
quelli infiniti).
UN ESEMPIO
 P(y,z), Q(x,y)
2. P(x,x) 
3. Q(a,b) 
1. P(x,z)
La query
• Albero di ricerca (regola rightmost)
<-- p(x,b) •
1
<-- p(y,b), q(x,y)
2
•
x=a
y=b
3
<-- p(b,b) •
2
1
•
•
<-- p(y,b), q(b,y)
fallimento finito
• Albero di ricerca (regola leftmost)
x=b
•
4.
 P(x,b)
41
•
<-- p(x,b)
2
1
x=b
•
•
2
1
<-- p(w,b), q(y,w), q(x,y)
<-- ... •
fallimento infinito
• <-- q(x,b)
2 w=b
3
x=a
• <-- q(y,b), q(x,y)
•
1
y=b
•
1
<-- ...
<-- p(y,b), q(x,y)
•
3 y=a
2
•
INTERPRETAZIONE
PROGRAMMI LOGICI
• <-- q(x,a)
fallimento finito
PROCEDURALE
DEI
• Clausole definite =Dichiarazioni di procedura
• Clausola goal =Insieme di chiamate di
procedura
• Clausola vuota =Comando di terminazione
• Dichiarazione di procedura
A
:- B, C, D
intestazione
corpo della procedura
• Le procedure possono essere ricorsive. Una
definizione di procedura è diversa da una
definizione (possibilmente condizionale) in un
linguaggio funzionale:
-
viene definita una relazione.
42
le diverse clausole della definizione
possono “sovrapporsi” (una procedura può
essere espansa nondeterministicamente).
• Una chiamata di procedura è gestita dalla regola
di inferenza (risoluzione), che realizza una
forma di “copy rule”: rimpiazza la chiamata di
procedure con una copia del corpo della
procedura (con le opportune associazioni tra
parametri formali e parametri attuali).
• Una differenza rispetto alle procedure standard
sta nel passaggio dei parametri e nella
restituzione dei valori (unificazione e variabili
logiche).
43
UNIFICAZIONE E VARIABILI LOGICHE
• L’unificazione di una chiamata di procedura
con una intestazione di procedura definisce:
• passaggio di parametri, quando una variabile
nella intestazione della procedura viene legata
ad un termine non variabile.
• restituzione di valori , quando una variabile
nella chiamata di procedura viene legata ad un
termine non variabile.
• Una variabile nella intestazione di una
procedura può funzionare diversamente in
differenti
chiamate
(invertibilità
delle
procedure).
• Un parametro può funzionare parzialmente
come input e parzialmente come output: un
valore “parziale” può essere passato ad una
procedura, che ne calcola una ulteriore
approssimazione e restituisce il valore così
ottenuto al chiamante.
• Principali differenza tra procedure standard e
procedure logiche:
• nondeterminismo e ricerca.
• variabili logiche e unificazione.
44
Programmazione ricorsiva
Tipi di dato ricorsivi
naturali: 0, s(N)
liste: [], [E|L]
Aritmetica
nat(0).
nat(s(X)):-nat(X).
0≤X:-nat(X). 0<s(X):-nat(X).
s(X)≤s(Y):-X≤Y.
s(X)<s(Y):-X<Y.
più(0,X,X):-nat(X).
più(s(X),Y,s(Z)):-più(X,Y,Z).
per(0,X,0):-nat(X).
per(s(X),Y,Z):-per(X,Y,W),più(W,Y,Z).
exp(s(X),0,0):-nat(X).
exp(0,s(X),s(0)):-nat(X).
exp(s(N),X,Y):-exp(N,X,Z),per(Z,X,Y).
fatt(0,s(0)).
fatt(s(N),F):-fatt(N,Z),per(Z,s(N),F).
minimo(N1,N2,N1):-N1≤N2.
minimo(N1,N2,N2):-N2≤N1.
*mod(X,Y,Z):-Z<Y,per(Y,Q,W),più(W,Z,X).
mod(X,Y,X):-X<Y.
mod(X,Y,Z):-più(W,Y,X),mod(W,Y,Z).
45
Programmazione ricorsiva
ackermann(0,N) = N+1
ackermann(M,0) = ackermann(M-1,1)
ackermann(M,N) =
ackermann(M-1,ackermann(M,N-1))
ackermann(0,N,s(N)).
ackermann(s(M),0,V):-ackermann(M,s(0),V).
ackermann(s(M),s(N),V):ackermann(s(M),N,V1),
ackermann(M,V1,V).
mcd(X,Y,Mcd) :- mod(X,Y,Z),mcd(Y,Z,Mcd).
mcd(X,0,X):-X>0.
46
Programmazione ricorsiva - Liste
list([]).
list([E|L]):- list(L).
member(X,[X|L]).
member(X,[Y|L]):-member(X,L).
prefix([],L).
prefix([X|L1],[X|L2]):-prefix(L1,L2).
suffix(L,L).
suffix(L1,[X|L2]):-suffix(L1,L2).
append([],L,L).
append([X|L1],L2,[X|L3]):-append(L1,L2,L3).
length([],0).
length([X|L],s(N)):-length(L,N).
a) sublist(L1,L2):-prefix(L3,L2),suffix(L1,L3).
b) sublist(L1,L2):-suffix(L3,L2),prefix(L1,L3).
c) sublist(L1,L2):-prefix(L1,L2).
sublist(L1,[X|L2]):-sublist(L1,L2).
d) sublist(X,AXB):append(A,XB,AXB),append(X,B,XB).
e) sublist(X,AXB):append(AX,B,AXB),append(A,X,AX).
member(X,L):-sublist([X],L).
member(X,L):-append(L1,[X|L2],L).
adjacent(X,Y,L):-append(L1,[X,Y|L2],L).
last(X,L):-append(L1,[X],L).
47
Programmazione ricorsiva - Liste
Naive reverse
reverse([],[]).
reverse([X|L1],L2):reverse(L1,L3),append(L3,[X],L2).
Reverse-accumulate
reverse(L1,L2):-reverse(L1,[],L2).
reverse([X|L1],Acc,L2):-reverse(L1,[X|Acc],L2).
reverse([],L,L).
Sort (permutation)
sort(L1,L2):-permutation(L1,L2),ordered(L2).
permutation(L1,[X|L2]):select(X,L1,L3),permutation(L3,L2).
permutation([],[]).
ordered([X]).
ordered([X,Y|L]):-X≤Y,ordered([Y|L]).
select(X,[X|L],L).
select(X,[Y|L1],[Y|L2]):-select(X,L1,L2).
Sort (insertion)
sort([X|L1],L2):-sort(L1,L3),insert(X,L3,L2).
sort([],[]).
insert(X,[],[X]).
insert(X,[Y|L1],[Y|L2]):-X>Y,insert(X,L1,L2).
insert(X,[Y|L],[X,Y|L]):-X≤Y.
48
Programmazione ricorsiva - Liste
Quicksort
quicksort([X|L1],L2):partition(L1,X,Littles,Bigs),
quicksort(Littles,Ls),
quicksort(Bigs,Bs),
append(Ls,[X|Bs],L2).
quicksort([],[]).
partition([X|L],Y,[X|Ls],Bs):- X≤Y,
partition(L,Y,Ls,Bs).
partition([X|L],Y,Ls,[X|Bs]):- X>Y,
partition(L,Y,Ls,Bs).
partition([],Y,[],[]).
Alberi binari
bt(void).
bt(tree(Element,Left,Right)):bt(Left),bt(Right).
Torre di Hanoi
hanoi(s(0),A,B,C,[A to B]).
hanoi(s(N),A,B,C,Moves):hanoi(N,A,C,B,Ms1),
hanoi(N,C,B,A,Ms2),
append(Ms1,[A to B|Ms2],Moves).
49
Derivate
der(Espressione,Variabile,Derivata)
con: x, y, z, ... , 0, s, +, -, *, /, ^,e, sin, cos, log
der(X,X,s(0)).
der(X^s(N),X,s(N)*X^N).
der(sin(X),X,cos(X)).
der(cos(X),X,-sin(X)).
der(e^X,X,e^X).
der(log(X),X,1/X).
der(F+G,X,DF+DG):der(F,X,DF),der(G,X,DG).
der(F-G,X,DF-DG):der(F,X,DF),der(G,X,DG).
der(F*G,X,F*DG+G*DF):der(F,X,DF),der(G,X,DG).
der(1/F,X,-DF/(F*F)):der(F,X,DF).
der(F/G,X,(G*DF-F*DG)/(G*G)):der(F,X,DF),der(G,X,DG).
der(U^s(N),X,s(N)*(U^N)*DU):der(U,X,DU).
...
oppure, usando una diversa rappresentazione dei
termini (termine unario di funtore ed argomento
rappresentato con tu(F,A), es:tu(sin,tu(log,x))):
der(tu(F,U),X,DF*DU):-
50
der(tu(F,U),U,DF),der(U,X,DU).