Cuprins

Cuprins
PREFA ............................................................................................................................... 9 CUVNT NAINTE............................................................................................................. 11 PARTEA I. PROGRAMAREA BAZAT PE REGULI I SISTEMELE EXPERT CAPITOLUL 1. PARADIGME DE PROGRAMARE ................................................... 17 1.1. PROGRAMAREA IMPERATIV REZOLV DICTND CUM S FACI ......................... 18 1.2. PROGRAMAREA LOGIC REZOLV SPUNND CE VREI S FACI ........................... 19 1.3. PROGRAMAREA FUNCIONAL REZOLV APELND O FUNCIE ......................... 22 1.4. PROGRAMAREA ORIENTAT-OBIECT REZOLV CONSTRUIND OBIECTE CE INTERACIONEAZ .................................................................................................................. 24 1.5. PROGRAMAREA BAZAT PE REGULI REZOLV CA NTR-UN JOC DE PUZZLE SAU LEGO ....................................................................................................................................... 26 CAPITOLUL 2. INTRODUCERE N SISTEMELE EXPERT ..................................... 31 2.1. CE SUNT SISTEMELE EXPERT ? ............................................................................... 32 2.2. PARTICULARITI ALE DOMENIULUI INTELIGENEI ARTIFICIALE ......................... 34 2.3. PRIN CE DIFER UN SISTEM EXPERT DE UN PROGRAM CLASIC? ............................. 35 2.4. EXEMPLE DE SISTEME EXPERT ............................................................................... 37 2.5. EVALUAREA OPORTUNITII SISTEMELOR EXPERT ............................................... 40 PARTEA A II-A. ORGANIZAREA I FUNCIONAREA SISTEMELOR EXPERT CAPITOLUL 3. ORGANIZAREA UNUI SISTEM EXPERT....................................... 45 3.1. BAZA DE CUNOTINE: FAPTELE............................................................................ 46 3.2. REGULILE ............................................................................................................... 48 3.3. VARIABILE I ABLOANE N REGULI ...................................................................... 50 3.4. LEGRI DE VARIABILE I INSTANE DE REGULI ..................................................... 52 3.5. AGENDA ................................................................................................................. 53 3.6. MOTORUL DE INFERENE ....................................................................................... 54 CAPITOLUL 4. NLNUIREA REGULILOR N MOTOARELE DE INFEREN ................................................................................................................................................ 57 4.1. CUTAREA SOLUIEI N PROBLEMELE DE INTELIGEN ARTIFICIAL .................. 57 4.2. NLNUIREA NAINTE ........................................................................................... 59 4.3. DESPRE PREZUMIA DE LUME DESCHIS/NCHIS ................................................. 62 4.4. DESPRE MONOTONIE .............................................................................................. 64 4.5. DESPRE FAPTE NEGATE I REGULI CU ABLOANE NEGATE .................................... 66 CAPITOLUL 5. REGIMUL DE LUCRU TENTATIV................................................... 67
Programarea bazat pe reguli
5.1. SIMULAREA UNUI MOTOR TENTATIV PRINTR-UN SHELL DE MOTOR IREVOCABIL .. 69 CAPITOLUL 6. CONFRUNTAREA RAPID DE ABLOANE: ALGORITMUL RETE ..................................................................................................................................... 81 6.1. IMPORTANA ORDINII ABLOANELOR.................................................................... 92 PARTEA A III-A. ELEMENTE DE PROGRAMARE BAZAT PE REGULI CAPITOLUL 7. PRIMII PAI NTR-UN LIMBAJ BAZAT PE REGULI: CLIPS ... 95 7.1. S FACEM O ADUNARE ........................................................................................... 96 7.2. CUM REALIZM O ITERAIE? ............................................................................... 102 CAPITOLUL 8. CONSTRNGERI N CONFRUNTAREA ABLOANELOR....... 111 8.1. INTEROGRI ASUPRA UNEI BAZE DE DATE ........................................................... 111 8.2. UN EXEMPLU DE SORTARE ................................................................................... 117 CAPITOLUL 9. DESPRE CONTROLUL EXECUIEI .............................................. 123 9.1. CRITERII UTILIZATE N ORDONAREA AGENDEI..................................................... 123 9.2. URMRIREA EXECUIEI ....................................................................................... 125 9.3. STRATEGII DE REZOLUIE A CONFLICTELOR ........................................................ 129 9.4. IMPORTANA ORDINII ASERTRILOR ................................................................... 130 9.5. EFICIENTIZAREA EXECUIEI PRIN SCHIMBAREA ORDINII COMENZILOR RETRACT I ASSERT ................................................................................................................................... 132 CAPITOLUL 10. RECURSIVITATEA N LIMBAJELE BAZATE PE REGULI... 135 10.1. TURNURILE DIN HANOI ...................................................................................... 135 10.2. CALCULUL FACTORIALULUI .............................................................................. 141 PARTEA A IV-A DEZVOLTAREA DE APLICAII CAPITOLUL 11. OPERAII PE LISTE, STIVE I COZI ......................................... 149 11.1. INVERSAREA UNEI LISTE .................................................................................... 149 11.2. MAINI-STIV I MAINI-COAD ....................................................................... 150 11.3. UN PROCES CARE LUCREAZ CU STIVA ............................................................. 153 11.4. UN PROCES CARE LUCREAZ SIMULTAN CU O STIV I O COAD ..................... 155 11.5. EVALUAREA EXPRESIILOR ................................................................................. 158 CAPITOLUL 12. SISTEME EXPERT N CONDIII DE TIMP REAL ................... 165 12.1. SERVIREA CLIENILOR LA O COAD .................................................................. 166 12.2. EVENIMENTE EXTERNE PSEUDO-ALEATORII ...................................................... 170 CAPITOLUL 13. CONFRUNTRI DE ABLOANE N PLAN ................................. 175 13.1. JOCUL 8-PUZZLE ................................................................................................ 178 13.2. JOCUL CU VAPORAE ......................................................................................... 180
Cuprins
CAPITOLUL 14. O PROBLEM DE CUTARE N SPAIUL STRILOR ......... 187 14.1. MAIMUA I BANANA O PRIM TENTATIV DE REZOLVARE .......................... 187 14.2. HILL-CLIMBING ................................................................................................... 190 14.3. O MAIMU EZITANT: METODA TENTATIV EXHAUSTIV .............................. 197 14.4. O MAIMU DECIS: METODA BEST-FIRST ......................................................... 199 CAPITOLUL 15. CALCULUL CIRCUITELOR DE CURENT ALTERNATIV ..... 201 CAPITOLUL 16. REZOLVAREA PROBLEMELOR DE GEOMETRIE ................ 207 16.1. REPREZENTAREA OBIECTELOR GEOMETRICE I A RELAIILOR DINTRE ELE ...... 208 16.2 LIMBAJUL DE DEFINIRE A PROBLEMEI ................................................................ 209 16.3 PROPAGAREA INFERENELOR ............................................................................. 211 16.4. LUNGIMEA RULRII I A DEMONSTRAIEI ......................................................... 218 CAPITOLUL 17. SFATURI DE PROGRAMARE BAZAT PE REGULI ............. 221 17.1. RECOMANDRI DE STIL N PROGRAMARE .......................................................... 221 17.2. ERORI N EXECUIA PROGRAMELOR CLIPS ...................................................... 224 17.3. ATEPTRI NENDEPLINITE ................................................................................ 226 BIBLIOGRAFIE ................................................................................................................ 229
Prefa
Inteligena artificial s-a impus ca una dintre cele mai dinamice ramuri ale tehnologiei informaiei prin realizrile remarcabile att pe plan teoretic ct i prin diversitatea aplicaiilor sale. ntre acestea, sistemele expert ocup un rol important n informatizarea unei mari diversiti de domenii ale activitii social-economice. Realizarea unui sistem expert este, n primul rnd, o activitate de echip care reunete specialiti din domenii diverse alturi de informaticieni. Pentru ca sistemul construit s poat dialoga cu viitorii utilizatori este necesar ca realizatorii s poat comunica ntre ei, s aib un limbaj comun. Cred c unul din principalele merite ale lucrrii de fa este acela de a oferi un model prin care se poate realiza o astfel de comunicare. Construciile teoretice care fundamenteaz paradigmele programrii bazate pe reguli i ale celei obiectuale sunt deduse n mod natural pornind de la exemple simple, sugestive. Autorul realizeaz o remarcabil prezentare a caracteristicilor sistemelor expert fapte, reguli, motoare de inferen , cu o meniune special asupra regimului tentativ de funcionare. n construcia unui sistem expert sunt necesare instrumente specializate. Exist numeroase limbaje pe structura crora se pot realiza sisteme expert. Din pcate, de multe ori prezentarea acestora le transform n cadre rigide n care trebuie s fie cuprinse faptele din realitate adesea cu eliminri ale unor trsturi eseniale. Abordarea insinuant obiectual a limbajului CLIPS permite autorului ca, pornind de la fapte, s regseasc natural acele structuri ale limbajului care concur la surprinderea realitii n esenialitatea ei n raport cu problema ce urmeaz a fi rezolvat. Exemplele din ultima parte a crii sunt de natur s pun n eviden diversitatea aplicaiilor n care instrumentele inteligenei artificiale ofer soluii elegante i eficiente, cu condiia alegerii judicioase a strategiei utilizate, ct i limitele, pentru moment, n abordarea unor probleme simple n aparen dar de mare complexitate n esen , cum ar fi cele ale demonstrrii automate a teoremelor din geometrie. Rod al unei prodigioase activiti de cercetare dublate de druirea exemplar n munca la catedr, lucrarea profesorului Dan Cristea va reui s devin o carte de referin pentru toi cei implicai n construcia i utilizarea sistemelor expert. Clin Ignat
Cuvnt nainte
O carte dedicat programrii bazate pe reguli ar putea strni, n primul rnd, curiozitatea informaticienilor profesioniti ori a studenilor la informatic sau calculatoare. Pentru un informatician, ntlnirea cu un alt mod de a concepe actul programrii dect cel pe care l utilizeaz zilnic poate fi incitant. Dezvoltatorii profesioniti de programe sunt deprini s-i treac n cv-urile lor o list de limbaje pe care le cunosc, de multe ori acestea acoperind mai multe paradigme. Ei nva mai multe limbaje, diferite ca modaliti de abordare a actului programrii, nu neaprat din necesitatea impus de un angajator de a programa n acele limbaje, ct pentru a dobndi nivelul lui aha, asta am mai ntlnit, care nseamn flexibilitate, nseamn asocieri i soluii bazate pe experien. Aceast experien, dat de practic sau de lecturi, duce, n esen, la adoptarea celei mai nimerite atitudini n faa unei noi probleme. Exist, fr ndoial, i o anumit categorie de meseriai, care, prin natura activitii lor, sunt pui n faa problemelor din sfera inteligenei artificiale sau a unui domeniu conex acesteia. Lor, cred eu, cartea le poate fi de folos. Cred apoi c aceast carte are ceva de spus profesorilor ce predau informatica n coal. Este foarte important ca informatica s fie predat, i nu numai n colile cu programe speciale de informatic, ntr-o manier atractiv pentru elevi. E att de uor s molipseti de informatic un elev iste, dar e la fel de uor s-l dezamgeti nct acesta s fug toat viaa lui de acest domeniu. Dac programarea se pred la tabl, ncepnd cu lecii de sintax rigid a unui limbaj de programare, pentru c aa oblig programa, i continu cu dezvoltarea de linii de cod, dac expunerea e att de strns legat de un limbaj anume nct a ti s programezi se reduce la a scrie programe n acel unic Limbaj De Programare, dac se pierde din vedere faptul esenial c activitatea de programare este n primul rnd una de creaie i calculatorul este un penson cu care poi realiza orice tablou iar nu un gherghef pe care trebuie s reproduci un desen impus, atunci uriaul potenial de creaie care este imaginaia att de debordant a copiilor notri va fi nchistat oficial n tipare iar notele mari i diplomele vor atesta umila docilitate i perversa abilitate de a reproduce, iar nu neastmprul, cutarea i arta. Cum cred c programarea prin reguli este o activitate pe care a numi-o confortabil intelectual, iar limbajul utilizat ca suport al argumentaiilor este att de uor de nvat, cartea ar putea constitui un ajutor pentru profesorii de informatic din coli n tentativa acestora de a stimula spre creaie informatic elevii talentai. Volumul pe care l avei acum n mn nu este un manual al unui limbaj de programare, dei limbajul CLIPS este utilizat aproape peste tot pentru a
12
exemplifica noiunile tratate (cu excepia capitolului 5 n care notaia este una generic, de pseudo-cod). CLIPS nu este predat n carte n sensul n care ne-au obinuit crile de Programare n Limbajul XYZ. Dovad: faptul c multe elemente ale limbajului, cum ar fi declaraiile de funcii, lista funciilor de bibliotec, sau elementele de programare orientat-obiect pe care le ncorporeaz, nu sunt tratate de loc ori doar episodic. Un manual de CLIPS poate fi uor procurat din biblioteci sau de pe Internet. Mai greu de nvat dect un limbaj de programare este ns deprinderea unui stil, ajungerea la acea maturitate a actului de programare care s permit gsirea metodelor celor mai adecvate rezolvrii unor probleme, dobndirea eleganei soluiilor, a productivitii muncii de programare i a eficienei codurilor. Am fost cu precdere interesat de aceste aspecte. Variantele complete ale programelor CLIPS prezentate n cuprinsul crii pot fi accesate de cititor la adresa de Internet http://www.infoiasi.ro/~dcristea/carti/PBR/. Pentru elaborarea crii am folosit materiale utilizate de-a lungul anilor n cadrul a trei cursuri la Facultatea de Informatic a Universitii Alexandru Ioan Cuza din Iai: cursul de baz de inteligen artificial, dedicat studenilor anului III, cursul opional de sisteme expert pentru studenii anului IV i cursul de inteligen artificial i CLIPS predat studenilor formaiilor de studii postuniversitare. n felul acesta, an de an s-au adugat noi probleme sau au fost gsite noi soluii la probleme vechi. Nu m-am sfiit s folosesc n carte i idei sau fragmente de cod sugerate de foti studeni ai mei, pe care i amintesc n lucrare i crora le mulumesc pe aceast cale. n fazele iniiale ale introducerii unui neologism n limb este ntotdeauna dificil de apreciat dac termenul care i face acum loc prin mprumut va fi pn la urm acceptat ori nu. n limbajul tehnic ori tiinific, dificultatea este i mai mare datorit abundenei de cuvinte strine i vitezei cu care acestea apar. n informatic ns, acest fenomen este exacerbat prin invazia de termeni de ngust specialitate, limba din care se fac mprumuturi fiind, n exclusivitate, engleza. Apoi e deja notorie apetena informaticienilor spre un limbaj amestecat, uneori voit colorat cu englezisme, datorat comoditii de a utiliza termeni strini n locul echivalenilor autohtoni i a-i considera ca fiind ai notri dintotdeauna. Deciziile dificile sunt aici, probabil ca i n alte domenii, nu att n privina termenilor ce nu-i gsesc nicicum un echivalent n romnete i care, fr discuie, trebuie preluai ca atare pentru a ne putea nelege ntre noi (n astfel de cazuri am notat cuvintele englezeti n italice i le-am adugat terminaiile romneti desprite prin cratim, de exemplu, shell, shell-uri), ci mai ales n privina acelora pentru care dicionarele indic cel puin un corespondent, dar sensurile indicate sunt uor diferite, deci imperfecte, pentru noua utilizare. Un termen din aceast categorie, pentru care am optat s utilizez o traducere romneasc, este cel de pattern, cu pleiada lui de compui ori sintagme derivate (pattern matching, pattern recognition). Am preferat s utilizez o traducere a sa, poate n dezacord cu ali colegi ai mei ce trudesc n acelai cmp, prin romnescul ablon (i nu tipar, ce mi sugereaz prea mult uzana lui din
Cuvnt nainte
13
croitorie). ablon mi s-a prut c are, sau poate primi uor, ncrcarea semantic din programare, care e legat de dou operaii: una n care selecteaz obiecte asemenea lui i cealalt n care produce obiecte, ori componente ale obiectelor, de un anumit tip. n privina lui pattern matching, am considerat ntotdeauna c sintagma are dou conotaii ce trebuie traduse diferit n romnete: una este dinamic, semnificnd o operaie de triere a unor obiecte ce corespund ablonului, deci o confruntare de abloane, cealalt este static i corespunde rezultatului confruntrii, n esen boolean, da ori nu, adic s-a verificat ori nu dac ablonul sa potrivit peste obiect.1 Cartea este structurat n patru pri. Partea I Programarea bazat pe reguli i sistemele expert realizeaz n primul rnd o introducere n programarea bazat pe reguli, prezentnd specificul acestui tip de programare. Cititorul este purtat prin marea familie a paradigmelor de programare prin rezolvarea unei probleme n maniera de cas a fiecreia dintre ele. Se descriu apoi sistemele expert, copiii minune ai paradigmei, i se inventariaz tipurile lor i realizrile din acest domeniu. Partea a II-a se intituleaz Organizarea i funcionarea sistemelor expert i prezint detalii constructive ale motoarelor de sisteme expert. Se descrie organizarea general a oricrui sistem expert, cum arat un ciclu din funcionarea unui astfel de motor, cunoscut i sub numele de motor de inferene, ce sunt faptele i regulile, cum se leag variabilele la valori n confruntarea regulilor asupra faptelor i ce este agenda. Se prezint apoi maniera de cutare a soluiei cea mai uzual n sistemele expert: dinspre fapte iniiale spre concluzii. Se descriu cele dou regimuri de funcionare a motoarelor de inferen: irevocabil (decis: un pas fcut, chiar dac pe o cale greit, rmne bun fcut) i tentativ (ezitant: ai ajuns ntr-un punct mort, nu-i nimic, ia-o pe o alt cale), ct i condiii suficiente de gsire a soluiei pentru motoarele ce funcioneaz ntr-o manier irevocabil. Pentru c cele mai multe motoare de inferen ale sistemelor expert implementeaz un comportament irevocabil, iar acesta nu garanteaz soluia, se arat cum poate fi modelat un comportament tentativ, care duce ntotdeauna la gsirea unei soluii, atunci cnd ea exist, pe o arhitectur irevocabil. Se prezint apoi un algoritm celebru de confruntare a unei mulimi de abloane peste o mulime de fapte RETE. Acest algoritm st la baza realizrii celor mai multe shell-uri de sisteme expert. Partea a III-a, sub titlul Elemente de programare bazat pe reguli, prezint fundamentele programrii prin reguli. Pe parcursul unui capitol se introduc sintaxa i elementele eseniale ale unui limbaj bazat pe reguli CLIPS. Toate exemplele din carte vor fi apoi construite n acest limbaj. Mici aplicaii, ca, de exemplu, una inspirat din activitatea profesorilor de liceu, vor fi tot attea pretexte
Despre pattern recognition, un termen care nu e utilizat n carte, se pot spune, de asemenea, multe lucruri, traducerea prin recunoaterea trsturilor prndu-mi-se mai puin supus confuziei dect recunoaterea caracterelor.
1
14
pentru construirea i comentarea unor soluii. Se insist asupra agendei, structura care pstreaz activrile, i se arat ce strategii de rezoluie a conflictelor pot fi utilizate i maniera n care programatorul poate beneficia de schimbarea strategiei. Exemplele date intenioneaz s evidenieze situaii care necesit impunerea de prioriti regulilor. Se comenteaz importana ordinii comenzilor care produc modificri n baza de fapte. Pentru c exist motive care fac ca recursivitatea s nu fie la ea acas ntr-un limbaj bazat pe reguli, se arat ce soluii se pot gsi care s simuleze un algoritm recursiv. Ultima parte, a IV-a este dedicat Dezvoltrii de aplicaii. Fiecare capitol prezint o alt problem, se propun soluii i se comenteaz. Astfel se arat cum pot fi construite maini specializate pentru structurile de stiv i coad i cum pot fi acestea integrate n aplicaii. Un alt capitol prezint elemente de proiectare a aplicaiilor n care pot aprea evenimente externe i n care variabila timp este la mare pre. Sub pretextul unor aplicaii ce necesit recunoaterea unor obiecte planare sau capacitatea de a naviga n plan, se descrie maniera n care abloanele prilor stngi ale regulilor sunt fcute s semene cu obiectele pe care dorim s le descoperim. Se prezint apoi o problem cunoscut din inteligen artificial care, dei aparent banal, se relev a avea o soluie ce depete n complexitate tot ceea ce s-a prezentat anterior. O problem de fizic de liceu ofer pretextul prezentrii propagrii fluxului de calcul n maniera ghidat de date (data-driven) i n care nedeterminismul intrinsec paradigmei este exploatat n privina ordinii efecturii operaiilor. Se propune apoi un demonstrator de teoreme aplicat n rezolvarea automat a problemelor de geometrie. Soluia adoptat este una de explozie combinatorial a faptelor ce pot fi generate din ipoteze prin aplicarea adevrurilor cunoscute (teoreme). n sfrit, n ultimul capitol al crii sunt puse n eviden, comentate i corectate cteva erori ntlnite n practica limbajului CLIPS.
Partea I Programarea bazat pe reguli i sistemele expert

Paradigme de programare Introducere n sistemele expert
Capitolul 1
Paradigme de programare
Programarea este o activitate mental pe care oamenii o fac de foarte mult vreme. n general, aceast activitate este fcut cu scopul de a gndi o dat i a aplica rezultatul acestui efort ori de cte ori este nevoie apoi. n loc s cnte efectiv la pian, oamenii au inventat un tambur sau o band, cu guri sau cu ace, care, nvrtindu-se, permite unui mecanism s produc sunete n ritmul n care reperele de pe tambur ori band acioneaz asupra unor senzori. O flanet nu este dect un calculator primitiv, capabil s reproduc un program nregistrat pe un band. Dac se schimb banda, se obine o alt melodie. Meterul ce a produs pentru prima dat o band cu guri pentru flanet n scopul reproducerii unei melodii a fost un programator. ntr-un anume sens, o carte de bucate este o colecie de programe. O reet ne nva ce ingrediente trebuie s folosim i ce operaii trebuie s facem asupra lor ori de cte ori ni se face dor de un fel de mncare sau de o prjitur. Apariia calculatoarelor a transformat activitatea de programare, episodic pn atunci, ntr-o tiin informatica. De cnd oamenii au nceput s se aplece asupra calculatoarelor din necesitatea de a rezolva probleme mai repede i mai bine, din pasiunea iscat de curiozitate, ori pentru satisfacerea necesitii de a-i folosi imaginaia, programarea a evoluat n dou direcii. Pe de o parte s-a produs o perfecionare a limbajelor, n aa fel nct actul programrii s-a deprtat tot mai mult de electronica rigid a mainii, apropiindu-se n schimb de standardele canalelor de comunicaie uman (exprimarea prin imagini sau limbaj apropiat de cel natural) i, pe de alt parte, nsi maniera de a programa s-a diversificat, n aa fel nct rezolvarea unei probleme se poate acum gndi n multiple feluri. Prima direcie n dezvoltarea programrii s-a manifestat pe linia mririi productivitii actului de programare, expresivitatea instruciunilor crescnd necontenit de la limbajul main, n care o instruciune exprima o comand ce era subliminal problemei de rezolvat, pn la limbajele moderne, n care un singur apel de funcie de bibliotec, ce concentreaz mii ori zeci de mii de instruciuni main, codific pai semnificativi n rezolvarea problemei. Cea de a doua direcie a nsemnat o diversificare a paradigmelor de programare, fiecare, prin trsturile ei, oferind o alt alternativ de a gndi o soluie dar i, uneori, o specializare a tipului de probleme la care se preteaz. n [26] colegul meu Dorel Lucanu preia o problem propus de Gries [18] pentru a analiza cteva soluii. Problema platoului: Se consider un ir finit de
18
ntregi cresctori. S se gseasc lungimea celui mai lung platou (ir de ntregi egali). Soluiile ce urmeaz intenioneaz s prezinte caracteristicile definitorii ale celor mai cunoscute paradigme de programare. Ele nu trebuie luate n nici un caz drept singurele soluii posibile n paradigmele respective. Pentru simularea rulrilor vom considera urmtorul vector de ntregi cresctori: (1 2 2 2 3).
1.1. Programarea imperativ rezolv dictnd cum s faci

n imaginarea unei soluii n maniera imperativ, ceea ce conteaz este depistarea unor operaii i gsirea ordinii n care acestea trebuie efectuate. Menionarea unui ir de numere aproape c invit la gndirea unei operaii care trebuie repetat pentru fiecare element al irului. Astfel, n soluia dat n cartea citat, variabila care ine lungimea platoului maxim este nti iniializat la 1, pentru ca operaia care se itereaz pentru fiecare element al irului s fie incrementarea acesteia n cazul n care elementul curent aparine unui platou cu 1 mai lung dect cel considerat maxim pn la pasul anterior. Dac variabila p ine lungimea maxim a platoului curent, iar elementul al i-lea al vectorului este notat vec[i], primul fiind vec[0], atunci apartenena lui vec[i] la un platou de lungime p+1 se face verificnd dac elementul aflat la distan p spre stnga elementului al i-lea este egal cu acesta, adic vec[i]==vec[i-p] (n aceast condiie este, evident, esenial proprietatea de ir ordonat cresctor). Cu aceasta, presupunnd lungimea irului n, algoritmul arat astfel, ntr-o notaie care mprumut mult din limbajul C:
for(i=1, p=1; i<n; i++) if vec[i]==vec[i-p] then p++;
O formulare echivalent a acestei soluii este: ntr-o parcurgere a vectorului stnga-dreapta, pentru toate poziiile din vector ce corespund unor platouri cu 1 mai lungi dect cel mai lung platou gsit deja, incrementeaz cu 1 cel mai lung platou. Execuia programului poate fi urmrit pe urmtorul tabel:
i 1 2 3 4 vec[i] 2 2 2 3 p nainte 1 1 2 3 i-p 0 1 1 1 vec[i-p] 1 2 2 2 vec[i]== vec[i-p] false true true false p dup 1 2 3 3
19
1.2. Programarea logic rezolv spunnd ce vrei s faci

A imagina o soluie n programarea logic nseamn a gndi n termenii gsirii de definiii pentru elementele centrale problemei. n cazul problemei noastre, preocuparea este s definim ce nseamn platoul de lungime maxim al irului din perspectiva unei anumite poziii a irului. S considerm un predicat platou(i, p, n, q) care afirm c, dac cel mai lung platou gsit n subirul iniial pn la indexul i al irului dat are lungimea p, atunci lungimea platoului maxim al ntregului ir, de index final n, este q. n Figura 1 elementele irului sunt desenate ca mici dreptunghiuri, lungimile maxime ale platourilor, considerate asociate elementelor irului, sunt marcate prin stegulee, secvenele din ir crora li se asociaz aceste platouri sunt figurate prin benzi colorate, iar indecii elementelor care mrginesc n partea dreapt aceste subiruri sunt notai deasupra lor:
i ... p q ... n
Figura 1: Semnificaia predicatului platou(i, p, n, q)
Dac vector(i, v) este un predicat care exprim c elementul de index i din vector are valoarea v (n sensul c se evalueaz la true n exact acest caz), primul element al vectorului fiind de index 0, atunci, ntr-o notaie apropiat oricrei versiuni a limbajului Prolog, o soluie poate s arate astfel:
(1) (2) platou(N, P, N, P) :- !. platou(I, P, N, Q) :- vector(I+1, V), vector(I+1-P, V), platou(I+1, P+1, N, Q). platou(I, P, N, Q) :- vector(I+1, V), ~vector(I+1-P, V), platou(I+1, P, N, Q).
(3)
Prima definiie exprim situaia asociat subirului de lungime n al irului dat, caz n care, aa cum se poate constata i din Figura 1, lungimea platoului maxim este q, deci p este egal cu q. Acest predicat este menit s termine demonstraia pentru cazul n care s-a reuit s se arate c lungimea platoului maxim
20
al unui subir ce este identic cu irul dat are lungimea p, ceea ce se rsfrnge i asupra lungimii platoului maxim al irului dat. Definiia a doua exprim relaia dintre dou predicate asociate la doi indeci adiaceni (i i i+1) ai vectorului i unde platourile maxime corespunztoare subirurilor iniiale ale irului dat, pentru indecii indicai, au lungimile p i respectiv p+1. Acest caz apare atunci cnd elementele irului de indeci i+1 i i+1-p sunt egale (vezi Figura 2, n care elementele egale aparinnd platoului maxim aflat n dezvoltare sunt notate prin aceeai culoare).
i+1-p ... ... p i i+1 ... n
..
p+1 q
p p+1 Figura 2: Relaia dintre predicatele asociate la doi indeci alturai crora le corespund platouri maxime inegale
Textual, aceast definiie exprim urmtoarele: ca s demonstrez c, dac lungimea platoului iniial al subirului dat pn la indexul i al vectorului este p, lungimea platoului maxim al ntregului ir este q n condiiile n care elementele vectorului de indeci i+1 i i+1-p sunt egale, atunci trebuie s demonstrez c dac lungimea platoului maxim al subirului iniial pn la indexul i+1 al vectorului este p+1, lungimea platoului maxim al vectorului de lungime n este q. Definiia a treia exprim relaia dintre dou predicate asociate la doi indeci adiaceni, crora le corespund platouri de aceeai lungime p, atunci cnd elementele irului de indeci i i i-p sunt inegale (vezi Figura 3).
21
i+1-p ... ...
i+1 ...
..
p q
p Figura 3: Relaia dintre predicatele asociate la doi indeci alturai crora le corespund platouri maxime egale
S remarcm c dei figura exprim situaia n care platoul maxim al subirului de index i este dispus n extremitatea dreapt a subirului, elementul de index i+1 fiind primul care nu aparine platoului, condiiile exprimate n predicat sunt valabile inclusiv pentru cazurile n care platoul maxim al subirului iniial de index i al vectorului nu se afl n captul din dreapta al acestuia. Vectorul folosit n seciunea anterioar, n declaraiile specifice limbajului Prolog, arat acum astfel:
vector(0, vector(1, vector(2, vector(3, vector(4, 1). 2). 2). 2). 3).
Pentru acest ir, calculul platoului maxim este amorsat de apelul:

?- platou(0, 1, 4, X).
care concentreaz ntrebarea: dac tim c n subirul format din primul element al vectorului (pn la indexul 0) lungimea platoului maxim are lungimea 1, care este lungimea platoului maxim al ntregului ir (pn la indexul 4)? S observm c soluia este valabil inclusiv pentru un ir banal de lungime total 1. n acest caz rspunsul l d direct prima definiie, pentru c predicatul platou(0, 1, 0, X) se va potrivi peste faptul platou(N, P, N, P), ceea ce va duce la legarea simultan a variabilelor P i X la valoarea 1. ntrebarea va genera urmtorul lan de confruntri de predicate i legri de variabile:
22
platou(0, 1, 4, X) versus platou(N, P, N, P) n (1) eec; platou(0, 1, 4, X) versus platou(I, P, N, Q) n (2) succes cu: I=0, P=1, N=4, Q=X; vector(1, V) versus vector(1, 2) succes cu: V=2; vector(0, 2) versus vector(0, 1) eec; platou(0, 1, 4, X) versus platou(I, P, N, Q) n (3) succes cu: I=0, P=1, N=4, Q=X; vector(1, V) versus vector(1, 2) succes cu: V=2; vector(0, ~2) versus vector(0, 1) succes; platou(1, 2, 4, X) versus platou(N, P, N, P) n (1) eec; platou(1, 2, 4, X) versus platou(I, P, N, Q) n (2) succes cu: I=1, P=2, N=4, Q=X; vector(2, V) versus vector(2, 2) succes cu: V=2; vector(0, 2) versus vector(0, 1) eec; platou(1, 2, 4, X) versus platou(I, P, N, Q) n (3) succes cu: I=1, P=2, N=4, Q=X; vector(2, V) versus vector(2, 2) succes cu: V=2; vector(0, ~2) versus vector(0, 1) succes; platou(2, 2, 4, X) versus platou(N, P, N, P) n (1) eec; platou(2, 2, 4, X) versus platou(I, P, N, Q) n (2) succes cu: I=2, P=2, N=4, Q=X; vector(3, V) versus vector(3, 2) succes cu: V=2; vector(2, 2) versus vector(2, 2) succes; platou(3, 3, 4, X) versus platou(N, P, N, P) n (1) eec; platou(3, 3, 4, X) versus platou(I, P, N, Q) n (2) succes cu: I=3, P=3, N=4, Q=X; vector(4, V) versus vector(4, 3) succes cu: V=3; vector(1, 3) versus vector(1, 2) eec; platou(3, 3, 4, X) versus platou(I, P, N, Q) n (3) succes cu: I=3, P=3, N=4, Q=X; vector(4, V) versus vector(4, 3) succes cu: V=3; vector(1, ~3) versus vector(1, 2) succes; platou(4, 3, 4, X) versus platou(N, P, N, P) n (1) succes cu: N=4, P=3, X=3.
1.3. Programarea funcional rezolv apelnd o funcie

Noiunea central n programarea funcional este apelul de funcie. Iteraia nu e fireasc n aceast paradigm. Desigur, o iteraie se poate realiza n toate limbajele funcionale existente, pentru c ntotdeauna proiectanii de limbaje de programare au fcut concesii unor trsturi care impurificau conceptul de baz n avantajul ergonomiei actului de programare. Dimpotriv recursivitatea, utiliznd apelul de funcie din interiorul aceleiai funcii, este aici natural. O soluie funcional a problemei platoului urmrete definirea unei funcii care trebuie s ntoarc lungimea platoului maxim al irului dat, de lungime n, dac
23
se cunoate lungimea p a unui subir de lungime i al irului dat. Notnd, ca n Lisp, (platou p i n) un apel al acestei funcii, atunci o soluie ar putea fi urmtoarea, dac un apel (nth i vector) ntoarce valoarea elementului de pe poziia i din vector, (eq x y) ntoarce t (true) dac x este egal cu y i nil (false) altfel, iar (if <pred> <form1> <form2>) ntoarce rezultatul evalurii lui <form1> dac <pred> se evalueaz la t i rezultatul evalurii lui <form2> dac <pred> se evalueaz la nil:
(defun platou (i p n) (if (eq i n) p (if (eq (nth (- i p) vector) (nth i vector)) (platou (+ i 1) (+ p 1) n) (platou (+ i 1) p n) ) ) )
Definiia ncepe cu condiia de terminare a recursiei, aceeai ca i n soluia dat n Prolog, i anume: dac se cunoate lungimea platoului maxim al unui subir iniial de lungime egal cu lungimea irului, atunci aceasta este i lungimea platoului maxim al irului dat. Altfel, dac valoarea elementului din vector aflat pe poziia i este egal cu cea a elementului aflat pe poziia i-p, atunci valoarea platoului maxim al irului este dat de valoarea ntoars de aceeai funcie n condiiile n care valoarea platoului maxim pentru subirul iniial de lungime i+1 este p+1. Altfel, ea este egal cu valoarea ntoars de funcie n condiiile n care valoarea platoului maxim pentru subirul iniial de lungime i+1 este tot p. Rezultatul, pentru irul nostru de lungime 5 este dat de apelul:
(platou 1 1 5)
Acest apel antreneaz urmtorul ir de apeluri i rezultate intermediare pentru acelai vector considerat drept intrare, care aici este comunicat prin setarea (setf vector '(1 2 2 2 3)):
(platou 1 1 5) 0: (PLATOU 1 1 5) ; i=1: vector(1) vector(0), test false ; => p rmne 1 1: (PLATOU 2 1 5) ; i=2: vector(2) = vector(1), test true ; => p devine 2 2: (PLATOU 3 2 5) ; i=3: vector(3) = vector(1), test true
24
; => p rmne 3 3: (PLATOU 4 3 5) ; i=4: vector(4) vector(1), test false ; => p rmne 3 4: (PLATOU 5 3 5) ; i=5: terminarea recursiei 4: returned 3 3: returned 3 2: returned 3 1: returned 3 0: returned 3 3 >
1.4. Programarea orientat-obiect rezolv construind obiecte ce interacioneaz

Un automobil este un obiect. Dar un automobil este format din caroserie, motor i roi. Fiecare dintre acestea sunt, la rndul lor, obiecte. Aa, spre exemplu, un motor are n componen asiul, pistoanele, carburatorul, pompele de ap, de ulei, de benzin, generatorul de curent .a. Pentru ca o main s mearg, este nevoie ca toate obiectele componente, fiecare cu rolul lor, s-i ndeplineasc funciile, n interaciune cu celelalte, la momentele de timp cnd aceste funcii sunt solicitate. De exemplu, roile motoare trebuie s se nvrteasc sincron, astfel nct s trag la fel de tare, cele patru pistoane trebuie s mping bielele n strict corelaie unele cu altele, exact atunci cnd aceste operaii sunt cerute de un dispecer electronic etc. Funcionalitatea unui obiect fizic, cum este o main, poate fi simulat printrun program. n acest caz programul modeleaz obiecte ca cele din lumea real. i, tot ca n lumea real, dac suntem capabili s realizm o main de un anumit tip, s zicem un Renault Meganne, atunci o putem multiplica n oricte exemplare, producnd instane ale ei, fiecare utilate cu caroserie, motor i roi de Renault Meganne. Ca s rezolvm problema platoului n maniera orientat-obiect ar trebui s privim fiecare element al vectorului ca pe un obiect nzestrat cu capacitatea de a rspunde la ntrebri prin introspecie sau schimbnd mesaje cu alte obiecte asemenea lui. Spre exemplu, presupunnd o ordonare stnga-dreapta a irului de numere, s ne imaginm c am construi un obiect ce ar corespunde unui element al irului i care ar fi capabil s ne indice, atunci cnd ar fi interogat: - pe de o parte, valoarea lui;
25
- pe de alt parte, presupunnd c i comunicm lungimea celui mai lung platou de la nceputul vectorului pn la elementul aflat n stnga lui inclusiv, care este valoarea platoului maxim al ntregului vector. Dac am avea construite obiecte cu aceast funcionalitate, atunci am putea afla lungimea platoului maxim al irului interognd direct primul element, dup ce i-am spus c lungimea celui mai lung platou de la nceputul vectorului pn la el este de 0 elemente. S ncercm s ne imaginm cum ar putea raiona un obiect al vectorului pentru a rspunde la cea de a doua ntrebare: dac tiu c cel mai lung platou de la nceputul irului de numere pn la elementul din stnga mea inclusiv este p, atunci, - dac valoarea mea este egal cu a unui element aflat cu p elemente la stnga, nseamn c lungimea celui mai lung platou de la nceputul irului pn la mine inclusiv este p+1 i atunci rspunsul meu trebuie s fie cel dat de vecinul meu din dreapta, atunci cnd l voi ruga s-mi comunice lungimea celui mai lung platou al irului, dup ce i voi fi spus c lungimea celui mai lung platou de la nceputul irului pn la mine inclusiv este p+1; - altfel, dac valoarea mea nu e, deci, egal cu a elementului aflat cu p elemente la stnga, nseamn c lungimea celui mai lung platou de la nceputul irului pn la mine inclusiv este tot p i rspunsul meu trebuie s fie cel dat de vecinul meu din dreapta atunci cnd l voi ruga s-mi comunice lungimea celui mai lung platou al irului, dup ce i voi fi spus c lungimea celui mai lung platou de la nceputul irului pn la mine inclusiv este p. Dup cum se poate vedea deja, pentru a asigura o funcionalitate de acest fel, va trebui s facem ca un obiect corespunztor unui element al irului s comunice, pe de o parte cu obiecte asemenea lui din ir, dar aflate n stnga lui, pentru a afla de la ele valoarea lor, iar pe de alt parte cu obiectul vecin lui n dreapta, pentru a afla de la el lungimea platoului maxim al ntregului ir atunci cnd i va comunica lungimea platoului maxim al elementelor de pn la el. Valoarea aflat de la acesta va fi i rspunsul pe care l va ntoarce la ntrebarea care i-a fost iniial adresat lui nsui. Iat, ntr-o notaie apropiat de limbajul C++, un astfel de program:
class Vector { int dim; int current; MyInt vec[5]; Vector(); } class MyInt { int val; MyInt (int i) {val = i;}
26
int getVal (void) {return val;} int platou (int); } int MyInt::platou(int p) { if(vec.current >= vec.dim) return(p); if(val == vec[vec.current-p].getVal()) return(vec[++vec.current].platou(++p)); else return(vec[++vec.current].platou(p)); } void main() { Vector myVector; int p = myVector[1].platou(1); printf(Lungimea platoului maxim = %d\n, p); }
1.5. Programarea bazat pe reguli rezolv ca ntr-un joc de Puzzle sau Lego
Puzzle este un joc n care o mulime de piese de forme i culori diferite pot fi asamblate pentru a forma un tablou. Pentru fiecare pies, n principiu, exist un singur loc n care aceasta poate fi integrat. n Lego dispunem de seturi de piese de acelai fel ce pot fi mbinate ntre ele pentru a realiza diverse construcii. Aceleai piese pot fi utilizate n combinaii diferite. n ambele cazuri, un ansamblu sau o construcie se realizeaz din elemente simple care au, fiecare n parte, funcionaliti precizate n tabloul de ansamblu. Analogia programrii bazate pe reguli este mai puternic cu jocul de Lego dect cu cel de Puzzle pentru c, utiliznd piesele din set, n Puzzle se poate crea un singur tablou, pe cnd n Lego putem realiza oricte construcii. n programarea bazat pe reguli, utiliznd aceleai piese de cunoatere, care sunt regulile, putem, n principiu cel puin, rezolva orice instan a aceleiai probleme. S revenim la problema noastr ncercnd o rezolvare prin reguli. S ne imaginm c proiectm testul de incrementare a lungimii unui platou maxim gsit deja. Vom avea n vedere proiectarea unei reguli care s mreasc cu o unitate lungimea platoului maxim gsit pn la un moment dat. Vom raiona astfel: dac tim c un platou de o lungime p a fost deja gsit, atunci putem afirma c am gsit un platou de lungime p+1 dac gsim dou elemente egale ale vectorului aflate la distan p unul de altul n secven. Ordinea n care sunt interogate elementele vectorului n acest calcul nu mai este relevant. n felul acesta, iteraia n lungime vectorului, ce aprea ntr-un fel sau altul n toate soluiile anterioare, este nlocuit cu o iteraie n lungimea platoului, fr ca, de la un pas la urmtorul n iteraie, s se pstreze neaprat o parcurgere n ordine a elementelor vectorului. Aceast
27
soluie, pentru cazul aceluiai exemplu de vector pe care l-am mai utilizat, poate fi redat de urmtorul program CLIPS (aici, pentru prima oar, ca i n restul crii, secvenele de programe n CLIPS sunt redate pe un font gri):
(deffacts (vector (vector (vector (vector (vector (platou ) initial 0 1) 1 2) 2 2) 3 2) 4 3) 1)
(defrule cel-mai-lung-platou ?ip <- (platou ?p) (vector ?i ?val) (vector ?j&:(= ?j (+ ?i ?p)) ?val) => (retract ?ip) (assert (platou =(+ ?p 1))) )
Prima parte a programului definete vectorul de elemente i platoul maxim iniial (egal cu 1) prin nite declaraii de fapte. Aici nu este necesar nici o declaraie care s iniializeze un index al vectorului. Partea a doua a programului definete o regul. Numele ei cel-mai-lung-platou nu e esenial n derularea programului, dar ajut la descifrarea coninutului. Textual, ea spune c, dac platoul maxim gsit pn la momentul curent este p, i dac n vector exist dou elemente egale aflate la distana p unul de altul, atunci lungimea platoului maxim gsit trebuie actualizat la valoarea p+1. La fiecare aplicare a regulii, aadar, va avea loc o incrementare a platoului maxim gsit. Este de presupus c atunci cnd regula nu se mai poate aplica, faptul care reine valoarea platoului maxim gsit s indice platoul maxim al ntregului ir. Ceea ce urmeaz reprezint o trasare comentat a rulrii:
CLIPS> (reset)
CLIPS fiind un limbaj interpretat, comenzile se dau imediat dup afiarea prompterului CLIPS>.
==> f-1 ==> f-2 (vector 0 1) (vector 1 2)
28
==> ==> ==> ==>
f-3 f-4 f-5 f-6
(vector (vector (vector (platou
2 2) 3 2) 4 3) 1)
n liniile care apar dup comanda (reset) sunt afiate faptele aflate iniial n baz, fiecare nsoit de un index (de la f-1 la f-6). Faptul (vector 0 1) memoreaz valoarea 1 n poziia din vector de index 0 .a.m.d. Valoarea iniial a platoului maxim este 1.
CLIPS> (run)
Ceea ce urmeaz dup comanda (run) semnaleaz aprinderea regulilor.

FIRE 1 cel-mai-lung-platou: f-6,f-3,f-4
Se aprinde pentru prima oar regula cel-mai-lung-platou datorit faptelor cu indicii f-6, f-3 i f-4, respectiv: faptul care indic lungimea 1 a platoului maxim, elementul de vector (vector 2 2) i elementul de vector (vector 3 2).
<== f-6 (platou 1)
Ca urmare, lungimea maxim a platoului este actualizat de la 1...

==> f-7 (platou 2)
... la 2, noul fapt primind indexul f-7.

FIRE 2 cel-mai-lung-platou: f-7,f-2,f-4
Regula se aprinde pentru a doua oar datorit faptelor de indici f-7, f-2 i f-4, respectiv: faptul care indic noua lungime 2 a platoului i elementele de vector (vector 1 2) i (vector 3 2), care sunt egale i se gsesc la o distan de 2 elemente.
<== f-7 (platou 2)
Ca urmare, lungimea maxim a platoului este actualizat de la 2...

==> f-8 (platou 3)
29
... la 3. n continuare regula nu mai poate fi aprins pentru c n vector nu mai exist dou elemente egale aflate la o distan de 3 indeci. Ca urmare rularea se oprete de la sine. Se poate constata c, dac n celelalte implementri exemplificate n acest capitol lungimea rulrii a fost proporional cu lungimea vectorului, n abordarea prin reguli ea a fost dictat de mrimea platoului maxim. Problema s-a inversat: n loc s iterez sau s recurez pe lungimea vectorului pentru ca la fiecare pas s incrementez sau nu o variabil ce ine lungimea platoului, iterez pe lungimea platoului maxim i folosesc condiia de incrementare a acestuia drept condiie de terminare a rulrii. ntr-adevr, cnd nu mai gsesc dou elemente egale aflate la o distan mai mare dect ceea ce tiu c este lungimea unui platou din cuprinsul vectorului, nseamn c am aflat rspunsul i pot opri calculele. n acelai timp, se poate remarca faptul c totul se petrece ca i cum cazurile ce duc la incrementarea variabilei ce ine lungimea platoului maxim gsit pn la un moment dat ies la iveal singure sau atrag regula n care s-a specificat acea condiie, pentru ca ea s fie aplicat. Continund metafora de la nceputul acestei seciuni, vedem c exemplul a pus n eviden un joc de puzzle cu un singur tip de pies, dar care a fost folosit de dou ori n gsirea soluiei. Piesa n chestiune nu face altceva dect s modeleze un microunivers de cunoatere, ncorpornd o specificare a unei situaii i aciunile ce trebuie efectuate n eventualitatea c situaia este recunoscut. Aceasta este nsi esena programrii bazat pe reguli. Sintetiznd diferena dintre programarea imperativ, cea mai utilizat paradigm de programare clasic, i programarea bazat pe reguli, putem spune c n maniera imperativ, atunci cnd condiii diferite antreneaz aciuni diferite, programul trebuie s itereze toate aceste condiii pentru a le gsi pe cele ce pot fi aplicate. Simplificnd, putem considera c, n paradigma bazat pe reguli, condiiile sunt organizate n pereche cu aciunile respective, iar realizarea unei condiii aprinde automat aciunea corespunztoare, fr a avea nevoie de o iterare care s parcurg ansamblul de condiii pn la gsirea celei ori celor satisfcute.
Capitolul 2
Introducere n sistemele expert
O varietate att de mare de paradigme de programare, ca cea descris n capitolul precedent, oglindete necesitatea de a avea la dispoziie limbaje de programare orientate cu precdere spre anumite tipuri de probleme. Specializarea unei paradigme pentru probleme de un anumit tip nu reprezint ns o restricie de a aplica aceast paradigm la orice alt problem, ci trebuie neleas doar ca preferin. Problemele cu precdere rezolvabile n paradigma programrii bazat pe reguli sunt cele din gama sistemelor expert. Potrivit lui Francis Bacon, puterea st n cunoatere2. Aplicarea acestui concept la sistemele artificiale nseamn dotarea lor cu abilitatea de a se servi de cunoatere specific (cunoatere expert). Simplificnd foarte mult actul medical, putem spune c un medic este valoros atunci cnd, pus n faa unui bolnav, reuete s-i stabileasc un diagnostic corect i, pe baza lui, s indice un tratament care s duc la vindecarea bolnavului. n stabilirea diagnosticului, medicul se bazeaz pe un bagaj de cunotine generale dar i specifice despre boli i bolnavi. Parial aceast cunoatere a acumulat-o din cri, parial n cursul anilor de experien clinic, prin attea cazuri n care s-a implicat i parial prin puterea minii lui de a corela toate simptomele spre configurarea diagnosticului celui mai reprezentativ. n precizarea tratamentului, el face apel din nou la cunotine achiziionate, care arat c n anumite boli sunt indicate anumite medicaii, regimuri, exerciii etc., la experiena n tratarea bolnavilor (atunci cnd aceasta nu s-a transformat ntr-o aplicare schematic datorit rutinei), dar i la puterea lui de corelaie, sintez i uneori chiar intuiie n a combina toate posibilitile, n a evalua indicaiile i contra-indicaiile pentru a ajunge la cea mai fericit soluie de tratament. Nu de puine ori n acest complex act de gndire, n care o problem nu este aproape niciodat n totalitate rezolvat anterior, pentru c exist bolnavi iar nu boli i nu s-au nscut nc doi indivizi absolut la fel, intervin aprecieri extrem de subtile care in de capacitatea minii omenete de a opera cu o cunoatere imperfect, aproximativ ori parial, de a trece peste lacune, de a extrapola o serie de experiene i de a apela la o manier de raionament nenumeric, bazat pe analogii, aproximaii i intuiii. O astfel de cunoatere este numit, n general,
Conceptul a fost preluat de E. Feigenbaum pentru a fi aplicat la sistemele inteligente.
32
cunoatere expert iar sistemele artificiale care sunt capabile s dezvolte raionamente bazate pe cunoatere expert se numesc sisteme expert.
2.1. Ce sunt sistemele expert ?

Edward Feigenbaum, profesor la Universitatea Stanford, un pionier al tehnologiei sistemelor expert, d pentru un astfel de sistem urmtoarea definiie: ... un program inteligent care folosete cunoatere i proceduri de inferen pentru a rezolva probleme suficient de dificile nct s necesite o expertiz uman semnificativ pentru gsirea soluiei. S ne imaginm urmtoarea situaie: un domeniu oarecare al cunoaterii i dou persoane: un expert n acel domeniu i un novice. Prin ce difer modul n care novicele, respectiv expertul, abordeaz probleme din domeniul dat? Desigur, ne putem imagina situaia n care novicele are cunotine generale asupra domeniului (aa cum se ntmpl de obicei cu domenii cum ar fi cel medical, cel meteorologic etc.). Novicele poate purta o discuie asupra vremii, fcnd constatri care pot fi chiar caracterizate drept exacte asupra vremii locale, sau emind pronosticuri asupra felului n care ea va evolua ntr-o zi, dou. Totui, cunoaterea sa asupra domeniului este cel puin nebuloas i fragmentar, adesea inexact. Dac cineva iar solicita s explice de ce azi a plouat, de exemplu, ar putea, eventual, argumenta printr-o tendin de rcire care s-a fcut simit ieri, sau prin acumulrile de nori pe care le-a observat venind dinspre nord, direcia obinuit de unde plou. Dar acestea sunt constatri de relevan redus i care dau o explicaie foarte aproximativ a fenomenelor. Sau, s presupunem c att expertul ct i novicele cunosc toate datele care permit stabilirea evoluiei vremii n intervalul imediat urmtor. Novicele va furniza un pronostic slab, expertul va face o prezicere bun, sau cel puin apropiat de realitate. De ce? Pentru c expertul are o bun cunoatere a regulilor care guverneaz micrile de aer, apariia ploii, schimbrile de vreme. Putem spune c oricine are o anumit expertiz asupra fenomenelor meteorologice. Diferena const n completitudinea sistemului i n maniera de sistematizare a acestor cunotine. Aadar, putem spune c motivele pentru care noi, novicii, nu putem furniza o explicaie satisfctoare asupra ploii de azi sunt cel puin acestea: - nu avem acces la o baz de informaii suficient, lipsete o cunoatere a faptelor, i - nu cunoatem regulile care guverneaz evoluia vremii, aadar ne lipsete o cunoatere a fenomenelor. Oricine tie c dac eti rcit trebuie s iei aspirin. Dar un medic tie, n plus, c trebuie s interzic acest tratament unui bolnav care manifest o
33
hipersensibilitate alergic, pentru c medicul tie c aspirina conine substane alergene care i pot provoca o criz de astm. n acest caz, un plus de cunoatere permite evitarea unor greeli. Mult lume dorete s slbeasc. Pentru a da jos cteva kilograme n plus, muli sunt dispui s in diete foarte severe, mncnd mai puin pine, renunnd la o mas, sau nfrnndu-i pofta de a savura o prjitur. Aceste restricii sunt gndite ca fiind naturale n a mpiedica procesul de ngrare. Dar puini tiu c exist o metod prin care poi s-i menii o greutate riguros constant fr a recurge la privaiuni, mncnd la fel de mult ca i nainte i din toate alimentele care-i plac. Este vorba de regimul disociat rapid al lui William Howard Hay (1866-1940): secretul const n a separa proteinele de lipide i de glucide la fiecare mas. Deci poi mnca pine, dar nu mpreun cu carne, poi mnca carne, dar fr legume i poi mnca legume la discreie mpreun cu orice altceva. n acest caz, alimentaia poate fi dirijat de o cunoatere aprofundat a metabolismului corpului omenesc. Rezultatul practic: mpiedicarea creterii n greutate.
Figura 4: Aprofundarea cunoaterii nseamn rafinarea conceptelor i a legturilor dintre ele
Cunoaterea expertului este organizat, precis, punctual; a novicelui este nestructurat, amorf, global. Insistnd mai mult asupra acestui aspect, am putea spune c, pe msur ce se aprofundeaz un domeniu, se rafineaz conceptele domeniului i, ca urmare, i conexiunile ce se stabilesc ntre aceste concepte devin mai specifice (v. Figura 4). Tehnologia sistemelor expert face parte din domeniul Inteligenei Artificiale, acea ramur a informaticii care se preocup de dezvoltarea unor programe care s emuleze capaciti cognitive (rezolvarea de probleme, percepia vizual, nelegerea limbajului natural etc.). Tehnologia sistemelor expert a oferit deja soluii interesante n diverse domenii: chimie organic, medicin intern i infecioas, diagnosticare tehnic, prospeciuni miniere. Dei n fiecare din aceste domenii s-au putut realizata sarcini asemntoare utiliznd metode clasice de
34
programare, maniera de abordare a sistemelor expert este suficient de diferit pentru a merita o tratare aparte. Achiziionarea, formalizarea i includerea cunoaterii expert n sistemele artificiale reprezint scopul domeniului sistemelor expert.
2.2. Particulariti ale domeniului inteligenei artificiale

Exist o seam de trsturi care difereniaz domeniul inteligenei artificiale de alte domenii ale informaticii. Pot fi considerate definitorii cel puin urmtoarele trsturi: - problemele de inteligen artificial necesit, n general, un raionament predominant simbolic; - problemele se preteaz greu la soluii algoritmice. De multe ori soluia poate fi rezultatul unei cutri ntr-un spaiu al soluiilor posibile; - problemele care invit la investigaii tipice domeniului inteligenei artificiale sunt i cele care manipuleaz informaie incomplet ori nesigur; - nu se cere cu necesitate ca soluia s fie cea mai bun sau cea mai exact. Uneori e suficient dac se gsete o soluie, sau dac se obine o formulare aproximativ a ei; - n rezolvarea problemelor de inteligen artificial intervin adesea volume foarte mari de informaii specifice. Gsirea unui diagnostic medical nu poate fi algoritmizat, pentru c diferenele de date asupra pacientului duc la tipuri de soluii diferite; - natura cunoaterii ce se manipuleaz n problemele de inteligen artificial poate fi uor clasificat n procedural i declarativ: este diferena dintre cunoaterea pe care o posed un pianjen fa de cea a unui inginer constructor, sau diferena dintre cunoaterea pe care o posed un juctor de tenis i cea pe care o posed un bun antrenor. Cunoaterea unuia este instinctiv, ori n vrful degetelor, a celuilalt const ntr-un sistem de reguli. Pot fi rezolvate probleme de inteligen artificial prin algoritmi clasici? Cu siguran, dar soluiile vor fi probabil greoaie, greu generalizabile, nefireti i neelegante. Invers: pot fi rezolvate probleme clasice prin metode ale inteligenei artificiale? Iari lucrul este posibil, dar e ca i cum am folosi un strung ca s ascuim un creion. Un program de calcul al salariilor nu este un program de inteligen artificial, pe cnd un program care conduce un robot care mtur prin cas fr s distrug mobila sau unul care recunoate figuri umane sunt aplicaii ale inteligenei artificiale.
35
2.3. Prin ce difer un sistem expert de un program clasic?

Vom inventaria n cele ce urmeaz o seam de trsturi care caracterizeaz diferena dintre sistemele expert i programele clasice (v. i [16]). Modularitate. Cunoaterea care st la baza puterii de raionament a unui sistem expert este divizat n reguli. In felul acesta piese elementare de cunoatere pot fi uor adugate, modificate ori eliminate. Modularitatea reprezentrii cunoaterii asigur totodat i posibilitatea de meninere la zi a bazei de cunotine de ctre mai muli experi simultan. Ea poate reprezenta astfel opera unui colectiv de autori, adesea dezvoltndu-se pe o perioad lung de timp, simultan cu intrarea ei n folosin. Transparen. Un sistem expert poate explica soluia pe care o d la o anumit problem. Acesta este, de altfel, un factor de importan major n asigurarea credibilitii sistemelor expert puse s furnizeze diagnostice medicale, de exemplu. Pentru ca un medic s aib ncredere ntr-un diagnostic furnizat de main, el trebuie s l neleag. Soluii n condiii de incertitudine. Sistemele expert pot oferi, n general, soluii problemelor care se bazeaz pe date nesigure ori incomplete. Dintr-un anumit punct de vedere un sistem expert funcioneaz ca o mainrie care tie s niveleze asperitile, ori care poate trece cu uurin peste ele. Adesea un mecanism foarte fin este i foarte pretenios, el putnd funciona n exact condiiile pentru care a fost proiectat. Acesta este i cazul unui program clasic, pentru care neputina de a furniza valoarea exact a unui parametru l poate arunca pe o condiie de eroare. Un sistem expert este, n general, mult mai adaptabil pentru domenii difuze, adic este pregtit s fac fa fie unor cunotine incomplete ori incerte asupra domeniului de expertiz, fie unor date de intrare incomplete ori incerte. Categorii de sisteme expert. n funcie de domeniul lor de aplicabilitate, sistemele expert pot fi mprite n trei categorii importante (dup [16]): 1. Sisteme expert de diagnostic (sau clasificare). Problemele tratate de acestea pot fi recunoscute dup urmtoarele proprieti: - domeniul const din dou mulimi finite, disjuncte una coninnd observaii, cealalt soluii i dintr-o cunoatere complex, adesea incert i incomplet despre relaiile dintre aceste dou mulimi; - problema este definit printr-o mulime de observaii, mulime ce poate fi incomplet; - rezultatul diagnosticului (clasificrii) este selecia uneia sau mai multor soluii ale problemei;
36
- n cazul n care calitatea soluiei poate fi mbuntit prin considerarea unor observaii suplimentare, una din sarcinile clasificrii o reprezint gsirea acelei submulimii de observaii suplimentare care ar trebui cerute pentru a le completa pe cele existente. Exemple din aceast categorie sunt: diagnosticarea motoarelor de automobil unde sistemul expert este un program cuplat on-line cu dispozitive electronice care msoar diveri parametri tehnici ai motorului (consum de benzin, unghiul de reglare al camelor, capacitatea de ncrcare a bateriei etc) [36]. O valoare a unui anumit parametru, detectabil prin senzori ca fiind ieit din limitele normale, este apoi pus n legtur cu o disfuncionalitate a unui organ al motorului i, de aici, cu piesa care trebuie nlocuit sau cu efectuarea unui anumit reglaj; diagnosticarea hardware a calculatoarelor teste efectuate asupra calculatoarelor pot indica o funcionare eronat. Sistemul expert, de o complexitate mult mai mic dect n sistemele de diagnostic medical, de exemplu, este utilizat pentru indicarea componentei defecte ce se recomand a fi nlocuit; diagnosticarea reelelor de calculatoare sau a reelelor de distribuire a energiei mesaje de control, ori teste efectuate n anumite puncte importante, verific satisfacerea protocoalelor pe liniile de comunicaii ale reelelor ori integritatea fizic a reelelor cu configuraii complicate. Dac apare o defeciune, ea este nti semnalat. n continuare, iterativ, aria de investigaii este micorat pn la izolarea complet a defeciunii; identificarea zcmintelor minerale n geologie, recunoaterea ntr-o anumit zon a anumitor roci poate fi pus n legtur cu identificarea formaiunilor scoarei i, de aici, cu existena unor zcminte n arii adiacente. Cunotine de aceast natur pot ghida procesele de foraj pentru identificarea zcmintelor petrolifere ori de gaze naturale i astfel pot contribui la micorarea preurilor pentru identificarea ori demarcarea zcmintelor. 2. Sisteme expert de construcie: aici soluia nu mai poate fi gsit prin cutarea ntr-o mulime existent. Soluia este acum construit ca o secven de pai ori o configuraie de elemente intercondiionate (astfel vzut, o problem de diagnostic poate fi considerat un caz special al unei probleme de construcie). Definirea problemei nseamn precizarea condiiilor iniiale ale problemei, precizarea cerinelor asupra soluiei i a spaiului soluiilor (combinaiile teoretic posibile de obiecte elementare care respect ori nu cerinele). Exemple din aceast categorie: asistent de vnzri n comer un sistem expert poate recomanda produse unor clieni rspunznd ntrebrilor acestora i furniznd recomandri cu aceeai dezinvoltur ca un foarte experimentat agent comercial. Prin ntrebri abil alese el reuete s configureze un model al cumprtorului i, prin aceasta, s vin
37
n ntmpinarea dorinelor sale, construind oferte care s maximizeze ansele de vnzare a produselor; configurarea calculatoarelor un dialog cu clientul poate duce la determinarea configuraiei de calculator personal care s rspund cel mai adecvat nevoilor acestuia. 3. Sisteme expert de simulare: dac n sistemele expert de diagnostic i construcie soluia era selectat ori respectiv asamblat, simularea servete numai pentru prezicerea efectelor anumitor presupoziii asupra unui sistem. Un sistem este privit ca o unitate a crei comportare poate fi inferat din cunoaterea comportrii prilor componente. Simularea const din determinarea valorilor unor parametri de ieire din valorile date ale unor parametri de intrare. Adesea o simulare este cerut pentru a verifica dac soluia oferit de un sistem expert proiectat pentru funciona n diagnostic sau construcie este ntr-adevr cea dorit.
2.4. Exemple de sisteme expert

DENDRAL. Creaie a unei echipe de la Universitatea Stanford [4], [17], [25], conduse de Edward Feigenbaum, DENDRAL apare ntr-o prim versiune n 1965. Intenia construirii sistemului a fost de a demonstra c metodologia domeniului inteligenei artificiale poate fi utilizat pentru formalizarea cunoaterii tiinifice, domeniul de aplicabilitate al sistemului ns chimia organic. DENDRAL a oferit o demonstraie convingtoare a puterii sistemelor expert bazate pe reguli. Implementnd o cutare de tipul plan-generare-test asupra datelor din spectroscopia de mas i din alte surse, sistemul era capabil s prezic structuri candidate plauzibile pentru compui necunoscui, pentru anumite clase de compui performana sa rivaliznd cu aceea a unor experi umani. Dezvoltri ulterioare au dus la crearea sistemului GENOA un generator interactiv de structuri (1983). In DENDRAL ns cunoaterea expert era mixat cu algoritmica de rezolvare a problemei. Separarea complet a cunoaterii declarative de cea executorie a nsemnat un pas mare nainte nspre definirea unor tehnologii rapide de dezvoltare a sistemelor expert. META-DENDRAL (1970-76) [5] este un program care formuleaz reguli pentru DENDRAL, aplicabile domeniului spectroscopiei de mas. El a reuit s redescopere reguli cunoscute despre compui chimici dar a formulat i reguli complet noi. Experimentele cu META-DENDRAL au confirmat c inducia poate fi automatizat ca un proces de cutare euristic i c, pentru eficien, cutarea poate fi desprit n doi pai: o faz de aproximare a soluiei i una de rafinare a ei. MYCIN. Proiectat de Buchanan i Shortliffe la mijlocul anilor 1970 [6], [7] pentru a ajuta medicul n diagnosticul i tratamentul meningitelor i al infeciilor bacteriene ale sngelui. Adesea diagnosticarea unei infecii, mai ales aprut n
38
urma unei operaii, este un proces laborios i de lung durat. MYCIN a fost creat pentru a scurta acest interval i a furniza indicaii de diagnostic i tratament chiar n lipsa unor teste complete de laborator. Este remarcabil includerea n sistem a unei componente care s explice motivaiile rspunsului dat. Constructiv, MYCIN implementa o strategie de control cu nlnuire napoi ghidat de scop. Rezultat al experienei dobndite cu MYCIN, autorii lui creeaz apoi EMYCIN (Empty MYCIN sau Essential MYCIN), obinut din MYCIN prin golirea sa de cunotine dependente de domeniu. Acesta a fost considerat primul shell de sisteme expert, aadar un mediu de dezvoltare a acestora, cuprinznd motorul de inferene i utilitare de dezvoltare i consultare a bazei de cunotine. Sistemul a fost intens utilizat n Statele Unite i n afara lor, una dintre aplicaii fiind sistemul Personal Consultant dezvoltat de Texas Instruments. MYCIN i EMYCIN a stimulat crearea unei pleiade ntregi de sisteme expert sau medii de asisten n dezvoltarea sistemelor expert: TEIRESIAS [11] asistent de achiziie a cunotinelor de tip MYCIN; PUFF [19], [1] primul sistem construit cu EMYCIN, dedicat interpretrii testelor funcionale pulmonare pentru bolnavii cu afeciuni de plmni, n folosin la Pacific Medical Center din San Francisco; VM [12] Ventilator Manager, program de interpretare a datelor cantitative n unitile de terapie intensiv din spitale, capabil s monitorizeze un pacient n evoluia lui i s modifice tratamentul corespunztor; GUIDON [19] sistem utilizat n structurarea cunoaterii reprezentate prin reguli pentru scopuri didactice, n realizarea de sesiuni interactive cu studenii domeniu cunoscut sub numele Instruire Inteligent Asistat de Calculator (ICAI), experiena cu GUIDON a demonstrat necesitatea de a explicita cunoaterea depozitat n reguli pentru ca ea s devin efectiv pentru scopuri didactice). AM [2], [11], [23] este un program de nvare automat prin descoperiri utilizat n domeniul matematicilor elementare. Folosind o baz de 243 de euristici AM a propus concepte matematice plauzibile, a obinut date asupra lor, a observat regulariti i, completnd ciclul demonstraiilor din matematic, a gsit calea de a scurta unele demonstraii propunnd noi definiii. AM nu a reuit ns s gseasc el nsui noi euristici pentru a-i perfeciona, ntr-un fel de cerc vicios al ctigului, propria personalitate. Acest eec, pus pe seama principiilor sale constructive, a stimulat cercetrile pentru crearea unui sistem care s combine capacitatea de a face descoperiri automate, a lui AM, cu trstura de a formula noi euristici. S-a ajuns n acest fel la EURISKO (1978-1984) [24]. n orice domeniu este aplicat sistemul are trei niveluri la care poate lucra: cel al domeniului, pentru rezolvarea problemei, cel al inventrii de noi concepte ale domeniului i cel al sintezei de noi euristici care sunt specifice domeniului. A fost aplicat n matematica elementar, n programare pentru descoperirea de erori de programare, n jocuri strategice navale i n proiectarea VLSI.
39
Foarte multe sisteme expert au fost folosite cu succes n discipline ale pmntului, ca geologia, geofizica ori pedologia. O anumit vlv, n anii '80, a strnit sistemul PROSPECTOR [21] cnd s-a anunat c datorit lui s-a reuit descoperirea unui depozit mineral valornd 100.000.000 USD. Mult mai recent, COAMES (COAstal Management Expert System) este un sistem expert dezvoltat de Plymouth Marine Laboratory cu intenia de a studia zonele de coast de o manier holistic, prin coroborarea datelor de natur biologic, chimic i fizic ce completeaz tabloul riveran, maritim i atmosferic al acestora. Se ateapt ca acest sistem s contribuie la dimensionarea corect a managementului mediului [30]. Sute de sisteme expert au fost descrise n cri sau reviste dedicate domeniului, cele mai importante dintre reviste fiind: - Expert Systems with Applications, Pergamon Press Inc. - Expert Systems: The International Journal of Knowledge Engineering, Learned Information Ltd. - International Journal of Expert Systems, JAI Press Inc. - Knowledge Engineering Review, Cambridge University Press, - International Journal of Applied Expert Systems, Taylor Graham Publishing Pentru cercettorii acestui domeniu este din ce n ce mai evident c problema fundamental n nelegerea inteligenei nu este identificarea ctorva tehnici foarte puternice de prelucrare a informaiei, ci problema reprezentrii i manipulrii unor mari cantiti de cunotine de o manier care s permit folosirea lor efectiv i inter-corelat. Aceast constatare caracterizeaz i tendinele fundamentale de cercetare: ele nu sunt ndreptate att spre descoperirea unor tehnici noi de raionament, ct spre probleme de organizare a bazelor de cunotine foarte mari ori de formalizare a cunotinelor disipate n baze de date n sisteme de reguli (data mining). Nu este, desigur, lipsit de interes i problema achiziiei cunoaterii din medii naturale, cu precdere din experiena uman [3]. Problema aici este cum ar putea fi identificat, formalizat i transpus n reguli expertiza specialitilor umani? Responsabilul cu aceast sarcin este, n general, cunoscut sub numele de inginer de cunoatere sau inginerul bazei de cunotine. El este cel care trebuie s gseasc limbajul comun cu specialiti din domeniul viitorului sistem expert, care trebuie s-i conving s colaboreze i s poarte un dialog cu ei, pentru ca apoi s aduc la o form convenabil i s introduc n sistemul artificial informaiile furnizate de acetia [22].
40
2.5. Evaluarea oportunitii sistemelor expert

Construcia unui sistem expert care s fac fa unei probleme reale este un proces, cel mai adesea, laborios. De aceea el presupune o faz de pregtire n care s se aprecieze gradul n care acest efort se justific. Tabelul de mai jos este reprodus din [32] (care la rndul su preia din [34]) conine 40 de criterii ponderate de evaluare a oportunitii construirii unui sistem expert. Criteriile sunt clasificate n eseniale i dezirabile, cele eseniale avnd ponderi mai mari dect cele dezirabile. Criterii eseniale Nr. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 Pondere 1 1 1 1 0,7 0,8 1 0,7 1 0,8 1 0,7 0,8 1 1 1 0,8 0,8 0,8 0,8 0,7 1 Utilizatorii sistemului ateapt beneficii mari n operaii de rutin. Utilizatorii au pretenii realiste asupra mrimii i limitelor sistemului. Proiectul are un mare impact managerial. Sarcina nu necesit o procesare a limbajului natural. Sarcina este bazat pe cunoatere ntr-o msur destul de mare, dar nu exagerat. Sarcina este de natur euristic. Sunt disponibile cazuri de test pentru toate gradele de dificultate. Sistemul se poate dezvolta n etape (sarcina e divizibil). Sarcina nu necesit de loc aprecieri de bun-sim, sau necesit numai foarte puine. Nu se cer soluii optime ale problemelor. Sarcina va fi relevant i n viitorul apropiat. Nu e esenial ca sistemul s fie gata n scurt timp. Sarcina e uoar, dar nu foarte uoar pentru sisteme expert. Exist un expert. Expertul este cu adevrat valoros. Expertul este implicat n proiect pe toat durata lui. Expertul e cooperant. Expertul e coerent n exprimare. Expertul are o anumit experien n proiectare. Expertul folosete raionament simbolic. Cunoaterea expert este dificil, dar nu foarte dificil de transferat (de exemplu ea ar putea fi predat). Expertul rezolv problemele prin aptitudini cognitive, nu motorii sau senzoriale.
41
23 24
1 1
Experi diferii sunt de acord asupra a ceea ce nseamn o soluie bun. Expertul nu trebuie s fie creativ n rezolvarea problemei.
Criterii dezirabile 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 0,8 0,4 0,4 0,4 0,4 0,4 0,4 0,5 0,8 0,5 0,3 0,4 0,3 0,4 0,4 0,2 Conducerea va susine proiectul dup terminarea lui. Introducerea sistemului nu va necesita mult reorganizare. Utilizatorul poate interaciona cu sistemul. Sistemul i poate explica raionamentul utilizatorului. Sistemul nu pune prea multe ntrebri i nu pune ntrebri ce nu sunt necesare. Sarcina era cunoscut anterior ca fiind problematic. Soluiile problemelor sunt explicabile. Sarcina nu necesit un timp de rspuns prea scurt. Exist sisteme expert de succes care se aseamn cu sistemul planificat. Sistemul planificat poate fi folosit n mai multe locuri. Sarcina e primejdioas sau, cel puin, neatractiv pentru oameni. Sarcina include i cunoatere subiectiv. Expertul nu va fi disponibil n viitor (de exemplu, datorit pensionrii). Expertul e capabil s se identifice intelectual cu proiectul. Expertul nu se simte ameninat. Cunoaterea folosit de expert la rezolvarea problemelor este slab structurat sau deloc.
Pentru a aprecia oportunitatea construirii unui sistem expert, trebuie atribuite scoruri ntre 1 i 10 rspunsurilor la ntrebri; scorurile trebuie ponderate cu coeficienii ataai i calculat media. Dac nota obinut este peste 7,5 nseamn c efortul merit a fi fcut. O not ntre 6 i 7,5 semnaleaz costuri mari i productivitate mic, invitnd la meditaie i la ncercarea de a reproiecta specificaiile pentru a mbunti acele rspunsuri care au avut cea mai mare contribuie la acest rezultat slab. O not mai mic de 6 indic cu trie renunarea la tentativ.
Partea a II-a Organizarea i funcionarea unui sistem expert

Organizarea unui sistem expert nlnuirea regulilor n motoarele de inferen Regimul de lucru tentativ Confruntarea rapid de abloane: algoritmul RETE
Capitolul 3
Organizarea unui sistem expert
Premisa principal pe care se bazeaz concepia constructiv a sistemelor expert este aceea c un expert uman i construiete soluia la o problem din piese elementare de cunoatere, stpnite de acesta anterior enunului problemei, i pe care expertul le selecteaz i le aplic ntr-o anumit secven. Pentru a furniza o soluie coerent la o problem dat, cunoaterea cuprins ntr-un anumit domeniu trebuie s fi fost iniial formalizat, apoi reprezentat ntr-o form adecvat proceselor de inferen i, n final, manipulat n conformitate cu o anumit metod de rezolvare de probleme. Se pune astfel n eviden diviziunea dintre seciunea care pstreaz reprezentarea cunoaterii asupra domeniului ct i a datelor problemei baza de cunotine i seciunea responsabil cu organizarea proceselor infereniale care s implice aceste cunotine sistemul de control (sau motorul de inferene). Acestea sunt, tradiional, cele dou module principale ale unui sistem expert (v. Figura 5).
Baza de cunotine Sistemul de control
Figura 5: Componentele principale ale unui sistem expert
Aceste dou module formeaz inima unui sistem expert. n jurul lor alte componente realizeaz funcionalitatea complex a unui sistem expert, dup cum urmeaz: - interfaa de comunicaii controleaz dialogul sistemului expert cu exteriorul. Prin intermediul acesteia, sistemul expert preia parametrii problemei pe msur ce componenta de control are nevoie de ei, fie interognd un utilizator uman, fie prelundu-i direct dintr-un proces industrial. Dac interfaa realizeaz un dialog cu un partener uman, atunci sistemul se numete interactiv, n caz contrar el este un sistem implantat (embedded system); - componenta de achiziie a cunotinelor permite introducerea i, ulterior, modificarea cunotinelor din baz. O funcionalitate minim trebuie s permit selecia, introducerea, modificarea i tiprirea regulilor i a faptelor. Procesul de achiziie a cunotinelor fiind esenial pentru reuita unei aplicaii, componentele de
46
achiziie ataate shell-urilor de sistem expert devin tot mai evoluate, putnd ncorpora trsturi de nvare, de generalizare, sau putnd lansa un proces inferenial n scopul verificrii consistenei ori completitudinii bazei; - componenta explicativ asigur transparena n funcionare a sistemului expert. Ea ajut att utilizatorul care caut o fundamentare a soluiei oferite de sistem, ct i pe inginerul bazei de cunotine n faza de depistare a erorilor. Baza de cunotine, care este componenta sistemului responsabil cu depozitarea de informaii asupra domeniului de expertiz i a problemei de rezolvat, este la rndul ei format din: - baza (ori colecia) de fapte: memoreaz datele specifice problemei de rezolvat, informaii de natur, n general, volatil, pentru c, pe parcursul unui proces de inferen, se pot aduga fapte noi, iar altele vechi pot fi retrase. - baza (ori colecia) de reguli: cuprinde piesele de cunoatere care vor ghida procesele de raionament ale sistemului. Recunoatem aici o seciune principal, care trebuie s cuprind cunoaterea specific domeniului, i o seciune dedicat meta-cunoaterii (sau regulilor de control) acel set de reguli care realizeaz tranziiile ntre faze ori ajut la derularea operaiilor auxiliare. - agenda (numit i memoria de lucru): depoziteaz informaii legate de activarea regulilor, instane de reguli, legri de variabile etc, toate acestea fiind necesare derulrii proceselor de inferen. Sistemul de control este responsabil cu desfurarea proceselor de inferen. El codific una sau mai multe strategii de aplicare a regulilor (v. i [20]).
3.1. Baza de cunotine: faptele

Faptele din baz codific obiecte, configuraia lor de nsuiri i valori particulare ale acestor nsuiri. n general, exist dou tipuri de cunotine ce se pot memora n seciunea de fapte a bazei de cunotine: declaraii asupra structurii obiectelor (precum numele generice ale obiectelor, configuraia lor de atribute i tipurile de valori pe care le pot avea atributele) i declaraii asupra coninutului informaional al obiectelor (numele ce le individualizeaz, valorile atributelor). Dintr-un alt punct de vedere, informaiile coninute n baza de cunotine pot fi permanente (cum sunt de exemplu declaraii care configureaz obiectele, dar i declaraii de coninut asupra unor obiecte imuabile n timpul procesrii) sau volatile (date ce sunt de utilitate temporar sau care contribuie la derularea procesului de inferen n anumite faze i trebuie apoi terse pentru a nu ncrca inutil memoria). Astfel, pentru un domeniu medical, anumite reguli pot memora diverse simptome ale bolnavilor. Ca s exprimm faptul c pacientul Ionescu are gtul eapn, putem utiliza un fapt care s aib codificate ntr-un anume fel informaiile privitoare la numele pacientului Ionescu, la simptomul de interes mobilitate_gt
47
i la valoarea acestuia mic. Maniera practic de codificare difer att de la un limbaj bazat de reguli la altul, ct i n funcie de opiunea de a utiliza codificri nestructurate sau obiectuale (n spiritul paradigmei orientate obiect). ntr-un fel sau altul, codificarea trebuie s cuprind urmtoarele informaii:
[nume_pacient = Ionescu, mobilitate_gt = mic]
ntr-o aplicaie de construcii geometrice n care avem nevoie s codificm puncte i triunghiuri, de exemplu, am putea exprima faptul c A, B i C sunt puncte i c ABC este un triunghi, ntr-o multitudine de feluri, dar, oricum ar fi ea, aceast informaie trebuie s ne permit s identificm numele punctelor i numele triunghiului:
[punct = A] [punct = B] [punct = C] [triunghi = ABC]
ntr-o aplicaie de fizic ce-i propune s calculeze circuite n curent alternativ se opereaz cu impedane, capaciti i rezistene. Cum cea mai fireasc reprezentare a acestora este ca numere complexe, trebuie avut n vedere o manier de a reprezenta diverse numere complexe. Dac 100 + 80 i este un astfel de numr, atunci o reprezentare trebuie s cuprind minimum partea real i pe cea imaginar, adic:
[100, 80]
Important pentru organizarea faptelor din baza de cunotine este observaia c un fapt este ntotdeauna reprezentat cu unicitate. Aceast observaie are dou implicaii: una legat de maniera de operare a sistemului de control care nu va permite includerea simultan n baz a dou fapte identic structurate i una legat de pstrarea consistenei informaionale a bazei i care adaug o responsabilitate programatorului: acesta trebuie s aib grij ca baza s nu cuprind informaii contradictorii. Legat de prima observaie, n exemplul medical considerat sistemul nu va permite mobilarea bazei cu dou fapte identice (n sens sintactic), ca de exemplu:
[pacient = Ionescu, mobilitate_gt = mic] [pacient = Ionescu, mobilitate_gt = mic]
Legat de a doua observaie, programatorul nu trebuie s permit existena simultan a unor fapte de forma:
48
[pacient = Ionescu, mobilitate_gt = mic] [pacient = Ionescu, mobilitate_gt = normal]
care, altfel, ar putea fi acceptate de sistem, pentru c, din punct de vedere strict sintactic, ele sunt diferite. Dac ns considerente legate de modelarea evoluiei simptomelor pacienilor ntr-o perioad de timp impun necesitatea de a avea ambele fapte n baz, pentru c, de exemplu, Ionescu avea iniial gtul eapn pentru ca, n urma tratamentului, acesta s fi revenit la normal, atunci trebuie adugat o informaie asupra datei prelurii observaiilor, adic ceva de genul:
[data = 22-dec-01, pacient = Ionescu, mobilitate_gt = mic] [data = 18-ian-02, pacient = Ionescu, mobilitate_gt = normal]
Observaia asupra unicitii nregistrrilor din baza de fapte oblig la o reconsiderare a modului de reprezentare a numerelor complexe n exemplul preluat din fizic, pentru c foarte repede vom constata c o structur a faptului ce memoreaz numere complexe n care putem identifica doar componenta real i pe cea imaginar face imposibil existena simultan n baz a dou numere complexe egale (de exemplu, caracteriznd dou componente electrice de impedane egale). Devine astfel evident c trebuie adugat n reprezentare o informaie care s identifice unic un numr complex:
[complex = c1, real = 100, imaginar = 80] [complex = c2, real = 100, imaginar = 80]
3.2. Regulile
Regulile codific transformrile ce trebuie operate asupra obiectelor din baza de cunotine. O regul este o entitate de forma:
<nume regul>: [<comentariu>] dac <condiii> atunci <aciuni>
Adesea condiiile se mai numesc i partea stng a regulii, iar aciunile partea sa dreapt. Activitatea sistemului de control legat de o regul poate fi exprimat simplificat astfel: dac partea de condiii este satisfcut de faptele existente n baza de cunotine, atunci aciunile pot fi executate. Aciunile dicteaz modificrile ce trebuie operate asupra bazei. Iat un exemplu de regul dintr-un domeniu medical (exemplu adaptat dup [32]):
49
diagnostic_meningit: dac pacientul are gtul eapn, pacientul are temperatur mare, pacientul are dese pierderi de cunotin, atunci introdu n baz informaia c pacientul e suspect de meningit.
Pentru ca aceast regul s fie luat n considerare de ctre componenta de control n vederea aplicrii, sistemul trebuie s gseasc n baza de cunotine trei fapte care, ntr-un fel sau altul, s precizeze c mobilitatea gtului pacientului X este mic, c temperatura pacientului X este mare i c pierderile de cunotin ale pacientului X sunt frecvente, adic ceva de genul:
[pacient = Ionescu, mobilitate_gt = mic] [pacient = Ionescu, temperatur = mare] [pacient = Ionescu, pierderi_cunotin = frecvente]
n continuare, dac sistemul de control decide s aplice aceast regul, n baza de fapte va fi adugat un nou fapt, ce va memora c diagnosticul posibil al pacientului Ionescu este meningit:
[pacient = Ionescu, diagnostic_posibil = meningit]
n aplicaia de construcii geometrice sugerat mai sus, urmtoarea indicaie de construcie:

construcie_triunghi: dac A, B i C sunt trei puncte diferite ntre ele atunci introdu n baz informaia c ABC este un triunghi
poate fi exprimat ca o regul. Aplicarea ei, amorsat de descoperirea n baz a trei obiecte de tip punct geometric, ar trebui s duc la construirea unui obiect de tip triunghi care s aib vrfurile constituite din cele trei obiecte de tip punct. n aplicaia de fizic, urmtoarea afirmaie poate fi pus sub forma unei reguli:
adunare_numere_complexe: dac c1 = a1 + i*b1 este un numr complex i
50
c2 = a2 + i*b2 este un numr complex, diferit de primul i se dorete efectuarea sumei dintre c1 i c2 atunci introdu n baz informaia c suma dintre c1 i c2 este dat de numrul complex c = (a1 + a2) + i*(b1 + b2).
Aplicarea ei, motivat de gsirea n baz a dou numere complexe i de o aseriune care dicteaz necesitatea efecturii sumei lor, ar trebui s adauge n baza de cunotine un nou fapt de tip numr complex i care s aib calculate prile real i imaginar n maniera tiut.
3.3. Variabile i abloane n reguli

n general, n definiiile de reguli apar variabile. Domeniul lexical al unei variabile (zona din program n care semnificaia variabilei este aceeai) este strict limitat la o regul. Astfel, n definiia regulii din exemplul medical, apare firesc s notm ntr-un anumit fel pacientul; n exemplul preluat din geometrie, numele punctelor vor fi date de variabile, iar n exemplul din fizic, att numerele complexe ct i prile lor reale i imaginare vor fi notate cu variabile. Este clar c regula de diagnostic medical dat mai sus nu este specific pacientului Ionescu, i nici unui alt pacient anume, ci este aplicabil oricrui pacient. Acest oricare pacient, trebuie, pe de o parte, s apar n exprimarea regulii, pentru ca cele trei fapte ce se caut n baz s fie legate ntre ele prin informaia comun asupra numelui pacientului (ar fi neplcut ca gtul eapn al lui Ionescu s fie coroborat cu temperatura mare a lui Popescu i cu pierderile de cunotin ale lui Georgescu pentru a trage concluzia c cineva are meningit). Pe de alt parte, acest oricare pacient, care a fost gsit n baz ca satisfcnd simultan condiiile prii stngi, este exact acela asupra cruia se va trage concluzia de meningit. Cu alte cuvinte, regula dat mai sus ar trebui s arate cam aa:
diagnostic_meningit: dac [pacient = X, mobilitate_gt = mic] [pacient = X, temperatur = mare] [pacient = X, pierderi_cunotin = frecvente] atunci introdu n baz [pacient = X, diagnostic_posibil = meningit]
X, n aceast exprimare, este o variabil. Condiia [pacient = X, mobilitate_gt = mic] din partea stng a regulii se aseamn cu faptul [pacient = Ionescu, mobilitate_gt = mic] din baz dar nu este
51
identic cu el. Aceast condiie constituie un ablon. Suntem n cazul unui ablon cu variabile. El exprim succint condiia ca n baz s existe un fapt care s se potriveasc cu modelul indicat de ablon. Dac un ablon nu conine variabile, el trebuie s fie identic cu un fapt din baz pentru ca partea corespunztoare din condiia regulii s fie verificat. Sistemul de control ncearc s confrunte partea de condiii a regulii cu faptele din baz. Regula se va considera aplicabil dac n baz se gsesc simultan trei fapte care s se potriveasc cu cele trei condiii, cum sunt cele date mai sus asupra pacientului Ionescu. Dac acest lucru se ntmpl, atunci un fapt nou este adugat n baz, conform ablonului din partea de aciuni a regulii. Variabila joac acum rolul de cru (transportor) de informaii din partea stng spre partea dreapt. Regula din aplicaia de construcii geometrice, poate fi acum rescris utiliznd un format al condiiilor apropiat de cel n care au fost definite faptele:
construcie_triunghi: dac [punct = A] [punct = B] i B A [punct = C] i C A i C B atunci introdu n baz [triunghi = ABC]
unde A, B i C sunt variabile. La fel, n aplicaia de fizic, regula de adunare a dou numere complexe poate fi exprimat ntr-o form apropiat de urmtoarea:
regula adunare_numere_complexe: dac [complex = c1, real = a1, imaginar = b1] [complex = c2, real = a2, imaginar = b2] i c1 c2 se dorete efectuarea sumei dintre c1 i c2 atunci introdu n baz informaia c suma dintre c1 i c2 este dat de numrul complex [complex = c, real = a1+a2, imaginar = b1+b2]
iar simbolurile c1, c2, c, a1, a2, b1 i b2 sunt toate variabile.
52
3.4. Legri de variabile i instane de reguli

n general sunt trei situaii n care se pot afla faptele din baza de cunotine fa de condiiile din partea stng a unei reguli: nu exist o combinaie de fapte din baz care s verifice condiiile, exist exact un mod n care faptele din baz verific condiiile sau exist mai multe moduri n care acestea s le verifice. Procesul de verificare a prii de condiii a unei reguli n inteligena artificial este numit confruntare de abloane. Astfel, pentru exemplul de diagnostic medical de mai sus, presupunnd o baz de fapte consistent i care nu deine informaii temporale (intereseaz, spre exemplu, datele asupra pacienilor la momentul internrii ntr-o secie a unui spital), vor exista attea posibiliti de aplicare a regulii ci pacieni ce manifest simultan simptomele menionate n regul sunt nregistrai n baz. n cazul exemplului de construcie geometric, dac baza de fapte cuprinde mai puin de trei definiii de puncte, regula nu poate fi aplicat. Dac baza include exact trei definiii de puncte atunci regula se poate aplica n nu mai puin de ase moduri. ntr-adevr, presupunnd punctele notate n baz M, N i P, atunci cu ele se pot forma triunghiurile MNP, MPN, NMP, NPM, PMN i PNM, n funcie de ordinea n care se consider realizate identificrile dintre numele punctelor geometrice din baz i notaiile punctelor n regul, respectiv A, B i C. Totodat, dac n exemplul de adunare a numerelor complexe de mai sus, presupunem existena n baz a dou definiii de numere complexe, s zicem:
[complex = z1, real = 200, imaginar = 150] i [complex = z2, real = 300, imaginar = 150]
atunci vor exista dou maniere de realizare a sumei, dup cum c1 din definiia condiiilor regulii va fi identificat cu z1 i c2 cu z2 sau invers. Aadar, este ca i cum o regul ar fi multiplicat de ctre componenta de control n mai multe instane. Ele apar ntotdeauna cnd n partea de condiii a unei reguli se regsesc mai multe condiii care sunt exprimate n forme similare (abloane structural identice3). Practic o instan a unei reguli R const din numele regulii mpreun cu faptele ce verific condiiile regulii i cu legrile variabilelor la valori. Aceste legri au loc la confruntarea prii de condiii a regulii cu o combinaie de fapte din baz. Vom nota o instan de regul ntre paranteze unghiulare, n forma:
<nume_regul; f1, ... fn; v1 a1, ... vk ak>
Dou abloane sunt structural identice dac ele sunt identice cu excepia numelor variabilelor.
53
unde prin f1, ... fn vom nelege faptele ce verific condiiile regulii, iar prin vi ai vom nelege legarea variabilei vi la valoarea ai (i {1, ..., k}). Astfel, considernd faptele de mai sus ce definesc simptomele pacientului Ionescu i regula diagnostic_meningit, sistemul de control va produce o unic instan a acesteia:
<diagnostic_meningit, X Ionescu>
n acelai mod, faptele ce descriu punctele A, B i C mpreun cu regula construcie_triunghi provoac instanierile:
<construcie_triunghi, <construcie_triunghi, <construcie_triunghi, <construcie_triunghi, <construcie_triunghi, <construcie_triunghi, A A A A A A M, M, N, N, P, P, B B B B B B N, P, M, P, M, N, C C C C C C P> N> P> M> N> M>
iar faptele ce definesc numerele complexe z1 i z2 mpreun cu regula adunare_numere_complexe duc la apariia instanelor:
<adunare_numere_complexe, c1 z1, a1 200, b1 150, c2 z2, a2 300, b2 150> <adunare_numere_complexe, c1 z2, a1 300, b1 150, c2 z1, a2 200, b2 150>
n Capitolul 7 Primii pai ntr-un limbaj bazat pe reguli: CLIPS din partea a treia a crii se vor detalia aciunile ce au loc n componenta de control la instanierea regulilor.
3.5. Agenda
Agenda este structura de date care memoreaz la fiecare moment instanele regulilor. Aceste instane sunt dispuse ntr-o list, instana de regul aflat pe prima poziie fiind aceea ce va fi apoi utilizat, aa cum vom vedea n seciunea urmtoare. Exist dou criterii care dicteaz ordinea instanelor regulilor din agend. Primul este prioritatea declarat a regulilor, al doilea strategia de control. Urmnd aceste dou criterii, instanele regulilor ce-i satisfac condiiile la un moment dat sunt nti ordonate n agend n ordinea descresctoare a prioritilor declarate, iar cele de prioriti egale, n ordinea dat de strategia de control.
54
3.6. Motorul de inferene

Componenta de control a unui sistem expert mai este numit i motor de inferene pentru c, n cursul execuiei, la fel ca ntr-un proces inferenial, sistemul este capabil s genereze fapte noi din cele cunoscute, aplicnd reguli. Un mecanism elementar de aprindere a regulilor lucreaz conform urmtorului algoritm, care descrie cel mai simplu ciclu al unui motor de inferene ca un motor n trei timpi: - faza de filtrare: se determin mulimea tuturor instanelor de reguli filtrate (MIRF) corespunztoare regulilor din baza de reguli (BR) care i pot satisface condiiile pe faptele din baza de fapte (BF). Dac nici o regul nu a putut fi filtrat, atunci motorul se oprete. Dac exist cel puin o instan de regul filtrat, atunci se trece n faza urmtoare; - faza de selecie: se selecteaz o instan de regul R MIRF. Dac MIRF conine mai mult de o singur instan, atunci selecia se realizeaz prin aplicarea uneia or a mai multor strategii de conflict (v. seciunea rezoluia conflictelor), dup care se trece n faza urmtoare; - faza de execuie: se execut partea de aciuni a regulii R, cu rezultat asupra bazei de fapte. Se revine n faza de filtrare. Anumite shell-uri de sisteme expert recunosc o sub-faz a fazei de filtrare, numit faza de restricie, n care se determin, plecnd de la baza de fapte BF i de la baza de reguli BR, submulimile BF1 BF, respectiv BR1 BR, care, a priori, merit s participe la acest ciclu inferenial. Apoi MIRF este determinat ca mulimea instanelor regulilor aparinnd BR1 care-i satisfac condiiile pe faptele din BF1. O tehnic curent pentru realizarea restriciei const a mpri cunotinele disponibile n familii de reguli, care s fie apoi utilizate n funcie de contextul n care a ajuns raionamentul (de exemplu ntr-un sistem de urmrire a funcionrii unui proces pot exista etapele detecie, diagnostic i intervenie) sau n funcie de tipul specific de problem ce trebuie soluionat (de exemplu, ntr-o aplicaie de diagnostic medical regulile ce in de bolile infantile pot fi desprite de cele ce analizeaz boli ale adulilor, iar faptele ce in de analiza sngelui pot fi separate de celelalte). Shell-urile evoluate de sisteme expert ofer inginerului bazei de cunotine posibilitatea de separare n clase a setului de reguli i, analog, a mulimii de fapte. Cel mai adesea, pentru mai multe cicluri consecutive se folosesc reguli aparinnd aceleiai submulimi. n consecin, pentru a economisi timp, faza de restricie poate fi exterioar unui ciclu, ea indicnd motorului s lucreze cu o seciune sau alta a bazei de reguli, respectiv de fapte, pe o etap anumit a derulrii raionamentului. Motoarele de inferen implementeaz o proprietate numit refractabilitate, care se manifest n faza de filtrare: o regul nu este filtrat mai mult de o singur dat pe un set anume de fapte. Fr aceast proprietate, sistemele expert ar fi
55
angrenate adesea n bucle triviale ce ar aprea ori de cte ori aciunile prii drepte ale unei reguli nu ar produce modificri n baz.
Capitolul 4
nlnuirea regulilor n motoarele de inferen
4.1. Cutarea soluiei n problemele de inteligen artificial

Problemele de inteligen artificial se aseamn prin aceea c toate presupun existena unei stri iniiale cunoscute i a uneia sau mai multor stri finale precizate exact sau doar schiate prin condiii pe care ele ar trebui s le satisfac, iar rezolvarea problemei const n identificarea unui traseu ntre starea iniial i o stare final. Uneori gsirea soluiei nseamn descifrarea unui drum care s uneasc o stare iniial de una final, iar alteori numai descoperirea strii finale (v. Figura 6).
tranziie stare fundtur
stare final posibil
stare final atins stare iniial traseu
dimensiunea spaiului strilor
Figura 6: Spaiul strilor n problemele de inteligen artificial
Acest lucru face ca o problem de inteligen artificial s fie una de cutare ntr-un spaiu al strilor. n funcie de dimensiunea acestui spaiu se utilizeaz
58
diferite metode pentru a eficientiza procesul de navigare. n limbajul domeniului inteligenei artificiale, aceste metode se mai numesc i strategii. Exist mai multe tipuri de strategii, dar ele sunt clasificate n dou mari clase: irevocabile i tentative. O strategie irevocabil este una n care orice micare n spaiul strilor este ireversibil, n care nu exist cale de ntoarcere n caz de greeal. O alegere o dat fcut rmne definitiv, iar dac ntr-un pas ulterior unei astfel de alegeri motorul ajunge ntr-un impas, el se va opri, aadar, fr a oferi posibilitatea de a mai fi explorate alte ci spre soluie. Dimpotriv, o strategie tentativ este una ovitoare, n care o micare ce se dovedete greit poate fi ndreptat. Aplicarea unei strategii este necesar pentru a decide ce e de fcut n situaiile n care dintr-o stare anumit exist mai multe ci de a trece ntr-o alt stare i n situaiile n care, dei nu s-a ajuns ntr-o stare final, nu mai exist nici o posibilitate de a face o alt tranziie. Totodat, parcurgerea spaiului strilor poate fi fcut plecnd de la strile iniiale pentru a avansa ctre cele finale, i atunci avem de a face cu o cutare (sau nlnuire) nainte, invers, plecnd de la ceea ce se consider a fi o stare final pentru a regsi starea iniial, i atunci avem de a face cu o cutare (sau nlnuire) napoi, sau combinnd o cutare nainte cu una napoi ntr-o cutare (sau nlnuire) mixt. n cele ce urmeaz vom discuta n amnunt tipul de nlnuire a regulilor nainte i vom face o prezentare scurt a celorlalte dou tipuri de cutri. Termenul de nlnuire folosit n sintagmele de mai sus este utilizat n direct legtur cu aplicarea domeniului inteligenei artificiale la sistemele expert, unde tranziia ntre dou stri nseamn aplicarea unei reguli. Faptele din baza de cunotine configureaz o stare a sistemului n orice moment din dezvoltarea inferenelor. Regulile bazei de reguli i verific partea de condiii pe faptele din baza de cunotine, deci pe starea curent. Rezult un numr oarecare de instane de reguli, adic de reguli potenial aplicabile. Aplicarea lor ar configura evantaiul de stri n care se poate tranzita din starea curent. n Figura 7 strile sunt notate ca noduri, starea din care se pleac este numit stare surs, iar starea n care se ajunge dup aplicarea regulii este numit stare destinaie. Este posibil ca instane diferite, aplicate strii surs, s produc aceeai stare destinaie, ceea ce nseamn c tranziiile ntre stri sunt caracterizate, n general, de mulimi de instane. De aceea etichete ale arcelor n notaia de graf pot fi liste de instane. Mulimea etichetelor arcelor care pleac din nodul stare curent este, astfel, agenda.
59
instane de reguli stare surs (curent) stri destinaie (poteniale)
agenda Figura 7: Instanele regulilor aplicabile n starea curent pot tranzita starea sistemului ntr-o mulime de stri poteniale
4.2. nlnuirea nainte

ntr-un motor cu nlnuire nainte se pleac cu fapte ce precizeaz ipoteze iniiale de lucru i se cere s se ajung la o concluzie. Aceasta poate fi cunoscut, i atunci cerina este de a o verifica, sau necunoscut, i atunci cerina este de a o gsi. n general verificarea concluziilor este o caracteristic a motoarelor implantate pe sisteme de diagnostic sau simulare, pe cnd gsirea unei stri noi este o caracteristic a sistemelor expert de construcie. ntr-un astfel de sistem, n principiu, nu se cunoate a priori configuraia spaiului strilor, dar o parte a acestui spaiu este relevat de rulare. Pentru a exemplifica funcionarea unui motor n nlnuire nainte, s considerm urmtoarea colecie de reguli (exemplu adaptat):
Ex. 1
R1: R2: R3: R4: R5: R6:
dac dac dac dac dac dac
A, B, C, B, F, I,
atunci E E, atunci E, atunci D, atunci G, atunci atunci H
F G G H
i urmtoarea colecie de fapte iniiale: {A, B, C, D, I}. Cerina este de a proba faptul H. Existena unui nume de fapt n partea de condiii a unei reguli (partea stng) semnific cerina ca acel fapt s se gseasc n baz. Existena lui n partea dreapt nseamn c, la aprinderea regulii, acel fapt este introdus n baz.
60
Putem simula activitatea sistemului de control cu nlnuire nainte pe acest exemplu utiliznd un graf I-SAU4 care s modeleze baza de reguli, ca n Figura 8:
R1 A B C D I R6 R3 R4 G R5 H E R2 F
Figura 8: Graful I-SAU ataat bazei de reguli a exemplului Ex. 1
n aceast figur am folosit urmtoarele convenii de notaie: cu cerculee mari am notat faptele, cu cerculee mici regulile, sgeile care neap o regul semnific un I logic pentru realizarea prii de condiii a regulii (pentru c o regul poate fi aplicat doar dac toate condiiile date de partea ei stng sunt realizate) iar sgeile care neap un fapt semnific un SAU logic pentru introducerea faptului n baz (pentru c un fapt poate fi introdus n baz de oricare dintre regulile care l specific n partea dreapt). Un fapt odat introdus n baz se consider a fi adevrat. Cu aceste convenii nodurile-regul sunt noduri I iar nodurile-fapte sunt noduri SAU. n secvena de grafuri din Figura 9 se indic o posibil ordine n aplicarea regulilor. Pe fiecare rnd este desenat graful I-SAU, care oglindete situaiile din faza de selecie, urmat de situaia existent imediat dup execuie. Primul graf arat aadar situaia n faza de selecie iniial. Faptele aflate n baz sunt prezentate ntr-o culoare nchis, regulile potenial active (filtrate) n gri deschis, iar cele efectiv aprinse (selectate i executate) n negru.
Grafurile I-SAU, grafuri orientate folosite n logic pentru demonstrarea valorilor de adevr ale formulelor logice, sunt formate din noduri I i noduri SAU. Un nod I este adevrat dac toate nodurile din care pleac arcele ce-l neap sunt adevrate. Un nod SAU este adevrat dac mcar unul dintre nodurile din care pleac arcele ce-l neap este adevrat.
61
A B C D I
R R R R
F G H A B C D I
R R R R
F G H
A B C D I
R R R R
F A G R H B C D I
R R R R
F G H
A B C D I
R R R R
F G H A B C D I
R R R R
F G H
A B C D I
R R R R
F G H A B C D I
R R R R
F G H
Figura 9: O secven posibil de aprinderi de reguli i includeri de fapte n baz pentru exemplul Ex.1
Trebuie evitat confuzia de a asimila reprezentarea sub form de graf a spaiului strilor, prezentat la nceputul acestui capitol, cu graful I-SAU pe care lam utilizat n notarea bazei de cunotine iniiale i n simularea aprinderii regulilor. Pentru a clarifica total lucrurile, s elaborm o parte a spaiului strilor pentru exemplul de mai sus, relevat de secvena de aprinderi de reguli indicat n Figura 9 (vezi Figura 10). O stare este dat de mulimea faptelor din baz, deci
62
starea iniial va fi {A, B, C, D, I}. Secvena de reguli aplicate este R1, R2, R3, R5, indicat n figur prin sgeile ngroate. Strile finale sunt marcate prin cercuri duble i sunt cele ce conin faptul H, ce trebuia dovedit. Figura prezint o strategie neeficient, pentru c starea final, dei posibil de atins dup un singur pas (ciclu), dup doi pai, sau dup trei pai, a fost atins numai dup patru cicli ai motorului.
A B C A B C A B C A B C D I R6 A B C D I H R4 D I R6 A B C D I G E D I R3, R4 A B C D I A B C D I E H E G A B C D I E F G H E F R5, R6 D I A B C D I
E F H
R3, R4
E F G
Figura 10: O poriune a spaiului strilor i realizarea tranziiilor pentru exemplul de mai sus
n cele ce urmeaz vom investiga cteva proprieti ale motoarelor de inferen.
4.3. Despre prezumia de lume deschis/nchis

Pn acum am asociat un fapt din baza de cunotine unui ansamblu de proprieti definite asupra unui obiect. Bazat pe reprezentarea proprietilor obiectelor de acest fel, am asociat satisfacerea unei condiii din partea stng a unei reguli cu gsirea unui fapt n baz care s corespund acelei descrieri de condiii.
63
Dar cum s-ar putea face ca o regul s verifice, dimpotriv, o condiie negat, adic inexistena unui obiect de un anumit fel n baz? Dac afirmarea proprietilor unor obiecte este o ndeletnicire rezonabil i finit n timp i spaiu, afirmarea explicit a proprietilor pe care nu le au obiectele este sortit eecului. Astfel, dac ar trebui s definesc proprietile scaunului pe care stau acum, cnd scriu aceste rnduri, ar trebui s spun ceva de genul: scaun cu patru picioare, din lemn sculptat, de culoare maro nchis, cu speteaz nalt, mbrcat n plu rou i prevzut cu brae. Imaginai-v ns ce ar nsemna s definesc explicit proprietile pe care scaunul meu nu le are. E lesne de neles c ar trebui s ncep cam aa: nu este din fcut din coaj de ou i nici nu e prevzut cu pene, nu are coad sau dini, nu are roi, bujii i faruri, nu are pagini ca o carte, nu cnt, nu are bani n banc, i nu are nevoie s fie udat periodic. Adic, dac cineva m-ar ntreba asupra existenei acestor proprieti la scaunul meu a rspunde negativ la ele, dar cine tie cte ntrebri ar mai putea cineva s iroseasc relativ la nevinovatul obiect pe care stau? Analog am putea s ne ntrebm cum definim ntr-o baz de cunotine obiectele care populeaz un micro-univers: asertndu-le pe cele care fac parte din el sau infirmndu-le pe cele care nu fac parte? ntr-adevr, uitndu-m n jur vd c obiectele de pe masa mea de lucru sunt: un calculator, un telefon fix, unul mobil, o cecu cu cafea, o vaz de flori, un ceas, un toc de ochelari, 18 cri, o map, hrtii, dou dischete, un deschiztor de plicuri, un CD, dou pixuri i o cutie cu agrafe. n mod clar nu se afl acolo: doi elefani, nici mcar unul, un Audi automatic, un microscop electronic, un tablou de Chagall, o poart de biseric, un vierme de mtase pistruiat i o pisic siamez rguit i cu ochii albatri. Cu alte cuvinte, ce putem face dac aciunea de a cumpra o pisic siamez cu ochi albatri ar trebui s fie condiionat de neexistena ei la mine n cas? Trebuie ca baza mea de date s o menioneze explicit ca nefiind n posesia mea, aa cum se ntmpl n cazul tuturor regulilor discutate pn acum, ce se aprind numai dac un obiect care se potrivete peste condiia specificat n regul este gsit n baz? Dac a fi pregtit pentru aceast ntrebare, mi-a prevedea un fapt care s nege explicit existena pisicii amintite la mine n cas, dar, adoptnd aceast politic, cte ntrebri trebuie anticipate nainte de a le fi auzit? Se pare aadar c putem conveni asupra a dou opiuni de a satisface un ablon negat din corpul unei reguli: s dispunem ca el s fie satisfcut numai dac un fapt care s afirme neexistena unui obiect cu anumite trsturi sau neexistena anumitor trsturi ale unui obiect este inclus n baz, sau, dimpotriv, s dispunem ca un ablon negat s fie satisfcut numai dac un fapt cu proprietile cerute n ablon nu este gsit n baz. n primul caz spunem c lucrm n prezumia de lume deschis, n cel de al doilea c lucrm n prezumia de lume nchis. Prezumia de lume deschis este echivalent cu presupunerea unui univers infinit, deci un univers n care att existena ct i neexistena unui obiect sau a unei proprieti a unui obiect trebuie declarate explicit pentru a fi siguri c el exist sau nu acolo. Dimpotriv, prezumia de lume nchis este echivalent presupunerii unui univers
64
finit, ce poate fi descris exhaustiv, astfel nct dac un obiect nu este declarat nseamn c el nu face parte din univers. Definiie: Spunem c un motor de inferene lucreaz n prezumia de lume deschis dac un ablon negat not(P), este evaluat la true numai atunci cnd n baza de fapte exist declarat un fapt not(P') peste care P s se potriveasc. Definiie: Spunem c un motor de inferene lucreaz n prezumia de lume nchis dac orice ablon aflat n partea de condiii a unei reguli, de forma not(P), este evaluat la true atunci cnd n baza de fapte nu exist nici un fapt P' peste care P s se potriveasc.
4.4. Despre monotonie

Se spune despre un sistem expert c funcioneaz monoton, sau c este monoton, dac: - nici o cunotin (fapt stabilit sau regul) nu poate fi retras din baz i - nici o cunotin adugat la baz nu introduce contradicii. Dimpotriv un sistem poate s funcioneze i nemonoton dac poate suprima definitiv sau inhiba provizoriu cunotine. Monotonia este o caracteristic a bazei de cunotine, mai precis a modului n care sunt proiectate regulile. S presupunem cazul unui motor cu nlnuire nainte i care lucreaz n prezumia de lume deschis pe o baz monoton. Cum, de la un ciclu la urmtorul, numrul faptelor dovedite (afirmative sau negative) crete, rezult c i numrul regulilor posibil de aplicat de la un ciclu la urmtorul, dup faza de filtrare, crete sau, cel puin, rmne constant. Atunci, dac ntr-un ciclu n avem mulimea MIRFn de instane de reguli filtrate, n ciclul n+1 vom avea mulimea MIRFn+1 MIRFn, deci aceleai posibiliti de aplicare a regulilor care au funcionat la pasul n se regsesc i la pasul n+1, eventual mai multe. De aceea, apariia unui eec ntr-un ciclu k nu se poate datora dect epuizrii tuturor instanelor de reguli din MIRFk (care include MIRFk-1 .a.m.d.) i deci nu ne putem atepta ca revenirea ntr-o stare anterioar, prin backtracking, s deschid posibiliti noi. Aceste considerente justific urmtoarea proprietate: dac, pentru un sistem de reguli monoton, o problem are o soluie, atunci un sistem care funcioneaz n nlnuire nainte n prezumia de lume deschis o poate gsi lucrnd n regim irevocabil (v. Figura 11).
sistem monoton de reguli (prin proiectarea prilor drepte) problema are soluie motor cu nlnuire nainte regim irevocabil prezumia de lume deschis Figura 11: Asigurarea soluiei n premisa de lume deschis
gsesc soluia
65
O alt ordine de aplicare a regulilor n acest caz poate nsemna o dinamic diferit de adugare a faptelor n baz. Dei, n principiu, n cursul rulrii tot mai multe reguli devin potenial active, terminarea procesului apare datorit epuizrii instanelor de reguli utilizabile prin restricia de unic filtrare a regulilor pe o configuraie anume de fapte (proprietatea de refractabilitate). Deci, dac exist, mai devreme ori mai trziu o soluie va fi gsit. Restricia privitoare la prezumia de lume deschis este important pentru c semnificaia abloanelor negate n prile de condiii ale regulilor este diferit n cele dou prezumii. Astfel, pentru un motor care lucreaz n prezumia de lume nchis, s presupunem existena unei reguli R care utilizeaz n partea de condiii un ablon negat not(P). Aplicnd definiia prezumiei de lume nchis, dac la un pas k o instan a lui R fcea parte din MIRFk atunci nseamn c nici un fapt P' peste care ablonul P se potrivete nu fusese introdus n baz pn n acest moment. Datorit monotoniei sistemului este posibil ns ca un astfel de fapt s apar la un pas k' ulterior lui k, ceea ce va avea ca efect eliminarea lui R din MIRFk. Ca urmare, pentru un motor care funcioneaz n prezumia de lume nchis, o condiie de suficien a gsirii soluiei trebuie enunat cu o restricie suplimentar. Proprietate: dac, pentru un sistem monoton de reguli n care regulile nu conin abloane negate, o ipostaz de problem are o soluie, atunci un sistem care funcioneaz n nlnuire nainte n prezumia de lume nchis o poate gsi lucrnd n regim irevocabil. Aceast concluzie este important pentru proiectarea sistemelor expert. Un shell de sisteme expert care funcioneaz ca motor cu nlnuire nainte, n regim irevocabil i utiliznd prezumia de lume nchis, este CLIPS, motorul de sistem expert pe care l vom utiliza n restul crii pentru experimentele noastre. Proprietatea de mai sus ne asigur de faptul c, proiectnd regulile astfel nct acestea s fie monotone i s nu conin abloane negate, putem s garantm gsirea soluiei n problemele care au soluii (vezi Figura 12).
sistem monoton de reguli (prin proiectarea prilor drepte) problema are soluie motor cu nlnuire nainte regim irevocabil prezumia de lume nchis regulile nu conin patternuri negate (prin proiectarea prilor stngi)
gsesc soluia
Figura 12: Restricii de proiectare a sistemelor expert pentru asigurarea soluiei n premisa de lume nchis
66
4.5. Despre fapte negate i reguli cu abloane negate

n premisa de lume deschis, un fapt negat, fie el not L, care apare n partea de condiii a unei reguli, pentru a putea fi validat trebuie s fi fost asertat ca negat n baz. Ca urmare, pentru c necesiti de consisten a bazei interzic prezena simultan att a lui L ct i a lui not L, faptul not L ar putea fi nlocuit pur i simplu cu un fapt ce nu mai exist, nenegat, L'=not L. Tragem de aici concluzia c faptele negate i, echivalent, condiiile negate din reguli, pot fi eliminate complet dintr-un sistem care lucreaz n premisa de lume deschis. Nu se poate spune acelai lucru ns atunci cnd se lucreaz n premisa de lume nchis. Aici, pentru ca o condiie negat s fie validat ntr-o regul nu e necesar ca faptul negat s fie declarat n baz, ci e suficient ca faptul nenegat s nu apar. Aadar nici n modelul de lume nchis faptele negate nu-i au rostul. Cele dou raionamente de mai sus duc la concluzia c putem foarte bine s lucrm numai cu fapte afirmative. De altfel un limbaj precum CLIPS nu accept declararea de fapte negate n baza de cunotine. Dar care este atunci utilitatea negaiei n partea de condiii a regulilor? S analizm mai nti ce se ntmpl cu un sistem monoton care are reguli ce conin abloane negate. Cum ntr-o baz de fapte monoton faptele nu dispar niciodat, o regul care conine abloane negate n partea de premise are urmtoarea comportare pe parcursul procesului de inferen: - dac faptul pe care l neag premisa exist iniial n baz, atunci regula nu este filtrat n ciclul I i nu va putea fi filtrat n nici un moment ulterior (pentru c acel fapt nu va disprea i nici nu va putea fi negat). Acest lucru este valabil n ambele premise de lume; - dac ns faptul pe care l neag premisa nu exist iniial (sau este negat iniial n premisa de lume deschis), atunci regula este potenial activ iniial dar poate ulterior s dispar din agend (o dat cu apariia faptului n baza de cunotine). Comportamentul sistemului este aadar dependent de contextul n care se afl motorul ceea ce poate fi exploatat de programator n proiectarea regulilor. Dup cum am vzut, n anumite condiii e suficient s avem un motor care s funcioneze n regim irevocabil pe o baz de reguli monotone pentru ca s garantm gsirea soluiei atunci cnd ea exist. n practic ns, cele mai frecvente sisteme sunt cele nemonotone care funcioneaz n prezumia de lume nchis. Retragerea faptelor din baz este o operaie des ntlnit. Din pcate utilizarea unui motor irevocabil nu mai garanteaz soluia la sistemele nemonotone, dup cum nu o garanteaz nici la cele monotone n care regulile au abloane negate. O alternativ o ofer regimul tentativ, de care ne vom ocupa n capitolul urmtor.
Capitolul 5
Regimul de lucru tentativ
Un regim tentativ este acela n care, dac ntr-un ciclu n se ajunge ntr-un punct mort (mulimea MIRF vid), deci nu se mai poate realiza faza de execuie, n ciclul de rang n+1 faza de restricie este srit iar faza de filtrare restabilete direct mulimea MIRF a regulilor din ciclul n-1, din care a fost ndeprtat regula R a crei aplicare n ciclul n-1 a dus la eec n ciclul n. ntoarcerea la contextul de lucru al ciclului anterior celui n care a avut loc blocajul presupune de asemenea restabilirea bazei de fapte caracteristice acelui moment. Procedura este aplicat recursiv de fiecare dat cnd apare un blocaj. Acest procedeu de ntoarcere napoi (backtracking) poate fi aplicat i n situaiile n care, o dat o soluie gsit, se dorete cutarea i a altor soluii. Pentru a exemplifica funcionarea n cele dou regimuri s considerm mai nti un set de reguli i o configuraie a bazei de fapte iniiale, care duce la obinerea unei soluii ntr-un regim irevocabil (exemplu adaptat).
Ex. 2
R1: R2: R3: R4: R5: R6: R7:
dac dac dac dac dac dac dac
A, B, D, F, D, J, B,
atunci B C, L, atunci D E, atunci F G, atunci H I, atunci J K, atunci H L, atunci H
Baza de fapte iniiale este {A, I, C, L} iar scopul este H. Tabela urmtoarea arat o posibil funcionare a motorului pe aceast baz de cunotine.
68 Tabela 1
Starea iniial:1 2 3 4 5:succes
Baza de fapte nainte de aplicarea regulii A,I,C,L A,I,C,L,B A,I,C,L,B,D A,I,C,L,B,D,J A,I,C,L,B,D,J,H
Reguli filtrate R1 R2,R7 R5,R7 R7 -
Regula aplicat R1 R2 R5 R7
Fapte adugate B D J H
Baza de fapte dup aplicarea regulii A,I,C,L,B A,I,C,L,B,D A,I,C,L,B,D,J A,I,C,L,B,D,J,H
O simpl modificare a unei reguli face acest sistem nemonoton. Regula pe care o vom modifica este R2. S presupunem c ea devine:
R2: dac B,C, L, atunci D, L
n care L are aci semnificaia de retragere a faptului L. Dup cum vedem din tabela de mai jos, aplicarea aceluiai motor pe baza de cunotine astfel modificat poate duce la un eec:
Tabela 2
Starea
iniial:1 2 3 4:eec
Baza de fapte nainte de aplicarea regulii A,I,C,L A,I,C,L,B A,I,C,B,D A,I,C,B,D,J
Reguli filtrate R1 R2,R7 R5 -
Regula aplicat R1 R2 R5 -
Fapte adugate B D J -
Fapte retrase L -
Baza de fapte dup aplicarea regulii A,I,C,L,B A,I,C,B,D A,I,C,B,D,J -
O soluie ns exist, i ea ar fi obinut dac n starea 2 s-ar prefera regula R7 n locul regulii R2. Dup cum tim, preferarea unei reguli din agend n favoarea alteia este de competena strategiei de control. Numai c preferarea unei strategii n locul alteia poate s dea rezultate pentru anumite probleme i s fie inefectiv pentru altele. Numai un motor tentativ, n momentul epuizrii agendei, poate reface condiiile de aplicare a unei reguli ce nu a fost aleas ntr-un pas anterior, rejucnd practic o carte i deschiznd astfel o nou cale spre succes. Iat ce s-ar ntmpla dac am lsa s ruleze un motor tentativ pe ultima baz de cunotine de mai sus:
69
Tabela 3
Starea
iniial:1 2 3 4:eec revenire n starea 2 5:succes
Baza de fapte nainte de aplicarea regulii A,I,C,L A,I,C,L,B A,I,C,B,D A,I,C,B,D,J A,I,C,L,B A,I,C,L,B,H
Reguli filtrate R1 R2,R7 R5 R7 -
Regula aplicat R1 R2 R5 R7
Fapte adugate B D J H
Fapte retrase L -
Baza de fapte dup aplicarea regulii A,I,C,L,B A,I,C,B,D A,I,C,B,D,J A,I,C,L,B,H
5.1. Simularea unui motor tentativ printr-un shell de motor irevocabil

Cu toat fragilitatea lor aparent, shell-urile de sisteme expert ce implementeaz regimuri de lucru irevocabile sunt foarte rspndite (exemple sunt OPS5 [8], [13], CLIPS [16]). Din fericire, un comportament tentativ poate fi realizat pe o main irevocabil pur i simplu prin proiectarea regulilor. n acest caz, practic se construiete un meta-sistem expert aflat deasupra sistemului expert dedicat domeniului avut n vedere. Faptele cu care lucreaz meta-sistemul sunt regulile din domeniul aplicaiei. n cele ce urmeaz vom proiecta meta-regulile unui sistem a crui menire va fi s fac s funcioneze pe un motor irevocabil baza de cunotine din exemplul Ex. 2. Vom considera urmtoarele tipuri generale de fapte (structuri de fapte5): fapte care pstreaz regulile domeniului (pentru c, aa cum spuneam, regulile domeniului trebuie privite acum drept fapte ale meta-sistemului), de forma:
(regula <eticheta> <prioritate> <listaPremise> <listaActiuni>)
n care <eticheta> identific unic o regul, <prioritate> este un indicator al prioritii regulii, iar <listaPremise> i <listaActiuni> pstreaz premisele, deci partea stng, i respectiv aciunile, adic partea dreapt, a regulii. Despre prioritatea regulilor, ca mijloc de a controla selecia, vom vorbi n mai multe rnduri n capitolele urmtoare.
5
Termenul englezesc: templates.
70
O observaie este necesar n acest punct. tim deja c trebuie s mpiedicm aplicarea unei reguli, n acelai context, mai mult de o singur dat. Apare deci necesar memorarea faptului c o regul a fost aplicat. Includerea n descrierea regulii a unui indicator care s avertizeze asupra utilizrii ei, va rezulta, dup o reflecie, ca fiind o alegere defectuoas. Motivul este comportamentul n situaiile de reveniri, cnd refacerea unei stri precedente nseamn inclusiv s uitm c au fost aprinse regulile utilizate n paii motorului ce sunt dai napoi. Lista regulilor utilizate deja este o caracteristic a contextului, la fel ca i baza de fapte curent sau lista regulilor ce sunt nc posibil de aprins n starea curent. Aadar, ntr-un comportament tentativ, o regul poate fi aprins de mai multe ori, n contexte diferite, unde contextul nseamn un fel de istorie a activitii motorului pe o cale ce marcheaz drumul de la starea iniial pn la starea curent, dac considerm exclusiv drumurile nainte, deci dac ignorm revenirile. Uneori vom numi o astfel de cale un fir de procesare. Astfel, n Figura 13, dei regula R a fost o dat aplicat ntr-un context care nu a dus la soluie (n gri deschis), aplicarea ei n acel context trebuie uitat pentru ca regula s poat fi aplicat din nou mai trziu, cu ansa de a participa la soluie (sgeat neagr ngroat pe figur).
stare fundtur
R revenire revenire R traseul final
stare fundtur
stare final atins
stare iniial
Figura 13: ntr-o cutare tentativ o regul este considerat aplicat numai pe calea spre soluie
Este uor de observat c dinamica accesului la aceast memorie a contextelor este una de tip stiv. n simularea noastr vom prefera s spargem aceast structur de stiv care memoreaz contextul de lucru n mai multe seciuni, numindu-le pe fiecare n parte stiv, dar cu observaia c aceste stive trebuie s lucreze sincron, n sensul c, n orice moment, ele au acelai numr de intrri, iar elementele din vrf, mpreun, configureaz contextul curent.
71
stiva listelor de reguli deja utilizate este dat de un fapt de forma:

(stivaReguliAplicate <listaReguli>*)
unde <listaReguli> este o intrare n stiv i reprezint o list a etichetelor regulilor ce au fost deja aplicate, iar stelua semnific, aici ca i mai departe, repetarea acestei structuri de zero sau mai multe ori. n aceast reprezentare, ca i n cele ce urmeaz, vom presupune c vrful stivei este prima list de dup simbolul care d numele stivei, iar baza stivei este lista din extremitatea dreapt a faptului. O ipostaz a acestei stive, dup al treilea ciclu al motorului care funcioneaz pe exemplul de mai sus, este:
(stivaReguliAplicate (R1 R2 R5) (R1 R2) (R1))
cu semnificaia: la primul ciclu s-a aplicat regula R1, dup al doilea erau aplicate R1 i R2, iar dup al treilea R1, R2 i R5. stiva listelor de reguli filtrate, dar neaplicate, este dat de un fapt de forma:
(stivaReguliDeAplicat <listaReguli>*)
unde <listaReguli> este o list a etichetelor regulilor ce mai pot fi nc aplicate ntr-o stare dat. Pentru exemplificare, o ipostaz a acestei stive, pe exemplul dat mai sus, dup acelai al treilea ciclu al motorului, este:
(stivaReguliDeAplicat () (R7) ())
nelegnd prin aceasta c dup primul pas nu mai rmsese de aplicat nici o regul dintre regulile filtrate, dup al doilea pas mai rmsese ca posibil de aplicat regula R7, iar dup ciclul al treilea, nici o regul. Dup cum se remarc, presupunem c funcioneaz strategia refractabilitii, ceea ce, simplificat, pentru cazul nostru, nseamn c o regul o dat aplicat nu mai poate fi filtrat. un fapt pstreaz stiva configuraiilor bazei de fapte la momente anterioare aplicrii regulilor, de forma:
(stivaBazelorDeFapte <listaFapte>*)
n care <listaFapte> este o list a faptelor din baz nainte de derularea unui ciclu. O ipostaz a acestei stive dup acelai al treilea ciclu al motorului, pe exemplul de mai sus, este:
(stivaBazelorDeFapte (A I C B D) (A I C L B) (A I C L))
72
n orice moment n care trebuie s aib loc o revenire, stiva regulilor de aplicat este memoria pe baza creia se poate decide o ntoarcere napoi prin alegerea unei alte reguli n locul celei deja selectate la un pas anterior i care a dus motorul ntr-un impas. Prin urmare, dac o intrare n aceast stiv este vid, nseamn c o ntoarcere n starea corespunztoare ei este inutil ntruct nici o alt alegere nu mai este posibil. Putem deci elimina intrrile vide din stiva regulilor de aplicat fr a pierde nimic din coeren. Condiia este s pstrm sincronismul sistemului de stive, pentru c altfel revenirea asupra alegerii unei reguli s-ar face ntr-un alt context dect cel avut n vedere. Cum cele trei stive trebuie s fie sincrone, deci s aib n orice moment acelai numr de intrri (fie el, cndva, k), datorit dispariiei intrrilor vide din stiva regulilor de aplicat, conform simplificrii sugerate mai sus, numrul de cicluri pe care motorul le-a executat, n acest caz, va fi k. Atunci, presupunnd c intrarea a i-a din stiva de reguli de aplicat corespunde ciclului j, j i, va trebui ca intrrii a i-a din stiva de fapte s-i corespund, de asemenea, configuraia bazei de fapte de imediat nainte de ciclul j al motorului, iar intrarea a i-a a stivei de reguli aplicate s semnifice lista regulilor aplicate n aceeai situaie. Aceast observaie avertizeaz deci s avem grij ca atunci cnd o intrare din stiva regulilor de aplicat dispare, intrrile corespunztoare din stiva de fapte i din cea a regulilor aplicate s dispar de asemenea. Aplicnd aceast observaie la exemplul tratat mai sus, dac nainte de simplificare, la momentul de dinaintea ciclului al treilea al motorului, configuraiile celor trei stive erau:
(stivaReguliDeAplicat () (R7) ()) (stivaReguliAplicate (R1 R2 R5) (R1 R2) (R1)) (stivaBazelorDeFapte (A I C B D) (A I C L B) (A I C L))
dup simplificare, acestea trebuie s arate astfel:

(stivaReguliDeAplicat (R7)) (stivaReguliAplicate (R1 R2)) (stivaBazelorDeFapte (A I C L B))
Pe Figura 14 se constat c aceast simplificare, efectuat nainte de ciclul al patrulea al motorului, semnific o revenire direct n starea 2 din starea 4, fr a mai vizita starea 3, de unde nici o alt alegere n-ar mai fi fost posibil. n continuare, o seam de fapte vor ine starea curent a motorului: lista regulilor filtrate n ciclul curent se memoreaz ntr-un fapt de forma:
(reguliFiltrate <etichetaRegula>*)
unde <etichetaRegula> este un index de regul.
73
baza de fapte curent este pstrat de un fapt de forma:

(bazaDeFapteCurenta <fapt>*)
unde <fapt> este un nume de fapt. Pe aceast baz de fapte are loc faza de filtrare. Baza de fapte este actualizat att n timpii de execuie ai motorului, ct i n urma revenirilor.
A revenire I C A I C A I A I C L C L B A I C L B H B D B D J
Figura 14: Scurt-circuitarea revenirii dintr-o stare de blocare n prima stare anterioar n care mai exist o alternativ neexplorat
lista regulilor deja aplicate la momentul curent este pstrat ntr-un fapt de forma: (reguliAplicate <etichetaRegula>*) scopul cutat l vom pstra ntr-un fapt de forma: (scop <fapt>)
74
mai avem nevoie de un fapt care precizeaz faza n derularea unui ciclu, de forma:
(faza <numeFaza>)
Configuraia iniial ntr-o rulare a motorului tentativ este dat de: - o mulime de fapte (regula ), - un fapt (stivaReguliDeAplicat), - un fapt (stivaReguliAplicate), - un fapt (stivaBazelorDeFapte), - un fapt (reguliFiltrate), - un fapt (reguliAplicate), - un fapt (bazaDeFapteCurenta <bazaDeFapteInitiala>), unde <bazaDeFapteInitiala> reprezint baza de fapte de plecare, - un fapt (scop <faptDeDemostrat>), unde <faptDeDemostrat> este faptul de demonstrat, - un fapt (faza filtrare), semnificnd faptul c prima faz a motorului este filtrarea. Descriem mai departe meta-regulile motorului tentativ. Vom ncepe prin a defini regulile responsabile cu terminarea procesului. Terminarea se poate face cu succes dac n baza de fapte curent se regsete faptul definit drept scop, sau cu eec dac, la sfritul fazei de filtrare, nici o regul nu a fost selectat iar stiva de reguli de aplicat e goal: MT0: Terminare cu succes, dac n baza de date curent se afl faptul scop
dac (faza filtrare) i (scop UN-FAPT) i (bazaDeFapteCurenta NISTE-FAPTE) i UN-FAPT NISTE-FAPTE atunci elimin (faza filtrare) anun succes
Condiia de terminare este cutat imediat dup execuie, deci dup actualizarea bazei de date curente, adic n faza de filtrare. Terminarea se produce prin retragerea faptului (faza ...) care este referit de oricare meta-regul. Prioritatea meta-regulii MT0 trebuie s fie cea mai mare din faza de filtrare pentru ca terminarea cu succes s se realizeze imediat dup ce faptul scop a fost gsit n faza anterioar de execuie. MT1: Terminare cu eec, dac nici o regul nu mai poate fi selectat i stiva de reguli rmase de aplicat e epuizat
75
dac (faza filtrare) i (reguliFiltrate) i (stivaReguliDeAplicat) i
nici una din regulile fazei de filtrare, MT0 sau MT2, nu pot fi aplicate
atunci elimin (faza filtrare) anun eec
La fel ca mai sus, terminarea se produce datorit retragerii faptului (faza ...) care este referit de oricare meta-regul. Prioritatea meta-regulii MT1 trebuie s fie cea mai mic ntre regulile ce pot fi aplicate n faza de filtrare, pentru ca ea s fie luate n considerare doar dup ncheierea filtrrii i nainte de tranziia n faza de selecie. Urmtoarea meta-regul descrie faza de filtrare: dintre faptele (regula ...) se selecteaz toate regulile aplicabile i care nu au mai fost aplicate, adic nu se regsesc printre regulile menionate n lista de reguli aplicate (reguliAplicate ...). Condiia de aplicabilitate a unei reguli este ca faptele din partea de condiii a regulii s se regseasc ntre cele ale bazei de fapte (bazaDeFapteCurenta ...): MT2: Faza de filtrare
dac (faza filtrare) i (reguliFiltrate NISTE-REGULI-FILTRATE) i (bazaDeFapteCurenta NISTE-FAPTE) i (reguliAplicate NISTE-REGULI-APLICATE) i (regula R PRI PREMISE ACTIUNI) i R NISTE-REGULI-FILTRATE i R NISTE-REGULI-APLICATE i PREMISE NISTE-FAPTE i MT0 nu poate fi aplicat atunci elimin (reguliFiltrate NISTE-REGULI-FILTRATE) adaug (reguliFiltrate R NISTE-REGULI-FILTRATE)
Regula MT2 se aplic de attea ori cte reguli pot fi filtrate. La terminarea filtrrii, motorul trece n faza de selecie: MT3: Tranziia n faza de selecie
dac (faza filtrare) i nici una din regulile MT0, MT1, sau MT2 nu (mai) poate fi aplicat atunci elimin (faza filtrare) i adaug (faza selecie)
Meta-regula care urmeaz descrie un proces elementar de selecie, i anume unul bazat exclusiv pe prioritatea declarat a regulilor. n cazul mai multor reguli
76
de prioritate maxim, ultima filtrat este cea selectat. Meta-regula MT4, n esen, procedeaz la o ordonare a etichetelor de reguli filtrate n ordine descresctoare: MT4: Faza de selecie
dac (faza selecie) i (reguliFiltrate ... R1 R2 ...) i (regula R1 PRI1 ...) i (regula R2 PRI2 ...) i PRI2 > PRI1 atunci elimin (reguliFiltrate ... R1 R2 ...) i adaug (reguliFiltrate ... R2 R1 ...)
Dac n urma filtrrii rezult cel puin o regul, cnd ordonarea lor ia sfrit se trece n faza de execuie: MT5: Tranziia normal n faza de execuie
dac (faza selecie) i regulile MT4 i MT6 nu (mai) pot fi aplicate atunci elimin (faza selecie) i adaug (faza execuie)
Meta-regula urmtoare descrie revenirea (backtracking). Ea se aplic cnd lista filtrat e vid dar stiva regulilor de aplicat indic nc alte posibiliti. Figura 15 arat schematic operaiile de efectuat n acest caz. MT6: Revenire cu tranziie n faza de execuie, dac nici o regul nu a putut fi selectat
dac (faza selecie) i (reguliFiltrate) i (reguliAplicate NISTE-REGULI) i (bazaDeFapteCurenta NISTE-FAPTE-CURENTE) i (stivaReguliDeAplicat O-LISTA-DE-APL REST-STIVA-DE-APL) i (stivaReguliAplicate O-LISTA-APL REST-STIVA-APL) i (stivaBazelorDeFapte NISTE-FAPTE REST-BAZE-DE-FAPTE) atunci elimin (faza selecie) elimin (reguliFiltrate) i elimin (reguliAplicate NISTE-REGULI) i elimin (bazaDeFapteCurenta NISTE-FAPTE-CURENTE) i elimin (stivaReguliDeAplicat O-LISTA-DE-APL REST-STIVADE-APL) i elimin (stivaReguliAplicate O-LISTA-APL REST-STIVA-APL) i elimin (stivaBazelorDeFapte NISTE-FAPTE REST-BAZE-DEFAPTE) i
77
adaug (faza execuie) i adaug (reguliFiltrate O-LISTA-DE-APL) i adaug (reguliAplicate O-LISTA-APL) i adaug (bazaDeFapteCurenta NISTE-FAPTE) i adaug (stivaReguliDeAplicat REST-STIVA-DE-APL) i adaug (stivaReguliAplicate REST-STIVA-APL) i adaug (stivaBazelorDeFapte REST-BAZE-DE-FAPTE)
Meta-regula MT6 descrie maniera n care se actualizeaz memoriile ce pstreaz starea curent a sistemului, respectiv regulile filtrate vor fi date de lista din vrful stivei regulilor de aplicat, regulile aplicate vor fi luate din vrful stivei regulilor aplicate, iar baza de fapte curent din vrful stivei bazelor de fapte. Toate stivele sunt simultan decrementate.
nainte de aplicarea regulii dup aplicarea regulii
reguliFiltrate
()
...
reguliAplicate
...
...
bazaDeFapteCurenta
stivaReguliDeAplica t
...
... )
... )
stivaReguliAplicate
...
...)
... )
stivaBazelorDeFapte
...
...
Figura 15: Operaiile n revenire (backtracking)
n faza de execuie, cea mai bine plasat regul dintre cele filtrate este executat:
78
MT7: Faza de execuie

Dac (faza execuie) i (reguliFiltrate R REST-FILTRATE) i (regula R PRI PREMISE ACTIUNI) i (reguliAplicate O-LISTA-REG-APL) i (bazaDeFapteCurenta NISTE-FAPTE) (stivaReguliDeAplicat LISTE-REG-DE-APL) i (stivaReguliAplicate LISTE-REG-APL) i (stivaBazelorDeFapte LISTE-DE-FAPTE) i execut ACTIUNI n contextul NISTE-FAPTE ce, la rndul lor, atunci
sunt transformate n
NOILE-FAPTE i elimin (faza selecie) i elimin (reguliFiltrate R REST-FILTRATE) i elimin (reguliAplicate O-LISTA-REG-APL) i elimin (bazaDeFapteCurenta NISTE-FAPTE) i elimin (stivaReguliDeAplicat LISTE-REG-DE-APL) i elimin (stivaReguliAplicate LISTE-REG-APL) i elimin (stivaBazelorDeFapte LISTE-DE-FAPTE) i adaug (faza filtrare) i adaug (reguliFiltrate) i adaug (reguliAplicate R O-LISTA-REG-APL) i adaug (bazaDeFapteCurenta NOILE-FAPTE) i adaug (stivaReguliDeAplicat REST-FILTRATE LISTE-REG-DEAPL) i adaug (stivaReguliAplicate O-LISTA-REG-APL LISTE-REGAPL) i adaug (stivaBazelorDeFapte NISTE-FAPTE LISTE-DE-FAPTE)
Figura 16 descrie operaiile necesare actualizrii memoriilor de lucru i a stivelor ce pstreaz configuraia curent, pentru cazul n care regula ce se execut nu este singura n lista de reguli filtrate. R, regula cea mai prioritar, aadar cea aflat pe prima poziie n lista regulilor filtrate (reguliFiltrate R RESTFILTRATE), se aplic asupra faptelor din baza de fapte curente, NISTE-FAPTE, producnd noua baz de fapte, NOILE-FAPTE, ce vor fi utilizate n faza urmtoare de filtrare. n plus, lista faptelor filtrate este resetat, pentru a pregti aceast nou faz de filtrare, iar regula R este adugat listei regulilor aplicate n firul curent de procesare O-LISTA-REG-APL. Simultan, restul regulilor filtrate REST-FILTRATE, ce nu vor mai fi folosite pe firul curent de procesare, sunt mpinse n stiva de reguli de aplicat, care va deveni acum (stivaReguliDeAplicat REST-FILTRATE LISTE-REG-DE-APL).
Regimul de lucru tentativ nainte de aplicarea regulii

(R )
79 dup aplicarea regulii
reguliFiltrate
...
reguliAplicate
...
( R
...
bazaDeFapteCurenta
stivaReguliDeAplicat
... )
...
... )
stivaReguliAplicate
... )
...
... )
stivaBazelorDeFapte
...
...
Figura 16: Faza de execuie n cazul mai multor reguli filtrate
Dup cum tim, cele trei stive trebuie s funcioneze sincron n privina numrului de intrri.Stiva regulilor de aplicat, a celor aplicate, ca i stiva bazelor de fapte trebuie s fac posibil revenirea n starea n care se gsea sistemul nainte de executarea regulii curente R, dac, la un moment ulterior, o reluare a procesrii din acest loc este necesar, simultan cu ncercarea unei alte reguli din cele filtrate dar ignorate pentru moment. Ca urmare, la stiva regulilor aplicate, ce ine istoria regulilor aplicate n firul curent de procesare, se adaug lista regulilor aplicate nainte de execuia lui R, adic O-LISTA-REG-APL, iar la stiva bazelor de fapte se adaug baza de fapte de dinaintea aplicrii regulii R, respectiv NISTE-FAPTE. Dac R este, ns, singura regul filtrat, atunci nici una din stive nu este incrementat. Meta-regula MT8 i Figura 17 descriu operaiile corespunztoare acestei situaii. MT8: Faza de execuie cnd stivele rmn neschimbate
Dac (faza execuie) i (reguliFiltrate R) i (regula R PRI PREMISE ACTIUNI) i
80
(reguliAplicate O-LISTA-REG-APL) i (bazaDeFapteCurenta NISTE-FAPTE) (stivaReguliDeAplicat LISTE-REG-DE-APL) i (stivaReguliAplicate LISTE-REG-APL) i (stivaBazelorDeFapte LISTE-DE-FAPTE) i atunci execut ACTIUNI n contextul NISTE-FAPTE ce, la rndul lor,
sunt transformate n
NOILE-FAPTE i elimin (faza selecie) i elimin (reguliFiltrate R) i elimin (reguliAplicate O-LISTA-REG-APL) i elimin (bazaDeFapteCurenta NISTE-FAPTE) i adaug (faza filtrare) i
adaug (reguliFiltrate) i adaug (reguliAplicate R O-LISTA-REG-APL) i adaug (bazaDeFapteCurenta NOILE-FAPTE)

nainte de aplicarea regulii dup aplicarea regulii
reguliFiltrate
(R )
reguliAplicate
...
( R
...
bazaDeFapteCurenta
stivaReguliDeAplicat
... )
... )
stivaReguliAplicate
... )
... )
stivaBazelorDeFapte
...
...
Figura 17: Execuia n cazul unei singure reguli filtrate
Capitolul 6
Confruntarea rapid de abloane: algoritmul RETE
Programatorii experimentai recunosc uurina de concepere a programelor ntr-un limbaj bazat pe reguli. Faptul c elementele bazei de cunotine ce fac obiectul prelucrrii nu trebuie identificate printr-un proces de cutare explicit ci sunt regsite automat de sistem prin procesul cablat de confruntare de abloane este un hocus-pocus extrem de convenabil programatorului. Dup cum bnuim ns, pentru c nimic pe lumea aceasta nu e pe gratis, un pre trebuie pltit pentru aceast convenien: fie un timp de calcul mai lung, fie un consum de memorie mai mare. n acest capitol vom face cunotin cu un algoritm de confruntare a regulilor cu faptele, datorat lui Forgy [14], [27], [16] care este eficient, dar care nu e tocmai ieftin n privina utilizrii memoriei (pentru alte abordri, a se vedea [9], [28], [29], [31]). Oricare din regulile unui sistem bazat pe reguli este format dintr-o parte de condiii i o parte de aciuni. Partea de condiii const ntr-o colecie de abloane ce trebuie confruntate cu obiecte din baza de fapte. Regulile considerate active, deci cele ce vor popula agenda la fiecare pas, sunt depistate n faza de filtrare. Nu e de mirare, aadar, c cel mai mult timp n rularea unui sistem bazat pe reguli se consum n faza de filtrare, responsabil, la fiecare ciclu, cu identificarea instanelor de reguli, deci a tripletelor: reguli filtrate, fapte folosite n filtrri, legri ale variabilelor la valori. Problema poate fi definit astfel: se dau un numr de reguli, fiecare avnd n partea stng un numr de abloane, i o mulime de fapte i se cere s se gseasc toate tripletele <regul, fapte, legri> ce satisfac abloanele. O manier de calcul imediat ar fi ca pentru fiecare ablon al fiecrei reguli s se parcurg baza de fapte pentru a le gsi pe acelea ce verific ablonul. Simpla iterare a setului de pri stngi ale regulilor peste setul de fapte din baz pentru gsirea acelor fapte care se potrivesc peste abloanele regulilor este extrem de costisitoare, pentru c ar trebui s aib loc la fiecare pas al motorului. Atunci cnd numrul regulilor i al faptelor este mare se pune aadar problema reducerii timpului fazei de filtrare. Iteraia abloanelor peste fapte la fiecare pas este ineficient, printre altele, i pentru c, de la o iteraie la alta, n general, numrul faptelor modificate este mic i deci foarte multe calcule s-ar repeta fr rost. Calculul inutil poate fi evitat dac la fiecare ciclu s-ar memora toate potrivirile ce au rmas nemodificate de la ciclul anterior, astfel nct s se calculeze numai potrivirile n care intervin faptele nou adugate,
82
modificate ori terse. Apare natural ideea ca faptele s-i gseasc regulile i nu invers. n algoritmul RETE regulile sistemului sunt compilate ntr-o reea de noduri, fiecare nod fiind ataat unei comparaii (test) ce are loc datorit unui anumit ablon. n construcia reelei compilatorul ine cont de similaritatea structural a regulilor, minimiznd astfel numrul de noduri. Similaritatea a dou abloane nseamn identitatea lor modulo numele variabilelor. abloanelor similare aflate n secvene identice n mai multe reguli le corespund aceleai noduri n reea. Algoritmul exploateaz relativa stabilitate a faptelor de la un ciclu la altul. Nodurile reelei sunt supuse unui proces de activare-dezactivare ce se propag dinspre rdcin spre frunze la fiecare ciclu al motorului. Poriunile din reea ce nu sunt afectate de schimbrile din baza de fapte prin aplicarea ultimei reguli rmn n aceeai stare. Un nod din reea ce-i schimb starea antreneaz ns modificri n toat structura aflat sub el. Prin aceasta, poriuni largi din reea rmn imobile ntre o execuie i alta. In extremis, modificarea ntregii baze de fapte antreneaz recalcularea ntregii reele ca i cum toate faptele ar fi fost comparate cu toate abloanele regulilor. O regul este considerat potenial activ, deci inclus n agend, atunci cnd toate abloanele prii ei stngi sunt verificate pe fapte din baz (n sensul c se potrivesc asupra lor). Dac, de exemplu, de la un ciclu la urmtorul, ablonul al treilea din patru al unei reguli i modific starea n raport cu baza (de exemplu nceteaz a mai fi verificat), atunci reeaua trebuie s pstreze informaia c primele dou abloane sunt nc verificate i o dezactivare de la nivelul ablonului al treilea trebuie s se propage mai jos. Invers, dac un ir de patru abloane al unei reguli era doar parial verificat la un anumit ciclu, s zicem pn la nivelul celui de al doilea ablon inclusiv, pentru ca la urmtorul ciclu o modificare n baz s provoace verificarea i a urmtoarelor dou, atunci un semnal n reea corespunznd acestor ultime dou abloane trebuie s se propage pentru a anuna totodat aprinderea regulii. Aceast observaie este de natur s atrag atenia asupra potrivirilor pariale. O potrivire parial a unei reguli este orice combinaie contigu de abloane satisfcute ncepnd cu primul ablon al regulii. O potrivire dintre un ablon i un fapt o vom numi potrivire simpl. Fie, de exemplu, faptele urmtoare:
f1: f2: f3: f4: f5: f6: f7: f8: [alpha a 3 a] [alpha a 4 a] [alpha a 3 b] [beta 3 a 3] [beta 3 a 4] [beta 4 a 4] [gamma a 3] [gamma b 4]
83
i o regul: R1: dac

[alpha X Y X] i [beta Y X Y] i [gamma X Y] atunci ...
n care X i Y sunt variabile. Au loc urmtoarele potriviri simple i pariale: - potriviri simple pentru primul ablon:
f1; X a, Y 3 f2; X a, Y 4
- potriviri simple pentru al doilea ablon:

f4; Y 3, X a f6; Y 4, X a
- potriviri simple pentru al treilea ablon:

f7; X a, Y 3 f8; X b, Y 4
- potriviri pariale pentru primele dou abloane:

f1, f4; X a, Y 3 f2, f6; X a, Y 4
- potriviri pariale pentru toate trei abloanele:

f1, f4, f7; X a, Y 3
Ultima potrivire parial corespunde activrii:

<R1; f1, f4, f7; X a, Y 3>.
Reeaua oglindete dou tipuri de comparaii dintre fapte i abloane: intraablon i inter-abloane, care definesc i dou reele aezate n cascad. Exist un unic nod rdcin al reelei comparaiilor intra-ablon. Pe nivelul aflat imediat sub rdcin sunt noduri n care se realizeaz confruntri simple, corespunznd potrivirilor elementare dintre abloane i fapte. n fapt, fiecare nod al reelei de abloane implementeaz cte un test elementar, care este responsabil de verificarea diverselor inter-relaii intra-ablon. Aceste noduri sunt plasate n cascad, oglindind ordinea operaiilor de comparaie corespunztoare confruntrilor ablon-fapt. n felul acesta, fiecare coloan de noduri corespunde cte unui ablon, de fapt, datorit similaritii structurale, cte unui set de abloane structural similare aparinnd unor reguli diferite. Nodurile terminale ale acestui nivel corespund, fiecare, unui set de potriviri simple similare. n Figura 18 este artat o reea care corespunde compilrii regulii R1 de mai sus i R2 de mai jos:
84
R2: dac atunci
[alpha Z U Z] i [beta U Z U] i [gamma Z 4] ...
nod rdcin
reeaua comparaiilor intra-ablon cmpul 1 = alfa cmpul 1 = beta cmpul 1 = gamma
cmpul 4 = cmpul 2
cmpul 4 = cmpul 2
cmpul 1 = 4
reeaua comparaiilor inter-abloane cmpul 2 stnga = cmpul 3 dreapta i cmpul 3 stnga = cmpul 2 dreapta
cmpul 2 stnga = cmpul 3 dreapta i cmpul 3 stnga = cmpul 2 dreapta
cmpul 3 stnga = cmpul 2 dreapta
R1 activat
R2 activat
Figura 18: Reeaua corespunznd regulilor R1 i R2
Cu excepia numelor variabilelor, primele dou abloane ale regulilor R1 i R2 sunt similare pentru c, redenumind variabilele Z i U din R2 respectiv n X i Y, obinem aceleai abloane. Acest lucru este oglindit n primele dou coloane ale
85
sub-reelei comparaiilor intra-ablon care conin noduri utilizate n comun de ambele reguli. Astfel primul nod al primei coloane exprim testul de identificare a faptelor care au pe primul cmp simbolul alpha. Urmtorul cmp al primului ablon conine variabila X n R1, respectiv Z n R2. Acest cmp nu genereaz nici un test pentru c orice valoare pe poziia corespunztoare lui ntr-un fapt ce a trecut cu bine de primul test este acceptat. Cmpul al treilea al primului ablon al regulii R1 conine variabila Y, respectiv U n R2, pentru care, din nou, nu se genereaz nici un test din acelai motiv. Cmpul al patrulea al primului ablon al lui R1 evoc variabila X din nou, respectiv variabila Z n R2. Pentru acest cmp trebuie generat un test pentru c apariia a doua oar a aceleiai variabile ntr-un ablon indic necesitatea identitii valorilor de pe poziiile corespunztoare ale faptului supus confruntrii. Ca urmare, reeaua include un nod care testeaz egalitatea cmpului 4 al faptului cu cmpul 2 al faptului, lucru valabil pentru ambele reguli. Coloana urmtoare a reelei exprim testele intra-ablon pentru abloanele secunde ale lui R1 respectiv R2: primul cmp din fapt trebuie s conin simbolul beta iar cmpul 4 al faptului, din nou, s fie egal cu cmpul 2 al faptului (datorit apariiei a doua oara a variabilei Y n R1 respectiv a variabilei U n R2). Coloana a treia a reelei, exprimnd testele intra-ablon pentru abloanele de pe poziia a treia a regulilor R1 respectiv R2, are un nod comun pentru ambele reguli, corespunznd primului cmp din fapt ce trebuie testat la egalitate cu simbolul gamma. Mai departe numai regula R2 mai necesit un test intra-ablon, corespunznd necesitii ca pe poziia cmpului al treilea din fapt s se regseasc valoarea 4. Sintetiznd, potrivirile simple ale regulii R1, datorate secvenei celor trei abloane, sunt testate n primele dou noduri ale coloanei 1, primele dou noduri ale coloanei 2 i, respectiv, primul nod al coloanei 3. Analog, potrivirile simple ale regulii R2 sunt testate n primele dou noduri ale coloanei 1, primele dou noduri ale coloanei 2 i, respectiv, al doilea nod al coloanei 3. Dup cum se poate observa i pe figur, fiecrei potriviri simple i corespunde o ieire din sub-reeaua comparaiilor intra-ablon. Imediat sub reeaua comparaiilor intra-ablon se afl reeaua comparaiilor inter-abloane. Prin intermediul ei sunt reprezentate testele datorate unor variabile partajate de mai multe abloane. Fiecare nod al acestei reele are dou intrri. Un nod reprezint aici o potrivire parial, cele dou intrri corespunznd, una potrivirii pariale de rang imediat inferior i cealalt ablonului urmtor supus testului. Ultimul nivel al reelei corespunde nodurilor reguli. Astfel, n sub-reeaua comparaiilor inter-abloane din Figura 18, regulii R1 i corespund dou noduri iar regulii R2 de asemenea dou noduri, dei numrul total de noduri ale sub-reelei este de trei, pentru c un nod este partajat de cele dou reguli. Figura 19 detaliaz maniera n care trebuie considerate intrrile nodurilor comparaie ale sub-reelei inter-abloane a regulii R1. Lund ca exemplu primul
86
nod, este clar c n prima comparaie am fi putut considera cmpul al patrulea al intrrii stnga n locul cmpului al doilea, ntruct n ambele cmpuri n ablon apare aceeai variabil iar egalitatea celor dou cmpuri a fost testat n subreeaua comparaiilor intra-ablon, n cel de al doilea nod de pe prima coloan.
cmp 2 cmp 3
[ intrare stnga primul nod intrare dreapta [
alpha
beta
intrare stnga al doilea nod
gamma
intrare dreapta
Figura 19: Corelaiile inter-abloane ale regulii R1
O reea ca cea descris are rolul de a pstra ntre cicluri succesive ale funcionrii motorului informaii despre potrivirile simple i pariale i de a propaga modificrile ce apar n baza de fapte, ca urmare a execuiei regulilor. n felul acesta reeaua va ine evidena instanierilor de reguli. Pentru a realiza acest lucru, fiecare nod al reelei are ataat o memorie ce va memora potrivirile, simple ori pariale, corespunztoare nivelului pe care este plasat nodul. Nodul rdcin al reelei are rolul de a colecta modificrile ce apar n baza de date la fiecare ciclu i a le distribui nodurilor aflate imediat sub el. n conformitate cu tipurile de aciuni pe care le-am admis pn acum asupra faptelor din baz, vom considera c exist doar dou tipuri de modificri ce pot aprea n reea: adugarea unui fapt i tergerea unui fapt. O vom numi pe prima modificare plus (+) i pe cea de a doua modificare minus (). Secvena de figuri care urmeaz arat propagarea modificrilor n reea pe msur ce faptele sunt introduse n baz. Amorsarea propagrilor se face prin inseria n nodul rdcin a unor dublete de forma <index-fapt,+>. Semnul + semnific aici modificarea plus. Ori de cte ori un fapt este retras din baz rdcina va propaga o modificare minus, de forma: <index-fapt,->. Pe aceste figuri ultimele noduri aprinse n propagare sunt ntunecate.
87
Astfel, Figura 20 reprezint situaia memoriei ataate reelei dup propagarea secvenei de modificri: <f1,+>, <f2,+>, <f3,+>. Faptele : [alpha a 3 a] i f2: [alpha a 4 a] ating nivelul nodului secund f1 al primei coloane, pentru c ambele teste sunt satisfcute de cmpurile acestor fapte. Totodat, pentru c ele nu satisfac condiiile din nodurile de pe celelalte dou coloane, ele nu pot trece de nici unul din aceste teste. Faptul f3: [alpha a 3 b] nu poate trece mai jos de primul nod al primei coloane.
<f3,+>
<f1,+>:$1 a,$2 3 <f2,+>:$1 a,$2 4
R1
R2
Figura 20: Propagarea modificrilor <f1,+>, <f2,+>, <f3,+>
Simultan cu propagarea modificrilor n josul reelei, trebuie s aib loc o memorare a legrii cmpurilor variabile din abloanele regulilor la valori, n cazurile de potriviri. Vom vizualiza aceast memorie numai n nodurile terminale ale reelei comparaiilor intra-ablon. Cum nodurile din reea pot fi partajate de mai multe reguli, fiecare numind altfel propriile variabile, notarea variabilelor n aceste asignri trebuie s fie neutr fa de notaiile utilizate n reguli. De aceea, pe figuri, aceste variabile s-au notat prin $1, $2... Semnificaia acestora este ns diferit de la un nod la altul. Considernd c faptele f4, f5 i f6 sunt propagate n reea ca modificri plus, Figura 21 arat cum faptul f5 nu poate trece mai jos de primul nod al coloanei a doua, n timp ce modificrile plus datorate faptelor f4 i f6 ajung la baza reelei comparaiilor intra-ablon pe coloana a doua.
88
<f3,+> <f5,+>
<f1,+>:$1 a,$2 3 <f2,+>:$1 a,$2 4 <f4,+>:$1 3,$2 a <f6,+>:$1 4,$2 a
R1
R2
Figura 21: Propagarea modificrilor <f4,+>, <f5,+>, <f6,+> n sub-reeaua comparaiilor intra-ablon
<f3,+> <f5,+>
<f1,+>:$1 a,$2 3 <f2,+>:$1 a,$2 4 <f4,+>:$1 3,$2 a <f6,+>:$1 4,$2 a <f1,f4,+>:$1 a,$2 3 <f2,f6,+>:$1 a,$2 4
R1
R2
Figura 22: Propagarea modificrilor <f4,+>, <f5,+>, <f6,+> n sub-reeaua comparaiilor inter-abloane
89
n acest moment dou intrri ale primului nod al sub-reelei comparaiilor inter-abloane sunt active. Figura 22 arat potrivirea parial ce se produce la nivelul acestui nod, prin selectarea respectiv a perechilor de dou fapte <f1,f4> i <f2,f6>. Acesta este cel mai jos punct n care modificrile pot fi nc propagate.
<f3,+> <f5,+> <f7,+>:$1 a,$2 3 <f8,+>:$1 b <f8,+>:$1 b <f4,+>:$1 3,$2 a <f6,+>:$1 4,$2 a <f1,f4,+>:$1 a,$2 3 <f2,f6,+>:$1 a,$2 4
<f1,+>:$1 a,$2 3 <f2,+>:$1 a,$2 4
R1
R2
Figura 23: Propagarea modificrilor <f7,+>, <f8,+> n reeaua comparaiilor intra-ablon
Propagarea n sub-reeaua comparaiilor intra-abloane a modificrilor plus, datorate apariiei n baz a faptelor f7 i f8 sunt artate n Figura 23. n fine, Figura 24 pune n eviden propagarea ultimelor modificri n subreeaua comparaiilor inter-ablon. Se constat c numai regula R1 poate fi filtrat prin satisfacerea condiiilor nodului nnegrit de ctre tripletul de fapte <f1,f4,f7>. Instana ce va popula agenda va fi n acest caz: <R1; f1,f4,f7; X a,Y 3>. Dimpotriv, nici unul din tripletele <f1,f4,f8> ori <f2,f6,f8> ce alimenteaz intrrile ultimului nod dreapta al reelei inferioare nu satisfac condiia din nod, ceea ce face ca regula R2 s nu poat fi filtrat.
90
<f3,+> <f5,+> <f7,+>:$1 a,$2 3 <f8,+>:$1 b <f8,+>:$1 b <f4,+>:$1 3,$2 a <f6,+>:$1 4,$2 a <f1,f4,+>:$1 a,$2 3 <f2,f6,+>:$1 a,$2 4
<f1,+>:$1 a,$2 3 <f2,+>:$1 a,$2 4
<f1,f4,f7,+>:$1 a,$2 3
R1 activat
R2
Figura 24: Propagarea modificrilor <f7,+>, <f8,+> n reeaua comparaiilor inter-ablon
S presupunem, n continuare, c regula R1, filtrat aa cum s-a artat mai sus, conine o parte dreapt ca mai jos:
R1: dac atunci [alpha X Y X] i [beta Y X Y] [gamma X Y] terge [gamma X Y] adaug [gamma X 4]
Execuia prii drepte a lui R1 injecteaz n nodul rdcin al reelei modificrile <f7,->, <f9,+>, unde f9 este faptul [gamma a 4]. Propagarea modificrii minus n reea este indicat n Figura 25. Traseul modificrilor i nodurile afectate sunt desenate ntr-o culoare ntunecat.
91
<f3,+> <f5,+> <f8,+>:$1 b
<f1,+>:$1 a,$2 3 <f2,+>:$1 a,$2 4
<f8,+>:$1 b <f4,+>:$1 3,$2 a <f6,+>:$1 4,$2 a
<f1,f4,+>:$1 a,$2 3 <f2,f6,+>:$1 a,$2 4
R1 dezactivat
R2
Figura 25: Propagarea modificrii minus <f7,->
<f3,+> <f5,+> <f8,+>:$1 b <f9,+>:$1 a <f8,+>:$1 b <f9,+>:$1 a <f4,+>:$1 3,$2 a <f6,+>:$1 4,$2 a <f1,f4,+>:$1 a,$2 3 <f2,f6,+>:$1 a,$2 4 <f2,f6,f9,+>:$1 a,$2 4 R2 activat
<f1,+>:$1 a,$2 3 <f2,+>:$1 a,$2 4
R1
Figura 26: Propagarea modificrii plus
92
n fine, propagarea modificrii plus produse de aceeai execuie este indicat n Figura 26, unde, din nou, pe traseul propagrii modificrii, nodurile afectate sunt desenate ntr-o culoare ntunecat.
6.1. Importana ordinii abloanelor

Consideraiile de mai sus privind construcia reelei de abloane a regulilor i maniera n care are loc propagarea modificrilor duc la formularea unor importante concluzii asupra eficientizrii rulrii. Cea mai important dintre ele se refer la ordinea abloanelor n prile stngi ale regulilor. Aceste concluzii au toate la baz maniera de calcul a potrivirilor pariale: trecerea de la considerarea primelor k abloane la considerarea primelor k+1 abloane ale prii stngi poate aduga suitei de potriviri pariale datorate primilor k abloane pn la produsul dintre numrul acestora i numrul de potriviri elementare ale ablonului al k+1-ulea. Dei reguli stricte n privina ordinii abloanelor snt dificil de formulat, explozia potrivirilor pariale poate fi controlat ntr-o oarecare msur respectnd cteva recomandri: - abloanele crora le corespund cele mai puine apariii de fapte n baz trebuie s apar pe primele poziii n prile stngi ale regulilor. n felul acesta nodurilor finale ale reelei comparaiilor intra-ablon le vor corespunde puine fapte verificate n baza de fapte. Astfel, nu este indiferent dac primul ablon realizeaz 1 sau 100 de potriviri elementare, pentru c acestea vor intra n calculul potrivirilor pariale ale reelei comparaiilor inter-abloane; - abloanele mai specifice trebuie s le precead pe cele mai generale. Cu ct un ablon are mai multe cmpuri libere sau conine mai multe variabile nelegate, cu att el trebuie s apar mai jos n partea stng a regulii. Ambele recomandri duc la micorarea numrului de potriviri pariale ataate nodurilor superioare din reeaua comparaiilor inter-abloane; - abloanele corespunztoare faptelor celor mai volatile (ce sunt retrase i asertate des n baz) trebuie plasate la urm. n felul acesta modificrile propagate de includerea sau eliminarea faptelor corespunztoare lor se vor manifesta n reea doar dac toate celelalte abloane ale regulii se verific; - nu trebuie exagerat folosirea variabilelor multi-cmp i cu precdere a celor anonime (ele vor fi introduse n capitolul 7). Acestea duc de obicei la instanieri multiple ale regulii, ce se pot apoi uor multiplica prin instanierile pariale. Uneori aceste recomandri pot fi contradictorii i uneori numai experimentnd, dup ce raionamentul este verificat, se poate gsi ordonarea optim. Experiena programatorului poate fi aici de mare pre.
Partea a III-a Elemente de programare bazat pe reguli

Primii pai ntr-un limbaj bazat pe reguli: CLIPS Constrngeri n confruntarea abloanelor Despre controlul execuiei Recursivitatea n limbajele bazate pe reguli
Capitolul 7
Primii pai ntr-un limbaj bazat pe reguli: CLIPS
CLIPS este un shell evoluat pentru dezvoltarea de sisteme expert. El se ncadreaz n paradigma limbajelor bazate pe reguli i implementeaz o cutare nainte irevocabil. CLIPS a fost dezvoltat iniial de Software Technology Branch la NATO Lyndon B. Johnson Space Center. Prima versiune a aprut n 1984, iar n 2002 a ajuns la versiunea 6.2, ca produs de domeniu public, aceast evoluie semnificnd un ir impresionant de mbuntiri i extinderi ale limbajului. Pentru a rezolva o problem n CLIPS programatorul definete baza de cunotine i alege strategia de cutare, iar sistemul dezvolt un proces de aplicare a regulilor care se perpetueaz att timp ct mai pot fi aplicate reguli pe faptele existente n baz. Prezentarea care urmeaz nu este propriu-zis o introducere n CLIPS, ct o introducere n programarea bazat pe reguli. Ca urmare, nu vom insista asupra elementelor de limbaj, ce pot fi oricnd gsite n documentaia interactiv a limbajului sau n alte materiale orientate cu precdere asupra prezentrii limbajului (v. de exemplu [15] ori situl CLIPS de la http://www.ghg.net/clips/CLIPS.html) ct asupra manierei n care se rezolv probleme utiliznd paradigma de programare bazat pe reguli de producie. Prezentarea care urmeaz este una tributar credinei mele c un limbaj nou se nva cel mai eficient i mai rapid cnd ai de rezolvat o problem. Ca urmare, elementele limbajului vor fi introduse ntr-o ordine indus de exemplele pe care le vom aborda, pe msur ce complexitatea mereu crescnd a problemelor tratate neo va impune. Cititorul chiibuar va gsi cu prisosin motive de nemulumire n cuprinsul prilor urmtoare ale crii, care, adesea, vor anuna titluri de probleme n locul unor elemente de limbaj, aa cum se procedeaz n orice carte dedicat prezentrii unui limbaj de programare. Pentru a uura totui accesul la elementele de limbaj introduse al acelui tip de cititor grbit s programeze i care nu este dispus s caute aiurea o documentaie, vom marca totui pasajele ce povestesc cte ceva despre limbaj printr-o bar vertical pe marginea stng a textului, ca aici. CLIPS, ca i alte shell-uri de sisteme expert, este un limbaj interpretat. Aceasta nseamn c o comand dat la prompter este executat imediat i rezultatul ntors utilizatorului. Interpretorul transform codul surs al programului
96
ntr-o reea a regulilor ce va fi executat apoi de algoritmul RETE, aa cum am vzut n Capitolul 6. Prompter-ul CLIPS este:
CLIPS>
7.1. S facem o adunare

Comanda dat direct la prompter Cum scriem n CLIPS c 2+1=3? Operaia de adunare se realizeaz prin operatorul de adunare +, scriind:
CLIPS> (+ 2 1)
urmat de un <Enter> (orice comand se termin cu <Enter>). Interpretorul va ntoarce:

3
dup care vom avea din nou un prompter:

CLIPS>
Reinem aadar c sintaxa comenzilor este n paranteze rotunde, cuvntul cheie semnificativ trebuind dat pe prima poziie. Fapte S presupunem acum c dorim s introducem numerele pe care vrem s le adunm ca date de intrare. Precizarea intrrii ntr-un program CLIPS se face fie direct de la tastatur, fie citindu-le dintr-un fiier, fie prin declaraii de fapte. De exemplu, am putea avea dou fapte ce conin numerele de adunat:
(numar 2) (numar 1)
Un fapt poate fi de dou feluri: o construcie multi-cmp, n care cmpurile nu au nume i ordinea lor este semnificativ fapte ordonate, sau una n care cmpurile au nume i, ca urmare, ordinea lor nu mai e important obiecte. n acest capitol vom lucra numai cu fapte ordonate.
97
Un fapt este reprezentat cu unicitate n baz, acest lucru nsemnnd c sistemul va mpiedica introducerea n baz a unui fapt identic cu unul deja existent. Aceasta nu nseamn c o regul care ar ncerca o astfel de aciune nu se aprinde. Ea lucreaz, dar fr s afecteze baza. Dar cum facem ca interpretorul s ia cunotin de fapte? Cum la prompter el se ateapt s primeasc comenzi, ncercarea de a le scrie direct acolo va eua pentru c el nu cunoate nici o comand numar:
CLIPS> (numar 2) Missing function declaration for numar.
Comanda care comunic interpretorului un grup de fapte este deffacts:

(deffacts numere numerele de adunat (numar 2)(numar 1))
un nume de grup de fapte
un comentariu (opional)
primul fapt
al doilea fapt
Grupul de fapte i numele lui nu au semnificaie pentru program. Dar el poate fi de folos programatorului din raiuni de structurare a datelor. Scriind la prompter acest rnd, aparent nu se ntmpl nimic. Faptele sunt interpretate dar nc nu sunt depozitate n baza de fapte a sistemului. Interpretului trebuie s i se comande explicit ca faptele declarate prin definiiile de grupuri de fapte deffacts s fie depozitate n baza de fapte. Comanda (reset) oblig includerea faptelor declarate n baza de fapte i alimenteaz reeaua regulilor cu fapte, unul cte unul, n ordinea n care acestea sunt declarate i care va fi i ordinea de indexare a lor n baz. Verificarea coninutului bazei de fapte se face cu comanda (facts). Deci, s relum secvena:
CLIPS> (deffacts numere numerele de adunat (numar 2)(numar 1)) CLIPS> (reset) CLIPS> (facts) f-0 initial-fact f-1 (numar 2) f-2 (numar 1) CLIPS>
Observm c, n afara faptelor pe care le-am depus noi, ne este raportat nc un fapt asupra cruia nu avem nici un merit: initial-fact. Utilitatea acestui fapt, pe care sistemul l introduce ntotdeauna, st n filtrarea regulilor
98
fr parte stng. Sistemul nlocuiete partea stng a regulilor care nu prevd nici un ablon printr-un ablon initial-fact, ce va fi satisfcut ntotdeauna de acest fapt introdus din oficiu, fcnd n acest fel posibil i aprinderea acestor reguli. Acum avem faptele n baz. Cum procedm pentru a aduna cele dou numere? Va trebui s construim o regul capabil s preia numerele din cele dou fapte i s le adune. Aceast regul va trebuie s fie att de general nct ori de cte ori coninutul acestor dou fapte din baz s-ar modifica, ea s produc noua sum. Reguli Pentru a defini o regul folosim construcia defrule:
(defrule <nume-regul> comentariu <ablon>* => <aciune>*)
orice regul trebuie s aib un nume
pot s scriu un comentariu care s descrie ce face regula (opional)
partea stng: un ir de abloane
partea dreapt: un ir de aciuni
Un ablon este o construcie care imit, mai mult sau mai puin, un fapt ce ar trebuie s fie gsit n baz. In extremis, un ablon poate s fie identic cu un fapt, caz n care el se va potrivi numai cu acesta. Cel mai adesea ns un ablon permite anumite grade de libertate n structura faptelor cu care se intenioneaz s se potriveasc. Operaia de cutare n baz a faptelor care se potrivesc cu un ablon o vom numi confruntare. Un ablon pentru fapte ordonate este o construcie sintactic de genul:
ablon ::= (<element-ablon>*) element-ablon ::= <atom> | ? | ?<var> | $? | $?<var>
Construcia de mai sus (dat ntr-un format Baccus-Naur) exprim succint faptul c un ablon este format din zero sau mai multe elemente-ablon, iar un element-ablon poate fi un atom sau o construcie n care apare semnul ?. Un element-ablon atomic poate fi un ntreg, un real, sau un simbol. Celelalte construcii se refer la cmpurile ce pot fi variabile n ablon. Confruntarea dintre un ablon i un fapt nseamn o parcurgere a ablonului n paralel cu faptul i confruntarea fiecrui cmp din ablon cu unul sau mai multe cmpuri din fapt, n funcie de forma elementului-ablon. O regul poate fi instaniat diferit n funcie de legrile care se realizeaz ntre variabilele abloanelor i
99
cmpuri ale faptelor din baz. O instaniere eueaz ori de cte ori elementele ablonului se epuizeaz nainte de epuizarea cmpurilor faptului sau invers: - dac elementul-ablon e un atom, atunci operaia de confruntare reuete dac cmpul respectiv din fapt este identic cu elementul-ablon; - dac elementul-ablon e ?, atunci operaia reuete; - dac elementul-ablon e ?<var>, unde <var> este un simbol, i variabila ?<var> nu e legat, atunci operaia reuete iar variabila ?<var>, ca efect colateral, va fi legat la valoarea din cmp; - dac elementul-ablon e ?<var>, i variabila ?<var> e deja legat, atunci, dac valoarea din cmp este identic cu cea la care este legat variabila, atunci operaia reuete, altfel ea eueaz; - dac elementul-ablon e $?, atunci operaia reuete i un numr de instanieri ale regulii egal cu numrul cmpurilor rmase necercetate n fapt plus unu sunt produse. n fiecare instaniere confruntarea continu de la o poziie diferit din fapt. Astfel, n prima instaniere confruntarea continu din chiar poziia curent a faptului, n a doua de la o poziie situat un cmp mai la dreapta, .a.m.d.; - dac elementul-ablon e $?<var> i variabila ?<var> nu e legat, atunci operaia reuete i au loc aceleai aciuni ca i n cazul elementuluiablon $?. n plus, ca efect colateral, n fiecare instaniere variabila ?<var> va fi legat la o secven de cmpuri din fapt, cele peste care se face avansarea; - dac elementul-ablon e $?<var> i variabila $?<var> e deja legat la o valoare multi-cmp, atunci, dac aceast valoare multi-cmp concord cu secvena de cmpuri urmtoare din fapt, atunci operaia reuete, altfel ea eueaz. De remarcat din definiiile de mai sus c numele variabilei este ?<var> sau $?<var>. Se interzice utilizarea n aceeai regul a unui simbol de variabil pentru a desemna simultan o variabil simplu-cmp i una multi-cmp. Pn acum am definit construcii ce pot aprea n partea stng a unei reguli. Ce aciuni pot s apar n partea dreapt? Pentru moment, ieirea programelor se va manifesta prin modificri asupra bazei de fapte. Putem modifica colecia de fapte din baz n dou moduri: adugnd noi fapte sau retrgnd fapte existente acolo. Ca s adugm, scriem: (assert <fact>*). Ca s retragem, trebuie ns s precizm despre ce fapt e vorba. Nu se pune problema s ncercm identificarea din nou a unui fapt n partea dreapt a regulii prin intermediul unui ablon: un ablon nu poate aciona dect n partea stng. Ca urmare faptul ce trebuie retras trebuie s fi fost deja identificat printr-un ablon i o adres a lui s fi fost reinut. Ca s reinem adresa unui ablon, ori indexul lui, folosim construcia:
?<var-idx> <- <ablon>
100
care poate s apar doar n partea stng a unei reguli. Dac ablonul se potrivete peste un fapt din baz, atunci variabila ?<var-idx> se va lega la indexul faptului. Cu aceasta, retragerea simultan a unui numr oarecare de fapte poate fi fcut printr-o comend: (retract ?<var-idx>*). Revenind la exemplul de adunare a celor dou numere, o prim tentativ ar putea fi urmtoarea:
(defrule aduna (numar ?x) (numar ?y) => (assert (suma =(+ ?x ?y))))
Faptul nou introdus cu comanda (assert ...) conine activarea unei evaluri (semnul = n faa apelului de funcie) ce utilizeaz operatorul de adunare. Cititorul va realiza c n aceeai manier se poate fora o evaluare cu orice alt operator, ori de cte ori se dorete ca valoarea unui cmp dintr-un fapt adugat s rezulte dinamic. Pn acum programul nostru a constat dintr-o singur regul. Pe aceasta am putut-o scrie direct la prompter. Dar cnd dimensiunea unui program e mai mare, maniera fireasc este s-l editm ntr-un fiier i, ca urmare, s-l ncrcm de acolo. Comanda pentru ncrcarea unui ir de declaraii dintr-un fiier este(load <nume-fiier>). Scriind o secven de declaraii defrule la prompter, sau comandnd ncrcarea lor dintr-un fiier, se construiete baza de reguli, ceea ce revine la construcia reelei. Comanda (reset) foreaz apoi propagarea modificrilorplus n reeaua de reguli prin alimentarea nodului rdcin. Prin aceasta se realizeaz fazele de filtrare i selecie. Lansarea efectiv n execuie a regulii selectate se realizeaz prin comanda (run). Aceast comand amorseaz procesul de inferen. n capitolele 3 i 6 am artat maniera n care se realizeaz legrile variabilelor din prile stngi ale regulilor la valori, ce sunt instanele de regul i cum se calculeaz acestea. Bnuim, probabil, c nu e cazul s ne ateptm ca lansarea programului construit mai sus s produc o baz de fapte de genul:
CLIPS> (facts) f-0 initial-fact f-1 (numar 2) f-2 (numar 1) f-3 (suma 3) CLIPS>
ntr-adevr, afiarea bazei de fapte, cu comanda (facts), relev existena n baz a nc dou fapte sum:
101
f-0 f-1 f-2 f-3 f-4 f-5
initial-fact (numar 2) (numar 1) (suma 2) (suma 3) (suma 4)
Cum de au aprut acolo i sumele 2 i 4? Pentru a rspunde, s revedem mecanismul de aplicare a regulilor. S presupunem c o regul i satisface toate abloanele asupra unei configuraii de fapte din baz. Spunem c s-a creat o activare a respectivei reguli. n acest caz, cel puin o instan a regulii trebuie s apar n agend. Aa cum tim, o instan a unei reguli este format dintr-un triplet ce asociaz numelui regulii o secven de fapte, cte unul pentru fiecare ablon din partea de condiii a regulii, i o configuraie de legri a variabilelor proprii la valori. Aceeai regul, mpreun cu o alt secven a unor fapte ce se potrivesc cu secvena de abloane a prii stngi, va genera o alt instan. E posibil deci ca n instane diferite s participe aceleai fapte dar ntr-o alt ordine.
regula inst1: irul de fapte (numar 2) aduna (numar 2) (numar 2) aduna (numar 1) (numar 1) aduna (numar 2) (numar 1) aduna (numar 1) legrile ?X 2 ?Y 2 ?X 2 ?Y 1 ?X 1 ?Y 2 ?X 1 ?Y 1
inst2:
inst3:
inst4:
Figura 27: Instanele regulii aduna
n exemplu nostru, n care apar regula aduna i faptele iniiale (numar 2) i (numar 1), partea de condiii a regulii, respectiv perechea de abloane (numar ?x) i (numar ?y), va crea instanele schiate n Figura 27. Ca urmare, pentru fiecare dintre aceste instane, presupunnd c toate s-ar aplica, faptul calculat de partea dreapt a regulii va fi:
102
inst1: ?X inst2: ?x inst3: ?x inst4: ?x
= = = =
2, 2, 1, 1,
?y ?y ?y ?y
= = = =
2 1 2 1
(suma (suma (suma (suma
4) 3) 3), deja existent 1)
Un program care nu se mai termin Modificnd un singur simbol n regula aduna facem ca ea s se aplice la nesfrit. Acest lucru se ntmpl, de exemplu, dac n loc de fapte (suma ) am crea tot fapte (numar ):
(defrule aduna (numar ?x) (numar ?y)=> (assert (numar =(+ ?x ?y))))
Bucla infinit e datorat faptului c la crearea fiecrui nou element din baz de forma (numar ), acesta va participa n attea activri cte fapte sunt deja n baz, ceea ce va duce la apariia a tot attea fapte noi, .a.m.d. Dac programul a intrat ntr-o bucl infinit, nu avem alt soluie dect s oprim programul prin mijloace brutale (<CTRL><C> sau <CTRL><ALT><DEL>, de exemplu).
7.2. Cum realizm o iteraie?

S calculm suma elementelor unui vector Primul exemplu de iteraie ce se d, de obicei, n orice carte de prezentare a unui limbaj este unul n care se parcurg elementele unei liste. S ncercm i noi s realizm o banal adunare a unui ir de numere. De data aceasta vom reprezenta irul de numere printr-un unic fapt numere, care are aparena unui vector. Mai avem nevoie de un fel de registru care s memoreze rezultate pariale ale sumei, la fiecare pas n iteraie, i care s fie iniializat cu 0:
(deffacts niste_numere (numere 2 7 5 3 4) (suma 0) )
Regula urmtoare realizeaz iteraia de sumare:

(defrule aduna ?r <- (numere ?x $?rest) ?s <- (suma ?y)
103
=> (retract ?r ?s) (assert (numere $?rest) (suma =(+ ?x ?y))) )
Cum funcioneaz ea? Partea de condiie a regulii conine o secven de dou abloane. Primul verific existena n baz a unui fapt numere care e urmat de cel puin un simbol (s observm c nimic n regul nu ncearc s valideze c ceea ce urmeaz dup simbolul numere sunt simboluri numerice; vom risca s nu ne lum aceast precauie). Condiia ca lungimea irului de numere s fie cel puin egal cu 1 este realizat prin variabila de ablon ?x urmat de variabila multi-cmp $?rest. Reinei aceast secven, pentru c ea este comun multor operaii de iteraii pe ir. ablonul (numere ?x $?rest) pune n eviden dup simbolul numere obligator un simbol, eventual i altele. n urma confruntrii, variabila simpl ?x se va lega la primul numr din secven, iar variabila multi-cmp $?y la restul lor. Ce de-al doilea ablon caut un fapt suma i leag variabila ?y de suma declarat n acest fapt. Dac aceste dou condiii sunt ndeplinite, cele dou fapte gsite sunt retrase i nlocuite cu un fapt numere mai scurt cu o poziie i, respectiv, o sum actualizat. Pentru orice ipostaz a bazei de fapte exist o unic activare, evident asociat acestei reguli, i, datorit acestui lucru, n lipsa conflictului, regula se aplic de fiecare dat. Aceasta se ntmpl pn cnd faptul numere nu mai conine nici un numr, caz n care faptul suma va conine rezultatul. Calculul unui maxim S presupunem c ne propunem s calculm maximul dintr-o secven de numere. Ca i mai sus, numerele sunt definite printr-un fapt numere care simuleaz un vector, iar un fapt max conine iniial primul numr din secven. Prima soluie este urmtoarea:
(deffacts initializari (numere 2 7 5 3 4) (max 2) ) (defrule max1 actualizeaza max ?r<-(numere ?x $?rest) ?s<-(max ?y) (test (> ?x ?y)) => (retract ?r ?s)
104
(assert (max ?x) (numere $?rest)) ) (defrule max2 max nu se schimba ?r<-(numere ?x $?rest) (max ?y) (test (<= ?x ?y)) => (retract ?r) (assert (numere $?rest)) )
Regula max1 nlocuiete faptul max cu un altul dac primul numr din secven e mai mare dect vechiul maxim. Construcia (test ) implementeaz o condiie prin evaluarea unei funcii predicat. n cazul regulilor de mai sus, aceste funcii realizeaz comparaii. Un test este satisfcut doar dac expresia pe care o ncorporeaz se evalueaz la un simbol diferit de false, altfel testul nu este satisfcut. O regul care conine un test n partea stng va fi activat doar dac testul este satisfcut mpreun cu toate celelalte abloane cuprinse n partea stng. Elementul condiional test nu este propriu-zis un ablon pentru c lui nu i corespunde un fapt din baz n situaia n care condiia este satisfcut. Regula max2 verific condiia complementar, situaie n care las neschimbat vechiul maxim dar elimin un element din vector. n ambele reguli nlocuirea vectorului cu unul mai scurt cu un element se face prin retragerea faptului (numere ) vechi i asertarea altuia nou care are toate elementele, cu excepia primului. n toate cazurile, variabila multi-cmp $?rest se leag la restul elementelor vectorului. Reguli ce se activeaz doar cnd altele nu se pot aplica Ceea ce deranjeaz n aceast soluie este necesitatea de a preciza att condiia > ct i pe cea complementar . Urmtoarea variant de program elimin testul complementar, care este unul redundant:
(deffacts initializari (numere 2 7 5 3 4) (max 2) ) (defrule max1 (declare (salience 10)) ?r<-(numere ?x $?rest) ?s<-(max ?y) (test (> ?x ?y))
105
=> (retract ?r ?s) (assert (max ?x) (numere $?rest)) ) (defrule max2 ?r<-(numere ? $?rest) => (retract ?r) (assert (numere $?rest)) )
Din regula max2 a disprut ablonul care identific elementul max din baz ct i testul de . Aadar, cum tim c max2 se aplic exact n cazurile n care nu se poate aplica max1? Rspuns: fcnd ca max1 s fie mai prioritar dect max2. Acesta este rostul declaraiei de salience din capul regulii max1. n CLIPS exist 20.001 niveluri de prioritate, ce se ntind n plaja 10.000 10.000, cu certitudine mai multe dect ar putea vreodat s fie utilizate ntr-un program. O regul fr declaraie de salience are, implicit, prioritatea 0. Valorile n sine ale prioritilor nu au importan, ceea ce conteaz fiind doar prioritile, unele n raport cu altele. Declaraiile de salience provoac o sortare a regulilor activate la oricare pas. Fcnd ca max1 s fie mai prioritar dect max2 form ca max2 s fie eliminat n faza de selecie care urmeaz filtrrii, ori de cte ori se ntmpl s fie ambele active. Cum ns condiiile regulii max2 sunt mai laxe dect cele ale regulii max1, ori de cte ori este activ max1, va fi activ i max2, iar prioritatea mai mare a lui max1 va face ca aceasta s fie preferat ntotdeauna lui max2. Rmne c max2 va putea fi aplicat numai cnd max1 nu este activat, ceea ce ar corespunde exact condiiei inverse, aa cum intenionam. Exemplul arat c, pentru a face ca o condiie de complementaritate s poat fi realizat printr-o declaraie de prioritate, trebuie s facem ca regula cu prioritate mai mic s aib o constrngere de aplicabilitate mai lax dect a regulilor cu care intr n competiie. Numai n acest fel ne asigurm c, n cazurile n care celelalte reguli nu se aplic, cea de prioritate mai mic nc i satisface condiiile pentru a putea fi aplicat. n cazul n care condiia aceasta nu e respectat, de exemplu cnd condiia implementat de regula mai puin prioritar este disjunct celei implementat de regula mai prioritar, atunci controlul prin declaraii de prioritate este inutil, pentru c el poate fi realizat direct prin condiii i, ca urmare, trebuie evitat. ntorcndu-ne la exemplul nostru, condiia de terminare a iteraiei se realizeaz impunnd ca faptul numere s mai conin cel puin o poziie (variabila ?x din ablon). Doar acest lucru face ca cel puin una din reguli s se aplice att ct mai exist mcar un numr neprocesat.
106
Revenind la o schem logic imperativ Un sistem bazat pe reguli e, n general, orientat spre alte tipuri de activiti dect cele ce se preteaz la o soluie imperativ. Am insistat suficient asupra acestui aspect n capitolul 1 al crii. N-ar trebui ns s nelegem prin aceasta c un sistem bazat pe reguli e incapabil s efectueze i tipuri de prelucrri specifice unui sistem imperativ. S ncercm n aceast seciune s nelegem cum trebuie procedat dac am dori s utilizm un sistem bazat pe reguli pentru a implementa o secven imperativ. Motivaia acestei tentative este aceea c pe parcursul rezolvrii unei probleme care necesit utilizarea mainriei bazate pe reguli poate s apar o subproblem care necesit o soluie imperativ. Cum procedm? Prsim sistemul bazat pe reguli pentru a construi o procedur imperativ care s fie apelat din acesta? E i aceasta o posibilitate, dar uneori e mai comod s gndim n maniera bazat pe reguli nsi acea secven.
iniializri
C1 ?
T
max1
F max2
C2 ?
S1
S2
Figura 28: Decuparea de reguli dintr-o diagram imperativ
Soluia imperativ a problemei de maxim este schiat n Figura 28. Aici, C1 este testul de terminare a iteraiei, C2 cel care verific ?x > ?y, S1 reprezint nlocuirea lui max din baz, iar S2 semnific scurtarea vectorului de numere cu un
107
element. Decuparea acestui algoritm n cele dou reguli este figurat n nuane diferite de gri. ntr-adevr max1 i max2 au n comun testul C1 cu ieire true i secvena S2, n timp ce max1 conine n plus secvena de actualizare a lui max. Iniializrile sunt realizate direct de declaraiile deffacts de includere de fapte n baz iar terminarea iteraiei (ieirea din testul C1 pe FALSE) se realizeaz automat n momentul n care nici una dintre regulile max1 i max2 nu-i mai satisfac condiiile, lucru care se ntmpl cnd faptul ce conine numerele a ajuns la forma: (numere). Cea de a treia soluie pe care o propunem zvorte din observaia c exist o anumit redundan a operaiunilor desfurate n cele dou reguli, manifestat n secvena S2. Preocuparea de a reduce redundana, n cazul de fa, poate prea exagerat, dar ea evideniaz o opiune ce poate deveni necesitate n alte ocazii. Aadar s ncercm s reducem redundana din cele dou reguli. Pentru aceasta va trebui s individualizm ntr-o regul separat operaia comun, minisecvena S2 ce conine decrementarea vectorului de numere. Vom introduce o secven set-rest care face acest lucru. Secvenierea regulilor devine acum cea din Figura 29, adic max1 ori max2 urmat de set-rest.
max1
max2
set-rest
Figura 29: O alt diagram de calcul al maximului
De data aceasta nu mai e posibil s umblm la prioriti pentru a impune o secven, fcnd de exemplu ca set-rest s aib o prioritate mai mic att dect max1 ct i dect max2, pentru c stabilirea acestei secvene nu se face n faza de selecie, ci ea ine de cicluri separate ale motorului. O soluie ar fi cea n care folosim un indicator (fanion), pe care max1 i max2 s-l seteze, iar set-rest s-l reseteze de fiecare dat, ca n Figura 30.
108
max1
max2
set-rest
Figura 30: Utilizarea unui fanion n calculul maximului
n secvena CLIPS care urmeaz fanionul setat are valoarea 1 i resetat 0.

(deffacts initializari (numere 2 7 5 3 4) (max 2) (fanion 0) ) (defrule max1 (declare (salience 10)) (numere ?x $?rest) ?s <- (max ?y) (test (> ?x ?y)) ?r <- (fanion 0) => (retract ?s ?r) (assert (fanion 1) (max ?x)) ) (defrule max2 ?r <- (flag 0) => (retract ?r) (assert (fanion 1)) ) (defrule set-rest ?r <- (numere ?x $?rest) ?s <- (fanion 1) => (retract ?r ?s) (assert (numere $?rest) (fanion 0)) )
109
n acest moment simim nevoia s anunm un rezultat i altfel dect prin includerea n baza de fapte. Scrierea ntr-un fiier sau n terminal se face printr-un apel de forma:
(printout <dispozitiv-logic> <element-tiprit>*)
n care:
<dispozitiv-logic> ::= t | <nume-logic> <element-tiprit> ::= <ir de caractere> | <variabil> | <constant> | crlf
Simbolul t este folosit pentru scrierea n terminal. crlf este un simbol a crui includere ntr-un apel al funciei de tiprire provoac trecerea la un rnd nou. Dac se dorete ca ieirea s apar ntr-un fiier, atunci fiierul trebuie deschis anterior printr-o comand:
(open <nume-fiier> <nume-logic> w)
Dup terminarea scrierii, fiierul trebuie nchis prin comanda

(close <nume-logic>)
Cu acestea, anunarea maximului, pentru oricare dintre soluiile de mai sus, se poate face astfel:
(defrule tipareste-max (numere) (max ?max) => (printout t Maximul: ?max crlf) )
Capitolul 8
Constrngeri n confruntarea abloanelor
n rularea oricrui program imaginabil pe un sistem de calcul exist un cod i nite date. n general, ntr-o rulare clasic, procesarea datelor se face la iniiativa programului. Un fir de execuie principal, sau mai multe (n cazul unei execuii paralele) cheam ori apeleaz alte componente de calcul, n funcie de nevoile dictate, la fiecare moment, de date. Componenta activ este programul i cea pasiv sunt datele. ntr-o rulare bazat pe reguli rolurile se inverseaz: practic datele i cheam codul ce le poate prelucra. E ca i cum regulile (ce formeaz corpul executabil) sunt flmnde s prelucreze faptele din baz, dar rmn inactive pn ce apar date care s corespund abilitilor de prelucrare pentru care ele au fost concepute. Prile drepte ale regulilor, ce formeaz componenta de prelucrare a sistemului, nu se activeaz dect atunci cnd prile stngi gsesc exact acele date ce convin. Prile stngi ale regulilor sunt ngheate n reelele de abloane, n timp ce modificri n baz, dictate de date, se propag prin aceste reele. Nu e surprinztor, aadar, ca necesitatea de a depista date ce convin regulilor s fi impus dezvoltarea unor mecanisme de regsire a datelor ct mai expresive. Cred, de aceea, c expresivitatea unui limbaj de programare bazat pe reguli trebuie apreciat n conformitate cu facilitile pe care le ofer n descrierea abloanelor. n acest capitol vom aprofunda descrierea de ablon pe care o ofer limbajul CLIPS, construind totodat o mic aplicaie care s etaleze o seam de necesiti ce pot aprea n confruntarea abloanelor regulilor cu faptele din baz. abloanele sunt constituite din simboluri, numere i variabile (acestea fiind simple ori multi-cmp). Am vzut pn acum cum putem indica acele pri constante, riguros exacte, pe care le dorim n faptele cutate, dar i cum putem lsa elemente ale faptelor s nu fie supuse nici unor restricii, aadar s fie lsate libere. Exist ns o plaj ntreag de constrngeri asupra cmpurilor care s acopere plaja de la o valoare complet specificat la o valoare total liber.
8.1. Interogri asupra unei baze de date

Fideli principiului c un limbaj se deprinde cel mai bine cnd avem n intenie construirea unei aplicaii, vom completa o mic baz cu informaii despre
112
nite piese de lego (reinnd, de exemplu, un identificator al pieselor, forma lor, materialul din care sunt fcute plastic sau lemn suprafaa, grosimea i culoarea lor), pentru ca, asupra ei, s putem organiza apoi interogri prin care s aflm: - toate piesele de alt culoare dect galben; - toate piesele de culoare fie rou fie galben; - toate piesele care au grosimea mai strict mic de 5 uniti (oricare ar fi ele), dar diferit de 2, dar s realizm i interogri ceva mai complicate: - toate piesele roii din plastic i verzi din lemn; - toate piesele din plastic cu aceeai arie ca a unor piese din lemn dar mai subiri dect acestea; - toate piesele de aceeai grosime, pe grupe de grosimi; - cele mai groase piese dintre cele de aceeai arie. Cum informaiile pe care trebuie s le memorm asupra pieselor cuprind o seam de trsturi diferite, ns aceleai pentru toate, o reprezentare obiectual a acestora este cea mai fireasc aici. CLIPS permite descrierea structurilor de obiecte prin declaraii de template combinate cu instanierea acestora ca fapte. Astfel, n mini-aplicaia noastr vom reprezenta piesele ca obiecte lego cu cmpurile id (pentru identificator), forma, material, arie, grosime i culoare:
(deftemplate lego (slot id) (slot forma) (slot material) (slot arie) (slot grosime) (slot culoare) ) (deffacts piese-lego (lego (id lego1) (forma cerc)(material plastic) (arie 10)(grosime 5)(culoare galben)) (lego (id lego2) (forma cerc)(material plastic) (arie 10)(grosime 4)(culoare albastru)) ... )
Din punct de vedere sintactic, constrngerile se descriu cu ajutorul unor operatori ce se aplic direct valorilor unor cmpuri sau variabilelor ce stau pe poziia unor cmpuri n abloane. Constrngerea NOT se realizeaz cu semnul tilda (~) plasat n faa unui
113
literal constant sau a unei variabile. Dac acest cmp se potrivete cu un cmp din fapt, atunci constrngerea NOT eueaz iar dac elementul prefixat cu ~ nu se potrivete peste valoarea din fapt, atunci constrngerea reuete. Utiliznd constrngerea NOT putem rspunde la ntrebarea toate piesele de alt culoare dect galben scriind un ablon:
(lego (culoare ~galben))
n plus, n cazul n care culoarea din acel cmp trebuie folosit undeva mai departe n regul, putem mperechea un nume de variabil cu constrngerea NOT:
(lego (culoare ?x&:~galben))
Simbolul constrngerii OR este bara vertical (|) i ea combin dou constrngeri ntr-o disjuncie. Rezultatul confruntrii reuete dac cel puin o constrngere dintre cele pe care le grupeaz reuete. Toate piesele de culoare fie rou fie galben, sunt gsite de un ablon:
(lego (culoare rosu|galben))
Simbolul constrngerii AND este ampersand (&) i el combin dou constrngeri ntr-o conjuncie. Rezultatul confruntrii reuete dac ambele constrngeri pe care le grupeaz astfel reuesc. De exemplu, pentru a cuta piesele care au grosimea mai mic strict de 5, dar diferit de 2, vom scrie:
(grosime ?x&:(< ?x 5)&~2)
Orice combinare a constrngerilor folosind ~, & i | poate fi realizat. Dac n condiie apar variabile, ele vor fi legate numai dac apar pe prima poziie n combinaie. n toate cazurile n care o variabil apare n interiorul unei constrngeri compuse, ea trebuie s fi fost anterior legat. De exemplu, atunci cnd cutm piese de grosime fie mai mic sau egal cu 3, fie egal cu 5, vom scrie:
(grosime ?x&:(<= ?x 3)|5)
n exemplele de mai sus s-au folosit cteva funcii predicat n scrierea constrngerilor. Iat o list (incomplet) din care programatorul poate s aleag: <, <=, <>, =, >, >=, and, or, not, eq, neq, evenp, oddp, integerp, floatp, stringp, symbolp etc.
114
Trecnd la problemele mai pretenioase, o prim tentativ de a rezolva cererea toate piesele roii din plastic i verzi din lemn duce la o bucl infinit:
(defrule selectie1-v1 ; toate piesele din plastic rosii si din lemn verzi (or (lego (id ?i)(material plastic)(culoare rosu)) (lego (id ?i)(material lemn)(culoare verde))) ?sel <- (selectie $?lis) => (retract ?sel) (assert (selectie $?lis ?i)) )
Motivul, aa cum ne putem lesne da seama, este modificarea faptului selectie la fiecare aplicare de regul, pentru c o modificare a unui fapt se face ntotdeauna prin tergerea lui i includerea n baz a unui fapt nou, deci cu un index nou. Acest lucru face ca perechea format dintr-un obiect lego i faptul selectie, ce determin o activare a regulii, s fie mereu alta n orice faz de filtrare i, drept urmare, refractabilitatea s nu dea roade. Putem repara aceast hib n mai multe moduri. Cea mai simpl cale e s eliminm obiectele din baz imediat dup ce le-am folosit, ca n varianta de regul de mai jos:
(defrule selectie1-v2 ; toate piesele din plastic rosii si din lemn verzi (or ?l <- (lego (id ?i)(material plastic)(culoare rosu)) ?l <- (lego (id ?i)(material lemn)(culoare verde))) ?sel <- (selectie $?lis) => (retract ?l ?sel) (assert (selectie $?lis ?i)) )
Exemplul mai pune n eviden i elementul condiional OR, ca i faptul c, sub el, pot avea loc inclusiv legri de variabile la indeci de fapte. Cum doar una dintre clauzele disjunciei va fi n final satisfcut, e suficient utilizarea unei singure variabile ce va fi legat la primul fapt, n ordinea din disjuncie, care se potrivete cu unul dintre abloane. Pentru c regula se aplic de mai multe ori, pn la urm toate obiectele ce satisfac una sau alta dintre condiiile disjunciei vor fi procesate i, n final, eliminate. O abordare de acest gen nu este ntotdeauna agreat pentru c afecteaz baza n mod neuniform: n urma procesrii unele obiecte vor fi disprut. Ca urmare, ar trebui s refacem baza dac dorim s o interogm n continuare. Putem ns lesne
115
face ca baza s rmn intact dup interogare: introducem un test care s mpiedice selectarea unui obiect ce se afl deja n lista selectie:
(defrule selectie1-v3 ; toate piesele din plastic rosii si din lemn verzi (or (lego (id ?i)(material plastic)(culoare rosu)) (lego (id ?i)(material lemn)(culoare verde))) ?sel <- (selectie $?lis) (test (not (member$ ?i $?lis))) => (retract ?sel) (assert (selectie $?lis ?i)) )
n aceast regul test este un element de realizare a condiiilor, ce poate fi utilizat n prile stngi ale regulilor pentru a evalua expresii n care apar funcii predicat. Predicatul multi-cmp member$, verific incluziunea primului argument n lista de cmpuri dat de cel de al doilea argument. S ncercm acum o soluie la cererea toate piesele din plastic cu aceeai arie ca a unor piese din lemn, dar mai subiri dect acestea.
(defrule selectie2 ; toate piesele din plastic cu aceeasi arie ca a unor piese din ; lemn dar mai subtiri (lego (material lemn)(arie ?a)(grosime ?g1)) (lego (id ?i)(material plastic)(arie ?a) (grosime ?g2&:(< ?g2 ?g1))) ?sel <- (selectie $?lis) (test (not (member$ ?i $?lis))) => (retract ?sel) (assert (selectie $?lis ?i)) )
Ca s rspundem la ntrebarea toate piesele de aceeai grosime, pe grupe de grosimi, avem nevoie de dou reguli. Prima construiete grupe de grosimi, iar a doua include piesele n grupe. Nu e nevoie ca aplicarea lor s fie dirijat n vreun fel. Faptele care descriu piesele pot fi considerate n orice ordine, n aa fel nct, ori de cte ori o pies de o grosime pentru care nu exist nc o grup este luat n considerare, grupa acesteia s fie construit, pentru ca, ulterior, o pies avnd aceeai grosime cu a unei grupe s fie inclus n grup:
(defrule selectie3-init-grupa
116
; initializeaza o grupa de grosimi (lego (id ?i) (grosime ?g1)) (not (gros ?g1 $?)) => (assert (gros ?g1 ?i)) ) (defrule selectie3-includ-in-grupa ; include un obiect in grupa corespunzatoare (lego (id ?i) (grosime ?g1)) ?g <- (gros ?g1 $?lista) (test (not (member$ ?i $?lista))) => (retract ?g) (assert (gros ?g1 $?lista ?i)) )
n sfrit, pentru interogarea cele mai groase piese dintre cele de aceeai arie, urmtoarea variant rezolv doar parial problema, pentru c ntoarce cte un singur obiect care satisface condiia de a fi cel mai mare dintre cele de aceeai arie:
(defrule selectie4 ; initializeaza o grupa de arii (lego (id ?i) (arie ?a1)) (not (arie ?a1 $?)) => (assert (arie ?a1 ?i)) ) (defrule selectie4-includ-in-grupa ; include un obiect in grupa corespunzatoare ; daca e mai gros decit cel existent deja (lego (id ?i) (arie ?a1) (grosime ?g1)) ?a <- (arie ?a1 ?j) (lego (id ?j) (grosime ?g2&:(> ?g1 ?g2))) => (retract ?a) (assert (arie ?a1 ?i)) )
Varianta urmtoare gsete toate obiectele care se presupune c au aceeai grosime maxim ntre cele de aceeai arie:
(defrule selectie4-init ; initializeaza o grupa de arii (lego (id ?i) (arie ?a1))
117
(not (arie ?a1 $?)) => (assert (arie ?a1 ?i)) ) (defrule selectie4-inlocuieste-in-grupa ; initializeaza o grupa cu un obiect daca are aria corespunzatoare ; grupei si daca e mai gros decit oricare dintre cele existente deja ; in grupa (lego (id ?i) (arie ?a1) (grosime ?g1)) ?a <- (arie ?a1 $?list) (lego (id ?j) (grosime ?g2&:(> ?g1 ?g2))) (test (member$ ?j $?list)) => (retract ?a) (assert (arie ?a1 ?i)) ) (defrule selectie4-includ-in-grupa ; include un obiect in grupa corespunzatoare ; daca e la fel de gros decit oricare dintre cele existente deja (lego (id ?i) (arie ?a1) (grosime ?g1)) ?a <- (arie ?a1 $?list) (test (not (member$ ?i $?list))) (lego (id ?j) (grosime ?g1)) (test (member$ ?j $?list)) => (retract ?a) (assert (arie ?a1 $?list ?i)) )
8.2. Un exemplu de sortare

Problema care urmeaz trateaz un aspect des ntlnit n programare: sortarea listelor. Pretextul va fi o mic aplicaie ce-i propune s acorde gradaii de merit profesorilor dintr-un liceu. Exist mai multe criterii dup care aceste gradaii se acord: gradul didactic, numrul de elevi ndrumai de profesor i care au participat la olimpiade, numrul de publicaii ale cadrului didactic, vechimea lui etc. Se cunosc numerele de puncte ce se acord pentru fiecare criteriu n parte. Datele despre personalul didactic sunt nregistrate ntr-o baz de date. Aplicaia noastr va trebui s ordoneze profesorii n vederea acordrii gradaiilor de merit, prin aplicarea acestor criterii.
118
Aplicaia ncepe prin definiia cadrelor de fapte care vor memora numele profesorilor i datele ce se cunosc despre ei. Aceste date vor fi folosite pentru aplicarea criteriilor de acordare a gradaiilor de merit. Exemplul nostru folosete patru profesori ai cror parametri sunt memorai imediat dup definiiile de template:
(deftemplate persoana (slot nume) (slot sex) (slot varsta) (slot vechime) (slot grad) (slot nr-ore) (multislot olimpiade) (slot publicatii) ) (deffacts personal (persoana (nume Ionescu)(sex b)(varsta 30)(vechime 5)(grad 2)(nr-ore 18)(olimpiade 1999 3 1998 5 1997 2)(publicatii 2)) (persoana (nume Popescu)(sex f)(varsta 35)(vechime 10)(grad 1)(nr-ore 17)(olimpiade 1999 4 1998 5 1997 3)(publicatii 1)) (persoana (nume Georgescu)(sex f)(varsta 32)(vechime 7)(grad 2)(nr-ore 18)(olimpiade 1999 5 1998 6 1997 1)(publicatii 0)) (persoana (nume Isopescu)(sex f)(varsta 40)(vechime 25)(grad 0)(nr-ore 20)(olimpiade 1999 1 1998 1 1997 1)(publicatii 0)) )
Se definete template-ul faptelor care vor nregistra punctajele persoanelor. Apoi aceste fapte sunt iniializate la valorile 0 ale punctajului:
(deftemplate punctaj (slot nume) (slot valoare) ) (deffacts puncte (punctaj (nume (punctaj (nume (punctaj (nume (punctaj (nume )
Ionescu)(valoare 0)) Popescu)(valoare 0)) Georgescu)(valoare 0)) Isopescu)(valoare 0))
119
Primele reguli calculeaz punctajele corespunztoare activitilor profesorilor. Regula criteriu-grad aplic criteriul grad didactic. La fiecare aplicare a acestei reguli ntr-un fapt punctaj al unei persoane se modific cmpul valoare prin adugarea unui numr de puncte corespunztor gradului didactic indicat prin comentarii n antetul regulii. Pentru prima dat n aceast regul avem un exemplu de folosire a comenzii if:
(defrule criteriu-grad ; doctor = 50 puncte ; grad 1 = 30 puncte ; grad 2 = 20 puncte ; definitivat = 10 puncte ; grad 0 = 0 puncte ?per <- (persoana (nume ?num) (grad ?grd&~folosit)) ?pct <- (punctaj (nume ?num) (valoare ?val)) => (modify ?per (grad folosit)) (if (eq ?grd doctor) then (modify ?pct (valoare =(+ ?val 50))) else (if (eq ?grd 1) then (modify ?pct (valoare =(+ ?val 30))) else (if (eq ?grd 2) then (modify ?pct (valoare =(+ ?val 20))) else (if (eq ?grd definitivat) then (modify ?pct (valoare =(+ ?val 10))))))) )
Regula criteriu-olimpiade se aplic de un numr de ori egal cu numrul de profesori multiplicat cu numrul de olimpiade n care acetia au avut elevi:
(defrule criteriu-olimpiade ; fiecare elev la olimpiada in ultimii 3 ani aduce 5 ; puncte ?per <- (persoana (nume ?num) (olimpiade ?an ?elevi $?rest)) ?pct <- (punctaj (nume ?num) (valoare ?val)) => (modify ?per (olimpiade $?rest)) (modify ?pct (valoare =(+ ?val (* 5 ?elevi)))) )
120
Regula criteriu-vechime se aplic cte o dat pentru fiecare persoan. Conform criteriului de vechime, la fiecare aplicare valoarea punctajului persoanei este incrementat cu un numr egal cu numrul anilor de vechime:
(defrule criteriu-vechime ; fiecare an de vechime aduce 1 punct ?per <- (persoana (nume ?num) (vechime ?ani&~folosit)) ?pct <- (punctaj (nume ?num) (valoare ?val)) => (modify ?per (vechime folosit)) (modify ?pct (valoare =(+ ?val (* 1 ?ani)))) )
Regula criteriu-publicatii se aplic din nou cte o dat pentru fiecare persoan. Conform criteriului publicaiilor, la fiecare aplicare valoarea punctajului persoanei este incrementat cu de dou ori numrul publicaiilor acesteia:
(defrule criteriu-publicatii ; fiecare publicatie aduce 2 puncte ?per <- (persoana (nume ?num) (publicatii ?publ&~folosit)) ?pct <- (punctaj (nume ?num) (valoare ?val)) => (modify ?per (publicatii folosit)) (modify ?pct (valoare =(+ ?val (* 2 ?publ)))) )
i regula criteriu-nr-ore are un numr de aplicaii egal cu numrul persoanelor. La fiecare aplicare valoarea punctajului persoanei este incrementat cu jumtate din numrul orelor prestate de aceasta sptmnal:
(defrule criteriu-nr-ore ; fiecare ora pe saptamina aduce 0.5 puncte ?per <- (persoana (nume ?num) (nr-ore ?ore&~folosit)) ?pct <- (punctaj (nume ?num) (valoare ?val)) => (modify ?per (nr-ore folosit)) (modify ?pct (valoare =(+ ?val (* 0.5 ?ore)))) )
Urmeaz trei reguli de sortare. Prioritile acestor trei reguli sunt, toate, -100, deci mai mici dect ale regulilor de aplicare a criteriilor, date mai sus. Ca urmare, aceste trei reguli se vor aplica numai n cazul n care nici o regul din cele de mai
121
sus nu mai poate fi aplicat. Acest lucru se ntmpl numai cnd toate cmpurile faptelor persoan sunt folosite deja. Cititorul a observat, cu siguran, c am marcat faptul c s-a lucrat asupra unui cmp al unui fapt persoana, prin nregistrarea valorii folosit n acest cmp. Regula sortare-initializare se aplic o singur dat, la nceputul sortrii persoanelor, i ea va introduce un fapt lista-final iniial vid. O pereche, format dintr-un nume de profesor ales la ntmplare i valoarea punctajului su, va intra apoi n aceast list. Faptul punctaj corespunztor este retras pentru a nu mai fi luat nc o dat n considerare:
(defrule sortare-initializare ; initializeaza lista finala in care persoanele vor fi ; asezate in ordinea descrescatoare a punctajelor (declare (salience -100)) (not (lista-finala $?)) ?pct <- (punctaj (nume ?num) (valoare ?val)) => (assert (lista-finala ?num ?val)) (retract ?pct) )
Vom sorta lista-final n ordinea descresctoare a punctajelor calculate. Regula sortare-extrema-stinga trateaz cazul n care o valoare de punctaj a unui profesor este mai mare dect cea mai mare valoare nscris n list, adic cea din extrema stng a listei. Perechea format din numele persoanei i valoarea punctajului su este inclus acolo:
(defrule sortare-extrema-stinga ; plaseaza o persoana in capul listei (declare (salience -100)) ?lst <- (lista-finala ?prim-nume ?prim-val $?ultime) ?pct <- (punctaj (nume ?num) (valoare ?val&:(> ?val ?prim-val))) => (assert (lista-finala ?num ?val ?prim-nume ?prim-val $?ultime)) (retract ?lst ?pct) )
Regula sortare-extrema-dreapta trateaz cazul n care o valoare de punctaj a unui profesor este mai mic dect cea mai mic valoare nscris n list, adic cea din extrema dreapt:
(defrule sortare-extrema-dreapta
122
; plaseaza o persoana in coada listei (declare (salience -100)) ?lst <- (lista-finala $?prime ?ultim-nume ?ultim-val) ?pct <- (punctaj (nume ?num) (valoare ?val&:(< ?val ?ultim-val))) => (assert (lista-finala $?prime ?ultim-nume ?ultim-val ?num ?val)) (retract ?lst ?pct) )
Ultimul caz tratat este cel al unei valori care trebuie plasat ntre dou valori aflate n list:
(defrule sortare-mijloc ; plaseaza o persoana intre alte doua persoane in lista (declare (salience -100)) ?lst <- (lista-finala $?prime ?un-nume ?o-val&:(numberp ?o-val) ?alt-nume ?alt-val $?ultime) ?pct <- (punctaj (nume ?num) (valoare ?val&:(and (< ?val ?o-val) (> ?val ?alt-val)))) => (assert (lista-finala $?prime ?un-nume ?o-val ?num ?val ?alt-nume ?alt-val $?ultime)) (retract ?lst ?pct) )
Capitolul 9
Despre controlul execuiei
9.1. Criterii utilizate n ordonarea agendei
Agenda este o structur folosit de motorul CLIPS pentru pstrarea informaiilor privitoare la activrile regulilor de la un ciclu al motorului la urmtorul. Ea este o list ordonat de instane (sau activri) de reguli. Plasarea unei activri de regul n aceast list se face dup urmtoarele criterii, n ordine: - regulile nou activate sunt plasate deasupra tuturor celor de o prioritate mai mic i dedesubtul tuturor celor de o prioritate mai mare; - printre regulile de egal prioritate, plasarea se bazeaz pe strategia de rezoluie a conflictelor activat implicit sau explicit; - dac primele dou criterii nu reuesc s stabileasc o ordine total ntre noile reguli activate de aceeai introducere ori retragere a unui fapt, atunci plasarea se face arbitrar (i nu aleator), adic este dependent de implementare. Programatorul este sftuit s nu se bazeze pe observaii empirice asupra manierei de ordonare a agendei. La momentul execuiei, activarea aflat pe prima poziie n agend va fi cea executat. Orice modificare ce se produce n agend ntre dou momente de execuie nu influeneaz n nici un fel rularea. O schi a activitilor motorului ce sunt amorsate de comenzi este dat n Figura 31. Dup cum se constat, primul criteriu al ordonrii agendei n vederea seleciei l constituie prioritatea regulilor i abia al doilea este strategia de rezoluie. Programatorul trebuie s deprind exploatarea corect a prioritii. Declaraii de prioritate au fost utilizate nc din capitolul precedent. n acest capitol, ct i n cel ce urmeaz, motivaia principal n prezentarea exemplelor va fi centrat pe utilizarea declaraiilor de prioritate. n primul exemplu vom utiliza ns o singur regul, ceea ce face ca o declaraie de prioritate s nu-i aib sens. Trasarea rulrii ne va ajuta s urmrim evoluia agendei.
124
declaraii de fapte (deffacts ...) (deffacts ...) comanda (reset)
- nici o modificare n baz; - faptele sunt introduse n baz n ordinea declarrii, ca modificri-plus ce sunt propagate n reea; - orice activare de regul ce poate astfel aprea este introdus n agend n poziia corespunztoare, conform criteriilor enunate mai sus; - prima activare din agend este lansat n execuie; - fiecare comand a prii drepte a regulii afecteaz baza de fapte; - apar modificri-plus i modificriminus ce sunt propagate n reea; - orice regul dezactivat este eliminat din agend; - orice activare de regul este introdus n agend n poziia corespunztoare; - prima activare din agend este lansat n execuie;
comanda (run)
comenzile prii drepte
comenzile prii drepte
etc.
Figura 31: Activitile motorului
Exemplele care urmeaz evideniaz diferite maniere de control al execuiei. n primul, o declaraie de prioritate a regulilor lipsete cu desvrire. i totui vom vedea c putem influena controlul prin ordinea comenzilor sau modificarea strategiei.
125
9.2. Urmrirea execuiei

S presupunem c avem o mini-baz de date cu preul pe kilogram al unor fructe:
(deffacts preturi-fructe (pret mere 10000) (pret pere 18000) (pret struguri 24000) )
S mai presupunem c plecm de acas cu o list a fructelor i a cantitilor pe care dorim s le cumprm:
(deffacts de-cumparat (cumpar mere 5) (cumpar pere 3) (cumpar struguri 2) )
i c o alt seciune a datelor conine o variabil ce ne va da, la ntoarcerea acas, ct am cheltuit:

(deffacts buzunar (suma 0) )
Dorim ca valoarea sumei s fie actualizat corespunztor cumprturilor efectuate. Pentru a face lucrurile ct mai simple, vom admite c fondul de bani de care dispunem este nelimitat. Atunci, tot ce avem de fcut este s lsm s ruleze o regul de felul:
(defrule cumpar_un_fruct ?c <- (cumpar ?fruct ?kg) (pret ?fruct ?lei) ?s <- (suma ?suma) => (retract ?f ?s) (assert (suma =(+ ?suma (* ?kg ?lei)))) )
La fiecare aplicare, un fapt cumpar dispare din baz iar valoarea cheltuit pentru fructele corespunztoare este adunat la suma deja cheltuit.
126
Mediul CLIPS are mai multe metode de a urmri o execuie. Una din ele este invocarea comenzii (watch <parametri>). Ea poate primi ca parametri: activations, facts, rules, statistics etc. Vom urmri efectul drii acestei comenzi nainte de rularea programului nostru pentru a nelege mai bine maniera n care regulile se activeaz i faptele sunt retrase ori incluse n baz n cursul execuiei. La ncrcarea programului printr-o comand (load ...) sau la definirea la prompter a faptelor, acestea nu sunt nc incluse n baz. Dup cum arat i Figura 31, acest lucru se realizeaz o dat cu execuia comenzii (reset).
CLIPS> (reset) ==> f-0 (initial-fact) ==> f-1 (pret mere 10000) ==> f-2 (pret pere 18000) ==> f-3 (pret struguri 24000) ==> f-4 (cumpar mere 8) ==> f-5 (cumpar pere 3) ==> f-6 (cumpar struguri 2) ==> f-7 (suma 0)
Sgeile spre dreapta indic faptele introduse n baz. Faptul (initialfact) are ntotdeauna indexul f-0. Faptele incluse de program sunt cele cu indecii de la f-1 la f-7. n continuare, trasarea indic trei activri de reguli, n fapt trei instane ale singurei reguli definite, cumpar-un-fruct:
==> Activation 0 ==> Activation 0 ==> Activation 0 cumpar-un-fruct: f-6,f-3,f-7 cumpar-un-fruct: f-5,f-2,f-7 cumpar-un-fruct: f-4,f-1,f-7
Indecii care urmeaz numelui regulii sunt faptele care sunt satisfcute de cele trei abloane ale regulii, primul de tip (cumpar...), al doilea de tip (pret...) i al treilea singurul fapt (suma...):
(defrule ?c <(pret ?s <=> ... ) cumpar_un_fruct (cumpar ?fruct ?kg) ?fruct ?lei) (suma ?suma)
Rezult c prima activare corespunde configuraiei de fapte:
127
f-6 f-3 f-7
(cumpar struguri 2) (pret struguri 24000) (suma 0)
a doua configuraiei:
f-5 f-2 f-7 (cumpar pere 3) (pret pere 18000) (suma 0)
iar a treia configuraiei:

f-4 f-1 f-7 (cumpar mere 8) (pret mere 10000) (suma 0)
Dac am considera o alt ordine de apariie a faptelor n baz dect cea dat, de exemplu plasnd declaraia de sum naintea declaraiilor fructelor:
(deffacts buzunar (suma 0) ) (deffacts de-cumparat (cumpar mere 5) (cumpar pere 3) (cumpar struguri 2) )
constatm o uoar modificare a trasrii, n conformitate cu schema de propagare a modificrilor dat de algoritmul RETE, care este reluat schematizat n Figura 31:
CLIPS> (reset) ==> f-0 (initial-fact) ==> f-1 (suma 0) ==> f-2 (pret mere 10000) ==> f-3 (pret pere 18000) ==> f-4 (pret struguri 24000) ==> f-5 (cumpar mere 8) ==> Activation 0 cumpar-un-fruct: f-5,f-2,f-1 ==> f-6 (cumpar pere 3) ==> Activation 0 cumpar-un-fruct: f-6,f-3,f-1 ==> f-7 (cumpar struguri 2) ==> Activation 0 cumpar-un-fruct: f-7,f-4,f-1
128
CLIPS>
ntruct faptele suma i pret sunt deja introduse, la fiecare apariie a unui fapt cumpar, o nou activare apare n agend. S presupunem, n continuare, c revenim la ordinea iniial de declarare a faptelor. Rularea, amorsat de comanda (run), decurge astfel:
CLIPS> (run) FIRE 1 cumpar-un-fruct: f-4,f-1,f-7 <== f-4 (cumpar mere 8) <== f-7 (suma 0) <== Activation 0 cumpar-un-fruct: <== Activation 0 cumpar-un-fruct: ==> f-8 (suma 80000) ==> Activation 0 cumpar-un-fruct: ==> Activation 0 cumpar-un-fruct:
f-5,f-2,f-7 f-6,f-3,f-7 f-6,f-3,f-8 f-5,f-2,f-8
Trasarea indic prima aprindere a regulii cumpar-un-fruct datorit potrivirii configuraiei de fapte: f-4,f-1,f-7 cu partea de condiii a regulii. Aprinderea n ordine invers fa de ordinea includerilor n agend se datoreaz utilizrii strategiei depth, care este implicit n lipsa unei declaraii explicite de strategie. Dar asupra strategiilor utilizate n CLIPS vom reveni imediat. n continuare, trasarea indic evenimente induse de executarea prii de aciuni a regulii cumpar_un_fruct:
... => (retract ?f ?s) (assert (suma =(+ ?suma (* ?kg ?lei)))) )
Sgeile spre stnga indic retrageri de fapte din baz i dispariiile unor activri din agend. Aadar aprinderea instanei f-4,f-1,f-7 a regulii cumpar-un-fruct duce la eliminarea faptelor cu indecii f-4 i f-7. Totodat, cum faptul f-7 intra n condiiile ambelor instane rmase, dispariia lui din baz este resimit imediat n agend prin dezactivarea acestor instane. Rezultatul executrii comenzii (assert ...) este apariia unui nou fapt de tip sum, de index f-8: (suma 80000). Apariia acestui fapt, corelat cu existena n baz a celorlalte fapte, duce la activarea a dou noi instane ale regulii cumpar-un-fruct, respectiv datorate secvenelor de fapte f-6,f-3,f-8 i f-5,f-2,f-8. Rularea continu astfel:
129
FIRE 2 cumpar-un-fruct: f-5,f-2,f-8 <== f-5 (cumpar pere 3) <== f-8 (suma 80000) <== Activation 0 cumpar-un-fruct: f-6,f-3,f-8 ==> f-9 (suma 134000) ==> Activation 0 cumpar-un-fruct: f-6,f-3,f-9 FIRE 3 cumpar-un-fruct: f-6,f-3,f-9 <== f-6 (cumpar struguri 2) <== f-9 (suma 134000) ==> f-10 (suma 182000)
Dac efectuarea unor statistici asupra rulrii, printr-o comand (watch statistics), a fost, de asemenea, invocat, un raport final ncheie trasarea. El indic numrul total de reguli aprinse, timpul total de execuie n secunde, o estimare a numrului mediu de reguli aprinse pe secund etc.
3 rules fired Run time is 0.1850000000013096 seconds. 16.21621621610141 rules per second. 7 mean number of facts (8 maximum). 1 mean number of instances (1 maximum). 2 mean number of activations (3 maximum). CLIPS>
9.3. Strategii de rezoluie a conflictelor

Atunci cnd, dup faza de filtrare, agenda structura responsabil cu memorarea instanelor regulilor potenial active conine mai mult dect o singur regul, iar declaraiile de prioritate nu sunt capabile s introduc o ordonare total a regulilor candidate la a fi aprinse, selecia trebuie s decid asupra uneia, care s fie apoi executat. Acest lucru se poate realiza simplu prin alegerea primei reguli gsite. De cele mai multe ori ns se prefer s se fac uz de anumite criterii strategii de rezoluie a conflictelor care ar mri ansele de gsire a soluiei. Prima strategie este mai mult un principiu, pentru c nu introduce o ordonare a instanelor regulilor din agend ci i propune s mpiedice intrarea motorului de inferene n bucle infinite, prin repetarea la nesfrit a acelorai secvene de reguli aplicate asupra acelorai fapte. Ea a fost amintit deja n capitolul 3 unde am vorbit despre fazele motorului. Este vorba despre principiul refractabilitii, care nu permite includerea n agend a acelor instane ce au fost deja procesate n cicluri anterioare ale rulrii. Shell-urile consacrate de sisteme bazate pe reguli au aceast strategie cablat.
130
CLIPS implementeaz cteva strategii de rezoluie a conflictelor. Strategia implicit este cea n adncime (depth strategy), dar ea poate fi schimbat prin comanda setstrategy (care reordoneaz agenda n conformitate): Strategia n adncime (depth strategy): regulile nou activate sunt plasate n agend n faa celor mai vechi de aceeai prioritate. Este strategia implicit n CLIPS. Strategia n lrgime (breadth strategy): regulile nou activate sunt plasate n agend n spatele celor mai vechi de aceeai prioritate. Strategia complexitii (complexity strategy): regulile nou activate sunt plasate n agend n faa tuturor activrilor de reguli de egal sau mai mic specificitate. Aceast strategie d prioritate regulilor cu condiii mai complexe. Motivaia este desigur aceea c o condiie mai complex va fi satisfcut ntr-o situaie mai specific. O msur aproximativ a complexitii este dat de numrul de comparri ce trebuie realizate de partea stng a regulii: - fiecare comparare cu o constant sau o variabil deja legat conteaz ca un punct; - fiecare apel de funcie fcut n partea stng ca parte a unui element :, = sau test adaug un punct; - funciile booleene and i or nu adaug puncte dar argumentele lor adaug; - apelurile de funcii fcute n interiorul altor apeluri nu conteaz. Strategia simplicitii (simplicity strategy): ntre activrile de aceeai prioritate declarat, regulile nou activate sunt plasate n agend n faa tuturor activrilor regulilor de egal sau mai mare specificitate. Strategia aleatorie (random strategy): regulile activate din agend sunt ordonate aleator.
9.4. Importana ordinii asertrilor

Pn acum nu am dat nici o importan ordinii n care am scris faptele noi n comenzile (assert...). Surprinztor, ori poate nu, ordinea de apariie a faptelor n baz conteaz. S considerm urmtorul exemplu:
(deffacts baza (fapt a) ) (defrule r1 ?fa<-(fapt a) =>
131
(printout t r1 crlf) (retract ?fa) (assert (fapt b) (fapt c)) ) (defrule r2 (fapt b) => (printout t r2 crlf) ) (defrule r3 (fapt c) => (printout t r3 crlf) )
Ordinea asertrilor n regula r1 este nti faptul b i apoi faptul c. Urmarea este c n agend se va introduce mai nti activarea regulii r2 i apoi cea a regulii r3. Utilizarea strategiei n adncime face ca prima regula aprins s fie cea corespunztoare ultimei activri introduse n agend, deci r3. Ordinea aprinderilor va fi deci r1, r3, r2.
CLIPS> (load ordineAssert1.clp) TRUE CLIPS> (reset) ==> f-0 (initial-fact) ==> f-1 (fapt a) ==> Activation 0 r1: f-1 CLIPS> (run) FIRE 1 r1: f-1 r1 <== f-1 (fapt a) ==> f-2 (fapt b) ==> Activation 0 r2: f-2 ==> f-3 (fapt c) ==> Activation 0 r3: f-3 FIRE 2 r3: f-3 r3 FIRE 3 r2: f-2 r2 CLIPS>
Schimbarea ordinii asertrilor n r1:
132
(defrule r1 ?fa<-(fapt a) => (printout t r2 crlf) (retract ?fa) (assert (fapt c) (fapt b)) )
face ca introducerea n agend a activrilor s fie acum n ordinea r3, r2, deci ordinea aprinderilor s fie r1, r2, r3:
CLIPS> (load ordineAssert2.CLP) TRUE CLIPS> (reset) ==> f-0 (initial-fact) ==> f-1 (fapt a) ==> Activation 0 r1: f-1 CLIPS> (run) FIRE 1 r1: f-1 r1 <== f-1 (fapt a) ==> f-2 (fapt c) ==> Activation 0 r3: f-2 ==> f-3 (fapt b) ==> Activation 0 r2: f-3 FIRE 2 r2: f-3 r2 FIRE 3 r3: f-2 r3 CLIPS>
Este evident c o schimbare a ordinii activrilor poate duce la execuii complet diferite.
9.5. Eficientizarea execuiei prin schimbarea ordinii comenzilor retract i assert

S revenim la exemplul gradaiilor de merit prezentat n capitolul 8. ntr-un context n care regula sortare-initializare nu era prevzut s se activeze, nedumerea numrul repetat de activri ale ei, ca n trasarea:
FIRE 30 sortare-extrema-stinga: f-64,f-49 <== f-64 (lista-finala Ionescu 88.0)
133
<== Activation -100 sortare-extrema-dreapta: f-64,f-21 <== Activation -100 sortare-extrema-stinga: f-64,f-35 ==> Activation -100 sortare-initializare: f-0,,f-21 ==> Activation -100 sortare-initializare: f-0,,f-35 ==> Activation -100 sortare-initializare: f-0,,f-49 <== f-49 (punctaj (nume Popescu) (valoare 110.5)) <== Activation -100 sortare-initializare: f-0,,f-49 ==> f-65 (lista-finala Popescu 110.5 Ionescu 88.0) ==> Activation -100 sortare-extrema-dreapta: f-65,f-21 <== Activation -100 sortare-initializare: f-0,,f-35 <== Activation -100 sortare-initializare: f-0,,f-21 FIRE 31 sortare-extrema-dreapta: f-65,f-21
Cauza e ordinea comenzilor retract i assert n prile drepte ale regulilor de sortare: retract urmat de assert. Rezultatul acestei ordini este c ntre momentul n care faptul lista-finala este retras i cel n care un nou fapt lista-finala este asertat, regula sortare-initializare, ce verific n partea ei stng lipsa unui fapt lista-finala din baz, i satisface condiiile de aplicabilitate i o activare a ei este inclus n agend. Fr ca acest lucru s influeneze execuia, pentru c imediat ce noul fapt lista-finala apare, regula sortare-initializare se dezactiveaz, lucrul este de natur a afecta viteza de execuie a programului. Corecia const n inversarea ordinii acestor dou comenzi, ca n:
(defrule sortare-extrema-dreapta ; plaseaza o persoana in coada listei (declare (salience -100)) ?lst <- (lista-finala $?prime ?ultim-nume ?ultim-val) ?pct <- (punctaj (nume ?num) (valoare ?val&:(< ?val ?ultim-val))) => (assert (lista-finala $?prime ?ultim-nume ?ultim-val ?num ?val)) (retract ?lst ?pct) )
nti se aserteaz un al doilea fapt lista-finala i abia apoi cel vechi este retras. Ca urmare, imediat dup introducerea pentru prima oar a unui astfel de fapt, nu va mai exista nici un moment n care el s lipseasc din baz, ceea ce va face ca regula sortare-initializare s nu se mai activeze la fiecare pas al sortrii. Aceeai secven dintre dou aprinderi de mai sus, va raporta acum:
134
FIRE 30 sortare-extrema-stinga: f-64,f-49 ==> f-65 (lista-finala Popescu 110.5 Ionescu 88.0) ==> Activation -100 sortare-extrema-dreapta: f-65,f-21 <== f-64 (lista-finala Ionescu 88.0) <== Activation -100 sortare-extrema-dreapta: f-64,f-21 <== Activation -100 sortare-extrema-stinga: f-64,f-35 <== f-49 (punctaj (nume Popescu) (valoare 110.5)) FIRE 31 sortare-extrema-dreapta: f-65,f-21
Capitolul 10
Recursivitatea n limbajele bazate pe reguli
Paradigma de programare prin reguli nu rejecteaz a priori conceptul de recursivitate. Comportamentul recursiv poate s apar cnd limbajul permite unei reguli s apeleze alte reguli. Atunci, ori de cte ori o regul invoc aceeai regul, sau pe una care o invoc pe prima, avem un comportament recursiv. Limbajele care accept recursivitate utilizeaz, implicit, stiva. Un apel recursiv nu difer, n esen, de un apel oarecare pentru c el este tradus, prin compilare, n aceleai tipuri de operaii asupra stivei interne. Limbajul CLIPS nu ncorporeaz trstura de recursivitate. n primul rnd, n CLIPS o regul nu este apelat n accepiunea clasic de apel din programare. Am putea spune c o regul se prinde singur cnd a sosit momentul n care si ofere serviciile. n al doilea rnd, limbajul nu permite ca, n secvena de operaii ce se desfoar dup aprinderea unei reguli, adic n cursul executrii prii ei drepte, alte reguli s poat fi chemate. Din acest motiv stiva nu este un accesoriu firesc al implementrii limbajului CLIPS. Ne punem, firesc, ntrebarea: putem derecursiva, prin reguli, algoritmi recursivi? Rspunsul este, desigur, pozitiv i esena soluiei const n realizarea explicit a stivei. Ca exemplificare, ne propunem s realizm prin reguli doi dintre cei mai comuni algoritmi recursivi: problema turnurilor din Hanoi i factorialul unui numr natural.
10.1. Turnurile din Hanoi

Bine-cunoscuta problem a turnurilor din Hanoi (un numr de discuri gurite la mijloc, de diametre descresctoare n formularea original 64, formeaz o stiv pe un suport, s-l numim A; se cere s se transfere aceste discuri pe un suport B, folosind ca intermediar un suport C, micnd un singur disc o dat i n aa fel nct la orice moment n configuraiile celor trei stive s nu apar un disc de diametru mai mare peste unul de diametru mai mic) are urmtoarea soluie, ntr-o formulare liber: ca s transfer n (n>1) discuri de pe A pe B folosind C drept intermediar: - transfer, n acelai mod, n-1 discuri de pe A pe C folosind B drept intermediar
136
- mut al n-lea disc de pe A pe B - transfer, n acelai mod, n-1 discuri de pe C pe B folosind A drept intermediar sau, ntr-o scriere pseudo-cod n care one-move(a, b) semnific mutarea unui disc de pe a pe b (vezi i Figura 32):
1
2 A B 3 C
Figura 32: Turnurile din Hanoi
1. procedure hanoi(n, a, b, c) ; n numarul de discuri ; a suportul de plecare ; b suportul de destinatie ; c suportul ajutator 2. begin 3. if n=1 then one-move(a, b) else
137
4. begin 5. hanoi(n-1, a, c, b) 6. one-move(a, b) 7. hanoi(n-1, c, b, a) 8. end 9. end
Pentru transpunerea acestui algoritm n reguli, va trebui, aa cum am mai artat, s introducem o structur de date care s aib comportamentul unei stive. La nceput stiva va conine apelul iniial al procedurii recursive hanoi, apoi, la fiecare pas, apelul din vrful stivei va fi interpretat astfel: dac e vorba de un apel recursiv atunci el va fi expandat ntr-o secven de trei apeluri: un prim apel recursiv, o mutare elementar i un al doilea apel recursiv, iar dac este vorba de o mutare elementar ea va fi executat. Pentru simplificarea operaiilor ce urmeaz a se executa asupra stivei, preferm s reprezentm toate apelurile ca obiecte, argumentele unui apel fiind valori ale unor atribute ale acestor obiecte. Iat o posibil reprezentare:
(deftemplate hanoi (slot index) (slot nr-disc) (slot orig) (slot dest) (slot rez) ) (deftemplate muta (slot index) (slot orig) (slot dest) )
Obiectul hanoi descrie un apel recursiv; obiectul muta descrie un apelmutare elementar; index pstreaz un index unic de identificare a apelului; nrdisc precizeaz numrul de discuri; orig, dest n ambele tipuri de obiecte reprezint indecii suporturilor de origine i respectiv destinaie; rez d indexul suportului de manevr. n regulile de mai jos respectm ordinea operaiilor asupra stivei, astfel nct numai obiectul aflat n vrful stivei s fie prelucrat la oricare intervenie asupra stivei. n funcie de tipul obiectului din vrf, trei operaii pot avea loc: - dac obiectul este un apel recursiv cu un singur disc (nr-disc=1), el este transformat ntr-un apel de mutare:
138
(defrule transforma-recursie1-in-mutare ?stf <- (stiva ?item $?end) ?hf <- (hanoi (index ?item) (nr-disc 1) (orig ?fr) (dest ?to) (rez ?re)) => (retract ?stf ?hf) (bind ?idx (gensym)) (assert (muta (index ?idx) (orig ?fr) (dest ?to)) (stiva ?idx $?end)) )
- dac obiectul este un apel recursiv cu mai mult dect un singur disc (nr-disc>1), el este expandat ntr-o secven coninnd un apel recursiv, un apel de mutare i un alt apel recursiv (vezi Figura 32):
(defrule expandeaza-hanoi ?stf <- (stiva ?item $?end) ?hf <- (hanoi (index ?item) (nr-disc ?no&:(> ?no 1)) (orig ?fr) (dest ?to) (rez ?re)) => (retract ?stf ?hf) (bind ?idx1 (gensym)) (bind ?idx2 (gensym)) (bind ?idx3 (gensym)) (assert (hanoi (index ?idx1) (nr-disc =(- ?no 1)) (orig ?fr) (dest ?re) (rez ?to)) (muta (index ?idx2) (orig ?fr) (dest ?to)) (hanoi (index ?idx3) (nr-disc =(- ?no 1)) (orig ?re) (dest ?to) (rez ?fr)) (stiva ?idx1 ?idx2 ?idx3 $?end)) )
- i, n sfrit, dac obiectul este un apel de mutare, o aciune corespunztoare este efectuat, n cazul de fa, tiprirea unui mesaj:
(defrule tipareste-mutare ?stf <- (stiva ?item $?end) ?hf <- (muta (index ?item) (orig ?fr) (dest ?to)) => (retract ?stf ?hf) (printout t muta disc de pe ?fr pe ?to crlf)
139
(assert (stiva $?end)) )
Desigur o regul iniial trebuie s amorseze procesul prin introducerea primului apel recursiv n stiv. Regula urmtoare realizeaz acest lucru dup interogarea utilizatorului asupra numrului de discuri:
(defrule hanoi-initial (not (stiva $?)) => (printout t Turnurile din Hanoi. Numarul de discuri? ) (bind ?n (read)) (bind ?idx (gensym)) (assert (hanoi (index ?idx) (nr-disc ?n) (orig A) (dest B) (rez C)) (stiva ?idx)) )
S observm c regulile transforma-recursie1-in-mutare i tipareste-mutare pot fi concentrate ntr-una singur, caz n care nu am mai avea nevoie de obiecte de tip (muta ...). O alt observaie, mult mai important, se refer la ordinea n care sunt consumate apelurile recursive. Ea este nerelevant, pentru c ceea ce intereseaz este doar secvena de mutri elementare cu care am rmne n stiv dup consumarea tuturor apelurilor recursive. Cu alte cuvinte, am putea nlocui stiva cu o list de apeluri, din care s consumm ntr-o prim etap, n maniera artat, toate apelurile recursive, pentru ca, ntr-o a doua etap, s parcurgem n ordine lista pentru execuia mutrilor elementare. Pentru a transforma ordinea de intervenie asupra obiectelor-apeluri din structura de memorare a apelurilor, dintr-una ultimul-venit-primul-servit6 (ceea ce face din structura de memorare o stiv) ntr-una aleatorie, doar urmtoarele modificri (marcate cu aldine mai jos) ar trebui operate asupra programului (toate regulile primesc n nume o terminaie v1):
(defrule transforma-recursie1-in-mutare-v1 ?stf <- (stiva $?beg ?item $?end) ?hf <- (hanoi (index ?item) (nr-disc 1) (orig ?fr) (dest ?to) (rez ?re)) => (retract ?stf ?hf) (bind ?idx (gensym))
6
Engl. last-in-first-out.
140
(assert (muta (index ?idx) (orig ?fr) (dest ?to)) (stiva $?beg ?idx $?end)) ) (defrule expandeaza-hanoi-v1 ; un obiect oarecare (cu n>1) din lista de memorare este ; selectat ?stf <- (stiva $?beg ?item $?end) ?hf <- (hanoi (index ?item) (nr-disc ?no&:(> ?no 1)) (orig ?fr) (dest ?to) (rez ?re)) => (retract ?stf ?hf) (bind ?idx1 (gensym)) (bind ?idx2 (gensym)) (bind ?idx3 (gensym)) (assert (hanoi (index ?idx1) (nr-disc =(- ?no 1)) (orig ?fr) (dest ?re) (rez ?to)) (muta (index ?idx2) (orig ?fr) (dest ?to)) (hanoi (index ?idx3) (nr-disc =(- ?no 1)) (orig ?re) (dest ?to) (rez ?fr)) (stiva $?beg ?idx1 ?idx2 ?idx3 $?end)) )
Dac interveniile asupra structurii de memorare n vederea transformrii apelurilor recursive n mutri elementare se pot face acum n orice ordine, regula de tiprire este singura care impune respectarea unei ordini n descrcarea acestei structuri, de la ultimul element introdus spre primul, ceea ce ne aduce din nou cu gndul la stiv. De asemenea, ntruct descrcarea trebuie s fie ultima faz a algoritmului, vom da regulii care o realizeaz o prioritate mai mic:
(defrule tipareste-mutare-v1 (declare (salience -10)) ?stf <- (stiva ?item $?end) ?hf <- (muta (index ?item) (orig ?fr) (dest ?to)) => (retract ?stf ?hf) (printout t muta disc de pe ?fr pe ?to crlf) (assert (stiva $?end)) )
141
10.2. Calculul factorialului

Funcia recursiv de calcul al factorialului unui numr natural (produsul numerelor naturale mai mici sau egale cu acesta) este, ntr-o notaie pseudo-cod, urmtoarea:
1. function fact(n) 2. begin 3. if n = 1 then 1; 4. else n * fact(n-1); 5. end
ntr-un limbaj susinut de mecanismul de stiv, funcia de mai sus se transcrie aproape identic. Spre exemplu, n Lisp, ea arat astfel:
(defun fact(n) (if (eq n 1) 1 (* n (fact (- n 1)))))
Dei aparent mai simpl dect precedenta problem a turnurilor din Hanoi, soluia calculului factorialului nu are o transcriere elementar ntr-un limbaj bazat pe reguli. Desigur, i aici, ca i n problema precedent, stiva de apeluri joac un rol important, ea trebuind s fie realizat explicit. Diferena fa de problema precedent este c, n cazul factorialului, n stiv apar operaii ale cror argumente depind de rezultatele altor apeluri aflate la rndul lor n stiv. n problema turnurilor, apelurile erau de forma (hanoi 2 A B C) (muta A C) (hanoi 2 B C A) etc., adic argumentele erau cunoscute, ele nu depindeau de rezultatele altor apeluri aflate n stiv. n Figura 33 este schiat evoluia stivei pentru un argument iniial al funciei factorial egal cu 3 (numele funciilor apar naintea parantezelor deschise, ntre paranteze fiind notate argumentele; sgeile ce pleac de pe poziiile argumentelor secunde ale apelurilor funciei de nmulire semnific faptul c argumentele secunde trebuie considerate rezultatele evalurilor apelurilor indicate de sgei):
fact(1) fact(2) fact(3) *(3, ) *(2, ) *(3, ) 1 *(2, ) *(3, ) 2 *(3, ) 6
Figura 33: Evoluia stivei n calculul factorialului
142
Dup cum sugereaz Figura 33, stiva are o dinamic foarte regulat, n sensul c ntr-o prim etap ea crete, pn la includerea n vrf a apelului factorialului de 1, pentru ca apoi ea s scad, pn ce n stiv rmne un singur element ce conine rezultatul. S mai observm c n etapa descreterii stivei, elementul din vrf nu conine un apel, ci un rezultat; de aceea vom prefera o reprezentare n care s separm acest element de stiv, ca n Figura 34:
1 fact(1) fact(2) fact(3) *(3, ) *(2, ) *(3, ) *(2, ) *(3, ) *(3, ) 2 6
Figura 34: Reprezentare n care rezultatul este separat de stiv
Ca i mai sus, n problema turnurilor, vom reprezenta apelurile funciilor factorial i produs prin obiecte CLIPS:
(deftemplate factorial (slot index) (slot arg) ) (deftemplate produs (slot index) (slot arg1) (slot arg2) )
n aceste reprezentri atributele index au rostul de a identifica unic apeluri. Atributul arg al obiectelor factorial i atributul arg2 al obiectelor produs indic alte obiecte, deci au ca tip valori index. Atributul arg1 al obiectelor produs au ca valori numere naturale. S remarcm c n stiv obiectele factorial i produs rmn doar att timp ct valorile lor nu se cunosc nc. Odat calculate, ele dispar, iar rezultatele apelurilor se vor pstra ntr-un obiect rezultat:
(deftemplate rezultat (slot index) (slot rez) )
143
Rndul 3 din definiia pseudo-cod a funciei factorial conine condiia de terminare a recursiei. Ea se transcrie astfel:
(defrule interpreteaza-factorial-1 ?stf <- (stiva ?item $?end) ?faf <- (factorial (index ?item) (arg 1)) => (retract ?stf ?faf) (assert (rezultat (index ?item) (rez 1)) (stiva $?end)) )
Cu alte cuvinte, cnd elementul din vrful stivei este apelul unui factorial cu argument 1, rezultatul (numrul ntreg 1) al apelului este memorat n atributul rez al unui obiect nou rezultat i stiva este decrementat. Aprinderea acestei reguli marcheaz nceputul fazei de decrementare a stivei. Rndul 4 al definiiei conine apelul recursiv. El trebuie realizat prin dou reguli, corespunztoare fazei de incrementare i, respectiv, decrementare a stivei. Prima regul va modifica stiva nlocuind apelul de factorial din vrful stivei cu un apel de produs i adugnd deasupra lui un nou apel de factorial. Primul argument al produsului este argumentul factorialului eliminat, iar argumentul al doilea al produsului este indexul apelului de factorial nou inclus:
(defrule interpreteaza-factorial-mai-mare-1 ?stf <- (stiva ?item $?end) ?faf <- (factorial (index ?item) (arg ?n&:(> ?n 1))) => (retract ?stf ?faf) (bind ?idx1 (gensym)) (assert (produs (index ?item) (arg1 ?n) (arg2 ?idx1)) (factorial (index ?idx1) (arg =(- ?n 1))) (stiva ?idx1 ?item $?end)) )
Cea de a doua regul, interpreteaza-produs, decrementeaz stiva dup ce n stiv au rmas numai apeluri de produs. La fiecare aplicare a ei, un apel de produs este eliminat din stiv, dup ce obiectul rezultat este actualizat cu produsul dintre valoarea pe care acest obiect o coninea i primul argument al apelului de produs aflat n vrful stivei:
(defrule interpreteaza-produs ?stf <- (stiva ?item $?end) ?prf <- (produs (index ?item) (arg1 ?a1) (arg2 ?idx2)) ?ref <- (rezultat (index ?idx2) (rez ?r))
144
=> (retract ?stf ?prf) (modify ?ref (index ?item) (rez =(* ?a1 ?r))) (assert (stiva $?end)) )
Verificarea naturii numerice a primelor argumente ale apelurilor de produs este inutil, dat fiind maniera n care aceste apeluri au fost construite. Ultimele dou reguli realizeaz amorsarea i, respectiv, stingerea procesului. Regula start interogheaz utilizatorul asupra numrului argument al factorialului, iar regula stop afieaz rezultatul:
(defrule start (not (stiva $?)) => (printout t Factorial de ...? ) (bind ?n (read)) (bind ?idx (gensym)) (assert (fact ?n) (factorial (index ?idx) (arg ?n)) (stiva ?idx)) ) (defrule stop (fact ?n) (stiva) (rezultat (rez ?r)) => (printout t factorial de ?n este ?r crlf) )
De reflectat n ultima lor variant, regulile transforma-recursie1-in-mutarev1 i expandeaza-hanoi-v1 se aplic ntr-o ordine care e dictat numai de strategia de rezoluie a conflictelor curent utilizat. Regula tiparestemutare-v1 va fi ulterior (datorit prioritii mai mici) aplicat de un numr de ori egal cu numrul apelurilor elementare rmase n structura de memorare. Ce s-ar ntmpla ns dac am nlocui regula tipareste-mutare-v1 cu prima variant a ei, tipareste-mutare, deci dac ar avea aceeai prioritate cu a celorlalte reguli? Rspunsul este c, probabil, soluia ar fi mai bun. Dar dac ea ar avea o prioritate mai mare? Rspunsul este c, sigur, soluia ar fi mai bun. Putei gsi o explicaie n favoarea acestor afirmaii?
145
Argumentul arg2 al obiectelor produs din problema factorialului pare superfluu, att timp ct este folosit numai n faza dinamicii descresctoare a stivei i indic ntotdeauna acelai obiect rezultat. Modificai programul astfel nct obiectele produs s nu conin atributul arg2.
Partea a IV-a Dezvoltarea de aplicaii

Operaii pe liste, stive i cozi Sisteme expert n condiii de timp real Confruntri de abloane n plan O problem de cutare n spaiul strilor Calculul circuitelor de curent alternativ Rezolvarea problemelor de geometrie Scurt ghid de programare spectaculoas bazat pe reguli
Capitolul 11
Operaii pe liste, stive i cozi
11.1. Inversarea unei liste
Ne propunem s inversm elementele unei liste. La nceput baza de date va conine un singur fapt de forma:
(lista <element>+)
pentru ca, la sfrit, ea s conin tot un singur fapt, lista, dar ale crui elemente s se afle n ordine invers. n soluia pe care o propunem7, schimbarea o efectum n aceeai structur, prin introducerea unui marcaj, fa de care elementele sunt apoi copiate ca n oglind. Mai nti introducem n coada listei un marcaj (un simbol care nu mai exist nicieri ntre elementele listei), de exemplu un asterisc (*):
(deffacts lista (lista 1 2 3 4 5 6 7) ) (defrule pregatire ?x <- (lista $?n) => (retract ?x) (assert (lista $?n *)) )
Primul element al listei aflat n stnga marcajului (notat ?h n regula muta-element) este mutat pe prima poziie de dup marcaj. Dac se repet aceast operaie, elementele din stnga marcajului se vor muta n dreapta acestuia, n ordine invers:
Soluie sugerat de Valentin Irimia.
150
(defrule muta-element (declare (salience 10)) ?x <- (lista ?h&:(neq ?h *) $?t * $?r) => (retract ?x) (assert (lista $?t * ?h $?r)) )
Trebuie s ne asigurm c regula pregatire nu se mai aplic niciodat din momentul n care marcajul a fost introdus n list. Din aceast cauz regula mutaelement este declarat mai prioritar dect regula pregatire. Putem face acest lucru bazndu-ne pe condiia regulii pregatire, care este mai lax dect cea a regulii muta-element. n acest fel, n toate cazurile n care este filtrat regula muta-element va fi filtrat i regula pregatire. Deci pregatire se va aplica numai atunci cnd muta-element nu e filtrat. n final, marcajul este ndeprtat. Motorul trebuie ns oprit printr-o comand explicit de oprire datorit cerinei ca, la terminarea execuiei, n baz s se afle numai un singur fapt lista, exact ca la nceput. Fr aceast comand, motorul ar cicla la nesfrit:
(defrule termina (declare (salience 10)) ?x <- (lista * $?n) => (retract ?x) (assert (lista $?n)) (halt) )
S notm nc o dat importana declaraiei de prioritate. Dac ea nu ar face din regula termina una la fel de prioritar ca i muta-element, n momentul n care muta-element i-ar nceta activitatea, regula pregatire ar putea fi din nou activat.
11.2. Maini-stiv i maini-coad

Ne propunem s realizm mai nti o main dedicat exploatrii stivei. Ea ar putea fi utilizat ca o component a oricrei aplicaii ce utilizeaz stiva. Operaiile pe stiv sunt: - push <element>: <element> e introdus n stiv; - pop: elementul din vrful stivei este eliminat ntr-o structur de memorare temporar top.
151
Vom impune ca structura de stiv s nu poat fi accesat de ctre proces dect prin intermediul acestor dou operaii. Deci, orice intervenie direct asupra stivei, vzut ca vector, de exemplu, este interzis. Procesul care lucreaz cu stiva tie c n urma unei operaii pop va regsi elementul eliminat din stiv n registrul top. Pentru c acesta are o singur poziie, o nou operaie pop va nlocui coninutul lui cu ultimul element aflat n vrful stivei. Cum ntr-un limbaj bazat pe reguli nu exist apeluri, execuia operaiilor push i pop trebuie comandat prin intermediul unor fapte. Vom adopta convenia ca procesul care utilizeaz stiva s comande o operaie push sau una pop nscriind n baz fapte de forma: (push <element>) i, respectiv, (pop). Registrul top va fi reprezentat printr-un fapt (top <element>). La nceput stiva e goal iar top acioneaz ca un registru ce poate memora o singur valoare:
(deffacts masina-stiva (stack) (top nil) )
Regula pop-ok realizeaz operaia pop pentru cazul cnd n stiv exist cel puin un singur element. Elementul din vrful stivei este transferat n top iar stiva este decrementat:
(defrule pop-ok ?p <- (pop) ?s <- (stack ?top $?rest) ?t <- (top ?) => (retract ?p ?s ?t) (assert (top ?top) (stack $?rest)) )
Urmtoarea regul trateaz cazul invocrii operaiei pop pe o stiv goal. Situaia este anunat procesului prin setarea la empty a registrului top:
(defrule pop-empty ?p <- (pop) (stack) ?t <- (top ?) => (retract ?p ?t) (assert (top empty)) )
152
Elementul comunicat de proces prin faptul push este plasat n vrful stivei:
(defrule push ?p <- (push ?elem) ?s <- (stack $?any) => (retract ?p ?s) (assert (stack ?elem $?any)) )
n cele ce urmeaz descriem funcionarea unei maini care realizeaz o coad de ateptare. Faptul queue va ine coada iar faptul temp elementul extras din coad:
(deffacts masina-coada (queue) (temp nil) )
Regula out1 descrie operaia out, de eliminare a unui element dintr-o coad ce conine minimum un element:
(defrule out1 ?o <- (out) ?q <- (queue ?first $?rest) ?t <- (temp ?) => (retract ?o ?q ?t) (assert (temp ?first) (queue $?rest)) )
Comanda de eliminare a unui element dintr-o coad goal provoac includerea n temp a valorii empty:
(defrule out2 ?o <- (out) (queue) ?t <- (temp ?) => (retract ?o ?t) (assert (temp empty)) )
153
Comanda de includere a unui element n coad se d prin intermediul unui fapt in ce conine elementul de inclus:
(defrule in ?i <- (in ?elem) ?q <- (queue $?any) => (retract ?i ?q) (assert (queue $?any ?elem)) )
11.3. Un proces care lucreaz cu stiva

S ne imaginm c dorim s realizm inversarea elementelor listei utiliznd o stiv. Putem proceda astfel: se parcurg n secven de la stnga la dreapta elementele listei i se ncarc, rnd pe rnd, fiecare element n stiv. Dup aceast secven, n vrful stivei va sta ultimul element al listei. ntr-o a doua etap se descarc stiva n list, n ordinea de la stnga la dreapta. n acest fel ultimul element introdus, cel ce era la baza stivei, adic primul din lista iniial, va aprea acum pe ultima poziie a listei. Regulile de lucru pe stiv sunt cele din problema precedent i, ca urmare, nu le mai reproducem aici.
(deffacts procesul (lista 1 2 3 4 5 6 7) ) (deffacts control (faza incarca) ) (defrule incarca-stiva (declare (salience -10)) (faza incarca) ?l <- (lista ?first $?rest) => (retract ?l) (assert (push ?first) (lista $?rest)) )
n faza incarca stiva se ncarc printr-un ir de operaii push. Aceast regul cheam maina de stiv prin plasarea n baz a unui fapt push. Dorim ca,
154
imediat ce un astfel de fapt apare, maina s-l i execute. Execuia imediat ar trebui s aib loc inclusiv n cazul n care un fapt pop s-ar introduce n baz. Ca urmare, va trebui s facem ca prioritile regulilor mainii stiv s fie mai mari dect cele ale regulilor procesului. Pentru a pstra intacte regulile stivei, vom cobor prioritile regulilor procesului la -10. Cnd lista s-a golit, procesul trece n faza de descarcare a stivei n list:
(defrule comuta-faza (declare (salience -10)) ?f <- (faza incarca) (lista) => (retract ?f) (assert (faza descarca)) )
Urmtoarea regul comand mainii de stiv s execute o operaie pop. Ea este amorsat de existena unui registru top resetat la nil. O dat faptul pop depus n baz, datorit prioritii mai mari a regulilor mainii stiv, aceast operaie este executat imediat:
(defrule descarca-stiva1 (declare (salience -10)) (faza descarca) (top nil) => (assert (pop)) )
Rezultatul execuiei unui pop este un element plasat n registrul top. Regula descarca-stiva2 preia acest element i l duce n coada listei. O precauie este luat ca elementul din top s fie diferit att de nil ct i de empty:
(defrule descarca-stiva2 (declare (salience -10)) (faza descarca) ?l <- (lista $?any) ?t <- (top ?elem&:(and (neq ?elem nil) (neq ?elem empty))) => (retract ?l ?t) (assert (lista $?any
155
?elem) (top nil)) )
Terminarea este forat, n momentul n care top anun stiva goal, prin retragerea faptului care precizeaz faza. Cum toate regulile procesului utilizeaz acest fapt, motorul se oprete:
(defrule termina (declare (salience -10)) ?f <- (faza descarca) (top empty) => (retract ?f) )
11.4. Un proces care lucreaz simultan cu o stiv i o coad

Urmtoarea problem pe care o propunem complic lucrurile i mai mult, plecnd de la observaia c operaiile asupra listei, respectiv golirea ei, n prima faz, urmat de umplerea ei n ordine invers, n faza a doua, sunt n fapt operaii caracteristice cozii de ateptare. Vrem aadar s descriem inversarea listei utiliznd simultan mainile stiv i coad. Figura 35 lmurete:
a. descrcarea cozii = ncrcarea stivei 3 3 4 5 6 7 2 1
b. descrcarea stivei = ncrcarea cozii 3 7 6 5 4 3 2 1 Figura 35: Lista (privit ca o coad) inversat prin intermediul unei stive
156
Cum mainile stiv i coad sunt cele definite deja mai sus, dm mai jos numai procesul care comand operaiile asupra acestor dou structuri. Elementele listei de inversat le considerm iniial existente n coad:
(deffacts masina-coada (queue 1 2 3 4 5 6 7) (temp nil) )
Procesul se va desfura n dou faze: prima de descrcare a cozii, respectiv ncrcare a stivei i cea de a doua de ncrcare a cozii, respectiv, descrcare a stivei.
(deffacts control (faza descarca-coada) ) (defrule comanda-out (faza descarca-coada) (temp nil) => (assert (out)) )
Dup ce maina de coad proceseaz o comand out, n registrul temp apare un element diferit de nil i, atta timp ct coada nc nu e vid, diferit de empty:
(defrule comanda-push (declare (salience -10)) (faza descarca-coada) ?t <- (temp ?elem&:(and (neq ?elem nil) (neq ?elem empty))) => (retract ?t) (assert (push ?elem) (temp nil)) )
O comand out este urmat de o comand push. Derularea acestor dou operaii, ntotdeauna n aceast ordine, e dictat de coninutul registrului temp care trebuie s fie nil pentru execuia comenzii out i diferit de nil sau empty la execuia comenzii push. Pe de alt parte, dup un push temp e fcut nil, iar dup execuia unui out temp e umplut de maina de coad. Sincronizarea se realizeaz, aadar, automat.
157
La golirea cozii se trece n faza a doua incarca-coada:

(defrule comuta-faza (declare (salience -10)) ?f <- (faza descarca-coada) (temp empty) => (retract ?f) (assert (faza incarca-coada)) )
n faza a doua, cele dou comenzi n pereche sunt pop i in: pop amorsat de un registru top cu coninutul nil:
(defrule comanda-pop (declare (salience -10)) (faza incarca-coada) (top nil) => (assert (pop)) )
iar in de un registru top diferit de nil sau de empty. Rezultatul unui pop e umplerea lui top, care este vrsat n coad prin operaia in. n urma acestei operaii top este resetat:
(defrule comanda-in (declare (salience -10)) (faza incarca-coada) ?t <- (top ?elem&:(and (neq ?elem nil) (neq ?elem empty))) => (retract ?t) (assert (in ?elem) (top nil)) )
Regula urmtoare exprim condiia de terminare, golirea lui top:

(defrule termina (declare (salience -10)) ?f <- (faza incarca-coada) (top empty) => (retract ?f))
158
Rezultatul se regsete n configuraia de fapte:

(queue 7 6 5 4 3 2 1) (top empty) (temp empty)
11.5. Evaluarea expresiilor

Ultima aplicaie urmrete evaluarea expresiilor aritmetice. Pentru a pstra caracterul elementar al implementrilor, vom considera c expresiile nu conin paranteze. Invitm cititorul s dezvolte aplicaia pentru prelucrarea expresiilor cu paranteze. Un binecunoscut algoritm de evaluare a expresiilor aritmetice utilizeaz dou stive, una a operatorilor i cealalt a operanzilor. E limpede c pot fi scrise reguli care s efectueze direct operaiile asupra stivelor, dar n cele ce urmeaz ne vom amuza s manipulm dou maini-stiv simultan. Devine clar c ne trebuie o main de stiv general (i nu avem motive s credem c lucrurile nu ar sta la fel i n cazul cozii) care s poat fi clonat n oricte copii, astfel nct manipularea acestora s fie independent i evoluia lor s poat fi sincronizat prin intermediul comenzilor push i pop, ce s-ar adresa fiecreia n parte, i a registrelor ce pstreaz elementele top. Este evident c stivele nu mai pot fi anonime, aa nct vom presupune c numele stivei este ntotdeauna al doilea simbol al faptelor care le memoreaz, adic vom avea: (stiva opr <element>*) pentru operatori, respectiv (stiva opd <element>*) pentru operanzi. La fel, faptele ce comand operaiile push vor fi etichetate (push opr <element>), respectiv (push opd <element>), operaiile pop: (pop opr) respectiv (pop opd) i elementele din vrf: (top opr <element>), respectiv (top opd <element>). n plus, pentru c algoritmul necesit la un moment dat o descrcare dubl a stivei operanzilor, vom permite o operaie pop2 al crei efect va fi extragerea a dou elemente n registrul top corespunztor. Figura 36 este, n acest sens, ilustrativ. Programul urmtor d soluia. Exist trei niveluri de prioriti: - al mainii stiv (ridicat aici la 100), - al regulilor curente ale domeniului problemei (considerate de prioritate 0) - a dou grupuri de reguli de condiii disjuncte (ambele de prioritate 10): unul format din regula de terminare cu succes i cea de terminare pe eroare i altul al regulilor de calcul al operaiilor aritmetice:
159
2+3*4-5
+3*4-5
3*4-5
2 opr *4-5 opd opr opd 4-5
+ opr - 5
2 opd
4 3 + opr - 5 2 opd * + opr - 5 3 2 opd * + opr 3 2 opd 5
12 + opr 2 opd opr 14 opd opr 14 opd
5 opr 14 opd opr 9 opd
Figura 36: Dinamica stivelor n evaluarea expresiei 2 + 3 * 4 - 5
;; Definitiile masinii-stiva (defrule pop-ok (declare (salience 100)) ?p <- (pop ?name) ?s <- (stiva ?name ?top $?rest)
160
?t <- (top ?name ?) => (retract ?p ?s ?t) (assert (top ?name ?top) (stiva ?name $?rest)) ) (defrule pop2-ok (declare (salience 100)) ?p <- (pop2 ?name) ?s <- (stiva ?name ?top1 ?top2 $?rest) ?t <- (top ?name $?) => (retract ?p ?s ?t) (assert (top ?name ?top1 ?top2) (stiva ?name $?rest)) ) (defrule pop-empty (declare (salience 100)) ?p <- (pop ?name) (stack ?name) ?t <- (top ?name ?) => (retract ?p ?t) (assert (top ?name empty)) ) (defrule pop2-empty (declare (salience 100)) ?p <- (pop2 ?name) (stack ?name ?) ?t <- (top ?name $?) => (retract ?p ?t) (assert (top ?name empty)) ) (defrule push (declare (salience 100)) ?p <- (push ?name ?elem) ?s <- (stiva ?name $?any) => (retract ?p ?s) (assert (stiva ?name ?elem $?any)) )
161
;; ;; Definitii din domeniul problemei ;; (deffacts masina-stiva-opr (stiva opr) (top opr nil) ) (deffacts masina-stiva-opd (stiva opd) (top opd nil) ) (deffacts expresie (expr 2 + 3 * 4 - 5) ) (deffacts prioritati (prio * 2) (prio / 2) (prio + 1) (prio - 1) ) (defrule opd ; Primul element al expresiei este un operand: se comanda ; o operatie ; push asupra stivei opd cu acest operand. ?ex <- (expr ?x&:(numberp ?x) $?rest) => (retract ?ex) (assert (expr $?rest) (push opd ?x)) ) (defrule opr1 ; Primul element al expresiei este un operator: se ; comanda o operatie ; push asupra stivei opr. ?ex <- (expr ?x&:(not (numberp ?x)) $?rest) (stiva opr) => (retract ?ex) (assert (expr $?rest) (push opr ?x)) )
162
(defrule opr2 ; Primul element al expresiei este un operator de ; prioritate mai mare decit a celui din virful stivei ; opr: se comanda o operatie push in stiva opr. ?ex <- (expr ?x&:(not (numberp ?x)) $?rest) (stiva opr ?top $?oprs) (prio ?x ?px) (prio ?top ?ptop&:(> ?px ?ptop)) => (retract ?ex) (assert (expr $?rest) (push opr ?x)) ) (defrule opr3 ; Primul element al expresiei este un operator de ; prioritate mai mica sau egala cu cea a operatorului din ; virful stivel opr: se comanda descarcarea unui element ; al stivei opr si a doua elemente ale stivei opd. (expr ?x&:(not (numberp ?x)) $?rest) (stiva opr ?top $?oprs) (prio ?x ?px) (prio ?top ?ptop&:(<= ?px ?ptop)) => (assert (pop opr) (pop2 opd)) ) (defrule opr4 ; La terminarea expresiei se comanda descarcarea unui ; element al stivei opr si a doua elemente ale stivei ; opd. Expresia goala este stearsa si adaugata pentru a ; face regula aplicabila repetat. ?e <- (expr) => (retract ?e) (assert (expr) (pop opr) (pop2 opd)) ) (defrule terminare-rezultat ; Oprire cind expresia si stiva opr sint goale iar stiva ; opd are un singur element (declare (salience 10)) ?e <- (expr) (stiva opd ?x)
163
(stiva opr) => (retract ?e) (printout t rezultat: ?x crlf) ) (defrule eroare ; Oprire pe eroare in faza de descarcare in care nu sint ; minimum 2 elemente in stiva-opd (declare (salience 10)) (top opd empty) => (printout t eroare! crlf) ) (defrule desc-mult ; Operatorul * disponibil in registrul top opr si ; doi operanzi disponibili in registrul top opd: ; se realizeaza inmultirea si se comanda push rezultatul ; in stiva opd. Prioritatea trebuie sa fie mai mare decit ; a restului regulilor domeniului pentru a se executa ; intotdeauna cind exista registre top pline in aceasta ; configuratie. (declare (salience 10)) ?sr <- (top opr *) ?sd <- (top opd ?opd1 ?opd2) => (retract ?sr ?sd) (assert (top opr nil) (top opd nil) (push opd =(* ?opd2 ?opd1))) ) (defrule desc-imp ; Analog pentru operatorul / (declare (salience 10)) ?sr <- (top opr /) ?sd <- (top opd ?opd1 ?opd2) => (retract ?sr ?sd) (assert (top opr nil) (top opd nil) (push opd =(/ ?opd2 ?opd1))) ) (defrule desc-adu ; Analog pentru operatorul +
164
(declare (salience 10)) ?sr <- (top opr +) ?sd <- (top opd ?opd1 ?opd2) => (retract ?sr ?sd) (assert (top opr nil) (top opd nil) (push opd =(+ ?opd2 ?opd1))) ) (defrule desc-sca ; Analog pentru operatorul (declare (salience 10)) ?sr <- (top opr -) ?sd <- (top opd ?opd1 ?opd2) => (retract ?sr ?sd) (assert (top opr nil) (top opd nil) (push opd =(- ?opd2 ?opd1))) )
Capitolul 12
Sisteme expert n condiii de timp real
Problemele n care evenimente externe trebuie tratate de un sistem expert sunt frecvente. Ceea ce intereseaz ntr-o astfel de realizare sunt cel puin urmtoarele aspecte: - apar evenimente externe la momente de timp oarecare; - un eveniment extern trebuie procesat n general imediat, dac el nu este la concuren cu alte resurse ale sistemului; - timpul este un element important. Pentru ca un sistem expert care conduce un proces ce funcioneaz n condiii de timp real s poat fi testat trebuie construit pentru el un simulator. Situaia este explicat n Figura 37:
PROCESUL REAL SIMULATORUL DE PROCES
sistemul expert pentru conducerea procesului
sistemul expert pentru conducerea procesului
a. Funcionarea n condiii reale
b. Funcionarea n condiii simulate
Figura 37: Un proces n timp real i simularea lui
Simulatorul de proces trebuie s reproduc ct mai fidel posibil evenimentele externe, n timp ce sistemul expert pentru conducerea procesului trebuie s fac sistemul s funcioneze. n proiectarea aplicaiei este important s punem n capitole separate prile care in de conducerea procesului i cele care in de controlul simulrii. Dac procedm n acest mod, n momentul n care simularea a reuit, vom putea
166
ndeprta fr nici o problem codul simulatorului, pentru a rmne cu partea care realizeaz funcionarea sistemului, ce urmeaz s fie apoi cuplat la procesul real. Exist, de asemenea, cazuri n care doar simularea conteaz, sistemul expert este construit numai pentru a studia pe el comportamentul unui sistem real, ceea ce se urmrete fiind n acest caz cunoaterea mai bun a procesului n sine. Pentru realizarea unui sistem expert care s lucreze n condiii de timp real, ne preocup deci s gsim rspuns la urmtoarele ntrebri: - cum pot fi simulate evenimente externe? - ce caracteristici trebuie s aib sistemul pentru a procesa evenimentele externe? - cum procedm atunci cnd una din componentele sistemului este timpul? Cum simulm ceasul? Exemplul urmtor ofer cteva rspunsuri la aceste ntrebri.
12.1. Servirea clienilor la o coad

Enunul problemei este urmtorul: se dorete simularea unei cozi de ateptare la un ghieu. Coada e format din clieni iar la ghieu exist un funcionar care servete clienii. Pentru a servi un client, funcionarul consum o cuant de timp, ntotdeauna aceeai. Apariia clienilor n coad se face la momente aleatorii de timp. Cel servit este primul din coad, iar ultimul venit intr la urma cozii. Exist dou tipuri de evenimente externe n aceast problem: intrarea clienilor n coad i tactul ceasului de timp real. S numim evenimentele din prima categorie evenimente client, i pe cele din a doua evenimente ceas. Apariia evenimentelor client e aleatorie n timp, pe cnd apariia evenimentelor ceas se face ntotdeauna dup acelai interval de timp cuanta de timp pe care o considerm propice problemei noastre. Pentru simularea activitii la o coad secunda e o cuant de timp prea fin iar ora prea grosier. Cea care convine e minutul. ntr-o prim variant, vom simula apariia evenimentelor client de o manier static, adic memornd n fapte apariia acestor evenimente. Dimpotriv vom lsa pe seama unei reguli simularea evenimentelor ceas. Grupul de fapte evenimente memoreaz faptele ce descriu evenimentele externe: ceasul n formatul (ceas <minut>) i apariia clienilor n coad n formatul (client <nume> <momentul apariiei>). Ceasul este iniializat la momentul 0:
(deffacts evenimente (ceas 0) (client Ion 0) (client Matei 1) (client Mircea 4)
167
(client Maria 11) )
Grupul parametri memoreaz parametrii simulrii n cazul de fa numai timpul de servire al unui client (presupus ntotdeauna acelai):
(deffacts parametri (timp-servire 3) )
Grupul date conine alte fapte ce ajut la simulare: coada iniial goal, un indicator care ine starea funcionarului (liber ori ocupat) i un contor al timpului rmas pentru servirea unui client:
(deffacts date (coada) (functionar liber) (trsc 0) )
Regula de apariie n coad a unui client se activeaz dac ceasul ajunge la momentul n care trebuie luat n considerare un client pentru c acesta intr n coad. Aciunile efectuate sunt: retragerea faptului ce memoreaz apariia clientului consumat i introducerea numelui clientului n extremitatea dreapt a cozii:
(defrule vine-client (ceas ?t) ?cl <- (client ?nume ?t) ?co <- (coada $?sir-clienti) => (retract ?cl ?co) (assert (coada $?sir-clienti ?nume)) (printout t vine clientul ?nume la momentul ?t crlf) )
Regula ce marcheaz nceperea servirii unui client este inc-serv-client: dac funcionarul este liber i n coad se gsete cel puin un client, atunci funcionarul devine ocupat cu servirea primului client aflat la rnd. S notm c dintre cele 5 condiii ale prii stngi a regulii, doar primele dou sunt restrictive (ele testnd respectiv funcionarul liber i existena cel puin a unui nume n coad). Faptul (trsc ...) este iniializat la valoarea cuantei de timp alocate clientului:
168
(defrule inc-serv-client ?func <- (functionar liber) (coada ?primul $?rest) (timp-servire ?ts) (ceas ?t) ?tr <- (trsc ?) => (retract ?func ?tr) (assert (functionar ocupat ?primul) (trsc ?ts)) (printout t incepe servirea clientului ?primul la momentul ?t crlf) )
Regula de terminare a servirii unui client: dac funcionarul este ocupat cu servirea clientului aflat n fa la rnd i timpul de servire al acestuia a expirat, atunci funcionarul devine liber i clientul iese din coad:
(defrule termin-serv-client ?func <- (functionar ocupat ?nume) ?co <- (coada ?nume $?rest) ?tr <- (trsc 0) (ceas ?t) => (retract ?func ?co) (assert (functionar liber) (coada $?rest)) (printout t termin servirea clientului ?nume la momentul ?t crlf) )
Urmtoarea regul simuleaz ceasul: faptele care pstreaz timpul i numrul de minute rmase pentru servirea clientului aflat n fa sunt actualizate primul incrementat, al doilea decrementat. S observm c prioritatea acestei reguli este cea mai mic dintre toate regulile simulrii. Cum condiiile ei de aplicare sunt satisfcute la orice pas al simulrii (existena faptelor ceas i trsc), doar declaraia de prioritate minim face ca regula s se activeze numai n cazul n care nici o alt regul nu mai poate fi aplicat.
(defrule tact-ceas (declare (salience -100))
169
?ce <- (ceas ?t) ?tr <- (trsc ?v) => (retract ?ce ?tr) (bind ?t (+ ?t 1)) (assert (ceas ?t) (trsc =(- ?v 1))) (printout t minutul: ?t crlf) )
Oprirea simulrii se face cnd coada este vid i nici un fapt client nu a mai rmas n baz. Maniera de oprire aleas aici a fost prin retragerea unui fapt care este folosit n absolut toate regulile, cel coninnd ceasul:
(defrule oprire (declare (salience 10)) (coada) (not (client $?)) ?ce <- (ceas ?) => (retract ?ce) )
Iat rezultatele rulrii acestui program:

CLIPS> (load Coada.clp) TRUE CLIPS> (reset) CLIPS> (run) vine clientul Ion la momentul 0 incepe servirea clientului Ion la momentul 0 minutul: 1 vine clientul Matei la momentul 1 minutul: 2 minutul: 3 termin servirea clientului Ion la momentul 3 incepe servirea clientului Matei la momentul 3 minutul: 4 vine clientul Mircea la momentul 4 minutul: 5 minutul: 6 termin servirea clientului Matei la momentul 6 incepe servirea clientului Mircea la momentul 6 minutul: 7 minutul: 8 minutul: 9
170
termin servirea clientului Mircea la momentul 9 minutul: 10 minutul: 11 vine clientul Maria la momentul 11 incepe servirea clientului Maria la momentul 11 minutul: 12 minutul: 13 minutul: 14 termin servirea clientului Maria la momentul 14 CLIPS>
12.2. Evenimente externe pseudo-aleatorii

ntr-o a doua variant a cozii simulate mai sus vrem s generm aleator evenimentele externe de tip client. S presupunem c mai cerem ca simularea s se petreac n timp real i dorim s putem controla numrul maxim de clieni ce pot s apar n unitatea de timp. Succesul satisfacerii acestor cerine st, evident, n abilitatea de a utiliza funcii care msoar timpul i care genereaz numere pseudo-aleatorii. n CLIPS ele sunt (time) care raporteaz timpul sistemului i (random) care, la fiecare apel, genereaz un numr aleator n plaja 1215. Pentru exersarea utilizrii generatorului de numere aleatoare, urmtorul program realizeaz o distribuie controlat de probabilitate: dac n faptul prob se comunic un numr natural n, la ntreruperea rulrii faptul da va conine un numr de aproximativ n ori mai mare dect cel raportat de faptul nu.
(deffacts fapte (da 0) (nu 0) (prob 4) ) (defrule test-prob ; Regula aserteaza de prob ori mai multe da-uri decit ; nu-uri. ?d <- (da ?x) ?n <- (nu ?y) ?v <- (prob ?p) => (bind ?r (random)) (if (> ?r (/ 32768 (+ ?p 1))) then (retract ?d) (assert (da =(+ ?y 1))) else (retract ?n) (assert (nu =(+ ?x 1)))) )
171
S pregtim simularea cozii n timp real realiznd, mai nti, un cod care genereaz simboluri noi la intervale aleatorii de timp, ntr-o anumit marj de timp. Marja de timp n care au loc apariiile de simboluri este dat ca parametru ntr-un fapt interval-max, n secunde. Iniial, regula apariie se aprinde pentru c momentul 0, ce iniializeaz un fapt moment-urmator, este mai mic dect timpul curent al sistemului. Ca urmare, momentul anunat n faptul moment-urmator este actualizat la o valoare mai mare dect timpul curent cu o durat aleatorie calculat ntr-un interval cuprins ntre 1 i valoarea marjei de timp, printr-o funcie:
<moment-urmtor> = (time) + <interval-max> * (random) / 215
De fiecare dat cnd acest moment n timp este atins, regula aparitie actualizeaz valoarea momentului urmtor. Msurarea scurgerii acestui interval este datorat regulii asteptare. Condiia ei, fiind complementar celei a regulii aparitie, face inutil o declaraie de prioritate.
(deffacts de-timp (moment-urmator 0) (interval-max 60) ) (defrule aparitie ; Intervalul s-a scurs: un simbol e generat si afisat ?a <- (moment-urmator ?ta&:(<= ?ta (time))) (interval-max ?im) => (retract ?a) (printout t apare (gensym) crlf) (assert (moment-urmator =(+ (time) (/ (* ?im (random)) 32766)))) ) (defrule asteptare ; Astept scurgerea intervalului. ?a <- (moment-urmator ?ta&:(> ?ta (time))) => (retract ?a) (assert (moment-urmator ?ta)) )
172
Pregtirea simulrii cozii de ateptare n timp real este acum terminat. Urmtorul program realizeaz aceast simulare. Faptul (timp-curent) ine timpul curent al sistemului, dei el poate fi obinut oricnd. Regulile aparitie i asteptare sunt cele construite mai sus. Fiind reguli care exploateaz timpul prin condiii extrem de generoase (faptele moment-urmator, interval-maxim i timp-curent sunt permanent n baz), prioritatea lor este declarat mai mic dect a oricrei reguli a procesului. Numele unui client este generat de regula aparitie prin funcia (gensym), clientul n sine fiind anunat prin includerea n baz a unui fapt client. Cele trei reguli ale domeniului rmn, aadar: regula care trateaz includerea unui client n coad vine-client, regula care trateaz nceperea servirii unui client inc-serv-client i regula care trateaz terminarea servirii unui client termin-serv-client:
(deffacts date-simulare (coada) (functionar liber) (mom-term-serv 0) (timp-servire 10) ) (deffacts date-de-timp (moment-urmator 0) (interval-max 30) (timp-curent 0) ) (defrule aparitie ; Intervalul s-a scurs: un simbol e generat si afisat (declare (salience -100)) ?a <- (moment-urmator ?ta&:(<= ?ta (time))) (interval-max ?im) => (retract ?a) (bind ?cl (gensym)) (printout t apare ?cl crlf) (assert (moment-urmator =(+ (time) (/ (* ?im (random)) 32766))) (client ?cl)) ) (defrule asteptare ; Astept scurgerea intervalului. (declare (salience -100)) ?a <- (moment-urmator ?ta&:(> ?ta (time)))
173
?atc <- (timp-curent ?tc) => (retract ?a ?atc) (assert (moment-urmator ?ta) (timp-curent (time))) ) ;; ;; Regulile domeniului ;; (defrule vine-client ?cl <- (client ?nume) ?co <- (coada $?sirclienti) => (retract ?cl ?co) (assert (coada $?sirclienti ?nume)) (printout t vine clientul ?nume la momentul (time) crlf) ) (defrule inc-serv-client (coada ?primul $?rest) ?func <- (functionar liber) (timp-servire ?ts) ?amts <- (mom-term-serv ?) => (retract ?func ?amts) (bind ?t (time)) (assert (functionar ocupat ?primul) ; aici ordinea are importanta (mom-term-serv =(+ ?t ?ts))) (printout t incepe servirea clientului ?primul la momentul ?t crlf) ) (defrule termin-serv-client ?func <- (functionar ocupat ?nume) ?co <- (coada ?nume $?rest) (timp-curent ?tc) (mom-term-serv ?mts&:(<= ?mts ?tc)) => (retract ?func ?co) (assert (functionar liber) (coada $?rest)) (printout t termin servirea clientului ?nume la momentul (time) crlf) )
Capitolul 13
Confruntri de abloane n plan
Ne propunem s investigm n acest capitol probleme ce se caracterizeaz prin condiii asupra unor amplasamente de obiecte n plan. Atunci cnd acest lucru e posibil, este de dorit ca abloanele regulilor nsele s fie ct mai apropiate ca form de structurile particulare cutate. Limbajul CLIPS nu ofer opiuni speciale pentru o confruntare de abloane care s exploreze aezri ale obiectelor n spaiu. n [9], [10] se descrie un limbaj bazat pe reguli, numit L-exp, care ncorporeaz trsturi speciale de definire a relaiilor de vecintate ntre obiecte. Utiliznd astfel de relaii, se pot descrie apoi condiii complexe pentru gsirea lanurilor de obiecte diferit configurate n spaiu. Regulile limbajului L-exp permit combinarea descrierilor de abloane cu descrieri ale relaiilor de vecintate. Alturarea liniar n partea stng a unei reguli L-exp, sub incidena unei relaii de vecintate, a mai multor abloane, fiecare responsabil cu identificarea unor obiecte de un anumit tip, semnific tentativa de depistare a lanurilor de obiecte ce se supun, pe de o parte, restriciilor elementare descrise de abloane i, pe de alt parte, condiiilor de vecintate descrise de relaiile invocate. Prin faptele sale multi-cmp, CLIPS poate fi considerat ca oferind faciliti rudimentare de definire spaial a obiectelor i de cutare corespunztoare prin abloane. Aezarea cmpurilor ntr-un fapt fiind una liniar, singura facilitate de descriere spaial oferit de CLIPS este una care exploateaz ordinea liniar. De aceea configuraiile de obiecte care prsesc linia pentru a se regsi n plan trebuie descrise explicit prin abloane succesive. Acest lucru poate fi fcut, de exemplu, prin tierea planului n caroiaje i gruparea obiectelor aflate pe aceste caroiaje n faptele declarate. n Figura 38 se arat maniera (notorie) de reprezentare a unei figuri plane prin ptrate de dimensiunea unui caroiaj. Un ptrat este considerat ca aparinnd figurii dac el conine semnificativ de multe puncte ale figurii.
176
Programarea bazat pe reguli ( ( ( ( ( ( ( ( a. figura originar b.figura discretizat Figura 38: Reprezentri planare c. reprezentarea ca fapte ) ) ) ) ) ) ) )
Lipsa unei ordonri apriorice a faptelor n baza de date oblig la numerotarea liniilor pentru a permite specificarea explicit a coordonatei verticale, de exemplu ca n Figura 39.
( 1 ( 2 ( 3 ( 4 ( 5 ( 6 ( 7 ( 8 Figura 39: Specificarea explicit a ordonatei n fapte
Configuraiile liniare de obiecte sunt uor de recunoscut prin reguli. De exemplu, o configuraie ca aceasta:
ce este plasat oriunde ntr-un rnd, poate fi recunoscut cu un ablon:

(?lin $?beg $?end)
Dac trecem de la rnd la plan, trebuie s facem ca formelor planare s le corespund aranjri succesive de abloane liniare. Alinierea orizontal a
177
abloanelor, care urmeaz a se aplica asupra faptelor ce corespund rndurilor succesive, nu rezult ns automat. Pentru a lmuri acest aspect, s considerm situaia n care am dori s recunoatem aranjamente de obiecte de forma:
Aceast figur nu poate fi ns recunoscut cu o list de abloane de genul:

(?l1 $?b1 (?l2&:(= ?l2 (+ 1 ?l1)) $?b2 (?l3&:(= ?l3 (+ 2 ?l1)) $?b3 $?e1) $?e2) $?e3)
datorit libertii variabilelor ir $?b1, $?b2, $?b3 de a se lega la oricte elemente i, prin aceasta, de a produce dezalinierea obiectelor de interes. Ca urmare, trebuie s controlm poziiile pe orizontal ale obiectelor ce trebuie recunoscute, n fiecare rnd n parte. Exist dou modaliti prin care putem face acest lucru: - prin controlarea lungimii irurilor de obiecte legate de variabilele ir ce colecteaz obiectele aflate n faa obiectelor de interes sau - prin notarea poziiei pe abscis a obiectelor din figur. Mai jos, continum exemplul de recunoatere a cruciulielor, considernd prima soluie:
(?l1 $?b1 (?l2&:(= ?l2 (+ ?l1 1)) $?b2&:(= (length$ $?b2) (- (length$ $?b1) 1)) (?l3&:(= ?l3 (+ ?l1 2)) $?b3&:(= (length$ $?b3) (length$ $?b1)) $?e1) $?e2) $?e3)
Prin aceasta, impunem restricia ca irul de obiecte ce precede poriunea din figur aparinnd rndului al doilea s fie mai scurt cu o poziie dect cel ce precede seciunea figurii de pe primul rnd, iar acesta s fie egal n lungime celui de pe ultimul rnd. Evident, o astfel de definiie a abloanelor exploateaz faptul c exist o linie vertical care delimiteaz n stnga figura de cutat. O scriere a abloanelor care ar exploata simetria figurii de recunoscut plecnd de la linia a doua nspre n sus i n jos ar trebui s plaseze nti n regul ablonul pentru linia a doua:
(?l2 $?b2 $?e2) (?l1&:(= ?l1 (- ?l2 1)) $?b1&:(= (length$ $?b1) (+ (length$ $?b2) 1)) (?l3&:(= ?l3 (+ ?l2 1)) $?b3&:(= (length$ $?b3) (+ (length$ $?b2) 1)) $?e1) $?e3)
O astfel de aranjare n pagin a abloanelor este, ns, neintuitiv pentru c acestea nu mai reflect fidel figura din plan.
178
n continuare, vom analiza dou probleme inspirate din jocuri, care presupun recunoateri de obiecte aflate n plan: jocul 8-puzzle i jocul vaporae.
13.1. Jocul 8-puzzle

n jocul 8-puzzle, 8 piese ptrate care au desenate cifrele de la 1 la 8 trebuie mutate prin micri de glisare orizontal sau vertical dintr-o configuraie iniial ntr-una final, ntr-un spaiu de form ptrat, 3 pe 3, din care lipsete o pies (blancul). n soluia pe care o propunem, obiectele au notate n fapte, n dreapta lor, poziiile pe abscis. Practic, un fapt care descrie o linie este de forma:
(linie <numr_linie> * <piesa_1> 1 * <piesa_2> 2 * <piesa_3> 3 *)
Marcajele * au rostul de a despri coloanele formate din dou elemente (un numr care indic piesa i un numr de coloan) pentru ca expresia ablon care identific numrul coloanei s nu confunde o coloan cu o pies. n aceast aranjare, numrul coloanei se afl ntotdeauna n a doua poziie dup asterisc. Piesele sunt notate cu cifre ntre 1 i 8 iar blancul cu B. Lista celor trei fapte ce urmeaz descrie o configuraie iniial de forma:
1 3 4 8 2 7 6 5
(deffacts tabla (line 1 * 1 1 * 3 2 * 4 3 *) (line 2 * 8 1 * 2 2 * B 3 *) (line 3 * 7 1 * 6 2 * 5 3 *) )
In continuare, regula move-B-up descrie o mutare a blancului n sus:

(defrule move-B-up ?l0 <- (line ?lin0&:(>= ?lin0 2) $?beg0 * B ?col * $?end0) ?l1 <- (line ?lin1&:(= ?lin1 (- ?lin0 1)) $?beg1 * ?n ?col * $?end1) => (retract ?l0 ?l1) (assert (line ?lin0 $?beg0 * ?n ?col * $?end0)
179
(line ?lin1 $?beg1 * B ?col * $?end1)) )
Primul ablon identific linia cu blanc iar cel de al doilea ablon linia aflat deasupra. n acest caz o aranjare a abloanelor care s reflecte fidel aranjarea liniilor nu este recomandat, pentru c identificarea liniei cu blanc poate fi fcut imediat i, deci, economisim timp de calcul dac plasm primul ablonul care i corespunde. Variabila ?col identific coloana blancului, pentru ca mutarea blancului n sus s se poat realiza n aceeai coloan. Regula care descrie mutarea n jos a blancului este asemntoare:
(defrule move-B-down ?l0 <- (line ?lin0&:(<= ?lin0 2) $?beg0 * B ?col * $?end0) ?l1 <- (line ?lin1&:(= ?lin1 (+ ?lin0 1)) $?beg1 * ?n ?col * $?end1) => (retract ?l0 ?l1) (assert (line ?lin0 $?beg0 * ?n ?col * $?end0) (line ?lin1 $?beg1 * B ?col * $?end1)) )
Pentru efectuarea mutrilor pe linie este suficient cte un singur ablon n fiecare regul:
(defrule move-B-left ?l <- (line ?lin $?beg0 * ?n ?col0 * B ?col1&:(>= ?col1 2) * $?end0) => (retract ?l) (assert (line ?lin $?beg0 * B ?col0 * ?n ?col1 * $?end0)) ) (defrule move-B-right ?l <- (line ?lin $?beg0 * B ?col0&:(<= ?col0 2) * ?n ?col1 * $?end0) => (retract ?l) (assert (line ?lin $?beg0 * ?n ?col0 * B ?col1 * $?end0)))
180
13.2. Jocul cu vaporae

n jocul cu vaporae doi combatani maritimi se confrunt pe un cmp de lupt, fiecare ncercnd s scufunde vasele celuilalt. Fiecare partener are n fa dou suprafee de joc, una pe care sunt marcate vasele lui i cealalt pe care marcheaz cunoaterea lui asupra zonei n care i ascunde adversarul vasele sale. Fiecare suprafa de joc este o tabl de 10x10 ptrele, vaporaele pot avea mrimi variind ntre 2 i 4 ptrele i forme date de orice configuraie de ptrele adiacente. Pentru scufundarea unui vapora de mrime n sunt necesare tot attea lovituri n exact ptrelele pe care acesta le ocup. n general, ntr-o partid de vaporae, un juctor nti bombardeaz dup un plan oarecare (care poate fi i aleator) caroiajul adversarului, pn ce o lovitur nimerete un vas al acestuia. Urmeaz un set de lovituri aplicate n vecintatea celei norocoase, pn la scufundarea intei. Sunt multe moduri prin care un program care joac vaporae cu un partener uman poate fi fcut mai performant: maniera de scanare a terenului pn la descoperirea poziiei unei inte, maniera de atac dintre prima lovitur aplicat unei inte i scufundarea complet a acesteia, nvarea preferinelor adversarului n privina plasrii vapoarelor i a formelor acestora n vederea mririi anselor de ctig n partide viitoare (lovirea cu precdere n poziii care amintesc de forme ce par astfel a fi cele mai vulnerabile) etc. n cele ce urmeaz ne vom preocupa de realizarea strategiilor pentru aruncarea bombelor n cele dou situaii de lupt: gsirea intelor i scufundarea lor dup o lovitur iniial. Fiecare regul va descrie operaiile de efectuat cnd o anumit situaie este ntlnit pe teren. ntr-un joc de vaporae, n fazele de localizare a intelor preferm s plasm loviturile ct mai uniform n spaiul de joc, astfel nct densitatea loviturilor s creasc relativ constant pe ntreaga suprafa. Pentru recunoaterea suprafeelor goale putem aplica familii de abloane planare cu care s descoperim oricare dintre configuraiile urmtoare de zone libere (numr linii numr coloane): 5x5, 3x3, 2x3, 3x2, 1x3 i 3x1:
Primul ablon, de exemplu, pune n eviden o zon liber de 5x5 celule, care, pe o tabl iniial 10x10, poate fi instaniat n 36 de moduri. Pentru
181
exemplificare, partea stng a unei reguli care tenteaz descoperirea unei zone 2x3, poate fi scris astfel:
(defrule EU-la-joc-alege-zona-libera-2x3-1 (declare (salience 8)) ... (TU-T ?lin1 $?beg1 0 0 0 $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= (length$ $?beg2) (length$ $?beg1)) 0 0 0 $?end2) => ... )
ntr-o astfel de descriere zona de lupt a adversarului este reprezentat printr-o mulime de 10 fapte liniare de forma:
(TU-T <nr-linie> <p1> <p2> <p3> <p4> <p5> <p6> <p7> <p8> <p9> <p10>)
n care <p1> ... <p10> reprezint cele 10 poziii ale liniei <nr-linie>, fiecare putnd fi notat cu 0, dac poziia nu este atins, sau cu numrul vaporului n cauz, atunci cnd se confirm c lovitura a atins un vapor. O dat descoperit o astfel de zon, o regul decide aplicarea unei lovituri ntr-o poziie care se afl fie n mijlocul zonei goale, fie foarte aproape de mijloc (ptrelele gri de mai jos):
Ca urmare, opt reguli, iar nu ase, descriu aciunile ce trebuie efectuate la descoperirea zonelor goale. Pentru exemplificare, printre alte lucruri, regula care mai sus a fost prezentat pentru partea stng ar putea conine n partea dreapt i urmtoarele:
(defrule EU-la-joc-alege-zona-libera-3x2-1 ... (TU-T ?lin1 $?beg1 0 0 0 $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1))
182
$?beg2&:(= (length$ $?beg2) (length$ $?beg1)) 0 0 0 $?end2) => ... (printout t Lovesc in patratul: ( ?lin2 , (+ 1 (length$ $?beg2)) )!. Comunica rezultatul! crlf) )
Aa cum tim, prioritatea declarat a regulilor este important n stabilirea ordinii n care zonele goale vor fi lovite. Este uor de vzut c numrul de instanieri pe tabla de joc ale unui ablon este cu att mai mare cu ct el ncearc descoperirea unor zone mai mici. Lsarea ordinii de aplicare a regulilor n voia strategiei de rezoluie a conflictelor cu care ruleaz sistemul poate rezulta ntr-o aglomerare a loviturilor n anumite zone ce sunt puse n eviden de abloane care cerceteaz suprafee mici. Cum suprafaa acoperit de un ablon reflect n proporie invers densitatea de aplicare a loviturilor (1/25 pentru ablon-ul 5x5, 1/9 pentru ablon-ul 3x3 .a.m.d. 1/3 pentru cel 1x3 sau 3x1) i cum ne preocup s realizm o acoperire a zonei de lupt, uniform n densitatea loviturilor, care s varieze dinspre densiti mici spre cele mari, ordinea de aplicare a regulilor trebuie s fie: mai nti cele cu abloane corespunznd suprafeelor mari i apoi cele cu abloane corespunznd suprafeelor mici. Cum nu avem nici un motiv pentru care s preferm configuraia 2x3 naintea celei 3x2, sau a configuraiei 1x3 naintea celei 3x1, declaraiile de prioritate vor trebui s repartizeze regulile pe ase niveluri.
(defrule EU-la-joc-alege-zona-libera-5x5 (declare (salience 10)) ... (TU-T ?lin1 $?beg1 0 0 0 0 0 $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= $?beg2) (length$ $?beg1)) 0 0 0 0 0 $?end2) (TU-T ?lin3&:(= ?lin3 (+ 2 ?lin1)) $?beg3&:(= $?beg3) (length$ $?beg1)) 0 0 0 0 0 $?end3) (TU-T ?lin4&:(= ?lin4 (+ 3 ?lin1)) $?beg4&:(= $?beg4) (length$ $?beg1)) 0 0 0 0 0 $?end4) (TU-T ?lin5&:(= ?lin5 (+ 4 ?lin1)) $?beg5&:(= $?beg5) (length$ $?beg1)) 0 0 0 0 0 $?end5) => ... (printout t Lovesc in patratul: ( ?lin3 , (length$ $?beg3)) )!. Comunica rezultatul! crlf) ) (defrule EU-la-joc-alege-zona-libera-3x3
(length$ (length$ (length$ (length$
(+ 3
183
(declare (salience 9)) ... (TU-T ?lin1 $?beg1 0 0 0 $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= (length$ $?beg2) (length$ $?beg1)) 0 0 0 $?end2) (TU-T ?lin3&:(= ?lin3 (+ 2 ?lin1)) $?beg3&:(= (length$ $?beg3) (length$ $?beg1)) 0 0 0 $?end3) => ... (printout t Lovesc in patratul: ( ?lin2 , (+ 2 (length$ $?beg2)) )!. Comunica rezultatul! crlf) ) (defrule EU-la-joc-alege-zona-libera-2x3-1 (declare (salience 8)) ... (TU-T ?lin1 $?beg1 0 0 0 $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= (length$ $?beg2) (length$ $?beg1)) 0 0 0 $?end2) => ... (printout t Lovesc in patratul: ( ?lin2 , (+ 2 (length$ $?beg2)) )!. Comunica rezultatul! crlf) ) (defrule EU-la-joc-alege-zona-libera-2x3-2 (declare (salience 8)) ... (TU-T ?lin1 $?beg1 0 0 0 $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= (length$ $?beg2) (length$ $?beg1)) 0 0 0 $?end2) => ... (printout t Lovesc in patratul: ( ?lin1 , (+ 2 (length$ $?beg1)) )!. Comunica rezultatul! crlf) ) (defrule EU-la-joc-alege-zona-libera-3x2-1 (declare (salience 8)) ... (TU-T ?lin1 $?beg1 0 0 $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= (length$ $?beg2) (length$ $?beg1)) 0 0 $?end2) (TU-T ?lin3&:(= ?lin3 (+ 2 ?lin1)) $?beg3&:(= (length$ $?beg3) (length$ $?beg1)) 0 0 $?end3) => ...
184
(printout t Lovesc in patratul: ( ?lin2 , (+ 1 (length$ $?beg2)) )!. Comunica rezultatul! crlf) ) (defrule EU-la-joc-alege-zona-libera-3x2-2 (declare (salience 8)) ... (TU-T ?lin1 $?beg1 0 0 $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= (length$ $?beg2) (length$ $?beg1)) 0 0 $?end2) (TU-T ?lin3&:(= ?lin3 (+ 2 ?lin1)) $?beg3&:(= (length$ $?beg3) (length$ $?beg1)) 0 0 $?end3) => ... (printout t Lovesc in patratul: ( ?lin2 , (+ 2 (length$ $?beg2)) )!. Comunica rezultatul! crlf) ) (defrule EU-la-joc-alege-zona-libera-1x3 (declare (salience 7)) ... (TU-T ?lin $?beg 0 0 0 $?end) => ... (printout t Lovesc in patratul: ( ?lin , (+ 2 (length$ $?beg)) )!. Comunica rezultatul! crlf) ) (defrule EU-la-joc-alege-zona-libera-3x1 (declare (salience 7)) ... (TU-T ?lin1 $?beg1 0 $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= (length$ $?beg2) (length$ $?beg1)) 0 $?end2) (TU-T ?lin3&:(= ?lin3 (+ 2 ?lin1)) $?beg3&:(= (length$ $?beg3) (length$ $?beg1)) 0 $?end3) => ... (printout t Lovesc in patratul: ( ?lin2 , (+ 1 (length$ $?beg1)) )!. Comunica rezultatul! crlf) )
Cel de al doilea motiv pentru care, n jocul de vaporae, am fi interesai de dispunerea elementelor n plan este legat de strategia de joc pe care o adoptm pentru scufundarea unui vapor o dat realizat o prim lovitur. Vom implementa o
185
strategie de lupt prin care se lovesc cu prioritate ptrele aflate n imediata apropiere a unor lovituri deja aplicate unui vapor ce este nc nescufundat. Astfel, presupunnd c un fapt de forma (TU-V-lovite <nr-vapor> <nr-lovituri-primite>) memoreaz pentru fiecare vapor al adversarului ce a primit cel puin o lovitur numrul de lovituri primite, iar (tip-V <nrvapor> <gabarit>) reine pentru fiecare vapor, indiferent de juctor, din cte ptrele este format, atunci decizia de lovire n poziia p a tablei adversarului este dat de conjuncia de condiii: - vaporul n are lovite un numr de poziii mai mare dect zero dar mai mic dect numrul de poziii al tipului respectiv de vapor; - poziia p se afl n vecintatea unei poziii lovite n vaporul n. Prima dintre cele dou condiii poate fi realizat de secvena urmtoarelor dou abloane:
(TU-V-lovite ?nr-V ?lov) (tip-V ?nr-V ?tip-V&:(< ?lov ?tip-V))
iar cea de a doua condiie, de diferite combinaii de abloane ce cerceteaz dispuneri planare n jurul unei poziii atinse n vaporul astfel depistat. n reprezentrile de mai jos, cu s-a notat poziia veche i cu cea nou. n abloane, se cerceteaz ca n poziia nou s existe un 0.
(TU-T ?lin $?beg ?nr-V 0 $?end)
(TU-T ?lin1 $?beg1 ?nr-V $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= (length$ $?beg2)(+ 1 (length$ $?beg1))) 0 $?end) (TU-T ?lin1 $?beg1 ?nr-V $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= (length$ $?beg2)(length$ $?beg1)) 0 $?end) (TU-T ?lin1 $?beg1 ?nr-V $?end1) (TU-T ?lin2&:(= ?lin2 (+ 1 ?lin1)) $?beg2&:(= (length$ $?beg2)(- (length$ $?beg1) 1)) 0 $?end)
(TU-T ?lin $?beg 0 ?nr-V $?end)
186
(TU-T ?lin1 $?beg1 ?nr-V $?end1) (TU-T ?lin2&:(= ?lin2 (- ?lin1 1)) $?beg2&:(= (length$ $?beg2)(- (length$ $?beg1) 1)) 0 $?end) (TU-T ?lin1 $?beg1 ?nr-V $?end1) (TU-T ?lin2&:(= ?lin2 (- ?lin1 1)) $?beg2&:(= (length$ $?beg2)(length$ $?beg1)) 0 $?end) (TU-T ?lin1 $?beg1 ?nr-V $?end1) (TU-T ?lin2&:(= ?lin2 (- ?lin1 1)) $?beg2&:(= (length$ $?beg2)(+ 1 (length$ $?beg1))) 0 $?end)
Capitolul 14
O problem de cutare n spaiul strilor
14.1. Maimua i banana o prim tentativ de rezolvare

O maimu se afl ntr-o camer n care se afl o banan, atrnat de tavan la o nlime la care maimua nu poate ajunge, i, ntr-un col, o cutie. Dup un numr de ncercri nereuite de a apuca banana, maimua merge la cutie, o deplaseaz sub banan, se urc pe cutie i apuc banana. Se cere s se formalizeze maniera de raionament a maimuei ca un sistem de reguli. Problema este una clasic de inteligen artificial i, ca urmare, proiectarea unei soluii trebuie s urmreasc descrierea strilor, a tranziiilor dintre stri (un set de operatori sau reguli) i o decizie n ceea ce privete controlul, adic maniera n care trebuie aplicate regulile. n proiectarea strilor putem pune n eviden trei tipuri de relaii ntre entitile participante la scenariul descris n problem: dintre maimu i cutie, dintre cutie i banan i dintre maimu i banan, dup cum urmeaz. Relaia maimu cutie: MC-departe = maimua se afl departe de cutie MC-lng = maimua se afl lng cutie MC-pe = maimua se afla pe cutie MC-sub = maimua de afl sub cutie Relaia cutie banan: CB-lateral = cutia este aezat lateral fa de banan CB-sub = cutia este aezat sub banan Relaia maimua banan: MB-departe = maimua se afl departe de banan MB-ine = maimua ine banana Cu aceste predicate putem descrie orice stare a problemei, inclusiv strile iniial i final (vezi i Figura 40):
188
Starea iniial: MC-departe, CB-lateral, MB-departe. Starea final: MC-pe, CB-sub, MB-ine. Putem apoi inventaria urmtoarele tranziii ntre stri (setul de operatori, sau reguli): aflat departe de cutie, maimua se aproprie de cutie: apropie-MC; aflat lng cutie, maimua se deprteaz de cutie: deprteaz-MC; aflat lng cutie i lateral fa de banan, maimua trage cutia sub banan: trage-sub-MCB; aflat lng cutie i sub banan, maimua trage lateral cutia de sub banan: trage-lateral-MCB; aflat lng cutie, maimua se urc pe ea: urc-MC; aflat pe cutie, maimua coboar de pe ea: coboar-MC; aflat lng cutie, maimua i urc cutia deasupra capului: urc-pe-cap-MC; din postura n care maimua ine cutia deasupra capului, maimua i d jos cutia de pe cap: coboar-de-pe-cap-MC; aflat pe cutie i sub banan maimua apuc banana: apuc-MB; Utiliznd setul de predicate pe care l-am inventariat pentru descrierea strilor, tranziiile pot fi formulate ca reguli astfel:
apropie-MC: dac {MC-departe} atunci terge {MC-departe}, adaug {MC-lng} deprteaz-MC: dac {MC-lng} atunci terge {MC-lng}, adaug {MC-departe} trage-sub-MCB: dac {MC-lng, CB-lateral} atunci terge {CB-lateral}, adaug {CB-sub} trage-lateral-MCB: dac {MC-lng, CB-sub} atunci terge {CB-sub}, adaug {CB-lateral} urc-MC: dac {MC-lng} atunci terge {MC-lng}, adaug {MC-pe} coboar-MC: dac {MC-pe} atunci terge {MC-pe}, adaug {MC-lng}
189
urc-pe-cap-MC: dac {MC-lng} atunci terge {MC-lng}, adaug {MC-sub} coboar-de-pe-cap-MC: dac {MC-sub} atunci terge {MC-sub}, adaug {MC-lng} apuc-MCB: dac {MC-pe, MB-departe, CB-sub} atunci terge {MB-departe}, adaug {MB-ine}
O soluie a problemei ar fi, atunci, cea sugerat n Figura 40:

apropie-MC trage-sub-MCB urc-MC apuc-MCB
Figura 40: O secven de stri i tranziii care rezolv problema
Primul impuls este s transcriem aproape direct n CLIPS starea iniial i regulile, aa cum le-am inventariat mai sus, i s lsm motorul limbajului s mearg. Starea iniial se transpune n declaraia urmtoare:
(deffacts initial-state (MC-departe) (CB-lateral) (MB-departe) )
n timp ce regulile au o transcriere aproape mot--mot. Iat cum ar putea arta una din ele:
(defrule apropie-MC ; daca maimuta e departe de cutie atunci muimuta se ; apropie de cutie ?mc <- (MC-departe) => (retract ?mc) (assert (MC-langa)))
190
Procednd n acest mod, ne vom da seama foarte repede c nu avem nici o ans s rezolvm problema, din dou motive: lipsete o definiie a scopului i lipsete o strategie de apropiere de scop. n cele ce urmeaz vom utiliza dou strategii: una irevocabil (hill-climbing) i una tentativ (cu revenire), prima fr succes, a doua cu succes.
14.2. Hill-climbing
Reamintim algoritmul hill-climbing (v., de exemplu, [33]):
procedure hill-climbing(initial-state) { current-state = initial-state; if (current-state e stare final) return current-state; while (mai exist operatori posibil de aplicat lui current-state) { selecteaz un operator care nu a fost aplicat lui current-state i aplic-l => new-state; if (new-state e stare final) return new-state; if (new-state e mai bun dect current-state) current-state = new-state; } return fail; }
Pentru aplicarea acestei strategii avem nevoie de o funcie de cost care s ne ajute s rspundem la ntrebarea: n ce condiii este o stare mai bun dect alta?. n cazul de fa, am putea s notm cu diverse scoruri relaiile din familiile MC, CB i MB n aa fel nct starea final s fie caracterizat de un scor maxim:
MC-departe = 0 MC-lng = 1 MC-pe = 2 MC-sub = -1 CB-lateral = 0 CB-sub = 1 MB-departe = 0 MB-ine = 2
Cu aceste note, starea iniial e calificat: 0+0+0=0, iar starea final: 2+1+2=5. Cum ne ateptm ns, aceast funcie nu e univoc. Iat dou stri care au acelai scor: starea {MC-pe, CB-lateral, MB-departe} are scorul:
191
2 + 0 + 0 = 2, iar starea {MC-lng, CB-sub, MB-departe} are scorul: 1 + 1 + 0 = 2. Ne ateptm deci la situaii de ezitri n evoluia spre soluie. De asemenea, nu e imposibil ca n acest parcurs s atingem stri intermediare care sunt caracterizate de maxime locale ale funciei de scor (orice stare n care s-ar putea tranzita are un scor mai mic). Dup cum se tie hill-climbing nu poate depi strile de maxim local. Dar, s ncercm... Algoritmul de mai sus sugereaz o aplicare virtual a unui operator, urmat de o evaluare i de consolidarea strii obinute n urma aplicrii operatorului, sau, dimpotriv, de invalidarea ei, n funcie de obinerea ori nu a unui scor mai bun. Pentru a realiza tentativa de aplicare a operatorului vom folosi, n afara unui fapt care pstreaz starea curent, un altul care ine starea virtual, pasibil de a lua locul strii curente. n plus, pare firesc s pstrm scorul strii actuale chiar n reprezentarea strii. Faptele corespunztoare strii curente i virtuale, ar putea fi deci:
(stare-curenta <scor> <predicat>*) (stare-virtuala <scor> <predicat>*)
adic:
(deffacts stari (stare-curenta 0 MC-departe CB-lateral MB-departe) (stare-finala 5 MC-langa CB-sub MB-tine) )
n aceste convenii de reprezentare a strilor s ncercm s descriem metaregulile de control. Le numim meta-reguli pentru c, la fel ca n capitolul 5, ele manipuleaz fapte printre care se afl i regulile de tranziie ntre strile problemei. Avem n vedere mai multe activiti: aflarea unei stri virtuale plecnd de la starea curent, calculul scorului strii virtuale, modificarea eventual a strii virtuale n stare actual (dac scorul strii virtuale l surclaseaz pe cel al strii actuale). Urmtoarele faze sunt semnificative i se repet ciclic: - selecia operatorilor, - modificarea strii virtuale, - calculul scorului strii virtuale, - actualizarea strii curente din starea virtual. Putem reprezenta tranziiile dintre stri ca obiecte regula caracterizate de atributele: nume, daca, sterge, adauga. Ca sa evitm anumite complicaii, dar i pentru c instana problemei noastre ne permite, vom considera c atributele sterge i adauga in, fiecare, exact cte un predicat:
(deftemplate regula (slot nume)
192
(multislot daca) (slot sterge) (slot adauga) ) (deffacts operatori (regula (nume apropie-MC) (daca MC-departe) (sterge MCdeparte) (adauga MC-langa)) (regula (nume departeaza-MC) (daca MC-langa) (sterge MC-langa) (adauga MC-departe)) (regula (nume trage-sub-MCB) (daca MC-langa CB-lateral) (sterge CB-lateral) (adauga CB-sub)) (regula (nume trage-lateral-MCB) (daca MC-langa CB-sub) (sterge CB-sub) (adauga CB-lateral)) (regula (nume urca-MC) (daca MC-langa) (sterge MClanga) (adauga MC-pe)) (regula (nume coboara-MC) (daca MC-pe MB-departe) (sterge MC-pe) (adauga MC-langa)) (regula (nume urca-pe-cap-MC) (daca MC-langa) (sterge MC-langa) (adauga MC-sub)) (regula (nume lasa-de-pe-cap-MC) (daca MC-sub) (sterge MC-sub) (adauga MC-langa)) (regula (nume apuca-MB) (daca MC-pe MB-departe CB-sub) (sterge MB-departe) (adauga MB-tine)) )
Putem ine scorurile individuale ale operatorilor ntr-o mulime de fapte, astfel:
(deffacts scoruri (scor MC-departe 0) (scor MC-langa 1) (scor MC-pe 2) (scor MC-sub -1) (scor CB-lateral 0) (scor CB-sub 1) (scor MB-aproape 1) (scor MB-tine 2) )
ntr-un fapt faza vom memora faza n care se afl automatul. Ne va fi comod ca n acest fapt s depozitm, ulterior, toi operatorii ce se pot aplica n starea curent. Faza iniial este cea de selecie a operatorilor:
(deffacts initial-phase (faza selectie-operatori))
193
Urmeaz descrierea meta-regulilor procesului. Pentru a urmri derularea procesului vom prefera s afim starea curent de fiecare dat cnd sistemul se afl n faza selecie-operatori:
(defrule afiseaza (declare (salience 20)) ?faz <- (faza selectie-operatori) (stare-curenta ?scor $?predsSC) => (printout t Stare: ?scor $?predsSC crlf) (retract ?faz) )
Dac setul de predicate care descriu starea final este o submulime a setului de predicate din starea curent, nseamn c starea final e satisfcut i execuia se termin cu succes. Testarea terminrii cu succes se face dup afiarea strii curente i nainte de orice alt activitate a fazei:
(defrule succes (declare (salience 10)) ?faz <- (faza selectie-operatori) (stare-curenta ?scor $?predsSC) (stare-finala ?scor $?predsSF&:(subsetp $?predsSF $?predsSC)) => (printout t Succes! crlf) (retract ?faz) )
Regula selectie-operatori adun n coada faptului faza toi operatorii ce-i satisfac condiiile:
(defrule selectie-operatori ?faz <- (faza selectie-operatori $?selected-ops) (stare-curenta ?scor $?preds) (regula (nume ?r&: (not (member$ ?r $?selected-ops))) (daca $?conds)) (test (subsetp $?conds $?preds)) => (retract ?faz) (assert (faza selectie-operatori $?selected-ops ?r)) )
194
Cnd nici un operator nu mai poate fi selectat, se tranziteaz n faza de calcul a scorurilor strilor posibil de atins din starea curent:
(defrule tranzitie-in-calcul-scoruri (declare (salience -10)) ?faz <- (faza selectie-operatori $?selected-ops) => (retract ?faz) (assert (faza calcul-scoruri $?selected-ops) (scoruri-ops)) )
Scorurile strilor n care se poate face tranziia din starea curent se calculeaz prin tergerea din scorul strii curente a scorului predicatului de ters i adugarea la rezultat a scorului predicatului de adugat. Regula calculscoruri-operatori se aplic de attea ori ci operatori au fost selectai. Rezultatele, noile scoruri ale strilor n care se poate face tranziie din starea curent, sunt pstrate n faptul (scoruri-ops), n pereche cu numele operatorilor care realizeaz tranziiile:
(defrule calcul-scoruri-operatori ?faz <- (faza calcul-scoruri ?oper $?rest-ops) (regula (nume ?oper)(daca $?conds)(sterge ?del) (adauga ?add)) (stare-curenta ?scor-sc $?) ?sc-ops <- (scoruri-ops $?all-scores) (scor ?del ?sc-del) (scor ?add ?sc-add) => (retract ?faz ?sc-ops) (assert (faza calcul-scoruri $?rest-ops) (scoruri-ops $?all-scores ?oper =(+ ?sc-add (- ?scor-sc ?sc-del)))) )
Cnd toate scorurile strilor destinaie au fost calculate, se trece n faza urmtoare de ordonare a lor:
(defrule tranzitie-in-faza-ordonare (declare (salience -10)) ?faz <- (faza calcul-scoruri) => (retract ?faz) (assert (faza ordonare)) )
195
Pentru ordonarea scorurilor se caut n faptul scoruri-ops o secven de dou perechi <operator, scor> n care al doilea scor e mai mare dect primul i se comut ntre ele:
(defrule ordonare-scoruri-stari-noi (faza ordonare) ?sc-ops <- (scoruri-ops $?primii ?opr1 ?sc1&:(numberp ?sc1) ?opr2 ?sc2&:(> ?sc2 ?sc1) $?ultimii) => (retract ?sc-ops) (assert (scoruri-ops $?primii ?opr2 ?sc2 ?opr1 ?sc1 $?ultimii)) )
Dac nici o comutare nu mai poate fi operat, se trece n faza urmtoare de tranziie efectiv a mainii din starea curent n starea de scor maxim:
(defrule tranzitie-in-faza-schimbarii-de-stare (declare (salience -10)) ?faz <- (faza ordonare) => (retract ?faz) (assert (faza schimbare-stare)) )
Regula actualizeaza-stare descrie operaiile ce se aplic strii curente prin tranzitarea cu operatorul cel mai eficient gsit, dac acesta duce ntr-o stare de scor mai bun. Operatorul din fruntea listei scoruri-ops, care ine perechi <operator, scor> ordonate descresctor dup scoruri, este aplicat strii curente. Pentru trasarea rulrii se afieaz operatorul aplicat. Din starea curent se terge un predicat i se include altul. Maina tranziteaz apoi din nou n faza selecie-operatori:
(defrule actualizeaza-stare ?faz <- (faza schimbare-stare) ?sc-ops <- (scoruri-ops ?opr ?scor-nou $?) (regula (nume ?opr) (sterge ?del) (adauga ?add)) ?st-crt <- (stare-curenta ?scor-vechi&:(> ?scor-nou ?scor-vechi) $?prim-preds ?del $?rest-preds) =>
196
(printout t Operator: ?opr >> ) (retract ?faz ?sc-ops ?st-crt) (assert (stare-curenta ?scor-nou $?prim-preds ?add $?rest-preds) (faza selectie-operatori)) )
Dac n faza de schimbare de stare, regula anterioar nu se poate aplica, nseamn c scorul strii curente, care nu este starea final, este mai mare, sau cel puin egal, cu al celei mai bune stri n care s-ar putea tranzita, i deci avem un eec:
(defrule esec (declare (salience -10)) ?faz <- (faza schimbare-stare) (stare-curenta ?scor $?predsSC) => (printout t Esec!! Stare: ?scor $?predsSC crlf) (retract ?faz) )
Rularea programului este urmtoarea:

CLIPS> (run) Stare: 0 (MC-departe CB-lateral MB-departe) Operator: apropie-MC >> Stare: 1 (MC-langa CB-lateral MBdeparte) Operator: urca-MC >> Stare: 2 (MC-pe CB-lateral MBdeparte) Esec!! Stare: 2(MC-pe CB-lateral MB-departe) CLIPS>
Ea relev oprirea n starea (stare-curenta 2 MC-pe CB-lateral MB-departe) care reprezint ntr-adevr un punct de maxim local pentru problem. Blocarea n starea raportat, fr putin de ieire din ea, se produce datorit aezrii ntmpltoare i nefericite a dou elemente de scoruri maxime egale n lista scorurilor dup terminarea ordonrii acesteia de ctre regula ordonare-scoruri-stari-noi: (scoruri-ops urca-MC 2 trage-sub-MCB 2 departeaza-MC 0 urca-pe-cap-MC -1).
197
Pe primele dou poziii s-au plasat aici operatorii urca-MC i trage-sub-MCB, ambii urmnd a urca scorul strii curente la 2, ns n urmtoarele dou configuraii diferite: - dup o eventual aplicare a operatorului urca-MC: (stare-curenta 2 MC-pe CB-lateral MB-departe); - dup o eventual aplicare a operatorului trage-sub-MCB: (stare-curenta 2 MC-langa CB-sub MB-departe). Singura micare posibil n starea (stare-curenta 2 MC-pe CB-lateral MB-departe) fiind coboara-MC, care aduce scorul strii curente din nou la 1, aceast stare este una de maxim local.
14.3. O maimu ezitant: metoda tentativ exhaustiv

Pentru ieirea din impas trebuie folosit o metod cu revenire. Vom rula nti problema maimuei i a bananei pe maina de cutare exhaustiv cu revenire proiectat n capitolul 5. Pentru aceasta nu avem dect s declarm problema, starea iniial, cea final i regulile de tranziie i s le integrm motorului cu revenire proiectat atunci. Singura diferen ntre declaraiile utilizate mai sus i cele trebuincioase pentru rularea cu motorul tentativ const n asignarea de prioriti regulilor o trstur pe care am impus-o instanelor problemelor motorului tentativ. Dac nu avem nici un motiv pentru care s atribuim prioriti difereniate regulilor problemei, le vom da la toate aceeai prioritate zero. Rularea dovedete un comportament extrem de ezitant, dar care, n cele din urm, gsete soluia:
CLIPS> (run) Stare: (MC-departe CB-lateral MB-departe) Operator: apropie-MC >> Stare: (MC-langa CB-lateral MBdeparte) Operator: departeaza-MC >> Stare: (MC-departe CB-lateral MB-departe) backtracking in starea: (MC-langa CB-lateral MB-departe) Operator: trage-sub-MCB >> Stare: (CB-sub MC-langa MBdeparte) Operator: departeaza-MC >> Stare: (MC-departe CB-sub MBdeparte) backtracking in starea: (CB-sub MC-langa MB-departe) Operator: trage-lateral-MCB >> Stare: (CB-lateral MClanga MB-departe) Operator: departeaza-MC >> Stare: (MC-departe CB-lateral MB-departe) backtracking in starea: (CB-lateral MC-langa MB-departe)
198
Operator: urca-MC >> Stare: (MC-pe CB-lateral MB-departe) Operator: coboara-MC >> Stare: (MC-langa CB-lateral MBdeparte) Operator: departeaza-MC >> Stare: (MC-departe CB-lateral MB-departe) backtracking in starea: (MC-langa CB-lateral MB-departe) Operator: urca-pe-cap-MC >> Stare: (MC-sub CB-lateral MBdeparte) Operator: lasa-de-pe-cap-MC >> Stare: (MC-langa CBlateral MB-departe) Operator: departeaza-MC >> Stare: (MC-departe CB-lateral MB-departe) backtracking in starea: (CB-lateral MC-langa MB-departe) Operator: urca-pe-cap-MC >> Stare: (MC-sub CB-lateral MBdeparte) Operator: lasa-de-pe-cap-MC >> Stare: (MC-langa CBlateral MB-departe) Operator: departeaza-MC >> Stare: (MC-departe CB-lateral MB-departe) backtracking in starea: (MC-langa CB-lateral MB-departe) Operator: urca-MC >> Stare: (MC-pe CB-lateral MB-departe) Operator: coboara-MC >> Stare: (MC-langa CB-lateral MBdeparte) Operator: departeaza-MC >> Stare: (MC-departe CB-lateral MB-departe) backtracking in starea: (CB-sub MC-langa MB-departe) Operator: urca-MC >> Stare: (MC-pe CB-sub MB-departe) Operator: coboara-MC >> Stare: (MC-langa CB-sub MBdeparte) Operator: departeaza-MC >> Stare: (MC-departe CB-sub MBdeparte) backtracking in starea: (MC-langa CB-sub MB-departe) Operator: trage-lateral-MCB >> Stare: (CB-lateral MClanga MB-departe) Operator: departeaza-MC >> Stare: (MC-departe CB-lateral MB-departe) backtracking in starea: (CB-lateral MC-langa MB-departe) Operator: urca-pe-cap-MC >> Stare: (MC-sub CB-lateral MBdeparte) Operator: lasa-de-pe-cap-MC >> Stare: (MC-langa CBlateral MB-departe) Operator: departeaza-MC >> Stare: (MC-departe CB-lateral MB-departe) backtracking in starea: (MC-langa CB-sub MB-departe) Operator: urca-pe-cap-MC >> Stare: (MC-sub CB-sub MBdeparte)
199
Operator: lasa-de-pe-cap-MC >> Stare: (MC-langa CB-sub MB-departe) Operator: departeaza-MC >> Stare: (MC-departe CB-sub MBdeparte) backtracking in starea: (MC-langa CB-sub MB-departe) Operator: trage-lateral-MCB >> Stare: (CB-lateral MClanga MB-departe) Operator: departeaza-MC >> Stare: (MC-departe CB-lateral MB-departe) backtracking in starea: (MC-pe CB-sub MB-departe) Operator: apuca-MB >> Stare: (MB-tine MC-pe CB-sub) Succes! Solutia: apropie-MC trage-sub-MCB urca-MC apucaMB
14.4. O maimu decis: metoda best-first

Metoda best-first (v. de exemplu [33] are avantajul c duce la soluie, n principiu, mai repede dect o metod de cutare exhaustiv n spaiul strilor. Motivul este cutarea ghidat de scor i precauia de a evita agarea n maximele locale. n continuare prezentm cteva indicaii pentru realizarea unei astfel de implementri. Se va utiliza o list de stri candidate a fi vizitate tradiional numit OPEN. Includerea unei stri n aceast list va fi fcut dac sunt satisfcute dou condiii: starea nu este deja acolo i starea nu a fost deja vizitat. Lista OPEN este continuu sortat, n aa fel nct cele mai reprezentative stri (adic cele caracterizate de scorurile cele mai mari) s poat fi vizitate primele. Chiar dac toate strile care pot fi generate din starea actual sunt de scoruri mai mici dect ale acesteia (deci cnd s-a atins un maxim local ori absolut), ele sunt introduse totui n list. n acest fel se las posibilitatea de ieire dintr-un punct de maxim local prin efectuarea unui salt direct ntr-o stare ce, cndva, a fost lsat n suspans, pentru a ncerca un alt urcu. Pentru verificarea condiiei ca o stare deja vizitat s nu mai fie introdus n lista OPEN este pstrat o nregistrare a strilor deja vizitate. Vom numi aceast list CLOSED. Aadar o stare este introdus n lista CLOSED ndat ce a fost vizitat. S presupunem un moment n derularea algoritmului n care: - maina se afl n starea curent; - exist o list OPEN a strilor care urmeaz s fie vizitate, list ordonat descresctor dup scoruri; - exist o list CLOSED a strilor deja vizitate. Secvena de operaii n aceast situaie pare a fi urmtoarea: - dac lista OPEN este vid, atunci termin cu eec, pentru c nu mai sunt stri de vizitat;
200
- dac nu, alege ca stare curent primul element al listei OPEN, elimin starea curent din lista OPEN i include-o n starea CLOSED; - dac starea curent este starea final, atunci termin cu succes; - dac nu, genereaz toate strile ce pot fi atinse din starea curent. Pentru aceasta: selecteaz toi operatorii posibil de aplicat din starea curent; compune strile urmtoare de vizitat prin modificarea corespunztoare a strii curente, calculnd totodat scorurile acestor stri; - pentru fiecare dintre aceste stri generate, apoi: verific dac starea nu a mai fost deja generat; verific dac starea nu a fost deja traversat, prin comparare cu lista CLOSED; verific dac starea nu este deja inclus n lista OPEN; include starea n lista OPEN n poziia corespunztoare scorului. - starea curent devine stare intermediar i reia ciclul. Rularea, mult mai scurt, este urmtoarea:
CLIPS> (run) Operator: >> Operator: >> Operator: >> Operator: >> Operator: >> Operator: >> Succes! CLIPS> Stare: Stare: Stare: Stare: Stare: Stare: 0 1 2 2 3 5 (MC-departe CB-lateral MB-departe) (MC-langa CB-lateral MB-departe) (MC-pe CB-lateral MB-departe) (MC-langa CB-sub MB-departe) (MC-pe CB-sub MB-departe) (MC-pe CB-sub MB-tine)
Capitolul 15
Calculul circuitelor de curent alternativ
Problema circuitelor de curent alternativ const n calculul curenilor care strbat diferitele ramuri ale unui circuit n care se afl legate rezistoare, condensatoare i bobine. n schema electric real a unui rezistor apare ntotdeauna o rezisten, n cea a unui condensator o capacitate, iar n cea a unei bobine o inductan. n realitate ns, pe lng aceste impedane dominante, mai pot coexista impedane parazite de valori mai mici. O bobin inclus ntr-un circuit, de exemplu, contribuie i cu o mic rezisten, dup cum, adesea, un condensator adaug o mic inductan. Calculul curenilor se face plin aplicarea legilor lui Ohm, lucru asupra cruia nu vom insista n acest capitol. Ceea ce ne intereseaz este maniera n care putem utiliza un limbaj de programare bazat pe reguli pentru calculul impedanelor circuitelor serie, paralel sau ale combinaiilor serie-paralel. Dup cum vom vedea ns, nvmintele trase n urma acestei experiene vor fi chiar mai bogate dect strict gsirea unei maniere de rezolvare a unei probleme de fizic de liceu. n notarea elementelor de circuit n curent alternativ este curent utilizarea numerelor complexe, o impedan fiind caracterizat de o component real i una imaginar: z = a + ib Impedanele se calculeaz dup binecunoscutele formule: - serie:
n
zs=
z
i =1
- sau paralel:
n
1/zp=
z
i =1
1
i
202
iar, din punct de vedere al impedanei, rezistoarele (notate R), capacitile (notate C) i inductanele (notate L) au formulele: zR = R zC = iL zC = i/C unde reprezint pulsaia curentului alternativ. Pentru modelarea problemei noastre ca una de calcul bazat pe reguli, s observm c putem descompune calculul impedanei echivalente a oricrui circuit RLC serie-paralel ntr-o secven de operaii serie ori paralel, n care s intervin numai dou componente de circuit. Astfel, de exemplu, impedana echivalent a unui circuit ca acesta:
R2 R1 L1 L2 C1
Figura 41: Un exemplu de grupare serie-paralel
poate fi calculat ca o secven de operaii de genul: zS1 = zR1 serie zL1 zP1 = zR2 paralel zL2 zP2 = zP1 paralel zC1 zS2 = zS1 serie zP2 Datorit asociativitii operaiei de adunare, ordinea n care sunt grupate impedanele ntr-o dispunere serie sau ntr-una paralel este nerelevant. Organizarea calculului schiat mai sus sugereaz construirea a dou reguli, una capabil s calculeze impedana echivalent a un circuit serie format din dou elemente de circuit, cealalt a unuia paralel de aceeai natur. Apoi, nedeterminismul inerent al aplicrii regulilor va constitui matca natural de combinare a impedanelor ntr-o ordine aleatorie. Pentru c nu avem de ce s controlm acest proces, paradigma de programare bazat pe reguli pare s fie cea mai convenabil. Putem avea ca intrri direct valorile rezistorilor, capacitilor i inductanelor, caz n care trebuie organizat un calcul care s le aduc la formatul de numere complexe. Spre exemplu, putem memora aceste valori printr-o serie de fapte de
203
forma (rezistor <nume> <valoare>), (capacitate <nume> <valoare>), (inductanta <nume> <valoare>), unde, n fiecare caz n parte, valorile sunt date n unitile de msur corespunztoare, respectiv ohmi, farazi, henri i un singur fapt (pulsatie <valoare>) care precizeaz pulsaia curentului, n Hz. Dac reprezentm numerele complexe prin fapte de forma (complex <nume> <parte-reala> <parte-imaginara>), atunci transformarea elementelor electrice de circuit n impedane poate fi realizat printr-un set de trei reguli de forma:
(defrule calcul-rezistor ?r <- (rezistor ?num ?val) => (retract ?r) (assert (complex ?num ?val 0)) ) (defrule calcul-capacitate ?c <- (capacitate ?num ?val) (pulsatie ?p) => (retract ?c) (assert (complex ?num 0 =(/ ?p ?val))) ) (defrule calcul-inductanta ?l <- (inductanta ?num ?val) (pulsatie ?p) => (retract ?l) (assert (complex ?num 0 =(* ?p ?val))) )
n continuare, definirea circuitului o facem printr-o serie de fapte de forma (serie <nume> <nume-1> <nume-2>) i (paralel <nume> <nume-1> <nume-2>), unde prin <nume> notm combinaia serie ori paralel realizat, iar prin <nume-1> i <nume-2> circuitele pariale ce intervin n grupare. Astfel, pentru grupul rezistiv-capacitiv-inductiv din Figura 41, intervine urmtoarea descriere:
(deffacts circuit (serie S1 R1 L1) (paralel P1 R2 L2) (paralel P2 P1 C1) (serie F P2 S1))
204
(deffacts comenzi (calcul F) )
Din pcate aceast descriere face mai mult dect am dori: ea precizeaz ntr-o anumit msur i ordinea de efectuare a calculelor. ntr-adevr, dac notm cu S1 gruparea serie realizate de rezistorul R1 i inductana L1, cu P1 gruparea paralel dintre rezistorul R2 i inductana L2, cu P2 gruparea paralel realizat de gruparea anterioar i capacitatea C1 i, n final, cu F gruparea serie dintre P2 i S1, atunci nu mai rmne prea mult nedeterminism pentru c, de exemplu, nu pot s realizez nti gruparea paralel dintre C1 i L2, pentru ca rezultatul acesteia s-l combin apoi cu R2 .a.m.d. S numim acest necaz ordine serie-paralel precizat i s-l uitm deocamdat, promind a reveni asupra lui. Pentru moment ne vom concentra asupra modului n care putem controla propagarea calculelor n acest circuit, n care, aa cum am vzut, maniera de descriere impune o ordonare parial a efecturii calculelor, ordonare sugerat de laticea din Figura 42:
(paralel P1 R2 L2) (serie S1 R1 L1) (paralel P2 P1 C1)
(serie F S1 P2) Figura 42: Ordinea operaiilor serie-paralel vzut ca o latice
Poza de mai sus exprim urmtoarele: ca s pot calcula serie F, trebuie s am simultan rezultatele de la serie S1 i paralel P2, iar ca s pot calcula paralel P2, trebuie s cunosc paralel P1. Care dintre serie S1 i paralel P1 se calculeaz nti nu este important, atta timp ct valorile R1, R2, L1, L2 i C1 pot fi accesate n orice moment. Ideea este de a propaga i multiplica un set de fanioane, dinspre expresiile finale ctre cele iniiale, care s anune valorile necesare efecturii calculelor. Dac un fanion ajunge pe o expresie care poate fi calculat, aceasta este calculat prioritar, pe cnd dac un fanion ajunge pe o expresie care, pentru a fi calculat, depinde de alte expresii, fanionul se multiplic n tot attea alte fanioane cte expresii necalculate refer expresia n cauz.
205
Astfel, o regul care calculeaz o expresie calculabil serie poate fi urmtoarea:

(defrule serie-CC (declare (salience 10)) ?c <- (calcul ?nume-s) (serie ?nume-s ?nume-1 ?nume-2) (complex ?nume-1 ?a1 ?b1) (complex ?nume-2 ?a2 ?b2) => (retract ?c) (assert (complex ?nume-s =(+ ?a1 ?a2) =(+ ?b1 ?b2))) )
Expresia de forma (serie <nume-s> <nume-1> <nume-2>) este recunoscut ca fiind calculabil prin existena n baz a faptelor (complex <nume-1> ...) i (complex <nume-2> ...) ce dau expresiile ca numere complexe ale elementelor de circuit <nume-1> i <nume-2>. Analoga ei pentru expresii paralel va arta mult mai complicat, datorit expresiilor inversate ce apar n echivalarea paralel:
(defrule paralel-CC (declare (salience 10)) ?c <- (calcul ?nume-s) (paralel ?nume-s ?nume-1 ?nume-2) (complex ?nume-1 ?a1 ?b1) (complex ?nume-2 ?a2 ?b2) => (retract ?c) (assert (complex ?nume-s =(...) =(...))) )
Dimpotriv, urmtoarele trei reguli propag fanioane din expresii necalculabile nc, adic expresii ce conin sub-expresii nc necalculate:
(defrule serie-NC-C ; Un circuit serie in care prima expresie e necalculata ; si a doua calculata propaga fanionul pentru prima ; expresie (calcul ?nume-s) (serie ?nume-s ?nume-1 ?nume-2) (complex ?nume-2 ? ?) => (assert (calcul ?nume-1)) )
206
(defrule serie-C-NC ; Un circuit serie in care prima expresie e calculata si ; a doua necalculata propaga fanionul pentru a doua ; expresie (calcul ?nume-s) (serie ?nume-s ?nume-1 ?nume-2) (complex ?nume-1 ? ?) => (assert (calcul ?nume-2)) ) (defrule serie-NC-NC ; Un circuit serie in care ambele expresii sint ; necalculate propaga fanionul pentru ambele expresii (calcul ?nume-s) (serie ?nume-s ?nume-1 ?nume-2) => (assert (calcul ?nume-1) (calcul ?nume-2)) )
Un set analog de trei reguli vor propaga fanioane de amorsare a calculelor pentru circuite paralel. O abordare de acest fel face ca fanioanele s se multiplice plecnd de jos n sus, pn n nodurile expresiilor calculabile. Apoi, prin efectul prioritii declarate mai mari a regulilor ce descriu operaiile serie i paralel, procesul se va inversa realizndu-se o propagare a calculelor de sus n jos. Efectul general este o parcurgere bottom-up depth-first a grafului calculelor. Astfel, pe graful din Figura 42 se va derula urmtoarea secven: fanion pe serie F (din declaraie), fanion pe serie S1, fanion pe paralel P2, calcul serie S1, fanion pe paralel P1, calcul paralel P1, calcul paralel P2, calcul serie F.
Capitolul 16
Rezolvarea problemelor de geometrie
Vom explica n acest capitol cum poate fi utilizat un limbaj bazat pe reguli pentru rezolvarea problemelor de geometrie de nivel mediu. Ne vom limita la probleme relativ simple, n care elementele geometrice sunt doar puncte, segmente, unghiuri i triunghiuri, n care nu apar construcii ajuttoare i n care nu se cer locuri geometrice. Punctele, segmentele, unghiurile i triunghiurile sunt definite ca obiecte cu proprieti. Ideea de rezolvare a unei astfel de probleme are n vedere derularea urmtorilor pai: iniializarea spaiului faptelor cu obiecte generate din ipotezele enunate ale problemei, urmat de o populare recursiv a spaiului cu obiecte geometrice i proprieti ale lor, derivate din cele existente prin efectul aplicrii teoremelor. n felul acesta, fie se ajunge la concluzie, caz n care programul raporteaz paii utili de raionament a cror secven constituie nsui demonstraia, fie raionamentul se stinge fr atingerea concluziei, caz n care programul anun un eec. Sunt cunoscute hibele unui raionament monoton, cu nlnuire nainte: explozia combinatorial a obiectelor i proprietilor geometrice, cele mai multe dintre ele nefiind utile pentru raionament. Se cunoate, de asemenea, cellalt pericol al unei explorri exhaustive a spaiului strilor: nesigurana c soluia gsit este cea semnificativ, n sensul de cea mai scurt. Un motiv de ngrijorare, desigur, l poate constitui explozia exponenial a obiectelor generate, dintre care multe vor fi redundante (de exemplu, apariia punctele A i B duce la generarea att a segmentului AB ct i a segmentului BA). Apoi, multe obiecte vor fi nerelevante pentru mersul demonstraiei. Vom ncepe prin a propune o modalitate de reprezentare a obiectelor geometrice, apoi vom prezenta un limbaj foarte simplu de definire a problemelor de geometrie, vom elabora maniera n care putem reprezenta teoremele de geometrie, vom gsi modaliti de verbalizare a pailor de raionament, pentru ca, n final, s ne ocupm de procesul inferenial n sine i de posibilitatea de a controla lungimea rulrii i a demontraiei8.
Soluia i aparine lui Iulian Videanu [35].
208
16.1. Reprezentarea obiectelor geometrice i a relaiilor dintre ele

Vom defini un punct printr-un nume o liter:
(deftemplate point (slot name (type STRING)) )
Un segment este definit prin nume o secven de dou litere i prin lungime (aici, ca i n cazul altor valori, necunoaterea lungimii e marcat printr-o valoare negativ):
(deftemplate segment (slot name (type STRING)) (slot size (type NUMBER) (default -1)) )
Un unghi se definete prin nume o secven de trei litere i msur:

(deftemplate angle (slot name (type STRING)) (slot size (type NUMBER) (default -1)) )
Un triunghi este definit prin nume o secven de trei litere , prin perimetru i arie:
(deftemplate triangle (slot name (type STRING)) (slot perimeter (type NUMBER) (default -1)) (slot area (type NUMBER) (default -1)))
Un punct poate fi mijlocul unui segment. Aceasta nseamn c obiectul din clasa punct se afl, pe de o parte, pe dreapta care unete capetele segmentului i, pe de alt parte, la distan egal de capete. Vom reprezenta relaiile dintre obiectele geometrice prin fapte de genul:
(fact {p|c} <relaie> <obiect>*)
n care: p nseamn c relaia este dat (premis), c c ea trebuie demonstrat (concluzie), iar <relaie> este un nume de relaie ce exist sau, respectiv, se cere a fi demonstrat ntre obiectele <obiect>* , date prin numele lor.
209
De exemplu, premisa c punctul O se afl ntre punctele A i C pe segmentul AC se reprezint prin:

(fact p between O A C)
iar concluzia c segmentele AB i AD sunt congruente, prin:

(fact c congr-segm AB AD)
16.2 Limbajul de definire a problemei

Exist trei tipuri de notaii ale limbajului de definire a problemei: declaraiile de entiti geometrice, declaraiile de relaii cunoscute ntre aceste entiti, declaraiile de concluzii (ceea ce trebuie demonstrat). Declaraiile de entiti au formatul:
<nume-entitate> <tip-figur> [<proprietate> [...]]
unde: <nume-entitate> este un ir de litere ce d numele entitii; <tip-figur> poate fi (n versiunea restrns la care am convenit): punct, unghi, segment, triunghi; <proprietate> poate fi: drept pentru unghi i dreptunghic, isoscel sau echilateral pentru triunghi. Exemple:
A punct AB segment ABC triunghi dreptunghic isoscel
Declaraiile de relaii pot fi clasificate n: - congruene:

AB =s MN ABC =a MNP ABC =t MNP ; congruenta de segmente ; congruenta de unghiuri ; congruenta de triunghiuri
- relaii ntre puncte i segmente:
210
O O O O
mijloc AB pe AB intre A B intersectie AB MN
- relaii ntre segmente:

AB || MN ; AB este paralel cu MN
- declaraii de segmente ca elemente n unghiuri i triunghiuri

AD bisectoare BAC AD inaltime ABC AD mediana ABC
Pentru c nu sunt prevzute notaii separate pentru dreapta determinat de dou puncte AB, pentru segmentul nchis [AB] i pentru segmentul deschis (AB), o aseriune de tipul: segmentele [AB] i [MN] se intersecteaz n punctul O va trebui exprimat prin urmtoarea secven:
O O O O pe AB intre A B pe MN intre M N
Forma declaraiilor de concluzii nu difer de cea a declaraiilor de premise, dar vom conveni s separm concluziile de premise printr-un rnd gol. Parserul de problem trebuie s fie capabil s transforme secvena de declaraii a problemei ntr-o mulime de fapte premis i concluzie. Pentru exemplificare, s considerm urmtoarea problem: Fie O mijlocul segmentului AC. Se consider punctele B i D, diferite, astfel nct OCB s fie egal cu OCD. S se arate c segmentele AB i AD sunt congruente. Definirea acestei probleme n mini-limbajul descris mai sus este:
AC segment O punct OCB triunghi OCD triunghi O mijloc AC OCB =t OCD AB =s AD
211
S presupunem c o funcie de parsare (pe care nu o vom detalia aici) e capabil s transforme acest ir de expresii n mulimea de fapte:
(segment (name AC)) (point (name O)) (triangle (name OCB)) (triangle (name OCD)) (fact p between O A C) (fact p congr-segm AO OC) (fact p congr-tr OCB OCD) (fact c congr-segm AB AD)
care exprim ntr-o manier uniform premisele i concluziile problemei. Dup cum observm, am ignorat aici declararea explicit a anumitor elemente, precum punctele A, C, B i D.
16.3 Propagarea inferenelor

Ideea unei demonstraii este ca din premise, prin aplicarea unor adevruri cunoscute (teoreme), s regsim concluziile. Un proces de raionament automat poate face acest lucru, dar, pentru ca demonstraia s fie urmrit, trebuie ca paii ei s fie relevai de sistemul de raionament. Va trebui s facem deci ca orice fapt care este adugat pe parcursul derulrii demonstraiei s conin i o nregistrare a manierei n care a fost el dedus de sistem. Aceti pai vor fi memorai n captul din dreapta al faptelor (fact ... ). n cele ce urmeaz enumerm i exemplificm cteva categorii de reguli. Reguli de generare de noi obiecte geometrice din cele existente precum i obiecte din relaii: - trei puncte genereaz un triunghi:
(defrule points-to-triangle (declare (salience 20)) (point (name ?A)) (point (name ?B)) (point (name ?C)) (test (and (not (eq ?A ?B)) (not (eq ?B ?C)) (not (eq ?C ?A)))) => (assert (triangle (name (str-cat ?A ?B ?C)))) )
212
- un triunghi genereaz trei puncte:

(defrule triangle-to-points (declare (salience 20)) (triangle (name ?ABC)) => (assert (point (name (sub-string 1 1 ?ABC))) (point (name (sub-string 2 2 ?ABC))) (point (name (sub-string 3 3 ?ABC)))) )
- dou puncte genereaz un segment:

(defrule points-to-segment (declare (salience 20)) (point (name ?A)) (point (name ?B)) (test (not (eq ?A ?B))) => (assert (segment (name (str-cat ?A ?B)))) )
- un segment genereaz dou puncte, capetele segmentului:

(defrule segment-to-points (declare (salience 20)) (segment (name ?AB)) => (assert (point (name (sub-string 1 1 ?AB))) (point (name (sub-string 2 2 ?AB)))) )
- trei puncte genereaz un unghi:

(defrule points-to-angle (declare (salience 20)) (point (name ?A)) (point (name ?B)) (point (name ?C)) (test (and (not (eq ?A ?B)) (not (eq ?B ?C)) (not (eq ?C ?A)))) => (assert (angle (name (str-cat ?A ?B ?C)))) )
213
- un unghi genereaz trei puncte:

(defrule angle-to-points (declare (salience 20)) (angle (name ?ABC)) => (assert (point (name (sub-string 1 1 ?ABC))) (point (name (sub-string 2 2 ?ABC))) (point (name (sub-string 3 3 ?ABC)))) )
Reguli de simetrie, reflexivitate i tranzitivitate. Aceste reguli propag proprietile obiectelor prin efectul simetriei, reflexivitii i tranzitivitii relaiilor de congruen ntre triunghiuri sau unghiuri sau de egalitate a mrimilor (unghiuri, lungimi). De exemplu, urmtoarea regul stabilete explicit congruena a dou unghiuri ce au aceeai mrime:
(defrule ca-equal-size (declare (salience 10)) (angle (name ?ABC) (size ?s)) (angle (name ?MNP) (size ?s)) (test (and (not (< ?s 0)) (not (eq ?ABC ?MNP)))) (not (fact p congr-angle ?ABC ?MNP $?any)) => (assert (fact p congr-angle ?ABC ?MNP)) )
Urmtoarea regul dubleaz, prin efectul relaiei de simetrie, declaraia de congruen a dou unghiuri:
(defrule ca-simetry (declare (salience 10)) (fact p congr-angle ?ABC ?MNP $?pdem) (not (fact p congr-angle ?MNP ?ABC $?)) => (assert (fact p congr-angle ?MNP ?ABC ?pdem)) )
S notm c o astfel de declaraie redundant este necesar, pentru c nu putem ti ordinea n care se propag anumite proprieti. Dac segmentul AB este congruent cu segmentul MN, atunci va trebui s definim i congruena dintre segmentele MN i AB, dac vrem s nu pierdem anumite inferene care ar putea s fie generate de MN iar nu de AB. Din acelai motiv, segmentele vor fi tratate ca vectori iar unghiurile i triunghiurile vor avea un sens de citire.
214
n aceeai idee a definiiilor redundante dar necesare, urmtoarea regul introduce n baza de fapte congruena unui unghi cu el nsui, citit invers.
(defrule ca-reverse (declare (salience 10)) (angle (name ?ABC)) (angle (name ?CBA)) (test (eq ?CBA (str-cat (sub-string 3 3 ?ABC) (sub-string 2 2 ?ABC) (sub-string 1 1 ?ABC) ) )) (not (fact p congr-angle ?ABC ?CBA $?any)) => (assert (fact p congr-angle ?ABC ?CBA)) )
Urmtoarea regul aplic tranzitivitatea relaiei de congruen a unghiurilor:

(defrule ca-tranzitivity (declare (salience 10)) (fact p congr-angle ?ABC ?MNP $?pdem1) (fact p congr-angle ?MNP ?XYZ $?pdem2) (test (not (eq ?ABC ?XYZ))) (not (fact p congr-angle ?ABC ?XYZ $?any)) => (assert (fact p congr-angle ?ABC ?XYZ (create$ ?pdem1 ?pdem2 (str-cat ?ABC = ?MNP , ?MNP = ?XYZ => ?ABC = ?XYZ) ) ) ) )
Pentru prima oar, n aceast regul apare o completare a declaraiei unei relaii (n cazul de fa, cea de congruen) cu un ir ce intenioneaz s verbalizeze paii din demonstrarea acestei relaii. Cu alte cuvinte, dac unghiurile ABC i XYZ au fost dovedite a fi congruente, prin tranzitivitate, din relaiile ABC congruent cu MNP i MNP congruent cu XYZ, atunci n baz va apare un fapt:
(fact p congr-angle ABC XYZ <sir1> <sir2> ABC=MNP, MNP=XYZ => ABC=XYZ)
215
unde <sir1> i <sir2> sunt iruri de verbalizri ale demonstraiei faptului c ABC=MNP i, respectiv, MNP=XYZ. n aceeai manier, o seam de reguli genereaz declaraii de congruen a segmentelor pe baza egalitii lungimilor acestora i aplic proprietile de simetrie i tranzitivitate relaiei de congruen a segmentelor:
(defrule cs-equal-length (declare (salience 10)) (segment (name ?AB) (size ?s)) (segment (name ?MN) (size ?s)) (test (and (not (< ?s 0)) (not (eq ?AB ?MN)))) (not (fact p congr-segm ?AB ?MN $?any)) => (assert (fact p congr-segm ?AB ?MN)) ) (defrule cs-simetry (declare (salience 10)) (fact p congr-segm ?AB ?MN $?pdem) (not (fact p congr-segm ?MN ?AB $?any)) => (assert (fact p congr-segm ?MN ?AB ?pdem)) ) (defrule cs-reflexivity (declare (salience 10)) (segment (name ?AB)) (not (fact p congr-segm ?AB ?AB $?any)) => (assert (fact p congr-segm ?AB ?AB)) ) (defrule cs-reverse (declare (salience 10)) (segment (name ?AB)) (segment (name ?BA)) (test (eq ?BA (str-cat (sub-string 2 2 ?AB) (sub-string 1 1 ?AB)))) (not (fact p congr-segm ?AB ?BA $?any)) => (assert (fact p congr-segm ?AB ?BA)) ) (defrule cs-tranzitivity (declare (salience 10))
216
(fact p congr-segm ?AB ?MN $?pdem1) (fact p congr-segm ?MN ?XY $?pdem2) (test (not (eq ?AB ?XY))) (not (fact p congr-segm ?AB ?XY $?any)) => (assert (fact p congr-segm ?AB ?XY (create$ ?pdem1 ?pdem2 (str-cat ?AB = ?MN , ?MN = ?XY => ?AB = ?XY) ) ) ) )
Nici mcar obiectele geometrice degenerate, ca triunghiurile aplatizate, de exemplu, nu pot fi eliminate. Ar fi foarte uor s scriem o regul ca urmtoarea:
(defrule elim-degen-tr (declare (salience 80)) ?t <- (triangle (name ?ABC)) (fact p on ?A ?BC) (test (and (eq ?A (sub-string 1 1 ?ABC)) (eq ?BC (sub-string 2 3 ?ABC)) )) => (retract ?t) )
dar, o dat un astfel de triunghi eliminat, condiiile de regenerare a lui vor fi din nou satisfcute, ceea ce va duce la intrarea n bucle infinite. Reguli de geometrie. Regulile din aceast clas sunt cele mai interesante. Ele propag relaii dintre obiecte i proprieti ale acestora pe baza teoremelor din geometrie. De exemplu, un numr de reguli trateaz cazurile de congruen ale triunghiurilor. Cazul latur-unghi-latur:
(defrule ct-LUL (fact p congr-angle ?ABC ?MNP $?pdem2) (fact p congr-segm ?AB ?MN $?pdem1) (test (and (eq ?AB (sub-string 1 2 ?ABC)) (eq ?MN (sub-string 1 2 ?MNP))
217
)) (fact p congr-segm ?BC ?NP $?pdem3) (test (and (eq (sub-string 2 3 ?ABC) ?BC) (eq (sub-string 2 3 ?MNP) ?NP) )) (not (fact p congr-tr ?ABC ?MNP $?any)) => (assert (fact p congr-tr ?ABC ?MNP (create$ ?pdem1 ?pdem2 ?pdem3 (str-cat ?AB = ?MN , ?ABC = ?MNP , ?BC = ?NP => ?ABC # ?MNP (LUL)) ) ) ) )
Ca i mai sus, regula completeaz declaraia de congruen adugat n baz, cu paii care au dus la demonstrarea ei. n cazul de fa, la paii care au dus la demonstrarea egalitii segmentelor AB i MN, a congruenei unghiurilor ABC i MNP i a egalitii segmentelor BC i NP, se daug acest ultim pas care, din cele trei ipoteze, trage concluzia c triunghiurile ABC i MNP sunt congruente. Urmtoarea regul exprim o proprietate a triunghiurilor isoscele: faptul c din egalitatea a dou unghiuri se poate trage concluzia egalitii laturilor adiacente:
(defrule congr-angles-to-sides (fact p congr-angle ?ABC ?ACB $?pdem) (test (and (eq (sub-string 1 1 ?ABC) (sub-string 1 1 ?ACB)) (eq (sub-string 2 2 ?ABC) (sub-string 3 3 ?ACB)) (eq (sub-string 3 3 ?ABC) (sub-string 2 2 ?ACB)) )) (segment (name ?AB)) (test (eq ?AB (sub-string 1 2 ?ABC))) (segment (name ?AC)) (test (eq ?AC (sub-string 1 2 ?ACB))) (not (fact p congr-segm ?AB ?AC $?any)) => (assert (fact p congr-segm ?AB ?AC (create$ ?pdem (str-cat ?ABC = ?ACB => ?AB = ?AC (isoscel))) ) ) )
218
16.4. Lungimea rulrii i a demonstraiei

Un fapt concluzie, o dat demonstrat, este eliminat din baz. Procesul de inferen se oprete cnd toate concluziile au fost demonstrate:
(defrule stop-inference (declare (salience 50)) (not (fact c $?any)) => (printout t Toate concluziile au fost demonstrate. crlf) (halt) )
ntr-o abordare cum este cea de fa, care urmrete o parcurgere cvasiexhaustiv a spaiului strilor n vederea producerii unei demostraii, este firesc s ne preocupe lungimea rulrii i a soluiei generate. Nu este evident c acestea sunt direct proporionale. Este nendoios c dac o soluie exist, pentru sistemul de proprieti geometrice stabilite, ea va fi gsit, pentru c rularea se face cu un motor monoton. Strategia de rezoluie a conflictelor poate juca ns un rol important n viteza de gsire a soluiei, ct i n lungimea demonstraiei. O aplicare a regulilor n maniera nti-n-adncime poate duce la explorri foarte detaliate n cotloane neinteresante ale spaiului strilor, deci poate genera soluii lungi. Adoptarea strategiei nti-nlrgime echivaleaz cu o cutare cu raz constant n toate direciile, deci ar trebui, n principiu, s gseasc cele mai scurte soluii. Nu e exclus ns ca acestea s fie gsite mai greu. Rularea exemplului definit mai sus n strategia nti-n-lrgime provoac aprinderea a 584 de reguli care genereaz nu mai puin de 445 de obiecte geometrice i relaii ntre ele, plecnd de la cele declarate iniial. Marea majoritate a acestor obiecte sunt ns aberaii de genul unghiurilor i triunghiurilor aplatizate (de exemplu AOC) sau multiplicri inutile de obiecte obinute prin simple permutri de litere (triunghiurile OCB, OBC, CBO, COB etc.). n final ns se produce urmtoarea demonstraie:
CLIPS> (run) Concluzia (congr-segm AB AD) rezulta astfel: O@AC=>ACB=OCB OCB#OCD=>OCB=OCD ACB=OCB,OCB=OCD=>ACB=OCD O@AC=>OCD=ACD ACB=OCD,OCD=ACD=>ACB=ACD CBO#CDO=>CB=CD
219
AC=AC,ACB=ACD,CB=CD=>ACB#ACD(LUL) BAC#DAC=>BA=DA AB=BA,BA=DA=>AB=DA AB=DA,DA=AD=>AB=AD --Toate concluziile au fost demonstrate. CLIPS>
In acest raport, semnul @ semnific apartenena, # congruena de triunghiuri, iar = egalitatea de unghiuri. Aceeai intrare, dar rulat cu strategia nti-n-adncime, dei produce un numr nesemnificativ diferit de obiecte i relaii, prin aproximativ tot attea aprinderi de reguli, rezult ntr-o demonstraie mai lung:
CLIPS> (run) Concluzia (congr-segm AB AD) rezulta astfel: BCO#DCO=>BCO=DCO O@AC=>OCB=ACB OCB=ACB,ACB=BCA=>OCB=BCA BCO=OCB,OCB=BCA=>BCO=BCA ACB=BCA,BCA=BCO=>ACB=BCO DCO=BCO,BCO=ACB=>DCO=ACB O@AC=>ACD=OCD DCA=ACD,ACD=OCD=>DCA=OCD DCO=OCD,OCD=DCA=>DCO=DCA ACD=DCA,DCA=DCO=>ACD=DCO ACB=DCO,DCO=ACD=>ACB=ACD BCO#DCO=>BC=DC DC=BC,BC=CB=>DC=CB CB=DC,DC=CD=>CB=CD AC=AC,ACD=ACB,CD=CB=>ACD#ACB(LUL) ADC#ABC=>AD=AB --Toate concluziile au fost demonstrate. CLIPS>
Capitolul 17
Sfaturi de programare bazat pe reguli
17.1. Recomandri de stil n programare

Mai multe reguli mici, n care fiecare se ocup de un aspect elementar, dar bine definit, sunt mai bune dect mai puine reguli complicate, fiecare rezolvnd o poriune amorf definit a problemei. Evitai regulile care ncorporeaz n prile drepte decizii ce s-ar putea implementa prin comparaii ale abloanelor asupra faptelor, deci ca mai multe reguli elementare. O rezolvare elegant, exploatnd principiile programrii bazate pe reguli, adesea aduce mai multe beneficii dect o rezolvare aparent mai eficient care impurific regulile cu pri mari de cod aparinnd paradigmei imperative. Evitai o exploatare exagerat a nivelurilor de prioritate. Dei limbajele bazate pe reguli ofer o plaj imens de valori de prioritate, personal n-am ntlnit probleme care s fi necesitat mai mult de apte niveluri, iar cazurile cele mai frecvente sunt acelea n care dou, maximum trei niveluri sunt suficiente. Apoi, regulile plasate pe acelai nivel de prioritate trebuie s fie caracterizate de o anumit structur comun a abloanelor care s se circumscrie indicaiei enunate n capitolul 7 relativ la acoperirea parial a condiiilor. n general, structura unui program bazat pe reguli este aceea a unui automat cu stri (faze), n care tranziia ntre faze poate s nsemne comutarea coninutului unui fapt ce pstreaz numele fazei. Execuia caracteristic unei faze este format fie din ciclri fie din tranziii n alte faze. Uneori o faz poate fi caracterizat de subfaze, caz n care o structur de mai multe fapte poate memora plasarea exact a execuiei ntr-o anumit subfaz a unei subfaze a unei faze... Indiferent de nivelul de imbricare a unei astfel de organizri, vom considera c nivelul execuiei caracterizat de satisfacerea unui anumit subscop al problemei se cheam tot faz, menirea declaraiei de prioritate fiind realizarea unui control al execuiei doar n mulimea regulilor ce sunt caracteristice unei faze.
222
oprire cu succes
faza A
oprire cu eec ciclare
tranziie n faza B faza B
tranziie n faza C
faza C
Figura 43: O configuraie posibil de reguli caracteristice unei anumite faze A din evoluia unui sistem
Astfel, Figura 43 sugereaz o posibil organizare a unui sistem, la nivelul unei faze A, n care exist urmtoarele posibiliti de evoluie a calculului: - oprire pe succes; - oprire cu eec; - ciclare n interiorul fazei; - tranziie ntr-o stare B i - tranziie ntr-o stare C. Diferite nlimi considerate pe linia ntrerupt de simetrie vertical ce ilustreaz faza A, sugereaz niveluri de prioritate grupate n jurul prioritii de nivel 0, ataat regulii de ciclare (considerat central pentru semantica fazei), dup cum urmeaz:
(defrule terminare_cu_succes (declare (salience 20)) condiii de terminare cu succes => ) (defrule terminare_cu_esec (declare (salience 10)) condiii de terminare cu eec, potenial mai slabe dect ale regulii de terminare cu succes
223
=> ) (defrule ciclare condiii de ciclare, potenial mai slabe dect ale regulii de terminare cu eec => ) (defrule tranzitie_in_faza_B (declare (salience -10)) condiii de tranziie n faza B, potenial mai slabe dect ale regulii de ciclare i complementare fa de cele ale regulii de tranziie n faza C => ) (defrule tranzitie_in_faza_C (declare (salience -10)) condiii de tranziie n faza C, potenial mai slabe dect ale regulii de ciclare i complementare fa de cele ale regulii de tranziie n faza B => )
Execuia sugerat de cazul prezentat este una n care, la intrarea n faza A, se testeaz nti terminarea rulrii. Dac aceasta nu se confirm, regula de terminare cu succes este urmtoarea care ar putea fi luat n considerare. Abia dac nici condiiile ei nu sunt verificate, se execut regula de ciclare, atta timp ct i mai satisface nc condiiile de aplicare. Cnd aceasta nu se mai aplic, una dintre regulile de tranziie n faza B sau C se poate aplica. Condiiile lor fiind presupuse complementare, numai una dintre acestea poate fi satisfcut la un anumit moment dat. De remarcat c pe parcursul rulrii regulii de ciclare nu se mai poate efectua o terminare cu succes sau eec doar atta timp ct modificrile produse la fiecare pas de regula de ciclare nu vor satisface condiiile regulilor de terminare, presupuse mai tari.
224
17.2. Erori n execuia programelor CLIPS

De cte ori, compilnd ori executnd programele scrise de noi, nu am fost tentai s credem c maina cu care lucrm a luat-o prin blrii, pentru c ceea ce rezulta nu semna cu ceea ce gndeam c ar trebui s rezulte. i de cte ori nu am recunoscut, nfrni dar luminai, c maina avea dreptate (ori c eroarea era corect, aa cum, htru, se exprima un ilustru student al meu9). Ceea ce urmeaz este un scurt compendiu de erori comentate, ntlnite n rularea programelor CLIPS. Eroare de aliniere a unei variabile din ablon cu cmpurile unui fapt
Function < expected argument #2 to be of type integer or float [DRIVE1] This error occurred in the join network Problem resides in join #2 in rule(s): sortare-mijloc [PRCCODE4] Execution halted during the actions of defrule sortare-extrema-dreapta.
Eroarea a aprut ntr-o regul ce coninea urmtoarele abloane:

?lst <- (lista-finala $?prime ?un-nume ?o-val ?alt-nume ?alt-val $?ultime) ?pct <- (punctaj (nume ?num) (valoare ?val&:(and (< ?val ?o-val) (> ?val ?alt-val))))
Intenia era de a cuta n lista lista-finala, n care alternau perechi de valori simbolice cu valori numerice, dou astfel de perechi ntre ale cror valori numerice s poat fi plasat o alt valoare luat din lista punctaj. Necazul este c perechea de variabile ?un-nume ?o-val din primul ablon se poate potrivi pe o pereche care ncepe cu o valoarea numeric i continu cu o valoare simbolic, astfel nct valoarea comparat nu poate fi argument ntr-un test numeric. Corecia const n plasarea unui filtru suplimentar care s centreze variabilele pe ir n aa fel nct valorile numerice s fie n urma celor simbolice:
?lst <- (lista-finala $?prime ?un-nume ?o-val&:(numberp ?o-val) ?alt-nume ?alt-val $?ultime)
9
Dan Guru, pe unde vei mai fi hlduind?
225
?pct <- (punctaj (nume ?num) (valoare ?val&:(and (< ?val ?o-val) (> ?val ?alt-val))))
Eroare de folosire a variabilelor index S considerm o situaie n care se dorete memorarea ntr-o list a indexului unui fapt iar nu a faptului ca atare, urmnd ca apoi s se ncerce a se identifica, n faptul a crui adres am salvat-o n acest mod, anumite cmpuri. Urmtoarea tentativ eueaz:
(defrule start ?sc <- (stare (tip curenta)) => (assert (OPEN ?sc) ) (defrule selectie-stare-curenta (OPEN ?prim $?rest) ?prim <- (stare (predicate $?preds)) => )
Eroarea raportat este una de compilare si este generat de imposibilitatea de utilizare a unei variabile index ce a fost deja legat ntr-o condiie-ablon:
[ANALYSIS2] Pattern-address ?prim used in CE #2 was previously bound within a pattern CE. ERROR: (defrule MAIN::selectie-stare-curenta (OPEN ?prim $?rest) ?prim <- (stare (predicate $?preds)) => (printout predicate in starea curenta $?preds crlf))
O soluie, care ocolete problema pentru c evit folosirea indecilor faptelor, const n a marca n locul indexului un simbol unic, de exemplu generat cu (gensym), ca aici (unde nume este slotul care pstreaz acest simbol-adres):
(defrule start ?sc <- (stare (tip curenta)) =>
226
(bind ?sym (gensym)) (modify ?sc (nume ?sym)) (assert (OPEN ?sym) ) (defrule selectie-stare-curenta (OPEN ?prim $?rest) (stare (nume ?prim) (predicate $?preds)) => (printout t predicate in starea curenta $?preds crlf) )
17.3. Ateptri nendeplinite

Lsat s ruleze un anumit timp, intenionam, cu urmtorul program, s gsesc limitele ntre care genereaz numere funcia random:
(deffacts min-max (max 25000) (min 25000) ) (defrule act ?max <- (max ?x) ?min <- (min ?y) => (bind ?r (random)) (if (> ?r ?x) then (retract ?max) (assert (max ?r))) (if (< ?r ?y) then (retract ?min) (assert (min ?r))) )
Urmrirea rulrii arat ns c regula se aplic de un numr foarte mic de ori. n fapt, ea se aplic pn se ntmpl prima oar ca apelul funciei random s dea un numr n interiorul intervalului min-max. Pentru c n acel moment nici unul din fapte nu se mai modific i principiul refractabilitii mpiedic o nou aplicare a ei. Repararea const n modificarea de fiecare dat a faptelor min i max, chiar i atunci cnd valorile pe care le memoreaz nu se schimb:
(deffacts min-max (max 25000) (min 25000) )
227
(defrule act-v1 ?max <- (max ?x) ?min <- (min ?y) => (retract ?max ?min) (bind ?r (random)) (if (> ?r ?x) then (assert (max ?r) (min ?y)) else (if (< ?r ?y) then (assert (min ?r) (max ?x)) else (assert (min ?y) (max ?x)))) )
Pentru peste 40000 de aplicri ale regulii, extremele astfel gsite au fost 2 i 32766, dar limitele reale sunt ntre 1 i 215.
Bibliografie
1. AIKINS, J. S., KUNZ, J. C. , SHORTLIFFE, E. H. FALLAT, R. J. PUFF: an expert system for interpretation of pulmonary function data. Computers and Biomedical Research 16:199-208, 1983. 2. BARR, A., E., FEIGENBAUM, A., COHEN, P. (eds.) The Handbook of Artificial Intelligence, Volumes 1-3. Los Altos, CA: Kaufmann, 2 vol., 1981, 1982. 3. BENNETT, J. S. ROGET: a knowledge-based system for acquiring the conceptual structure of an expert system. Journal of Automated Reasoning 1(1):49-74, 1985. 4. BUCHANAN, B. G.; FEIGENBAUM, E. A. DENDRAL and META-DENDRAL: their applications dimensions. Artificial Intelligence 11:5-24, 1978. 5. BUCHANAN, B. G.; MITCHELL, T. Model directed learning of production rules. In D. A. Waterman and F. Hayes-Roth (eds.), Pattern-Directed Inference System. New York: Academic Press, 1978. 6. BUCHANAN, B. G., SHORTLIFFE, E. H. Rule-Based Expert Systems: The MYCIN Experiments oJ the Stanford Heuristic Programming Project. Reading, MA: Addison-Wesley, 1984. 7. BUCHANAN, B.; SMITH, R.. Fundamentals of Expert Systems, Annual Review of Computer Science 3, 23-58, 1988. 8. COOPER, T., WOGRIN, N. Rule-based Programming with OPS5, Morgan Kaufmann Publishers, 1988. 9. CRISTEA, D. Probleme de analiza limbajului natural. n curs de apariie la Editura Universitii "Alexandru Ioan Cuza" Iai, 2002. 10. CRISTEA, D., GALESCU, L., BACALU, C. L-Exp: A Language for building NLP applications, Proceedings of 14th International Avignon Conference Natural Language Processing, AI'94, Paris, 1994, pp. 97-107. 11. DAVIS, R., LENAT, D. Knowledge-Based Systems in Artificial Intelligence: AM and TEIRESIAS. New York: McGraw-Hill, 1982. 12. FAGAN, L. M. VM: representing time-dependent relations in a medical setting. Memo HPP 831 (Knowledge Systems Laboratory), June 1980. 13. FORGY, C. L. OPS5 User's Manual, Technical Report, CMU-CS-81-135, Carnegie Mellon University, School of Computer Science, Pittsburgh, PA, 1981. 14. FORGY, C. L. RETE: A fast algorithm for the many pattern/many object pattern match problem, Artificial Intelligence 19(1):17-37, September 1982.
230
15. GLEA, D., COSTIN, M., ZBANCIOC, M. Programarea n CLIPS prin exemple. Editura Tehnopress, 2001. 16. GIARRATANO, J.; RILEY, G. Expert Systems Principles and Practice", ediia a doua, PWS Publishing, Boston, MA., 1994, 644 pp. 17. GRAY, N. A. B.; SMITH, D. H.; VARKONY, T. H.; CARHART, R. E.; BUCHANAN, B. G. Use of a computer to identify unknown compounds: the automation of scientific inference. Chapter 7 in G. R. Waller and O. C. Dermer, eds., Biomedical Application of Mass Spectrometry. New York: Wiley, 1980. 18. GRIES, D. The Science of Programming. Springer-Verlag, 1981. 19. HASLING, D., CLANCEY, W. J., RENNELS, G. Strategic explanations for a diagnostic consultation system. International Journal of Man-Machine Studies 20(1):3-19, 1984. 20. JACKSON, P. Introduction to Expert Systems, 3rd Edn. Harlow, England: Addison Wesley Longman, 1999. 21. KATZ, S.S. Emulating the Prospector expert system with a raster GIS. Computer and Geosciences, 18., 1991. 22. KRIVINE, J.P., DAVID, J.M. L'Acquisition des Connaissances vue comme une Processus de Modlisation: Mthodes et Outils. Intellectica (12), 1991. 23. LENAT, D. The nature of heuristics. Artificial Intelligence 19(2): pp. 189-249, 1981. 24. LENAT, D. EURISKO: a program that learns new heuristics and domain concepts. Artificial Intelligence 21(2):61-98 (1983). 25. LINDSAY, R. K., BUCHANAN, B. G., FEIGENBAUM, E. A., LEDERBERG, J. Application of Artificial Intelligence for Chemistry: The DENDRAL Project. New York: McGrawHill, 1980. 26. LUCANU, D. Proiectarea algoritmilor. Tehnici elementare, Ed. Universitii Al. I. Cuza Iai, 1993. 27. MERRITT, D. Building Expert Systems in Prolog, Springer-Verlag, 1989. 28. MIRANKER, DANIEL P. TREAT: A better match algorithm for AI production systems. Proceedings of the Sixth National Conference on Artificial Intelligence (AAAI-87), pp. 42-47, 1987. 29. MIRANKER, DANIEL P. TREAT: A New and Efficient Match Algorithm for AI Production Systems, Morgan Kaufmann Publishers, 1990. 30. MOORE, T., MORRIS, K., BLACKWELL, G. COAMES - Towards a Coastal Management Expert System, Proceedings of the International Conference on GeoComputation, University of Leeds United Kingdom, 17 - 19 September 1996. 31. PERLIN, M. The match box algorithm for parallel production system match, Technical Report CMU-CS-89-163, Carnegie Mellon University, School of Computer Science, Pittsburgh, Pennsylvania, May 1989.
Bibliografie
231
32. PUPPE, F. Systematic Introduction to Expert Systems: Knowledge Representation and Problem Solving Methods. Berlin: Springer, 1993. 33. RICH, E., KNIGHT, K. Artificial Intelligence, McGraw Hill, 1991. 34. SLAGE, J., WICK, M. A method for evaluating expert system applications, AI Magazine 9, 1988. 35. VIDEANU, I. GEOM-2 Sistem expert pentru rezolvarea problemelor de geometrie n plan. Tez de licen, Facultatea de Informatic, Universitatea "Al.I.Cuza" Iai, 2001. 36. YAO, SUK I.; KIM, Il KON. DIAS1: An Expert System for Diagnosing Automobiles with Electronic Control Units, Expert Systems with Applications, 4(1), pp. 69-78, 1992.

Cuprins

Î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

Cuprins

Încărcat de

Drepturi de autor:

Formate disponibile

Cuprins

Programarea bazat pe reguli

Programarea bazat pe reguli

Programarea bazat pe reguli

Partea I Programarea bazat pe reguli i sistemele expert

Programarea bazat pe reguli

1.1. Programarea imperativ rezolv dictnd cum s faci

1.2. Programarea logic rezolv spunnd ce vrei s faci

Figura 1: Semnificaia predicatului platou(i, p, n, q)

Programarea bazat pe reguli

i+1-p ... ...

Pentru acest ir, calculul platoului maxim este amorsat de apelul:

Programarea bazat pe reguli

1.3. Programarea funcional rezolv apelnd o funcie

Programarea bazat pe reguli

1.4. Programarea orientat-obiect rezolv construind obiecte ce interacioneaz

Programarea bazat pe reguli

Programarea bazat pe reguli

==> ==> ==> ==>

f-3 f-4 f-5 f-6

(vector (vector (vector (platou

Ceea ce urmeaz dup comanda (run) semnaleaz aprinderea regulilor.

Ca urmare, lungimea maxim a platoului este actualizat de la 1...

... la 2, noul fapt primind indexul f-7.

Ca urmare, lungimea maxim a platoului este actualizat de la 2...

Conceptul a fost preluat de E. Feigenbaum pentru a fi aplicat la sistemele inteligente.

Programarea bazat pe reguli

2.1. Ce sunt sistemele expert ?

Introducere n sistemele expert

Figura 4: Aprofundarea cunoaterii nseamn rafinarea conceptelor i a legturilor dintre ele

Programarea bazat pe reguli

2.2. Particulariti ale domeniului inteligenei artificiale

Introducere n sistemele expert

2.3. Prin ce difer un sistem expert de un program clasic?

Programarea bazat pe reguli

Introducere n sistemele expert

2.4. Exemple de sisteme expert

Programarea bazat pe reguli

Introducere n sistemele expert

Programarea bazat pe reguli

2.5. Evaluarea oportunitii sistemelor expert

Introducere n sistemele expert

Partea a II-a Organizarea i funcionarea unui sistem expert

Figura 5: Componentele principale ale unui sistem expert

Programarea bazat pe reguli

3.1. Baza de cunotine: faptele

Organizarea unui sistem expert

Programarea bazat pe reguli

[pacient = Ionescu, mobilitate_gt = mic] [pacient = Ionescu, mobilitate_gt = normal]

Organizarea unui sistem expert

n aplicaia de construcii geometrice sugerat mai sus, urmtoarea indicaie de construcie:

Programarea bazat pe reguli

3.3. Variabile i abloane n reguli

Organizarea unui sistem expert

iar simbolurile c1, c2, c, a1, a2, b1 i b2 sunt toate variabile.

Programarea bazat pe reguli

3.4. Legri de variabile i instane de reguli

Organizarea unui sistem expert

Programarea bazat pe reguli

3.6. Motorul de inferene

Organizarea unui sistem expert

nlnuirea regulilor n motoarele de inferen

4.1. Cutarea soluiei n problemele de inteligen artificial