limbajul prolog - Facultatea de Electrotehnică şi Electroenergetică

Cursul 3
LIMBAJUL PROLOG
• operații aritmetice şirelaționale
• determinism şi nedeterminism în bazele de cunoştințe
• operatii de citire / scriere
• operații p ț cu şiruri ş de caractere
ȘȘ.l.dr.ing. ldring Ioan BORLEA BORLEA– Facultatea de Electrotehnică şi Electroenergetică Timişoara

OPERAȚII ARITMETICE ŞI RELAȚIONALE
Expresiile aritmetice
Sunt formate din numere şi variabile despărțite prin operatori
aritmetici: + , ‐ , * , mod , div , / .
Expresiile aritmetice pot să fie sau să nu delimitate de paranteze.
RRegulile lil de d evaluare l a expresiilor iil aritmetice it ti respectă tă convențiile țiil standard t d d
referitoare la evaluarea operanzilor şi parantezelor.
Expresii relaționale
Se pot compara expresii aritmetice aritmetice, caractere caractere, şiruri şi respectiv simboluri simboluri.
Operatorii relaționali sunt: < , > , = , sau >< , = .

O clauză de forma:
Egalitatea g şi ş ppredicatul egal g „=” „
N = N1 - 2
• indică o relaţie ţ între trei obiecte adică N, N1 şşi
valoarea 2,
• sau o relaţie între două obiecte adică N şi valoarea N1 - 2.
• Dacă N este o variabilă liberă atunci primeşte valoarea definită de obiectul
N1 – 2 adică operaţia este similară cu atribuirea.
• Daca N este o variabilă legată atunci egalitatea este ca şi o comparare a
celor două (sau trei) obiecte, rezultatul fiind
• Yes dacă N=N1 N = N1 - 2sau 2 sau
• No dacă N N1 – 2; în operaţia de comparare se ţine cont de
domeniul la care aparţine p ţ variabila respectivă. p

EExemplu l 1: 1 CConstruiți t ițio procedură d ă care să ă calculeze l l numărul ă l dde
elemente ale unei liste.
Predicatul este de forma: nr ( lista , nr nr_elemente) elemente)
Regulile de construcție pornesc de la două observații:
lungimea unei liste vide este 0;
dacă lista nu este vidă, lungimea este dată de
‐ 1 (lungimea capului listei) +
‐ lungimea cozii listei listei.
predicates
nr(lista, ( , nr) )
clauses
nr ( [ ], 0).
nr ( [ _ | Rest ], N) if
nr ( Rest, N1),
N=1+N1.
Exemplu de apelare: nr( [ a,b,c], R) rezultă R=3.

Exemplu p 2: Construiți ț o pprocedură
care să determine elementul
maxim al unei liste.
Considerăm un predicat de forma:
maxim(lista, ( elem_maxim). )
Procedura rezultă din observațiile:
dacă lista este formată dintr‐un singur element, atunci maxim este chiar
elementul respectiv;
în caz contrar maximul se obține prin compararea capului listei cu maximul cozii
listei.
predicates
maxim(lista, integer) % lista şi elementul maxim rezultat
max(integer, integer, integer) % elementele listei care se compară şi
clauses
maxim ( [X] , X).
maxim ( [X | Rest], Maxim) if
maxim (Rest, Max_Rest),
max ( X, Max_Rest, Maxim).
max ( A, B, A) if A>=B.
max ( AA, BB, B) if A

EExemplu l 3: 3 CConstruiti t itio procedură d ă care să ă dt determine i c.m.m.d.c d di dintre t 2
valori numerice X şi Y
Considerăm un predicat de forma: cmmdc(x cmmdc(x, yy, rezultat) rezultat).
Se pleacă de la considerațiile:
‐ Dacă X=Y cmmdc este oricare dintre cele două
‐ Dacă X>Y cmmdc se obține dintre X şi X‐Y
‐ Dacă XY, , X1=X‐Y, , cmmdc( ( X1, , Y, , R). )
cmmdc( X, Y, R) if X

