Laboratorul 4

(Deadline: 21.04.2019 23:59:59)

Daca nu sunteti logati exercitiile nu se mai afiseaza.

Observatie: Adesea veti intalni o notatie de forma nume_predicat/numar. Numarul respectiv reprezinta numarul de parametri corespunzatori predicatului. Doua predicate cu acelasi nume dar cu numere diferite de parametri sunt predicate diferite.

Predicatul call

Predicatul call primeste ca parametru un termen compus si realizeaza o interogare corespunzatoare acelui termen, cu alte cuvinte a realiza call(p(X,Y)) e echivalent cu a face interogarea p(X,Y)

Predicatul once

Are aceeasi sintaxa ca si call, de exemplu, once(p(X,Y)), insa realizeaza o singura interogare pentru predicatul p(X,Y).

Directive

Conform specificatiilor din documentatia pentru Sicstus Prolog directivele sunt apeluri de predicate al caror rezultat nu este afisat. Se folosesc de obicei pentru predicate cu efecte colaterale precum afisari pe ecran, citire/scriere in fisier, consultari, incarcarea unui modul, definirea unui predicat dinamic etc. Ele trebuiesc precedate de :-.

Exemplu interogare obisnuita vs. directiva: | ?- X=3, write(X).
3
X = 3 ?
yes
| ?- :- X=3, write(X).
3
| ?-

In exemplul de mai sus, in primul caz, deoarece aveam in query o variabila, dupa terminarea evaluari interogarii a afisat si valoarea variabilei calculate si de asemenea si raspunsul yes care arata faptul ca predicatul s-a terminat cu succes. In al doilea caz, cand s-a folosit o directiva (observati ca e acelasi query de dinainte dar precedat de :- ), s-a realizat doar afisarea declansata de predicatul write atunci cand a fost evaluat insa nu s-au mai afisat nici valori de variabile si nici rezultatul predicatului. Totusi fiindca n-am primit niciun warning stim ca directiva s-a executat cu succes, daca insa ar fi rezultat cu un esec s-ar fi primit un mesaj asemanator cu cel de mai jos: | ?- :- X=3, write(X), fail.
3
* user:(X=3,write(X),fail) - goal failed
| ?-

In programele prolog directivele au aceeasi sintaxa si acelasi efect, si sunt executate la consultarea programului. De exemplu, pentru un program care contine linia de cod:

Putem folosi directive de exemplu cand prin consultarea unui fisier dorim sa fortam si consultarea altor fisiere.
Consideram ca avem fisierele:
temporar1.pl, cu continutul:

Observam ca daca schimbam continutul lui temporar2.pl in

Aceasta se intampla deoarece daca avem incarcate niste predicate in urma consultarii unui fisier, si apoi incercam consultarea unui al doilea fisier care contine un predicat cu nume si numar identic de parametri fata de un predicat deja existent (in urma primei consultari), se considera ca predicatul trebuie redefinit (toate clauzele vechi sterse si in locul lor incarcate cele din fisierul nou), si se cere o confirmare pentru acest lucru. In cazul predicatelor cu format identic, observam, deci, ca operatia de consultare nu mai are comportament cumulativ (spre deosebire de cazul in care un predicat cu acel format nu a mai fost intalnit si clauzele lui se adauga in mod direct la baza de cunostinte existenta).

Observati ca inainte de a se defini predicatul p/1 din temporar1.pl, s-a realizat consultarea lui temporar2.pl. In urma consultarii lui s-a adaugat la baza de cunostinte clauza p(t2). Apoi dupa ce a terminat consultarea celor doua fisiere din lista, a ajuns sa defineasca si clauza p(t1). Cum deja era definit din temporar2.pl un predicat de forma p/1, s-a considerat ca este redefinit in temporar1.pl, s-a cerut confirmarea pentru acest lucru, si apoi, dupa cum se vede clauza veche p(t2) a fost inlocuita de definitia noua p(t1).

In cazul meniului de redefinire a unui predicat daca se tasteaza comanda ? se pot vedea explicatiile pentru toate optiunile: Do you really want to redefine it? (y, n, p, s, a, b, or ?) ?
       y    redefine this procedure
       n    don't redefine this procedure
       p    redefine this procedure and don't ask again
       s    don't redefine this procedure and don't ask again
       a    abort
       b    break
       ?    print this information

