Download - Soluciones CLIPS

Se plantea el problema clásico de rutas entre ciudades: Un agente desea desplazarse por carretera desde la ciudad en la que se encuentra actualmente a una ciudad destino. La acción básica que puede emprender es ir(x,y), que lo lleva de la ciudad X a la ciudad Y, siempre y cuando exista una ruta directa entre ambas. Este último hecho se expresa mediante hechos (rutaDirecta x y). Se supone que existen los siguientes hechos en la memoria de trabajo para representar estas rutas:(deffacts mapa_ciudades

(rutaDirecta Zeind Oradea 71) (rutaDirecta Oradea Sibiu 151)(rutaDirecta Zerind Arad 75) (rutaDirecta Arad Sibiu 140)(rutaDirecta Arad Timisoara 118) (rutaDirecta Timisoara Lugoj 111)(rutaDirecta Lugoj Mehadia 70) (rutaDirecta Mehadia Dobreta 75)(rutaDirecta Dobreta Caiova 120) (rutaDirecta Caiova Rimnicu 146)(rutaDirecta Caiova Pitesti 138) (rutaDirecta Rimnicu Sibiu 80)(rutaDirecta Rimnicu Pitesti 97) (rutaDirecta Pitesti Bucarest 101)(rutaDirecta Sibiu Fagaras 99) (rutaDirecta Fagaras Bucarest 211)(rutaDirecta Bucarest Giurgiu 90) (rutaDirecta Bucarest Urziceni 85)(rutaDirecta Urziceni Hirsova 98) (rutaDirecta Hirsova Eforie 86)(rutaDirecta Urziceni Vaslui 142) (rutaDirecta Vaslui Iasi 92)(rutaDirecta Iasi Neamt 87)

)Se pide que responda a las siguientes cuestiones:a) Elaborar una Base de Conocimiento de reglas para este problema que sea capaz de responder a la consulta (ir X Y) al menos con una ruta factible entre las ciudades X e Y. La ruta contendrá todas las rutas directas exploradas para llegar de X a Y. No se solicita calcular la ruta óptima, sólo una ruta factible en la que ningunaciudad en la ruta esté repetidai) Debe tenerse en cuenta que, aunque en la base de hechos inicial únicamente se describen las rutas directas en una dirección, estas rutas son simétricas, ej. (rutaDirecta Oradea Sibiu 151) -> (rutaDirecta Sibiu Oradea 151). ii) Dentro de la solución al problema deberá incluirse, al menos, todas las ciudades recorridas (en su orden correcto desde el origen al destino). La solución no tiene que repetir una ciudad (utilizar la función booleana que comprueba si un elemento es miembro de una lista (member$ ?elemento $?lista-elementos)). Se pide también justificar brevemente el diseño del hecho o de los hechos de la solución al problema.iii) Una vez encontrada la solución, se pide que esta se imprima en la salida estándar, utilizando (printout t <cadena> crlf)b) Supóngase ahora que el vehículo utilizado tiene un depósito de combustible y consume 5 litros cada 100 kilómetros. Se pide ampliar la representación de manera que estos nuevos factores queden reflejados y lasconsultas anteriores sigan funcionando y produciendo planes factibles.i) En el inicio de cada ruta, se supone que el depósito está lleno de combustible.ii) La capacidad del depósito de combustible estará definida por un hecho que deberá ser especificado en la base de hechos.iii) Un plan se considera factible si el vehículo tiene combustible suficiente para llegar al destino.iv) Únicamente se pide especificar las reglas y hechos que cambian respecto al apartado anterior.

Solución:

(defglobal ?*preferencia-maxima* = 10000);-------------------------------------------;- Inserta todas las rutas directas con el;- origen y destino invertidos ;-------------------------------------------(defrule simetrica

(declare (salience ?*preferencia-maxima*))(rutaDirecta ?orig ?dest $?resto)=>(assert (rutaDirecta ?dest ?orig $?resto))

);-------------------------------------------;- Detecta la consulta "ir a" y comienza a;- construir la ruta;-------------------------------------------(defrule ir_desde_origen

(ir ?origen ?destino)(rutaDirecta ?origen ?dest ?)=>(assert (ruta ?origen ?dest))

);-------------------------------------------;- Expande todas las rutas con los destinos;- directos accesibles;-------------------------------------------(defrule expande_ruta_sin_duplicar

(ruta $?previo ?final)(rutaDirecta ?final ?dest ?)(test (not (member$ ?dest $?previo)))=>(assert (ruta $?previo ?final ?dest))

);-------------------------------------------;- Cuando existe un ruta en el que la;- última ciudad sea el destino de la;- consulta, se crea un nuevo hecho solución;- para marcar esta ruta como solución;-------------------------------------------(defrule solucion

?nruta <- (ruta $?lista ?destino)(ir ?origen ?destino)=>(retract ?nruta)(assert (solucion $?lista ?destino))

);-------------------------------------------;- Imprime la ruta con la solución;-------------------------------------------(defrule imprime_solucion

(solucion $?lista)=>(printout t "-> Solucion: " $?lista crlf)

)

b)Sólo se muestran las reglas que cambian:;-------------------------------------------;- Hechos iniciales para el depósito de;- combustible;-------------------------------------------(deffacts combustible

(capacidad_deposito 35)(consumo 0.05)

);-------------------------------------------;- Detecta la consulta "ir" y cominenza a;- construir la ruta;- Descuenta el consumo del trayecto al;- depósito, que es el último valor en la;- ruta.;-------------------------------------------(defrule ir_desde_origen

(ir ?origen ?destino)(rutaDirecta ?origen ?dest ?dist)(capacidad_deposito ?cap)(consumo ?cons)(test (>= ?cap (* ?dist ?cons)))=>(assert (ruta ?origen ?dest (- ?cap (* ?dist ?cons))))

);-------------------------------------------;- Expande todas las rutas con los destinos;- directos accesibles. Recalcula;- el consumo de combustible;-------------------------------------------

(defrule expande_ruta_sin_duplicar(ruta $?previo ?final ?deposito)(rutaDirecta ?final ?dest ?dist)(consumo ?cons)(test (not (member$ ?dest $?previo)))(test (>= ?deposito (* ?dist ?cons)))=>(assert (ruta $?previo ?final ?dest (- ?deposito (* ?dist ?cons))))

);-------------------------------------------;- Cuando existe un ruta en el que la;- última ciudad sea el destino de la;- consulta, se crea un nuevo hecho solución;- para marcar esta ruta como solución;-------------------------------------------(defrule solucion

?nruta <- (ruta $?lista ?destino ?deposito)(ir ?origen ?destino)=>(retract ?nruta)(assert (solucion $?lista ?destino ?deposito))

);-------------------------------------------;- Imprime la ruta con la solución;-------------------------------------------(defrule imprime_solucion

(solucion $?lista ?deposito)=>(printout t "-> Solucion: " $?lista crlf)(printout t "-> Deposito: " ?deposito crlf)

)

- A continuación presentamos un ejemplo de tarea propia de la audiología clínica. El perfil de un paciente se caracteriza por un conjunto de hallazgos V1…V8 que se obtiene a partir de observaciones de los pacientes (desde la “observación” de la edad de paciente de 65 años se obtiene el hallazgo V1:“edad>60”): hallzs. DescripciónV1 edad>60V2 air = mild V3 history = noise V4 speech = poorV5 tympan = aV6 acoustic_ref_c = elevated V7 acoustic_ref_u = elevatedV8 o_acoustic_ref_c = elevatedLos diferentes diagnósticos posibles son los expresados en la siguiente tabla:Diags. DescripciónSA1 age-induced cochlear with otitis media

SA2 age and noise-induced cochlear

SA3 noise-induced cochlear

SA4 age-induced cochlear

SA5 normal ear ( norm)

SA6 acoustic neuroma

SA7 cochlear

SA8 mixed

SA9 otitis media

SA10 possible menieres

SA11 bells palsy

Los hallazgos sugieren diferentes posibles diagnósticos (V sugiere SA), como se observa en la siguiente tabla:hallzs Diags.V1 SA1, SA2, SA4, SA9V2 SA6, SA7, SA9V3 SA2, SA3V4 SA7, SA8V5 SA5, SA7V6 SA8, SA10V7 SA4, SA9V8 SA7, SA8, SA11

Aquí se reduce pues el conjunto de diagnósticos posibles, pero solamente con esta tabla no se designa un único diagnóstico como solución. Para conseguir un diagnóstico más preciso, en primer lugar, se suman todas las ocurrencias de cada SA en la tabla de equiparaciones (por ejemplo cochlear SA7 tiene 4 ocurrencias). A continuación, cada SA como subcategoría hereda además los puntos de las categorías genéricas a que pertenece, (por ejemplo, “age-induced cochlear” hereda de “cochlear”, “age-induced cochlear with otitis media” hereda de “otitis media”). Por ejemplo, si se da V1 entonces se sugiere SA1, SA2, SA4 y SA9. Como SA4 y SA9 refuerzan SA1, ésta queda con 3 puntos. Mientras que SA2 queda con 2 puntos. Así, la solución puntuada en primer lugar sería “age-induced cochlear with otitis media”. Esta fase del diagnóstico, por tanto, concluiría con las hipótesis más valoradas (o la más valorada) como solución.Se pide una implementación en Clips para este diagnóstico.Solución:; Se puede hacer de una forma mas ortodoxa, sin variable global y sin modificación de los hechos tabla-refuerzos-diagnosticos, por ejemplo, pero esta solución es bastante sencilla.(defglobal ?*contador-diagnosticos* = 0)

(deftemplate datos-paciente(slot id-paciente (type INTEGER))(slot edad (type INTEGER))

)

(deftemplate datos-pruebas-paciente(slot id-paciente (type INTEGER))(slot variable (type SYMBOL))(slot valor (type STRING))

)

(deftemplate hallazgo(slot id-hallazgo (type SYMBOL))(slot variable (type SYMBOL))(slot operador (type STRING))(slot valor (type STRING))

)

(deftemplate diagnostico(slot id-diagnostico (type SYMBOL))(slot descripcion (type STRING))

)

(deftemplate refuerza(slot diagnostico-G (type SYMBOL))

(slot diagnostico-E (type SYMBOL))(slot hecho (type SYMBOL) (allowed-values NO SI) (default NO))

)

(deftemplate hallazgo-paciente(slot id-paciente (type INTEGER))(slot hallazgo (type SYMBOL))

)

(deftemplate hallazgo-diagnostico(slot id-hallazgo (type SYMBOL))(slot diagnostico (type SYMBOL))

)

(deftemplate diagnostico-paciente(slot id-paciente (type INTEGER))(slot diagnostico (type SYMBOL))(slot contador (type INTEGER) (default 1))

)

(deftemplate lista-aux-diagnosticos(multislot diagnosticos (type SYMBOL))

)

; afirmamos los hallazgos como hechos

(deffacts tabla-hallazgos

(hallazgo (id-hallazgo V1) (variable edad) (operador ">") (valor "65"))(hallazgo (id-hallazgo V2) (variable air) (operador "=") (valor "mild"))(hallazgo (id-hallazgo V3) (variable history) (operador "=") (valor "noise"))(hallazgo (id-hallazgo V4) (variable speech) (operador "=") (valor "poor"))(hallazgo (id-hallazgo V5) (variable tympan) (operador "=") (valor "a"))(hallazgo (id-hallazgo V6) (variable acoustic_ref_c) (operador "=") (valor "elevated"))(hallazgo (id-hallazgo V7) (variable acoustic_ref_u) (operador "=") (valor "elevated"))(hallazgo (id-hallazgo V8) (variable o_acoustic_ref_c) (operador "=") (valor "elevated"))

)

(deffacts tabla-diagnosticos

(diagnostico (id-diagnostico SA1) (descripcion "age-induced cochlear with otitis media"))(diagnostico (id-diagnostico SA2) (descripcion "age and noise-induced cochlear"))(diagnostico (id-diagnostico SA3) (descripcion "noise-induced cochlear"))(diagnostico (id-diagnostico SA4) (descripcion "age-induced cochlear"))(diagnostico (id-diagnostico SA5) (descripcion "normal ear"))(diagnostico (id-diagnostico SA6) (descripcion "acoustic neuroma"))(diagnostico (id-diagnostico SA7) (descripcion "cochlear"))(diagnostico (id-diagnostico SA8) (descripcion "mixed"))(diagnostico (id-diagnostico SA9) (descripcion "otitis media") )(diagnostico (id-diagnostico SA10) (descripcion "possible menieres") )(diagnostico (id-diagnostico SA11) (descripcion "bells palsy"))

)

(deffacts tabla-hallazgos-diagnosticos

(hallazgo-diagnostico (id-hallazgo V1) (diagnostico SA1))(hallazgo-diagnostico (id-hallazgo V1) (diagnostico SA2))(hallazgo-diagnostico (id-hallazgo V1) (diagnostico SA4))(hallazgo-diagnostico (id-hallazgo V1) (diagnostico SA9))(hallazgo-diagnostico (id-hallazgo V2) (diagnostico SA6))

(hallazgo-diagnostico (id-hallazgo V2) (diagnostico SA7))(hallazgo-diagnostico (id-hallazgo V2) (diagnostico SA9))(hallazgo-diagnostico (id-hallazgo V3) (diagnostico SA2))(hallazgo-diagnostico (id-hallazgo V3) (diagnostico SA3))(hallazgo-diagnostico (id-hallazgo V4) (diagnostico SA7)) (hallazgo-diagnostico (id-hallazgo V4) (diagnostico SA8))(hallazgo-diagnostico (id-hallazgo V5) (diagnostico SA5))

(hallazgo-diagnostico (id-hallazgo V5) (diagnostico SA7))(hallazgo-diagnostico (id-hallazgo V6) (diagnostico SA8)) (hallazgo-diagnostico (id-hallazgo V6) (diagnostico SA10))(hallazgo-diagnostico (id-hallazgo V7) (diagnostico SA4))(hallazgo-diagnostico (id-hallazgo V7) (diagnostico SA9))(hallazgo-diagnostico (id-hallazgo V8) (diagnostico SA7))

(hallazgo-diagnostico (id-hallazgo V8) (diagnostico SA8))(hallazgo-diagnostico (id-hallazgo V8) (diagnostico SA11))

)

(deffacts tabla-refuerzos-diagnosticos

(refuerza (diagnostico-G SA3) (diagnostico-E SA2))(refuerza (diagnostico-G SA4) (diagnostico-E SA1))(refuerza (diagnostico-G SA4) (diagnostico-E SA2))(refuerza (diagnostico-G SA7) (diagnostico-E SA3))(refuerza (diagnostico-G SA7) (diagnostico-E SA4))(refuerza (diagnostico-G SA9) (diagnostico-E SA1))

)

; los resultados de la exploración podrían introducirse por teclado, preguntando al usuario por ejemplo, o desde una ; base de datos. Asumimos que los tenemos disponibles como hechos según la definición de los anteriores templates

