Cartea Pelin 2011 Capitolul Turbo Prolog

S. Pelin, N.
Pelin
Programarea
logică
în proiectarea sistemelor informaţionale
Chişinău, 2011
Limbajul Prolog
Pelin, S.
Programarea logică: în proiectarea sistemelor informaţionale / S.

Pelin, N. Pelin ; recenzenţi şt.: Chiriac Liubomir, Capaţina Gheorghe. –
Ch. : UST, 2011. – 221 p.
55 ex.
ISBN 978-9975-76-061-4.
510.62/.63+004.432.4(075.8)
P 49

Prezenta lucrare este consacrată aspectelor teoretice şi practice ale programării logice şi
utilizării lor în proiectarea sistemelor informaţionale.
În acest scop sunt descrise metodele logice utilizate în teoria programelor scrise în limbajul de
programare Prolog şi interpretarea lor automată pentru soluţionarea problemelor; tehnica
programării în limbajul Prolog; prezentarea logică a lumii reale pentru modelarea ei în sisteme
informaţionale. Pe de altă parte, este descris sistemul SPprolog - mediu computerizat pentru
suportul în proiectarea şi studierea de sine stătătoare a limbajului Prolog, precum şi metoda de
structurare a cunoştinţelor prin intermediul „Matricei elementelor de cunoştinţă”, ultima fiind
necesară la etapa de preproiectare a sistemelor informaţionale.
Lucrarea poate servi drept suport de curs pentru studenţi, masteranzi şi profesori de profil
informatic la studierea şi predarea ciclului de discipline ce ţin de metodele logice în sistemele
informaţionale, precum savanţilor şi specialiştilor în modelarea logică a sistemelor informatice.
Recomandată pentru publicare de către Senatul Universităţii de Stat Tiraspol
Recenzenţi ştiinţifici: Chiriac Liubomir, doctor-hab. în şt. fiz.-mat., şef catedră informatică şi tehnologii
informaţionale, Universitatea de Stat Tiraspol
Capatina Gheorghe, doctor-ing., şef.catedra tehnologii de programare Universităţii de Stat din Moldova
Copyright © 2011 Pelin Serghei, Pelin Nicolae

Limbajul Prolog
Cuprins
Prefaţă....................................................................................................
7
Întroducere...........................................................................................
9
1. Aspecte teoretice a programării logice ......................................

11
1.1.Unele noţiuni despre programe logice şi interpretorul Prolog ....

11
Lumea reală în programul logic realizat la calculator ...................... 11
Noţiunea de algoritm în filosofia programării logice ...................... 12
Programare în limbajele imperative de programare..........................

12
Sarcina ce stă în faţa programatorului având la dispoziţie
un interpretor logic .................................................................... 13
Caracterul nedeterminist al programelor logice ............................ 14
Interpretorul limbajului Prolog ...................................................... 14
1.2.Programarea logică ca
teorie .........................................................15 Logica
Limbajul Prolog
propoziţională ......................................................................
15
Disjunctul ......................................................................................... 16
Forma normală conjunctivă (FNC) .................................................. 17
Disjuncţii lui Horn ........................................................................... 17
Logica predicatelor........................................................................... 18
Variabilele şi rolul lor ...................................................................... 21
Despre interpretarea formulelor în logica predicatelor ....................

22
Forma prenex şi legătura ei cu formulele logicii propoziţionale...... 22
Probleme ce apar în operarea cu formele prenex .............................

23
Forma clauzală ................................................................................. 24
Universul Herbrand ......................................................................... 25
Forma frazală a logicii predicatelor ................................................. 25
Cuantificarea variabilelor în formă frazală ..................................... 26
Structura programului logic standard ..............................................

26
1.3 Întrebări şi exerciţii

...................................................................... 27
2. Deducţia logică – mecanism de calcul al limbajului
de programare logică .................................................................

31
Limbajul Prolog
2.2.Elemente de teorie
....................................................... ................ 31
Regula rezoluţiei ............................................................................. 31
Proprietăţile de finalizare a metodei de rezoluţie ...........................

32
Algoritmul de verificare a executabilităţii mulţimilor de
disjuncţi Horn ................................................................................. 32
Regula rezoluţiei în logica predicatelor ........................................... 33
Unificarea ........................................................................................ 34
Principiul programării logice .......................................................... 35
Strategia descendentă de rezolvare a problemelor prin
utilizarea regulii rezoluţiei ........................................................... 35
Eficienţa strategiei de rezolvare ................................................... 36
2.3.Interpretarea programelor logice

............................................. 36
Interpretorul abstract al programelor logice ................................. 36
Mecanisme de gestionare, implementate în interpretorul
programelor logice ....................................................................... 37
Executarea programelor de către interpretorul logic .................... 38
Executarea programelor în regim de interpretare ......................... 39
Ipoteza lumii închise .................................................................... 39
Prolog «pur» ................................................................................ 39

Limbajul Prolog
2.4. Rolul limbajului Prolog în studierea cursului de informatică

40
2.5.Aspecte metodologice de studiere a programării logice

......... 41
2.6.Întrebări şi
exerciţii ................................................................... 41
3. Limbajul Prolog ....................................................................... 43
3.2.Privire generală
........................................................................ 43
De ce trebuie de studiat programarea logică ? .............................. 43
Diferenţa dintre limbajele de programare tradiţionale şi logice ... 44
Mecanismele de ordonare, ramificare şi repetare în Prolog ......... 46
Puterea limbajului Prolog ............................................................. 47
3.3. Aspecte practice ce ţin de programare în limbajul Prolog

....... 51
Fapte ............................................................................................. 51
Reguli ........................................................................................... 53
Variabile ........................................................................................ 56
Secţiunile unui program Turbo Prolog ................................. ........ 58
Scopuri (Întrebări) ......................................................................... 59
Exerciţii ........................................................................................... 61
Relaţiile logice................................................................................. 62
Limbajul Prolog
Interfaţa cu utilizatorul în Turbo Prolog ........................................ 63
Intrări/Ieşiri ..................................................................................... 63
Lucrul cu ferestrele ......................................................................... 64
Unificare ......................................................................................... 66
Exerciţii ........................................................................................... 66
Backtraking ...................................................................................... 67
Esenţa mecanismului ...................................................................... 68
Exerciţii ........................................................................................... 71
Repetiţie şi recursie ......................................................................... 72
Exemple de reguli recursive ............................................................ 74
Exerciţii ........................................................................................... 77
Obiecte compuse .............................................................................78
Funcţii ............................................................................................. 78
Procesarea şirurilor ..........................................................................78
Conversii de tip de date .................................................................. 80
Aritmetica în Prolog ...................................................................... 81
Exerciţii ........................................................................................... 81
Liste ................................................................................................ 81
Declararea listelor ............................................................................83
Utilizarea listelor în exemple ..........................................................84
Arbori ............................................................................................. 86
Limbajul Prolog
Arbori binari ....................................................................................86
Utilizarea arborilor ..........................................................................87
Exerciţii .......................................................................................... 91
Baze de date interne (dinamice) ..................................................... 92
Adaugarea faptelor la momentul executării ................................... 92
Eliminarea faptelor la momentul executării ................................... 93
Salvarea datelor .............................................................................. 93
Operaţii afişare/citire ...................................................................... 96
Exerciţii .......................................................................................... 96
Fişiere ............................................................................................ 98
Exerciţii ..........................................................................................100
3.4.Sisteme Expert
............................................................................ 100
Proiectarea unui sistem expert ..................................................... 102
Exerciţii ....................................................................... . ............. 102
3.4. Întrebări şi exerciţii .....................................................................

105
4. Posibilităţile Turbo Prolog ...................................................... 109
4.2. Tipurile de date utilizate în Turbo Prolog ...............................

109
4.3.Predicate
predifinite................. .................................................. 110
Limbajul Prolog
4.4.Mediul Turbo Prolog

.................................................................. 113
4.5. Întrebări şi exerciţii

.................................................................... 117
5. Mediul de instruire şi proiectare al limbajului de
programare Prolog ................................................................. 119
5.2. Programarea logică în sisteme interactive de instruire

.......... 119
5.3.SPprolog : realizări şi perspective

.............................................. 120
Introducere .................................................................................... 120
Istoria aparitiei ............................................................................... 120
5.4.Posibilităţile SPprolog
................................................................. 124
Editor de cod avansat ......................................................................124
Mecanismul de reacţie la acţiunile utilizatorului ............................ 126
Interpretor multimedia interactiv ....................................................

128
5.5.Utilizarea sistemului
..................................................................... 131
5.5. Întrebări şi exerciţii .....................................................................

136
6. Alte versiuni al limbajului Prolog ............................................ 139

Limbajul Prolog
6.2.Analiza comparativă a versiunilor limbajului Prolog

............... 139
6.3.Strawberry Prolog
....................................................................... 140
6.4.Limbajul tuProlog
....................................................................... 148
6.5.Visual Prolog
................................................................................ 150
6.6.Întrebări şi exerciţii
..................................................................... 152
7. Proiectarea sistemelor informaţionale prin intermediul

limbajului Prolog
.......................................................................153
7.2.Unele noţiuni şi
definiţii. .......................................................... 153
7.3.Analiza şi sinteza sistemului informaţional în procesul de

proiectare ................................................................................
.... 157
Activităţi de proiectare a unui sistem informaţional ..................... 157
Stabilirea posibililor funcţii a sistemului informaţional, având la
bază întrebări simple ...................................................................... 158
Stabilirea posibililor funcţii a sistemului informaţional, având la
bază întrebări compuse ................................................................. 164
Funcţiile sistemului informaţional ................................................. 170

Limbajul Prolog
Etapele de proiectare a sistemului informaţional ...........................

171
..................................................................... 171
8. Structurarea informaţiilor în sisteme informaţionale ............. 173
8.1.Logica întrebărilor şi răspunsurilor .........................................

173
8.2.Structurarea informaţiilor (cunoştinţelor)

............................... 176
8.3.Unele concretizări
...................................................................... 184
8.4.Teoria „Matricei elementelor de cunoştinţe”

........................... 187
Constrângeri în funcţionare ........................................................... 188
Funcţionare în sistem ..................................................................... 189
Logica „Matricei elementelor de cunoştinţe” ................................. 191
Dialoguri ........................................................................................ 193
8.5.Structurarea cunoştinţelor din domeniul economic

................. 195
Exemplu descrierii noţiunii „corporaţie” în categoria esenţă prin

„Matricea elementelor de cunoştinţe”............................................ 195
Exemplu descrierii fragmentale a noţiunii „corporaţie” în
alte categorii prin „Matricea elementelor de cunoştinţe”...............

197
Limbajul Prolog
Fragmentul unui dialog .................................................................. 197
Cunoştinţe extrase ......................................................................... 198
8.6.„Matricea elementelor de cunoştinţe” în instruire

....................200
..................................................................... 201
Bibliografie .....................................................................................
203
Anexe .................................................................................................
207
I. Codurile
erorilor ............................................................................. 207
II. Cerinţe ce ţin de organizarea, executarea şi susţinerea

lucrărilor
de
laborator ...........................................................................................
217
Limbajul Prolog
3.1. Privire generală
De ce trebuie studiată programarea logică

Limbajul Prolog
În urma analizelor făcute mai sus, este posibil de afirmat că limbajele

de programare în logică trebuie studiate şi practicate din mai multe
considerente. Autorii, bazându-se pe mai multe surse [1, 9, 32, 33,
38, 39] şi experienţa proprie, evidenţiază şapte motive ce ne
sugerează studierea limbajului Prolog:
1. Programând în limbajul logic Prolog, în acelaşi timp, practic, se

obţine şi un model logic al aplicaţiei.
2. Programând în limbajul declarativ Prolog, se obţine un SOFT

pentru prelucrarea informaţiei, deseori fiind mai eficient decît
limbajele procedurale (imperative, algoritmice), cum ar fi de
exemplu C sau Pascal [1, p. 27] .
3. Programând în limbajul logic Prolog, se dezvoltă continuu

gîndirea logică a proiectantului.
4. SOFT-ul realizat în limbajul logic Prolog contribuie la

dezvoltarea gîndirii logice a utilizatorului.
5. Programând în Prolog, lărgim cercul potenţialilor proiectanţi

ai sistemelor de inteligenţă artificială, deoarece Prolog este un
limbaj al inteligenţei artificiale [18, 21, 28, 37, 44].
6. Începând programarea calculatorului prin intermediul

limbajului relaţional Prolog, se obţin rezultate mai importante
în studierea informaticii, deoarece Prolog este un limbaj de
programare mai apropiat de limbajul natural, este mai uşor de
studiat faţă de alte limbaje de programare. Nici din punct de
vedere metodologic nu este corect să se înceapă studierea
limbajelor de programare de la limbajele procedurale. Din
momentul când elevul a început să înţeleagă cum se
programează calculatorul, când a reuşit să lege un proiect cu
tehnicile de programare, să conştientizeze importanţa
Limbajul Prolog
informaticii în viaţa lui, să poată trece şi la alte tehnologii de

programare.
7. Programând în limbajul Prolog se contribuie la apropierea de

tehnologiile viitorului. Cel puţin aceasta reiese şi din
denumirile cărţilor unor autori [29].
Din păcate, limbajelor logice de programare, precum şi a celor

declarative în întregime, nu li se acordă atenţia cuvenită în Republica
Moldova, deoarece la nivel liceal au fost acceptate alte concepţii [9].
Pe parcursul anilor 1991-2010, în programele liceale de studiu a
informaticii despre programarea în logică, despre programarea
declarativă ca direcţie de alternativă, nici nu se menţionează.
Propunerile înaintate Ministerului Învăţământului din Republica
Moldova pentru prima dată, încă la începutul anilor 90 şi repetate pe
parcursul anilor pănă în prezent la diverse forumuri stiinţifice şi
metodice, nu au fost luate în consideraţie. E regretabil, dar aşa este.
Studierea limbajului Prolog în universităţi a inceput prin anii 90, deja
dupa studierea limbajelor procedurale în licee. Fapt care duce la
rezultate mai modeste [9, 33]. Şi totuşi este o decizie corectă şi
necesară. Autorii speră, că totuşi vor fi revizuite programele liceale la
cursul de informatică, cursul general de informatică la studii
universitare ciclul I şi disciplinele de specializare la ciclul II universitar.
Este necesară studierea conceptelor de programare atât declarativ,
cât şi procedural, prin analiza lor critică, evidenţierea priorităţilor şi
neajunsurilor fiecărei direcţii.
Diferenţa dintre limbajele de programare tradiţionale şi logice.
Există două diferenţe principiale ale limbajului de programare logică

