PROLOG: PROgramming in LOGic Linguaggio usato per risolvere problemi che coinvolgono oggetti e relazioni tra oggetti.

Transcript

1 Paradigmi di programmazione Imperativo: orientato alla soluzione algoritmica del problema (Assembler, C, Pascal, Ada,...) Dichiarativo: si concentra sulla descrizione del problema. Il programmatore specifica che cosa si deve calcolare, piuttosto che come calcolare; descrive il problema, le relazioni e concetti in esso coinvolti, non il modo dettagliato in cui il problema va risolto. Funzionale: il programma definisce funzioni Logico: il programma definisce relazioni PROLOG: PROgramming in LOGic Linguaggio usato per risolvere problemi che coinvolgono oggetti e relazioni tra oggetti. Programmare in Prolog consiste nel dichiarare fatti su oggetti e relazioni definire regole su oggetti e relazioni fare domande su oggetti e relazioni Fatti e regole costituiscono il programma logico. 1

2 Programma logico Un programma logico è costituito da un insieme di clausole definite: disgiunzioni di letterali con uno ed un unico letterale positivo (con n 0, e P, Q 1,..., Q n atomiche). Se n = 0, allora la clausola è un fatto. P Q 1 Q 2... Q n Altrimenti, la clausola si può riscrivere nella forma equivalente: (Q 1 Q 2... Q n P) (P Q 1 Q 2... Q n ) P :- Q1, Q2,..., Qn. regola P: testa della regola Q1, Q2,..., Qn: corpo della regola Il segno :- è un se ( ). La virgola è un. Un insieme di clausole definite (un programma logico) è sempre soddisfacibile. 2

3 Goal Un goal è una clausola negativa: tutti i letterali sono negativi: che equivale a Questa clausola corrisponde alla formula che equivale a Q 1 Q 2... Q n (Q 1 Q 2... Q n )?- Q1, Q2,..., Qn. goal x 1... x k (Q 1 Q 2... Q n ) x 1... x k (Q 1 Q 2... Q n ) Questa formula corrisponde alla negazione della query. Quindi il goal?- Q1, Q2,..., Qn. corrisponde alla query x 1... x k (Q 1 Q 2... Q n ) Le variabili nel goal hanno lettura esistenziale, la virgola è un AND. Esecuzione del programma logico P con goal G: la query corrispondente a G è derivabile dall insieme di formule corrispondenti a P? 3

4 Programmazione logica Supponiamo di avere la seguente base di conoscenza (KB): {padre(aldo, piero), padre(piero, ugo), x y( z(padre(x, z) padre(z, y)) nonno(x, y))} Verificare se da KB è derivabile x nonno(x, ugo) equivale a verificare se KB { x nonno(x, ugo)} è insoddisfacibile. Il programma logico P corrispondente a KB è la forma a clausole di KB: padre(aldo, piero) padre(piero, ugo) nonno(x, y) padre(x, z) padre(z, y) padre(aldo,piero). padre(piero,ugo). nonno(x,y) :- padre(x,z), padre(z,y). Verificare se da P è derivabile x nonno(x, ugo) si riduce a derivare (clausola vuota) da P {?- nonno(x, ugo)}. Risoluzione SLD con la regola di calcolo scelta del primo atomo :?- n(x, ugo) n(x 1, Y ) :- p(x 1, Z), p(z, Y ) Quindi KB = x nonno(x, ugo)?- p(x, Z), p(z, ugo) p(aldo, piero)?- p(piero, ugo) p(piero, ugo) 4

5 Programmazione logica per rispondere a domande ASK Domande ASK hanno spesso la forma quale x è tale che...? Un programma serve per calcolare dei valori e non solo per rispondere SI o NO. Informazioni utili si possono estrarre dalle sostituzioni applicate nella refutazione SLD. Le sostituzioni applicate nella derivazione data sopra sono: θ 0 = {X/X 1, ugo/y } θ 1 = {aldo/x, piero/z} θ 2 = La loro composizione è: Non solo P = x nonno(x, ugo), ma anche θ = θ 0 θ 1 θ 2 = {aldo/x, ugo/y, piero/z} P = nonno(x, ugo)θ cioè P = nonno(aldo, ugo) Quindi la composizione delle sostituzioni utilizzate nella SLD-refutazione fornisce una risposta alla domanda: chi è un nonno di ugo? Sostituzione di risposta (answer substitution): restrizione di θ 0 θ 1... θ n alle variabili del goal. Una esecuzione in programmazione logica consiste nel tentativo di dimostrare che esiste un istanza della query che segue logicamente dal programma, e, se esiste, calcolare la sostituzione di risposta data dalla dimostrazione. 5