(deffacts datos-del-paciente(datos-paciente (id-paciente 23) (edad 66))

; por simplificación, los datos del paciente entran en este hecho. ; Logicamente, al menos, habría que añadir una regla para introducirlos por teclado.

(datos-pruebas-paciente (id-paciente 23) (variable air) (valor "other"))(datos-pruebas-paciente (id-paciente 23) (variable history) (valor "other"))(datos-pruebas-paciente (id-paciente 23) (variable peech) (valor "other"))(datos-pruebas-paciente (id-paciente 23) (variable tympan) (valor "other"))(datos-pruebas-paciente (id-paciente 23) (variable acoustic_ref_c) (valor "other"))

(datos-pruebas-paciente (id-paciente 23) (variable acoustic_ref_u) (valor "other"))

(datos-pruebas-paciente (id-paciente 23) (variable o_acoustic_ref_c) (valor "other"))

(contador-diagnosticos 0))

(deffacts datos-inferidos(lista-aux-diagnosticos (diagnosticos))

)

; reglas para abstraer los hallazgos desde los datos introducidos sobre los pacientes

(defrule abstraer-hallazgos-V1(declare (salience 1000))(datos-paciente (id-paciente ?paciente) (edad ?edad&:(> ?edad 65)))=>(assert (hallazgo-paciente (id-paciente ?paciente) (hallazgo V1)))

)

(defrule abstraer-hallazgos-resto(declare (salience 1000))(datos-paciente (id-paciente ?id-paciente))(hallazgo (id-hallazgo ?hallazgo) (variable ?variable) (valor ?valor))?datos-pruebas-paciente <- (datos-pruebas-paciente (id-paciente ?paciente) (variable ?variable) (valor ?valor))=>(assert (hallazgo-paciente (id-paciente ?id-paciente) (hallazgo ?hallazgo)))

)

;reglas para emparejar los hallazgos con las soluciones(defrule emparejar-hallazgos-soluciones

(declare (salience 900))(datos-paciente (id-paciente ?id-paciente))(hallazgo-paciente (id-paciente ?id-paciente) (hallazgo ?id-hallazgo))(hallazgo-diagnostico (id-hallazgo ?id-hallazgo) (diagnostico ?diagnostico))=>(assert (diagnostico-paciente (id-paciente ?id-paciente) (diagnostico ?diagnostico)))(bind ?*contador-diagnosticos* (+ ?*contador-diagnosticos* 1))

); regla para contabilizar los refuerzos de unos diagnosticos sobre otros(defrule refuerzos-soluciones

(declare (salience 700))(datos-paciente (id-paciente ?id-paciente))(diagnostico-paciente (id-paciente ?id-paciente) (diagnostico ?diagnostico))?refuerza <- (refuerza (diagnostico-G ?diagnostico) (diagnostico-E ?diagnostico-E) (hecho NO))?reforzado <- (diagnostico-paciente (id-paciente ?id-paciente) (diagnostico ?diagnostico-E) (contador ?contador))=>(modify ?reforzado (contador (+ ?contador 1)))(bind ?*contador-diagnosticos* (+ ?*contador-diagnosticos* 1))(modify ?refuerza (hecho SI))

)

; regla imprimir los resultados como tabla de probabilidades de los diagnosticos, para esto se utiliza la variable global(defrule imprime-soluciones

(declare (salience 400))(datos-paciente (id-paciente ?id-paciente))(diagnostico-paciente (id-paciente ?id-paciente) (diagnostico ?diagnostico) (contador ?contador))=>(printout t crlf "El paciente " ?id-paciente " sufre " ?diagnostico " con probabilidad: " (* 100 (/ ?contador ?*contador-

diagnosticos*)) " %" crlf))

- Se plantea un sistema experto para la ayuda a la composición de programas musicales en emisoras de radio. El programa de radio tiene una duración determinada que se pretende cubrir con canciones cuya duración se acerque lo más posible a la duración prevista para el programa. Las canciones además de una duración tienen un identificador y una intensidad (de 1 a 5).Se pide llevar a cabo las siguientes acciones:a) Definir los templates y reglas necesarias para dado un programa musical de una duración determinada completarlo con las canciones disponibles sin repetir ninguna (utilizar la función booleana que comprueba si un elemento es miembro de una lista (member$ ?elemento $?lista-elementos)) y sin que entre una y la siguiente haya un salto de intensidad superior a 1. Escribir una regla “primera-cancion” que seleccione inicie el programa y otra regla “programar” que vaya añadiendo canciones hasta llegar al límite de tiempo.b) Diseñe una regla equivalente a ”primera_canción” tal que seleccione como primera canción del programa la canción con más intensidad de las disponibles en la base de hechos de canciones.c) Diseñe una regla ”ultima_canción” tal que sitúe como última canción en la programación la canción que más se acerque a la duración restante del programa y que no esté incluida con anterioridad en la programación. Esta regla deberá ejecutarse tras la regla ”programar”.

Solución:

; respuesta a)

(deftemplate cancion(slot id (type INTEGER))(slot intensidad (type INTEGER) (range 1 5))(slot duracion (type INTEGER))

)(deftemplate programa

(slot nombre (type STRING))(slot duracion (type INTEGER))(multislot canciones (type INTEGER))(slot duracion_completa (type INTEGER) (default 0))

)(deffacts programa-y-canciones

(programa (nombre "matinal") (duracion 60))(cancion (id 1) (intensidad 3) (duracion 7))(cancion (id 2) (intensidad 1) (duracion 3))(cancion (id 3) (intensidad 2) (duracion 2))(cancion (id 4) (intensidad 5) (duracion 6))(cancion (id 5) (intensidad 2) (duracion 5))(cancion (id 6) (intensidad 1) (duracion 4))(cancion (id 7) (intensidad 3) (duracion 4))(cancion (id 8) (intensidad 4) (duracion 2))(cancion (id 9) (intensidad 2) (duracion 8))(cancion (id 10) (intensidad 3) (duracion 4))(cancion (id 11) (intensidad 1) (duracion 3))(cancion (id 12) (intensidad 1) (duracion 3))(cancion (id 13) (intensidad 5) (duracion 4))(cancion (id 14) (intensidad 4) (duracion 5))(cancion (id 15) (intensidad 4) (duracion 6))(cancion (id 16) (intensidad 3) (duracion 2))(cancion (id 17) (intensidad 1) (duracion 3))(cancion (id 18) (intensidad 1) (duracion 4))(cancion (id 19) (intensidad 5) (duracion 5))(cancion (id 20) (intensidad 2) (duracion 3))(cancion (id 21) (intensidad 2) (duracion 4))(cancion (id 22) (intensidad 3) (duracion 5))(cancion (id 23) (intensidad 4) (duracion 6))(cancion (id 24) (intensidad 3) (duracion 7))(cancion (id 25) (intensidad 5) (duracion 2))(cancion (id 26) (intensidad 1) (duracion 4))(cancion (id 27) (intensidad 1) (duracion 5))

)

;(defrule primera_cancion

; ?p <- (programa (duracion ?dur_prog) (duracion_completa 0)); (cancion (id ?id_cancion) (duracion ?dur_cancion)); =>; (modify ?p (canciones ?id_cancion) (duracion_completa ?dur_cancion));)

(defrule programar?p <- (programa (duracion ?dur_prog) (canciones $?canciones ?ultima_cancion) (duracion_completa ?dur_compl))(cancion (id ?id_cancion) (intensidad ?int_cancion) (duracion ?dur_cancion))(cancion (id ?ultima_cancion) (intensidad ?int_ultima_cancion))(test (neq ?id_cancion ?ultima_cancion))(test (not (member$ ?id_cancion $?canciones)))(test (<= (+ ?dur_compl ?dur_cancion) ?dur_prog))(test (<= (abs (- ?int_cancion ?int_ultima_cancion)) 1 ))=>(modify ?p (canciones $?canciones ?ultima_cancion ?id_cancion) (duracion_completa (+ ?dur_compl ?dur_cancion)))

)

; respuesta b)

(defrule primera_cancion_max_intensidad?p <- (programa (duracion ?dur_prog) (duracion_completa 0))(cancion (id ?id_cancion) (intensidad ?int_cancion) (duracion ?dur_cancion))(not (cancion (intensidad ?int&:(> ?int ?int_cancion))))=>(modify ?p (canciones ?id_cancion) (duracion_completa ?dur_cancion))

)

; respuesta c)

(defrule ultima_cancion?p <- (programa (duracion ?dur_prog) (canciones $?canciones) (duracion_completa ?dur_compl&:(< ?dur_compl ?

dur_prog)))(cancion (id ?id_cancion) (duracion ?dur_cancion))(test (not (member$ ?id_cancion $?canciones)))(not (cancion (duracion ?dur&:(< ?dur (- ?dur_prog ?dur_compl)))))(not (cancion (id ?id&:(not (member$ ?id $?canciones))) (duracion ?dur&:(< ?dur ?dur_cancion))))=>(modify ?p (canciones $?canciones ?id_cancion) (duracion_completa (+ ?dur_compl ?dur_cancion)))

)

- Realizar un sistema en Clips que permita introducir los datos de entrada y llegar a una clasificación de peces de acuerdo al siguiente texto:“Si un pez tiene la boca pequeña y con dientes puntiagudos y vive en ríos de muchas partes del mundo, entonces estamos hablando de un ejemplar del orden de los ciprinodontiformes. Si tenemos un individuo de esta orden que vive en los ríos de América del Sur y que en el caso de ser macho posee Gonopodio, entonces el pez es de la familia de los Poccilidos y la hembra es 3 cm. más grande que el macho. Si es hembra también es, claro, de los Poccilidos y el macho será 3 cms. más pequeño.Si tenemos un individuo de la familia de los Poccilidos que tiene manchas a lo largo del cuerpo, estamos ante un pez de la raza Gambusia Affinis. Pero si tiene color gris y rayas verdes a lo largo del cuero entonces es de la raza Gambusia Punetata.Si es un pez de tamaño medio, tiene dientes puntiagudos, vive en ríos de todo el mundo y posee canales laberínticos para respirar fuera del agua, entonces pertenece al orden de los anabátidos. Si un pez de esta orden es de color azul, tiene rayas royas y vive en ríos de Asia, estamos ante un pez de la raza Luchadores de Sian. Pero si mide 25 cms. y no tiene rayas entonces es una perca trepadora.Si es un pez de boca pequeña, vive en ríos de todo el mundo y tiene la cola redondeada es que es un ejemplar de la orden de los Cíclidos. Si un pez de esta orden vive en ríos de África y es de color rojo con manchas negras, es un pez joya.”

- Un cajero automático guarda 10 billetes de 10 euros, cinco billetes de 20, dos billetes de 50 y un billete de 100. Se trata de implementar en CLIPS un programa que pregunte al usuario la cantidad de dinero que quiere sacar y que le devuelva por pantalla una combinación de billetes que suman la cantidad total pedida, de manera que el número total de billetes sea mínimo (o bien un mensaje diciendo que no es posible reunir la cantidad exacta).

El problema puede ser planteado como un problema de espacio de estados, de manera que los nodos sean definidos por una plantilla con campos para almacenar el número utilizado de cada tipo de billete, el número total de billetes (coste) y la suma total de euros. En el nodo inicial hay 0 billetes de cada tipo. Existe un operador por cada tipo de billete, de manera que al aplicarlo a un nodo incrementa el número de billetes de ese tipo en uno. En el nodo final (o solución) la suma total de euros es igual a la solicitada por el usuario. El problema debe ser resuelto mediante una búsqueda que minimice el número total de billetes. A continuación aparecen varios ejemplos de sesión. NOTA: en los ejemplos, el usuario teclea la cantidad que está a continuación de "Reintegro:". El resto es salida del programa.

CLIPS> (reset)CLIPS> (run)Reintegro: 230Billetes de 10 :1Billetes de 20 :1Billetes de 50 :2Billetes de 100 :1CLIPS> (reset)CLIPS> (run)Reintegro: 410NO ES POSIBLE.CLIPS> (reset)CLIPS> (run)Reintegro: 125Cantidad errónea, debe ser entero múltiplo de 10!!Reintegro: 270Billetes de 10 : 1Billetes de 20 : 3Billetes de 50 : 2Billetes de 100 : 1

- Definir las reglas Clips que lleven a cabo la petición al usuario de la cantidad que desea como reintegro. En el caso de que el usuario introduzca una cantidad que no sea un entero múltiplo de 10, entonces el programa debe dar un mensaje de error, repitiendo la pregunta. En el caso de que el dato sea un múltiplo de 10, se aplicarán los operadores.INDICACION: Usar un hecho de la forma (total ...) para almacenar la petición del usuario.- Definir una plantilla Clips para los nodos que incluya información sobre: numero de billetes de mil, de dos mil, de cinco mil, de diez mil, número total de billetes, suma total de euros y si el nodo está abierto o cerrado (es decir, ha sido, o está siendo, expandido). Incluir un "deffacts" para que inicialmente se cree el nodo inicial.- Definir una regla Clips por cada operador, otra regla que pasa el nodo de menor coste a cerrado y una última regla que se dispara solamente si ya no es posible encontrar solución. NOTA: controlar mediante restricciones que no se creen nodos que tengan un número superior al permitido de billetes de cada tipo.- Definir una única regla Clips que elimine los nodos cuya suma total de euros sea superior a la cantidad que pide el usuario.- Definir una regla Clips que detecte nodos que son solución. La regla debe mostrar en pantalla la solución encontrada.

Solución:

;;; Plantillas (deftemplate nodo (slot bill-100 (type INTEGER) (default 0))

(slot bill-50 (type INTEGER) (default 0)) (slot bill-20 (type INTEGER) (default 0)) (slot bill-10 (type INTEGER) (default 0)) (slot num-bill (type INTEGER) (default 0)) (slot importe-bill (type INTEGER) (default 0)) (slot estado (type SYMBOL) (allowed-values cerrado abierto) (default abierto)))(deftemplate cajero (slot bill-100 (type INTEGER) (default 1)) (slot bill-50 (type INTEGER) (default 2)) (slot bill-20 (type INTEGER) (default 5)) (slot bill-10 (type INTEGER) (default 10)))

(deffacts iniciales(cajero)(inicio)

)

;;; Regla de petición del importe del reintegro (se puede hacer con dos reglas en lugar de una)

(defrule Pedir-importe?estado <- (inicio)=>(retract ?estado)(printout t crlf "Teclee el importe del reintegro (multiplo de 10) (0 para salir): " crlf)(bind ?in (read))(if (= ?in 0) then (halt))(if (= (mod ?in 10) 0) then

(assert (reintegro ?in))(assert (nodo))else

(assert (inicio)))

)

;;; Reglas de los operadores

