Mtodos para la solucin de problemas. 2. Solucin de problemas.

La solucin de problemas es fundamental para la mayora de las aplicaciones de IA; existen principalmente dos clases de problemas que se pueden resolver mediante procesos computables: aqullos en los que se utiliza un algoritmo determinista que garantiza la solucin al problema y las tareas complejas que se resuelven con la bsqueda de una solucin; de sta ltima clase de problemas se ocupa la IA. 2.1. Definicin del problema como bsqueda en un espacio de estados. En ste inciso se describe el esquema conocido como espacio de estados para representar problemas. Espacio de estados. Un espacio de estados es un grafo cuyos nodos corresponden a estados del problema. De ste modo, utilizando sta representacin, la solucin a los problemas se convierte en la bsqueda de caminos rutas ptimas dentro del grafo. Representacin de problemas mediante espacios de estados. Estudiaremos ejemplos de formulacin de problemas utilizando la aproximacin de espacio de estados. El problema de los bloques. El problema consiste en encontrar un plan para reordenar la pila de bloques que se muestra en la figura 2.1

C A B

A B C

Figura 2.1. El problema de los bloques. las restricciones al problema son las siguientes: solamente podemos mover un bloque cada vez; un bloque puede levantarse nicamente cuando no tiene nada encima; el bloque levantado puede colocarse sobre el piso sobre otro bloque.

Fundamentos de Inteligencia Artificial

Para resolver el problema se requiere encontrar una secuencia de movimientos vlidos que hagan la conversin. Es decir, podemos entender el problema como una exploracin de alternativas posibles; en el estado inicial nicamente tenemos una alternativa: colocar el bloque C sobre el piso. Luego del primer movimiento encontramos ahora tres alternativas: poner el bloque A sobre el piso, colocar el bloque A sobre C y, poner el bloque C sobre A. Este tipo de anlisis est basado en el manejo de dos tipos de conceptos: estados del problema y, movimientos vlidos que nos hagan pasar de un estado del problema a otro estado del mismo. El espacio de estados para este ejemplo se muestra en la figura 2.2.
C A B B A C

A BC

A BC

C B A

B AC

ABC

C AB

B C A

B AC

C AB

A B C

A C B

Figura 2.2. Representacin espacio-estado para el problema de los bloques, indicando el camino de solucin. en sta figura, los nodos corresponden a estados posibles del problema y los arcos corrresponden a transiciones vlidas entre estados posibles; el problema de encontrar un plan de solucin es equivalente a encontrar un camino entre un nodo inicial (estado inicial) y un nodo meta (estado final).

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

El rompecabezas de 8. El problema consiste de una tabla de 3x3 celdas conteniendo ocho nmeros del 1 al 8 y una celda vaca. Como son ocho nmeros, una celda siempre permanecer vaca; un nmero puede moverse a una celda adyacente si sta est vaca, dejando vaca la celda donde se encontraba; el problema consiste en ordenar los nmeros del 1 al 8 en forma circular dejando la celda central vaca tal y como se muestra en la figura 2.3.
1 3 8 2 4 7 6 5 1 2 3 4 8 7 6 5

Figura 2.3. El rompecabezas de 8. la representacin espacio estado para ste problema es como sigue :
1 3 8 2 4 7 6 5

1 3 8 2 4 7 6 5

1 3 4 8 2 7 6 5

1 3 8 2 4 7 6 5

1 2 3 8 4 7 6 5

1 3 4 8 2 5 7 6

1 3 4 2 8 7 6 5

Figura 2.4. Representacin espacio-estado para el problema del rompecabezas de 8.

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

El problema del juego de ajedrez. Si queremos escribir un programa para jugar ajedrez, podramos, en primer lugar, especificar cul es la posicin inicial de las piezas en el tablero, cules son las reglas que definen los movimientos legales y qu posiciones de las piezas representan la victoria tanto para un jugador como para el otro. La posicin inicial y en general cualquier posicin, puede describirse con una tabla de 8x8 elementos. La meta es una posicin del tablero en la cual el jugador contrario tenga su rey amenazado y no pueda realizar ningn movimiento legal para quitarse la amenaza. Los movimientos legales son la forma de pasar, desde un estado inicial a un estado meta y pueden describirse como un conjunto de reglas del tipo "si X entonces Y" donde 'X' y 'Y' son posiciones legales del tablero y significa que se puede 'pasar' del estado 'X' al estado 'Y' :