şi ale limbajelor clasice algoritmice destinate calculelor numerice
[44]:
Limbajul Prolog
 prima - programarea logica este o programare simbolică,

unde datele sunt simboluri care se reprezintă doar pe sine şi
nu sunt interpretate la îndeplinirea programelor;
 a doua – în programarea logica algoritmii de obţinere a

rezultatelor nu se stabilesc. Se descriu doar obiectele,
calităţile lor şi relaţiile dintre ele prin intermediul Faptelor,
Regulilor de formare a faptelor noi, Întrebărilor care
determină prezenţa faptelor sau posibilitatea de stabilire a
lor.
Trei tipuri de expresii (Fapte, Reguli şi Întrebări) sunt interpretate ca

predicate logice şi atunci acest limbaj este o submulţime a logicii
formale.
Asemenea limbaje de programare ca Basic, Pascal şi C sunt limbaje

imperative (sau procedurale). Programul scris în limbajul imperativ
reprezintă o consecutivitate de comenzi scrise în baza unui algoritm)
care determină paşii necesari pentru obţinerea rezultatului dorit.
Prolog este un limbaj declarativ. Programul în limbajul declarativ

Prolog este doar o mulţime de descrieri logice ce determină scopul
pentru care a fost scris programul. În esenţă, programul scris în
Prolog, după cum a fost deja menţionat în capitolul 1, reprezintă o
mulţime de fapte şi reguli, modelele logice a cărora sunt disjuncţii
(clauzele) lui Horn, disjuncţi care nu dispun mai mult de o singură
literă pozitivă. La general, aceşti disjuncţi cuprind patru cazuri
particulare:
1. Disjunctul lui Horn unar, disjunct care conţine o literă pozitivă

şi nici una negativă. Este un model logic al faptului (axiomei);
Limbajul Prolog
2. Disjunctul lui Horn fix, disjunct care conţine o literă pozitivă şi

una sau mai multe litere negative. Este model logic al regulii
(teoremei);
3. Disjunctul lui Horn negativ, disjunct care nu conţine nici o

literă pozitivă, dar conţine una sau mai multe litere negative.
Este un model logic al întrebării (scopului);
4. Disjunctul vid care de asemenea, este unul dintre cazurile

particulare ale disjuncţilor lui Horn, dar spre deosebire de
primii trei este singurul din disjuncţi care nu este executabil.
Rolul lui, după cum s-a menţionat mai sus, este desebit de
important. Prin aplicarea lui şi a rezoluţiei în înterpretorul
limbajului Prolog, apare posibilitatea de a stopa calculul
pentru a obţine rezultatul interpretării programei logice.
În limbajul Prolog lipsesc structurile de control explicite cum ar fi

DO...WHILE... şi IF...THEN ... , iar programatorii cu experienţă de
programare prin intermediul limbajelor de programare imperative,
uneori au confuzii când se confruntă cu lipsa totală a controlului
programului. În locul descrierii paşilor de execuţie ai programului,
programatorul trebuie să determine metoda logică pentru obţinerea
scopului programului. Procedurile interne de unificare vor căuta apoi
soluţia problemei.
Mecanismele de ordonare, ramificare şi repetare în Prolog
În acelaşi timp, limbajul Prolog dispune de necesarul pentru a efectua

cele trei mecanisme (ordonare, ramificare şi repetare) văzute într-un
algoritm-tip prin care să reflecte organizarea fluxului de evenimente
în procesul de calcul (fig.4).
Ordonarea indică executarea câtorva operaţiuni la rând în strictă

corespundere cu ordinea stabilită. Este cea mai elementară metodă
Limbajul Prolog
de gestionare în majoritatea limbajelor de programare [45].

Mecanismul de ordonare poate fi demonstrat, de exemplu, printr-un
fragment al chemei-bloc a algoritmului (fig. 4a). În programele logice
ordonarea se stabileşte simplu, prin transcrierea chemarilor într-o
ordine textuală, după cum urmează:
readln(X), process(X, Y),write(Y)
Conform regulii de calul, interpretorul execută toate aceste trei

indicaţii în ordinea stabilită de la stânga la dreapta.
a) b) c)
Fig. 4. Fragmente ale schemelor-bloc care conţin mecanismele

de ordonare, ramificare şi repetare.
Mecanismul ramificare permite nominalizarea circumstanţelor în

urma cărora calculul atinge punctul de ramificare. În punctul de
ramificare se face verificarea executării unor condiţii, pentru alegerea
pasului următor în calcul. În exemplul 10b, este lansat fragmentul
Limbajul Prolog
schemei-bloc , al algoritmului ce demonstrează ramificarea. În

programele logice acest mecanism se poate atinge prin scrierea a
două reguli cu aceeaşi denumire a „capului” fiecăreia dintre reguli,
având în corpurile sale condiţiile ce reflectă ramificarea, de exemplu
ask :-
..., conditia1, ... .
ask:-
..., conditia2, ... .
Mecanismul de repetare asigură procesul de executare multiplă a

unuia şi aceluiaşi segment al programului. În fiecare din paşii repetaţi,
calculul, prevăzut pentru acest segment al programului, este complet
repetat şi numai după aceasta începe următorul pas [45]. Schema-
bloc a algoritmului în care este reprezentat acest mecanism este
redată în figura 10c. În programarea logică sunt două metode, care
permit atingerea acestui rezultat. Prima metodă - backtraking şi a
doua prin utilizarea regulilor recursive.
Puterea limbajului Prolog
Puterea limbajului Prolog constă în posibilităţile lui de căutare şi

potrivire. Procedurile interne de unificare vor enumera toate
opţiunile posibile, pentru satisfacerea scopului indicat de
programator. Prologul se bazează pe principiile logice – naturale şi
clare. Să examinăm un exemplu de operaţiune permanent prezent un
limbajele de programare procedurale: X = X + 1. Pentru un
programator sau o persoană care cunoaşte cât de puţin programarea
algoritmică (imperativă, procedurală) această operaţie este absolut
Limbajul Prolog
evidentă. Pentru limbajul Prolog sau o persoană care nu cunoaşte

programarea în general, o astfel de afirmaţie îl dezorientează. Cum
poate fi doi egal cu trei (2 = 2 + 1)? Pentru Prolog o asemenea
afirmaţie înseamnă ceva necondiţionat FALS. Desigur, şi pentru logica
umană aşa ceva pare incorect.
Pe de altă parte, programul în limbajul Prolog diferă foarte puţin de

metoda de gândire şi de explicaţie a omului. Un program logic
(declarativ) scris corect poate fi „citit” ca un limbaj natural. Să
analizăm câteva exemple de complexitate crescătoare.
Afirmaţia în limbajul natural „Mariei îi place muzica.”, în Prolog va

arăta astfel:
place( „Maria”, muzica ).
Afirmaţia „Lui Ion îi place Ceea ce îi place Mariei.”, în Prolog se va

scrie:
place( „Ion”, X ) if place(„Maria”, X ).
În această regulă X este o variabilă şi poate fi prezentată prin orice

combinaţie de caractere şi cifre, având orice lungime, dar neapărat
prima literă trebuie să fie majusculă. Cuvintele „Maria” şi „Ion” sunt
luate în „” pentru a evita confundarea variabilelor cu constantele.
Cuvântul if aici reflectă în limba română „DACĂ ... ATUNCI” (poate fi
înlocuit cu combinaţia de caractere „:-”). Dacă vom ţine cont de cele
susmenţionate, programul devine şi mai „citibil”:
place („Ion”, Ceva) if place („Maria”, Ceva).

Limbajul Prolog
Acest program mic poate răspunde la mai mult de 5 întrebări diferite

cum ar fi:
Tab.1. Variante de întrebărî şi răspusuri
Întrebare în limbajul Întrebare în Turbo Răspunsul Turbo

natural Prolog Prologului
Ce îi place Mariei? place( „Maria” , X). X = muzica
Ce îi place lui Ion? place( „Ion” , X). X = muzica

Dacă este adevărat place( „Maria” , Yes
că Mariei îi place muzica ).
muzica?
Cui îi place muzica? place( X , muzica) X = Maria
X = Ion
Să analizăm un alt exemplu. Este dată o listă de obiecte [carte, masa,

ceas, laptop, agenda]. Trebuie să determinăm dacă un obiect
aparţine acestei liste. Să încercăm a explica prin cuvintele limbajului
natural modelul procesului pentru soluţionarea acestei probleme.
Deoarece lista poate fi de o lungime aleatoare, ar trebui să găsim o
metodă logică recursivă de rezolvare. Aceasta poate fi:
X este primul element din Listă.
X aparţine Listei dacă sau
X aparţine RestuluiListei (Lista fără primul element).

Limbajul Prolog
În limbajul Prolog fragmentul programului, care reflectă modelul de

mai sus, poate fi uşor citit şi în limbajul natural, deoarece se apropie
mult de original:
apartine( X, [CapulListei | RestulListei] ) if X = CapulListei.
apartine( X,[ CapulListei | RestulListei] ) if apartine( X,RestulListei ).
Ca şi în primul exemplu, programul Prolog nu răspunde doar la o

întrebare: „Aparţine obiectul listei sau nu”, dar poate răspunde la cel
puţin 2 întrebări, acţionând şi ca un generator de soluţii sau, în cazul
dat, obiecte:
Tab.2. Variante de întrebări la care Prologul raspunde,

acţionând ca un generator de soluţii
Întrebare Răspunsul
Întrebare în Prolog
în limbajul natural Prologului
X = laptop,
Dacă aparţine
apartine(X, [carte, masa, Yes
obiectul listei?
ceas, laptop, agenda])
X = carte
X = masa
Care sunt apartine(X, [carte, masa,
X = ceas
obiectele listei? ceas, laptop, agenda])
X = laptop
X = agenda
Limbajul Prolog
Analizăm un alt exemplu, din domeniul rezolvării problemelor logice:

să se rezolve rebusul matematic TO + GO = OUT. Fiecare literă
trebuie să fie substituită cu un număr de la 0 până la 9, astfel încăt
această sumă matematică să devină corectă. În Prolog această
problemă se rezolvă astfel:
rebus(T,O,G,U):-
Numere = [0,1,2,3,4,5,6,7,8,9],
apartine( T, Numere),
apartine( O, Numere),
apartine( G, Numere),
apartine( U, Numere),
(T*10+O) + (G*10+O) = (O*100 + U*10 + T).
Această rezolvare va căuta toate soluţiile posibile ale acestui rebus,

dar trebuie menţionat că rezolvarea rebusului mai presupune o
condiţie, şi anume - literele rebusului trebuie să reprezinte numere
diferite. Această condiţie se adăugă pur şi simplu în program unde se
indica: T<>O (T diferit de O), T <> G, si aşa mai departe pentru fiecare
combinaţie de litere.
După cum se observă din mai multe exemple un program scris în

Prolog este clar, absolut logic şi poate fi citit şi înţeles fără o
experienţă mare în programarea logică. În aceasta şi constă farmecul
Prolog-ului, deoarece el întruchipează logica în acţiune.
Dacă vorbim despre alte deosebiri şi avantaje ale programării în

limbajul Prolog, putem menţiona că apariţia acestuia este un rezultat
al investigaţiilor savanţilor de la mai multe universităţi şi centre
ştiinţifice, dar nu o elaborare a unei persoane sau unui grup de
Limbajul Prolog
persoane cum sunt elaborate majoritatea limbajelor de programare.

Asta nu confirmă că Prologul să fie unicul şi cel mai important limbaj,
dar este o bună motivare să se considere că la baza limbajului sunt
puse investigaţii teoretice si o bază incontestabilă de demonstrare în
logica formală.
Aşadar, enumerăm avantajele principale ale Prologului şi programării

logice în general:
 este rezultatul investigaţiilor ştiinţifice întemeate;
 se bazează pe logică, - ştiinţă ce ţine de raţionament;
 este un limbaj declarativ (descriptiv);
 expresivitatea îi permite descrierea lumii reale cu tot

conţinutul, nuanţele şi subtilităţile ei;
 timpul de elaborare a softului în Prolog relativ este mic, în

special pentru proiectarea sistemelor de inteligenţă
artificială;
 este posibil de însuşit mult mai uşor decât limbajele

procedurale, poate fi predat chiar şi elevilor din clasele
primare.
3.2. Aspecte practice ce ţin de programare

în limbajul Prolog
Un program Turbo Prolog este o mulţime de clauze. Acestea sunt de

trei tipuri: fapte, reguli şi scopuri, pot fi descrisă, conform calculului
predicatelor, prin intermediul disjuncţiilor (clauzelor) lui Horn,
respectiv disjuncţiilor unare, fixă şi negative.
Limbajul Prolog
Fapte
Un fapt precizează „o proprietate a unui obiect sau exprimă o relaţie

dintre mai multe obiecte”. Forma sintactică generală prin care pot fi
descrise faptele este:
relaţie ( obiect1, obiect2, …, obiect n ).
În conformitate cu calcului (logica) predicatelor relaţie - este o

constantă predicativă, iar obiect1, obiect2, …, obiect n – sunt termeni.
Terminaţia fiecărui fapt este identificată prin punct. Constanta
predicativă în Turbo Prolog poate fi transcrisă folosind numai literele
alfabetului englez, cifrele arabice şi caracterul „_”- subliniere. De
exemplu:
ask
ASK
Ask_1
ask_szstem5
sunt constante predicative (relaţii) scrisă sintactic corect în limbajul