(defrule operador-100?nodo <- (nodo (bill-100 ?bill-100) (bill-50 ?bill-50) (bill-20 ?bill-20) (bill-10 ?bill-10) (num-bill ?num-bill) (importe-bill ?

importe-bill) (estado cerrado))(cajero (bill-100 ?caj-bill-100&:(> ?caj-bill-100 ?bill-100)))=>(assert (nodo (bill-100 (+ ?bill-100 1)) (bill-50 ?bill-50) (bill-20 ?bill-20) (bill-10 ?bill-10)(num-bill (+ ?num-bill 1)) (importe-bill

(+ ?importe-bill 100)))))

(defrule operador-50

?nodo <- (nodo (bill-100 ?bill-100) (bill-50 ?bill-50) (bill-20 ?bill-20) (bill-10 ?bill-10) (num-bill ?num-bill) (importe-bill ?importe-bill) (estado cerrado))

(cajero (bill-50 ?caj-bill-50&:(> ?caj-bill-50 ?bill-50)))=>(assert (nodo (bill-100 ?bill-100) (bill-50 (+ ?bill-50 1)) (bill-20 ?bill-20) (bill-10 ?bill-10) (num-bill (+ ?num-bill 1)) (importe-

bill (+ ?importe-bill 50)))))


importe-bill) (estado cerrado))(cajero (bill-20 ?caj-bill-20&:(> ?caj-bill-20 ?bill-20)))=>(assert (nodo (bill-100 ?bill-100) (bill-50 ?bill-50) (bill-20 (+ ?bill-20 1)) (bill-10 ?bill-10) (num-bill (+ ?num-bill 1)) (importe-

bill (+ ?importe-bill 20))))

)


importe-bill) (estado cerrado))(cajero (bill-10 ?caj-bill-10&:(> ?caj-bill-10 ?bill-10)))=>(assert (nodo (bill-100 ?bill-100) (bill-50 ?bill-50) (bill-20 ?bill-20) (bill-10 (+ ?bill-10 1)) (num-bill (+ ?num-bill 1)) (importe-

bill (+ ?importe-bill 10)))))

;;; Regla de selección del nodo de menor coste.

(defrule cierra-nodo-menor-costo(declare (salience -10))?nodo-1 <- (nodo (importe-bill ?importe-bill) (num-bill ?num-bill1) (estado abierto))(not (exists (nodo (num-bill ?num-bill2&:(< ?num-bill2 ?num-bill1)) (estado abierto))))=>(modify ?nodo-1 (estado cerrado))

)

;;; Regla que se dispara solamente si ya no es posible encontrar la solución

(defrule sin-solucion(declare (salience -100))(not (solucion-encontrada))=>(printout t crlf "Actualmente no hay suficientes billetes para ese reintegro " crlf)

)

;;; Regla que se dispara solamente si ya no es posible encontrar la solución

(defrule elimina-nodos-excesivo-importe(declare (salience 100))(reintegro ?reintegro)?nodo <- (nodo (importe-bill ?importe-bill&: (> ?importe-bill ?reintegro)))=>(retract ?nodo)

)

;;; Regla que identifica un nodo solución

(defrule identifica-solucion(declare (salience 100))(reintegro ?reintegro)(nodo (importe-bill ?importe-bill&: (= ?importe-bill ?reintegro)) (bill-100 ?bill-100) (bill-50 ?bill-50) (bill-20 ?bill-20) (bill-10 ?

bill-10))=>(printout t crlf "Se reintegra con los siguientes billetes: " crlf)(printout t crlf ?bill-100 " Billetes de 100" crlf)(printout t crlf ?bill-50 " Billetes de 50" crlf)(printout t crlf ?bill-20 " Billetes de 20" crlf)(printout t crlf ?bill-10 " Billetes de 10" crlf)(assert (solucion-encontrada))(halt)

)

Se trata de simular el comportamiento de una colonia de células cuya vida o muerte a lo largo de generaciones viene determinada por una serie de reglas. Las células están dispuestas en forma de grafo, es decir, existe una relación de "vecindad" entre ellas. En cada generación, cada célula puede estar viva o muerta (OJO, es posible que una célula este muerta en una generación y viva en la siguiente). La regla que marcan la vida o muerte de las células es la siguiente:

SI UNA CELULA EN LA GENERACION N TIENE AL MENOS DOS VECINAS VIVAS Y AL MENOS UNA MUERTA, ENTONCES VIVE EN LA GENERACION N+1. EN CASO CONTRARIO, MUERE.

Supongamos el siguiente ejemplo, una colonia de nueve células de nombres a1, a2, a3, b1, b2, b3, c1, c2 y c3. La relación de vecindad viene determinada por el siguiente grafo (por ejemplo, a1 y a3 son vecinas, pero a1 y a2 no lo son). Las células vivas son las marcadas con la x. Inicialmente (en la primera generación), las que están vivas son a1, a2, b1 y b2. x a1 x a2 \ / a3 / \ b3-----c3 / \ / \ x b1 x b2 c1 c2

Siguiendo la regla anteriormente expuesta, la situación de la colonia en la generación 2 es la siguiente: a1 a2 \ / x a3 / \ x b3----c3 / \ / \ b1 b2 c1 c2

Decimos que una colonia de células queda estancada en la generación N si la generación N+1 es igual (exactamente las mismas células vivas y muertas) a la generación N. En nuestro ejemplo, en la cuarta generación, la colonia queda estancada: todas las células están muertas.

Se trata de hacer un programa CLIPS que simule el comportamiento de una colonia de células cuya vida o muerte a lo largo de las generaciones se rige por la regla anterior y aplicarlo al ejemplo anterior para detectar en qué generación se estanca y cómo queda la colonia una vez estancada.

1.1- Definir una plantilla Clips que represente el estado de cada célula en una generación determinada, incluyendo información sobre el nombre de la célula, la generación en la que se encuentra y el estado en el que se encuentra (viva o muerta). Escribir los hechos iniciales (deffacts), que describan el estado de la colonia de células en la generación 1. Incluir además dos hechos sin plantilla para almacenar la generación actual y la anterior (inicialmente 1 y 0, respectivamente).

La siguiente definición inicial de hechos informa de la relación de vecindad en el grafo. (deffacts vecinas (vecina a1 a3)…)

1.2. Definir reglas Clips que obtengan la generación actual a partir de la generación anterior. Una regla para obtener las células que quedan vivas y otra, u otras, para obtener las células que quedan muertas. Debe borrarse la información sobre generaciones anteriores.

1.3. Describir las reglas Clips para que en cada generación se compruebe si se ha producido estancamiento y parar en tal caso devolviendo los mensajes pertinentes. Para esto último serían precisas tres reglas, la primera de ellas debe actuar antes que las otras: 1) que escriba un mensaje que indique que la colonia se ha estancado y en qué generación, 2) Otra regla para escribir las células que quedan vivas, 3) Otra para escribir las células que quedan muertas

Nótese que existe estancamiento si no hay células tal que en la generación anterior tengan distinto estado que en la actual.

(deftemplate celula "estructura de celula"(slot nombre)(slot estado)(slot generacion)

)

(deftemplate vecina(slot nombre1)(slot nombre2)

)(deftemplate generacion

(slot numero))(deftemplate estancamiento

(slot valor))

(deffacts colonia (celula (nombre a1) (estado viva) (generacion 0))(celula (nombre a2) (estado viva) (generacion 0))(celula (nombre a3) (estado muerta) (generacion 0))(celula (nombre b1) (estado viva) (generacion 0))(celula (nombre b2) (estado viva) (generacion 0))(celula (nombre b3) (estado muerta) (generacion 0))(celula (nombre c1) (estado muerta) (generacion 0))(celula (nombre c2) (estado muerta) (generacion 0))(celula (nombre c3) (estado muerta) (generacion 0))(vecina (nombre1 a1) (nombre2 a3))(vecina (nombre1 a2) (nombre2 a3))(vecina (nombre1 a3) (nombre2 b3))(vecina (nombre1 a3) (nombre2 c3))(vecina (nombre1 b3) (nombre2 b1))(vecina (nombre1 b3) (nombre2 b2))(vecina (nombre1 b3) (nombre2 c3))(vecina (nombre1 c3) (nombre2 c1))(vecina (nombre1 c3) (nombre2 c2))(vecina (nombre1 a3) (nombre2 a1))(vecina (nombre1 a3) (nombre2 a2))(vecina (nombre1 b3) (nombre2 a3))(vecina (nombre1 c3) (nombre2 a3))(vecina (nombre1 b1) (nombre2 b3))(vecina (nombre1 b2) (nombre2 b3))(vecina (nombre1 c3) (nombre2 b3))(vecina (nombre1 c1) (nombre2 c3))(vecina (nombre1 c2) (nombre2 c3))(estancamiento (valor true))(generacion (numero 0))

)

(defrule obtener-celulas-vivas "Obtiene la generacion siguiente a partir de la anterior"(declare (salience 550))?celula1 <- (celula (nombre ?nombre1) (estado ?estado1) (generacion ?generacion1))(celula (nombre ?nombre2&~?nombre1) (estado ?estado2) (generacion ?generacion2))(celula (nombre ?nombre3&~?nombre2&~?nombre1) (estado ?estado3) (generacion ?generacion3))(celula (nombre ?nombre4&~?nombre3&~?nombre2&~?nombre1) (estado ?estado4) (generacion ?generacion4))(vecina (nombre1 ?nombre1) (nombre2 ?nombre2))(vecina (nombre1 ?nombre1) (nombre2 ?nombre3))(vecina (nombre1 ?nombre1) (nombre2 ?nombre4))(vecina (nombre1 ?nombre1) (nombre2 ?nombre5))(generacion (numero ?generacion-actual))(test (and (eq ?generacion1 ?generacion-actual) (eq ?generacion2 ?generacion-actual) (eq ?generacion3 ?generacion-

actual) (eq ?generacion4 ?generacion-actual)))(test (or (and (eq ?estado2 viva) (eq ?estado3 viva)) (and (eq ?estado2 viva) (eq ?estado4 viva)) (and (eq ?estado3 viva)

(eq ?estado4 viva))))?estancamiento <- (estancamiento (valor ?valor))=> (bind ?siguiente-generacion (+ ?generacion1 1))(modify ?celula1 (estado viva) (generacion ?siguiente-generacion))(modify ?estancamiento (valor false))

)

(defrule obtener-celulas-muertas "todas las que queden deben cambiar a muertas"(declare (salience 500))?celula1 <- (celula (nombre ?nombre) (estado ?estado) (generacion ?generacion1))(generacion (numero ?generacion-actual))(test (eq ?generacion1 ?generacion-actual))=> (bind ?siguiente-generacion (+ ?generacion-actual 1))(modify ?celula1 (estado muerta) (generacion ?siguiente-generacion))

)

(defrule cambiar-generacion(declare (salience 150))?generacion <- (generacion (numero ?numero))?estancamiento <- (estancamiento (valor false))=>(bind ?siguiente-generacion (+ ?numero 1))(modify ?generacion (numero ?siguiente-generacion))(modify ?estancamiento (valor true))

)

(defrule imprimir-celulas-vivas "Imprime al final las celulas vivas"(celula (nombre ?nombre) (estado viva) )=> (printout t"La celula " ?nombre " vive. " crlf)

)

(defrule imprimir-celulas-muertas "Imprime al final las celulas muertas"(celula (nombre ?nombre) (estado muerta) )=>

(printout t"La celula " ?nombre " ha muerto. " crlf))

(defrule imprimir-estancamiento(declare (salience 10))(estancamiento (valor true))(generacion (numero ?numero))=>(bind ?numero (+ ?numero 1))(printout t "Se ha producido estancamiento y por lo tanto finalizamos en la generación " ?numero crlf)

)

Implementar en el lenguaje CLIPS el conjunto de los operadores del mundo de los bloques. La solución debe, mediante reglas de inferencia, identificar la trayectoria de los estados alcanzados, partiendo de un estado inicial, y los operadores aplicados, que reflejen los movimientos efectuados por el robot hasta alcanzar el estado meta (u objetivo).

Los operadores válidos son:

Operador Precondición/ResultadoCoger (x) Precondición: Sobre mesa (x), libre (x), mano robot vacía

Resultado: Cogido (x)Dejar (x) Precondición: Cogido (x)

Resultado: Sobre mesa (x), libre (x), mano robot vacíaMontar (x en y) Precondición: Cogido (x), Libre (y)

Resultado: Sobre (y, x), mano robot vacía, libre (x)Desmontar (x, y) Precondición: Mano robot vacía, sobre (y, x), libre (x)

Resultado: Cogido (x), libre (y)

Solución:(deftemplate apilado (slot encima (type SYMBOL)) (slot debajo (type SYMBOL)))

(deftemplate objetivo (slot encima (type SYMBOL)) (slot debajo (type SYMBOL)))

(deffacts bloques

; Estado de partida; nada encima de B encima de A encima de mesa; nada encima de C encima de D encima de mesa

(apilado (encima B) (debajo A))(apilado (encima nada) (debajo B)) (apilado (encima C) (debajo D)) (apilado (encima nada) (debajo C)) (apilado (encima D) (debajo mesa))(apilado (encima A) (debajo mesa))

; Estado final u objetivo

(objetivo (encima A) (debajo D))

; Reglas

(defrule Objetivo-logrado(declare (salience 110))?obj <- (objetivo (encima ?a) (debajo ?b))?x <- (apilado (encima nada) (debajo ?a))?y <- (apilado (encima nada) (debajo ?b))?z <- (apilado (encima ?a) (debajo ?c))

=> (modify ?z (debajo ?b)) (retract ?obj ?y)

(printout t crlf "Objetivo conseguido" crlf))

(defrule Objetivo-arriba-la-mesa?obj <- (objetivo (encima ?a) (debajo ?b))?x <- (apilado (encima ?algo&:(neq ?algo nada)) (debajo ?a))

=>(assert (objetivo (encima ?algo) (debajo mesa)))(printout t "Objetivo: encima " ?algo " debajo: mesa" crlf)

)

(defrule Objetivo-abajo-a-la-mesa?obj <- (objetivo (encima ?a) (debajo ?b))?x <- (apilado (encima ?algo&:(neq ?algo nada)) (debajo ?b))

=>(assert (objetivo (encima ?algo) (debajo mesa)))(printout t "Objetivo: encima " ?algo " debajo: mesa" crlf)

)

(defrule Objetivo-cumplido(declare (salience 100))?obj <- (objetivo (encima ?a) (debajo mesa))(apilado (encima ?a) (debajo mesa))

=>(retract ?obj)

)

(defrule mover-a-la-mesa?obj <- (objetivo (encima ?a) (debajo mesa))(apilado (encima nada) (debajo ?a))?y <- (apilado (encima ?a) (debajo ?b))

=> (retract ?obj)

(modify ?y (debajo mesa))(assert (apilado (encima nada) (debajo ?b)))(printout t "muevo " ?a " a la mesa" crlf)

)

Dado un mapa que representa la situación de distintas ciudades, se quiere construir un sistema en Clips que permita contestar preguntas sobre la posición relativa de dos ciudades, con las siguientes características:

a) Se introducirán exclusivamente hechos correspondientes a las relaciones “estar al norte de” y “estar al oeste de” y sólo entre las ciudades más próximas entre sí. Por ejemplo, si suponemos 9 ciudades distribuidas en una cuadrícula:A B CD E FG H I

