===== Prolog: Introducere =====

Scopul laboratorului:

  * Familiarizarea studenților cu limbajul Prolog

==== Despre Prolog ====

Prolog este un limbaj de [[https://en.wikipedia.org/wiki/Logic_programming|programare logică]], bazat pe un set mic de mecanisme de baza (e.g. pattern-matching, backtracking). Deși setul de mecanisme de baza este limitat, Prolog este un limbaj foarte puternic și flexibil.

==== SWI-Prolog ====

Există mai multe implementări ale limbajului Prolog. Noi vom folosi SWI-Prolog, disponibil [[http://www.swi-prolog.org/Download.html|aici]], sau puteți instala pachetul ''swi-prolog''.

Vom lucra în modul interactiv, care ne permite să apelăm funcții din consolă și să vedem rezultatul lor. Pentru modul interactiv, rulați ''swipl''.
 
==== Structura unui program Prolog ====

Un program Prolog contine (doar) trei constructii:
   * fapte
   * reguli
   * interogari

==== Fapte =====

Folosim faptele pentru a exprima un adevar. De exemplu vrem sa "definim" ca Gigel este barbat. Pentru a defini o regula este suficient sa ii definim numele(de preferat sugestiv) si sa ne hotaram care este "actorul".
In cazul de fata Gigel este actorul iar numele regulii este barbat => **barbat(gigel).**  \\
Observati **numele regulii** - barbat - **numele actorului** - gigel(cu litera mica!) - si **punctul** de la sfarsitul regulii(echivalent ";")

==== Interogari ====

Interogarile sunt metodele prin care noi putem sa ii cerem ceva programului. Pentru a "intreba" ceva este suficient sa scriem in interpretor ce vrem sa aflam. \\
De exemplu vrem sa aflam daca Gigel este barbat, pur si simplu "intrebam" in interpretor **barbat(gigel).** (observati numele regulii, actorul si punctul de la final!).\\
Raspunsul dat de programul nostru este **true**.  Raspunsul este afirmativ deoarece acest fapt exista in cadrul programului nostru in setul de fapte si reguli (denumit in continuare baza de cunostinte). \\ \\
Ce va raspunde programul la urmatoarea interogare: **copil(gigel).***? \\
Raspunsul este **false** (nu avem nicio informatie in baza de cunostinte legata de varsta lui Gigel). \\ \\
Dar la intrebarea **femeie(andreea)**? De ce?\\

==== Reguli ====

Regulile ne permit sa exprimam o legatura intre anumite fapte si reguli. De exemplu, pentru ca Gigel sa fie sot el trebuie sa fie insurat si sa fie barbat.\\
barbat(gigel).\\
insurat(gigel).\\
**sot(gigel):- barbat(gigel),insurat(gigel)**. Ce spune aceasta regula? Ce inseamna **","**? \\
Tocmai am definit o regula care spune ca Gigel este sot daca Gigel este barbat **si** daca Gigel este insurat. Virgula este modul in care se exprima conjunctia logica in Prolog \\
Care este raspunsul la urmatoarea interogare: **sot(gigel).** ?

==== Exemplu ====
Fie urmatoarea baza de cunostinte:
   femeie(ioana).
   barbat(mihai).
   barbat(andrei). 
   casatorit(mihai,ioana).
   parinte(ioana,andrei).
   parinte(mihai,andrei).

Observam ca am definit fapte cu aritate doi(nu suntem limitati la fapte/reguli cu aritate 1!).
Care este raspunsul la urmatoarea interogare: **casatorit(ioana,mihai).**? \\

Vrem sa definim o regula care sa ne spuna daca Mihai este tata: **tata(mihai):- barbat(mihai), parinte(mihai,andrei).**(Mihai este barbat si este tatal lui Andrei).\\
Problema cu aceasta abordare este ca Mihai poate sa fie parintele mai multor copii, nu doar al lui Andrei, ceea ce nu il invalideaza ca si tata. Cum rezolvam aceasta problema? Ne trebuie o "generalizare" a lui Andrei.
Aceasta generalizare o vom "implementa" folosind **variabile**. 
==== Variabile ====
Variabilele in Prolog sunt stringuri care incep cu litera mare.\\
Noua regula devine: **tata(mihai):- barbat(mihai), parinte(mihai,Copil).**\\
Prolog va incerca(prin backtracking) sa lege variabile Copil la orice actor care respecta faptul parinte(mihai,Copil) (in cazul nostru doar andrei). \\
Ce se intampla daca baza noastra de cunostinte contine (mult) mai multe fapte si reguli si vrem sa aflam care sunt toate mamele.?\\
**mama(Mama):- femeie(Mama), parinte(Mama,Copil).** Interogand **mama(Mama).** variabila Mama va lua, pe rand, totii actorii care satisfac cele doua reguli.(Interogarea intoarce cate o valoare pe rand. Pentru e trece la urmatoarea valoare folositi **;**) \\

Cum procedam daca vrem sa aflam un rezultat in urma unei interogari? Vom folosi variabile. Pentru a exemplifica acest lucru vom recurge la aritmetica.\\

Aritmetica in Prolog are o particularitate legate de sintaxa: 7 + 2 = 9 (in limbaj natural) se traduce in 9 is 7 + 2 (in Prolog). \\
Pentru a obtine un rezultat putem forma urmatoarea interogare: ** R is 2+3.** (R va unifica cu 5). \\

Sa observam urmatoarea regula: **compute_sum(A,B,Sum):- Sum is A+B.**. Avem o regula care calculeaza suma primelor doua variabile si "salveaza" rezultatul in ultima variabila. Cand avem de scris reguli cu input si output este important sa fiti consecventi in alegerea unei conventii(in exemplul oferit variabilele de intrare sunt pozitionate la inceputul regulii pe cand cele de iesire sunt la sfarsitul cererii).

==== Liste ====
Un concept extrem de util in Prolog este cel de lista. In Prolog, o lista se declara in felul urmator:
<code>
[1, 2, 3].
[1 | [2 | [3 | []]]]. ([1,2,3])
[mihai, ioana, andrei].
[mihai, parinte(ioana), X].
[1, [2, copil(andrei)], [], [X, Y, Z]].

</code>

Din penultimul exemplu se poate vedea ca o lista poate contine atat variabile, cat si constante sau itemi complecsi. Din ultimul exemplu se poate vedea ca o lista poate contine ca element o alta lista. \\
Ne propunem in continuare sa obtinem primul element dintr-o lista, precum si restul listei(**head** si **tail** din Haskell). Pentru aceasta, se va folosi unificarea din Prolog.

<code>
?- [H|L] = [1, 2, 3].
H = 1,
L = [2,3].
</code>
In urma comenzii, capul listei va fi legat la variabila **X**, iar restul listei va fi legata la variabila **Y**.

<code>
?- [H1,H2|_] = [1, 2, 3].
H1 = 1,
H2 = 2.
</code>
In urma comenzii, primele doua elemente ale liste vor fi legate la variabilele **H1** si **H2**. Simbolul **'_'** (underscore) are un comportament similar cu cel din Haskell si anume cel de variabila anonima. Folosim acest simbol cand nu dorim sa legam ceva la o variabila.

Incercam in continuare sa calculam lungimea unei liste. \\
Incepem prin a defini o regula prin care determinam daca ceva reprezinta o lista.
<code>
empty(L) :- L = [].
isList(L) :- empty(L).
isList([H|T]) :- isList(T).
</code>

Ne dam seama ca putem simplifica codul.
<code>
isList([]).
isList([_|T]) :- isList(T).
</code>

Calculam acum lungimea unei liste.
<code>
len(L, R) :- empty(L), R = 0.
len([H|T], R) :- isList(L), len(T, R1), R = R1 + 1.
</code>
Observati ca secventa nu functioneaza cum ar trebui pentru ca unificarea previne evaluarea lui R. Varianta finala a codului este:

<code>
len([], 0). (unificare implicita)
len([_|T], R) :- len(T, R1), R is R1+1.
</code>

Cum determinam daca un element apartine unei liste?
<code>
contains(E, [E|_]).
contains(E, [X |T]) :- E \= X, contains(E, T). 

?- contains(1, [1,2,3]).
true;
false.
</code>
De ce prima data obtinem **true**, iar dupa aceea **false**?

==== Exerciții ====

=== I. Liste ===

  - Definiți predicatul ''firstTwo(L, X, Y)'' care leagă variabilele ''X'', ''Y'' la primele două elemente din lista ''L'', dacă acestea exista.
  - Definiți predicatul ''notContains(E, L)'', care verifică dacă elementul la care este legat ''E'' **nu există** in lista ''L''.
  - Definiți predicatul ''unique(L1, L2)''. ''L2'' este lista ''L1'' fără elemente duplicate.
  - Definiți predicatul ''listOnly(L1, L2)''. ''L2'' este lista ''L1'' care conține doar elementele de tip listă. Exemplu: ''listOnly([1,[2,3],4,[5],6], [ [2,3],[5]]).''
  - Implementati ''insertionSort'' in Prolog.
      * Idenficati predicatele necesare, aritatea fiecăruia, variabilele care reprezinta input-ul, respectiv output-ul.

=== II. Arbori ===

  - Stabiliți o convenție de reprezentare pentru arbori. Ilustrați convenția in Prolog. Exemplu: ''T=...''.
  - Definiți predicatul ''size(T, S)'', unde ''T'' este un arbore, iar ''S'' numărul de noduri.
  - Definiți predicatul ''height(T, H)'', unde ''T'' este un arbore, iar ''H'' este numărul de niveluri.
  - Definiți predicatul ''flatten(T, L)'' unde ''T'' este un arbore, iar ''L'' o listă de noduri, în [[https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)|preordine]].
==== Recommended Reading ====

  * [[https://mitpress.mit.edu/books/art-prolog-second-edition|The Art of Prolog - I. Logic Programs - 1. Basic Constructs]]
  * [[https://mitpress.mit.edu/books/art-prolog-second-edition|The Art of Prolog - I. Logic Programs - 2. Database Programming]]
  * [[https://mitpress.mit.edu/books/art-prolog-second-edition|The Art of Prolog - I. Logic Programs - 3. Recursive Programming]]
  * [[https://mitpress.mit.edu/books/art-prolog-second-edition|The Art of Prolog - II. The Prolog Language - 6. Pure Prolog]]
  * [[https://mitpress.mit.edu/books/art-prolog-second-edition|The Art of Prolog - II. The Prolog Language - 7. Programming in Pure Prolog]]
  * [[https://mitpress.mit.edu/books/art-prolog-second-edition|The Art of Prolog - II. The Prolog Language - 8. Arithmetic]]
  * [[http://www.learnprolognow.org/lpnpage.php?pagetype=html&pageid=lpn-htmlse1|Learn Prolog Now! - Chapter 1 Facts, Rules and Queries]]
  * [[http://www.learnprolognow.org/lpnpage.php?pagetype=html&pageid=lpn-htmlch2|Learn Prolog Now! - Chapter 2 Unification and Proof Search]]
  * [[http://www.learnprolognow.org/lpnpage.php?pagetype=html&pageid=lpn-htmlch3|Learn Prolog Now! - Chapter 3 Recursion]]
  * [[http://www.learnprolognow.org/lpnpage.php?pagetype=html&pageid=lpn-htmlch4|Learn Prolog Now! - Chapter 4 Lists]]