Turbo Prolog. La general, termenii (deja ştim din teorie) pot fi sau
constante, sau variabile, sau forme funcţionale Termenii obiect1,
obiect2, …, obiect n în fapte sunt (de obicei) constante. Constantele
simple, adica celea care nu sunt forme funcţionale, sunt puse în
corespundere cu cele şase tipuri de domene (date). Constantele pot fi
considerate scrisă corect în Turbo Prolog dacă sunt respectate ceriţile
formulate pentru relaţii (constante predicative) cu condiţia că în
calitate de prim simbol nu se folosesc litere majuscule. De exemplu,
constantele simple
ask
Limbajul Prolog
aSK
ask_1
ask_sistem5
sunt scrise sintactic corect, iar
ASK
Ask_1
în Turbo Prolog vor indentifica variabile despre care se va scrie mai

jos. Vom analiza două exemple.
Exemplul1: Dispunem de o propoziţie :
Bill este părintele lui Bob.
În acestă propoziţie (scrisă în formă infexă) Bill şi Bob sunt obiecte

(simple), iar relaţia între Bill şi Bob este determinată prin „este
părintele lui”. În conformitate cu sintaxa limbajului Turbo Prolog
aceasta propoziţie se prezintă în formă prefix în modul următor:
parinte (bill, bob).
Dacă totuşi este necesar de folosit litere majuscule pentru

prezentarea constantelor, atunci acestea obiecte trebuie de luat în
ghilimele:
Limbajul Prolog
parinte („Bill”, „Bob”).
Este posibil de prezentat în Turbo Prolog propoziţia susmenţionată şi

mai deplin:
este_parinte_lui („Bill”, „Bob”).
Tutuşi într-un program real prima prezentare a propziţiei din limba

română în limbajul Turbo Prolog este destulă pentru a fi „înţeleasă”
de programator, utilizator şi interpretor al limbajului Turbo Prolog.
O informaţie mai compusă se poate descrie cu o mulţime de fapte:
pam tom
parinte ( pam , bob ).
bob liz parinte ( tom , bob ).
parinte ( tom , liz ).

ann pat
parinte ( bob , ann ).
jim parinte ( bob , pat ).
parinte ( pat , jim ).
Fig.5. Fragment al unui arbore geneologic

Limbajul Prolog
Exemplul 2:
Elenei îi place muzica. place ( elena , muzica ).
Mariei îi place înotul şi voleiul. place ( maria , inot ).
place ( maria , volei ).
În Paris este situat Turnul Eiffel. situat ( paris , turnul_eiffel).
Reguli
O regulă în Prolog exprimă „o relaţie de dependenţă între fapte” şi

permite descrierea unor informaţii noi în baza celor deja cunoscute.
Forma sintactică generală este:
capul_regulii if corpul_regulii.
Sau, mai succint:
cap:-
corp.
Unde capul regulii poate fi:
relaţie (obiect1, obiect2,…,obiect n ),

Limbajul Prolog
iar corpul regulii poate fi:
relaţie1(obiect1,1 ,obiect1,2,…,obiect1, k1) and
not(relaţien-m(obiectn-m,1,obiectn-m,2,…,obiectn-m,k n-1)) and

:
relaţien-1(obiectn-1,1,obiectn-1,2,…,obiectn-1,k n-1) and
relaţien(obiectn,1,obiectn,2,…,obiectn,kn).
În capul regulii avem un singur predicat. În corpul regulii pot apărea

unul sau mai multe predicate, legate între ele prin conectorul and (,)
sau or (;). Un fapt poate fi privit şi ca o regulă cu corpul vid.
Aşă dar, în Turbo Prolog următoarele simboluri sunt echivalente:
if  :-
and  ,
or  ;
Totuşi, în viziunea noastră, legătura logică or nu este bine să fie

folosită în calitate de conector în corpul regulei. Această
recomandare să referă în primul rând pentru programatorii-
începători. După cum sa mai menţionat mai sus logicul or în textul
programului scris în Prolog poate fi exprimat şi prezentat prin două
reguli cu aceleaşi forme predicative scrisă în capul lor. Aceste reguli
trebuie scrise la rând una după altă.
Limbajul Prolog
Terminaţia fiecărei din reguli, în program, este indentificată prin

punct.
În final vom specifica unele aspecte ce ţin de reguli, fiind o structură

deosebit de importantă în programarea logică [11,12].
Esenţial: regula este o structură care permite opţinerea noilor fapte

(cunoştinţe) din faptele deja existente.
Calitativ: regula este „apreciată” de interpretorul limbajului Prolog în

modul după cum urmează:
Forma predicativă stipulată în capul regulei va fi indentificată prin

„Adevăr”, dacă se va confirma că formele predicative stipulate în
corpul ei vor fi indentificate la fel prin „Adevăr”.
Cantitativ: regula constă din patru componente: cap(cu una singura

formă predicativa, programatorii practici simplificat o mai numesc
predicat), corp(cu una sau mai multe forme predicative), deviator (if
sau :-) şi terminaţie (punct).
Relativ: regula este secundară în comparaţie cu faptul. Regula poate

fi echivalentă cu un fapt numai în cazul dacă corpul regulei este nul.
Când: regula poate fi „acceptată” de către interpretorul limbajului

Turbo Prolog în procesul de compilare, numai în cazul daca în secţia
CLAUSES există fapte care pot fi unificate cu formele predicative
(predicatele) din corpul regulei.
Unde: regula este o structură de bază în sisteme deductive.
În ce stare se găseşte: Se foloseşte la maxim, de exemplu, în

proiectarea sistemelor bazate pe producţii.
Limbajul Prolog
Este posesoare de: Vizual regula scrisă în conformitate cu sintaxa

Turbo Prologului este posesoare de o structură expresivă, fapt ce
permite de a o găsi vizual repede în textul programului.
Acţionează: Fără structuri de acest fel cum este o regulă ar fi

imposibil utilizarea programării logice în inteligenţă artificială,
dezvoltarea eficientă acestui domeniu al informaticii.
Suportă: În funcţie de versiune a limbajului logic de programare

suportă diverse modificări ce ţine de alfabet şi sintactică.
Aşa dar a fost analizată regula la general, utilizând categoriile

Aristoteliene, descrise în opera lui sub denumirea „Categorii”.
Structurarea cunoştinţelor ce ţine de reguli, în felul prezentat mai
sus cu mult contribuie la înţelegerea mai profundă a materialului.
Utilizarea acestei metodologii în procesul de analizare şi proiectare a
sistemelor informaţionale la fel este de o importanţă majoră. Mai
detaliat despre structurarea cunoştinţelor este scris în capitolul 8.
Vom analiza un mic program cu utilizarea regulei în exemplul de

mai jos.
Exemplul 3:
fapte:
parinte ( bill , bob ).
femeie ( pam ).
Putem adăuga în acest program o regulă care defineşte relaţia mamă

reieşind din faptele părinte şi femeie.
mama ( X, Y ) if
Limbajul Prolog
parinte ( X, Y) and
femeie (X).
Exemplul 4:
auto(BMW,_524td,1984,220,diesel,automat,negru,2.4,yes,3000).
auto(BMW,_525,1990,260,benzin,manual,alb,2.5,yes,6000).
auto(FORD,transit,1986,180,benzin,manual,alb,2.3,yes,4000).
auto(WV,golf,1995,280,benzin,manual,rosu,2.0,yes,6000).
auto(Honda,civic,1998,280,benzin,manual,negru,3.1,yes,9000).
automobil_sportiv( X ):-
auto(X, _ , _ , Viteza , _ , Cutia_de_viteze , _ , _ , _ , _ ),
Viteza > 250,
Cutia_de_viteze = manual.
Variabile
În Turbo Prolog numele de variabile trebuie să înceapă cu majusculă

sau simbolul „ _”‚ (liniuţa de subliniere), urmate de oricâte litere,
cifre sau simbolul „_” care înseamnă „orice”. Se foloseşte atunci când
în scrierea unei reguli o variabilă apare o singură dată (semnificând
practic faptul că valoarea ei nu este folosită).
Variabilele sunt iniţial „nedefinite” (nu au valori, sunt „nelegate”).

Legarea la o „valoare” se face pe parcursul executarii programului,
prin unificare. Variabilele în Prolog sunt variabile logice. Ele sunt
Limbajul Prolog
asemănătoare cu necunoscutele din matematică, în sensul că atunci

când sunt libere, se presupune că vor lua o valoare dintr-un domeniu,
iar atunci când sunt legate la o anumită valoare nu i se mai poate
schimba valoarea decât prin backtracking.
Valoarea variabilei nu se poate modifica prin instrucţiuni de asignare

cum ar fi X:=X+1; sau X:=2∙X +Z ca în limbajele imperative. Din punct
de vedere a logicii, instrucţiunea de tip
X=X+1 (5=5+1)
nu este logică!!! Dacă într-o clauză o variabilă apare de mai multe ori,
atunci ea va avea aceeaşi valoare. Modificarea variabilei se face
printr-o altă variabilă: X2=X+1. Însă două clauze pot folosi acelaşi
nume pentru o variabilă, neexistând nici un fel de legătură între ele.
Transmisia valorilor variabilelor între clauze se face prin argumentele
predicatelor.
Exemplul 5:
clauza_1:-
X=5,
X2=X*2,
clauza_2(X2).
clauza_2(X2):-write(“X2=”,X2).
În exemplul 5 se arată cum poate fi transmisă o variabilă de la o

clauză la alta (se transmite valoarea variabilei X2 din clauza_1 în
clauza_2).
Limbajul Prolog
Exemplul 6:
clauza_1:-
X=5,
clauza2(X2),
X3 = X + X2,
write (X3).
clauza_2(X2):-
X2 = 4.
În exemplul 6 se arată cum poate fi obţinută o variabilă dintr-o clauză

(se obţine valoarea variabilei X2 din clauza_2).
Secţiunile unui program Turbo Prolog
Un program scris în Turbo Prolog este segmentat în mai multe secţii.

În fiecare din secţii în parte a programului pot fi sau declarate tipurile
de date sau predicatele respective create de către programator, sau
faptele şi regulile sau scopul. De exemplu:
/*====================================
Comentariu
=====================================*/
% Comentariu
DOMAINS
Limbajul Prolog
% <descrierea tipurilor de date (symbol, string, char, integer,

real, file)>
DATABASE
% <declararea predicatelor de baza de date dinamica>
PREDICATES
% <declararea predicatelor>
CLAUSES
% <afirmaţiile>
GOAL
% <afirmaţiile de scop>
În acest exemplu sunt menţionate numai unele din secţiuni (precum

şi ordinea de scrierea lor) care vor fi folosite în programele analizate
în această lucrare. În proprame mai complicate se folosesc şi alte
secţii descrisă în User Guaid. Există posibilitate şi necesitate pentru
unele cazuri de introduce în program secţii cum ar fi GLOBAL
DATABASE, GLOBAL PREDICATES şi altele.Grupul de simboluri /*
...*/ este utilizat pentru a comenta o parte din text a programului,
care poate conţine unul sau mai multe rânduri şi nu este interpretat
de către înterpretor. Simbolul % este utilizat pentru a comenta un
rând din textul programului.
După cum vedem în DOMAINS trebuie descris tipurile de date.

Formatul transcrierii tipurilor de date pentru symbol, string, char,
integer şi real este într-un fel, file în altul, de exemplu:
Limbajul Prolog
DOMAINS
nume_simbolic_al_termului_1=symbol
nume_simbolic_al_termului_2=integer
file= nume_simbolic_al_fisierului
În secţiile DATABASE şi PREDICATES şă declară predicatele

respective. Pentru ambele secţiuni formatul trascrierii este indentic.
De exemplu:
DATABASE
age_db(nume_simbolic_al_termului_1,
nume_simbolic_al_termului_2)
PREDICATES
age(nume_simbolic_al_termului_1,
nume_simbolic_al_termului_2)
În CLAUSES să scriu faptele şi regulile conform cerinţelor ce ţin de

sintaxa limbajului Turbo Prolog.
În secţia GOAL să anunţă scopul intern, scop urmarit în realizarea

versiunei concrete a aplicaţiei.
Limbajul Prolog
Aşadar, în secţiile CLAUSES şi GOAL – sunt prezentate faptele,

regulile şi întrebările prin modelele sale logice, respectiv,- disjuncţii
lui Horn unar, fix şi negativ.
Scopuri (întrebări)
Scopurile pot fi interne sau externe. Un scop intern, dupa cum sa

menţionat mai sus, se va scrie în secţiunea GOAL. Scopul extern se
va scrie în fereastra de dialog, după rularea programului (dacă acesta
nu conţine secţiunea GOAL, adica nu conţine scop predefinit înnainte
de rularea programului).
Forma sintactică generală a unui scop se aseamănă cu forma corpului

unei reguli. Reacţiile sistemului Turbo Prolog la scop extern şi cel
intern este demostrată în exemple şi respectiv prezentate prin
figurile 6 şi 7, afişate mai jos.
█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▀▀▀▀▀▀▀▀▀█
█┌──────────────────────────────────────────────┐█
█│ Files Edit Run Compile Options Setup │█
█└──────────────────────────────────────────────┘█
█┌────────── Editor ────────┐ ┌───── Dialog─────┐█
█│Predicates │ │GOAL: │█
█│ parinte (symbol,symbol) │ │ parinte(X,bob). │█