sólo se establecerán como hechos: “A está al norte de D”, “A está al oeste de B”, etc.b) El sistema de representación será capaz de inferir todas las relaciones inversas de las dadas directamente, es decir, las

relaciones “estar al sur de” y “estar al este de”.c) Se inferirán nuevas relaciones por transitividad. Por ejemplo, sabiendo que “A está al norte de D” y que “D está al norte de

G” se inferirá que “A está al norte de G”.d) Se inferirán las relaciones noroeste, noreste, suroeste y sureste a partir de los hechos iniciales. Por ejemplo, se podrá

inferir que “C está al noreste de G”.e) El hecho que se utilizará para consultar al sistema será ( situación <ciudad_1> <ciudad_2> ). Cuando este hecho se

inserta en el sistema, el mismo debe responder mostrando por pantalla la situación de la ciudad 1 con respecto a la ciudad 2.

Solución:Desde luego, la forma más simple de hacer es:

(deffacts ciudades

(ubicada A al-oeste-de B)(ubicada B al-oeste-de C)(ubicada D al-oeste-de E)(ubicada E al-oeste-de F)(ubicada G al-oeste-de H)(ubicada H al-oeste-de I)(ubicada A al-norte-de D)(ubicada D al-norte-de G)(ubicada B al-norte-de E)(ubicada E al-norte-de H)(ubicada C al-norte-de F)(ubicada F al-norte-de I)

(situacion B F)

)

; Reglas para inferir relaciones inversas

(defrule al-sur-de

(ubicada ?a al-norte-de ?b) => (assert (ubicada ?a al-sur-de ?a)))

(defrule al-este-de

(ubicada al-oeste-de ?a ?b) => (assert (ubicada ?b al-este-de ?a)))

; Reglas para inferir relaciones transitivas

(defrule transitiva

(ubicada ?a ?rel ?b)(ubicada ?b ?rel ?c)

=> (assert (ubicada ?a ?rel ?c)))

; Reglas para inferir relaciones combinadas

(defrule noreste

(ubicada ?a al-norte-de ?b)(ubicada ?b al-este-de ?c)

=> (assert (ubicada ?a al-noreste-de ?c)))

(defrule noroeste

(ubicada ?a al-norte-de ?b)(ubicada ?b al-oeste-de ?c)

=> (assert (ubicada ?a al-noroeste-de ?c)))

(defrule sureste

(ubicada ?a al-sur-de ?b)(ubicada ?b al-este-de ?c)

=> (assert (ubicada ?a al-sureste-de ?c)))(defrule suroeste

(ubicada ?a al-sur-de ?b)(ubicada ?b al-oeste-de ?c)

=> (assert (ubicada ?a al-suroeste-de ?c)))

;Respuesta de la pregunta

(defrule relacion-entre-ciudades(declare (salience -10))(situacion ?a ?b)(ubicada ?a ?rel ?b)

=> (printout t ?a " está " ?rel " " ?b crlf))

Consideremos fórmulas de la lógica proposicional construidas con las conectivas: negación (-), disyunción (|), conjunción (&), implicación (->) y equivalencia (<->). Por ejemplo: (p&q)->rPara la representación en clips de este tipo de fórmulas se propone el siguiente template.(deftemplate formula

(slot id)(slot tipo)(multislot componentes)

)

Id almacena un identificador asociado a la fórmula. Tipo almacena la conectiva entre (siguiente campo) los identificadores de las fórmulas componentes. Por ejemplo, la fórmula anterior quedaría en los siguientes hechos:(formula (id id-1) (tipo ->) (componentes id2 id3))(formula (id id-2) (tipo &) (componentes id4 id5))(formula (id id-3) (tipo var) (componentes))(formula (id id-4) (tipo var) (componentes))(formula (id id-5) (tipo var) (componentes))

a) ¿Con qué hechos se representaría la fórmula ((-q)| (-r)) <> (-(q&r))

Toda fórmula proposicional se puede transformar a forma normal negativa aplicando una serie de reglas de transformación, de las cuales las siguientes son una parte:

(-(-p)) se transforma en p

(p->q) se transforma en (-p)|q

(-(p&q)) se transforma en (-p)|(-q)

(p<->q) se transforma en (p->q)&(q->p)

b) Construir un conjunto de reglas Clips que sirvan para realizar estas transformaciones. Para ello será necesario utilizar la función gensym que genera un identificador único para asignárselo a una fórmula. Por ejemplo, (assert (formula (id (genysim))))

No se permite la utilización de condicionales en el consecuente de las reglas.

c) ¿Cómo se podría imprimir mediante reglas Clips una fórmula así representada conocido el identificador raíz?

Solución:

Solución:

1.

(deffacts hechos

(formula (id q) (tipo "var") (componentes))(formula (id r) (tipo "var") (componentes))(formula (id id-1) (tipo "-") (componentes q))(formula (id id-2) (tipo "-") (componentes r))(formula (id id-3) (tipo "|") (componentes id-1 id-2))(formula (id id-4) (tipo "-") (componentes id-5))(formula (id id-5) (tipo "&") (componentes q r))(formula (id raiz) (tipo "<->") (componentes id-3 id-5))

(transformar)

)

2.

; transformacion de la doble negación(defrule doble-negacion (declare (salience 550))

(transformar)?f1 <- (formula (id ?id-1) (tipo "-") (componentes ?id-2))?f2 <- (formula (id ?id-2) (tipo "-") (componentes ?id-3))?f3 <- (formula (id ?id-3) )=>

(retract ?f1 ?f2)(modify ?f3 (id ?id-1))

)

;transformación de la implicación(defrule implicacion (declare (salience 550))

(transformar)?f1 <- (formula (id ?id-1) (tipo "->") (componentes ?id-2 ?id-3))=>

(bind ?nuevo-id (gensym))(modify ?f1 (tipo "|") (componentes ?nuevo-id ?id-3))(assert (formula (id ?nuevo-id) (tipo "-") (componentes ?id-2)))

)

;transformación negación de la conjunción(defrule negacion-conjuncion (declare (salience 550))

(transformar)?f1 <- (formula (id ?id-1) (tipo "-") (componentes ?id-2))?f2 <- (formula (id ?id-2) (tipo "&") (componentes ?id-3 ?id-4))=>

(bind ?id-2a (gensym))(bind ?id-2b (gensym))(modify ?f1 (id ?id-1) (tipo "|") (componentes ?id-2a ?id-2b))(modify ?f2 (id ?id-2a) (tipo "-") (componentes ?id-3))

(assert (formula (id ?id-2b) (tipo "-") (componentes ?id-4))))

; transformacion doble implicación(defrule doble-implicacion (declare (salience 550))

(transformar)?f1 <- (formula (id ?id-1) (tipo "<->") (componentes ?id-2 ?id-3))=>

(bind ?id-4a (gensym))(bind ?id-4b (gensym))(modify ?f1 (id ?id-1) (tipo "&") (componentes ?id-4a ?id-4b))(assert (formula (id ?id-4a) (tipo "->") (componentes ?id-2 ?id-

3)))(assert (formula (id ?id-4b) (tipo "->") (componentes ?id-3 ?id-

2))))

; cierra la transformacion y define hecho raiz para la impresión (defrule cierra-transformacion (declare (salience 100))

?t <- (transformar)=>

(retract ?t)(assert (imprimir raiz))

)

3.

(defrule imprimir-dupla?f <- (imprimir ?id-1)(formula (id ?id-1) (tipo ?tipo&"&"|"|"|"->"|"<->") (componentes ?id-2 ?

id-3))=>

(retract ?f)(printout t ?tipo " ")(assert (imprimir ?id-3))(assert (imprimir ?id-2))

)(defrule imprimir-negacion

?f <- (imprimir ?id-1)(formula (id ?id-1) (tipo "-") (componentes ?id-2))=>

(retract ?f)(printout t "- ")(assert (imprimir ?id-2))

)(defrule imprimir-var

?f <- (imprimir ?id-1)(formula (id ?id-1) (tipo "var"))=>

(retract ?f)(printout t ?id-1 " ")

)(defrule imprimir-fin

(not (imprimir ?))=>

(printout t crlf))

El siguiente árbol de decisión presenta una pequeña sección de un diagnóstico de fallos en el sistema de encendido de coches. Cada caja redondeada es una recomendación. Cada caja rectangular implica la recogida de evidencias. Implemente en Clips un sistema que solucione este problema. ¿Hay diversas posibilidades en cuanto al diseño de la implementación? Razone las opciones y sus ventajas o inconvenientes. ¿Puede implementar el sistema de acuerdo a cada una de esas posibilidades? No importa si no entiende alguna palabra de la figura, son preguntas de respuestas booleanas y las recomendaciones correspondientes a las secuencias de evidencias.

;Definición de la estructuras de datos

(deftemplate nodo-binario "estructura del nodo del arbol binario"(slot nodo-id (type INTEGER))(slot pregunta (type STRING))

(slot nodo-yes (type INTEGER)) (slot nodo-not (type INTEGER))

)

(deftemplate nodo-terminal "estructura del nodo terminal del arbol"(slot nodo-id (type INTEGER))(slot indicacion (type STRING))

)

(deffacts arbol-binario "contenidos de los nodos que componen en arbol"(nodo-binario (nodo-id 1) (pregunta "Starter turning") (nodo-yes 2) (nodo-

not 3))(nodo-binario (nodo-id 2) (pregunta "Got any petrol") (nodo-yes 4) (nodo-

not 5))(nodo-binario (nodo-id 3) (pregunta "Lights working") (nodo-yes 6) (nodo-

not 7))(nodo-binario (nodo-id 6) (pregunta "Solenoid clik") (nodo-yes 8) (nodo-

not 9))(nodo-binario (nodo-id 8) (pregunta "Terminals clean") (nodo-yes 10)

(nodo-not 11))(nodo-binario (nodo-id 9) (pregunta "Solenoid fuse OK") (nodo-yes 12)

(nodo-not 13))

(nodo-terminal (nodo-id 4) (indicacion "Call de A.A.")) (nodo-terminal (nodo-id 5) (indicacion "Buy same")) (nodo-terminal (nodo-id 7) (indicacion "Charge battery")) (nodo-terminal (nodo-id 10) (indicacion "Replace starter")) (nodo-terminal (nodo-id 11) (indicacion "Clean terminals")) (nodo-terminal (nodo-id 12) (indicacion "Replace solenoid"))(nodo-terminal (nodo-id 13) (indicacion "Replace fuse"))

(nodo-activo 1))

;*************************************

;DEFINICIÓN DE REGLAS

;******************************************** (defrule pide-datos "Presenta la pregunta del nodo y navega por el arbol"

?n <- (nodo-activo ?nodo)(nodo-binario (nodo-id ?nodo) (pregunta ?pregunta) (nodo-yes ?ny) (nodo-

not ?nn))=>

(retract ?n)(printout t crlf ?pregunta " (Y/-)?: " crlf)(if (eq (read) Y) then (assert (nodo-activo ?ny)) else (assert

(nodo-activo ?nn)) ))

(defrule presenta-conclusiones "Presenta la indicacion correspondiente"?n <- (nodo-activo ?nodo)(nodo-terminal (nodo-id ?nodo) (indicacion ?indicacion))=>

(retract ?n)(printout t crlf ?indicacion "!" crlf crlf)

)

Ejercicio de Clips: Se dispone de un registro con los siguientes datos de personas: DNI, Nombre, Apellidos, año-nacimiento, profesión, DNI-padre, DNI-madre y DNI-cónyuge.1.1 Diseñar las estructuras Clips para almacenar estos datos en la base de hechos.Implementar las reglas Clips que permitan alcanzar los siguientes objetivos:1.2 Se desea obtener un listado de los nombres de los ascendientes de cada persona.1.3 Se desea determinar si hubo matrimonios entre primos hermanos.1.4 Se desea determinar si hubo matrimonios entre un cónyuge que tuviese una determinada profesión y que el padre del otro cónyuge tuviese esa misma profesión.1.5 Se desea un listado de todas las personas ordenadas por año de nacimiento.1.6 Se desea un listado de todas las personas ordenadas por apellidos.Para comparar strings se dispone de la función str-compare que tiene como argumentos los dos strings a comparar. Devuelve 0 si son iguales, un valor positivo si el primero es mayor que el segundo, y devuelve un valor negativo en el caso inverso.;Se dispone de un registro con los siguientes datos de personas: DNI, Nombre y apellidos, año-nacimiento, profesión, DNI-padre, ;DNI-madre y DNI-cónyuge.


(deftemplate persona "Tipo de entidad persona" (slot posicion (type INTEGER)); campo para la ordenación de los registros

segun diferentes criterios (slot dni) (slot nombre) (multislot apellidos) (slot nacimiento (type INTEGER));Año nacimiento (slot profesion) (slot padre) ;Contendrá el DNI del padre (slot madre) ;Contendrá el DNI de la madre

(slot conyuge); contendrá el DNI del conyuge ) (deffacts personas(persona (posicion 1) (dni 156688068A) (nombre Pedro) (apellidos "Ponce Sala") (nacimiento 1941) (profesion "cartero"))(persona (posicion 2) (dni 080245678A) (nombre Francisco) (apellidos "Ponce Suarez") (nacimiento 1960) (profesion "Informatico") (padre 156688068A) (madre 112244069A) (conyuge 663355046A))(persona (posicion 3) (dni 856678098A) (nombre Zeus) (apellidos "Ponce Suarez") (nacimiento 1961) (profesion "Agricultor") (padre 156688068A)(madre 112244069A) (conyuge 333344059A))(persona (posicion 4) (dni 356688068A) (nombre Pepe) (apellidos "Ponce Saez") (nacimiento 1980) (profesion "Lechero") (padre 080245678A) (madre 663355046A)) (persona (posicion 5) (dni 556688068A) (nombre Luis) (apellidos "Ponce Lopez") (nacimiento 1972) (profesion "cartero") (padre 856678098A) (madre 333344059A) (conyuge 552299078A))

(persona (posicion 6) (dni 456688068A) (nombre Juan) (apellidos "Ponce Lopez") (nacimiento 1981) (profesion "elect") (padre 856678098A) (madre 663355046A) )

(persona (posicion 7) (dni 552299078A) (nombre Carol) (apellidos "Ponce Saez") (nacimiento 1973) (profesion "azafata") (padre 080245678A) (madre 663355046A)(conyuge 556688068A))

(persona (posicion 8) (dni 663355046A) (nombre Petra) (apellidos "Saez Diaz") (nacimiento 1963) (profesion "ama casa") (conyuge 080245678A))

(persona (posicion 9) (dni 333344059A) (nombre Manuela) (apellidos "Lopez Perez") (nacimiento 1962) (profesion "cartero") (conyuge 856678098A))

(persona (posicion 10) (dni 112244069A) (nombre Felisa) (apellidos "Suarez Garcia") (nacimiento 1948) (profesion "ama casa") (conyuge 156688068A))

(inicio))

