Scopul laboratorului:

1. aprofundarea mecanismului de căutare din prolog
2. înțelegerea cut-urilor ca mecanism de control al căutării
3. distincția între “green cuts” și “red cuts”
4. metode de colectare a rezultatelor

Pentru a demonstra goal-urile necesare, Prolog folosește backtracking pentru a explora toate posibilitățile, rezultând într-un arbore de căutare. Uneori asta duce la comportamente neintuitive:

min(X, Y, X) :- X < Y.
min(X, Y, Y).

?- min(1, 2, 1).
true ;
false.

?-

Putem încerca să rezolvăm problema, explicitând condiția din cea de-a doua clauză:

min(X, Y, X) :- X < Y.
min(X, Y, Y) :- X >= Y.

Dar tot obținem un al doilea rezultat false.

?- min(1, 2, 1).
true ;
false.

?-

Putem porni un trace în program pentru a vedea ce se întâmplă:

?- trace.

[trace]  ?- min(1, 2, 1).
   Call: (8) min(1, 2, 1) ? creep
   Call: (9) 1<2 ? creep
   Exit: (9) 1<2 ? creep
   Exit: (8) min(1, 2, 1) ? creep
true ;
   Redo: (8) min(1, 2, 1) ? creep
   Fail: (8) min(1, 2, 1) ? creep
false.

[trace]  ?-

După ce obținem un răspuns positiv din prima clauză, Prolog încearcă să găsească și alte soluții, folosind a doua ramură. Ajunge astfel la goal-ul min(X, Y, Y) care nu poate fi satisfăcut, deoarece nu există o unificare posibilă, deci căutarea eșuează. Am vrea să avem control asupra execuției procedurale, eliminând ramuri din arborele de căutare (în cazul nostru, am vrea ca după ce am aflat că un element se găsește în listă, să ne oprim).

Pentru asta avem predicatul !/0 (numit “cut”). Acesta poate fi mereu satisfăcut, dar are un efect lateral: împiedică resatisfacerea părții din stânga, inclusiv clauza (amintiți-vă că o clauză este practic o “linie”, iar un predicat e o colecție de una sau mai multe clauze. Predicatul elem are două clauze). Astfel, putem rezolva problema noastră:

min(X, Y, X) :- X < Y, !.
min(X, Y, Y) :- Y >= X.

[trace]  ?- min(1, 2, 1).
   Call: (8) min(1, 2, 1) ? creep
   Call: (9) 1<2 ? creep
   Exit: (9) 1<2 ? creep
   Exit: (8) min(1, 2, 1) ? creep
true.

[trace]  ?-

Când primește goal-ul min(1, 2, X), prolog încearcă, de sus în jos, toate clauzele predicatului min. Pentru că reușește unificarea cu substituția {X = 1, Y = 2}, alege prima clauză. Aceasta este o regulă, deci trebuie încercată satisfacerea corpului acesteia, adică X < Y, !. 1 < 2 este adevărat, iar predicatul ! reușește și deci și clauza curentă, iar prolog ne raportează true; dar acum nu mai poate să încerce o altă clauză a predicatului min.

Putem folosi predicatul “cut” pentru a altera rezultatul unei interogări, dar și doar cu scopul de a face o interogare mai eficientă, având același rezultat. Astfel distingem între “green cuts” și “red cuts”.

Un “green cut” este un “cut” care are scopul de a face un program mai eficient, fără a-i schimba outputul. Cut-ul folosit mai sus are această proprietate. Fără acesta, prolog ar verifica și cea de-a doua ramură, în mod inutil. În principal, un “green cut” ar trebui folosit pentru clause mutual-exclusive: dacă una din ele e adevărate, cealălalte nu poate fi. O carecteristică a acestor cut-uri este că eliminarea lor din program, nu schimbă rezultatul.

Definiția predicatului min de mai sus, poate părea nesatisfăctoare. Avem în ambele clauzele o comparație explicită a argumentelor. Intuitiv, observăm că cele două condiții sunt mutual exclusive, deci ar fi suficient ca doar una să fie explicitată.

