Laboratorul 2

Arbore genealogic
(deffacts fapte
(parinti Maria_Alba Geanina_Alba Marian_Alba)
(parinti Claudia_Alba Marian_Alba Geanina_Alba)
(frati Alexandra_Popovici Ion_Popovici)
(soti Geanina_Alba Marian_Alba)
(soti Tina_Munteanu Vasile_Munteanu)
(frati Geanina_Alba Sonia_Turcescu)
(frati Geanina_Alba Marta_Leon)
(parinti Tina_Vlas Tina_Munteanu Vasile_Munteanu)
(parinti Monica_Munteanu Vasile_Munteanu Tina_Munteanu)
(frati Marian_Alba Zoe_Ungureanu)
(parinti Marian_Alba Tina_Munteanu Vasile_Munteanu)
(parinti Geanina_Alba Maia_Topala Gheoghe_Topala)
(parinti Tudor_Apostol Maia_Topala Gheoghe_Topala)
(parinti Roza_Apostol Mariana_Apostol Tudor_Apostol)
(frati Ion_Popovici Dana_Rogoz)
(parinti Alexandra_Popovici Camelia_Apostol Robert_Apostop)
(frati Camelia_Apostol Gigi_Burlacu)
(parinti Iuliana_Burlacu Nicoleta_Burlacu Gigi Burlacu)
(frati Sonia_Turcescu Tudor_Chirila)
(parinti Amanda_Low Silvia_Chirila Tudor_Chirila)
(parinti Gabriela_Leon Marta_Leon Titu_Leon)
(parinti Lidia_Turcescu Sonia_Turcescu Vasile_Turcescu)
)

(defrule meniu_principal
(not (optiune_principal ?))
=>
(printout t “1. Adauga” crlf)
(printout t “2. Cauta” crlf)
(printout t “3. Afisare” crlf)
(printout t “4. Iesire” crlf)
(printout t “Dati optiunea:” crlf)
(assert (optiune_principal (read)))
)

(defrule validare_principal
?a
(printout t “Nu ati introdus corect optiunea!” crlf)
(retract ?a)
(printout t “Introduceti din nou optiunea:” crlf)
(assert (optiune_principal (read)))
)

(defrule meniu_adauga
(optiune_principal 1)
(not (optiune_adauga ?))
=>
(printout t “1. Adauga parinti” crlf)
(printout t “2. Adauga frati/surori” crlf)
(printout t “3. Adauga sot/sotie” crlf)
(printout t “4. Iesire” crlf)
(printout t “Dati optiunea:” crlf)
(assert (optiune_adauga (read)))
)

(defrule validare_adauga
?a
(printout t “Nu ati introdus corect optiunea!” crlf)
(retract ?a)
(printout t “Introduceti din nou optiunea:” crlf)
(assert (optiune_adauga (read)))
)

(defrule adauga_parinti
?a
(printout t “Dati copilul si parintii: ” crlf)
(assert (parinti (read) (read) (read)))
(retract ?a)
)

(defrule adauga_frati
?a
(printout t “Dati frati:” crlf)
(assert (frati (read) (read)))
(retract ?a)
)

(defrule adauga_soti
?a
(printout t “Dati sot/sotie:” crlf)
(assert (soti (read) (read)))
(retract ?a)
)

(defrule adauga_iesire
?a<-(optiune_adauga 4)
?b
(retract ?a)
(retract ?b)
)

(defrule meniu_cauta
(optiune_principal 2)
(not (optiune_cauta ?))
=>
(printout t “1. Cauta frati” crlf)
(printout t “2. Cauta bunici” crlf)
(printout t “3. Cauta veri” crlf)
(printout t “4. Cauta cumnati” crlf)
(printout t “5. Cauta unchi/matusa” crlf)
(printout t “6. Cauta nepoti” crlf)
(printout t “7. Iesire” crlf)
(printout t “Dati optiunea:” crlf)
(assert (optiune_cauta (read)))
)

(defrule validare_cauta
?a
(printout t “Nu ati introdus corect optiunea!” crlf)
(retract ?a)
(printout t “Introduceti din nou optiunea:” crlf)
(assert (optiune_cauta (read)))
)

(defrule cauta_frati “facut la laborator”
(optiune_cauta 1)
(not (lista_frati $?))
=>
(printout t “Fratii pentru?” crlf)
(assert (lista_frati (read)))
)

(defrule completeaza_frati
(declare (salience 10))
?a
(retract ?a)
(assert (lista_frati $?x1 $?x2 ?x ?y))
)