Uneori insa nu dorim redefinirea predicatelor din diverse fisiere, ci pur si simplu vrem sa cumulam regulile din mai multe fisiere. Adica in caz ca avem clauze definite in fisiere diferite pentru un predicat cu acelasi nume si numar de parametri sa consideram ca sunt de fapt clauzele aceluiasi predicat pe care acum vrem sa le adunam laolalta. In acest caz se va folosi directiva include.

Directiva include poate primi o singura cale de fisier sau mai multe, caz in care acestea trebuie puse intr-o lista.
:-include('cale_fisier').
:-include(['cale_fisier_1','cale_fisier_2',...,'cale_fisier_n']).

Sa consideram un exemplu de folosire a lui include. Avem fisierul exemplu_include1.pl cu codul:

Directiva include se comporta ca si cum ar copia clauzele din fisierul/fisierele incluse in cadrul programului chiar in locul unde apare directiva. In cazul de mai sus, observam ca fisierul inclus, exemplu_include1.pl, se termina cu definirea predicatului b/1. In cadrul fisierului exemplu_include2.pl, imediat sub directiva de includere a fisierului exemplu_include1.pl sunt definite tot clauze ale predicatului b/1. Sa consideram ca modificam programul exemplu_include2.pl astfel:

Predicate dinamice

Pana in prezent am lucrat doar cu predicate statice. Acestea se folosesc pentru a defini fapte si reguli care nu trebuie sa se schimbe pe parcursul executiei, in functie de starea sistemului (de aceea ele si sunt protejate la adaugare ori stergere de clauze: cu assert si retract veti obtine un permission error, iar pentru abolish trebuie precizata o anumita optiune ca sa functioneze, se va vedea mai jos). Insa exista si predicate dinamice, care pot avea clauze adaugate sau sterse in urma unor interogari. Definirea unui predicat dinamic se face cu ajutorul unei directive de forma:

Pentru a verifica daca un predicat este sau nu declarat dinamic se poate folosi predicate_property. | ?- predicate_property(p(_,_,_),dynamic).
yes

Inserarea si stergerea faptelor din baza de cunostinte

Inserarea de clauze de la tastatura (in consola)

Acest lucru se poate face de la consola de sicstus prolog scriind [user]. inserand faptele si regulile si apoi apasand Ctrl+Z

Atentie aici se comporta ca si cum ar consulta un alt fisier, doar ca e scris de voi de la tastatura in consola. Puteti din gresala sa va redefiniti predicate deja existente. Daca ar fi existat in baza de cunostinte clauza spune(soricel,chit) inainte de a consulta clauza spune(pisica,'miau miau') atunci ar fi aparut un mesaj in care va cerea confirmarea pentru a redefini predicatul si prima clauza ar fi fost stearsa, in urma consultarii regasindu-se doar a doua clauza.

Nu prea e indicat sa scrieti clauze de predicate in felul acesta, de la consola, deoarece la inchiderea consolei daca nu v-ati salvat baza de cunostinte intr-un fisier ati pierdut toate clauzele.

Observatie: predicatele definite astfel sunt statice (in caz ca nu s-a specificat printr-o directiva faptul ca sunt dinamice), deoarece ceea ce introduceti de la tastatura e vazut precum continutul unui fisier oarecare pe care il consultati numai ca, in acest caz, acest continut e luat direct din consola.

Predicatele assert, asserta, assertz, retract, retractall

Aceste predicate lucreaza doar cu predicate dinamice.

Predicatul assert adauga clauze la baza de cunostinte. De exemplu: | ?- assert(stare(ion,flamand)).
yes
| ?- listing(stare).
stare(ion, flamand).

yes
| ?- assert((mananca(ion,_):-stare(ion, flamand))).
yes
| ?- listing(mananca).
mananca(ion, _) :-
        stare(ion, flamand).

yes
| ?- mananca(ion,placinta).
yes
| ?-

Observati ca in cazul regulilor la assert apar doua randuri de paranteze, parantezele interioare avand rolul de a grupa regula sub forma unui singur termen, altfel apar erori de sintaxa. Exemplu: | ?- assert(mananca(ion,_):-stare(ion, flamand)).
! Syntax error
! , or ) expected in arguments
! in line 834
! assert ( mananca ( ion , _ )
! <<here>>
! :- stare ( ion , flamand ) ) .
| ?-