DETERMINISM ŞI NEDETERMINISM
ÎN BAZELE DE CUNOŞTINȚE
Modul de acțiune al elementului de tăiere ” ! ”
Elementul de tăiere (cut ‐ !) are rolul de a prevenii acțiunea mecanismului de căutare a
soluțiilor (backtracking) în arbore de soluțiilor prin impiedicarea parcurgerii anumitor
ramuri ramuri.
Considerăm o regulă de forma :
H if B1, , B2, , ... , Bm, , ! , Bm+1, , ... ,
Bn.
Prin mecanismul de căutare în intervalul premizelor B1 ... Bm se presupune că s‐a găsit o
soluție.
In momentul atingerii elementului de tăiere (!) soluția parțială găsită este „înghețată”,
operația fiind echivalentă cu ştergerea pointerilor de pe clauzele B1...Bm deja parcurse.
Căutarea continuă pentru premizele Bm+1 Bm+1, ... , Bn în care sunt permise toate soluțiile
posibile. Cu alte cuvinte spațiul soluțiilor este format din soluția definită de B1, ... , Bm şi
variantele oferite de Bm+1, ... Bn.
Elementul de tăiere îşi e tinde acțiunea si pentru clau ele cu acelaşi nume (H) care urmea ă
Elementul de tăiere îşi extinde acțiunea si pentru clauzele cu acelaşi nume (H) care urmează
după aceea în care este prezent.

Exemplu teoretic:
H if P, Q, R, !, S, T, U. % Regula care conține !.
H if U, V . % Aceasta regulă nu se mai execută dacă
pentru precedenta s‐a găsit cel puțin o soluție.
A if B B, H, H C. C % Nu Nu se mai poate întoarce pentru B dacă pentru H H
s‐a găsit o soluție.
REGULI DE AMPLASARE A LUI „!”
1. Elementul de tăiere se amplasează pe axioma care implementează întrebarea
pusă adică:
sterge(X, [X| R], R) if ! .
2. Se utilizează opțiunea CHECK_DETERM (verificarea determinismului), care se
amplasează în fața programului sub forma:
check_determ

Construirea regulilor IF THEN ELSE
Elementul de tăiere (!) poate fi utilizat în Prolog pentru construirea unor reguli de
tipul if then else sub forma:
a) ) Construiti o procedura: p max (x, (,y, y, maxim). )
În limbaj natural avem
if X>=Y then MAX=X else MAX=Y.
Regula poate fi scrisă:
max (X, Y, X) if X>=Y. % adică X este maxim este adevărat
max (X, Y, Y) if X=Y , ! . % X este maxim şi ! (nu mai căuta altă soluție)
max ( _ ,Y,Y). % dacă nu s‐a îndeplinit prima clauză
atunci atunci YY este maxim automat

) Construiti o procedură care să asigure adunarea unui element X la o listă L numai
dacă X nu este prezent în L; în acest caz X devine capul listei.
aduna(Elem, Lista, Rezultat)
În limbaj natural regula se scrie:
if Elem apartine Lista
then Rezultat = Lista
else Rezultat = [Elem | Lista]
Secvența de priogram se scrie:
aduna(X , L, L) if apartine (X, L), ! .
aduna(X, L, [X | L]).
Exemple:
aduna (2, [1, 3], R) rezultatul este R=[2, 1, 3]
aduna d ( (3 , [ [1, X ,4] ] ,R) R) rezultatul lt t l este t X X=3 şi i R R=[1, [ 3, 4]
]

C) Construiți o procedură care să permită clasificarea concurenților dintr‐un turneu
de tenis în 3 categorii definite astfel:
‐ categoria câştigător dacă jucătorul i‐a bătut pe toți cei cu care a jucat;
‐ categoria luptător dacă jucătorul a câştigat şi a pierdut jocuri;
‐ categoria i sportiv i ddacă ă jjucătorul ă l a pierdut i d toate meciurile. i il
if X bate pe cineva and X este batut de altcineva
then X este luptator p
else if X bate pe cineva
then X este cistigator
else if X primeste bataie de la toti
then X este sportiv.
predicates
clasa (nume_sportiv, categoria)
clauses
clasa (X, luptator) if
b bate_pe(X, (X _), ) bate_pe( b ( _ , X) X), ! !.
clasa (X, cistigator) if bate_pe(X, _), !.
clasa (X, sportiv) if bate_pe( _, X).