8 7 6 5 4 3 2 1

a b c d E f g h TN CN AN RN DN AN CN TN PN PN PN PN PN PN PN PN

PB PB PB PB PB PB PB PB TB CB AB RB DB AB CB TB

8 7 6 5 4 3 2 1

A b c d e f g h TN CN AN RN DN AN CN TN PN PN PN PN PN PN PN PN

PB PB PB PB PB PB PB PB TB CB AB RB DB AB CB TB

Estado X Figura 2.5. Tablero de Ajedrez

Estado Y

Acabamos de definir el problema de jugar ajedrez como un problema de movimientos a travs de un espacio de estados; la resolucin de problemas con bsqueda en un espacio de estados forma la base de muchas aplicaciones de inteligencia artificial.

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

2.2. Sistemas de Produccin. Un sistema de produccin es una tcnica computacional cuyo efecto es convertir a la computadora en una mquina ms menos experta en la resolucin de problemas especficos, es decir, restringidos a un cierto dominio de conocimientos. El concepto en que se basan los sistemas de produccin es una extensin de la idea de las estructuras iterativas de la programacin tradicional: un sistema de produccin itera continuamente hasta que se satisfagan una varias condiciones que implican normalmente la solucin la imposibilidad de resolver los problemas planteados. Un sistema de produccin consiste de : -Un conjunto de reglas del tipo "si X entonces Y". -Una base de conocimientos que contenga informacin til para la tarea a realizar. -Una estrategia de control que especifique el orden en que se aplicarn las reglas y que resuelva los conflictos que se puedan presentar. -Un aplicador de reglas. el algoritmo bsico del aplicador de reglas puede escribirse en forma no determinstica como sigue : algoritmo sisprod. 1. [Establecer la base de datos inicial.] DATOS <--- base de datos inicial; 2. [Aplicar reglas hasta que se satisfaga alguna condicin de terminacin del problema (xito fracaso)] while DATOS no satisfaga la condicin de terminacin del problema { seleccionar alguna regla R del conjunto de reglas, tal que pueda ser aplicada a DATOS; DATOS <--- resultado de aplicar R a DATOS; } 3. [Fin] presentar los resultados. end. ste algoritmo es no determinstico porque todava no hemos especificado la estrategia de control (seleccionar), es decir, cmo se va a seleccionar en cada iteracin la regla que se aplicar (puede haber ms de una regla aplicable); de ste modo, la operacin de un sistema de produccin puede caracterizarse como un proceso de bsqueda en el cual, las reglas se van probando hasta que se encuentra alguna secuencia de ellas que satisfagan alguna condicin de terminacin. En realidad, las estrategias de control, para ser eficientes, requieren conocer el tipo de problema que se va a resolver.

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial 2.3. Heursticas

Para solucionar la mayora de los problemas difciles, a menudo es necesario construir una estructura de control que aunque no nos garantice encontrar la mejor respuesta, por lo menos proporcione una respuesta satisfactoria para nuestros propsitos. Una tcnica heurstica es aqulla que mejora la eficiencia del proceso de bsqueda de soluciones a cambio, posiblemente, de sacrificar su completitud. Como ejemplo de aplicacin de tcnicas heursticas consideraremos un problema clsico de optimizacin : El problema del agente viajero. Un vendedor tiene una lista de ciudades cada una de las cuales debe visitar solamente una vez; existen carreteras directas entre cada par de ciudades de la lista. Se debe encontrar la ruta que el vendedor debera seguir para que, siguiendo el camino ms corto posible, visitara todas las ciudades, comenzando por cualquiera de ellas y volviendo a la misma. Un ejemplo de ste tipo de problemas para seis ciudades se plantea en la figura 2.6.