(defrule completeaza_frati2
(declare (salience 12))
(or (and ?w<-(parinti ?x ?a ?b)
?q<-(parinti ?y ?a ?b)
)
(and ?w<-(parinti ?x ?a ?b)
?q
(assert (frati ?x ?y))
)

(defrule sterge_frati2
?a<-(frati ?x ?y)
?b
(retract ?a)
)

(defrule afiseaza_fratii
?a<-(optiune_cauta 1)
?b
(printout t “Frati: ” $?x crlf)
(retract ?a)
(retract ?b)
)

(defrule completeaza_parinti2
(declare (salience 12))
(or (frati ?x ?y)
(frati ?y ?x)
)
(parinti ?x ?a ?b)
(not (parinti ?y ? ?))

=>
(assert (parinti ?y ?a ?b))
)

(defrule cauta_bunici
(optiune_cauta 2)
(not (lista_bunici $?))
=>
(printout t “Bunicii pentru?” crlf)
(assert (nepot (read)))
(assert (lista_bunici))
)

(defrule completeaza_bunici
(declare (salience 10))
?a<-(nepot ?x)
?b
(retract ?b)
(assert (lista_bunici $?h ?z))
)

(defrule afisare_bunici
?a<-(optiune_cauta 2)
?b<-(lista_bunici $?h )
?c
(printout t “Bunicii: ” $?h crlf)
(retract ?a)
(retract ?b)
(retract ?c)
)

(defrule cauta_veri
(optiune_cauta 3)
(not (lista_veri $?))
=>
(printout t “Verii pentru?” crlf)
(assert (nume (read)))
(assert (lista_veri))
)
(defrule completeaza_veri1
(declare (salience 9))
?a<-(nume ?x)
?b
(retract ?b)
(assert (lista_veri $?h ?z))
)

(defrule completeaza_veri2
(declare (salience 8))
?a
(retract ?a)
(assert (lista_veri $?x1 $?x2 ?x ?z))
)
(defrule afisare_veri
?a<-(optiune_cauta 3)
?b<-(lista_veri $?h )
?c
(printout t “Veri: ” $?h crlf)
(retract ?a)
(retract ?b)
(retract ?c)
)

(defrule cauta_cumnati
(optiune_cauta 4)
(not (lista_cumnati $?))
=>
(printout t “Cumnati/cumnate pentru?” crlf)
(assert (nume (read)))
(assert (lista_cumnati))
)
(defrule completeaza_cumnati1
(declare (salience 9))
?a<-(nume ?x)
?b
(retract ?b)
(assert (lista_cumnati $?h ?z))
)

(defrule completeaza_cumnati2
(declare (salience 8))
?a
(retract ?a)
(assert (lista_cumnati $?x1 $?x2 ?x ?z))
)
(defrule afisare_cumnati
?a<-(optiune_cauta 4)
?b<-(lista_cumnati $?h )
?c
(printout t “Cumnati/Cumnate: ” $?h crlf)
(retract ?a)
(retract ?b)
(retract ?c)
)

(defrule cauta_unchi
(optiune_cauta 5)
(not (lista_unchi $?))
=>
(printout t “Unchi/matuse pentru?” crlf)
(assert (nume (read)))
(assert (lista_unchi))
)
(defrule completeaza_unchi1
(declare (salience 9))
?a<-(nume ?x)
?b
(retract ?b)
(assert (lista_unchi $?h ?z))
)

(defrule completeaza_unchi2
(declare (salience 8))
?a
(retract ?a)
(assert (lista_unchi $?x1 $?x2 ?x ?z))
)
(defrule afisare_unchi
?a<-(optiune_cauta 5)
?b<-(lista_unchi $?h )
?c
(printout t “Unchi/matuse: ” $?h crlf)
(retract ?a)
(retract ?b)
(retract ?c)
)

(defrule cauta_nepoti
(optiune_cauta 6)
(not (lista_nepoti $?))
=>
(printout t “Nepotii pentru?” crlf)
(assert (bunic (read)))
(assert (lista_nepoti))
)

(defrule completeaza_nepoti
(declare (salience 10))
?a<-(bunic ?x)
?b
(retract ?b)
(assert (lista_nepoti $?h ?z))
)

(defrule afisare_nepoti
?a<-(optiune_cauta 6)
?b<-(lista_nepoti $?h )
?c
(printout t “Nepoti: ” $?h crlf)
(retract ?a)
(retract ?b)
(retract ?c)
)

(defrule cauta_iesire
?a<-(optiune_cauta 7)
?b
(retract ?a)
(retract ?b)
)

(defrule meniu_afisare
(optiune_principal 3)
(not (optiune_afisare ?))
=>
(printout t “1. Afisare frati” crlf)
(printout t “2. Afisare soti” crlf)
(printout t “3. Afisare parinti” crlf)
(printout t “4. Afisare bunici/nepoti” crlf)
(printout t “5. Iesire” crlf)
(printout t “Dati optiunea:” crlf)
(assert (optiune_afisare (read)))
)

(defrule validare_afisare
?a
(printout t “Nu ati introdus corect optiunea!” crlf)
(retract ?a)
(printout t “Introduceti din nou optiunea:” crlf)
(assert (optiune_afisare (read)))
)

(defrule afiseaza_frati1
?a
(assert (afiseaza_frati))
(retract ?a)
)

(defrule afiseaza_frati2
(declare (salience 10))
?a
(printout t ?x ” este fratele/sora lui ” ?y crlf)
)

(defrule afiseaza_soti1
?a
(assert (afiseaza_soti))
(retract ?a)
)
(defrule afiseaza_soti2
(declare (salience 10))
?a
(printout t ?x ” este casatorit(a) cu ” ?y crlf)

)

(defrule afiseaza_parinti1
?a
(assert (afiseaza_parinti))
(retract ?a)
)
(defrule afiseaza_parinti2
(declare (salience 11))
?a
(printout t “Parintii lui ” ?x ” sunt ” ?y ” si ” ?z crlf)

)
(defrule afiseaza_bunici1
?a
(assert (afiseaza_bunici))
(retract ?a)
)

(defrule afiseaza_bunici2
(declare (salience 10))
?a
(printout t ?y ” si ” ?k ” sunt bunicii lui ” ?z crlf)
)

(defrule afisare_iesire

?a<-(optiune_afisare 5)
?b
(retract ?a)
(retract ?b)
)

Altele

Exemplu
(deffacts fapte
(curs ia pbr)
)
(defrule afisare
(curs $? ?x $?)
=>
(printout t “curs:” ?x crlf))

Exemplu
(deffacts fapte
(curs ia pbr)
)
(defrule afisare
(curs $?x)
=>
(printout t “curs:” $?x crlf))

Exemplu
(deffacts fapte
(curs ia)
(curs pbr)
)
(defrule afisare
(curs ?x)
=>
(printout t “curs:” ?x crlf))

Exemplu
(deffacts fapte
(curs ia pbr)
(prof ia cristea)
(prof pbr cristea2)
)
(defrule afisare
(curs $? ?x $?)
(prof ?x ?y)
=>
(printout t “cursul: ” ?x ” are ca profesor: ” ?y crlf))

Exemplu
(deffacts fapte
(curs ia pbr)
)
(defrule afisare
(curs $? ?x $?)
(not (prof ?x ?))
=>
(printout t “Dati prof pt: ” ?x crlf)
(assert (prof ?x (read)))
)

Laboratorul 1

Varianta 1
(deffacts a
(forma patrulater)
(unghi drept)
(laturi egale)
)
(defrule patrat
(forma patrulater)
(unghi drept)
(laturi egale)
=>
(assert (patrat))
)
(defrule dreptunghi
(forma patrulater)
(unghi drept)
(not (laturi egale))
=>
(assert (dreptunghi))
)
(defrule trapez
(forma patrulater)
(not (unghi drept))
(not (laturi egale))
=>
(assert (trapez))
)
(defrule altceva
(not (forma patrulater))
(not (unghi drept))
(not (laturi egale))
=>
(assert (altceva))
)
(defrule romb
(forma patrulater)
(not (unghi drept))
(laturi egale)
=>
(assert (romb))
)

Varianta 2
(deffacts a (patrulater da) (laturiegale nu) (unghidrept da))
(defrule test1D (patrulater da) => (assert (dotest2)))
(defrule test1N (patrulater nu) => (assert (altceva)))
(defrule test2D (dotest2)(unghidrept da) => (assert (dotest3)))
(defrule test2N (dotest2) (unghidrept nu) => (assert (dotest4)))
(defrule test3D (dotest3) (laturiegale da) => (assert (patrat)))
(defrule test3N (dotest3) (laturiegale nu) => (assert (dreptunghi)))
(defrule test4D (dotest4) (laturiegale da) => (assert (romb)))
(defrule test4N (dotest4) (laturiegale nu) => (assert (trapez)))

Varianta 3
(deffacts s (forma patrulater) (unghiuri drepte))
(defrule a (forma patrulater) => (assert (unghi)))
(defrule b (not (forma patrulater)) => (assert (altceva)))
(defrule c (unghi) (or (unghiuri drepte) (not (unghiuri drepte))) => (assert (laturi)))
(defrule e (laturi) (laturi egale) (unghiuri drepte) => (assert (patrat)))
(defrule f (laturi) (laturi egale) (not(unghiuri drepte)) => (assert (trapez)))
(defrule d (laturi) (not (laturi egale)) (unghiuri drepte) => (assert (dreptunghi)))
(defrule g (laturi) (not(laturi egale)) (not(unghiuri drepte)) => (assert (patrat)))

Varianta 4
(deffacts f
(forma patrulater)
(unghiuri nedrepte)
(laturi inegale)
)

(defrule patrat
(forma patrulater)
(unghiuri drepte)
(laturi egale)
=>
(assert (patrat))
)

(defrule dreptunghi
(forma patrulater)
(unghiuri drepte)
(laturi inegale)
=>
(assert (dreptunghi))
)

(defrule romb
(forma patrulater)
(unghiuri nedrepte)
(laturi egale)
=>
(assert (romb))
)

(defrule trapez
(forma patrulater)
(unghiuri nedrepte)
(laturi inegale)
=>
(assert (trapez))
)

(defrule altceva
(forma nepatrulater)
(unghiuri nedrepte)
(laturi inegale)
=>
(assert (altceva))
)

Varianta 5
(deffacts fapte
(forma patrulater)
)

(defrule r1
?f
(assert (unghiuridrepte))
(retract ?f)
)

(defrule r2
(unghiuridrepte)
=>
(assert (laturiegale))
)

(defrule r3
?l
(assert (patrat))
(retract ?l)
)

(defrule r4
(not(laturiegale))
?u
(assert (dreptunghi))
(retract ?u)
)

(defrule r5
(not(unghiuridrepte))
=>
(assert (laturiegale2))
)

(defrule r6
?le
(assert (romb))
(retract ?le)
)

(defrule r7
(not(laturiegale2))
=>
(assert (trapez))
)

(defrule r8
(not(forma patrulater))
=>
(assert (altceva))
)

Varianta 6
(deffacts fapte
(forma patrulater)
(unghiuri drepte)
(laturi neegale)
)

(defrule r1
?f
(assert (unghiuridrepte))
(retract ?f)
)

(defrule r2
?u<-(unghiuridrepte)
?u2
(assert (laturiegale1))
(retract ?u)
(retract ?u2)
)
(defrule r3
?u
(assert (laturiegale2))
(retract ?u)
)

(defrule r4
?l<-(laturiegale1)
?l2
(assert (patrat))
(retract ?l)
(retract ?l2)
)

(defrule r5
?l
(assert (dreptunghi))
(retract ?l)
)

(defrule r6
?l
(assert (romb))
(retract ?l)
)

(defrule r7
?l
(assert (trapez))
(retract ?l)
)

(defrule r8
(not (or (patrat) (dreptunghi) (trapez) (romb)))
=>
(assert (altceva))
)

Varianta 7
(deffacts fapte
(patrulater da)
(unghiuri da)
(laturi nu)
)

(defrule r1
(patrulater da)
=>
(assert (unghi))
)

(defrule r2
(unghi)
=>
(assert (laturi))
)

(defrule r3
(laturi)
(unghiuri da)
(laturi da)
=>
(assert (patrat))
)

(defrule r4
(laturi)
(unghiuri da)
(laturi nu)
=>
(assert (dreptunghi))
)

(defrule r5
(laturi)
(unghiuri nu)
(laturi da)
=>
(assert (romb))
)

(defrule r6
(laturi)
(unghiuri nu)
(laturi nu)
=>
(assert (trapez))
)

(defrule reg7
(patrulater nu)
=>
(assert (altceva))
)

Varianta 8
(deffacts fapte (stareinitiala))
(defrule patrulater
(stareinitiala)
=>
(printout t “Este patrulater?”)
(assert (patrulater (read)))
)
(defrule unghiuridrepte
(patrulater da)
=>
(printout t “Are ungiuri drepte?”)
(assert (unghiuridrepte (read)))
)
(defrule laturiegale
(unghiuridrepte ?)
=>
(printout t “Are laturi egale?”)
(assert (laturiegale (read)))
)
(defrule patrat
(unghiuridrepte da)
(laturiegale da)
=>(printout t “Este patrat!”)
)
(defrule dreptughi
(unghiuridrepte da)
(laturiegale nu)
=>(printout t “Este dreptunghi!”)
)
(defrule romb
(unghiuridrepte nu)
(laturiegale da)
=>(printout t “Este romb!”)
)
(defrule trapez
(unghiuridrepte nu)
(laturiegale nu)
=>(printout t “Este trapez!”)
)
(defrule altceva
(patrulater nu)
=>(printout t “Este altceva!”)
)