Predicatele asserta si assertz adauga clauze la inceputul, respectiv sfarsitul bazei de cunostinte. Exemplu: | ?- listing(stare).
stare(ion, flamand).

yes
| ?- asserta(stare(luca,flamand)).
yes
| ?- listing(stare).
stare(luca, flamand).
stare(ion, flamand).

yes
| ?- assertz(stare(andrei,satul)).
yes
| ?- listing(stare).
stare(luca, flamand).
stare(ion, flamand).
stare(andrei, satul).

yes
| ?-

Predicatul retract sterge o singura clauza al carei head se potriveste (se poate realiza o unificare) cu termenul compus pe care il primeste ca parametru. Predicatul retractall sterge toate predicatele care indeplinesc acea conditie. Atentie, daca retract nu are ce sterge, returneaza no, pe cand retractall, indiferent daca sterge ceva sau nu, returneaza yes.

Sa luam ca exemplu programul de mai jos (pentru cei care nu stiu de unde vine catz din program, este ceea ce spunem cand vrem sa gonim o pisica, iar pis-pis cand vrem sa o chemam):

Observam ca daca cerem in continuare detalii despre predicat: | ?- predicate_property(pisica(_,_),dynamic).
yes
| ?- desi nu mai exista clauze ale predicatului pisica il recunoaste in continuare ca fiind dinamic.

Reconsultam programul ca sa mai observam ceva. Avem din nou toate pisicile in baza de cunostinte si incercam de data asta sa le gonim dupa culoare.

Observam ca pentru interogarea pisica(X,gri) intoarce bine solutiile pentru fapte, dar, atunci cand ajunge la regula, deoarece predicatul miauna/1 nu a fost definit, da o eroare. Totusi in urma interogarii spune(catz,culoare,gri) care apeleaza

Atentie! In momentul in care Prologul ajunge la o instructiune retract, vede la acel pas care sunt faptele dinamice care pot fi sterse, si deci care ar fi solutiile lui retract. Sa prespunem ca in cadrul acelei reguli imediat dupa retract se face un assert cu o regula ce ar putea fi stearsa de catre retract. Aceasta a fost adaugata dupa momentul evaluarii solutiilor posibile ale lui retract. Deci daca am realiza intoarceri repetitive din backtracking (fie din cauza unui esec mai departe in clauza, fie prin cererea de noi solutii) dupa ce retract ar sterge toate faptele vechi (care au existat inaintea executarii assert-ului despre care vorbeam), nu ar mai sterge si faptele adaugate de assert, deoarece ele nu fac parte din setul initial de solutii, calculat la inceput. Pentru a intelege mai bine sa luam urmatorul exemplu:

Initial din baza de cunostinte au fost complect sterse faptele predicatului pas/1 (reamintesc /1 se refera la numarul de parametri ai predicatului), cu un retractall, ca sa stim ca initial nu exista nimic definit pentru pas. Apoi se adauga doua fapte, cu assert: pas(ceva_1).
pas(ceva_2).
Acestea sunt si afisate in cadrul programului, cu ajutorul lui listing: Faptele initiale:
pas(ceva_1).
pas(ceva_2). Apoi urmeaza instructiunea retract(pas(P)) pentru care Prologul observa ca in acest moment exista doar doua solutii posibile: pas(ceva_1) si pas(ceva_2). Il sterge pe primul, ceva_1, asa cum si este afisat: Am sters pas(ceva_1) In program, urmeaza instructiunea assert(pas(pas_nou)), de aceea listingul va afisa: pas(ceva_2).
pas(pas_nou). Instructiunea fail de la final, va intoarce procesul de backtracking pana la instructiunea retract(pas(P)), deoarece format, listing si assert din fata lui se valideaza o singura data (din cauza asta, backtracking-ul, la incercarea de revalidare a fiecaruia, va fi trimis la instructiunea anterioara din regula). Astfel se sterge un nou fapt, si bactrackingul cu noua valoare calculata in P porneste inainte in regula, si se ajunge la format-ul de dupa retract care afiseaza: Am sters pas(ceva_2)
Se ajunge iar la assert si se mai adauga un fapt pas(pas_nou), in final listing-ul afisand numai faptele noi: Afisare fapte dupa adaugare:
pas(pas_nou).
pas(pas_nou). Se ajunge iar la fail, insa motorul de backtracking stie ca niciunul dintre predicatele dinaintea failului nu mai are solutii (singurul care putea sa mai aiba era retractul, dar pentru el s-au calculat solutiile la inceput, si faptele noi nu mai sunt luate in considerare). Astfel predicatul are ca rezultat: no