1 1

2 3

13 12 18 7 14

2 13 21 26 15 25 3 12 21 11 6 4 4 18 26 11 12 14 5 7 15 6 12 9 6 14 25 4 14 9

Red de Ciudades

Matriz de distancias

Figura 2.6. El problema del agente viajero. En principio se puede resolver ste problema explorando el rbol de todos los caminos posibles y eligiendo aqul que tenga la longitud mnima; pero, si existen n ciudades, el nmero de caminos diferentes entre ellas es (n-1)!, esto significa que el tiempo requerido para resolver el problema es proporcional a n!. Por lo tanto, si tenemos once ciudades, (11-1)! = 10*9*8*7*6*5*4*3*2*1 = 3,628,000 rutas son posibles, es decir, se trata de un problema tpico de explosin combinatoria en el que es til aplicar tcnicas heursticas. Una tcnica heurstica de propsito general que es til para resolver problemas combinatorios es el 'algoritmo del vecino ms prximo', que trabaja seleccionando la alternativa ms cercana que an no ha sido visitada y as sucesivamente hasta recorrer todos los nodos y retornar al punto de partida :

1. Seleccionar arbitrariamente una ciudad de partida.

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

2. Para seleccionar la siguiente ciudad, analizar todas las ciudades que an no se han visitado y seleccionar aqulla que sea la ms cercana a la ciudad actual; ir a ella en el siguiente paso. 3. Repetir el paso dos hasta que se hayan visitado todas las ciudades. ste algoritmo se ejecuta en un tiempo proporcional al cuadrado de n lo que representa una mejora significativa sobre n!. Ejercicio. Implemente el algoritmo del vecino ms prximo en lenguaje Lisp prolog y resuelva el problema planteado en la figura 2.6. Ejercicio. Utilice el algoritmo anterior para resolver el siguiente problema: imagine que usted es un agente de viajes y que un cliente le pide que le reserve su pasaje en algn vuelo de Nueva York a Los Angeles, pero con la aerolnea XYZ ya que el cliente tiene un pase de cortesa; usted observa la lista de vuelos de XYZ y encuentra que no existe un vuelo directo y que tendr que hacer la reservacin utilizando transbordos.

Calgary

1500 millas Toronto 800 1800 Chicago 1000 Denver 1900 Urbana 500 1000 Nueva York

Los Angeles

1000 1500

1000

1500 Houston

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

3. Mtodos para la solucin de problemas. En ste captulo se presentan los mtodos ms importantes de propsito general para la bsqueda de soluciones a los problemas presentados en el captulo anterior; para la bsqueda de stas soluciones se han desarrollado tcnicas como las siguientes : -Bsqueda ciega. -Primero en profundidad. -Primero a lo ancho. -Solucin por costo mnimo. -Reduccin de Problemas, grafos AND/OR, rboles de juegos. -Heurstica, funciones de evaluacin, bsquedas heursticas en grafos AND/OR. -Tcnicas de poda : alfa, beta, alfa-beta, hacia adelante y otras.

3.1. Mtodos Bsicos. Primero en profundidad. Explora cada camino posible hasta su conclusin antes de intentar otro camino. Ejemplo :
A

Figura 3.1. Bsqueda en profundidad

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

Primero a lo ancho. Explora cada nodo sobre el mismo nivel antes de intentar analizar un nivel ms profundo. Ejemplo :
A