Limbajul Prolog
█│Clauses ││ │█
█│ parinte (bill, bob). │ │X = bill │█
█│ parinte (pam, bob). │ │X = pam │█
█│ │ │2 Solutions │█
█│ ││ │█
█│ ││ │█
█└──────────────────────────┘ └─────────────────┘█
█┌───────── Message ────────┐ ┌────── Trace ────┐█
█│ ││ │█
█│ ││ │█
█└──────────────────────────┘ └─────────────────┘█
█F2-Save F3-Load F6-Switch F9-Compile Alt-X-Exit█
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▀▀▀▀▀▀▀▀▀▀
Fig. 6. Reacţia sistemului Turbo Prolog la scop extern
█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▀▀▀▀▀▀▀▀▀█
█┌──────────────────────────────────────────────┐█
█│ Files Edit Run Compile Options Setup │█
█└──────────────────────────────────────────────┘█
█┌────────── Editor ────────┐ ┌───── Dialog─────┐█

Limbajul Prolog
█│Predicates │ │bill │█
█│ parinte (symbol,symbol) │ │Press the SPACE b│█
█│Clauses │ │ar │█
█│ parinte (bill, bob). │ │ │█
█│ parinte (pam, bob). │ │ │█
█│Goal ││ │█
█│ parinte(X,bob), ││ │█
█│ write(X). ││ │█
█└──────────────────────────┘ └─────────────────┘█
█┌─────── Message ─────────┐ ┌────── Trace ─────┐█
█│ ││ │█
█│ ││ │█
█└─────────────────────────┘ └──────────────────┘█
█F2-Save F3-Load F6-Switch F9-Compile Alt-X-Exit█
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
-▀
Fig. 7. Reacţia sistemului Turbo Prolog la scop intern
Exerciţii
Limbajul Prolog
1. De elaborat un program în limbajul Prolog ce simulează un

vocabular (român-englez, englez-român, francez-român etc... ).
De consultat programul cu întrebări de tipul:
 p(cuvânt_concret, cuvânt_concret) - răspuns corect
 p(cuvânt_concret, cuvânt_concret) - răspuns incorect
 p(X, cuvânt_concret) - valoarea X
 p(cuvânt_concret,Y) - valoarea Y
 p(X,Y) - valorile X,Y
2. De elaborat o bază de cunoştinţe, un program în limbajul Prolog

care constă din faptele unui arbore genealogic, folosind relaţiile:
parinte, femeie, barbat.
I. De verificat programul cu întrebări de tipul:
 parinte (nume_concret, nume_concret).
 parinte (nume_concret, X).
 parinte (X,Y).
 femeie (nume_concret).
 femeie (X).
II. De substituit faptele cu relaţia barbat cu o regula

este_barbat( X ) :- ..., care este adevărată dacă numele X nu este
nume de femeie.
III. De verificat programul cu întrebări de tipul:

Limbajul Prolog
 este_barbat(nume_concret)% motivaţi rezultatul
 este_barbat( X ) % motivaţi rezultatul
IV. De adăugat în programul de mai jos reguli care ar determina

următoarele relaţii:
 X este mama lui Y  X este mătuşa lui Y
 Y este tata lui Y  X este nepotul lui Y
 X este fratele lui Y  X este copilul lui Z
 X este sora lui Y  X are copii
 X este bunica lui Y
DOMAINS % baza de cunoştinţe = baza de fapte
nume = SYMBOL
PREDICATES
parinte( nume, nume )
CLAUSES
parinte ( tom , bob ) .
parinte ( tom , liz ).
parinte ( bob , ann ).
parinte ( bob , pat ).

Limbajul Prolog
parinte ( pat , jim ).
femeie (pam).
femeie (liz).
femeie (ann).
femeie (pat).
barbat (bob).
barbat (tom).
barbat (jim).
Relaţiile logice în Prolog
În limbajul Prolog sunt folosite trei legături logice: ŞI, SAU, NU

(AND,OR,NOT). După cum ştim din teorie, o formulă scrisă în logică
poate fi retransformată în forma conjuctiv normală (FCN), în care
sunt folosite aceleaşi trei legături logice. Acestea legături pot fi
prezentate şi înţelese prin următoarea schemă care reflectă trecerea
de la propoziţii în limbajul natural la instucţiuni în limbajul Prolog:
Mâine timpul va fi bun

Limbaj natural
Limbaj natural
DACĂ azi timpul este cald ŞI NU este vânt ŞI NU sunt nori
SAU
DACĂ azi plouă ŞI este vânt dar ploaia scade ŞI vântul

Limbajul Prolog
scade SI temperatura creşte
SAU
DACĂ aşa a fost anunţat la radio.
timpul(miine,bun)
DACA este(azi,cald) ŞI NU(este(azi,vint)) ŞI NU(este(azi,nori))
SAU
timpul(miine,bun)
DACA este(azi,ploaie) ŞI este(azi,vint) ŞI este(azi,ploaia_scade) ŞI
este(azi, vintul_scade) ŞI este(azi,temperatura_creşte)
SAU
timpul(miine,bun)
DACA este(azi, anunţal_la_radio)
Fragmentul modelului logic în limbajul Prolog.
timpul(miine,bun) :-
Limbajul Prolog
este(azi,cald) , not(este(azi,vint)) , not(este(azi,nori)).
este(azi,ploaie) , este(azi,vint) , este(azi,ploaia_scade) ,
este(azi, vintul_scade), este(azi,temperatura_creşte).
este(azi, anunţal_la_radio).
De fapt în limbajul Prolog dispunem de acelaşi model logic, prezentat

puţin diferit numai sintactic.
Interfaţa cu utilizatorul în Turbo Prolog
Pentru a elabora o interfaţă clară şi simplă pentru un program în

Turbo Prolog, există predicate predifinite în lucrul cu ferestrele,
predicate predifinite pentru întrări şi ieşiri, pentru prelucrarea
şirurilor, fişierelor, etc.
Intrări/Ieşiri
write
Este un predicat cu care se poate scrie pe ecran orice tip de

obiecte. Formatul:
write (Arg, Arg2, ... , ArgN, „comentariu” )
Prototipul:
(i)
Limbajul Prolog
Arg, Arg2, ... , ArgN –variabile,
„comentariu” – ori care text luat în „” care va fi scos la ecran.
Exemplu:
X=„Ion”,
write („Bine aţi venit domnule(nă) ”,X).
Scrie pe ecran:
Bine aţi venit domnule(nă) Ion
readln
Cu readln se citeşte o linie de text terminată cu newline.
Formatul:
readln (Arg)
Prototipul:
(o)
Arg – variabilă tip STRING sau SYMBOL
Exemplu:
readln(X)
Atribuie lui X valoarea introdusă de la tastatură.
Modificaţii:
readint(integer)
readchar(char)
Limbajul Prolog
readreal(real)
Sunt folosite în funcţie de tipul de date, valorii care trebuie să fie

întrodusă de la tastatură.
Lucrul cu ferestrele
makewindow
Makewindow creează o fereastră.
Formatul:
makewindow (Win_nr, Scr_atr, Fr_atr, Header, Row,

Column, Height, Width)
Prototipul:
(i,i,i,i,i,i,i,i) sau (o,o,o,o,o,o,o,o)
Win_nr - numărul ferestrei (identificator),

Scr_atr - culoarea ecranului,
Fr_atr - culoarea chenarului,
Header - titlul ferestrei,
Row, column - poziţia colţului stâng de sus,
Height - înălţimea ferestrei,
Width - lăţimea ferestrei.
Culorile ecranului şi culorile chenarului se calculează prin executarea

indicaţiei: „Selectaţi una dintre culorile foreground color şi
background color şi adunaţi cele două valori”.
Tab.3. Codurile culorilor [22, 46]
BACKGROUND-COLORS (Screen) FOREGROUND-COLORS (Characters)
-----------+---------+----------------+------------
Limbajul Prolog
Black 0 Black 0
Blue 16 Blue 1
Green 32 Green 2
Cyan 48 Cyan 3
Red 64 Red 4
Magenta 80 Magenta 5
Brown 96 Brown 6
White 112 White 7
Grey 8
Light Blue 9
Light Green 10
Yellow 14
White (High Intensity) 15
0 col 8
0 0
row Heade
r
heig
ht
25
widt
h
Limbajul Prolog
Fig. 8. Prezentarea grafică a termenelor header, row, column, height,

width predicatului makewindow.
Exemplu:
makewindow(1,25,25, “PROLOG”, 5, 20, 10, 40)
În urma executării acestui predicat se creează o fereastră cu

dimensiunile specificate.
Unificare
termen1 = termen2
Tab.4. Prezentarea operaţiunelor de executare

în procesul de unificare
termen1 termen2 Operaţiunea

Limbajul Prolog
executată
Variabilă ce conţine Variabilă ce conţine
Comparaţie
o valoare o valoare
Variabilă ce conţine Variabila fără Se atribuie valoarea

o valoare valoare (free) termen2:=termen1
Variabilă fără Variabilă ce conţine Se atribuie valoarea
valoare (free) o valoare termen1:=termen2
Variabile fără Variabile fără

Eroare
valoare (free) valoare (free)
Exerciţii
De elaborat un program în limbajul Prolog, care conţine o bază de

date (fapte) de automobile la un magazin auto.
I. De verificat programul cu întrebări de tipul:
 care sunt automobilele de culoare neagra?
 care sunt automobilele de anumita marca şi serie?
 care sunt automobilele cu preţul mai mic decât 3000?
 care sunt automobilele de culoare neagră, cu anul mai mare

decât 1995 şi cu preţul mai mic decât 4500?
 care sunt automobilele cu volumul motorului între 2.0 şi 3.0 de

culoare neagra sau roşie?
II. De adăugat o regulă care ar determina ce înseamnă un automobil

sportiv:
Limbajul Prolog
sport_car ( Marca, Seria).
II.1. De listat toate automobilele sportive din baza de date.
II.2. De verificat programul cu următoarele întrebări:
 sport_car(marca_sportiva,seria_sportiva)
 sport_car(marca_ne_sportiva,seria_ne_sportiva)
III. De adăugat în program următoarele definiţii de tipuri de

automobile:
 automobil_de_familie
 automobil_de_prestigiu
 automobil_pentru_dame
 automobil_de_anticariat
IV. De elaborat un meniu textual pentru controlul întregului program

de mai jos.
DOMAINS % baza de date = baza de

fapte
marka,seria,combustibil, culoarea, accesorii = SYMBOL
anul, viteza_max = INTEGER
volumul_motorului, pretul = REAL
PREDICATES
auto( marka, seria , anul, viteza_max, combustibil, culoarea ,
volumul_motorului, accesorii, pretul)

Limbajul Prolog
CLAUSES
auto(BMW, _524td, 1984, 220, diesel, negru, 2.4, yes, 3000).
auto(BMW, _525, 1990, 260, benzina, alb, 2.5, yes, 6000).
auto(FORD, transit, 1986, 180, benzina, alb, 2.3, yes, 4000).
auto(WV, golf, 1995, 280, benzina, rosu, 2.0, yes, 6000).
auto(Honda, civic, 1998, 280, benzina,negru, 3.1, yes, 9000).
Backtraking
Mecanismul backtracking constă în satisfacerea şi resatisfacerea

repetată a subscopurilor unui scop. La satisfacerea unei conjuncţii de
subscopuri se încearcă satisfacerea fiecărui subscop pe rând, de la
stânga la dreapta. Prima satisfacere a unui subscop determină
plasarea unui marcaj în dreptul faptului care a determinat
satisfacerea subscopului. Dacă un subscop nu poate fi satisfăcut,
adică eşuează, sistemul revine şi încearcă resatisfacerea subscopului
cel mai aproape din stânga, pornind căutarea în baza de la marcaj în
jos. Înainte de resatisfacerea unui subscop, se elimină toate
instanţierile de variabile determinate de ultima satisfacere a acestuia
Bactraking este un mecanism de revenire în caz de nereuşită la cel

mai apropiat punct de ramificare în program de unde se poate obţine
o variantă alternativă de soluţionare a problemei.
Puncte de ramificare sunt întrebările sau apelurile la predicatele din

program care conţin mai mult de o clauză (legătura logica SAU).
Esenţa mecanismului
Limbajul Prolog
În program se întâlnesc „Puncte de ramificare” – puncte unde este

necesar ca Prolog să aleagă una din mai multe variante de soluţionate
(legătura sau) din mai multe alternative. Apoi se poate constata că
varianta selectată nu poate fi soluţie pentru problema dată, atunci
Prolog revine la ultimul Punct de ramificare şi selectează următoarea
soluţie posibilă din punctul dat.
Specificul backtrakingului constă în faptul că revenirea la ultimul

punct de ramificare înseamnă şi restabilirea valorilor variabilelor.
Valorile variabilelor îşi restabilesc valorile care le-au avut la prima
trecere a acestui punct de ramificare.
Dacă sunt nereuşite toate soluţiile (alternativele) unui punct de

ramificare, atunci Prologul ia precedentul punct de ramificare.
Goal
Punct de ramificare 1
Punct de ramificare 2 A Punct de ramificare 3
B Soluţie
C Soluţie
1a 2a
Soluţie Soluţie
Soluţie Soluţie
Soluţie 1c 2c
1b 1b nu
Dacă soluţia 3b
2b
satisface scopul (este
falsă), revine la punctul de
ramificare B şi selectează
următoarea soluţie.
Limbajul Prolog
Fig. 9. Demonstrarea mecanismului backtracking.
Predicatul „!” – „cut” retrage toate punctele de ramificare din

predicatul dat!
Exemplul 1:
PREDICATES
country(STRING)
Moldova
print_countries Romania
Germania
CLAUSES Bulgaria
country(“Moldova”).
Country(“Romania”).
Country(“Germania”).
Country(“Bulgaria”).
Print_countries :-
Limbajul Prolog
country (X),
write (X),nl,
fail.
Print_countries.
GOAL
print_countries.
Exemplul 2:
PREDICATES
>Chisinau
country (STRING) Moldova
Romania
capital (STRING) Germania
Bulgaria
print_countries
>Bucuresti
CLAUSES Moldova
country (“Moldova”). Romania
Germania
Country (“Romania”). Bulgaria
Country (“Germania”). >Berlin