6 PROGRAMMAZIONE = LOGICA + CONTROLLO Un programma PROLOG è una rappresentazione logica del problema Il problema viene risolto dal motore di inferenza del PROLOG, basato sulla risoluzione SLD, con strategia di ricerca in profondità. Importanti meccanismi di base: unificazione (che differenza c è tra unificazione e pattern matching?) procedimento di ricerca mediante backtracking PROLOG utilizzato soprattutto in Intelligenza Artificiale sistemi esperti e, in generale, sistemi basati sulla conoscenza elaborazione del linguaggio naturale pianificazione automatica Facilità di rapid prototyping 6

7 Semantica dichiarativa e semantica procedurale La chiave della programmazione logica è il fatto che una regola si può leggere in due modi: nonno(x,y) :- padre(x,z), padre(z,y). lettura dichiarativa ( che cosa ): per ogni X e Y, se esiste Z tale che X è padre di Z e Z è padre di Y, allora X è nonno di Y X Y Z(padre(X, Z) padre(z, Y ) nonno(x, Y )) Programma = specifica del problema lettura procedurale ( come ): per risolvere il problema nonno(x,y), si trovi Z che risolve il problema padre(x,z) e risolvere poi il problema padre(z,y) L insieme delle clausole che definiscono un predicato P costituiscono la definizione della procedura P Il Prolog puro consente sia la lettura dichiarativa che quella procedurale di un programma 7

8 Osservazione sulla lettura delle regole nonno(x,y) :- padre(x,z), padre(z,y). è la sintassi Prolog per la clausola Questa clausola corrisponde alla formula nonno(x, y) padre(x, z) padre(z, y) x y z(padre(x, z) padre(z, y) nonno(x, y)) Dato che z non occorre nel conseguente, la formula equivale a In una regola della forma testa :- corpo. x y( z(padre(x, z) padre(z, y)) nonno(x, y)) le variabili nella testa hanno un significato universale (su tutta la clausola); le variabili in corpo che non occorrono in testa hanno un significato esistenziale all interno del corpo. 8

9 PROLOG: rappresenta oggetti e relazioni vicino(c,c1). vicino(c,c2). colore(c1,blu). colore(c2,rosso). colore(x,y) :- vicino(x,z), colore(z,y). colore è una relazione: un oggetto può avere più colori.?- colore(c,x). ha più di una soluzione REVERSIBILITÀ dei predicati: una stessa procedura può essere invocata con diversi parametri di input/output?- colore(c,x).?- colore(x,rosso).?- colore(x,y). 9

10 Fatti, regole, procedure Fatti genitore(pam,bob). genitore(tom,bob). genitore(tom,liz). genitore(bob,ann). genitore(bob,pat). genitore(pat,jim). Regole figlio(x,y) :- genitore(y,x). madre(x,y) :- genitore(x,y), femmina(x). nonno(x,y) :- genitore(x,z), genitore(z,y). Procedure: insiemi di fatti e regole antenato(x,y) :- genitore(x,y). antenato(x,y) :- genitore(x,z), antenato(z,y). Le clausole (fatti e regole) di una procedura rappresentano modi alternativi di risolvere problemi della stessa forma (antenato). 10

11 Ricerca in profondità genitore(pam,bob). genitore(tom,bob). genitore(tom,liz). genitore(bob,ann). genitore(bob,pat). genitore(pat,jim). antenato(x,y) :- genitore(x,y). antenato(x,y) :- genitore(x,z), antenato(z,y).?- antenato(bob,jim). a(bob,jim) g(bob,jim) NO g(bob,z), a(z,jim) Z=ann a(z,jim) Z=pat a(z,jim) g(z,jim) NO g(z,z 1 ), a(z 1,jim) NO g(z,jim) YES g(z,z 1 ), a(z 1,jim) 11