Figura 3.2. Bsqueda a lo ancho Ascenso de la colina. Escoge como prximo paso el nodo que aparezca en el lugar ms cercano a la meta; ste mtodo se basa en la analoga de un excursionista perdido en la oscuridad en la mitad de una montaa donde l sabe que cualquier paso hacia arriba lo sita en la direccin correcta. Un algoritmo posible para ste mtodo es el siguiente : 1. Generar la primera solucin propuesta de la misma forma que se hara en el algoritmo para el mtodo de generar-y-comprobar; ver si es una solucin; si lo es, terminar; de lo contrario continuar. 2. Una vez obtenida dicha solucin, aplicar algunas reglas para generar un conjunto nuevo de soluciones propuestas. 3. Para cada elemento del conjunto hacer lo siguiente : a). Enviarlo a la funcin de comprobacin; si es la solucin, terminar. b). Si no lo es, ver si est ms cerca de la solucin que cualquiera de los elementos comprobados hasta el momento; si lo es, recordarla; si no lo es, olvidarla. 4. Tomar el mejor elemento encontrado anteriormente y usarlo como la siguiente solucin propuesta; ste paso corresponde a un movimiento a travs del espacio del problema en la direccin que parece conducir ms rpidamente hacia la meta. 5. Regresar al paso nmero dos.

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

10

Ejemplo 1. El problema del laberinto. En las figuras 3.3 y 3.4 se muestra un ejemplo del problema a resolver (salida de un laberinto) y la grfica de su espacio de estados.

2 6 5 13 14 17 19 7 9 12 1 15 18 20

3 8 10 11

21 16

Figura 3.3. Salida de un laberinto.

8 5 6 7 21

14

10

11

13

12

15

16

17 19

18 20

Figura 3.4. Espacio de estados del problema.

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

11

la bsqueda en profundidad pasa de cada nodo a su primer sucesor no revisado: si ste es la meta ya se encontr el camino que buscamos; si no lo es, se pasa a su primer sucesor y as se contina. Si el nodo ya no tiene sucesores no revisados, se pasa al siguiente sucesor no revisado de su predecesor y se aplica la misma estrategia. El orden en que se visitan los nodos depende naturalmente de la manera en que se toman en cuenta los sucesores, si stos estn ordenados entre s (usando por ejemplo alguna numeracin global), el orden de bsqueda es nico. Saliendo del nodo 1 y tomando los sucesores en orden creciente, de acuerdo con sus nmeros, para la grfica de la figura 3.3 recorrida en profundidad, encontramos la siguiente secuencia de nodos : 1, 9, 6, 2, 3, 4, 21

a). Solucin en Lisp. Ahora nuestro objetivo es programar el mtodo en Lisp: supongamos que nuestra tarea es encontrar un camino de un nodo A a un nodo Z en una grfica G. Despus de realizar algunos pasos de la bsqueda en profundidad nos vamos a encontrar en una situacin general esquematizada en la figura 3.5.

...

...

P1
Figura 3.5. Bsqueda en profundidad. llegamos hasta el nodo X usando algn camino parcial P1 y hay que decidir cmo continuar. Si el nodo X coincide con Z, se termin la bsqueda y el camino P1 es el resultado. Si todava no llegamos a la meta y X no tiene ningn sucesor hay que regresar a su predecesor y continuar usando el prximo hermano de X disponible. Si X todava tiene sucesores disponibles, se toma el primero de ellos (sea ste Y), el camino parcial P1 se prolonga hasta l y el proceso se repite. Diseamos una funcin recursiva path1 con argumentos X, Z, P1, G, SCX, cuya tarea es realizar los pasos especificados arriba; SCX representa la lista de los sucesores disponibles del nodo X (son los sucesores que todava no se encuentran en el camino parcial P1). La definicin de la funcin path1 se muestra a continuacin :

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial (defun path1 (x z p1 g scx) (prog (p) (return (cond ; se termin la bsqueda ((eq x z) p1) ; no hay sucesores ((null scx) nil) ; se toma el primer sucesor disponible y se prueba ((setq p (path1 (car scx) z (cons (car scx) p1) g (sucd (car scx) g p1) ) ) p) ; el primer sucesor no tuvo xito, se quita de la lista ; de sucesores y se repite la bsqueda (t (path1 x z p1 g (cdr scx))) ) )))

12