Moldova
Country (“Bulgaria”). Romania
Germania
Bulgaria
Capital (“Chisinau”).
Capital (“Bucuresti”).
Capital (“Berlin”).
Print_countries :-
Limbajul Prolog
capital (Y),
write (“>”,Y),
nl,
country (X),
write (X),
nl,
fail.
Print_countries.
GOAL
print_countries.
Exemplul 3:
PREDICATES
country (STRING)
Chişinău> Moldova
capital (STRING) Chişinău>Romania
Chişinău>Germania
print_countries Chişinău>Bulgaria
CLAUSES Bucureşti>Moldova
Bucureşti>Romania
country (“Moldova”). Bucureşti>Germania
Bucureşti>Bulgaria
Country (“Romania”). Berlin >Moldova
Berlin >Romania
Country (“Germania”). Berlin >Germania
Berlin >Bulgaria
Country (“Bulgaria”).
Limbajul Prolog
Capital (“Chişinău”).
Capital (“Bucureşti”).
Capital (“Berlin”).
Print_countries :-
capital (Y),
country (X),
write (Y,”>”),
write (X),
nl,
fail.
Print_countries. 00000000
00000001
GOAL
00000010
print_countries. 00000011
00000100
00000101
00000110
00000111
00001000
Exemplul 4: 00001001
PREDICATES 00001010
00001011
bit (INTEGER) 00001100
00001101
byte 00001110
00001111
CLAUSES 00010000
bit (0).
Limbajul Prolog
Bit (1).
Byte :-
bit (X1), bit (X1),
bit (X1), bit (X1),
bit (X1), bit (X1),
bit (X1), bit (X1),
write (X1,X2,X3,X4,X5,X6,X7,X8),
nl,
fail.
Byte.
GOAL
byte.
Exerciţii
1. De elaborat un program în limbajul Prolog care rezolvă

rebusul:
TETA
BETA
GAMMA
Limbajul Prolog
şi
DONALD
GERALD
ROBERT
2. De elaborat un program în limbajul Prolog numit Magazin-Auto.
Programul conţine un meniu prin care se poate selecta parametrul de

căutare (Marka, Anul, Preţul); permite introducerea parametrului şi
afişează toate automobilele din baza de date ce corespund
parametrilor de căutare.
1. Lista automobilelor
2. Căutare după anul automobilului
3. Căutare după marcă
4. Căutare după preţ
?–
3. (Enigma poliţistă) Sa se scrie un program Prolog pentru rezolvarea

urmatoarei enigme poliţiste:
Jean a fost omorât marţi. Singurii suspecţi sunt Luc, Paul, Alain,
Bernard şi Louis. Se ştie că:
- asasinul este cineva care doreşte sa-l omoare pe Jean, are armă şi n-
are un alibi valabil pentru marţi;
- un alibi susţinut de o persoana dubioasa nu este valabil;

Limbajul Prolog
- cineva poate dori să-l omoare pe Jean dacă are acest interes sau
dacă doreşte să se răzbune;
- cineva are interesul să-l omoare pe Jean dacă îi moşteneşte averea,

îi datorează bani sau Jean l-a surprins comiţând o crimă.
Ancheta a stabilit următoarele:
- Luc are un alibi susţinut de Bernard pentru marţi;
- Paul are un alibi susţinut de Bernard pentru marţi;
- Louis are un alibi susţinut de Luc pentru marţi;
- Alain are un alibi susţinut de Luc pentru joi;
- Alain este o persoana dubioasa;
- Paul vrea să se răzbune pe Jean;
- Luc vrea să se răzbune pe Jean;
- Bernard este moştenitorul lui Jean;
- Jean este moştenitorul lui Louis;
- Louis îi datorează bani lui Jean;
- Luc îi datorează bani lui Jean;
- Jean l-a văzut pe Alain comiţând o crimă;
- Luc are o armă;
- Louis are o armă;
- Alain are o armă.

Limbajul Prolog
Repetiţia şi recursia
Turbo Prolog nu dispune de instrucţiuni imperative repetitive de

genul for, while, repeat. Pentru a putea, totuşi, repeta evaluarea
unor predicate, există două posibilităţi:
1) folosirea backtracking-ului în cazul în care nu este nevoie să

se transmită valorile unor variabile;
2) folosirea recursiei cu parametri, „transmiţând” rezultatele

intermediare ca argumente ale predicatului recursiv.
Schemele generale pentru efecuarea repetiţiei folosind backtracking-

ul sunt următoarele:
<acţiune_repetata>:-
<predicat_cu_punct_de_backtracking>,
<acţiune>,
fail.
<acţiune_repetata>.
<acţiune_repetata>:-
<predicat_cu_punct_de_backtracking>,
<acţiune>,
<condiţie de oprire>.
<acţiune_repetata>.
Limbajul Prolog
Prima metodă este folosită pentru a prelucra toate faptele din baza
de date. Se poate scrie un predicat, numit (generic) repeat, care să
creeze punctul de backtracking
repeat.
repeat:-repeat.
În cazul în care valorile unor variabile trebuie transmise de la o

iteraţie la alta, repetiţia se va efectua folosind recursia cu parametri.
La fiecare apel recursiv, sistemul Turbo Prolog salvează în stivă starea
curentă, pentru a se putea relua calculul după executarea apelului
recursiv. Turbo Prolog permite o optimizare în această direcţie: dacă
recursia este finală (tail-recursion), atunci starea curentă nu va mai fi
salvată în stivă. Cele două condiţii care trebuie îndeplinite de un
predicat pentru a fi final-recursiv sunt:
 apelul recursiv apare pe ultima poziţie în corpul regulii;
 nu există puncte de backtracking în regulă, adică predicatul

recursiv şi cele care apar în definiţia lui sunt deterministe. Un
predicat este determinist atunci când clauzele care îl definesc
sunt disjunctive (exclusive). Altfel spus, nu există nici o
instanţiere a variabilelor care să satisfacă (simultan) aceste
clauze.
Procedurile recursive pot să păstreze date relative în procesul de

execuţie ale lor, deoarece variabilele-contor, totalurile şi variabilele
intermediare pot să fie pasate de la o iteraţie la următoarea ca
argumente
Limbajul Prolog
Exemplul 1:
Calcularea factorialului unui număr N:
Dacă N este 1, factorialul este 1.
Altfel, găseşte factorialul lui N-1, apoi înmulţeşte-l cu N.
PREDICATES
factorial (INTEGER, INTEGER)
CLAUSES
factorial ( 1 , 1 ) :- !.
factorial ( X , FX ) :-
Y = X-1,
factorial ( Y , FY ),
FX = FY * X.
GOAL
write(“introduceti N:”),
readln(N),
factorial (N, F),
write(“factorialul numarului ”,N, “este”, F).
Exemple de reguli recursive
Exemplul 2:
Limbajul Prolog
Organizarea unui meniu:
PREDICATES
functie (INTEGER)
menu
CLAUSES
menu:-
write(“1. Functia 1”),nl,
write(“5. Iesire”),nl,
write(“------------------------”),
write(“Introduceti functia dorită:”),
readint(X),
functie(X).
!,
menu.
Menu: - menu.
Functie(1):-
% aici sunt predicate pentru functia 1.

Limbajul Prolog
Functie(4):-
% aici sunt predicate pentru functia 4.
Functie(5):-
exit.
GOAL
makewindow(1,23,23,”program”,0,0,25,80),
menu.
Exemplul 3:
Căutare în adâncime (X este strămoş pentru Y)
PREDICATES
parinte (SYMBOL,SYMBOL)
Goal:
stramos (SYMBOL,SYMBOL)
stramos(pam,jim)
CLAUSES Yes
parinte ( “pam” , “bob” ). Goal:

parinte ( “tom” , “bob” ). stramos(bob,jim)
parinte ( “tom” , “liz” ). Yes
parinte ( “bob” , “pat” ).
Goal: stramos(X,jim)
parinte ( “bob” , “ann” ). X=pat
parinte ( “pat” , “jim” ). X=pam
X=tom
X=bob
Stramos(X,Y):- 4 solutions
Limbajul Prolog
parinte(X,Y).
stramos(X,Y):-
parinte(X,Z),
stramos(Z,Y).
Exemplul 4:
Ciclu infinit
Hello world!
Hello world!
PREDICATES
Hello world!
repetare
Hello world!
GOAL
Hello world!
repetare
Hello world!
CLAUSES
Hello world!
repetare:-
Hello world!
write(“Hello world!“),
nl, Hello world!
repetare.
Limbajul Prolog
Exemplul 5:
Ciclu finit
PREDICATES
repetare(integer)
GOAL Hello world!
repetare(3). Hello world!
Hello world!
CLAUSES
repetare(0).
repetare(X):-
write(“Hello world!“),nl,
X2=X-1,
repetare(X2).
Exemplul 6:
Ciclu finit 3. Hello world!
2. Hello world!
PREDICATES 1. Hello world!
repetare(integer)
GOAL
Limbajul Prolog
repetare(3).
CLAUSES
repetare(0).
repetare(X):-
write(X,“Hello world!“), nl,
X2=X-1,
repetare(X2).
Exemplul 7:
Ciclu finit
1. Hello world!
2. Hello world!
PREDICATES
3. Hello world!
repetare(integer)
GOAL
repetare(3).
CLAUSES
repetare(0).
repetare(X):-
X2=X-1,
repetare(X2),
write(X,“Hello world!“),nl.
Exerciţii
Limbajul Prolog
1. Să se scrie predicatele Prolog care ar îndeplini următoarele

funcţii recursive:
x dacă n = 1.
f(x,n) = (2n+x)*f(x,n-1) dacă
x dacă y = 0
-x dacă y = 1
f(x,y) =
2. Să se scrie 3 reguli Prolog care ar afişa următoarele

combinaţii
(de la 1 la N):
1. PROLOG 11. PROLOG 10. 1. PRO-5-LOG 10.

Limbajul Prolog
3. Să se scrie o regulă Prolog care ar calcula suma cifrelor de la 1 la N.
4. Să se scrie un program (joc) „Snake”. (Modificarea lungimii snak-

ului este opţională).
█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▀▀▀▀▀▀▀▀▀█
█┌──────────────────────────────────────────────┐█
█│ │█
█│ │█
█│ nnnnnnnnnnnnnnnnnN │█
█│ n │█
█│ n │█
█│ n │█
█│ nn │█
█│ │█
█│ │█
█│ │█
█└──────────────────────────────────────────────┘█
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▀▀▀▀▀▀▀▀▀▀
Limbajul Prolog
Obiecte compuse
Obiectele compuse permit să se trateze mai multe informaţii ca un

singur element astfel, încât să se poată utiliza şi pe bucăţi. De
exemplu, data de 4 ianuarie 2004 constă din trei informaţii: ziua, luna
şi anul, dar e util să fie tratată ca un singur obiect. Acest lucru se
poate face declarând obiectul compus astfel:
DOMAINS
DATA = data( Integer, String, Integer)
PREDICATES
person(STRING name, DATA, .....)
sau
DOMAINS
CAPACITATEA = INTEGER
TIP_CONBUSTIBIL = benzin ; diesel
MOTORUL = motor(CAPACITATEA,TIP_CONBUSTIBIL)
AUTO = auto(Marca, Anul, MOTORUL)
DATA_NASTERE = data( Integer, String, Integer)
NUME = nume(NUME,PRENUME)
PREDICATES
sofer(NUME,DATA_NASTERE,AUTO)
Funcţii
Limbajul Prolog
Declararea unei funcţii în Prolog:
PREDICATES
INTEGER /*Return*/ cube(INTEGER In)
CLAUSES
cube(In,Return):- Return = In*In*In.
Variabila care se întoarce trebuie să fie ultimul argument.
Procesarea şirurilor
Predicate predefinite pentru prelucrarea şirurilor:
STRING = FIRSTCHAR + REST_STRING

Obţine primul caracter şi restul dintr-un şir
frontchar(String,FrontChar,RestString)
(string,char,string)
(i,o,o) (i,i,o)(i,o,i) (i,i,i) (o,i,i)
GOAL
X = „Prolog”,
frontchar(X,C,REST),
Limbajul Prolog
C = ‘P’
REST = „Prolog”
STRING = TOKEN + REST_STRING
Unde TOKEN – este un cuvânt
fronttoken(String,Token,RestString)
(string,string,string)
(i,o,o) (i,i,o)(i,o,i) (i,i,i) (o,i,i)
GOAL
X = „Prolog este un limbaj al viitorului”,
fronttoken(X,TOKEN,REST),
...
TOKEN = ‘Prolog’
REST = „ este un limbaj al viitorului”
Împarte şirul în două subşiruri unde

primul este de lungimea LENGHT
Limbajul Prolog
frontstr(Lenght,Inpstring,StartString,RestString)
(integer,string,string,string)
(i,i,o,o)
GOAL
X = „Prolog este un limbaj al viitorului”,
frontstr(5,X, A,B),
A = ‘Prolo’
B = „g este un limbaj al viitorului”.
String3 = String1 + String2

Uneşte doua şiruri
concat(String1,String2,String3)
(string,string,string)
Limbajul Prolog
(i,i,o) (i,o,i)(o,i,i) (i,i,i)
GOAL
X = „Prolog este”,
Y= „ un limbaj al viitorului”,
concat(X,Y,Z),
Z = „ Prolog este un limbaj al viitorului”
Calculează lungimea unui şir
str_len(String,Length)
(string,integer)
(i,i) (i,o) (o,i)
GOAL
X = „Prolog”,
str_len(X,LEN),
...
LEN = 6.
Conversii de tip de date

Limbajul Prolog
Predicate predefinite pentru transformare dintr-un tip de date în

altul:
char_int(CharParam,IntgParam) (char,integer) – (i,o) (o,i) (i,i)
str_int(StringParam,IntgParam) (string,integer) – (i,o) (o,i) (i,i)
str_char(StringParam,CharParam) (string,char) – (i,o) (o,i) (i,i)
str_real(StringParam,RealParam) (string,real) – (i,o) (o,i) (i,i)
upper_lower(StringInUpperCase,StringInLowerCase) (string,string) -
(i,i) (i,o) (o,i)
upper_lower(CharInUpperCase,CharInLowerCase) (char,char) – (i,i)