Implementarea negației in Prolog
1. Se utilizează predicatele predefinite: cut (!) , fail sau true.
2 2. Se utilizează predicatul not not.
Exemplul:
Fie următoarea afirmație: Lui Tom îi plac animalele cu excepția pisicilor.
ii_place (proprietar, animal)
animal(nume ( _ animal) )
afirmația anterioara se scrie în prolog astfel:
ii_place(tom, p X) if X=pisica p , !, fail. % spune p ca pproprietatea p este falsă
ii_place(tom, X) if animal(X). % lui Tom îi place orice animal diferit
de pisică
Secventa mai poate fi scrisă compactat şi sub forma:
ii_place(tom, X) if
X=pisica, ii ! , fail fil ;
animal=X .

Cap. 7 OPERATII DE CITIRE / SCRIERE (I/O)
Scrierea
Predicatul de scriere prezintă sintaxa:
write(arg1, ... ,argn)
în care argumentele pot fi constante sau variabile legate ce aparțin unor
domenii standard sau definite de programator.
În interiorul şirului de caractere care pot fi afisate pe ecran ecran, sunt acceptate
următoarele caractere de control:
\n –scrie pe linie nouă, \t – tabulator,
\r –enter, \nnn –scrie caracterul cu codul ASCII nnn.
Exemplu: write ("\t Lista1 = ", L1, "\ n \ t Lista2 = ", L2)
Lista1 = [ ] Lista2 = [1, 2]

Citirea
Citirea dateleor de la tastatură este realizată de următoarele predicate:
readint(X) ‐ citirea variabilelor de tip întreg;
readreal(X) ‐ citirea variabilelor din domeniul real.
readln(X) ( ) ‐ citirea variabilelor din domeniul symbol y sau string; g
readchar(X) ‐ citirea caracterelor.
readint , readreal și readln ‐ operația de citire se termină în momentul
readint , readreal și readln operația de citire se termină în momentul
apăsării tastei enter
redachar ‐ este întotdeauna un succes;

Exemple p pentru p citire
1. Citirea termenilor unei liste de intregi:
domains
lista=integer *
predicates
citeste(lista)
clauses
citeste([E |Rest]) if
write("Element="),
write( Element ),
readint(E),
citeste(Rest).
citeste( ( [ ] ] ). ) { {citirea se termină
cu elementul vid}
goal
citeste(L), write(L).
domains
lista=integer *
predicates
citeste(lista, lista)
clauses
citeste(L1, L2) if
write("Element="),
readint(E), E0,
L1nou=[E| L1],
citeste(L1nou, L2).
citeste(L, ( L). ) { {citirea se termină cu 0} }
goal
citeste( i ([ [ ] , L) L), write(L).
i (L)

22. Specificați setul de clauze care să asigure citirea unei liste a căror elemente
sunt obiecte compuse de forma: persoana = p(nume, prenume, vârstă)
domains
nume, prenume = symbol
persoana = p( nume, prenume, integer)
lista = persoana *
predicates
citesc(lista)
citeste(persoana)
clauses
citeste( p( N, P, V)) if
nl,
write("Nume="),readln( N ),
write("Prenume="), readln( P ),
write("Virsta="), readint( V ),
nl.
citesc( ( [E|R]) ) if
citeste( E ),
citesc( R ).
citesc( [ ] ).

OPERAȚII CU ŞIRURI DE CARACTERE
Operatii de divizare / compunere a unui şir
A. La nivelul unui caracter:
frontchar(Sir, Elem, Rest_sir)
Exemplu:
frontchar( "Radu Dan Ion", E, R) % varianta (i,o,o):
EE= 'R' R , R = "adu adu Dan Ion" Ion
1 solution
Varianta (o (o,i,i) i i) recompune şirul, şirul alte moduri de lucru: (i (i,o,i), o i) (iio) (i,i,o), (iii) (i,i,i).
B. La nivelul unui element al şirului:
fronttoken(Sir, Elem, Rest Rest_sir) sir)
Exemplu:
fronttoken( ( "12 Dan Ion", , E, , R) ) % varianta (i,o,o) (, , )
E="12", R ="Dan Ion"
1 solution

Construiți o procedură care să desfacă un şir în elemente componente
a) la nivel de caracter si b) la nivel de element de şir
ddomains i
lista= char*
predicates
desfac(string, lista)
domains
elem= string
lista= lista elem* elem
predicates
desfac(string, lista)
clauses
clauses
desfac("", []).
desfac( ( S, , [ [E| | Lista]) ]) if
desfac(S, [C| Lista]) if
fronttoken( S, E, Rest),
frontchar(S, C, Rest_s),
desfac( Rest, Lista), !.
desfac(Rest desfac(Rest_s, s Lista), Lista) !. ! ddesfac( f ( _, [ ]) ]).