en sta funcin, primero se prueba si los nodos X y Z coinciden, y en ste caso se regresa P1 como resultado. Luego se averigua si hay todava sucesores disponibles y se reporta falla (nil) en caso contrario (el regreso al predecesor de X y el uso de los hermanos de X est asegurado por la recursin y las alternativas que siguen). Luego se toma el primer sucesor disponible y se busca algn camino entre l y el nodo Z llamando otra vez la misma funcin path1 con argumentos ajustados apropiadamente (la funcin SUCD determina los sucesores disponibles y por sto necesita tener acceso al camino parcial P1). Si el avance por el primer sucesor no tuvo xito, ste se quita de la lista SCX y se repite la bsqueda con la lista reducida.

La funcin que llama a path1 y que representa el algoritmo completo de bsqueda en profundidad es el siguiente : (defun pathdep (a z g) (reverse (path1 a z (list a) g (sucd a g (list a))) )) sta funcin llama a la funcin path1 dndole el nodo inicial (n1), el nodo meta (n21), el camino parcial (contiene inicialmente slo a n1), la grfica g, y los sucesores disponibles que se determinan usando la funcin sucd. La grfica dirigida G se puede representar en Lisp utilizando una lista de la siguiente forma : (setq g '( (n1 n9 n12) (n2 n3 n5 n6 n7) (n3 n2 n4 n8) (n4 n3 n8 n21)

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial (n5 n2 n6) (n6 n2 n5 n9) (n7 n2 n9) (n8 n3 n4 n10) (n9 n1 n6 n7 n12) (n10 n8 n11 n15) (n11 n10) (n12 n1 n9 n14 n17) (n13 n14 n17 n19) (n14 n12 n13) (n15 n10 n16 n18) (n16 n15 n20) (n17 n12 n13 n19) (n18 n15) (n19 n13 n17 n20) (n20 n16 n19) (n21 n4) )) en que para cada nodo se mencionan explcitamente todos sus nodos sucesores.

13

La funcin sucd elige al primer sucesor disponible apoyndose en la funcin auxiliar dif : (defun sucd (n g p1) (cond ((null g) nil) ((eq (caar g) n) (dif (cdar g) p1)) (t (sucd n (cdr g) p1)) )) (defun dif (p q) (cond ((null p) nil) ((member (car p) q) (dif (cdr p) q)) (t (cons (car p) (dif (cdr p) q))) )) en la funcin sucd, si el nodo es N, la lista de todos sus sucesores (cdar G) se pasa a la funcin dif; si el primer nodo no es N, se llama recursivamente la misma funcin sucd dndole sta vez la grfica G sin el primer nodo y as en adelante. Si el nodo no se encontr, sucd regresa la lista vaca NIL. Cabe recordar que la funcin (caar G) es una abreviacin de (car (car G)) y se usa como selector del primer nodo de la grfica G; asimismo (cdar G) es abreviacin de (cdr (car G)); sto se ilustra en la figura 3.6 siguiente :

(CAR G) G = ( ( n1 s11 s12 . . . ) (CDAR G)

(CDR G) ( n2 . . . ) ... )

(CAAR G)

Figura 3.6. Representacin de la Grfica G. el algoritmo completo de bsqueda en profundidad es el siguiente :

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

14