(i,o) (o,i)
Aritmetica în Prolog
Operatori aritmetici: +, -, *, /, mod, div
Operatori de relaţii: >, <, =, >=, <=, <>, ><
Funcţii: sin, cos, tan, arctan, ln, log, exp, sqrt, round, trunc, abs
Exerciţii
1. Să se scrie un program în limbajul Prolog numit calculator

care efectuează următoarele funcţii:
 +
 -
 /
Limbajul Prolog
 *
 ^2
 
 sin
 cos
 convertor valută
2. Să se scrie în Prolog un traducător al textului din Română în

engleză, care ar traduce propoziţiile sau textele introduse.
De exemplu:
Numele meu este Sergiu.
My name is Sergiu.
Mâine eu voi pleca la Bucureşti.
Tomorrow I will go to Bucureşti.
3. Să se scrie un program care ar putea fi folosit pentru a cifra

fişierele de text şi pentru a le descifra.
Liste
Lista este o structură care conţine un număr finit de elemente

consecutive. Elementele unei liste trebuie să aparţină aceluiaşi
domeniu (toate de tipul integer sau toate de tipul string sau toate de
orice domeniu simplu sau compus).
Limbajul Prolog
Listele sunt asemănătoare cu array-urile din alte limbaje. Spre

deosebire de ele, dimensiunea listei nu trebuie să fie specificată. O
listă care conţine elementele 1, 2, 3, 4 este prezentată în felul după
cum urmează:
[1,2,3,4]
Fiecare component al listei se numeşte element. Fiecare element al

listei se separă prin virgulă şi toate elementele se includ în paranteze
pătrate.
Exemplu:
[1,2,3,4,5,6,7]
[a,b,c,d,e,f]
[“CD-ROM”,”Hard Drive”,”Mouse”,”Keyboard”]
O listă poate conţine un număr arbitrar de elemente. Numărul

elementelor în listă se numeşte Lungimea listei. Lista care conţine 0
elemente este Listă vidă.
O listă constă din două părţi: Capul – primul element din listă şi
Coada – restul elementelor ce formează tot o listă:
Capul listei este un element.
Coada listei este tot o listă !!!
O listă poate fi separată în cap şi coadă cu ajutorul simbolului ‘ | ’

Limbajul Prolog
Coada listei
[H|T]
Coada listei
[ 1 | [2, 3, 4, 5, 6] ] Capul listei
Coada listei
Lista vidă nu poate fi separată în cap şi coadă. Fiecare listă poate fi

Capul listei
separată în N capuri şi o coadă.
[ H1, H2, H3 | T ]
Coada listei
[ 1, 2, 3| [ 4, 5, 6] ]
Capul listei
Capul 1
Capul 3
Capul 2
Limbajul Prolog
Tab. 5. Divierea listelor în cap şi coadă
Lista Capul Coada

[a,b,c] a [b,c]
[a,b] a [b]
[a] a []
[] - -
[cat, dog, horse] cat [dog, horse]
[ [1,2,3], [2,1,3], [1, 2, 3] [ [2,1,3], [3,2,1] ]

[3,2,1] ]
Tab. 6. Liste cu variabile şi semnificaţiile lor
Lista Semnificaţie
[X|L] Toate listele nevide

[X,Y,Z|[]] Toate listele cu trei elemente
[X,Y,Z, Coada] Toate listele cu patru elemente

[X,X,Coada] Toate listele cu trei elemente în care
primul şi al doilea element reprezintă
acelaşi termen
Tab. 7. Exemple de unificare a listelor
Lista 1 Lista 2 Instanţieri

Limbajul Prolog
[X,Y,Z] [a,b,c] X=a Y=b Z=c

[X|Y] [a] X=a Y=[]
[X|Y] [a,b,c] X=a Y=[b,c]

[X,Y] [a,b,c] No
[X,Y|Z] [a,b,c] X=a Y=b Z=[c]

[X|[Y|Z]] [a,b,c] X=a Y=b Z=[c]
[X|Y] [[1,2],a,b] X=[1,2] Y=[a,b]

[[a,Y]|Z] [[X,b],[c,d]] X=a Y=b Z=[[c,d]]
[X|Y] [] No
[X|Y] [X|[Y]] No
[X|Y] [[1,2]|X] X=Y, X=[1,2]

Declararea listelor
Listele se declară în secţiunea DOMAINS a programului Turbo Prolog.

Spre exemplu, dacă dorim să declarăm o listă de tip integer vom scrie
următoarele:
DOMAINS
INTEGERLIST = integer*
Asteriscul înseamnă „lista de”; în cazul nostru „lista de intregi”.
Elementele unei liste pot fi orice tip de date inclusiv şi alte liste. Însă
toate elementele din listă trebuie să aparţină unuia şi aceluiaşi tip:
DOMAINS
STRINGLIST = string*
Limbajul Prolog
MULTY_LEVEL_LIST = STRINGLIST*
Exemplu de declarare eronată:
elementlist = elements*
elements = string; integer; symbol /*incorect*/
Utilizarea listelor în exemple
Exemplul 1:
Afişarea elementelor unei liste:
DOMAINS
SLIST= STRING*
PREDICATES
show_list(SLIST)
CLAUSES
show_list( [] ).
show_list( [H|T] ):-
write(H),
nl,
show_list(T).
GOAL
Limbajul Prolog
show_list([“bmw”, ”volvo”,”ford”,”citroen”,”renault”,
”ford”,”fiat”,”opel”,”mazda”]).
Exemplul 2:
Calcularea lungimii unei liste:
DOMAINS
CHAR_LIST = char*
PREDICATES
list_len( CHAR_LIST, integer)
CLAUSES
list_len([],0).
list_len([H|T],N2):-
list_len(T,N),
N2=N+1.
GOAL
list_len([‘p’, ‘r’, ‘o’, ‘l’, ‘o’, ‘g’],N), write(N).
Exemplul 3
Concatenarea a două liste:
DOMAINS
ILIST = integer*
PREDICATES
append( ILIST,ILIST,ILIST)
Limbajul Prolog
CLAUSES
append([],Ys,Ys).
append([X|Xs],Ys,[X|Zs]):-
append(Xs,Ys,Zs).
GOAL
append( [1,2,3], [4,5], N ), write(N).
Exemplul 4:
Este membrul listei:
DOMAINS
ILIST = integer*
PREDICATES
member( INTEGER,ILIST)
CLAUSES
member(X, [X|_] ).
member(X, [_|Xs] ):-
member(X,Xs).
GOAL
member( 2, [1,2,3]),
write(“Da cifra 2 aparţine listei date”).
Exemplul 5
Eliminarea unui element din listă:

Limbajul Prolog
DOMAINS
ILIST = integer*
PREDICATES
eliminare(INTEGER,ILIST,ILIST)
CLAUSES
eliminare(X, [X|Xs], Xs).
eliminare(X,[Cap|Xs],[Cap|Ys]):-
eliminare(X,Xs,Ys).
GOAL
eliminare( 2, [1,2,3], X), write(X).
Arbori
Arborele este un caz particular al grafului şi are următoarele

caracteristici:
 orice nod are cel mult un ascendent;
 există un singur nod, numit rădăcină, care nu are nici un

ascendent;
 nodurile care nu au descendenţi se numesc noduri terminale

sau frunze.
Limbajul Prolog
b c d
e f g
Fig. 10. Arbore.
În fig.10, a – rădăcina arborului, b, e, f, g – noduri terminale.
Pentru prezentarea arborelui este foarte eficientă forma relaţională.

Acest arbore poate fi prezentat prin următoarele fapte:
arc(a,b).
arc(a,c).
arc(a,d).
arc(c,e).
arc(c,f).
arc(d,g).
Arborele binar este un arbore în care fiecare nod are cel mult doi
succesori. De obicei, succesorii se numesc nodul stânga şi nodul
dreapta. Arborii binari sunt folosiţi mai ales ca arbori binari de
căutare.
Limbajul Prolog
b c
d e f
Fig. 11. Arbore binar
Utilizarea arborilor. Să se scrie un program care descrie harta

drumurilor rutiere al Moldovei (fig. 12) şi să se determine diferite
rute posibile şi lungimea lor.
Edinet 80
Soroca
75 65
Balti
95
Orhei
150
53
Chisinau
94
Ungheni 76
Tiraspol
95
106
130
Leova
48 Comrat
72
79
Cahul
Limbajul Prolog
Fig. 12. Reţiaua: „Drumurile RM”
Faptele care reprezintă conţinutul hărţii:
cale (chisinau, orhei, 53).
cale (chisinau, ungheni, 94).
cale (chisinau, balti, 150).
cale (chisinau, tiraspol, 76).

Limbajul Prolog
cale (chisinau, leova, 93).
cale (chisinau, comrat,106).
cale (leova, comrat, 48).
cale (leova, cahul, 72).
cale (cahul, comrat, 79).
cale (tiraspol, comrat, 130).
cale (orhei, balti, 53).
cale (balti, edinet, 75).
cale (balti, soroca, 65).
cale (edinet, soroca, 80).
Deoarece drumurile sunt bidirecţionale, utilizăm o regula care

determină că dacă exista o cale din oraşul A în oraşul B atunci există
şi o cale din oraşul B în oraşul A. Această regulă se va numi cale2:
cale2(A,B,L):-
cale(A,B,L);
cale(B,A,L).
Să notăm un predicat care ar determina dacă există un traseu din

oraşul A în oraşul B.
Traseul din A în B există dacă există calea din A în B:
traseu( A, B):-
cale( A, B).
Limbajul Prolog
Traseul din A în B există dacă există cale din A într-un alt oraş, spre
exemplu C, şi din oraşul C există traseu în oraşul B:
traseu( A, B):-
cale( A, C),
traseu( C, B).
Acest predicat nu poate evita buclele. Pentru evitarea buclelor

posibile trebuie să reţinem toate oraşele care deja sunt intrate în
traseu, si să nu permitem căutarea traseului printr-un oraş mai mult
de o dată. Aceasta se poate efectua prin două metode:
 baza de date interne;
 liste.
Bazele de date interne vor fi obiectul de studiu al următoarei teme.

Deci, vom modifica predicatul traseu cu ajutorul listelor. Vom adăuga
un argument - Ruta. Aceasta va fi o listă ce conţine oraşele prin care
trece traseul căutat. Acest argument va îndeplini funcţia de
acumulator, care iniţial trebuie să conţină o listă cu valoarea oraşului
iniţial. Pentru obţinerea rezultatului, vom mai adăuga un argument
care este folosit doar la sfârşitul executării predicatului şi va întoarce
valoarea rutei:
traseu( A, B, Ruta,X):-
cale2( A, B),
append(Ruta,[B],X).
traseu( A, B, Ruta,X):-
cale2( A, C, L),
not (member(C, Ruta)),

Limbajul Prolog
append(Ruta, [C], Ruta2), !,
traseu( C, B, Ruta2,X).
Să mai adăugăm un argument care ar calcula lungimea traseului:
traseu( A, B, Ruta,X, Lungimea):-
cale2( A, B,Lungimea),
append(Ruta,[B],X).
traseu( A, B, Ruta,X, Lungimea2):-
cale2( A, C, L),
append(Ruta, [C], Ruta2), !,
traseu( C, B, Ruta2,X, Lungimea),
Lungimea2 = Lungimea+L.
Program deplin care va asigura funcţionarea unui sistem de

informare a calatorului este prezentat mai jos:
DOMAINS
symbolList = symbol*
PREDICATES
cale( symbol, symbol, integer)
cale2( symbol, symbol, integer)
traseu( symbol, symbol, symbolList,symbolList, Integer)
append( symbolList, symbolList, symbolList)

Limbajul Prolog
member( symbol, symbolList)
CLAUSES
cale (chisinau, orhei, 53).
cale (chisinau, ungheni, 94).
cale (chisinau, balti, 150).
cale (chisinau, tiraspol, 76).
cale (chisinau, leova, 93).
cale (chisinau, comrat, 106).
cale (leova, comrat, 48).
cale (leova, cahul, 72).
cale (cahul, comrat, 79).
cale (tiraspol, comrat, 130).
cale (orhei, balti, 53).
cale (balti, edinet, 75).
cale (balti, soroca, 65).
cale (soroca, edinet, 80).
cale2(A,B,L):-cale(A,B,L);cale(B,A,L).
traseu( A, B, Ruta,X, Lungimea):-
cale2( A, B,Lungimea),
append(Ruta,[B],X).
traseu( A, B, Ruta,X, Lungimea2):-

Limbajul Prolog
cale2( A, C, L),
append(Ruta, [C], Ruta2),
!,
traseu( C, B, Ruta2,X, Lungimea),
Lungimea2 = Lungimea+L.
append( [], Ys, Ys).
append( [X|Xs], Ys,[X|Zs]):-
append(Xs,Ys,Zs).
member( X, [X|_]).
member(X,[_|Xs]):-member(X,Xs).
GOAL
write(“Introduceti orasul A: ”),
readln(A),
write(“Introduceti orasul B: ”),
readln( B),
traseu( A, B, [A], Ruta, Lungimea), !,
write( “Lungimea traseului este:”, Lungimea),nl,
write( “Traseu:”, Ruta),nl.

Limbajul Prolog
Rezultatul lansării programului este următorul:
Introduceti orasul A: edinet
Introduceti orasul B: chisinau
Lungimea traseului este: 225
Traseu:["edinet","balti","chisinau"]
Menţionăm că programul dat nu calculează lungimea traseului

optimal, ci doar lungimea primului traseu posibil.
Exerciţii:
1. Să se calculeze suma elementelor unei liste date de intregi.
2. Să se scrie un program care să inverseze lista de integeri

dată.
3. Să se scrie un predicat care să decidă dacă o listă conţine un

număr par de elemente.
4. Să se scrie un program care să sorteze o listă de integeri.
5. Să se scrie un program care să determine dacă o listă este