;********************************************


;********************************************

;Regla que plantea de forma muy simple el menú de acciones que se desean realizar:

(defrule presenta-menu "Presenta el menu de acciones al usuario"?inicio <- (inicio) =>

(printout t crlf "Seleccione acción (1-5)" crlf " 1- Listar por apellidos" crlf" 2- Listar por año de nacimiento" crlf" 3- Obtener los ascendientes de una persona" crlf" 4- Determinar si hubo matrimonios entre primos" crlf" 5- Determinar si un conyuge con la profesion del suegro"

crlf" Acción: ")

(bind ?accion (read))(if (= ?accion 1) then (assert (listar-apellidos)))(if (= ?accion 2) then (assert (listar-anhos)))(if (= ?accion 3) then (assert (listar-ascendientes)))(if (= ?accion 4) then (assert (determinar-matri-primos)))(if (= ?accion 5) then (assert (determinar-matri-suegro)))(retract ?inicio)

)

;**************************************

;Reglas que ordenan las posiciones por apellidos

(defrule ordenar-apellidos "ordena por apellidos" (declare (salience 550))

(listar-apellidos) ?x1 <- (persona (posicion ?i) (apellidos $?ap1) ) ?x2 <- (persona (posicion ?j)(apellidos $?ap2) )

(test (= ?j (+ ?i 1))) ;Pasamos la variable multicampo a una cadena simple y se compara (test (> (str-compare (implode$ $?ap1) (implode$ $?ap2)) 0)) ;Ordenadas alfabeticamente

=> (modify ?x1 (posicion ?j))

(modify ?x2 (posicion ?i))

)

; regla para preparar el proceso de impresión

(defrule inicia-indice-apellidos "Inicia el indice para la ordenación" (declare (salience 520))

?l <- (listar-apellidos) => (retract ?l)(assert (indice-ap 1))

)

; Regla imprime ordenadamente por apellidos(defrule imprime-apellidos "Imprime por apellidos" (declare (salience 500)) ?x <- (indice-ap ?i) (persona (posicion ?i) (nombre ?nombre) (apellidos $?ap) )

=> (printout t $?ap ", " ?nombre crlf)

(retract ?x)(assert (indice-ap (+ ?i 1)))

)

;**************************************

;Regla que ordena las posiciones por anho de la misma forma que la anterior

(defrule ordenar-anhos "ordena por anhos" (declare (salience 550))

(listar-anhos) ?x1 <- (persona (posicion ?i) (nacimiento ?anho-1) ) ?x2 <- (persona (posicion ?j) (nacimiento ?anho-2) )

;se comparan solo las posiciones adyacentes(test (= ?j (+ ?i 1)))

(test (< ?anho-1 ?anho-2)) =>

(modify ?x1 (posicion ?j))(modify ?x2 (posicion ?i))

)

(defrule inicia-indice-anhos "Inicia el indice para la ordenación" (declare (salience 520))

?l <- (listar-anhos) => (retract ?l)(assert (indice-an 1))

)

(defrule imprime-anhos "imprime por anhos" (declare (salience 450)) ?x <- (indice-an ?i) (persona (posicion ?i) (nombre ?nombre) (nacimiento ?a) )

=> (printout t ?a ", " ?nombre crlf)

(retract ?x)(assert (indice-an (+ ?i 1)))

)

;**************************************

; Reglas para el listado de los ancestros de una persona

(defrule obtener-dni-ascendientes "Pide el dni de la persona cuyos ascendientes se buscan" (declare (salience 550))

?fase <- (listar-ascendientes)=>

(printout t crlf "introduzca el dni de la persona: " crlf) (assert (objetivo (read)))

(retract ?fase))

(defrule obtener-ascendentes "Obtiene los ascendientes de una persona dada" (declare (salience 500)) ?ob <- (objetivo ?dni-ob)

(persona (dni ?dni-ob) (nombre ?nombre) (apellidos $?ap-h) (padre ?dni-padre) (madre ?dni-madre) )

(persona (dni ?dni-padre) (nombre ?nombre-p) (apellidos $?ap-p) ) (persona (dni ?dni-madre) (nombre ?nombre-m) (apellidos $?ap-m) ) =>

(printout t ?nombre " " $?ap-h " es hijo de " ?nombre-p " " $?ap-p " y de " ?nombre-m " " $?ap-m crlf)

(retract ?ob) (assert (objetivo ?dni-padre)) (assert (objetivo ?dni-madre))

)

;**************************************

;Regla que comprueba si hay matrimonios entre primos. Para simplificar supondremos que hay un único matrimonio;para cada miembro de una pareja. Así, podemos dejar las abuelas tranquilas, por ejemplo

(defrule comprueba-matrimonios-primos "Determina si ha habido matrimonios entre primos"

?mp <- (determinar-matri-primos) (persona (dni ?dni) (nombre ?nombre) (padre ?padre) (madre ?madre) (conyuge ?d-conyuge) ) (persona (dni ?d-conyuge) (nombre ?conyuge) (padre ?c-padre) (madre ?c-madre) ) (persona (dni ?padre) (padre ?abuelo-p)) ; abuelo paterno (persona (dni ?madre) (padre ?abuelo-m)) ; abuelo materno (persona (dni ?c-padre) (padre ?c-abuelo-p) ) ; abuelo paterno del conyuge (persona (dni ?c-madre) (padre ?c-abuelo-m) ) ; abuelo materno del conyuge

(test ( or (eq ?abuelo-p ?c-abuelo-p )(eq ?abuelo-p ?c-abuelo-m )(eq ?abuelo-m ?c-abuelo-p )(eq ?abuelo-m ?c-abuelo-m )

))=>

(retract ?mp)(printout t "Se ha encontrado un matrimonio entre primos: " ?nombre

" y " ?conyuge " " crlf) )

;**************************************

;Regla que comprueba si hay un matrimonio con un conyuge con la misma profesión que el padre del otro conyuge

(defrule comprueba-profesion-suegro "Determina si una persona con la profesión de su suegro"

?mp <- (determinar-matri-suegro) (persona (dni ?dni) (nombre ?nombre) (profesion ?prof ) (conyuge ?conyuge)) (persona (dni ?conyuge) (padre ?suegro) ); obtenemos el dni del suegro (persona (dni ?suegro) (nombre ?n-suegro) (profesion ?prof)) ; coincide la profesion del suegro

=> (retract ?mp)(printout t "Se ha encontrado que " ?nombre " y su suegro " ?n-

suegro " tienen la misma profesión " crlf) )

Supóngase una empresa de mensajería que transporta paquetes y cartas. La siguiente tabla presenta los costes de enviar cartas y paquetes menores de 2 Kgs. entre la ciudad origen y la ciudad destino siempre que la entrega sea al día siguiente.

COSTE (euros)

ORIGEN DESTINO CARTA PAQUETE

Madrid Barcelona 4 7

Madrid Toledo 2 6

Madrid Badajoz 3 7

Barcelona Cádiz 6 8

Barcelona Gerona 2 4

Barcelona Badajoz 4 9

Si la entrega es para el mismo día que la recogida existe un suplemento tanto para las cartas como para los paquetes de 60 euros. Al margen de esto, si el paquete pesa más de 2 kilos, hay un suplemento de 6 euros por cada 100 grs. de más. Se pide, utilizando Clips,

4.1. Definir la base de hechos .4.2. Construir la base de reglas que formalice dichos conocimientos utilizando el menor número de reglas posible. 4.3. Construir las reglas para la introducción de los datos del paquete a enviar y muestren el importe correspondiente. 4.4. Supóngase que cada fila de la tabla representa los costes de enviar cartas entre dos ciudades determinadas, con

independencia de cuál sea el origen y cuál el destino. Es decir, vale lo mismo enviar una carta de Madrid a Barcelona que de Barcelona a Madrid. Construir la o las reglas para formalizar tal conocimiento.

;Definición de la estructuras de datos (deftemplate ruta "Ruta y tipo de envíos"

(slot origen) (slot destino) (slot tipo) (slot importe (type INTEGER)) )(deftemplate envio "Datos del envio"

(slot origen) (slot destino) (slot tipo (type SYMBOL))

(slot urgente? (type SYMBOL))(slot peso (type INTEGER))

(slot importe (type INTEGER)) )(deftemplate suplementos "suplemento que se paga por entrega rápida"

(slot entrega-rapida (type INTEGER)) (slot exceso-peso-minimo (type INTEGER)) (slot importe-peso-minimo (type INTEGER)) (slot exceso-peso-margen (type INTEGER)) (slot importe-margen (type INTEGER))

)(deffacts tarifas

(ruta (origen Madrid) (destino Barcelona) (tipo C) (importe 4)) (ruta (origen Madrid) (destino Barcelona) (tipo P) (importe 7))(ruta (origen Madrid) (destino Toledo ) (tipo C) (importe 2))

(ruta (origen Madrid) (destino Toledo ) (tipo P) (importe 6)) (ruta (origen Madrid) (destino Badajoz) (tipo C) (importe 3)) (ruta (origen Madrid) (destino Badajoz) (tipo P) (importe 7)) (ruta (origen Barcelona) (destino Cadiz) (tipo C) (importe 6))(ruta (origen Barcelona) (destino Cadiz) (tipo P) (importe 8)) (ruta (origen Barcelona) (destino Gerona) (tipo C) (importe 2)) (ruta (origen Barcelona) (destino Gerona) (tipo P) (importe 4)) (ruta (origen Barcelona) (destino Badajoz) (tipo C) (importe 4)) (ruta (origen Barcelona) (destino Badajoz) (tipo C) (importe 9))(suplementos (entrega-rapida 60) (exceso-peso-minimo 2000) (exceso-peso-

margen 100) (importe-margen 6)));************************************* ;DEFINICIÓN DE REGLAS ;******************************************** ;Regla que plantea de forma muy simple el menú de acciones que se desean realizar:;origen, destino, y tipo de paquete;pregunta la urgencia del envío (urgente o no);si es paquete pide el peso(defrule pide-datos "Pide los datos del envio"

(initial-fact) =>

(printout t crlf "Datos del envío" crlf)(printout t crlf "Origen: " )(bind ?origen (read)) (printout t crlf "Destino: ")(bind ?destino (read)) (printout t crlf "Es una carta (C) o un paquete (P): ")(bind ?tipo (read)) (printout t crlf "Es urgente? (S/N): ")(bind ?urgente (read)) (assert (envio (origen ?origen) (destino ?destino) (tipo ?tipo)

(urgente? ?urgente) (peso 0) (importe 0))))(defrule calcula-importe "calcula el importe en función del origen, destino, urgencia y tipo"

?e <- (envio (origen ?origen) (destino ?destino) (tipo ?tipo) (urgente? ?urgente) (peso 0) (importe 0))

(ruta (origen ?origen) (destino ?destino) (tipo ?tipo) (importe ?importe))(suplementos (entrega-rapida ?entrega-rapida))=>

(if (eq ?urgente S) then (bind ?importe (+ ?importe ?entrega-rapida)))

(modify ?e (importe ?importe)))(defrule suma-importe-exceso-peso "acumula el importe del peso extra"

?e <- (envio (tipo P) (peso 0) (importe ?importe&:(> ?importe 0)))(suplementos (exceso-peso-minimo ?peso-minimo) (importe-peso-minimo ?

importe-peso-minimo) (exceso-peso-margen ?margen) (importe-margen ?importe-margen))

=>(printout t crlf "Peso?: ")(bind ?peso (read))(if (> ?peso ?peso-minimo) then

(bind ?importe (+ ?importe ?importe-peso-minimo))(bind ?exceso (div (- ?peso ?peso-minimo) ?margen))(if (> ?exceso 0) then (bind ?importe (+ ?importe (* ?exceso ?

importe-margen)))))

(modify ?e (peso ?peso) (importe ?importe))

); Regla final que termina presentando el coste del envio.(defrule presenta-importe "presenta el coste del envio"

(declare (salience -10))?e <- (envio (importe ?importe))=>

(printout t crlf "El coste del envío es: " ?importe crlf))

Supóngase una agencia de viajes que ofrece viajes de trenes a sus clientes. Los viajes tienen unos atributos como son: el lugar de origen y el lugar de destino y una tarifa inicial que se utilizará para calcular el precio final del viaje. Los viajes en tren se caracterizan por el tipo de tren (AVE o TALGO), por la clase (turista o preferente), por el período de salida (blanco, rojo o azul) y el tipo de cliente (asiduo o esporádico).

Sin descuentos ni incrementos, los precios de un viaje en clase turista, entre dos ciudades, son los siguientes y dependen del tipo de tren.

COSTE (euros)

ORIGEN DESTINO AVE TALGO

Madrid Córdoba 70 60

Madrid Sevilla 80 70

Barcelona Madrid --- 80

… …

El precio sería el mismo para el viaje Barcelona-Madrid que para el viaje Madrid-Barcelona. Se utilizan las siguientes reglas para calcular el precio final:

o Si el viaje es en clase preferente, los precios de la tabla se ven incrementados en un 30%o Si la fecha de salida es azul, el precio del billete se reduce en un 10% y si es roja se incrementa en un 10%.o Si el cliente es asiduo, el precio se reduce en un 10%o Si el viajero es menor de 22 años (tarifa joven), se le aplica un 20% de reducción.o Si el viajero es mayor de 65 años (tarifa dorada), se le aplica un 50% de reducción.o Los descuentos y suplementos se aplican en el orden establecido en el enunciado.

Usando Clips:5.1. Definir la base de hechos 5.2. Construir la base de reglas que formalice dichos conocimientos utilizando el menor número de reglas posible. Esto debe

realizarse de tal forma que sea fácil añadir y borrar reglas en el sistema, y modificar los incrementos y descuentos sin modificar la base de reglas.

5.3. Construir las reglas para la introducción de los datos del viaje y muestren el importe correspondiente.