12 Trace 1?- [bratko1]. % bratko1 compiled 0.00 sec, 3,336 bytes 2?- trace. [trace] 2?- antenato(bob,jim). Call: (6) antenato(bob, jim)? Call: (7) genitore(bob, jim)? Fail: (7) genitore(bob, jim)? Redo: (6) antenato(bob, jim)? Call: (7) genitore(bob, _G466)? Exit: (7) genitore(bob, ann)? Call: (7) antenato(ann, jim)? Call: (8) genitore(ann, jim)? Fail: (8) genitore(ann, jim)? Redo: (7) antenato(ann, jim)? Call: (8) genitore(ann, _G466)? Fail: (8) genitore(ann, _G466)? Fail: (7) antenato(ann, jim)? 12 Redo: (7) genitore(bob, _G466)? Exit: (7) genitore(bob, pat)? Call: (7) antenato(pat, jim)? Call: (8) genitore(pat, jim)? Exit: (8) genitore(pat, jim)? Exit: (7) antenato(pat, jim)? Exit: (6) antenato(bob, jim)?

13 Il backtracking Ogni sottogoal ha il proprio puntatore al programma likes(mary,food). /* 1 */ likes(mary,wine). /* 2 */ likes(john,beer). /* 3 */ likes(john,wine). /* 4 */ likes(john,mary). /* 5 */?- likes(mary,x), likes(john,x). Goal 1: likes(mary,x): X=food. Puntatore alla prossima clausola: 2 Goal 2: likes(john,x) con X=food. Fallimento dopo aver scandito tutta la procedura Tentativo di risoddisfare Goal 1, a partire dalla clausola 2: X=wine Goal 2 con X=wine (scansione della procedura dall inizio): successo 13

14 Ricerca in profondità La scelta di una strategia di ricerca può compromettere la completezza del sistema: Ricerca in profondità: si può espandere un cammino infinito e non trovare mai una soluzione Riordino delle clausole nel programma o degli atomi nel corpo delle regole: il significato dichiarativo non cambia, ma può cambiare il significato procedurale. Riordino delle clausole nel programma vicino(c,c1). vicino(x,y) :- vicino(y,x).?- vicino(c1,c). vicino(x,y) :- vicino(y,x). vicino(c,c1).?- vicino(c1,c). ERROR: Out of local stack 14

15 Riordino dei goal nel corpo delle regole pat jim pam bob ann tom liz /* Prima variante */ antenato(x,y) :- genitore(x,y). antenato(x,y) :- genitore(x,z), antenato(z,y).?- antenato(bob,jim).?- antenato(liz,bob). No /* riordino dei goal nel corpo della regola */ antenato(x,y) :- genitore(x,y). antenato(x,y) :- antenato(z,y), genitore(x,z).?- antenato(bob,jim).?- antenato(liz,bob). ERROR: Out of local stack 15

16 Il goal non è derivabile dal programma, ma il meccanismo di ricerca non termina antenato(x,y) :- genitore(x,y). antenato(x,y) :- antenato(z,y), genitore(x,z).?- antenato(liz,bob). a(liz,bob) (liz non è genitore di nessuno) g(liz,bob) NO a(z,bob), g(liz,z) g(z,bob), g(liz,z). NO a(z 1,bob), g(z,z 1 ), g(liz,z) g(z 1,bob), g(z,z 1 ), g(liz,z). NO a(z 2,bob), g(z 1,Z 2 ), g(z,z 1 ), g(liz,z). 16

17 Riordino delle clausole e dei goal pat jim pam bob ann tom liz antenato(x,y) :- antenato(z,y), genitore(x,z). antenato(x,y) :- genitore(x,y).?- antenato(bob,jim). ERROR: Out of local stack Goal derivabile ma la ricerca non termina?- antenato(liz,bob). ERROR: Out of local stack Goal non derivabile e la ricerca non termina Regole di programmazione 1. In una procedura, prima i fatti poi le regole (prima le cose più semplici, poi quelle più complicate) 2. Nel corpo di una regola, prima i goal più semplici da dimostrare o refutare, poi quelli più difficili 17

18 Il Prolog è corretto? Il predicato predefinito = controlla se due termini sono unificabili: Term 1 = Term 2 unifica Term 1 con Term 2. Ha successo se l unificazione ha successo?- f(x,pippo) = f(pluto,y). X = pluto Y = pippo Ma attenzione:?- X = f(x). X = f(f(f(f(f(f(f(f(f(f(...))))))))))?- unify_with_occurs_check(x,f(x)). No 18

19 L unificazione utilizzata dal motore di inferenza non esegue l occur check figlio(x,padre(x)).?- figlio(pippo,y). Y = padre(pippo)?- figlio(y,y). X = padre(padre(padre(padre(padre(padre(padre(padre(padre(padre(...)))))))))) 19