inclusă în altă listă (lista [1, 2, 3, 4, 5, 6] conţine
consecutivitatea de elemente [3, 4])
6. Să se modifice programul de mai sus pentru ca să afişeze

doar lungimea minimă a traseului.
7. Să se scrie un program (joc) „Snake”. Lungimea „Snake”

trebuie să fie modificată de fiecare data când „Snake” trece
prin poziţiile introduse în prealabil.
Limbajul Prolog
█▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▀▀▀▀▀▀▀▀▀▀█
█┌───────────────────────────────────────────────┐█
█│ │█
█│ │█
█│ │█
█│ nnnnnnnnnnnnnnnnnN │█
█│ n │█
█│ n │█
█│ n │█
█│ nn │█
█│ │█
█│ │█
█│ │█
█│ │█
█│ │█
█└───────────────────────────────────────────────┘█
▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀
▀▀▀▀▀▀▀▀▀▀▀
Baze de date interne (dinamice)

Limbajul Prolog
În limbajul Prolog există unele predicate predefinite care acţionează

asupra programului, adăugând, eliminând şi verificând prezenţa
clauzelor. Aceasta denotă că programele în Prolog nu sunt un obiect
static. Adică, o mulţime de fapte şi reguli pot fi „consultate de sistem”
şi această mulţime poate fi schimbată în procesul executării
programului.
Această calitate a Prologului poate fi folosită pentru organizarea

bazelor de date stocate în memorie sau în fişiere, pentru
memorizarea diferiţilor parametri interni, pentru modificarea
dinamică a programului pe parcursul executării lui.
Există trei moduri de introducere a faptelor în program (se poate

modifica dinamic programul):
 ca parte din secţiunea clauses;
 în timpul executarii programului cu ajutorul predicatelor standard

assert, asserta, assertz, retract şi retractall;
 prin încărcarea în baza de date a unui fişier cu fapte, folosind

predicatul standard consult.
Lista predicatelor standard necesare pentru manipulare dinamica a

datelor este prezentată mai jos.
Adăugarea faptelor la momentul executarii:
asserta
Sintaxa:
asserta (<fapt>)
Caracteristici:
Limbajul Prolog
Adaugă faptul indicat în baza de date înaintea faptelor

corespunzătoare predicatului respectiv.
assertz
Sintaxa:
assertz (<fapt>)
Caracteristici:
Adaugă faptul indicat în baza de date după faptele corespunzătoare

predicatului respectiv.
assert
Sintaxa:
assert (<fapt>)
Caracteristici:
Acelaşi efect ca assertz
Eliminarea faptelor la momentul executarii
retract
Sintaxa:
retract (<fapt>)
Caracteristici:
Limbajul Prolog
Elimină din baza de date primul fapt care se potriveşte cu faptul

indicat.
retractall
Sintaxa:
retractall (<fapt>)
Caracteristici:
Elimină din baza de date toate faptele care se potrivesc cu faptul

indicat.
Citirea unor fapte noi din fişier
consult
Sintaxa:
consult (<nume_fisier>)
Caracteristici:
Va citi din fişierul nume_fisier toate faptele relative la predicatele

declarate in DATABASE.
Salvarea datelor
save
Sintaxa:
save (<nume_fisier>)
Limbajul Prolog
Caracteristici:
Va salva faptele relative la predicatele declarate în DATABASE intr-un

fişier cu numele (<nume_fisier>. Formatul fişierului este textual. El
poate fi citit şi modificat ca un fişier textual simplu. Faptele sunt
prezentate în formatul faptelor limbajului Prolog.
Exemplu
Să se scrie un program în limbajul Prolog care îndeplineşte funcţia

unui dicţionar roman-englez. Să se permită utilizatorului adăugarea
cuvintelor noi în bază. Să se salveze baza de date la sfârşitul
executării programului.
Declararea bazei de date a viitorului dicţionar va fi următoarea:
DATABASE
dict(String,String)
Programul va avea şi interfaţă – un meniu simplu pentru funcţiile

posibile:
menu:-
write(„1. Dictionar”),nl,
write(„2. Adauga cuvint”),nl,
write(„3. Iesire”),nl,
write(„===================”),nl,
readint(X),
func(X),
menu.
Limbajul Prolog
menu:-menu.
Următorul predicat va îndeplini funcţia principală – traducerea:
func(1):-
write(„Introduceti cuvintul in Limba Engleza:”),
readln(Eng),
dict(Eng,Rom),
write(„Traducerea cuvintului este: ”,Rom).
Predicatul pentru adăugarea cuvintelor în baza de date:
func(2):-
write(„Introduceti cuvintul in Limba Engleza:”),
readln(Eng),
write(„Introduceti traducerea in Limba Romana:”),
readln(Rom),
assert(dict(Eng,Rom)).
Salvarea bazei de date se va face la ieşire:
func(3):-
save(“baza.dba”).
Codul programului complet va arata astfel:
DATABASE
dict(String,String)
Limbajul Prolog
PREDICATES
menu
func(integer)
CLAUSES
menu:-
write("1. Dictionar"),nl,
write("2. Adauga cuvint"),nl,
write("3. Iesire"),nl,
write("==================="),nl,
readint(X),
func(X),
menu.
menu:-menu.
func(1):-
write("Introduceti cuvintul in Limba Engleza:"),
readln(Eng),
dict(Eng,Rom),
write("Traducerea cuvintului este: ",Rom).
func(2):-
write("Introduceti cuvintul in Limba Engleza:"),

Limbajul Prolog
readln(Eng),
write("Introduceti traducerea in Limba Romana:"),
readln(Rom),
assert(dict(Eng,Rom)).
func(3):-
save("baza.dba"),
exit.
GOAL
consult("baza.dba"),
menu.
Menţionăm că la prima lansare a programului, fişierul textual vid

„baza.dba” trebuie să existe în directoriul unde este salvat
programul.
Exerciţii:
1. Să se scrie un program care să îndeplinească funcţia unui

dicţionar roman-engles şi englez-roman. Programul trebuie
sa permită utilizatorului modificarea cuvintelor din bază,
adăugarea cuvintelor noi şi retragerea cuvintelor din bază.
Baza de date trebuie să se salveze automat la ieşirea din
program şi să se citească din fişier la start.
2. Să se îndeplineacă funcţia de memorizare a traseului din

lucrarea de laborator precedentă cu ajutorul bazelor
dinamice în locul listelor.
Limbajul Prolog
Operaţii afişare/citire
Afişarea datelor
write
Este un predicat cu care se poate scrie pe ecran orice tip de obiecte.
Formatul:
write (Arg1, Arg2, ... , ArgN)
Prototipul: (i,i,...,i)
Arg – constante sau variabile
Exemplu:
X= "Ion”,
write (“Bine aţi venit domnule(nă) ”,X).
Scrie pe ecran: Bine aţi venit domnule(nă) Ion
writef
Este analog predicatului write şi are un argument de format după

care se scrie.
Formatul:
write (Format,Arg1, Arg2, ... , ArgN)

Limbajul Prolog
Prototipul: (i,i,...,i)
Arg – constante sau variabile
Format – precizează formatul pentru fiecare argument.
Pentru fiecare argument se introduce:
% simbolul iniţial,
- determină alinierea la stângă,
m lăţimea minimală a câmpului,
p exactitatea.
Poate conţine:
f real (zecimal fixat),
e real (notaţie exponenţială),
g real scurt.
Exemplu:
X1=”Pelin Sergiu Nicolae”,

Y1=”RM”,
Z1=234.03948234,
X2=”Orlovski Ian Stanislav”,
Y2=”RM”,
Z2=321.213234455,
writef (“Numele: %8.8 \t % \t %5.5”,X1,Y1,Z1),nl,

writef (“Numele: %8.8 \t % \t %5.5”,X2,Y2,Z2).
Scrie pe ecran:
Limbajul Prolog
Numele: Pelin Se RM 234.03948

Numele: Orlovski RM 321.21323
Citirea datelor
readln
Cu readln se citeşte o linie de text, terminată cu newline.
Formatul:
readln (Arg)
Prototipul: (o)
Arg – variabila tip STRING sau SYMBOL
Exemplu:
readln(X)
atribuie lui X valoarea introdusă de la tastatură.
Pentru citirea datelor de tip INTEGER, CHAR, REAL sunt prevazuţi

respectiv predicaţii:
readint(integer)
readchar(char)
readreal(real)
readterm
Limbajul Prolog
Citeşte o linie şi o converteşte la un obiect al domeniului dat.
Formatul:
readterm (Nume domeniu, Domeniu)
Prototipul: (i,i)
Fişiere
Pentru a folosi fişierele într-un program Turbo Prolog, este necesar

se fie declarate în secţiunea domains, unde se specifică numele lor
simbolice:
file = datafile; f2
Predicate pentru accesul la fişiere
file_str (FileName, File_data_String)
1. Citeşte caracterele din fişier cu numele FileName şi le

transformă în variabila File_data_String (i,o).
2. Creează un fişier cu numele FileName care va conţine

valoarea variabilei File_data_String (i,i).
Exemplu: file_str(“data.txt”,”Hello this is file content....”).

Limbajul Prolog
openread(datafile, FileName)
Deschide fişierul pentru citire, asociind variabilei de tipul file

(datafile) fişierul DOS cu numele FileName.
openwrite(datafile,FileName)
Deschide fişierul pentru scriere asociind variabilei de tip file

(datafile) fişierul DOS cu numele FileName.
openmodify(datafile,FileName)
Deschide fişierul pentru modificare asociind variabilei de tip

file (datafile) fişierul dos cu numele FileName.
readdevice(datafile)
Modifică dispozitivul de citire curent.
writedevice(datafile)
Modifică dispozitivul de scriere curent.
closefile(datafile)
Închide fişierul cu numele datafile.
eof(datafile)
Limbajul Prolog
întoarce true dacă poziţia curentă este la sfârşitul fişierului cu

nume datafile.
Exemplu:
Citirea datelor din fişier, afişarea lor pe ecran şi imprimantă:
DOMAINS
file = datafile
PREDICATES
read_and_print
read_and_display_a_file
GOAL
read_and_display_a_file.
CLAUSES
read_and_display_a_file:-
write(“Please enter complete filename.”),nl,
readln(FileName),nl,
openread(datafile,FileName),
readdevice(datafile),
read_and_print,
closefile(datafile),nl,
Limbajul Prolog
write(“Press the space bar.”),
readchar(_),
exit.
read_and_print:-
not(eof(datafile)),
readln(String),
concat(String,”\13\10”,String2),
write(String2),
writedevice(printer),
write(String2),
flush(printer),
writedevice(screen),
read_and_print.
read_and_print:-
eof(datafile),!.
Exerciţii:
1. Folosind predicatele prezentate, să se scrie o bază de date

internă (cu toate predicatele aferente limbajului Turbo Prolog)
2. Să se scrie câteva predicate care să implementeze principalele

operaţii ce apar în fişiere (căutare, adăugare, ştergere).
Limbajul Prolog
3. Creaţi un fişier „carte.txt” ce conţine cărţile bibliotecii de

informatică cu structura: cota_carte, autor, titlu, editura şi un
fişier „imprumut.txt” cu persoanele ce împrumută cărţi, cu
structura: nume, adresa, carţi_imprumutate în care nume este un
obiect compus, iar cărţi împrumutate este de tip listă care
conţine cotele cărţilor împrumutate.
Scrieţi programe care să efectueze:
 crearea celor două fişiere;
 adăugarea şi ştergerea cărţilor din fişier „carte.txt” în care

ştergerea se răsfrângere asupra unei cărţi (prin cota ei), sau
asupra cărţilor unui autor;
 adăugarea şi ştergerea persoanelor, ce împrumută cărţi, din

fişierul „imprumut.txt”;
 lista cărţilor din bibliotecă, în ordinea crescătoare a cotelor;
 lista în ordine alfabetică a autorilor şi a cărţilor lor;
 o listă care să conţină obiecte cu date:nume, cota_carte, autor,

titlu.
3.3. Sisteme expert
Sisteme expert sunt sisteme inteligente bazate pe reprezentarea

simbolică a cunoaşterii.
Într-un sistem expert cunoaşterea obţinută de la un expert uman este

analizată, memorată şi folosită la rezolvarea unor probleme specifice.
Limbajul Prolog
Sistemul expert este un program, în care sunt folosite cunoştinţele

unui sau mai multor experţi, pentru a asigura o decizie eficientă a
problemelor într-un domeniu restrâns. Astfel de programe, de obicei,
reprezintă cunoştinţele în mod simbolic, cercetează şi explică
procesele de raţionament şi sunt destinate pentru domenii în care
oamenii, pentru a obţine un nivel înalt de măiestrie, au nevoie de
mulţi ani de studii şi practică.
Experţi Baza de date
Modulul de
Învăţarea sistemului
extragere a
cunoştinţlor
Baza de cunoştinţe
Nucleul sau inima SE

Maşina/Motor de
inferenţe
Interfaţa legată de
explicaţii
Utilizator
Limbajul Prolog
Fig.13. Arhitectura sistemului expert

Limbajul Prolog
Proiectarea unui sistem expert
Un sistem expert este un produs informatic care încearcă să se

comporte ca un expert uman într-un anumit domeniu. Sistemul
expert este alcătuit din 3 părţi:
 baza de cunoştinţe care conţine fapte şi reguli;
 motorul de inferenţă care obţine date noi din cele existente,

folosind o anumită metodă de inferenţă;
 interfaţa cu utilizatorul.
Motorul de inferenţă poate fi „cu înlănţuire”:
înainte: porneşte de la o mulţime de cunoştinţe şi se obţin

altele noi;
înapoi: porneşte de la un scop şi se verifică dacă acesta poate

fi dedus din faptele existente, folosind regulile aflate în baza de
cunoştinţe;
mixtă - combină ideile anterioare.
Prolog poate fi folosit în mod natural pentru proiectarea unui sistem

expert:
 baza de cunoştinţe este reprezentată de faptele şi regulile Prolog;
 motorul de inferenţă (cu înlănţuire înapoi) reprezintă strategia

SLD-DFS de „rezolvare” a scopurilor.
Programul de mai jos ilustrează cum poate fi folosit Prolog pentru a

„crea” un sistem expert.
Limbajul Prolog
/*****************************************************
Sistem expert pentru clasificarea animalelor
Regulile:
1. DACĂ are păr ATUNCI este mamifer.
2. DACĂ dă lapte ATUNCI este mamifer.
3. DACĂ are pene ATUNCI este pasăre.
4. DACĂ zboară ŞI face oua ATUNCI este pasăre.
5. DACĂ mănâncă carne ATUNCI este carnivor.
6. DACĂ are dinţi ascuţiţi ŞI are gheare ŞI are ochii plasaţi in fata
ATUNCI este carnivor.
7. DACĂ este mamifer ŞI are copite ATUNCI este copitat.
8. DACĂ este mamifer ŞI rumegă ATUNCI este copitat.
9. DACĂ este mamifer ŞI este carnivor ŞI are culoare brună ŞI are pete
închise la culoare ATUNCI este ghepard.
10. DACĂ este mamifer ŞI este carnivor ŞI are culoare brună ŞI are
dungi negre ATUNCI este tigru.
11. DACĂ este copitat ŞI are gatul lung ŞI are picioare lungi ŞI are pete
închise la culoare ATUNCI este girafa.
12. DACĂ este copitat ŞI are dungi negre ATUNCI este zebra.
13. DACĂ este pasare ŞI nu zboară ŞI are gatul lung ŞI are picioare
lungi ŞI este alb cu negru ATUNCI este struţ.
14. DACĂ este pasare ŞI nu zboară ŞI înoată ŞI este alb cu negru

ATUNCI este pinguin.
Limbajul Prolog
15. DACĂ este pasare ŞI zboară bine ATUNCI este albatros.
*****************************************************/
DATABASE
stiu(symbol)
nu_stiu(symbol)
PREDICATES
animal(symbol)
este(symbol)
CLAUSES
este(mamifer) :- stiu(are_par).
este(mamifer) :- stiu(da_lapte).
este(pasare) :- stiu(are_pene).
este(pasare) :-
stiu(zboara),
stiu(face_oua).
este(carnivor) :-
stiu(mananca_carne).
este(carnivor) :-
stiu(are_dinti_ascutiti),
stiu(are_gheare),
Limbajul Prolog
stiu(are_ohci_in_fata).
este(copitat) :-
este(mamifer),
stiu(are_copite).
este(copitat) :-
este(mamifer),
stiu(rumaga).
animal(ghepard):-
este(mamifer),
este(carnivor),
stiu(are_culoare_bruna),
stiu(are_pete_inchise).
animal(tigru):-
este(mamifer),
este(carnivor),
stiu(are_culoare_bruna),
stiu(are_raiuri_negre).
animal(girafa):-
este(copitat),
stiu(are_gat_lung),
Limbajul Prolog
stiu(are_piciore_lungi),
stiu(are_pete_inchise).
animal(zebra):-
este(copitat),
stiu(are_raiuri_negre).
animal(strut):-
este(pasare),
nu_stiu(zboara),
stiu(are_gat_lung),
stiu(are_piciore_lungi),
stiu(este_alb_cu_negru).
animal(pinguin):-
este(pasare),
nu_stiu(zboara),
stiu(inoata),
stiu(este_alb_cu_negru).
animal(albatros):-
este(pasare),
stiu(zboara_bine).
GOAL
assert(stiu(„are_culoare_bruna”)),
Limbajul Prolog
assert(stiu(„are_raiuri_negre”)),
assert(stiu(„mananca carne”)),
assert(stiu(„are_par”)).
Exerciţii
1. Să se construiască o interfaţă pentru programul de mai sus.
2. Să se scrie un sistem expert pentru determinarea defectului

automobilului.
3.4. Întrebări şi exerciţii
1. Care este diferenţa între limbajele de programare

imperative şi declarative?
2. Cum se obţin ordonarea, ramificarea şi repetarea în

programele scrisе în limbajul Prolog?
3. Este posibil sau nu , prezentarea expresiei cum ar fi

X=X+1, în textul programei scrisă în Prolog?
4. La ce probleme ne aduce predicatului cut utilizat în

limbajul Prolog?
5. Care sunt principalele avantaje al limbajului Prolog?

Limbajul Prolog
6. Poate fi considerat limbajul Turbo Prolog, limbaj al

programarii logice?
7. Descrieţi structura unui fapt.
8. Descrieţi forma generală unei reguli.
9. Descrieţi forma generală unui scop (întrebări).
10. Ce este o variabila in Prolog? Care sunt regulile

formarii a unei variabile Prolog?
11. Aspectele cantitative şi calitative a unei reguli, fapt,

întrebări.
12. Descrieţi mecanismul de unificare a limbajului Prolog.
13. Predicatul predefinit write. Descrieţi destinaţia,

formatul etc.
14. Să se scrie un program care ar afişă în fereastra de

dialoguri, expresia Salut Moldova!
15. Exportul şi importul variabilei dintr-o regulă în alta.
16. Scopuri externe şi interne. De efectuat o analiză

comparativă prin exemple.
17. Structura programului scris în limbajul Turbo Prolog,
18. Tipuri de date în Turbo Prolog.
19. Legaturile logice în Prolog.
20. Care este tipul de date a termenul X în predicatul

predifinit readln (X)? Care este destinaţia lui?
Limbajul Prolog
21. Descrieţi fiecare din termeni a fiecărui din predicate

predefinite destinate pentru formarea şi lucru cu
ferestrele.
22. Care este destinaţia predicatului predefinit fail? Cum

se numeşte mecanismul iniţiat de acest predicat?
Variate de alternativă prin care se poate de iniţia
acest mecanism fără a folosi predicatul predefinit
fail?
23. Ce se numeste „punct de ramificare”? Cind apare un

punct de ramificare in program?
24. Cum se numeşte regula cu structură după cum

urmează:
ask:- ...,ask.
25. Cum se realizeaza operatiuni repetative in Prolog? Sa

se scrie un exemplu.
26. Ce este un obiect compus?
27. Ce este o lista? Ce elemente poate contine o lista? Ce

operatiuni se pot aplica asupra unei liste?
28. Ce lista nu poate fi impartita in cap si coada?
29. Să se scrie programe care ar permite:
a) Accesarea fiecărui element a listei;
b) Înlocuirea elementului N a listei cu o constantă