min(X, Y, X) :- X < Y, !.
min(X, Y, Y).

La prima vedere, predicatul pare corect:

?- min(1, 2, X).
X = 1.

?- min(2, 1, X).
X = 1.

?-

Însă putem observa că atunci când toate variabilele sunt instanțiate, comportamentul nu e cel dorit:

?- min(1, 2, 2).
true.

?-

Pentru că nu poate aborda prima clauză (nu există nicio substituție posibilă, X ar trebui să fie și 1 și 2), prolog trece la a doua. Cu substituția {X = 1, Y = 2}, goal-ul reușește și prolog raportează true.

O soluție este să întârziem unificarea variablei rezultat, până după comparație:

min(X, Y, Z) :- X < Y, !, X = Z.
min(X, Y, Y).

?- min(1, 2, 2).
false.

?-

Inițial prolog găsește substituția {X = 1, Y = 2, Z = 2}. Comparația X < Y reușește (deoarece 1 < 2), ! reușește, dar unificarea X = Z nu (ambele sunt variabile instanțiate la valori diferite). Din cauza cut-ului, prolog nu poate să încerce a doua clauză, deci rezultatul e false.

Fără acel cut, predicatul ar funcționa ca variante dinainte (cea fără variabila Z). Astfel de cut-uri, care alterează comportamentul programului, se numesc “red cuts”. O recomandare comună e că ar trebui folosite cu grijă, pentru că pot îngreuna înțelegerea codului.

Fie următoarea bază de cunoștiințe genealogice:

% File: norse.pl
father(buri, borr).
father(borr, odin).
father(borr, vili).
father(borr, ve).
father(odin, thor).
father(odin, baldr).
 
mother(bestla, odin).
mother(bestla, vili).
mother(bestla, ve).
mother(jorth, thor).
mother(frigg, baldr).

Putem defini ușor un predicat pentru a determina relația părinte-copil:

parent(P, C) :- mother(P, C).
parent(P, C) :- father(P, C).

După cum ați observat până acum, predicatul definit e versatil; poate fi folosit pentru a verifica o relație, pentru a determina părinții unei persoane, pentru a determina copiii unei persoane, sau pentru a genera toate perechile părinte-copil din baza de cunoștiințe:

?- parent(odin, thor).
true.

?- parent(buri, odin).
false.

?- parent(borr, C).
C = odin ;
C = vili ;
C = ve.

?-

Pentru ultima interogare, există mai multe posibilități de unificare a variabilei C, iar prolog ni le oferă pe rând (introducând ; interactiv, primim următoarea soluție). Uneori, este util să putem colecta toate aceste soluții într-o listă pe care putem, ulterior, face alte procesări. În continuare, vom studia trei predicate pentru a realiza acest lucru.

findall/3 este un predicat care primește un tipar de rezultate, un goal de demonstrat și o listă de ieșire care va conține toate rezultatele construite pe baza tiparului, pentru care goal-ul primit este adevărat. Cel mai simplu tipar util este o singură variabilă, care se regăsește în scopul primit.

?- findall(C, parent(borr, C), L).
L = [odin, vili, ve].

?-

Dacă nu există niciun rezultat, findall/3 generează o listă vidă:

?- findall(C, parent(baldr, C), L).
L = [].

?-

Deasemenea primul argument poate fi un termen compus:

?- findall(child(C, borr), parent(borr, C), L).
L = [child(odin, borr), child(vili, borr), child(ve, borr)].

?-

bagof/3 este un predicat asemănător cu findall/3, având aceeași semnificație a parametrilor. Diferența dintre cele două este vizibilă atunci când introducem în goal o variabilă care nu apare în template.

?- findall(C, parent(P, C), L).
L = [odin, vili, ve, thor, baldr, borr, odin, vili, ve|...].

?-

Observăm că findall/3 ne întoarce o singură listă cu toate rezultatele posibile. În unele cazuri, ar fi util ca, pentru fiecare părinte P, să primim o altă listă. Pentru asta folosim bagof:

?- bagof(C, parent(P, C), L).
P = bestla,
L = [odin, vili, ve] ;
P = borr,
L = [odin, vili, ve] ;
P = buri,
L = [borr] ;
P = frigg,
L = [baldr] ;
P = jorth,
L = [thor] ;
P = odin,
L = [thor, baldr].

?-

Rezultatele sunt generate în stilul clasic, necesitând ; interactiv. Putem apoi să le colectăm folosind din nou bagof/3:

?- bagof(children(P, L), bagof(C, parent(P, C), L), R).
R = [children(bestla, [odin, vili, ve]), children(borr, [odin, vili, ve]), children(buri, [borr]), children(frigg, [baldr]), children(jorth, [thor]), children(odin, [thor, baldr])].

?-

Ca urmare a felului de funcționare, o diferență notabilă între findall/3 și bagof/3 este că, atunci când goal-ul nu poate fi satisfăcut, findall/3 reușește, generând o listă vidă, iar bagof/3 eșuează.

?- findall(C, parent(thor, C), L).
L = [].

?- bagof(C, parent(thor, C), L).
false.

?-

Fie următorul predicat, pentru a stabili care două persoane au un copil în comun:

common_child(F, M) :- father(F, C), mother(M, C).

Am vrea să generăm o listă cu toate persoanele care au un copil cu Odin. Ne folosim de predicatele bagof/3 și common_child/2:

?- bagof(M, common_child(odin, M), L).
L = [jorth, frigg].

?-

Obținem rezultatul dorit. Ce se întâmplă însă dacă două persoane au în comun mai mulți copii?

?- bagof(M, common_child(borr, M), L).
L = [bestla, bestla, bestla].

?-

Rezultatul nu este ideal, deoarece conține duplicate.

setof/3 este un predicat asemănător cu bagof, având aceeași semnificație a parametrilor, dar care generează o listă sortată, fără duplicate (mai multe informații despre ce implică sortarea, puteți găsi aici).

?- setof(M, common_child(odin, M), L).
L = [frigg, jorth].

?- setof(M, common_child(borr, M), L).
L = [bestla].

?-

În rest, setof/3 se comportă ca bagof/3; pentru variabilele din goal care nu apar în template generează soluții separate și eșuează dacă nu există niciuna:

?- setof(M, common_child(F, M), L).
F = borr,
L = [bestla] ;
F = odin,
L = [frigg, jorth].

?- setof(M, common_child(thor, M), L).
false.

?-

?- findall(P, parent(P, C), L).
L = [bestla, bestla, bestla, jorth, frigg, buri, borr, borr, borr|...].

?- set_prolog_flag(answer_write_options,[max_depth(0)]).
true.

?- findall(P, parent(P, C), L).
L = [bestla,bestla,bestla,jorth,frigg,buri,borr,borr,borr,odin,odin].

1. Definiți predicatul cartesian(L1, L2, R) care construiește produsul cartezian al L1 cu L2.
2. Definiți predicatul union(L1, L2, R) care construiește reuniunea a două mulțimi codificate ca liste.
3. Definiți predicatul intersection(L1, L2, R) care construiește interesecția a două mulțimi codificate ca liste.
4. Definiți predicatul diff(L1, L2, R) care construiește diferenta a două mulțimi codificate ca liste.
5. Definiți predicatul pow(S, R) care construiește power set-ul multimii S.
6. Definiți predicatul perm(S, R) care generează toate permutările lui S.
7. Definiți predicatul ar(K, S, R) care generează toate aranjamentele de dimensiune K cu elemente luate din S.
8. Definiți predicatul comb(K, S, R) care generează toate combinările de dimensiune K cu elemente luate din S.

• The Art of Prolog - II. The Prolog Language - 11. Cuts and Negation
• Learn Prolog Now! - Chapter 5 Arithmetic
• Learn Prolog Now! - Chapter 6 More Lists
• Learn Prolog Now! - Chapter 10 Cuts and Negation
• Learn Prolog Now! - Chapter 11 Database Manipulation and Collecting Solutions