Pentru a arata si mai clar pasii, mai jos s-a aplicat un trace pe predicat: | ?- stare_pred_dinam.
        1      1 Call: stare_pred_dinam ?
        2      2 Call: retractall(user:pas(_768)) ?
        2      2 Exit: retractall(user:pas(_768)) ?
        3      2 Call: assert(user:pas(ceva_1)) ?
        3      2 Exit: assert(user:pas(ceva_1)) ?
        4      2 Call: assert(user:pas(ceva_2)) ?
        4      2 Exit: assert(user:pas(ceva_2)) ?
        5      2 Call: format('Faptele initiale:\n',user:[]) ?
Faptele initiale:
        5      2 Exit: format('Faptele initiale:\n',user:[]) ?
        6      2 Call: listing(user:pas) ?
pas(ceva_1).
pas(ceva_2).
        6      2 Exit: listing(user:pas) ?
        7      2 Call: retract(user:pas(_815)) ?
?       7      2 Exit: retract(user:pas(ceva_1)) ?
        8      2 Call: format('Am sters pas(~p)\n',user:[ceva_1]) ?
Am sters pas(ceva_1)
        8      2 Exit: format('Am sters pas(~p)\n',user:[ceva_1]) ?
        9      2 Call: assert(user:pas(pas_nou)) ?
        9      2 Exit: assert(user:pas(pas_nou)) ?
       10      2 Call: format('Afisare fapte dupa adaugare:\n',user:[]) ?
Afisare fapte dupa adaugare:
       10      2 Exit: format('Afisare fapte dupa adaugare:\n',user:[]) ?
       11      2 Call: listing(user:pas) ?
pas(ceva_2).
pas(pas_nou).

       11      2 Exit: listing(user:pas) ?
        7      2 Redo: retract(user:pas(ceva_1)) ?
        7      2 Exit: retract(user:pas(ceva_2)) ?
       12      2 Call: format('Am sters pas(~p)\n',user:[ceva_2]) ?
Am sters pas(ceva_2)
       12      2 Exit: format('Am sters pas(~p)\n',user:[ceva_2]) ?
       13      2 Call: assert(user:pas(pas_nou)) ?
       13      2 Exit: assert(user:pas(pas_nou)) ?
       14      2 Call: format('Afisare fapte dupa adaugare:\n',user:[]) ?
Afisare fapte dupa adaugare:
       14      2 Exit: format('Afisare fapte dupa adaugare:\n',user:[]) ?
       15      2 Call: listing(user:pas) ?
pas(pas_nou).
pas(pas_nou).

       15      2 Exit: listing(user:pas) ?
        1      1 Fail: stare_pred_dinam ?
no
% trace

Atentie: O regula in timp ce este evaluata se poate sterge pe ea insasi (daca este, bineinteles, o regula a unui predicat dinamic). Observati interogarile de mai jos:

Vom face un nou test:

Reordonarea faptelor in baza de cunostinte

Uneori avem nevoie sa reordonam clauzele unui predicat dinamic dupa anumite considerente. De exemplu, sa presupunem ca avem faptele din exemplul de mai jos si vrem sa le ordonam crescator in functie de al doilea parametru.

Nu putem sa mutam in mod direct fapte dintr-o pozitie in alta in cadrul bazei de cunostinte. Asadar cel mai simplu ar fi sa le stergem pe toate, punand structurile corespunzatoare lor intr-o lista. Lista respectiva o putem construi astfel incat ordinea elementelor sa fie chiar ordinea pe care o doream pentru faptele din baza de cunostinte. Apoi mai trebuie doar sa parcurgem lista respectiva si sa adaugam ca fapte structurile in ordinea in care le gasim in lista:

Dar daca vrem acum sa sortam faptele dupa valoarea produsului dintre primul si ultimul parametru? Ca si mai derveme ar trebui sa avem un termen compus al carui prim parametru sa fie criteriul de sortare (in cazul de fata, produsul): st(Prod,a(A,B,C)). Astfel pe masura ce setof parcurge faptele si le sterge, calculam si produsul,asa cum se vede in predicatul de mai jos. Apoi parcurgem lista de structuri care a rezultat si adaugam in baza de cunostinte structuri de forma a(A,B,C) in oridinea in care le gasim in lista construita de setof.

Predicatul abolish

Predicatul abolish este folosit tot pentru a sterge clauzele unui predicat insa in afara de clauze sterge si orice alte specificatii privitoare la acesta. Spre deosebire de retract si retractall el poate sterge si predicate statice, daca se forteaza acest lucru printr-un al doilea parametru. Sintaxa pentru acest predicat este abolish(nume_predicat/aritate) sau abolish(nume_predicat/aritate,lista_optiuni). Consideram tot exemplul de mai devreme: | ?- listing(pisica).
pisica(miau, alb).
pisica(mitzi, alb).
pisica(miaunel, gri).
pisica(pufi, gri).
pisica(A, B) :-
        miauna(A),
        culoare(B).

yes
| ?- abolish(pisica/2).
yes
| ?- listing(pisica).
* listing(user:pisica) - no matching predicate
yes
| ?- predicate_property(pisica(_,_),dynamic).
no
| ?- Observam ca au disparut toate clauzele pentru predicatul pisica, dar si insusi predicatul a fost sters din baza de cunostinte, fapt ce se observa atat din output-ul lui listing ("no matching predicate") cat si din faptul ca nici nu mai e vazut ca predicat dinamic. Comparati cu rezultatul obtinut mai sus in urma unui retractall care a sters toate clauzele predicatului pisica.

Stergerea bazei de cunostinte incarcate in consola

Dupa cum am vazut mai sus consultarea are un comportament cumulativ si daca lucram succesiv la mai multe pograme fara sa inchidem consola ajungem in final sa le avem pe toate incarcate ceea ce uneori poate genera erori. Cea mai simpla metoda de a reinitializa consola este inchiderea si redeschiderea ei. Nu exista un predicat predefinit sau vreo comanda care sa stearga toate predicatele incarcate in consola.
In schimb se poate defini unul:

Problema predicatului de mai sus e insa faptul ca dispare si el in urma interogarii. Daca mai avem nevoie de el si nu vrem sa fie sters nu avem decat sa testam ca valoarea lui P sa fie diferita de curata_bc/0.

Definirea operatorilor proprii.

Pana acum am folosit doar operatori predefiniti. Operatorii presupun doar o noua forma de scriere. O expresie ce contine un operator poate fi scrisa in mod echivalent sub forma parantezata:

Acet lucru e valabil chiar si pentru operatorii care au un test asociat; cum ar fi operatorii de comparatie:

Se definesc cu ajutorul predicatului op printr-o directiva de forma: :-op(precedenta,forma_operator,simbol_operator).

De exemplu:

Pot fi definiti operatori direct in consola. Mai jos e un exemplu care din nou pune in evidenta ca scrierea cu ajutorul operatorilor e echivalenta cu scrierea parantezata.

Precedenta unui operator, conform documentatiei este un numar intre 1 si 1200, care determina in cadrul unei expresii in ce ordine se vor realiza operatiile. Precedenta e inversa prioritatii, cu cat precedenta e mai mare cu atat prioritatea e mai mica. Atunci cand setati precedenta operatorilor custom este bine sa aveti in vedere precedenta operatorilor predefiniti pentru a asigura o buna functionare a programului.

Parametrul din mijloc, determina sintaxa operatorului (pozitia fata de operanzi) si conform documentatiei poate avea valorile: xfx,xfy,yfx (pentru forma infixata);fx,fy (forma prefixata);xf,yf (forma postfixata).
Litera y din acest parametru se refera la asociativitate. De exemplu, pentru operatorul definit cu op(100, xfy, +++), daca am avea o expresie de forma 1 +++ 2 +++ 3, interpretorul va considera 2 +++ 3 mai intai deoarece y-ul e in partea dreapta. Daca am fi avut in loc de xfy, yfx, atunci s-ar fi considerat 1 +++ 2 mai intai.