predefinită;
c) Exluderea elementului N din listă;

Limbajul Prolog
d) Exluderea unui numar k de elemente a listei începând cu

elementul N a listei;
e) Calcularea numarul elementelor unei liste;
f) Calcularea numarul elementelor unei liste, începând cu

poziţia N;
g) Calcularea sumei elementelor unei liste;
h) Concatenarea listelor în al treilea;
i) Concatenarea listelor în al treilea fără repetarea

elementelor egale;
j) Formarea unei liste din doua cu numere întregi fiecare şi

care ar conţine numai cifre impare din prima listă şi pare
din al doilea listă;
k) Segmentarea unei liste de numere întregi în două, în fel

pentru ca prima lista se conţină de la primul element
până la elementul N, iar al doilea rest, începând cu
elementul N+1;
l) Segmentarea unei liste de numere întregi în două, în fel

pentru ca prima lista se conţină numai elemente pare,
iar al doilea impare;
m) Exluderea din listă elementelor, numărul la rănd cărora

sunt date prin altă listă;
n) Invertarea listei;
o) Întruducerea unui element nou în poziţia N a listei;
p) Întroducerea în listă elementelor altei liste, începând cu

poziţia N.
Limbajul Prolog
30. Ce este un arbore binar? Cum poate fi prezentat un

arbore binar in Prolog?
31. Prezentati un arbore binar prin intermediul unui

obiect compus.
32. Descrieţi ce reprezintă termenul names având numai

urmatorul fragment al programului:
DOMAINS
names=symbol*
33. Dispunem de un predicat write_l([H|T]). Descrieţi ce

reprezintă termenul, ce posibilităţi să oferă prin
transcrierea lui în felul cum este prezentat.
34. Descrieţi procedura declarării unei funcţii în Turbo

Prolog.
35. Predicatul predifinit fronttoken(String, Token,

RestString) ce destinaţie are, ce reprezintă fiecare
din termeni, exemple.
36. Ce predicate predefinite sunt destinate pentru

modificarea dinamică a programului scris în Prolog?
37. Ce este un sistem expert?
38. Care sunt modulele din care este construit un sistem

expert?
39. Şi acum un exerciţiu pentru cei care deja sunt mai

bine pregătiţi. Utilizând posibilităţile limbajului
Prolog de elaborat un program care va găsi
rezolvarea testului a lui Albert Einştein [56].
Limbajul Prolog
Prezumţii:
1.Există 5 case fiecare de altă culoare.

2. În fiecare casă locuieşte o singură persoană fiecare de alta
naţionalitate.
3. Fiecare locatar preferă o anumită bautură, fumează o anumită
marcă de ţigări şi deţine un anumit animal de companie.
4. Nici una din cele 5 persoane nu are casa de aceeaşi culoare cu alta,
nu bea aceeaşi bautură, nu fumează aceeaşi marcă de ţigări şi nu
deţine aceeaşi specie de animal.
Se dau urmatoarele:
a)Britanicul locuieşte în casa roşie.

b) Suedezul are un câine.
c) Danezul bea cu placere ceai.
d) Casa verde se află în stânga casei albe.
e) Locatarul casei verzi bea cafea.
f) Persoana care fumează “Pas Mal” are o pasare.
g) Locatarul casei din mijloc bea lapte.
h) Locatarul casei galbene fumează “Down Hill”.
i) Olandezul locuieşte în prima casă.
j) Fumatorul de “Carlbrough” locuieşte langă cel care are o pisică.
k) Locatarul care are un cal locuieşte lângă cel care fumează “Down
Hill”.
l) Fumatorul de “Wind Fill” bea bere.
m) Olandezul locuieşte lăngă casa albastră.
n) Germanul fumează ”Rustguns”.
o) Fumatorul de “Carlbrough” are un vecin care bea apă.
Să se găseacă: Cine are acvariul cu peşti?

Limbajul Prolog

Cartea Pelin 2011 Capitolul Turbo Prolog

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Cartea Pelin 2011 Capitolul Turbo Prolog

Încărcat de

Drepturi de autor:

Formate disponibile

S. Pelin, N.

Programarea logică: în proiectarea sistemelor informaţionale / S.

Recomandată pentru publicare de către Senatul Universităţii de Stat Tiraspol

Copyright © 2011 Pelin Serghei, Pelin Nicolae

1. Aspecte teoretice a programării logice ......................................

1.1.Unele noţiuni despre programe logice şi interpretorul Prolog ....

Lumea reală în programul logic realizat la calculator ...................... 11

Noţiunea de algoritm în filosofia programării logice ...................... 12

Programare în limbajele imperative de programare..........................

Sarcina ce stă în faţa programatorului având la dispoziţie

un interpretor logic .................................................................... 13

Caracterul nedeterminist al programelor logice ............................ 14

Interpretorul limbajului Prolog ...................................................... 14

Forma normală conjunctivă (FNC) .................................................. 17

Disjuncţii lui Horn ........................................................................... 17

Variabilele şi rolul lor ...................................................................... 21

Despre interpretarea formulelor în logica predicatelor ....................

Forma prenex şi legătura ei cu formulele logicii propoziţionale...... 22

Probleme ce apar în operarea cu formele prenex .............................

Forma clauzală ................................................................................. 24

Universul Herbrand ......................................................................... 25

Forma frazală a logicii predicatelor ................................................. 25

Cuantificarea variabilelor în formă frazală ..................................... 26

Structura programului logic standard ..............................................

1.3 Întrebări şi exerciţii

2. Deducţia logică – mecanism de calcul al limbajului

de programare logică .................................................................

Regula rezoluţiei ............................................................................. 31

Proprietăţile de finalizare a metodei de rezoluţie ...........................

Algoritmul de verificare a executabilităţii mulţimilor de

disjuncţi Horn ................................................................................. 32

Regula rezoluţiei în logica predicatelor ........................................... 33

Principiul programării logice .......................................................... 35

Strategia descendentă de rezolvare a problemelor prin

utilizarea regulii rezoluţiei ........................................................... 35

Eficienţa strategiei de rezolvare ................................................... 36

2.3.Interpretarea programelor logice

Interpretorul abstract al programelor logice ................................. 36

Mecanisme de gestionare, implementate în interpretorul

programelor logice ....................................................................... 37

Executarea programelor de către interpretorul logic .................... 38

Executarea programelor în regim de interpretare ......................... 39

Ipoteza lumii închise .................................................................... 39

Prolog «pur» ................................................................................ 39

2.4. Rolul limbajului Prolog în studierea cursului de informatică

2.5.Aspecte metodologice de studiere a programării logice

3. Limbajul Prolog ....................................................................... 43

De ce trebuie de studiat programarea logică ? .............................. 43

Diferenţa dintre limbajele de programare tradiţionale şi logice ... 44

Mecanismele de ordonare, ramificare şi repetare în Prolog ......... 46

Puterea limbajului Prolog ............................................................. 47

3.3. Aspecte practice ce ţin de programare în limbajul Prolog

Secţiunile unui program Turbo Prolog ................................. ........ 58

Scopuri (Întrebări) ......................................................................... 59

Interfaţa cu utilizatorul în Turbo Prolog ........................................ 63

Lucrul cu ferestrele ......................................................................... 64

Esenţa mecanismului ...................................................................... 68

Repetiţie şi recursie ......................................................................... 72

Exemple de reguli recursive ............................................................ 74

Obiecte compuse .............................................................................78

Procesarea şirurilor ..........................................................................78

Conversii de tip de date .................................................................. 80

Aritmetica în Prolog ...................................................................... 81