;------------------------------------------------------------------------------------; busprof1.lsp ;---------------------------------------------------------------------------------; Representacin de la grfica g. (setq g '( (n1 n9 n12) (n2 n3 n5 n6 n7) (n3 n2 n4 n8) (n4 n3 n8 n21) (n5 n2 n6) (n6 n2 n5 n9) (n7 n2 n9) (n8 n3 n4 n10) (n9 n1 n6 n7 n12) (n10 n8 n11 n15) (n11 n10) (n12 n1 n9 n14 n17) (n13 n14 n17 n19) (n14 n12 n13) (n15 n10 n16 n18) (n16 n15 n20) (n17 n12 n13 n19) (n18 n15) (n19 n13 n17 n20) (n20 n18 n19) (n21 n4) )) ;-------------------------------------------------------(defun pathdep (a z g) (reverse (path1 a z (list a) g (sucd a g (list a))) ))

;-------------------------------------------------------(defun path1 (x z p1 g scx) (prog (p) (return (cond ((eq x z) p1) ((null scx) nil) ((setq p (path1 (car scx) z (cons (car scx) p1) g (sucd (car scx) g p1) ) ) p) (t (path1 x z p1 g (cdr scx))) ) ))) ;---------------------------------------------------------------(defun sucd (n g p1) (cond ((null g) nil) ((eq (caar g) n) (dif (cdar g) p1)) (t (sucd n (cdr g) p1)) )) (defun dif (p q) (cond ((null p) nil) ((member (car p) q) (dif (cdr p) q)) (t (cons (car p) (dif (cdr p) q))) ))

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

15

Ejemplo de ejecucin :

A:\> mulisp common <enter> ;Loading A:COMMON.LSP $(load busprof1) <enter> ;Loading A:BUSPROF1.LSP T $(pathdep 'n1 'n21 g) <enter> (N1 N9 N6 N2 N3 N4 N21) $(pathdep 'n1 'n1 g) <enter> (N1) $(pathdep 'n18 'n21 g) <enter> (N18 N15 N10 N8 N3 N4 N21 $(pathdep 'n4 'n21 g) <enter> (N4 N21) $(system) <enter> A:\> _

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

16

b). Solucin en Prolog. La relacin path1 tendr los mismos cuatro primeros argumentos de la funcin path1 de Lisp ms un argumento que se utilizar para el resultado (el camino final). En las relaciones de Prolog que corresponden a las funciones de Lisp siempre hay que reservar un argumento aparte para el resultado. La definicin de path1 la componen las clusulas :

; el camino trivial: estamos en la meta. path1( Z, Z, P, _, P ). ; El caso general: se elige algn sucesor disponible y ; se sigue adelante. path1( X, Z, P1, G, P ) :sucd( X, G, P1, Y) , path1( Y, Z, [Y | P1], G, P).
la coincidencia del primer y segundo argumento distingue el caso trivial y se expresa usando la misma variable en ambos lados: dado que los dos primeros argumentos de path1 siempre tendrn algn valor asociado, el proceso de empatamiento simplemente averigua la igualdad de sus valores. La misma variable P en el tercer y quinto argumento significa otra cosa: sta vez se expresa as la asignacin del resultado al ltimo argumento sabiendo que la realizar Prolog en el proceso de empatamiento (matching). La segunda clusula expresa la regla general: se toma el primer sucesor disponible Y y se avanza adelante prolongando el camino parcial P1 por Y. La relacin pathdep se puede definir por la clusula :

pathdep(A, Z, G, P) :path1(A, Z, [A], G, Pr) , invertir(Pr, P).

en el cuerpo de sta clusula se usa primero la relacin path1 dndole los nodos lmites (A y Z) y el camino parcial que corresponde al inicio del algoritmo (la lista con un slo elemento: A); luego se invierte el resultado de path1 recibiendo as el camino final buscado P. La relacin sucd se supone que determina al primer sucesor disponible ( bien falla); para su implantacin usaremos la misma representacin de la grfica G como lo hicimos en Lisp siendo la nica diferencia la forma en que Prolog expresa y accesa las listas. La definicin de sucd la componen las clusulas :

% Se encontr el nodo X: elige el prximo % sucesor que no est en P1. sucd(X, [ [ X | Scx ] | _ ], P1, Y) :!, miembro(Y, Scx), not miembro(Y, P1). % Se investiga el resto de la grfica. sucd(X, [ _ | GRest], P1, Y) :sucd(X, GRest, P1, Y).

FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

17

la primera regla corresponde al caso en que ya se encontr el nodo X y sus sucesores en la representacin de la grfica G: el proceso de empatamiento asegura las asociaciones que se ven en la figura 13. Usando la relacin member se elige algn elemento Y de la lista de sucesores Scx (que adquiri su valor en el empatamiento con la cabeza) y se verifica si no est en el camino parcial P1. Si est all, el retroceso automtico de Prolog llama otra vez la relacin member para que le d el siguiente elemento de la lista Scx y as se procede hasta que se encuentre algn sucesor disponible bien la relacin sucd falle. G = [ [ n1 s11 s12 . . . ] [ n2 . . . ] . . . ]

[[ X |

ScX

] |

Figura 3.7. Representacin de la Grfica G. La segunda regla sirve solamente para recorrer la grfica G en la bsqueda de la parte que informa sobre los sucesores del nodo X y se toma en consideracin slo si la primera regla no se pudo usar ( sea que su cabeza no empat), sto asegura el corte. Por ltimo es importante destacar el caracter diferente de los dos usos de member en la primera regla: en el primer caso tiene definido solamente su segundo argumento (la lista) y entonces con cada paso de retroceso asocia con el primer argumento el prximo elemento de la lista. En el segundo caso se trata del uso convencional de member. El algoritmo completo de bsqueda en profundidad es :

%--------------------------------------------% busprof1.ari %-------------------------------------------pathdep(A, Z, G, P) :path1(A, Z, [A], G, Pr), invertir(Pr, P). path1(Z, Z, P, _, P). path1(X, Z, P1, G, P) :sucd(X, G, P1, Y), path1(Y, Z, [Y | P1], G, P). sucd(X, [[X | Scx] | _ ], P1, Y) :!, miembro(Y, Scx), not miembro(Y, P1). sucd(X, [_ | GRest], P1, Y) :- sucd(X, GRest, P1, Y). invertir([],[]). invertir([Cabeza | Cola], Linvertida) :invertir(Cola, Colainvertida), concatenar(Colainvertida, [Cabeza], Linvertida). concatenar([],L,L). concatenar([X | L1], L2, [X | L3]) :- concatenar(L1, L2, L3).
FACULTAD DE MATEMATICAS

Fundamentos de Inteligencia Artificial

18

miembro(X, [ X | _ ]). miembro(X, [ _ | Cola ]) :- miembro(X, Cola). resolver(Ni, Nf, P) :- pathdep( Ni, Nf, [[n1, n9, n12],[n2,n3,n5,n6,n7], [n3,n2,n4,n8], [n4,n3,n8,n21], [n5,n2,n6], [n6,n2,n5,n9],[n7,n2,n9], [n8,n3,n4,n10], [n9,n1,n6,n7,n12], [n10,n8,n11,n15], [n11,n10], [n12,n1,n9,n14,n17], [n13,n14,n17,n19], [n14,n12,n13], [n15,n10,n16,n18], [n16,n15,n20], [n17,n12,n13,n19], [n18,n15], [n19,n13,n17,n20], [n20,n16,n19],[n21,n4]], P).

Ejemplo de ejecucin : A:\> api <enter> ?- consult( 'busprof1.ari' ). <enter> yes ?- resolver( n1, n21, X ). <enter> X = [n1,n9,n6,n2,n3,n4,n21] -> ; X = [n1,n9,n6,n2,n3,n8,n4,n21] -> ; X = [n1,n9,n6,n5,n2,n3,n4,n21] -> ; X = [n1,n9,n6,n5,n2,n3,n8,n4,n21] -> ; X = [n1,n9,n7,n2,n3,n4,n21] -> ; X = [n1,n9,n7,n2,n3,n8,n4,n21] -> ; X = [n1,n9,n12,n14,n13,n17,n19,n20,n16,n15, n10,n8,n4,n21] -> <enter> yes ?- halt. <enter> A:\> _

c). Comparacin de las soluciones. La diferencia ms importante entre los programas en Lisp y Prolog reside en la forma en que se asegura el uso consecutivo de todos los sucesores disponibles de cada nodo: en Lisp se logr incluyendo un argumento ms ( sea en forma explcita), en Prolog se aprovech el mecanismo de retroceso automtico (backtracking) ( sea la forma implcita). Otra diferencia es la simplicidad de la definicin de sucd en prolog ya que no necesit las dos etapas de Lisp (sucd y dif); aprovechando el proceso de empatamiento con la cabeza de la primera regla, en el cuerpo de sucd queda slo implementar la operacin que realizaba la funcin dif.

FACULTAD DE MATEMATICAS