Академический Документы
Профессиональный Документы
Культура Документы
Al combinar objetivos simples podemos construir queries complejos. Por ejemplo: Deseamos saber si hay algo que se pueda comer en la cocina. En prolog debemos preguntar: ?- location(X, kitchen), edible(X). Un query complejo tiene una conjuncin de ojetivos, el carcter (,) se toma como un operador and. En forma lgica: Existe una X tal que X est localizada en la cocina y adems sea comible? El query tendr xito si existe un valor de X que satisfaga los dos objetivos.
Inteligencia Artificial
3.1
(cont.)
El nombre de la variable de un query (e.g. X) no tiene significado para otro query o hecho. Se dice que el alcance (scope) de una variable es un query.
Inteligencia Artificial
3.2
Interpretacin Procedural
Inteligencia Artificial
3.3
Usando Puertos
Un query compuesto inicia llamando el primer objetivo desde la izquierda. Si tiene xito, se llama al siguiente objetivo utilizando la variable que conect durante el objetivo anterior. Si el query termina via el puerto exit del objetivo de ms a la derecha, entonces tiene xito y el listener reporta los valores conectados. Si el usuario teclea (;) despus de una respusta, el query se reinicia a travs del puerto redo del objetivo de ms a la derecha. Slo el valor de la variable que conect en este objetivo se desconecta Si el query termina via el puert fail del objetivo de ms a la izquierda, entonces el query falla.
Inteligencia Artificial
3.4
Debugger
?- location(X, kitchen), edible(X). El seguimiento del query contiene un nmero en la primer columna con el que indica el objetivo sobre el cual est trabajando Primero se llama al objetivo location(X, kitchen), se indica que el patrn coincide con la segunda clusula location. 1 CALL location(X, kitchen) Esta llamada tiene xito, por lo cual X conecta con apple.
1 EXIT (2)location(apple, kitchen) Enseguida se llama al segundo objetivo edible(X). X ahora est conectada con apple, se llama entonces a edible(apple).
2 CALL edible(apple)
Inteligencia Artificial
3.5
(cont.)
Esta llamada edible(apple) tiene xito en la primera clusula de edible/1, entonces el query tine xito 2 EXIT (1) edible(apple) X = apple ; Tecleando (;) causa que el listener haga backtrack hacia el objetivo de ms a la derecha. 2 REDO edible(apple) Se trata nuevamente el objetivo dos, pero no existe calusula que coincida con el patrn obejtivo. 2 FAIL edible(apple) Cuando se sale por el puerto fail del segundo objetivo se provoca la entrada al primer objetivo via su puerto redo. De esta manera, se deconect X del valor anterior. 1 REDO location(X, kitchen) Tiene xito en la clusula sexta, conceca X con broccoli.
Inteligencia Artificial
3.6
(cont.)
1 EXIT (6) location(broccoli, kitchen) El segundo objetivo se llama con el nuevo valor que conect X. Este segundo objetivo es nuevo, por lo que se inicia la bsqueda desde la primer clusula 2 CALL edible(broccoli) No existe clusula que coincida con edible(broccoli), asi que falla. 2 FAIL edible(broccoli) Ahora, el primer objetivo se reinicia via su puerto redo, deconectndose la variable X. 1 REDO location(X, kitchen) Esta llamada tine xito conectando X a un nuevo valor. 1 EXIT (7) location(crackers, kitchen) Esto va a producir una segunda solucin al query.
Inteligencia Artificial
3.7
(cont.)
2 CALL edible(crackers) 2 EXIT (2) edible(crackers) X = crackers ; Tecleando (;) inicia el bactracking de nuevo, falla para ambos objetivos y produce la falla total del query. 2 REDO edible(crackers)
2 FAIL edible(crackers)
1 REDO location(X, kitchen) 1 FAIL location(X, kitchen)
no
Inteligencia Artificial
3.8
Inteligencia Artificial
3.9
Debugger
Goal: door(kitchen, R), location(T,R) 1 CALL door(kitchen, R) 1 EXIT (2) door(kitchen, office) 2 CALL location(T, office) 2 EXIT (1) location(desk, office) R = office
T = desk ;
2 REDO location(T, office) 2 EXIT (8) location(computer, office) R = office T = computer ; 2 REDO location(T, office)
Inteligencia Artificial
3.10
(cont.)
2 FAIL location(T, office)
1 REDO door(kitchen, R) 1 EXIT (4) door(kitchen, cellar) 2 CALL location(T, cellar)
Inteligencia Artificial
3.11
Predicados Evaluables
Prolog tiene un formato propio para darnos resultados, pero ahora podremos hacer que la salida de un query tenga un cierto formato personal deseado. Ejemplo: Formular un query que liste todas las cosas que estn en la cocina. Un predicado evaluado est predefinido por Prolog, quiere decir que no existe una clusula en la base de datos lgica para este tipo de predicados. Prolog llama a un procedimiento predefinido cuando encuentra una coincidencia con el patrn de un predicado evaluable.
Inteligencia Artificial
3.12
(cont.)
Los predicados evaluables son escritos en el lenguaje con el que se escribi el listener. Normalmente son funciones que nada tienen que ver con programas lgicos, por ejemplo escribir en la consola. Algunas veces son llamados predicados extra lgicos. Estos predicados debern responder a un call por la parte izquierda y a un redo por la parte derecha. La respuesta en el caso de un redo, se conoce como su comportamiento en backtracking.
Inteligencia Artificial
3.13
SOCRATES TORRES:
write/1 Este predicado siempre tiene xito cuando es llamado, como efecto lateral escribe su argumento en la consola. Backtracking no deshace su efecto lateral. nl/0 Tiene xito, y empieza una nueva lnea. Igual que write, siempre tiene xito cuando es llamado y falla en backtracking. Tab/1 Espera un argumento tipo integer, escribe ese nmero de espacios en blanco. xito cuando se llama, falla en bactracking.
Inteligencia Artificial
3.14
Inteligencia Artificial
3.15
Nunca cambian la direccin del flujo de control. Si obtienen el control desde el lado izq. lo pasan al lado der. Si obtienen el control desde el lado der. lo pasan al lado izq.
Inteligencia Artificial
3.16
Obtiene el control siempre desde el lado izquierdo, e inmediatamente regresa el control a tarvs del puerto fail, el control lo pasa al puerto redo del objetivo situado a su izquierda. Tiene el mismo efecto (;), aunque este ltimo lo introduciamos manualmente.
Inteligencia Artificial
3.17
Listar todo lo que se encuentra en la cocina usando predicados de I/O y el predicado fail.
apple
broccoli crackers
no
Inteligencia Artificial
3.18
Inteligencia Artificial
3.19
Debugger
Goal: location(X, kitchen), write(X), nl, fail. 1 CALL location(X, kitchen) 1 EXIT (2) location(apple, kitchen) 2 CALL write(apple) apple 2 EXIT write(apple) 3 CALL nl 3 EXIT nl 4 CALL fail 4 FAIL fail 3 REDO nl
3 FAIL nl
2 REDO write(apple) 2 FAIL write(apple)
Inteligencia Artificial
3.20
(cont)
1 REDO location(X, kitchen)
4 FAIL fail
3 REDO nl 3 FAIL nl 2 REDO write(broccoli)
2 FAIL write(broccoli)
Inteligencia Artificial
3.21
(cont.)
1 REDO location(X, kitchen) 1 EXIT (7) location(crackers, kitchen) 2 CALL write(crackers) crackers 2 EXIT write(crackers) 3 CALL nl 3 EXIT nl 4 CALL fail 4 FAIL fail 3 REDO nl 3 FAIL nl
2 REDO write(crackers)
2 FAIL write(crackers) 1 REDO location(X, kitchen) 1 FAIL location(X, kitchen) no
Inteligencia Artificial 3.22 Dr. Scrates Torres Ovalle
Ejercicios
Considera la siguiente base lgica
easy(1). easy(2). easy(3). Predice los resultados a los siguientes queries, luego trata con Prolog ?- gizmo(a,X),easy(X). ?- gizmo(c,X),easy(X). ?- gizmo(d,Z),easy(Z). ?- easy(Y),gizmo(X,Y). ?- write('report'), nl, easy(T), write(T), gizmo(M,T), tab(2), write(M), fail.
gizmo(a,1).
gizmo(b,3). gizmo(a,2). gizmo(d,5).
gizmo(c,3).
gizmo(a,3). gizmo(c,4). harder(a,1). harder(c,X). harder(b,4). harder(d,2).
Inteligencia Artificial
3.23
Tarea
Nani Search Experimenta con los queries que hemos visto. Predice los resultados para el siguiente query, luego trata con Prolog:
Inteligencia Artificial
3.24
Tarea
Family Los queries complejos pueden ser usados para encontrar algn tipo de relacin entre personas. Por ejemplo, encontrar la madre de alguien. ?- parent(X, someone), female(X).
Escribe queries similares para padtres, hijos, e hijas. Utiliza el debugger para seguir el comportamiento des estos queries.
Expermineta cambiando el orden de los objetivos de los queries ?- parent(X, someone), female(X).
Inteligencia Artificial
3.25
Reglas
Un predicado es definido por clusulas. Las clusulas pueden ser hechos o reglas. La sintaxis de una reglas es: cabeza :- cuerpo. donde cabeza es la defincin del predicado (igual que un hecho). :- es el smbolo neck, se lee como if. cuerpo es uno o ms objetivos (un query).
Inteligencia Artificial
3.26
Ejemplo de Reglas
El query compuesto que encuentra dnde se encuentran las cosas que se pueden comer puede ser formulado como una Regla: abuelo(X,Z):papa(X,Y), papa(Y,Z), mujer(X). where_food(X,Y) :location(X,Y), edible(X).
Se podra leer como Hay algo X que se puede comer en la habitacin Y si X est localizada en Y, y X es comible
3.27 Dr. Scrates Torres Ovalle
Inteligencia Artificial
Uso de la Regla
Ahora podemos usar la regla mediante un query: ?- where_food(X, kitchen). X = apple ; X = crackers ; no ?- where_food(Thing, 'dining room'). no
Inteligencia Artificial
3.28
(cont)
O que nos diga todas las cosas comibles que hay en cada habitacin: ?- where_food(Thing, Room).
Thing = apple
Room = kitchen ; Thing = crackers
Room = kitchen ;
no
Inteligencia Artificial
3.29
location(X,Y),
edible(X). where_food(X,Y) :location(X,Y), tastes_yucky(X).
Inteligencia Artificial
3.30
Inteligencia Artificial
3.31
Respecto a reglas, Prolog trata de unificar el patrn objetivo con la cabeza de la regla. Si la unificacin tiene xito, entonces Prolog inicia un nuevo query usando los objetivos en el cuerpo de la clusula. Las reglas producen queries de mltiples niveles. El primer nivel corresponde al objetivo original. El siguiente nivel corresponde a un nuevo query compuesto por los objetivos del cuerpo en la clusula del primer nivel. Cada nivel puede producir niveles ms profundos. Tericamente esto se repite hasta el infinito. En practica esto continua hasta que el listener se queda sin espacio de memoria.
Inteligencia Artificial
3.32
El backtracking del tercr objetivo del tercer nivel se dirije hacia el segundo nivel.
2-1, Dos indica el nivel del query, uno el objetivo dentro del query
Inteligencia Artificial
3.33
1-1 try (1) where_food(X, kitchen) Ahora el cuerpo de la primera clusula se toma como query y continua la bsqueda.
2-1 CALL location(X, kitchen) Desde este punto, la bsqueda continua como se hizo para un query complejo. 2-1 EXIT (2) location(apple, kitchen) 2-2 CALL edible(apple)
edible(X). where_food(X,Y) :location(X,Y), tastes_yucky(X). where_food(X,Y) :location(X,Y),
Inteligencia Artificial
3.34
(cont.)
Dado que el cuerpo ha tenido xito, el objetivo del nivel previo (primero) tiene xito tambin. 1-1 EXIT (1) where_food(apple, kitchen)
X = apple ;
El backtracking se dirige del objetivo del primer nivel, al objetivo del segundo nivel 1-1 REDO where_food(X, kitchen) 2-2 REDO edible(apple)
location(X,Y),
tastes_yucky(X).
(cont.)
Cuelquier intento de backtracking en el query no dar resultados, el query falla. 2-2 REDO edible(crackers) 2-2 FAIL edible(crackers) 2-1 REDO location(X, kitchen) 2-1 FAIL location(X, kitchen) Esto provoca que el listener usque otras clusulas que coincidan con el patrn del query. En este ejemplo, la segunda clusula de where_food/2 tambin coincide con el patrn del query. 1-1 REDO where_food(X, kitchen) Ahora se construye un query usando el cuerpo de la segunda clusula where_food(X,Y) :1-1 try (2) where_food(X, kitchen)
location(X,Y), edible(X). where_food(X,Y) :-
location(X,Y),
tastes_yucky(X).
Inteligencia Artificial 3.36 Dr. Scrates Torres Ovalle
(cont.)
1-1 try (2) where_food(X, kitchen) 2-1 CALL location(X, kitchen) 2-1 EXIT (2) location(apple, kitchen)
where_food(X,Y) :-
location(X,Y),
edible(X). where_food(X,Y) :location(X,Y), tastes_yucky(X).
Inteligencia Artificial
3.37
(cont.)
Backtracking produce el ltimo no, ya que no existen ms clusulas que coincidan con where_food/2. 2-2 REDO tastes_yucky(broccoli) 2-2 FAIL tastes_yucky(broccoli) 2-1 REDO location(X,kitchen) 2-1 EXIT (7) location(crackers, kitchen) 2-2 CALL tastes_yucky(crackers)
Inteligencia Artificial
3.38
Variables Independientes
Relacin entre las variables del primer nivel y las variables del segundo nivel. La X en el query no es la misma que la X en el cuerpo de la clausuala where_food/2, parecen ser las mismas debido a la unificacin. El objetivo en el query es: ?- where_food(X1, kitchen) La cabeza de la primer clusula es: where_food(X2, Y2) Despus de la unificacin entre las variables: X1 = _01 X2 = _01
Y2 = kitchen
Inteligencia Artificial
3.39
(cont.)
El segundo nivel del query se construye con el cuerpo de la clusula usando estos valores conectados. location(_01, kitchen), edible(_01).
Cuando la variable interna _01 toma un valor, por ejemplo apple, ambas Xs (X1 y X2) toman ese mismo valor.
Esto difiere en concepto de paso de parmetros que normalmente utiilizan otros lenguajes.
Inteligencia Artificial
3.40
Usando Reglas
Podemos ahora resolver el problema de las puertas de un solo sentido. Podemos definir un nuevo predicado con dos clusulas, connect/2. connect(X,Y), estarcerradapuerta(X,Y),
opendoor(X,Y):-
here(X).
connect(X,Y) :- door(X,Y). connect(X,Y) :- door(Y,X).
X = kitchen Y = office ;
...
Inteligencia Artificial
X = hall Y = office ;
3.41
Otras Reglas
List_things/1, el cual lista todas las cosas en una habitacin. list_things(Place) :location(X, Place),
tab(2),
write(X), nl, fail.
Inteligencia Artificial
3.42
(cont.)
Existe un problema con la regla list_things/1, Siempre da la lista pero al ltimo siempre falla, sale por el puerto fail; no podremos usarla en conjuncin con otras reglas que le sugan por la parte derecha. Se puede resolver el problema (forzar la salida por el puerto exit) aadiendo otra clusula que siempre tenga xito: list_things(Place) :location(X, Place),
tab(2),
write(X), nl, fail. list_things(AnyPlace).
Inteligencia Artificial
3.43
(cont.)
Como no nos interesa el valor de la variable AnyThing, podemos usar una variable especial denominada variable annima, representada por (_). list_things(_).
List_connections/1, el cual lista habitaciones conectadas. Una regla puede ser definida usando otras reglas.
Inteligencia Artificial
3.44
(cont.)
look/0, el juego le dice al jugador: dnde se encuentra el jugador. qu cosas hay en la habitacin donde se encuentra. y cules habitaciones son adyacentes.
Inteligencia Artificial
3.45
look/0
look :- here(Place), write('You are in the '), write(Place), nl, write('You can see:'), nl, list_things(Place), write('You can go to:'), nl, list_connections(Place).
Inteligencia Artificial
3.46
(cont.)
Dado que estmos en la cocina, as es como funciona: ?- look. You are in the kitchen You can see: apple broccoli crackers You can go to: office cellar
dining room
yes
Inteligencia Artificial
3.47
Un programa en Prolog es una base lgica de hechos y reglas interrelacionadas. Las reglas se comunican entre si a travs de la unificacin, verificador de coincidencia de patrones de Prolog. Las reglas se comunican con el usuario a travs de predicados evaluables tal como write/1. Las reglas pueden ser consultadas (call) individualmente mediante un query desde el listener.
Inteligencia Artificial
3.48
El comportamiento de ejecucin de las reglas es controlado por el mecanismo de bsqueda backtracking de Prolog. Podemos forzar el backtracking con el predicado evaluable fail.
Podemos forzar el xito de un predicado aadiendo una clusula final con variables dummy como argumento y sin cuerpo.
Inteligencia Artificial
3.49
Los hechos en una base lgica (locations, doors, etc.) reemplazan la definicin de datos convencional. La bsqueda con bactracking (list_things/1) reemplaza el cdigo de muchos ciclos. El paso de control a travs de coincidencia de patrones (connect/2) reemplaza pruebas condicionales y estructuras de ramificacin. Las reglas pueden ser probadas individualmente favoreciendo el desarrollo modular del programa. Las reglas que llaman a reglas favorecen la prctica de programacin mediante abstraccin de datos y procedimientos (look/0 no sabe como list_things/1 funciona o como los datos location se almacenan).
Inteligencia Artificial
3.50
Ejercicios
Considera la siguiente base lgica: a(a1,1). a(A,2). a(a3,N). b(1,b1). b(2,B). b(N,b3). c(X,Y) :- a(X,N), b(N,Y). d(X,Y) :- a(X,N), b(Y,N).
Predice las respuestas a las siguientes preguntas, luego comprubalo usando Prolog.
?- a(X,2).
?- b(X,kalamazoo).
?- c(X,b3). ?- c(X,Y). ?- d(X,Y).
Inteligencia Artificial
3.51
Tarea
Nani Search Experimenta con todas las reglas que hemos desarrollado, utiliza tambin el Debugger.
Escribe look_in/1. Deber listar las cosas que se localizan en su argumento. Por ejemplo, look_in(desk) deber regresar la lsiat de las cosas que contiene el escritorio.
lookin(X):list_things(X).
Inteligencia Artificial
Tarea
Family Construuye reglas para definir varias relaciones familiares que fueron implementadas como queries compuestos. Por ejemplo: mother(M,C):- parent(M,C), female(M). father(F,C):-
Construye una regla para siblings (uno de dos o ms personas que tienen uno o ambos padres en comn). Probablemente encontrars que una persona es sibling de si mismo. Usa el debugger para que observes el porqu. Se puede arreglar el problema de personas siendo su propio sibling un predicado evaluable que tiene xito si dos valores son diferentes, y falla si son iguales. El predicado es \=(X,Y). Tambin se puede escribir de la forma X \= Y. Usa el predicado sibling para definir reglas adicionales: hermanos, hermanos, tos, tas, y primos.
Inteligencia Artificial
3.53
(cont.)
Si deseamos representar casados (marriages) en Family, enfrentamos el mismo problema que se tuvo con las puertas bidireccionales usadas en Nani Search. Igual que parent/2, el cal tiene dos argumentos con distintos significados, married/2 puede intercambiar sus argumentos sin cambiar sus significados. Usando como ejemplo el predicado door/2 de Nani Search, aade el predicado spouse/2 (esposo(a)). Luego escribe el predicado married/2 usando como modelo connect/2.
Usa el nuevo predicado married para aadir reglas para tos y tas que son tos o tas polticos o por sangre. Debes aadir dos reglas para cada una de estas relaciones, una para el caso sanguineo y otro para el caso poltico. Usa el debugger.
Explora otras relaciones , tales como las relacionadas con parientes polticos (in-laws).
Inteligencia Artificial
3.54
(cont.)
Escribe un predicado para grandparent/2. salo para encontrar tanto un abuelo como un nieto. grandparent(someone, X).
grandparent(X, someone).
Obrseva su comportamiento en el Debugger para ambos casos. Depende de cmo lo escribas, uno reuqerir menos pasos que el otro. Escribe dos predicados, uno llamado grandparent/2 y otro llamado grandchild/2. Ordena los objetivos en ambos de tal manera que sean eficientes en su uso.
Inteligencia Artificial
3.55
Tarea Birds
Los Sistemas Expertos son llamdos tambin sistemas basados en reglas. Las reglas son reglas de dedo usadas por expertos para resolver cierto tipo de problemas. Los sistemas expertos incluyen un mecanismo de inferencia, el cual sabe cmo usar las reglas. Existen muchos tipos de mecanismos de inferencia y muchas tcnicas de representacin del conocimiento que son usadas en Sistemas Expertos. Prolog es un lenguaje excelente para construir cualquier tipo de sistema experto. El cdigo para 'birds' en el apndice contiene un sistema experto que puede ser usado para identificar aves. Se podra hacer un sistema que identifique cualquier cosa: animales, carros, enfermedades.
Inteligencia Artificial
3.56
(cont.)
Decide que va a identificar tu sistema experto, pero decide aves..., aada algunas reglas de identificacin. Por ejemplo, un sistema que identifique mascotas puede tener las siguientes reglas: pet(dog):- size(medium), noise(woof). pet(cat):- size(medium), noise(meow). pet(mouse):- size(small), noise(squeak).
Por ahora, podemos probar las reglas poniendo hechos conocido en la base lgica. Por ejemplo, si aadimos size(medium) y noise(meow) y luego ejecutamos el query pet(X) encontraremos que X=cat.
Prolog permite que se aadan clusulas directamente desde el listener.
Inteligencia Artificial
3.57
(cont.)
?- noise(meow) :- true.
recorded
Estos ejemplos usan los predicados en la forma general attribute(value). En este ejemplo, el atributo pet se deduce. Los atributos size y noise deben ser dados.
Inteligencia Artificial
3.58
(cont.)
Mejora el sistema experto para que pregunte por los atributos/valores que no pueda deducir. Se hace esto aadiendo primero las reglas: size(X):- ask(size, X). noise(X):- ask(noise, X).
Por ahora, ask/2 slo preguntar al usuario si un par attribute/value es verdadero o falso. Usar el predicado evaluable read/1 el cual lee un trmino Prolog (terminando en (.)). ask(Attr, Val):write(Attr),tab(1),write(Val), tab(1), write('(yes/no)'),write(?), read(X), X = yes.
El ltimo objetivo, X = yes, trata de unificar X y yes. Si se ley yes, entonces esta clusula tiene xito, sino falla.
Inteligencia Artificial
3.59