Comenzi şi operații de determinare a tipului de domeniu
char_int(char, integer) ‐ converteşte un caracter în valoarea ASCII (i,o) sau invers (o, i),
sau verifica egalitatea dintre codul caracterului si întreg (i, i)
str_char(string, char) ‐ converteşte un caracter într‐un şir (o, i), sau un şir cu un singur
caracter într‐un caracter (i, o)
str str_int(string, int(string, integer) ‐ converteşte un şir numeric într‐un într un întreg (i, o) sau invers (o, i) sau
verifică corespondenta dintre cele două
str_real(string, real) ‐ similar cu str_int, pentru numere reale
isname(string) ‐ verifică dacă variabila este un nume (începe cu o litera şi
continua cu cifre sau litere)
Operatii auxiliare
str_len(string, integer) - determină lungimea şirului (i, o) sau o verifică (i, i)
frontstr(integer, string, string, string) - împarte primul şir în două, primul având lungimea
dată de întreg; poate fi folosit numai ca (i, i, o, o).
concat(string, string, string) - concatenează primele două şiruri în al treilea;
numai (i, i, o).

Construiți o procedură care să determine tipurile de elemente din care
este t alcătuit l ăt itun şir: i alcătuit("12 l ăt it("12 a beta", bt"R) R)
R=[nr(12), car('a'), nume("beta")]
domains
element = nr(integer); car(char); nume(string)
lista = element*
predicates
alcatuit(string, lista) % desface sirul in elementele componente
este(string este(string, element) % determinarea tipului
clauses
este(E, ( , nr(N)) ( )) if str_ int(E,N). ( , )
este(E, car(C)) if str_char(E,C).
este(E, nume(E)) if isname(E).
alcatuit(Sir, [Tip | L ]) if
fronttoken(Sir, E, Restsir),
este(E, Tip), alcatuit(Restsir, L), !.
alcatuit(_,[]).

Exemplu: Construiți o procedura care să permită o analiză gramaticală simplă pentru propoziții simple de
forma: "Tom Tom is a cat cat" .
Pentru a detecta şi stabili predicatele se porneşte de la analiza gramaticală a propozițiilor de forma:
analizeaza ( "Tom is a cat", R)
R= structura(substantiv("Tom"), expe_verb("is", expr_substantivala("a", "cat")))
analizeaza (“ is a cat”), R)
R = structura(predicat( structura(predicat("is") is ), expr expr_substantivala( substantivala("a" a , "cat")) cat ))
analizeaza ( "a cat", R)
R = structura(articol("a"), substantiv("cat"))

