1) Descrieti enuntul bazat pe spatiul de stari: Fiind date: o stare initiala, o multime de stari finale si o multime de operatori de schimbare de stare, gasiti un sir de operatori care permit trecerea de la starea initiala la una din starile finale.
2) Descrieti enuntul bazat pe spatiul subproblemelor: Fiind date: o problema, o multime m ultime de operatori de descompunere in subprobleme si o multime de problem primitive (presupuse rezolvate), gasiti operatorii de aplicat pentru descompunerea problemei initiale intr-o multime de problem primitive.
3) Definiti rolul strategiilor in Clips. Descrieti doua strategii Clips:
O buna strategie permite, de cele mai multe ori, in cazul unei problem pr oblem a carei rezolvare sistematica este costisitoare, obtinerea de rezultate in timp rezonabil.
Strategia de control inapoi Porneste de la obiectivul care trebuie demonstat urm and ca problema sa fie descompusa in subprobleme de complexitate mai mica pana la obtinerea unor primitive sau fapte cunoscute, fie reformularea problemei in termini derivati pe baza regurilor folosite.
Strategia de control inainte Aplica metode reductive ptr obtinerea de subprobleme pe care le rezolva cu ajutorul unor metode prod. Se foloseste atunci cand metode reductive nu pot conduce direct catre solutii dupa descompunerea problemei.
4) Definiti rolul modulelor in Clips: Rolul modulelor in Clips este de a permite utilizatorului sa-si grupeze regulile in functie de actiunile realizate de acestea si de prefe rintele sale, in module.
5) Descrieti regula de inferenta „modus ponens” universal: Modus ponens (metoda afirmării) se referă la referente de forma p
⊃
q; „p,
atunci q". Premiza: P -> Q si P. Concluzie: Q Lat. „ponere”: a pune, a afirma.
Modalitatea prin care afirmand [P] afirma [Q]. Afirmarea antecedentului.
6) Descrieti algoritmul minimax. Aplicati algoritmul in cazul jocului „x si 0”. Alegeti o euristica, adancimea arborelui fiind 2.
Algoritmul Minimax este un algoritm de cautare intr-un arbore. Acest algoritm urmareste selectarea celei mai bune mutari pentru calculator, intr-un joc cu 2 jucatori. Mai intai se construieste arborele de joc cu toate mutarile posibile pentru ambii jucatori, dupa metoda descrisa mai sus. Acest algoritm este denumit Minima, deoarece calculatorul face mutarea care-I ofera castigul maxim, in acelsi timp asigurandu-se ca oponentul face mutarea cea mai defavorabila calc. Deoarece multarile alterneaza, si alg. alterneaza maximizand si minimizand nivele arborelui in mod recursive. Minimax face cautarea numai pe o adancime fixa.
Proprietati: Optimal: Da (impotriva unui adversary optimal) Complexitate temporara: b^m, unde b – factorul de ramificare m – adancimea arborelui Complex. Spatiala: O(b*m)
7) Diferente dintre graful „si -sau” si arborele de joc: 1) In cazul spatiului subproblemelor, functia de evaluare f s e calculeaza pentru toate nodurile. In cazul algoritmului Minimax, evaluarea se face doar la nivelul frunza.
2) Algoritmul Minimax se extinde in totalitate la un anumit nivel. Spatiul subproblemelor se extinde in functie de cost.
8) Definiti cunostintele imprecise si tipul de rationament asociat. Dati un exemplu de generator de sisteme expert ce foloseste acest tip de rationament: Cunostintele sunt utilizate pentru a putea rezolva o anumita problema dintrun anumit context. Aceste informatii au rolul de a descrie contextul si de a furniza elemente privind datele problemei si metode de rezolvare corespunzatoare, prin folosirea unui rationament adecvat. Toate aceste cunostinte sunt introduse intr-o baza de cunostinte, pentru a putea fi digitalizate. Cunostintele primite pot avea un caracter imperfect, cum ar fi imprecizia. Aceasta imprecizie se datoreaza nesigurantei informatiilor primite si a inexactitatii lor. Rationamentul care utilizeaza cunostintele imprecise, se numeste rationament
aproximativ. Generatorul de sisteme expert care foloseste cunostintele imprecise, se numeste Clips.
9) Definiti modul de reprezentare bazat pe retelele semantice: Modelul retelelor semantice a fost primul model structurat de reprezentare a cunostintelor, folosit pentru a descrie semantica cuvintelor si a propozitiilor limbajului natural. Modelul mai ofera posibilitatea de a organiza si structura cunostintelor in functie de ralatiile existente, intre obiectele universului problemei.
10) Definiti modul de reprezentare bazat pe frame-uri: Un frame este un prototip ce descrie o situatie sau un obiect standard. Reprezentarea prin intermediul frame-urilor se face prin intermediul sloturilor. Slot-urile sunt niste atribute ale caror diferite aspecte sunt descrise cu ajutorul unor fatete declarative sau procedurale.
11) Enumerati cinci caracteristici ale inteligentei artificiale: -
Problemele rezolvate de IA se refera la activitati umane variate: perceptie, gandire, ratiune, etc.
-
Toate problemele pentru care nu exista un algoritm cunoscut, necesita aportul IA.
-
Problemele IA necesita un rationament predominant simbolic.
-
Solutiile care se cer in cadrul IA nu trebuie sa fie cele mai exacte sau cele mai bune. Uneori este de ajuns sa se gaseasca o singura solutie sau o formulare aproximativa al acesteia.
-
IA se ocupa cu automatizarea comportarii inteligente.
12) Care este corespondenta intre termenii grafului de solutii si termenii grafului de stari. (enunt combinatorial -> enuntul bazat pe spatiul de stari): Enuntul combinatorial: Contine: X = spatiu sau univers. K = constrangeri. => Astfel incat, l apartine X/K, pentru a determina numarul de elemente ale universului X, care verifica constrangerile K. Formalizare (Graful de solutii): Reprezentare: Graful de solutii. Nodul radacina: Solutia vida. Nodul intermediar: Solutie intermediara sau partiala. Nodul frunza: Solutia sau esecul. Arc intre doua noduri: La alegere. Complexitate: O(K^n).
Enuntul bazat pe spatiul de stari: Avem o stare initiala: Si. Avem o multime de stari finale: Sf. Avem o multime de operatori, care ne permit sa ajungem de la o stare la alta. (opK: Sk -> Sk +1). Gasirea operatorilor potriviti pentru a putea ajunge la una dintre starile finale, pornind de la starea initiala. Formalizare(Graful de stari): Reprezentare: Graful de stari. Nodul radacina: Si. Nodul intermediar: Solutie intermediara. Nodul frunza: Sf sau esec. Arc intre doua noduri: Un operator. Complexitate: O(K^n).
13) Caracterizati algoritmul de parcurgere iterativ in adancime din punctul de vedere al complexitatii, completitudinii si optimalitatii: - Este un algoritm de parcurgere neinformat. - Complexitate de timp: O(K^n). - Complexitate de spatiu: O(K^n).
- Completitudine: DA. - Optimalitate: DA. 14) Caracterizati euristicile: Def: Euristicile sunt principii dupa care se alege cea mai buna alternativa de atingere al unei tinte. Caracteristici: 1) Completitudine. 2) Complexitate de timp. 3) Complexitate de spatiu. 4) Optimalitate.
Tipuri de euristici: 1) Functia de evaluare. 2) Reducerea diferentelor. 3) Alegerea cea mai constransa.
15) Caracterizati algoritmul de parcurgere iterativ in adancime si cu adancime limitata din punctul de vedere al complexitatii, completitudinii si optimalitatii: Adancime: -
Completitudine: NU
-
Optimalitate: NU
-
Complexitate de timp: O(b^m)
-
Complexitate de spatiu: O(b^m)
Cautare limitata in adancime: -
Completitudine: DA
-
Optimalitate: NU
-
Complexitate de timp: O(b^l)
-
Complexitate de spatiu: O(b*l)
16) Definiti si caracterizati rezolvarea problemelor in IA. Dati 2 exemple: Def: Toate problemele pentru care nu exista algoritm de rezolvare, sau nu se gaseste un algoritm rezonabil, necesita aportul IA. Moduri de rezolvare al problemelor: 1) Informatica clasica: Problema + ratiune -> algoritm + procesare masina -> solutie. 2) Inteligenta artificiala:
Enuntul problemei + ratiune + (elemente de cunostinta si strategii de rezolvare) -> solutie. In IA rezolvarea unei probleme dificile presupune: 1) A dispune de un set de cunostinte. 2) A le folosi pentru a putea rationa. 3) A avea o „buna” folosire a cunostintelor „bune” => strategie eficienta.
Modele de rezolvare a problemelor in IA (2 exemple): 1) DEDRAL = Aplica ciclul „generate and test” asupra ipotezelor problemelor. 2) SOAR = Prezinta o modalitate universala de rezolvare a problemelor, prin crearea unui univers subtinta.
17) Definiti tipurile de rationament asociate cunostintelor imprecise si incerte: 1) Rationamentul aproximativ: O caracteristica a cunostintelor este imperfectiunea lor. Aceasta imperfectiune poate lua forma impreciziei sau a incertitudinii. Pentru a putea gestiona astfel de cunostinte, sistemul bazat pe cunostinte foloseste un rationament aproximativ, avand urmatoarele caracteristici: -
Crearea unei ilustrari a cunostintelor imprecise si incerte.
-
Largirea mecanismelor de rationament, pentru a putea lua in considerare cunostintele respective.
-
Propagarea aproximarii in cursul etapelor de rationament. Rationamentul aproximativ mai apare si in cadrul rationamentelor de: clasificare, analogie, ipotetic.
18) Definiti si caracterizati euristicile. Dati 2 ex de euristici folosite in 8 puzzle: -
La fel ca si la celalat punct in care am definit euristicile.
Euristici utilizate in 8 puzzle (2 exemple): 1) X-Y: Presupunem ca putem inlocui spatiul liber din puzzle cu orice spatiu ocupat de un element, folosind o regula de miscare. (sus, jos, stanga, dreapta). 2) n- MaxSwap: Presupunem ca puteme inlocui spatiul liber din puzzle cu orice spatiu ocupat de un element. Toate miscarile folosite vor fi atribuite ca si valoarea euristicii.
19) Cand spunem ca euristica h2 domina euristica h1 ? Presupunem ca avem 2 euristici admisibile, h1 si h2. Euristica h2 domina euristica h1, atunci cand drumul precizat de euristica h2 es te mai eficient decat drumul precizat de h1. Astfel, putem nota h2(n) > h1(n), pentru orice nod n.
20) Definiti tipul de rationament asociat cunostintelor incomplete: Rationamentul ipotetic: Rationamentul ipotetic gestioneaza cunostintele care sunt incomplete. => o eventuala revizuire a comportamentului. Se fac supozitii asupra cunostintelor care lipsesc, prin folosirea unui sistem de gestiune al ipotezelor. Modalitati de revizuire a comportamentului: 1) Evolutie: Noi fapte apara pentru a contrazice faptele optinute anterior. (Universul problemei evolueaza) 2) Nemonotonie: Cunostinte noi apar pentru a contrazice ipoteza obtinuta anterior.
21) Fiind date euristicile admisibile h1,h2, ... , hm, ce puteti spune de euristica h(n) = max (h1(n),h2(n),...,hm(n)) ? Eusiticile admisibile sunt euristici care nu supraestimeaza costul de atingere al unei stari finale. Acestea se mai numesc si euristici optimiste, deoarece estimeaza ca este mai usor de a ajunge la o stare finala, decat este in realitate. Secventa h(n) = max (h1(n),h2(n),...,hm(n)), apare in cadrul algoritmului de cautare A*, care este optim si complet atunci cand euristica h(n) este admisibila. Pentru ca euristica h(n) sa fie admisibila, trebuie ca si celalate euristici sa fie admisibile. Astfel, putem spune ca euristica h(n) domina euristicile h1(n),h2(n), ... ,hm(n), pentru orice nod n.
22) Enumerati cinci moduri de reprezentare a cunostintelor: 1) Logica. 2) Reprezentare mixta. 3) Reprezentare prin folosirea mostenirii. 4) Reprezentare procedurala. 5) Reguli de productie.
23) Definiti rationamentul din punct de vedere informatic: Un rationament in cadrul unei baze de cunostinte, reprezinta o insiruire de elemente de cunostinte, care aplicate unor informatii cunoscute, pot conduce la o tinta cautata. Un rationament reprezinta un set de enunturi sau de reprezentari simbolice, conduse de catre o anumita tinta, care poate lua mai multe valori: determina, argumenteaza, convinge, rationeaza, etc.
24) Descrieti taietura beta din cadrul algoritmului alpha-beta: -
Fie alpha, cea mai buna valoare (cea mai mare) al lui MAX si beta, cea mai buna valoare (cea mai mica) al lui MIN. Algoritmul va actualiza valorile lui alpha si a lui beta in timpul parcurgerii arborelui si va elimina subarborii pentru care alpha si beta au valori ineficiente.
-
Algoritmul se va opri sub un nod MAX, avand pe alpha cu o valoare mai mare sau egala cu beta, valoare asociata lui MIN care este predecesorul lui MAX.
25) Descrieti algoritmul de cautare „hill climbing search”. Exemplificati in cadrul unei probleme: -
Algoritmul nu stocheaza un arbore de cautare, astfel toate nodurile isi vor stoca starea lor curenta si evaluarea lor. Este vorba de o miscare constanta pentru a atinge valori mai mari, mai bune.
-
In cazul in care sunt mai multi succesori care au aceeasi valoare, algoritmul va selecta un singur succesor in mod aleator. Dezavantaje: 1) Maximele locale: Reprezinta un varf care este mai mic decat cel mai inalt varf din spatiul starilor. Cand algoritmul intalneste o maxima locala, acesta se va opri deoarece nu mai poate cobori dealul. Astfel, valoarea gasita va fi una ineficienta. 2) Platourile: Reprezinta o zona din spatiul de cautare in care valoarea functiei de evaluarea este constanta. Astfel, cautarea se va desfasura in mod aleator. Ex: Problema celor 8 dame.
-
Functia de evaluare: Numarul de perechi de dame care se ataca in mod direct / indirect.
-
Minimul local: h = 1.
26) Definiti notiunea de prioritate a regulilor in Clips / JESS: -
Fiecare regula in JESS contine o anumita prioritate, pentru a putea determina care dintre reguli va fi declansate prima.
-
O regula cu o prioritate mai mare, va fi declansata inaintea unei reguli cu o prioritate mai mica. Programatorul poate selecta ordinea apelarii regulilor, prin caracteristicile oferite de catre functia defrule.
27) Explicati ciclul motor in cazul inlantuirii inapoi: -
Spatiul problemei poate fi explorat si in sens invers, fata de modul in care a fost explorat anterior.
-
Daca cautarea incepe de la un nod final si are ca destinatie un nod initial, putem spune ca avem de-a face cu un rationament inapoi.
-
Nodul radacina reprezinta starea tinta.
-
Arborele isi creeaza nivelul urmator prin determinarea regulilor a caror parte dreapta se potriveste cu nodul radacina.
-
Nodurile vor fi adaugate prin determinarea partii stangi a regulilor considerate.
-
Acest ciclu se repeta pentru fiecare nod in parte, pana cand se va dezvolta o structura identica cu starea initiala.
28) Enumerati 5 tipuri de cunostinte: 1) Relatii. 2) Algoritmi de rezolvare. 3) Euristici si strategii. 4) Elemente de baza , obiecte ale lumii reale. 5) Asertiune asupra elementelor de baza.
29) Descrieti algoritmul d e cautare „beam search”: Algoritmul Beam search foloseste algoritmul Breadth-first-search pentru a-si construi arborele de cautare. Acesta adauga succesorii starilor curente, in ordinea crescatoare a euristicii. Acesta mai stocheaza si o valoarea pre-determinata beta, in care sunt incluse valorile cele mai bune de pe fiecare nivel al arborelui (latimea beam-ului). Cu cat latimea beam-ului este mai mare, cu atat se vor taia mai putine stari.
Beam Search nu este un algoritm optim, nu garanteaza ca va gasi solutia cea mai eficienta, returneaza prima solutie pe care o gaseste.
30) Ce intelegeti prin probleme de complexitate NP ? -
Clasa tuturor problemelor care pot fi rezolvate doar cu ajutorul algoritmilor nedeterministi, intr-un timp polinomial P si astfel sunt numite NP (nedeterministic polinomial).
-
Problemele de tipul P se gasesc si in cadrul problemelor NP, deoarece algoritmii deterministi reprezinta un caz extrem al algoritmilor nedeterministi.
31) Consideram un automat de cafea ce permite utilizarea monezilor de 5 centi si de 25 centi, pretul unei cafele fiind 55 centi. Aparatul este reprezentat printr-un automat finit unde:
multime de fapte. Scrieti o baza de reguli ce permite ca de la o stare curenta si o valoare (moneda) introdusa permite trecerea automantului intr-o alta stare. b) Simulati introducerea unui sir de monezi in vederea ajungerii in starea finala (obtinerea cafelei). c) Scrieti niste reguli de control ce permit la cererea utilizatorului trecerea in starea initiala (apt pentru o noua comanda de cafea). d) Cum putem realiza sistemul a.i. banii ramasi in aparat sa poata fi folositi la plata urmatoarei cafele ?
(deftemplate numeStare (slot nume) ) (deftemplate relatie (slot monezi) (slot stare1) (slot stare2) ) (deftemplate functionareAparat (slot stareCurenta) (slot moneda)
) (deftemplate ControlExecutie (slot intrebare) (slot raspuns) ) (assert (numeStare (nume start))) (assert (numeStare (nume 5))) (assert (numeStare (nume 10))) (assert (numeStare (nume 15))) (assert (numeStare (nume 20))) (assert (numeStare (nume 25))) (assert (numeStare (nume 30))) (assert (numeStare (nume 35))) (assert (numeStare (nume 40))) (assert (numeStare (nume 45))) (assert (numeStare (nume 50))) (assert (numeStare (nume succes)))
(assert (relatie (monezi N) (stare1 start) (stare2 5))) (assert (relatie (monezi Q) (stare1 start) (stare2 25))) (assert (relatie (monezi N) (stare1 5) (stare2 10)))
(assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi (assert (relatie (monezi
Q) N) Q) N) Q) N) Q) N) Q) N) Q) N) Q) N) Q) N) Q) N) Q)
(stare1 5) (stare2 30))) (stare1 10) (stare2 15))) (stare1 10) (stare2 35))) (stare1 15) (stare2 20))) (stare1 15) (stare2 40))) (stare1 20) (stare2 25))) (stare1 20) (stare2 45))) (stare1 25) (stare2 30))) (stare1 25) (stare2 50))) (stare1 30) (stare2 35))) (stare1 30) (stare2 succes))) (stare1 35) (stare2 40))) (stare1 35) (stare2 succes))) (stare1 40) (stare2 45))) (stare1 40) (stare2 succes))) (stare1 45) (stare2 50))) (stare1 45) (stare2 succes))) (stare1 50) (stare2 succes))) (stare1 50) (stare2 succes)))
(facts) (assert (functionareAparat (stareCurenta nil) (moneda nil))) (defrule Faza1 (functionareAparat (stareCurenta nil) (moneda nil)) => (printout t "Introduceti o moneda: 5 sau 25 centi" crlf) (bind ?m (read)) (assert (functionareAparat (stareCurenta start) (moneda ?m))) ) (defrule Faza2 (functionareAparat (stareCurenta 5) (moneda 5)) => (printout t "Introduceti inca o moneda in valoare de: 5 sau 25 centi" crlf) (bind ?m (read))
(assert (functionareAparat (stareCurenta 5) (moneda ?m))) ) (defrule Intrebare1 (ControlExecutie (intrebare nil) (raspuns nil)) => (printout t "Resetare sistem ? (DA/NU)" crlf) (bind ?r (read)) (assert (ControlExecutie (intrebare "Resetare sistem") (raspuns ?r))) ) (defrule Control1 (ControlExecutie (intrebare "Resetare sistem ?") (raspuns DA)) (functionareAparat (stareCurenta start) (moneda nil)) => (printout t "Sistemul a fost resetat!" crlf) (printout t "Introduceti o moneda in valoare de: 5 sau 25 centi" crlf) (bind ?m (read)) (assert (functionareAparat (stareCurenta start) (moneda ?m))) ) (defrule Control2 (ControlExecutie (intrebare "Resetare sistem ?") (raspuns NU)) => (printout t "Sistemul va continua procesul de producere al cafelei" crlf)
)
(defrule Faza3 (functionareAparat (stareCurenta 25) (moneda 25)) => (printout t "Introduceti inca o moneda in valoare de: 5 sau 25 centi" crlf) (bind ?m (read)) (assert (functionareAparat (stareCurenta 25) (moneda ?m))) ) (defrule Faza4 (functionareAparat (stareCurenta 10) (moneda 5)) => (printout t "Introduceti inca o moneda in valoare de: 5 sau 25 centi" crlf) (bind ?m (read)) (assert (functionareAparat (stareCurenta 10) (moneda ?m))) ) (defrule Faza5 (functionareAparat (stareCurenta 50) (moneda 25)) => (printout t "Introduceti inca o moneda in valoare de: 5 sau 25 centi" crlf) (bind ?m (read)) (assert (functionareAparat (stareCurenta 50) (moneda ?m))) ) (defrule Faza6 (functionareAparat (stareCurenta 15) (moneda 5)) =>
(printout t "Introduceti inca o moneda in valoare de: 5 sau 25 centi" crlf) (bind ?m (read)) (assert (functionareAparat (stareCurenta 15) (moneda ?m))) ) (defrule Incheiere1 (functionareAparat (stareCurenta 55) (moneda 5)) => (printout t "Cafeaua a fost platita !" crlf) ) (defrule Faza8 (functionareAparat (stareCurenta 20) (moneda 5)) => (printout t "Introduceti inca o moneda in valoare de: 5 sau 25 centi" crlf) (bind ?m (read)) (assert (functionareAparat (stareCurenta 20) (moneda ?m))) ) (run) ;ETC pana la 55
32) Se considera date mai multe figuri geometrice (dreptiunghiuri, patrate, cercuri), definite cu fapte de forma: (dreptunghi ), (patrat ), (cerc ). a) Sa se scrie o baza de reguli ce calculeaza suma ariilor pentru fiecare categorie. b) De asemenea, se va calcula si suma ariilor tuturor figurilor geometrice date.
(deftemplate dreptunghi (slot nume) (slot lungime) (slot latime) ) (assert (dreptunghi (nume drept1) (lungime 20) (latime 2.5))) (deftemplate patrat (slot nume) (slot latura) ) (assert (patrat (nume patrat1) (latura 20)))
(deftemplate cerc (slot nume) (slot raza) ) (assert (cerc (nume cerc1) (raza 20))) (deftemplate ValoareStocare (slot valoare) (slot valoare2) (slot valoare3)
)
(assert (ValoareStocare (valoare 1) (valoare2 1) (valoare3 1))) (deftemplate sumaAriei (slot suma) ) (assert (sumaAriei (suma 0)))
(defrule CalculArieDreptunghi ?valD <- (dreptunghi (lungime ?L) (latime ?l)) ?valA <- (ValoareStocare (valoare ?va)) => (modify ?valA (valoare (* ?L ?l ?va))) (retract ?valD) ) (defrule AfisareArieDreptunghi (ValoareStocare (valoare ?arie1)) => (printout t "Aria dreptunghiului este:" ?arie1 crlf) )
; ARIE PATRAT (defrule CalculAriePatrat ?valP <- (patrat (latura ?l)) ?valA <- (ValoareStocare (valoare2 ?va2)) => (modify ?valA (valoare2 (* ?l ?l ?va2))) (retract ?valP)
) (defrule AfisareAriePatrat (ValoareStocare (valoare2 ?arie2)) => (printout t "Aria patratului este:" ?arie2 crlf) )
; ARIE CERC (defrule CalculArieCerc ?valC <- (cerc (raza ?r)) ?valA <- (ValoareStocare (valoare3 ?va3)) => (modify ?valA (valoare3 (* 3.14 ?r ?r ?va3))) (retract ?valC) ) (defrule AfisareArieCerc (ValoareStocare (valoare3 ?arie3)) => (printout t "Aria cercului este:" ?arie3 crlf) )
(defrule SumaArie ?arie <- (ValoareStocare (valoare ?arie1) (valoare2 ?arie2) (valoare3 ?arie3)) ?sume <- (sumaAriei (suma ?sa))
=> (modify ?sume (suma (+ ?arie1 ?arie2 ?arie3 ?sa))) (retract ?arie) ) (defrule AfisareSumaArie (sumaAriei (suma ?sumaArie)) => (printout t "Suma ariei este egala cu:" ?sumaArie crlf) ) (run)
33)Fie automatul finit partial utilizat pentru a determina validitatea unei intrari (in cadrul procesului de compilare):
Reprezentati automatul finit ca o multime de fapte; b) Fiind date – automatul, o stare curenta (stare-curenta ) si o intrare (input ) - sa se scrie o baza de reguli pentru a determina urmatoarea stare a automatului; c) Fiind dat un sir de intrari (sub forma de fapte) sa se determine starile prin care trece automatul; d) Adaugati reguli care
permit revenirea, la cerere, la starea initiala pentru a rezolva o noua problema.
(deftemplate automat (slot prinStare) (slot nodCurent) (slot nodUrmator) )
(assert (automat (nodCurent Start) (prinStare w) (nodUrmator nod1_w))) (assert (automat (nodCurent nod1_w) (prinStare H) (nodUrmator nod2_H))) (assert (automat (nodCurent nod1_w) (prinStare R) (nodUrmator nod3_R))) (assert (automat (nodCurent nod2_H) (prinStare I) (nodUrmator nod4_I))) (assert (automat (nodCurent nod3_R) (prinStare I) (nodUrmator nod5_I))) (assert (automat (nodCurent nod4_I) (prinStare L) (nodUrmator nod6_L))) (assert (automat (nodCurent nod5_I) (prinStare T) (nodUrmator nod6_T))) (assert (automat (nodCurent nod6_L) (prinStare E) (nodUrmator Succes))) (assert (automat (nodCurent Start) (prinStare B) (nodUrmator nod7_B))) (assert (automat (nodCurent nod7_B) (prinStare E) (nodUrmator nod8_E))) (assert (automat (nodCurent nod7_B) (prinStare notE) (nodUrmator Error)))
(assert (automat (nodCurent nod8_E) (prinStare G) (nodUrmator nod9_G))) (assert (automat (nodCurent nod8_E) (prinStare notG) (nodUrmator Error))) (assert (automat (nodCurent nod9_G) (prinStare I) (nodUrmator nod10_I))) (assert (automat (nodCurent nod9_G) (prinStare notI) (nodUrmator Error))) (assert (automat (nodCurent nod10_I) (prinStare N) (nodUrmator Succes))) (assert (automat (nodCurent nod10_I) (prinStare notN) (nodUrmator Error))) (facts) (deftemplate functionare (slot nodCurent) (slot prinStare) ) (assert (functionare (nodCurent nil) (prinStare nil)))
(defrule Faza1 (functionare (nodCurent nil)(prinStare nil)) => (printout t "Alegeti starea de deplasare (w,B):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) ) (defrule Faza2 (functionare (nodCurent nod1)(prinStare w))
=> (printout t "Sunteti in nodul: nod1" crlf) (printout t "Alegeti starea de deplasare (H,R):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) ) (defrule Faza3 (functionare (nodCurent nod7)(prinStare B)) => (printout t "Sunteti in nodul: nod7" crlf) (printout t "Alegeti starea de deplasare (E,notE):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) ) (defrule Faza4 (functionare (nodCurent nod2)(prinStare H)) => (printout t "Sunteti in nodul: nod2" crlf) (printout t "Alegeti starea de deplasare (I):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) ) (defrule Faza5 (functionare (nodCurent nod8)(prinStare E)) => (printout t "Sunteti in nodul: nod8" crlf) (printout t "Alegeti starea de deplasare (G,notG):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n)))
) (defrule Faza6 (functionare (nodCurent nod3)(prinStare R)) => (printout t "Sunteti in nodul: nod3" crlf) (printout t "Alegeti starea de deplasare (I):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) ) (defrule Faza7 (functionare (nodCurent Error)(prinStare notE)) => (printout t "Sunteti in nodul: Error" crlf) (printout t "Programul se incheie" crlf) ) (defrule Faza8 (functionare (nodCurent nod4)(prinStare I)) => (printout t "Sunteti in nodul: nod4" crlf) (printout t "Alegeti starea de deplasare (L):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) ) (defrule Faza9 (functionare (nodCurent nod9)(prinStare G)) => (printout t "Sunteti in nodul: nod8" crlf)
(printout t "Alegeti starea de deplasare (I,notI):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) ) (defrule Faza10 (functionare (nodCurent nod5)(prinStare I)) => (printout t "Sunteti in nodul: nod5" crlf) (printout t "Alegeti starea de deplasare (T):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) ) (defrule Faza11 (functionare (nodCurent nod6)(prinStare L)) => (printout t "Sunteti in nodul: nod6" crlf) (printout t "Alegeti starea de deplasare (E):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) ) (defrule Faza12 (functionare (nodCurent nod10)(prinStare I)) => (printout t "Sunteti in nodul: nod6" crlf) (printout t "Alegeti starea de deplasare (N,notN):" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) ) (defrule Faza13
(functionare (nodCurent nod10)(prinStare notI)) => (printout t "Sunteti in nodul: Error" crlf) (printout t "Programul se va incheia" crlf) ) (defrule Faza14 (functionare (nodCurent Error)(prinStare notG)) => (printout t "Sunteti in nodul: Error" crlf) (printout t "Programul se va incheia" crlf) ) (defrule Faza15 (functionare (nodCurent Succes)(prinStare E)) => (printout t "Sunteti in nodul: Succes" crlf) (printout t "Programul se va incheia" crlf) ) (defrule Faza16 (functionare (nodCurent Error)(prinStare notN)) => (printout t "Sunteti in nodul: Error" crlf) (printout t "Programul se va incheia" crlf) ) (defrule Faza17 (functionare (nodCurent nod10)(prinStare N)) =>
(printout t "Sunteti in nodul: Succes" crlf) (printout t "Programul se va incheia" crlf) ) (run)
(deftemplate Revenire (slot Intrebare) (slot Raspuns) ) (assert (Revenire (Intrebare nil) (Raspuns nil))) (defrule Intrebare (Revenire (Intrebare nil) (Raspuns nil)) => (printout "Doriti sa resetati programul ? (DA/NU)" crlf) (bind ?r (read)) (assert (Revenire (Intrebare "Doriti sa resetati programul ?") (Raspuns ?r))) ) (defrule Raspuns1 (Revenire (Intrebare "Doriti sa resetati programul ?") (Raspuns DA)) (functionare (nodCurent nil) (prinStare nil)) => (printout t "Programul a fost resetat, alegeti calea: (w,B)" crlf) (bind ?n (read)) (assert (functionare (nodCurent Start) (prinStare ?n))) )
(defrule Raspuns2 (Revenire (Intrebare "Doriti sa resetati programul ?") (Raspuns NU))
=> (printout t "Programul va continua" crlf) )
34)a) Convertiti reteaua semantica urmatoare intr-o multime de fapte (relatiile avute in vedere fiind isa, ako, respectiv atribut):
AKO
Aircraft
AKO
Has-shape round
AKO
ballon
Pr. driven
jet
AKO AKO AKO Ellips.
AKO
AKO
AKO
blimp
specia l
Has-shape IS-A
Good year
DC-3
DC-9
IS-A
Spirit of StL
Conco rde IS-A
AirFo rce 1
b) Scrieti o multime de reguli ce permit determinarea tuturor conceptelor ce sunt un
relatia AKO sau IS-A plus AKO cu un concept dat (indiferent de
numarul de relatii successive de tipul AKO) (de exemplu (det-all-AKO blimp) ballon, Pr.driven, Aircraft).
(deftemplate retea (slot relatie) (slot atribut1) (slot atribut2)
) (assert (retea (atribut1 GoodYear) (relatie IS-A) (atribut2 Blimp))) (assert (retea (atribut1 Blimp) (relatie Has-shape) (atribut2 Ellips))) (assert (retea (atribut1 Blimp) (relatie AKO) (atribut2 Pr.driven))) (assert (retea (atribut1 Blimp) (relatie AKO) (atribut2 Ballon))) (assert (retea (atribut1 Ballon) (relatie Has-shape) (atribut2 Round))) (assert (retea (atribut1 Ballon) (relatie AKO) (atribut2 Aircraft))) (assert (retea (atribut1 SpiritOfStl) (relatie IS-A) (atribut2 Special))) (assert (retea (atribut1 Special) (relatie AKO) (atribut2 Pr.driven))) (assert (retea (atribut1 Pr.driven) (relatie AKO) (atribut2 Aircraft))) (assert (retea (atribut1 DC-3) (relatie AKO) (atribut2 Pr.driven))) (assert (retea (atribut1 Airforce1) (relatie IS-A) (atribut2 DC-9))) (assert (retea (atribut1 DC-9) (relatie AKO) (atribut2 Jet))) (assert (retea (atribut1 Concorde) (relatie AKO) (atribut2 Jet))) (facts) (defrule AKO (retea (atribut1 ?x)(atribut2 ?y)(relatie ?z) {relatie == AKO})
=> (printout t "Atributele " "(" ?x "," ?y ")" "sunt in relatia " ?z crlf) ) (run) (defrule IS-A (retea (atribut1 ?x)(atribut2 ?y)(relatie ?z) {relatie == IS-A}) => (printout t "Atributele " "(" ?x "," ?y ")" "sunt in relatia " ?z crlf) ) (run) (defrule Has-shape (retea (atribut1 ?x)(atribut2 ?y)(relatie ?z) {relatie == Has-shape}) => (printout t "Atributele " "(" ?x "," ?y ")" "sunt in relatia " ?z crlf) ) (run)
35)a) Convertiti arborele de decizie urmator (ce reprezinta informatii despre clasificarea animalelor) intr-o multime de fapte. Cum sunt reprezentate legaturile? (Nodurile frunza (raspuns) necesita o reprezentare diferita de nodurile neterminale (de decizie)):
It is very big? NO YES
Does it squeak?
Does it have a long neck? YES
NO
Guess squirrel
YES
NO
Gues mouse
Does it have a t runk? NO
YES
Does it like to be in water? NO
Guess rhino
Guess giraffe
Guess elephant YES
Guess hippo
b) Scrieti o regula / un grup de reguli care pornind de la un nod current (neterminal), pe baza raspunsului dat de utilizator, determina urmatorul nod current. Scrieti o regula care in cazul unui nod current terminal furnizeaza raspunsul utilizatorului.
(deftemplate schema (slot Intrebare) (slot Raspuns) ) (assert (schema (Intrebare nil) (Raspuns nil))) (defrule Intrebare1 (schema (Intrebare nil) (Raspuns nil)) => (printout t "Is it very big ? (YES/NO)" crlf) (bind ?r (read))
(assert (schema (Intrebare "Is it very big ?") (Raspuns ?r))) ) (defrule Intrebare2 (schema (Intrebare "Is it very big?") (Raspuns NO)) => (printout t "Does it squeak ? (YES/NO)" crlf) (bind ?r (read)) (assert(schema (Intrebare "Does it squeak ?") (Raspuns ?r))) ) (defrule Intrebare3 (schema (Intrebare "Is it very big ?") (Raspuns YES)) => (printout t "Does it have a long neck ?" crlf) (bind ?r (read)) (assert (schema (Intrebare "Does it have a long neck?") (Raspuns ?r))) ) (defrule Veverita (schema (Intrebare "Does it squeak ?") (Raspuns NO)) => (printout t "Guess squirrel" crlf) ) (defrule Soarece (schema (Intrebare "Does it squeak ?") (Raspuns YES)) =>
(printout t "Guess mouse" crlf) ) (defrule Intrebare4 (schema (Intrebare "Does it have a long neck ?") (Raspuns NO)) => (printout t "Does it have a trunk ? (YES/NO)" crlf) (bind ?r (read)) (assert (schema (Intrebare "Does it have a trunk ?") (Raspuns ?r))) )
(defrule Girafa (schema (Intrebare "Does it have a long neck ?") (Raspuns YES)) => (printout t "Guess giraffe" crlf) ) (defrule Intrebare5 (schema (Intrebare "Does it have a trunk ?") (Raspuns NO)) => (printout t "Does it have to be in water ? (YES/NO)" crlf) (bind ?r (read)) (assert (schema (Intrebare "Does it have to be in water ?") (Raspuns ?r))) ) (defrule Elefant
(schema (Intrebare "Does it have a trunk ?") (Raspuns YES)) => (printout t "Guess elephant" crlf) ) (defrule Rinocer (schema (Intrebare "Does it have to be in water") (Raspuns NO)) => (printout t "Guess Rhino" crlf) ) (defrule Hipopotam (schema (Intrebare "Does it have to be in water") (Raspuns YES)) => (printout t "Guess Hippo" crlf) ) (run) (facts)
36) a) Scrieti o baza de reguli ce pornind de la faptele (multime A … ) si (multime B … ), cu elemente numere, determina reuniunea a celor doua multimi (reuniune AB … ). b) Scrieti un set de reguli ce determina suma elementelor mai mari ca 10 si mai mici ca 50 din cadrul multimii rezultate la a). Nu se folosesc if si while in partea dreapta a regulilor.
(deftemplate multimi (slot numeMultime) (slot element1) (slot element2) (slot element3) (slot element4) ) (assert (multimi (numeMultime A) (element1 1) (element2 2) (element3 3) (element4 5))) (assert (multimi (numeMultime B) (element1 6) (element2 7) (element3 8) (element4 9))) (deftemplate multimeNoua (slot numeMultime) (slot element1) (slot element2) (slot element3) (slot element4) (slot element5) (slot element6) (slot element7) (slot element8) ) (assert (multimeNoua (numeMultime AB) (element1 0) (element2 0) (element3 0) (element4 0) (element5 0) (element6 0) (element7 0) (element8 0))) (deftemplate sumaElemente (slot suma) ) (assert (sumaElemente (suma 0)))
(defrule suma1 ?valM <- (multimi (numeMultime A) (element1 ?e1) (element2 ?e2) (element3 ?e3) (element4 ?e4))
?valS <- (multimeNoua (element1 ?el1) (element2 ?el2) (element3 ?el3) (element4 ?el4)) => (modify ?valS (element1 (+ ?e1 ?el1)) (element2 (+ ?e2 ?el2)) (element3 (+ ?e3 ?el3)) (element4 (+ ?e4 ?el4))) (retract ?valM) ) (defrule suma2 ?valM <- (multimi (numeMultime B) (element1 ?e1) (element2 ?e2) (element3 ?e3) (element4 ?e4)) ?valS <- (multimeNoua (element5 ?el5) (element6 ?el6) (element7 ?el7) (element8 ?el8)) => (modify ?valS (element5 (+ ?e1 ?el5)) (element6 (+ ?e2 ?el6)) (element7 (+ ?e3 ?el7)) (element8 (+ ?e4 ?el8))) (retract ?valM) ) (defrule afisareSuma (multimeNoua (numeMultime ?x) (element1 ?e1) (element2 ?e2) (element3 ?e3) (element4 ?e4) (element5 ?e5) (element6 ?e6) (element7 ?e7) (element8 ?e8)) => (printout t "Multimea rezultanta este: " ?x " ,avand elementele:" ?e1 "," ?e2 "," ?e3 "," ?e4 "," ?e5 "," ?e6 "," ?e7 "," ?e8 crlf) ) (run) (defrule SumaElementeAB