(deftemplate trayecto "Trayecto y tipo" (slot origen)

(slot destino) (slot tipo-transporte) (slot importe (type INTEGER)) )(deftemplate billete "Datos billete"

(slot origen) (slot destino) (slot tipo-transporte (type SYMBOL))

(slot preferente? (type SYMBOL))(slot edad-viajero (type INTEGER))(slot tipo-dia (type SYMBOL))(slot asiduo? (type SYMBOL))(slot tarifa-edad (type SYMBOL))

(slot importe (type INTEGER)) )(deftemplate suplementos "suplemento que se paga por entrega rápida"

(slot preferente (type FLOAT))(slot dia-azul (type FLOAT))(slot dia-rojo (type FLOAT))(slot viajero-asiduo (type FLOAT))(slot tarifa-joven (type FLOAT))(slot tarifa-dorada (type FLOAT))(slot exceso-peso-margen (type INTEGER)) (slot importe-margen (type INTEGER))

)(deffacts tarifas

(trayecto (origen Madrid) (destino Cordoba) (tipo-transporte A) (importe 70))

(trayecto (origen Madrid) (destino Cordoba) (tipo-transporte T) (importe 60))

(trayecto (origen Madrid) (destino Sevilla) (tipo-transporte A) (importe 80))

(trayecto (origen Madrid) (destino Sevilla) (tipo-transporte T) (importe 70))

(trayecto (origen Barcelona) (destino Madrid) (tipo-transporte T) (importe 80))

(suplementos (preferente 0.3) (dia-azul -0.1) (dia-rojo 0.1) (viajero-asiduo -0.1) (tarifa-joven -0.1) (tarifa-dorada -0.5 )); desglose de edades

(edad-joven 22) (edad-mayor 65)

)

;*************************************


;******************************************** ;Regla que plantea de forma muy simple el menú de acciones que se desean FLOATizar:;origen, destino, y tipo de paquete;pregunta la urgencia del envío (urgente o no)

;si es paquete pide el peso

(defrule pide-datos "Pide los datos del envio"?i <- (initial-fact) (edad-joven ?joven) (edad-mayor ?mayor)=>

(printout t crlf "Datos del billete" crlf)(printout t crlf "Origen: " )(bind ?origen (read)) (printout t crlf "Destino: ")(bind ?destino (read)) (printout t crlf "Tipo de tren, AVE (A) o Talgo (T): ")(bind ?tipo-transporte (read)) (printout t crlf "Viaja en preferente (S/N): ")(bind ?preferente? (read)) (printout t crlf "La fecha del viaje es dia Normal (N), Azul (A) o

Rojo (R): ")(bind ?tipo-dia (read)) (printout t crlf "Es viajero asiduo (S/N): ")(bind ?asiduo? (read)) (printout t crlf "Edad del viajero (años): ")(bind ?edad (read)) (if (< ?edad ?joven) then (assert (billete (origen ?origen) (destino ?destino) (tipo-

transporte ?tipo-transporte) (preferente? ?preferente?) (tipo-dia ?tipo-dia) (asiduo? ?asiduo?) (tarifa-edad J) (importe 0)))

else (if (> ?edad ?mayor) then (assert (billete (origen ?origen) (destino ?destino) (tipo-

transporte ?tipo-transporte) (preferente? ?preferente?) (tipo-dia ?tipo-dia) (asiduo? ?asiduo?) (tarifa-edad D) (importe 0)))

else (assert (billete (origen ?origen) (destino ?destino) (tipo-

transporte ?tipo-transporte) (preferente? ?preferente?) (tipo-dia ?tipo-dia) (asiduo? ?asiduo?) (tarifa-edad N) (importe 0)))

))

(retract ?i)(assert (trayecto-tipo))

)

(defrule calcula-importe-trayecto-tipo-tren "calcula el importe en función del origen, destino y tipo de transporte"

?i <- (trayecto-tipo)?e <- (billete (origen ?origen) (destino ?destino) (tipo-transporte ?tipo)

)(trayecto (origen ?origen) (destino ?destino) (tipo-transporte ?tipo)

(importe ?importe))=>

(modify ?e (importe ?importe))(retract ?i)(assert (clase))

)

(defrule suma-clase "acumula el importe de clase preferente, si lo es"?i <- (clase)?e <- (billete (preferente? S) (importe ?importe))(suplementos (preferente ?preferente)) =>

(modify ?e (importe (* ?importe (+ 1 ?preferente))))(retract ?i)(assert (tipo-dia))

)

(defrule suma-tipo-dia "acumula el importe en funcion del tipo de dia"?i <- (tipo-dia)?e <- (billete (tipo-dia ?tipo-dia) (importe ?importe))(suplementos (dia-rojo ?dia-rojo) (dia-azul ?dia-azul)) =>

(if (eq ?tipo-dia A) then (modify ?e (importe (* ?importe (+ 1 ?dia-azul)))))

(if (eq ?tipo-dia R) then (modify ?e (importe (* ?importe (+ 1 ?dia-rojo)))))

(retract ?i)(assert (tipo-viajero))

)(defrule suma-tipo-viajero "acumula el importe segun si es asiduo o no lo es"

?i <- (tipo-viajero)?e <- (billete (origen ?origen) (destino ?destino) (asiduo? S) (importe ?

importe))(suplementos (viajero-asiduo ?viajero-asiduo)) =>

(modify ?e (importe (* ?importe (+ 1 ?viajero-asiduo))))(retract ?i)(assert (tipo-edad))

)

(defrule suma-edad-viajero "acumula el importe segun la tarifa aplicable segun la edad"

?i <- (tipo-edad)?e <- (billete (tarifa-edad ?tarifa-edad) (importe ?importe))(suplementos (tarifa-joven ?tarifa-joven) (tarifa-dorada ?tarifa-dorada))=>

(if (eq ?tarifa-edad J) then (modify ?e (importe (* ?importe (+ 1 ?tarifa-joven)))))

(if (eq ?tarifa-edad D) then (modify ?e (importe (* ?importe (+ 1 ?tarifa-dorada)))))

(retract ?i)(assert (calcula-total))

)

; Regla final que termina presentando el coste del envio.

(defrule presenta-importe "presenta el precio final del billete"?i <- (calcula-total)(billete (importe ?importe))=>

(printout t crlf "El precio del billete es: " ?importe crlf)(retract ?i)

)

Se pretende construir un sistema que aconseje a un usuario la compañía (de entre dos contratadas) más barata para cada llamada. El sistema debería preguntar si la llamada es local o interprovincial, la duración estimada, y el día y la hora de comienzo.

Los precios de la compañía AAT son: Las llamadas locales tienen una tarifa mínima de 0,1 euros, e incluye los dos primeros minutos. Los siguientes minutos son: de lunes a viernes, de 8 a 18 hs, a 0,02 euros y de 18 a 8 hs. de 0,01 euros. Los sábados y domingos, todo el día a 0,01 euros. Las llamadas interprovinciales tienen una tarifa mínima de 0,25 euros que también incluye solamente el primer minuto. Cada uno de los siguientes minutos cuesta: de lunes a viernes, de 8 a 22 hs, a 0,3 euros y de 22 a 8 hs. de 0,2 euros. Los sábados y domingos, todo el día a 0,2 euros el minuto.

Los precios de la compañía BBT son: Las llamadas locales tienen una tarifa mínima de 0,04 euros, pero no incluye ningún minuto. Cada minuto de lunes a viernes cuesta, de 8 a 20 hs, a 0,03 euros y de 20 a 8 hs. de 0,01 euros. Los sábados y domingos, todo el día a 0,01 euros. Las llamadas interprovinciales tienen una tarifa mínima de 0,1 euros, que tampoco incluye ningún minuto. Cada minutos cuesta: de lunes a viernes, de 8 a 20 hs, a 0,3 euros y de 20 a 8 hs. de 0,1 euros. Los sábados y domingos, todo el día a 0,1 euros el minuto.

Se pide construir el sistema en Clips.

3.1. Construir la base de hechos y la base de reglas que formalice dichos conocimientos utilizando el menor número de reglas posible.

3.2. Construir las reglas para la introducción de los datos de la llamada y muestren al usuario el número de la compañía por la cual efectuar la llamada.

1era. Versión:;La solución más adecuada a este tipo de problemas normalmente es la definición de una tabla, y este se podría resolver así,; como en los anteriores ejercicios. Pero en este, dada la variabilidad de los tipos de datos, vamos a resolverlo de otra forma,; con reglas que contienen todos los variables, datos y rangos que se utilizan para el calculo de la tarifa

(deftemplate llamada "Datos de la llamada tipo"(slot tipo-llamada (type SYMBOL))

(slot dia (type INTEGER)) (slot hora (type INTEGER))

(slot duracion (type INTEGER)))

;*************************************


;******************************************** ;Regla que plantea de forma muy simple el menú de acciones que se desean FLOATizar:;origen, destino, y tipo de paquete;pregunta la urgencia del envío (urgente o no);si es paquete pide el peso

(defrule pide-datos "Pide los datos de la llamada"=>

(printout t crlf "Datos de la llamada tipo" crlf)(printout t crlf "Llamada Local (L) o Interprovincial (I)?: ")(bind ?tipo-llamada (read)) (printout t crlf "El dia habitual de la llamada (1 a 7)?: ")(bind ?dia (read)) (printout t crlf "La hora habitual de la llamada (1 a 24)?: ")(bind ?hora (read)) (printout t crlf "Duracion de la llamada: ")(bind ?duracion (read)) (assert (llamada (tipo-llamada ?tipo-llamada) (dia ?dia) (hora ?

hora) (duracion ?duracion))))

(defrule calcula-importe-segun-la-telefonica-AAT "calcula el importe en función del tipo de llamada, duración y dia y hora de AAT"

?e <- (llamada (tipo-llamada ?tipo) (dia ?dia) (hora ?hora) (duracion ?duracion))

=> (if (eq ?tipo L) then (bind ?importe 0.1) (if (> ?duracion 2) then (bind ?duracion (- ?duracion 2))

(if (and (>= ?dia 1) (<= ?dia 5) (>= ?hora 8) (< ?hora 18)) then (bind ?importe (+ ?importe (* ?duracion 0.02))))

(if (and (>= ?dia 1) (<= ?dia 5) (or (>= ?hora 18) (< ?hora 8))) then (bind ?importe (+ ?importe (* ?duracion 0.01))))

(if (and (>= ?dia 6) (<= ?dia 7)) then (bind ?importe (+ ?importe (* ?duracion 0.01))))

) ) (if (eq ?tipo I) then (bind ?importe 0.25) (if (> ?duracion 1) then (bind ?duracion (- ?duracion 1))

(if (and (>= ?dia 1) (<= ?dia 5) (>= ?hora 8) (< ?hora 22)) then (bind ?importe (+ ?importe (* ?duracion 0.03))))

(if (and (>= ?dia 1) (<= ?dia 5) (or (>= ?hora 22) (< ?hora 8))) then (bind ?importe (+ ?importe (* ?duracion 0.02))))

(if (and (>= ?dia 6) (<= ?dia 7)) then (bind ?importe (+ ?importe (* ?duracion 0.02))))

) ) (printout t crlf "El importe de la llamada tipo en AAT es: " ?importe

crlf crlf))(defrule calcula-importe-segun-la-telefonica-BBT "calcula el importe en función del tipo de llamada, duración y dia y hora de BBT"


=> (if (eq ?tipo L) then

(bind ?importe 0.04) (if (and (>= ?dia 1) (<= ?dia 5) (>= ?hora 8) (< ?hora 20)) then

(bind ?importe (+ ?importe (* ?duracion 0.03)))) (if (and (>= ?dia 1) (<= ?dia 5) (or (>= ?hora 20) (< ?hora 8)))

then (bind ?importe (+ ?importe (* ?duracion 0.01)))) (if (and (>= ?dia 6) (<= ?dia 7)) then (bind ?importe (+ ?importe

(* ?duracion 0.01)))) )

(if (eq ?tipo I) then (bind ?importe 0.1) (if (and (>= ?dia 1) (<= ?dia 5) (>= ?hora 8) (< ?hora 22)) then

(bind ?importe (+ ?importe (* ?duracion 0.03)))) (if (and (>= ?dia 1) (<= ?dia 5) (or (>= ?hora 22) (< ?hora 8)))

then (bind ?importe (+ ?importe (* ?duracion 0.01)))) (if (and (>= ?dia 6) (<= ?dia 7)) then (bind ?importe (+ ?importe

(* ?duracion 0.01)))) ) (printout t crlf "El importe de la llamada tipo en BBT es: " ?importe

crlf crlf))

2da. Versión:

; Antes hemos resuelto este mismo problema con una reglas para cada telefonica que incluyen todas sus tarifas; Ahora lo resolveremos mediante una tabla sencilla. Se puede hacer más complejo, de forma que admita todas las ; posibilidades de tarifas (es un recomendable ejercicio). Pero esta es una solución intermedia.

(deftemplate llamada "Datos de la llamada tipo"(slot tipo-llamada (type SYMBOL))

(slot dia (type INTEGER)) (slot hora (type INTEGER))

(slot duracion (type INTEGER)))