Analizor gramatical
domains
subst, pred, art = string
e_subst = s(subst); e_subst (art, subst)
e_verb b = p(pred); ( d) e_verb b (pred, ( d e_subst) b )
propozitie = structura (e_subst, e_verb)
predicates pedcates
analizeaza(string, propozitie)
este_e_subst(string, string, e_subst)
este_e_verb(string, e_verb)
a(art) ( t)
s(subst)
p(pred)
clauses
analizeaza(Sir, structura(S_exp, V_exp)) :‐
este_e_subst(Sir, Rest, S_exp),
este_e_verb(Rest, t b(R t V V_exp). )
a("the"). a("a").
s("Tom"). ( ) s("Bill"). ( ) s("dog"). ( g ) s("cat"). ( )
p("is"). p("has").
este_e_subst(Sir, Rest, e_subst(Art, Subst)):‐
fronttoken(Sir, o tto e (S , Art,Rest1), t, est ),
a(Art),
fronttoken(Rest1, Subst, Rest),
s(Subst).
este_e_subst(Str, t b t(St RRest, t s(Subst)):‐ (S b t))
fronttoken(Str, Subst, Rest),
s(Subst).
este_e_verb(Str, e_verb(Pred, S_exp)):‐
fronttoken(Str, Pred, Rest1),
p(Pred),
este_e_subst(Rest1,"",S_exp).
t b t(R t "" S )
este_e_verb(Str, p(Pred)):‐
fronttoken(Str, Pred, ""),
p(Pred). p( )

Exemplu: Construiți o procedură care asigure împărțirea în silabe a unui cuvânt.
Reguli de despartire:
a) la o secvență de tipul vocală ‐ consoană ‐ vocală, împărțirea se face după prima vocală:
(prolog‐> pro‐log)
(regula‐> re‐gula)
b) lla o secvență ă dde tipul i lvocală lă ‐ consoană ă ‐ consoană ă ‐ vocală, lă împărțirea î ă i se face f între î cele l
două consoane (turbo ‐> tur‐bo)
c) excepțiile se exclud
domains /* structura de tip sir de caractere a unui cuvânt */
litera = char
cuvant = litera litera* % sirul de caractere este despărtit în literele componente
predicates
repeta /* asigură repetarea */
vocala(litera) /* distingerea între vocală‐consoană */
consoana(litera)
sir_cuvant(string, cuvant) /* transformarea unui şir în lista de caractere şi invers */
divide(cuvant divide(cuvant, cuvant cuvant, cuvant, cuvant cuvant) /* / impartirea în silabe */ /
/* divide(caractere prelucrate, rest de prelucrat, silaba 1, silaba 2)*/
clauses
vocala('a'). vocala('e'). vocala('i').
vocala('o'). vocala('u'). vocala('y').
consoana(C) if not(vocala(C)), C>= 'a', C

clauses
sir_cuvant("", [ ] ).
sir_cuvant(S, _ ( ,[ [C| | Lista]):‐ ])
frontchar(S, C, Rest_sir),
sir_cuvant(Rest_sir, Lista).
di divide(Inceput, ide(Inceput [L1 [L1, L2 L2, L3| Rest] Rest], Silaba1, Silaba1 [ L2 L2, L3| Rest]) :‐
vocala(L1), consoana(L2), vocala(L3),
conc(Inceput, [L1], Silaba1).
divide(Inceput, ( p [ [L1, L2, L3,L4| 3 4| Rest], ] Silaba1, [ [L3,L4| 3 4| Rest]) ]) if
vocala(L1), consoana(L2), consoana(L3), vocala(L4),
conc(Inceput, [L1, L2], Silaba1).
divide(Inceput, [Litera| Rest], Sil1, Sil2) if
conc(Inceput conc(Inceput, [Litera], [Litera] Prelucrat) Prelucrat),
divide(Prelucrat, Rest, Sil1, Sil2), !.
divide( _, [ ], [], []).
repeta.
repeta:‐ repeta.
goal /* citeşte cuvinte şi le desparte în silabe */
goal /* citeşte cuvinte şi le desparte în silabe */
repeta, write("cuvant = "), readln(C),
sir_cuvant(C, Lista_car),
divide( [ ] , Lista_car, S1, S2),
sir_cuvant(Sil1, S1), sir_cuvant(Sil2, S2),
write(Sil1, "‐", Sil2), nl, fail.

UUrmează ă cursul l4! 4 !