Esercizio - Prolog - cut e negazione come fallimento (laboratorio 4)

antibodies_owner(maria).
dance(linda).
sing(linda).
sing(gianni).
noproblems(vittorio).

healthy(X) :- happy(X).
healthy(X) :- antibodies_owner(X).
happy(X) :- sing(X), dance(X).
happy(X) :- noproblems(X).

---

Punto 1: Vittorio e il cut

Programma A (verificato): X = linda ; X = vittorio ; X = maria. Ordine di esecuzione di healthy(X):

1. Clausola 1: happy(X). Clausola 1 di happy: sing(X), dance(X). sing(X) dà $X = linda$, dance(linda) riesce: linda.
2. Ritorno: sing(X) dà $X = gianni$, dance(gianni) fallisce.
3. Clausola 2 di happy: noproblems(X) dà $X = vittorio$: vittorio.
4. Clausola 2 di healthy: antibodies_owner(X) dà $X = maria$: maria.

Programma B, con happy(X) :- sing(X), !, dance(X).: risposte X = linda ; X = maria. Esecuzione:

1. healthy clausola 1, happy clausola 1: sing(X) dà $X = linda$; si esegue !; dance(linda) riesce: linda.
2. Al ritorno il cut ha eliminato le alternative: non si prova sing(gianni) e non si prova la clausola 2 di happy (noproblems(vittorio)). happy(X) è esaurito.
3. Clausola 2 di healthy: antibodies_owner(X) dà maria.

Vittorio non compare perché la sua unica via per essere sano, happy(vittorio) :- noproblems(vittorio), è la clausola 2 di happy, scartata dal cut quando $X = linda$ ha superato sing.

?- healthy(vittorio). nel B risponde true: con $X = vittorio$ già legata, sing(vittorio) fallisce prima di raggiungere il cut, quindi non si impegna nulla e si prova la clausola 2 di happy, che riesce. È un cut rosso: cambia il significato, e i risultati dipendono da come si interroga il programma (healthy(X) e healthy(vittorio) non sono coerenti), cioè il programma non è reversibile.

Punto 2: cut verde o rosso

min con due cut. Le condizioni X=<Y e Y<X si escludono a vicenda. Senza i cut le soluzioni sono le stesse: il cut serve solo a non provare la seconda clausola dopo il successo della prima. Cut verde. Verifiche: min(3,5,M) dà $M = 3$; min(5,3,M) dà $M = 3$; min(4,4,M) dà $M = 4$ (solo la prima clausola, perché $4 < 4$ è falso).

min2: min2(X,Y,X) :- X=<Y, !. e min2(X,Y,Y). La seconda clausola non ha condizione e conta sul cut per essere raggiunta solo quando $X > Y$. Cut rosso: togliendo il cut min2(3,5,M) darebbe $M = 3$ e anche $M = 5$ (sbagliato). Anche con il cut:

• min2(3,5,M) dà $M = 3$, min2(5,3,M) dà $M = 3$: giusto;
• min2(3,5,5) risponde true, sbagliato. Con il terzo argomento già istanziato a $5$ la testa della clausola 1 (min2(X,Y,X)) non si unifica ($X = 3$ e $X = 5$ in contrasto), il cut non viene raggiunto e la clausola 2, senza condizioni, riesce.

Si corregge scrivendo la condizione nella seconda clausola (Y<X, come in min) oppure unificando l'uscita dopo il cut: min3(X,Y,Z) :- X=<Y, !, Z = X. e min3(_,Y,Y). Ora il cut viene raggiunto anche con Z istanziato: min3(3,5,5) e min3(5,3,5) sono false, min3(3,5,M) e min3(5,3,M) danno $M = 3$ (verificato).

Punto 3: cut e fail

Programma C (verificato):

L'ultimo caso è l'attenzione delle slide: con la variabile libera il primo legame è il pinguino e il cut-fail chiude tutto, quindi fly(X) risponde false benché volino nightingale e blackbird. Il predicato funziona solo con l'argomento istanziato.

Nota sul programma delle slide: king_penguin e camelus_ostrich non sono dichiarati bird: fly(king_penguin) sarebbe false comunque. Con anche bird(king_penguin). e bird(camelus_ostrich). le risposte della tabella restano le stesse (verificato) e a bloccare i pinguini sono davvero cut e fail; senza i cut fly(king_penguin) darebbe true, perché fail fallirebbe sulla clausola 1 ma poi si proverebbe la 3.

Punto 4: negazione come fallimento

Programma D (verificato, anche con bird per i pinguini):

La query aperta ora funziona, a differenza del programma C: il filtro non impegna con il cut.

Perché not dopo bird(X). Con fly(X) :- not(penguin(X)), bird(X). e i fatti bird(nightingale). bird(king_penguin). penguin(king_penguin). la query fly(X) risponde false: not(penguin(X)) con X libera prova penguin(X), che riesce ($X = king_penguin$), quindi il not fallisce prima che bird(X) assegni un valore. Con bird(X), not(penguin(X)) (verificato) la risposta è X = nightingale. Regola: i goal che generano valori vanno prima, quelli che filtrano (not, confronti, \=) dopo.

not non è la negazione logica: dice "non riesco a dimostrare", sotto l'ipotesi del mondo chiuso (ciò che non è nel programma è falso). Per fly(opus), con opus mai nominato, bird(opus) fallisce e fly(opus) è false anche se in realtà non si sa nulla di lui.