(deftemplate tarifa "datos de cada telefonica"(slot telefonica (type SYMBOL))(slot tipo-llamada (type SYMBOL))(slot establecimiento-llamada (type FLOAT))(slot franquicia (type INTEGER))(slot inicio-noche-laborable (type INTEGER))(slot minuto-laborable-noche (type FLOAT))(slot inicio-dia-laborable (type INTEGER))(slot minuto-laborable-dia (type FLOAT))

(slot minuto-festivo (type FLOAT)))(deffacts tarifas-telefonicas "datos de las tarifas de las diferentes telefonicas"

(tarifa (telefonica AAT) (tipo-llamada L) (establecimiento-llamada 0.1) (franquicia 2)

(inicio-noche-laborable 18) (minuto-laborable-noche 0.01) (inicio-dia-laborable 8) (minuto-laborable-dia 0.02)(minuto-festivo 0.01))

(tarifa (telefonica AAT) (tipo-llamada I) (establecimiento-llamada 0.25) (franquicia 1)


(tarifa (telefonica BBT) (tipo-llamada L) (establecimiento-llamada 0.04) (franquicia 0)

(inicio-noche-laborable 20) (minuto-laborable-noche 0.03) (inicio-dia-laborable 8) (minuto-laborable-dia 0.01)

(minuto-festivo 0.01))

(tarifa (telefonica BBT) (tipo-llamada I) (establecimiento-llamada 0.1) (franquicia 0)


)

;*************************************


;******************************************** ;Regla que plantea de forma muy simple el menú de acciones que se desean FLOATizar:;origen, destino, y tipo de paquete;pregunta la urgencia del envío (urgente o no);si es paquete pide el peso

(defrule pide-datos "Pide los datos de la llamada"=>

(printout t crlf "Datos de la llamada tipo" crlf)(printout t crlf "Llamada Local (L) o Interprovincial (I)?: ")(bind ?tipo-llamada (read)) (printout t crlf "El dia habitual de la llamada (1 a 7)?: ")(bind ?dia (read)) (printout t crlf "La hora habitual de la llamada (1 a 24)?: ")(bind ?hora (read)) (printout t crlf "Duracion de la llamada: ")(bind ?duracion (read)) (assert (llamada (tipo-llamada ?tipo-llamada) (dia ?dia) (hora ?

hora) (duracion ?duracion))))

(defrule calcula-importe-segun-la-telefonica "calcula el importe en función del tipo de llamada, duración y dia y hora"


(tarifa (telefonica ?telefonica) (tipo-llamada ?tipo) (establecimiento-llamada ?est) (franquicia ?franquicia)

(inicio-noche-laborable ?inicio-noche-laborable) (minuto-laborable-noche ?minuto-laborable-noche)

(inicio-dia-laborable ?inicio-dia-laborable) (minuto-laborable-dia ?minuto-laborable-dia)

(minuto-festivo ?minuto-festivo)) => (bind ?importe ?est) (if (> ?duracion ?franquicia) then (bind ?duracion (- ?duracion ?franquicia))

(if (and (>= ?dia 1) (<= ?dia 5) (>= ?hora ?inicio-dia-laborable) (< ?hora ?inicio-noche-laborable)) then (bind ?importe (+ ?importe (* ?duracion 0.02))))

(if (and (>= ?dia 1) (<= ?dia 5) (or (>= ?hora ?inicio-noche-laborable) (< ?hora ?inicio-dia-laborable))) then (bind ?importe (+ ?importe (* ?duracion ?minuto-laborable-noche))))

(if (and (>= ?dia 6) (<= ?dia 7)) then (bind ?importe (+ ?importe (* ?duracion ?minuto-festivo))))

)

(printout t crlf "El importe de la llamada tipo en " ?telefonica " es: " ?importe crlf crlf))

Dentro del problema global de un juego de ajedrez:

1 Definir una plantilla "ficha" que sirva para almacenar los datos relativos a las diferentes piezas de ajedrez que se encuentran sobre el tablero: tipo de pieza, color y posición que ocupa.

2 Definir las reglas que sean necesarias para la generacion de todas las casillas del tablero, almacenándolas en hechos de la forma (casilla <i> <j>).

3 Definir las reglas que sean necesarias para eliminar las casillas que estén ocupadas. Asúmase para ello que se han generado los hechos del 3.1.

4 Definir las reglas que sean necesarias para eliminar las casillas que son amenazadas por alguna de las piezas blancas colocadas. Para simplificar, considerar únicamente amenazas procedentes de reyes, peones y torres.

5 Defina la regla/s para visualizar las casillas libres y no amenazadas.

Resolución del ejercicio

1

(deftemplate ficha

(slot tipo (type SYMBOL) (allowed-values peon torre alfil caballo rey reina))

(slot color (type SYMBOL) (allowed-values blanca negra))

(slot posicion_h (type INTEGER) (range 1 8))

(slot posicion_v (type INTEGER) (range 1 8)))

2

(defrule inicio(initial-fact)

=> (bind ?i 1)

(while (< ?i 9)(bind ?j 1)(while (< ?j 9)

(assert (casilla ?i ?j))(bind ?j (+ ?j 1))

)(bind ?i (+ ?i 1))

))

3

(defrule eliminar_ocupadas(ficha (posicion_h ?i) (posicion_v ?j))?ocupada <- (casilla ?i ?j)

=> (retract ?ocupada))

4

;el enunciado no diferencia, para eliminar las casillas amenazadas, ;de si trata de una amenaza blanca o negra sobre el contrario,;asumamos que las blancas avanzan en sentido creciente del indice del tablero

(defrule eliminar_amenazadas_peon(ficha (tipo peon)(color blanca) (posicion_h ?i) (posicion_v ?j))?amenazada <- (casilla ?k ?l)

(or (and (test(= ?l (+ ?i 1))) (test(= ?k (+ ?j 1))))(and (test(= ?l (- ?- 1))) (test(= ?k (+ ?j 1))))

) => (retract ?amenazada)

)

;la siguiente regla podría haberse diferenciado en 8(defrule eliminar_amenazadas_rey

(ficha (tipo rey)(color blanca) (posicion_h ?i) (posicion_v ?j))?amenazada <- (casilla ?k ?l)(or (and (test(= ?l (+ ?j 1))) (test (= ?k ?i)))

(and (test(= ?l (- ?j 1))) (test (= ?k ?i)))(and (test(= ?l ?j)) (test (= ?k (+ ?i 1))))(and (test(= ?l ?j)) (test (= ?k (- ?i 1))))(and (test(= ?l (+ ?j 1))) (test(= ?k (+ ?i 1))))(and (test(= ?l (+ ?j 1))) (test(= ?k (- ?i 1))))(and (test(= ?l (- ?j 1))) (test(= ?k (+ ?i 1))))(and (test(= ?l (- ?j 1))) (test(= ?k (- ?i 1))))

) => (retract ?amenazada)

)

; para eliminar las celdas amenazadas por la torre(defrule eliminar_amenazadas_torre_1

(ficha (tipo torre)(color blanca) (posicion_h ?i) (posicion_v ?j))?amenazada <- (casilla ?i ?k)(test (> ?k ?j))=> (retract ?amenazada)

)

;Esta solución pasa por alto la posibilidad de que alguna ficha, ;en la misma columna que la torre "amenazante", impida que la torre ;amenace el resto posterior de la columna. Para solucionar esto, lo más práctico;sería diferencia entre celda ocupada y celda simplemente amenazada.

5

(defrule mensaje

(declare (salience -10))

=>

(printout t "Han quedado libres las siguientes casillas" crlf))

(defrule casillas


(casilla ?i ?j)

=>

(printout t "(" ?i " , " ?j ") "))

(defrule terminacion


=>

(printout t crlf))

Se dispone de dos cántaros de agua, uno de 4 litros y otro de 3 litros de capacidad, siendo ésta la única información que se tiene de los mismos. Existe una bomba de agua con la que se pueden llenar los cántaros. Se desea que el cántaro de 4 ls. de capacidad quede lleno por la mitad y el de 3 ls. vacío. Este es un ejemplo planteable como problema de búsqueda en un espacio de estados. Este espacio consistiría del conjunto de pares de enteros (x, y), tal que x = 0, 1, 2, 3 o 4 e y = 0, 1, 2 o 3, donde x e y representan el número de litros de agua que hay en los cántaros de 4 y 3 litros respectivamente. Se considerará que el estado inicial es (0, 0) y el estado meta (2, 0). En cuanto a los operadores que se pueden aplicar a los estados descritos con anterioridad, pueden definirse los siguientes:

a. Llenar el cántaro de 4 ls.: Si (x, y) and x < 4 entonces (4, y)

b. Llenar el cántaro de 3 ls.: Si (x, y) and y < 3 entonces (x, 3)

c. Vaciar en el suelo el cántaro de 4 l.: Si (x, y) and x > 0 entonces (0, y)

d. Vaciar en el suelo el cántaro de 3 ls.: Si (x, y) and y > 0 (x, 0)

e. Verter agua del cántaro de 3 ls. al de 4 hasta llenarlo: Si (x, y) and x + y 4 and y > 0 and x < 4 entonces (4, y (4 x))

f. Verter agua del cántaro de 4 ls. al de 3 hasta llenarlo: Si (x, y) and si x + y 3 and x > 0 and y < 3 entonces (x (3 y), 3)

g. Verter todo el agua del cántaro de 3 ls. al de 4: Si (x, y) and x + y 4 and y > 0 entonces (x + y, 0)

h. Verter todo el agua del cántaro de 4 ls. al de 3: Si (x, y) and x + y 3 and x > 0 entonces (0, x + y)

¿Cómo llevarías a un programa Clips la resolución de este problema, considerada la solución del mismo como la obtención de un hecho que represente la distribución de litros planteada como objetivo desde el hecho que representa la distribución inicial?

1. ¿Cómo representaría el contenido y capacidad de las jarras?

2. ¿Y de los operadores?

3. ¿Cómo determinarías el final del proceso?

4. ¿Podría (y cómo) generalizarse la resolución para una jarra A de capacidad A1 y otra jarra B con capacidad B1 y obtener A2 litros en la primera y B2 litros en la segunda? ¿podría plantearse algún dificultad en la resolución?

5. La verdadera resolución de este tipo de problemas es encontrar y mostrar (imprimir, por ejemplo) la secuencia de operadores que conducen al objetivo. ¿Cómo podría hacerse aquí?

Resolución del ejercicio.

(deftemplate cantaros(slot profundidad (type INTEGER) (range 1 ?VARIABLE))

(slot padre (type FACT-ADDRESS SYMBOL) (allowed-symbols sin-padre))(slot contenido_4 (type INTEGER))(slot contenido_3 (type INTEGER)(ultimo_mov (type STRING))

)

(deffacts cantaros_inicio (cantaros (contenido_4 0) (contenido_3 0)))

(defrule llena_4 (declare (salience 510)) ?h <- (cantaros (profundidad ?pf) (padre ?p) (contenido_4 ?c4&:(< ?c4 4)) (contenido_3 ?c3))

=> (assert (cantaros

(profundidad (+ 1 ?pf)) (padre ?h)(contenido_4 4) (contenido_3 ?c3)(ultimo_mov "llena 4)))

(printout t "llena_4" crlf))

(defrule llena_3 (declare (salience 510)) ?h <- (cantaros (profundidad ?pf) (padre ?p) (contenido_4 ?c4) (contenido_3 ?c3&:(< ?c3 3))) => (assert (cantaros (profundidad (+ 1 ?pf)) (padre ?h) (contenido_4 ?c4) (contenido_3 3))) (printout t "llena_3" crlf))

(defrule vacia_4 (declare (salience 500)) ?h <- (cantaros (profundidad ?pf) (padre ?p) (contenido_4 ?c4&:(> ?c4 0)) (contenido_3 ?c3)) => (assert (cantaros (profundidad (+ 1 ?pf)) (padre ?h) (contenido_4 0)(contenido_3 ?c3))) (printout t "vacia_4" crlf))

(defrule vacia_3 (declare (salience 500)) ?h <- (cantaros (profundidad ?pf) (padre ?p) (contenido_4 ?c4)(contenido_3 ?c3&:(> ?c3 0))) => (assert (cantaros (profundidad (+ 1 ?pf)) (padre ?h) (contenido_4 ?c4) (contenido_3 0))) (printout t "vacia_3" crlf))

(defrule llenar_3_con_4 (declare (salience 515)) ?h <- (cantaros (profundidad ?pf) (padre ?p) (contenido_4 ?c4&:(> ?c4 0)) (contenido_3 ?c3&:(< ?c3 3))) (test (>= (+ ?c3 ?c4) 3)) => (assert (cantaros (profundidad (+ 1 ?pf)) (padre ?h) (contenido_4 (- ?c4 (- 3 ?c3))) (contenido_3 3))) (printout t "llenar_3_con_4" crlf))(defrule llenar_4_con_3 (declare (salience 515)) ?h <- (cantaros (profundidad ?pf) (padre ?p) (contenido_4 ?c4&:(< ?c4 4)) (contenido_3 ?c3&:(> ?c3 0))) (test (>= (+ ?c3 ?c4) 4)) => (assert (cantaros (profundidad (+ 1 ?pf)) (padre ?h) (contenido_4 4) (contenido_3 (- ?c3 (- 4 ?c4))))) (printout t "llenar_4_con_3" crlf))(defrule verter_3_en_4 (declare (salience 515))

?h <- (cantaros (profundidad ?pf) (padre ?p) (contenido_4 ?c4&:(< ?c4 4)) (contenido_3 ?c3&:(> ?c3 0))) (test (< (+ ?c3 ?c4) 4)) => (assert (cantaros (profundidad (+ 1 ?pf)) (padre ?h) (contenido_4 (+ ?c4 ?c3)) (contenido_3 0))) (printout t "verter_3_en_4" crlf))(defrule verter_4_en_3 (declare (salience 515)) ?h <- (cantaros (profundidad ?pf) (padre ?p) (contenido_4 ?c4&:(> ?c4 0)) (contenido_3 ?c3&:(< ?c3 3))) (test (< (+ ?c3 ?c4) 4)) (printout t "verter_4_en_3" crlf) => (assert (cantaros (profundidad (+ 1 ?pf)) (padre ?h) (contenido_4 0) (contenido_3 (+ ?c4 ?c3)))))

(defrule elimina-circularidad (declare (salience 520)) (cantaros (profundidad ?pf1) (contenido_4 ?c4) (contenido_3 ?c3)) ?h <-(cantaros (profundidad ?pf2&:(< ?pf1 ?pf2)) (contenido_4 ?c4) (contenido_3 ?c3)) => (retract ?h))

(defrule finaliza (declare (salience 520)) (cantaros (contenido_4 2) (contenido_3 0)) => (printout t "Conseguido" crlf) (halt)

)

Las siguientes reglas de sustitución de símbolos pueden usarse para reemplazar la cifra de la izquierda por la tira de cifras a su derecha:

2 11 3 21 4 31 5 32

Codificar en Clips un sistema que permita la traducción de un número compuesto de varias cifras (del 1 al 5) según las reglas anteriores.

Para ello podrían ser útiles las siguientes funciones:

(str-index <strig-expression> <string-expression>): devuelve la posición del primer string dentro del segundo.

(sub-string <integer-1-expression> <integer-2-expression> <string-expression>): devuelve la porción del string que comienza en la posición integer-1 y termina en la posición integer-1 + integer-2.

(str-cat <string-expression>*) : Concatena los strings argumento


(deffacts datos-a-traducir (vector 3 2 1)

(tabla 2 1 1)(tabla 3 2 1)(tabla 4 3 1)

)

(defrule traduce ?cadena <- (vector $?ini ?x $?fin) (tabla ?x ?y1 ?y2) => (retract ?cadena) (assert (vector $?ini ?y1 ?y2 $?fin)))

(defrule imprime-cadenas (vector $?datos) => (printout t "una salida es: "$?datos crlf))

Una solución alternativa:

(deftemplate traduccion (slot numero (type STRING)))

(deftemplate cifra (slot entrada) (slot salida))

(deffacts entrada_salida (traduccion (numero "0")))

(deffacts tabla-traduccion(cifra (entrada "2") (salida "11"))(cifra (entrada "3") (salida "21"))(cifra (entrada "4") (salida "31"))

)

(defrule pide_valor?f1 <- (traduccion (numero "0"))

=>(printout t "Introduzca numero: " crlf)(modify ?f1 ( numero (read))))

(defrule traduce_i

(cifra (entrada ?i)(salida ?o))?f1 <- (traduccion (numero ?numero))(test (neq (str-index ?i ?numero) FALSE ))

=>(bind ?long (str-length ?numero))(bind ?posicion (str-index ?i ?numero))(bind ?numero (str-cat (sub-string 1 (- ?posicion 1) ?numero) ?o (sub-

string (+ ?posicion 1) ?long ?numero))) (printout t "una salida es: " ?numero crlf)

(modify ?f1 (numero ?numero)))

Dados los datos del siguiente esquema,

codificar en Clips un sistema que permita inferir:

Si una persona tiene un cónyuge que está vivo, entre sus herederos se incluirá al cónyuge.

Si una persona tiene hijos que están vivos, estos se incluirán entre sus herederos.

Si una persona tiene un descendiente (hijo) que tiene hijos, los hijos del descendiente serán sus herederos siempre que el cónyuge y sus hijos hayan fallecido.

Si una persona no tiene hijos ni cónyuge ni padres vivos, sus herederos serán los herederos de sus padres.


(deftemplate persona (slot id (type SYMBOL)) (slot nombre (type STRING)) (slot apellidos (type STRING)) (slot conyuge (type SYMBOL)) ; Id del cónyuge (multislot padres (type SYMBOL) (cardinality 2 2)) ; Ids de los padres (multislot hijos (type SYMBOL)) ; Ids de los hijos (slot vivo (allowed-values SI NO) (default SI)))

Se han insertado como vivas a las siguientes personas: (deffacts arbol-genealogico (persona (id juan) (nombre "Juan") (apellidos "Rodríguez") (conyuge ana) (hijos elena javier) (vivo NO)) (persona (id ana) (nombre "Ana") (apellidos "López") (conyuge juan) (hijos elena javier)

(vivo NO)) (persona (id jose) (nombre "José") (apellidos "Pérez") (conyuge elena) (hijos jaime belen alba) (vivo NO)) (persona (id elena) (nombre "Elena") (apellidos "Rodríguez") (conyuge jose) (padres juan ana) (hijos jaime belen alba) (vivo NO)) (persona (id javier) (nombre "Javier") (apellidos "Rodríguez") (conyuge eva) (padres juan ana) (hijos rut mar) (vivo NO)) (persona (id eva) (nombre "Eva") (apellidos "García") (conyuge javier) (hijos rut mar)) (persona (id jaime) (nombre "Jaime") (apellidos "Pérez") (padres jose elena) (vivo NO)) (persona (id belen) (nombre "Belén") (apellidos "Pérez") (padres jose elena)) (persona (id alba) (nombre "Alba") (apellidos "Pérez") (padres jose elena)) (persona (id rut) (nombre "Rut") (apellidos "Rodríguez") (padres javier eva)) (persona (id mar) (nombre "Mar") (apellidos "Rodríguez") (padres javier eva) (vivo NO)))

; Secuenciación de tareas de búsqueda de herederos(deffacts secuencia-tareas (siguiente buscar-conyuge buscar-hijo)

(siguiente buscar-hijo buscar-nieto) (siguiente buscar-nieto buscar-padre) (siguiente buscar-padre buscar-herederos-padres) (siguiente buscar-herederos-padres sin-herederos))

;; REGLAS "EXPERTAS";

; Inicialización. Calcularemos los herederos para cada persona fallecida(defrule inicializar (persona (id ?id) (vivo NO)) => (assert (tarea buscar-conyuge ?id)))

; Si el conyuge está vivo, formará parte de sus herederos(defrule buscar-conyuge (tarea buscar-conyuge ?id) (persona (id ?id) (conyuge ?id-conyuge)) (persona (id ?id-conyuge) (vivo SI)) => (assert (heredero ?id ?id-conyuge)))

; Los hijos vivos, formarán parte de sus herederos(defrule buscar-hijo (tarea buscar-hijo ?id) (persona (id ?id) (hijos $?hijos)) (persona (id ?id-hijo&: (member$ ?id-hijo $?hijos)) (vivo SI)) => (assert (heredero ?id ?id-hijo)))

; Si el cónyuge y todos los hijos han muerto, heredarán sus nietos(defrule buscar-nieto (tarea buscar-nieto ?id) (persona (id ?id) (conyuge ?id-conyuge) (hijos $?hijos)) (persona (id ?id-conyuge) (vivo NO)) (forall (persona (id ?id-hijo&: (member$ ?id-hijo $?hijos))) (persona (id ?id-hijo) (vivo NO))) (persona (id ?id-hijo) (hijos $?nietos)) (persona (id ?id-nieto&: (member$ ?id-nieto $?nietos)) (vivo SI)) => (assert (heredero ?id ?id-nieto)))

; Si no tiene cónyuge ni hijos, heredarán sus padres vivos(defrule buscar-padre (tarea buscar-padre ?id) (persona (id ?id) (conyuge nil) (hijos) (padres $?padres)) (persona (id ?id-padre&: (member$ ?id-padre $?padres)) (vivo SI)) => (assert (heredero ?id ?id-padre)))

; Lo mismo si el cónyuge, todos los hijos y nietos han muerto(defrule buscar-padre2 (tarea buscar-padre ?id) (persona (id ?id) (conyuge ?id-conyuge) (hijos $?hijos) (padres $?padres)) (not (heredero ?id ?)) (persona (id ?id-padre&: (member$ ?id-padre $?padres)) (vivo SI)) => (assert (heredero ?id ?id-padre)))

; Finalmente, si no tiene cónyuge, ni hijos, y sus padres se conocen pero han muerto, ; heredarán los herederos de sus padres(defrule buscar-herederos-padres (tarea buscar-herederos-padres ?id) (persona (id ?id) (conyuge nil) (hijos) (padres $?padres)) (forall (persona (id ?id-padre&: (member$ ?id-padre $?padres))) (persona (id ?id-padre) (vivo NO))) (heredero ?id-padre&: (member$ ?id-padre $?padres) ?heredero-padre& ~Estado) => (assert (heredero ?id ?heredero-padre)))

; Lo mismo si el cónyuge, todos los hijos, nietos y padres han muerto(defrule buscar-herederos-padres2 (tarea buscar-herederos-padres ?id) (persona (id ?id) (conyuge ?id-conyuge) (hijos $?hijos) (padres $?padres)) (not (heredero ?id ?)) (forall (persona (id ?id-padre&: (member$ ?id-padre $?padres))) (persona (id ?id-padre) (vivo NO))) (heredero ?id-padre&: (member$ ?id-padre $?padres) ?heredero-padre& ~Estado) => (assert (heredero ?id ?heredero-padre)))

; Para las personas sin herederos, el Estado se queda con la herencia(defrule sin-herederos (tarea sin-herederos ?id) (not (heredero ?id ?)) => (assert (heredero ?id Estado)))

;; REGLAS DE CONTROL;

; Regla con prioridad baja para cambiar de tarea según la secuenciación establecida ; en la base de hechos(defrule siguiente-tarea (declare (salience -100)) ?t <- (tarea ?tarea ?id) (siguiente ?tarea ?siguiente) => (retract ?t) (assert (tarea ?siguiente ?id)))

; Elimina la última tarea de la base de hechos cuando finaliza(defrule ultima-tarea (declare (salience -100)) ?t <- (tarea ?tarea ?id) (not (siguiente ?tarea ?siguiente)) => (retract ?t))

Se desea desarrollar un sistema basado en conocimiento en Clips para la determinación de la terapia adecuada a los síntomas encontrados en el paciente. Para ello se dispone del conocimiento recogido en la siguiente tabla. En ella tenemos una columna para las infecciones, que tienen asociada una terapia genérica (por ejemplo paperas tiene asociada una "terapia de paperas genérica") que en algunos casos se particulariza con alguna otra indicación (por ejemplo para las paperas de adultos).

Infección Síntomas Terapia específica

Rubeola Fiebre de 3 días, glándulas inflamadas y salpullido

Paperas Fiebre, sudor, glándulas inflamadas y sin salpullido Suero inmunológico solo para adultos

Sarampión Fiebre, ojos llorosos, manchas de Koplik, tos y salpullido.

Ganmaglobulina para adultos no mayores de 65 años

Sarampión alemán Fiebre, ojos llorosos, manchas rosadas, tos, glándulas inflamadas en la nuca e inflamación de oído.

Ganmaglobulina si la paciente esta embarazada.

Varicela Fiebre, costras y picazón.

Escarlatina Fiebre, dolor de cabeza, vómitos, salpullido rojo y dolor al tragar.

Penicilina para no alérgicos


Desde luego hay otras formas de resolver el problema e incluso con algo más de estructura en el código, o incluso ahorrando código, pero esta propuesta puede ser aceptable. Los datos iniciales del paciente se introducen como hechos iniciales y se pregunta al usuario por datos complementarios cuando estos son necesarios.

(deftemplate paciente(slot adulto (type SYMBOL) (allowed-values SI NO NONE) (default NONE) )(slot adulto_mayor (type SYMBOL) (allowed-values SI NO NONE) (default

NONE))(slot sexo (type SYMBOL) (allowed-values MASCULINO FEMENINO NONE) (default

NONE))(slot sudor (type SYMBOL) (allowed-values SI NO NONE) (default NONE))(slot embarazada (type SYMBOL) (allowed-values SI NO NONE) (default NONE))(slot fiebre (type SYMBOL) (allowed-values SI NO NONE) (default NONE))(slot fiebre_mas_3_dias (type SYMBOL) (allowed-values SI NO NONE) (default

NONE))(slot glandulas_inflamadas (type SYMBOL) (allowed-values SI NO NONE)

(default NONE))(slot salpullido (type SYMBOL) (allowed-values SI NO) (default NO))(slot ojos_llorosos (type SYMBOL) (allowed-values SI NO NONE) (default

NONE))(slot manchas_Koplik (type SYMBOL) (allowed-values SI NO NONE) (default

NONE))(slot tos (type SYMBOL) (allowed-values SI NO NONE) (default NONE))(slot manchas_rosadas (type SYMBOL) (allowed-values SI NO NONE) (default

NONE))(slot glandulas_inflamadas_nuca (type SYMBOL) (allowed-values SI NO NONE)

(default NONE))(slot inflamacion_oido (type SYMBOL) (allowed-values SI NO NONE) (default

NONE))(slot costras (type SYMBOL) (allowed-values SI NO NONE) (default NONE))(slot picazon (type SYMBOL) (allowed-values SI NO NONE) (default NONE))(slot dolor_cabeza (type SYMBOL) (allowed-values SI NO NONE) (default

NONE))(slot vomitos (type SYMBOL) (allowed-values SI NO NONE) (default NONE))

(slot salpullido_rojo (type SYMBOL) (allowed-values SI NO NONE) (default NONE))

(slot dolor_tragar (type SYMBOL) (allowed-values SI NO NONE) (default NONE))

(slot alergico_penicilina (type SYMBOL) (allowed-values SI NO NONE) (default NONE))

(slot tipo_infeccion (type SYMBOL)(default NONE))(slot terapia_especifica (type SYMBOL)(default NONE))

)

(deffacts datos_paciente(paciente

(adulto SI) (sexo FEMENINO)

(fiebre SI)(ojos_llorosos SI)(manchas_rosadas SI)(tos SI)(glandulas_inflamadas_nuca SI)(inflamacion_oido SI)

))

(defrule dias_fiebre?paciente <-(paciente (fiebre SI)

(glandulas_inflamadas SI) (salpullido SI) (fiebre_mas_3_dias NONE)

) => (printout t crlf "Mas de 3 dias de fiebre? ")

(modify ?paciente (fiebre_mas_3_dias (read))))(defrule pide_salpullido

?salpullido <- (paciente (salpullido SI) (dolor_cabeza SI) (vomitos SI) (dolor_tragar SI)(salpullido_rojo NONE)

) => (printout t "El salpullido es rojo? ")

(modify ?salpullido (salpullido_rojo (read))) (printout t crlf))(defrule adulto_mayor

?adulto <-(paciente (adulto SI)(tipo_infeccion sarampion) (adulto_mayor NONE)

) => (printout t crlf "Mas de 65 años? ")

(modify ?adulto (adulto_mayor (read))))

(defrule embarazada?sexo <-(paciente (sexo FEMENINO)

(tipo_infeccion sarampion_aleman)(embarazada NONE)

) =>

(printout t crlf "Se encuentra embarazada? ")(modify ?sexo (embarazada (read)))

)(defrule rubeola

?paciente <-(paciente (fiebre_mas_3_dias SI )(glandulas_inflamadas SI) (salpullido SI)(tipo_infeccion NONE)

) =>

(modify ?paciente (tipo_infeccion rubeola))(printout t crlf "tiene rubeola")

)(defrule paperas

?paciente <-(paciente (fiebre SI ) (sudor SI)(glandulas_inflamadas SI) (salpullido NO)(tipo_infeccion NONE)

) =>

(modify ?paciente (tipo_infeccion paperas))(printout t crlf "tiene paperas")

)(defrule sarampion

?paciente <-(paciente (fiebre SI ) (ojos_llorosos SI)(manchas_Koplik SI) (tos SI)(salpullido SI)(tipo_infeccion NONE)

) =>

(modify ?paciente (tipo_infeccion sarampion))(printout t crlf "tiene sarampion")

)(defrule sarampion_aleman

?paciente <-(paciente (fiebre SI ) (ojos_llorosos SI)(manchas_rosadas SI) (glandulas_inflamadas_nuca SI)(inflamacion_oido SI)(tipo_infeccion NONE)

) =>

(modify ?paciente (tipo_infeccion sarampion_aleman))(printout t crlf "tiene sarampion aleman")

)(defrule varicela

?paciente <-(paciente (fiebre SI ) (costras SI)(picazon SI) (tos SI)(tipo_infeccion NONE)

) =>

(modify ?paciente (tipo_infeccion varicela))(printout t crlf "tiene varicela" crlf)

)(defrule escarlatina

?paciente <-(paciente (fiebre SI )

(dolor_cabeza SI)(vomitos SI) (salpullido_rojo SI)(dolor_tragar SI)(tipo_infeccion NONE)

) =>

(modify ?paciente (tipo_infeccion escarlatina))(printout t crlf "tiene escarlatina" crlf)

)(defrule suero_paperas_adultos

?paciente <-(paciente (tipo_infeccion paperas ) (adulto SI)(terapia_especifica NONE)

) =>

(modify ?paciente (terapia_especifica suero_inmunologico))(printout t crlf "terapia especifica: suero_inmunologico" crlf)

)(defrule ganma_sarampion_menores

?paciente <-(paciente (tipo_infeccion sarampion) (adulto_mayor NO)(terapia_especifica NONE)

) =>

(modify ?paciente (terapia_especifica ganmaglobulina))(printout t crlf "terapia especifica: ganmaglobulina" crlf)

)(defrule ganma_sarampion_aleman_embarazada

?paciente <-(paciente (tipo_infeccion sarampion_aleman) (embarazada SI)(terapia_especifica NONE)

) =>

(modify ?paciente (terapia_especifica ganmaglobulina))(printout t crlf "terapia especifica: ganmaglobulina" crlf)

)(defrule penicilina_escarlatina_no_alergicos

?paciente <-(paciente (tipo_infeccion escarlatina) (alergico_penicilina NO)(terapia_especifica NONE)

) =>

(modify ?paciente (terapia_especifica penicilina))(printout t crlf "terapia especifica: penicilina" crlf)

)

Download - Soluciones CLIPS

Top Related