Material IA

UNIVERSIDAD AUTONOMA DE GUERRERO
FACULTAD DE MATEMTICAS
UNIDAD ACAPULCO
No. 001
Apuntes de
FUNDAMENTOS DE
INTELIGENCIA ARTIFICIAL
Primera Edicin
Serie: Material de Apoyo a la Maestra en Ciencias de la

Computacin.
Estos apuntes fueron elaborados a partir de la bibliografa citada al final del mismo; su
propsito es servir como apoyo al curso de Fundamentos de Inteligencia Artificial que se
imparte en la Maestra en Ciencias de la Computacin de la Facultad de Matemticas. Su
publicacin no persigue fines de lucro, est destinada al uso interno en la Universidad
Autnoma de Guerrero.
Edgar Altamirano Carmona
Acapulco, Gro. enero de 2003
Fundamentos de Inteligencia Artificial
Contenido
1. Introduccin.
Mtodos para la solucin de problemas

2. Solucin de problemas
3. Mtodos para la solucin de problemas.
6
13
Representacin de conocimientos y razonamiento

4. Lgica.
5. Reglas de produccin y redes.
6. Objetos estructurados y procedimientos.
24
41
49
Aplicaciones
7. Aplicaciones.
54
Bibliografa.
61
FACULTAD DE MATEMATICAS
1. Introduccin
Inteligencia Artificial.
Es el estudio de cmo hacer que las computadoras realicen tareas que por el momento,
las personas realizan mejor.
El quhacer en IA parece haber convergido a dos objetivos :
a). Hacer que las computadoras ejecuten acciones que de ser realizadas por el hombre, se
denominaran inteligentes, y
b). Entender el proceso inteligente natural con la ayuda conceptual de los sistemas que
ejecutan tales acciones.
Orgenes.
El origen de lo que conocemos como inteligencia artificial se puede detectar formalmente
en la dcada de los aos sesentas; en 1961, Marvin Minsky, en el MIT, escribi un artculo
titulado "Hacia la Inteligencia Artificial"; en 1960, John McCarthy, crea el lenguaje de
programacin LISP, con caractersticas apropiadas para manipular problemas del tipo de
los identificados como de inteligencia artificial; en 1964, Weizenbaum escribe el programa
llamado "Eliza", el cual simula la actuacin de un psicoanalista; en la misma dcada de los
sesentas aparecen los primeros programas que juegan ajedrez; el entusiasmo por realizar
programas inteligentes tuvo en esta dcada su primer efervecencia.
Aunque como los investigadores intentaron generalizar sus aplicaciones se encontraron
con que los recursos informticos existentes resultaban insuficientes; las capacidades de
memoria y rapidez de ejecucin no eran tiles para manipular los problemas; en los aos
setentas las capacidades computacionales aumentaron aunque todava subsisti lo que hoy
conocemos como la crisis del software.
Es hasta finales de los aos setentas cuando se conocen aplicaciones al procesamiento del
lenguaje natural, representacin de conocimientos, resolucin de problemas difciles y la
aparicin de los sistemas expertos.
Otro de los acontecimientos importantes en la IA es el anuncio en 1981, de la industria
informtica japonesa respecto a utilizar el lenguaje Prolog como base de sus
computadoras de quinta generacin; ste lenguaje de programacin fu creado desde fines
de la dcada de los sesentas en Europa, pero es hasta la dcada de los ochentas en que su
utilizacin en IA cobra una importancia primordial junto a LISP al grado de conocerse
como los dos lenguajes de la IA.
En sta dcada de los aos ochentas, la IA pasa de los laboratorios de investigacin a las
aplicaciones reales y a la comercializacin de software y hardware orientados a IA. A fines
de esta dcada cobra adems importancia la tecnologa de programacin orientada a
objetos y los lenguajes C, C++, Smalltalk y otros con orientaciones especficas a campos
de la IA.
En la actualidad se reconocen tambin varias reas de estudio dentro del campo de la IA
- Representacin de Conocimientos
- Resolucin de problemas
- Teora de juegos
- Procesamiento del lenguaje natural
- Visin
- Robtica
- Sistemas Expertos
- Redes Neuronales
- Aprendizaje
- Razonamiento Artificial.
Estas reas de estudio se han venido incorporando individualmente a las aplicaciones
informticas tradicionales; por ejemplo, los sistemas manejadores de bases de datos
pueden contener ahora un elemento deductivo (razonamiento) para obtener informacin
no explcita en la base pero que se puede inferir; otra incorporacin es el proceso del
lenguaje natural para consultas en la base de datos.
Algunas definiciones de la I.A.
Es la ciencia de la inteligencia en general.
Es el estudio de la manera en que pueden construirse programarse las computadoras
para que realicen el tipo de cosas que la mente puede hacer.
La creacin de computadoras cuyo desempeo observable tiene caractersticas que, en
los seres humanos atribuiriamos a procesos mentales.
Es el estudio de problemas complejos de procesamiento de informacin que a menudo
tienen sus races en algn aspecto del procesamiento biolgico de informacin. Su
objetivo es identificar problemas interesantes y resolubles del procesamiento de
informacin para solucionarlos.
Es el arte de crear mquinas que ejecutan funciones que requieren inteligencia cuando
son realizadas por las personas.
Es el estudio de los problemas de computacin que todava no han sido resueltos.
Es la simulacin computacional de procesos cognitivos.
Estupidez Artificial (E.A.)

Es el intento de los cientficos en computacin para crear programas de cmputo,
capaces de causar problemas de un tipo normal, asociados con el pensamiento
humano.
Inteligencia.
Allen Newell ofrece la siguiente lista para un sistema inteligente :

Opera en tiempo real, explota una vasta cantidad de conocimiento, tolera entradas
errneas, inesperadas y posiblemente desconocidas, usa smbolos y abstracciones; se
comunica usando alguna forma de lenguaje natural; aprende del medio ambiente y
exhibe un comportamiento de objetivos orientados adaptable.
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
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.
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
C
B
A
B
AC
C
AB
ABC
B
AC
A
B
C
A
BC
B
C
A
C
AB
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).
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 2 3
4
8
7 6 5
1 3
8 2 4
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 4
8 2
7 6 5
1
3
8 2 4
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.
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
Estado Y
Figura 2.5. Tablero de Ajedrez
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.
10
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.
2.3. Heursticas
11
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
Red de Ciudades
1
13 12 18
2 13
21 26
3 12 21
11
4 18 26 11
5
2 3
7 14
15 25
6 4
12 14
7 15 6 12
6 14 25 4 14 9
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.

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.
12
ste algoritmo se ejecuta en un tiempo proporcional al cuadrado de n lo que representa

una mejora significativa sobre n!.
Ejercicio1. Implemente el algoritmo del vecino ms prximo en lenguaje Lisp prolog y
resuelva el problema planteado en la figura 2.6.
Ejercicio2. 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.
1500 millas
Calgary
Toronto
1800
1000
Los Angeles
1000
Chicago
1900
Denver
1000
1500
1000
800
500
Urbana
1500
Houston
Nueva York
13
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
14
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.
15
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.
3
6
5
13
14
17
19
12
10 11
21
15
18
20
16
Figura 3.3. Salida de un laberinto.
12
13
17
14
10
11
15
16
18
20
19
Figura 3.4. Espacio de estados del problema.
21
16
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 :
(defun path1 (x z p1 g scx)

(prog (p)
17
(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))) )
)))
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)
(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)
18

(n18 n15) (n19 n13 n17 n20) (n20 n16 n19) (n21 n4) ))
en que para cada nodo se mencionan explcitamente todos sus nodos sucesores.
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
(CAAR G)
s11 s12 . . . )
(CDR G)
( n2 . . . )
... )
(CDAR G)
Figura 3.6. Representacin de la Grfica G.

el algoritmo completo de bsqueda en profundidad es el siguiente :
;------------------------------------------------------------------------------------; 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))) ))
19
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)
(N1)
(N18 N15 N10 N8 N3 N4 N21
(N4 N21)
$(system) <enter>
A:\> _
20
21
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).
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
22
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).
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],
23
[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.
24
Representacin de conocimientos y razonamiento.

En los siguientes captulos se presentan los formalismos y estructuras de datos ms
utilizados para la representacin de conocimientos en aplicaciones de IA. Estos se pueden
agrupar para su estudio en los siguientes tipos de representacin :
Lgica.
Reglas de produccin.
Redes.
Objetos estructurados.
Procedimientos.
4. Lgica.
La lgica simblica es un modelo matemtico del pensamiento deductivo; el formalismo
lgico es atractivo porque sugiere una forma potente para derivar conocimiento nuevo a
partir de hechos comprobados: la deduccin mate-mtica. Utilizando la lgica podemos
concluir que una proposicin nueva es cierta demostrando que se deduce de proposiciones
conocidas, sto nos permite usar la deduccin como una forma de derivar respuestas a
preguntas y solucionar problemas.
4.1. Lgica proposicional.
La lgica proposicional es atractiva porque es sencilla de manejar y existe para ella un
procedimiento de decisin; con ella podemos representar fcilmente los hechos del mundo
real mediante proposiciones lgicas escritas como frmulas bien formadas (fbf) y deducir
nuevas proposiciones.
La lgica proposicional puede definirse como un lenguaje formal constitudo por un
alfabeto, reglas de sintaxis, axiomas y una regla de demostracin.
Alfabeto.
El alfabeto contiene los siguientes smbolos :
a). Smbolos de proposiciones atmicas, se utilizan las letras de variables p, q, r, s, t, tc.
b). Smbolos de conectivas y parntesis: , , , , , (, ).
Sintaxis para construccin de frmulas.
Una frmula en lgica proposicional debe cumplir con los siguientes requisitos :
1). No deben aparecer conectivas adyacentes, y
2). Es preciso definir la relacin conectivas-proposiciones cuando haya ms de una
conectiva.
A efecto de cumplir con lo anterior, una frmula sintcticamente correcta se define de
acuerdo con las siguientes reglas :
Para cumplir con el primer requisito :
a). Las letras proposicionales p, q, r, s, t, son frmulas correctamente formadas.
b). Si A y B son frmulas correctas, tambin son frmulas correctas las siguientes :
A, B, A B, A B, A B, A B.
c). Slo son frmulas correctas las que cumplen con las condiciones a) y b).
25
Para cumplir con el segundo requisito :

d). Una conectiva afecta a las letras proposicionales inmediatas a los conjuntos de letras
y smbolos inmediatos a ella entre parntesis.
e). Para evitar el exceso de parntesis se define una jerarqua entre conectivas:
nivel 1 :
nivel 2 : ,
nivel 3 : ,
Las conectivas del primer nivel obedecen exclusivamente a la regla d); para las de los
otros niveles puede presuponerse el parntesis cuando estn entre frmulas afectadas por
las conectivas de niveles inferiores.
Axiomas.
Los axiomas que determinan las reglas de demostracin de teoremas enunciados por
Kleene en 1953 son :
1. A (B A)
2. (A B) ((A (B C)) (A C))
3. A (B (A B))
4. A B AA B B
5. A A B A B A
6. (A C) ((B C) ((A B) C))
7. (A B) ((A B) A)
8. (A) A
Regla de demostracin.
Para interpretar ste lenguaje formal y hacer de l una herramienta para el estudio del
razonamiento, se asume que cualquier proposicin es una sentencia que toma los valores
de verdadero falso. Una frmula es verdadera si coincide con un axioma puede
comprobarse a partir de axiomas por medio de la regla de deduccin simple conocida
como regla de modus ponens :
A,
A B
-----------------B
las letras A, B, C simbolizan frmulas cualesquiera sintcticamente correctas, de forma
que los axiomas y reglas de inferencia son realmente esquemas de frmulas
estructuralmente asumidos como correctos.
Concepto de demostracin.
Una demostracin de una frmula A en la lgica de proposiciones es una sucesin de
frmulas P1, P2, P3, ... Pn tales que :
-Cada frmula Pi, elemento de la sucesin es :
*un axioma;
*una frmula obtenida a partir de las anteriores, aplicando la regla de
demostracin de modus ponens.
26
-El ltimo elemento de la sucesin Pn, es precisamente la frmula a

demostrar, A.
Concepto de deduccin.
Una demostracin estructura deductiva se describe mediante dos sucesiones separadas
por el signo
p1, p2, p3, ..., pn q1, q2, q3, ... qm
la sucesin pi es el antecedente de la deduccin y sus elementos se llaman premisas. La
sucesin qi es el consecuente de la deduccin y sus elementos se llaman conclusiones.
Una estructura deductiva se define como correcta cuando la sucesin consecuente se
obtiene de acuerdo con alguna de las reglas siguientes :
a). qi es una de las premisas.
b). qi es una frmula vlida en el sistema, es decir, qi es un axioma un teorema.
c). qi se deduce de alguna premisa alguna conclusin previa aplicando la regla de modus
ponens.
Teorema de la deduccin.
Este teorema es fundamental en teora de la demostracin ya que permite definir una
relacin entre las estructuras deductivas correctas y las frmulas vlidas. Su enunciado es
el siguiente :
Si p1, p2, p3, ..., pn q1, q2, q3, ..., qi, es una deduccin correcta, existe una
deduccin correcta de pn qm con premisas p1, p2, p3, ..., pn-1.
4.2. Lgica de predicados.
La lgica de predicados permite representar entidades que no pueden representarse
razonablemente en lgica proposicional; la definicin de la lgica de predicados como un
lenguaje formal es una generalizacin del ya planteado para la lgica proposicional.
Alfabeto.
Consta de los siguientes smbolos :
a). Smbolos de trminos constitudos por letras de variables (ltimas letras del alfabeto
x,y,z,t,w, tc.) y letras de constantes (primeras letras del alfabeto a,b,c,d, tc.).
b). Smbolos de predicado, se emplean las letras minsculas del alfabeto p,q,r,s, tc.
c). Smbolos de conectivas y parntesis idnticos a los utilizados en el clculo
proposicional: , , , , , (, ).
d). Smbolos de cuantificacin: cuantificador universal y cuantificador existencial .
Sintaxis para construccin de frmulas.
Una frmula constituye una sucesin de smbolos del alfabeto que verifica las reglas de
formacin siguientes :
e). Toda proposicin es una frmula.
27
f). Si p es una letra de predicado de n plazas p(t 1, t2, t3, ... , t n) es una frmula, siendo t i
smbolos de trminos.
g). Si A es una frmula que contiene libre la variable xi :
xi A(x1, x2, x3, ... , xn)
xi A(x1, x2, x3, ... , xn)
son frmulas sintcticamente correctas; las otras variables xk que figuran en A distintas de
xi continan libres.
h). Si A y B son frmulas, A, B, A B, A B, A B, son tambin frmulas.
i). Slo son frmulas aqullas construidas segn los incisos de a) hasta h).
Axiomas.
Se pueden utilizar los axiomas de Kleene referidos ahora a frmulas del clculo de
predicados, completados con otros referentes a propiedades de los cuantificadores, por
tanto, las frmulas vlidas para el clculo de proposiciones son tambin vlidas para el
clculo de predicados. Los axiomas de Kleene son :
1. A (B A)
2. (A B) ((A (B C)) (A C))
3. A (B (A B))
4. A B AA B B
5. A A B A B A
6. (A C) ((B C) ((A B) C))
7. (A B) ((A B) A)
8. (A) A
9. x B(x) B(t)
10. B(t) x B(x)
en los ltimos axiomas (9 y 10), t representa un trmino cualquiera, constante variable.
Reglas de inferencia.
1. Modus Ponens.
2. Generalizacin universal condicional
A,
A B
-----------------B
A B(y)
---------------------A x B(x)
(en A no aparece libre y)
3. Generalizacin existencial condicional.

28
A(y) B
---------------------x A(x) B
(en B no aparece libre y).
Reglas complementarias de inferencia.
Adems de las reglas anteriores es posible demostrar la validez de las siguientes reglas de
inferencia que son de gran utilidad :
4. Generalizacin universal.
A(y)
-------------------x A(x)
6. Especificacin universal.
x A(x)
---------------------A(y)
5. Generalizacin existencial.
A(y)
--------------x A(x)
7. Especificacin existencial.
x A(x), A(y) B
----------------------------B
(en B no aparece libre y)
En las definiciones anteriores, A y B son frmulas cualesquiera; A(y), B(y), deben

entenderse como frmulas cualesquiera en las que la variable y est libre, lo que no implica
que sta sea la nica variable en la frmula.
Una demostracin correcta es una sucesin de frmulas vlidas: P 1, P2, P3, ... Pn en
donde cada Pi es un axioma se obtiene de algunas P j anteriores (j < i) aplicando las
reglas de inferencia definidas como correctas en el sistema.
Teorema de la deduccin.
Si P1, P2, P3, ... Pn Q1, Q2, Q3, ... Qm es una deduccin correcta, existe una
deduccin correcta de Pn Qi a partir de P1, P2, P3, ... Pn-1 como premisas. Sin
embargo, en clculo de predicados existe una restriccin en P n para que sea vlido este
teorema: no pueden utilizarse las variables libres de P n mediante reglas de generalizacin
para obtener Qm. Por tanto, en clculo de predicados no siempre a una deduccin
correcta le corresponde una frmula vlida.
4.3. Ejemplo de deduccin en lgica de predicados.
Se presenta un ejemplo clsico para el cual, a partir de un conjunto de hechos conocidos
se demuestra una cierta afirmacin.
Representacin de conocimientos.
29
Los hechos conocidos y su representacin en lgica de predicados son :

1. Marco era un hombre.
hombre(marco).
2. Marco era pompeyano.
pompeyano(marco).
3. Marco naci en el ao 40 D.C.
nace(marco, 40).
4. Todos los hombres son mortales.
x hombre(x) mortal(x).
5. Todos los pompeyanos murieron cuando erupcion el volcn en
el ao 79 D.C.
x pompeyano(x) muri(x, 79).
6. erupcion(volcn, 79).
7. Ningn mortal vive ms de 150 aos.
x t t mortal(x) nace(x, t1) mayor_que(t2-t1, 150) muerto(x, t2).
8. Ahora estamos en el ao 1994 D.C.
ahora = 1994.
9. Estar vivo significa no estar muerto.
x t vivo(x, t) muerto(x, t).
10.Si alguien muere, entonces est muerto para todos los tiempos posteriores.
x t1 t2 muri(x, t1) mayor_que(t2, t1) muerto(x, t2).
Razonamiento con el conocimiento.
A partir de stos hechos se quiere saber si Marco est vivo, es decir, se trata de probar
que: vivo(marco, ahora). Si observamos la lista de hechos conocidos podemos sugerir
dos formas diferentes para deducir una respuesta: probar que Marco est muerto porque
lo mat el volcn, bien, que debe estar muerto porque de lo contrario tendra ahora ms
de 150 aos. En las figuras 4.1 y 4.2 se presentan dos demostraciones posibles; el trmino
NIL al final de cada demostracin indica que la lista de condiciones que queda para
demostrar est vaca y por lo tanto, que la demostracin tuvo xito.
vivo(marco, ahora).
muerto(marco, ahora).
muri(marco, t1) mayor_que(ahora, t1).
pompeyano(marco) mayor_que(ahora, 79).
mayor_que(ahora, 79).
mayor_que(1994, 79).
NIL.
% por 9, sustitucin.
% por 2.
Figura 4.1. Una demostracin posible de que Marco est muerto.
30
vivo(marco, ahora).
muerto(marco, ahora).
mortal(marco)
nace(marco, t1)
mayor_que(ahora - t1, 150)
hombre(marco)
nace(marco, t1)
nace(marco, t1)
% por 1.
mayor_que(ahora - 40, 150).
% por 3.
mayor_que(1994 - 40, 150).
% por 8.
mayor_que(1954, 150).
% (se calcula la resta).
NIL.
Figura 4.2. Otra demostracin posible de que Marco est muerto.

4.4. Resolucin.
Es una regla de inferencia que se aplica a cierta clase de frmulas denominadas como
clusulas.Una clusula es una frmula que consiste de una disyuncin de predicados. El
proceso de resolucin, cuando es aplicable, lo hace sobre un par de clusulas padres para
producir una clusula hija derivada.
La regla de resolucin es una herramienta importante en la demostracin de teoremas, la
cual, a su vez, tiene aplicaciones a procesos de recuperacin de informacin en bases de
datos, razonamiento, programacin automtica, sistemas de planeacin y sistemas
expertos.
En un problema tpico de demostracin de teoremas se tiene un conjunto S de frmulas
lgicas, a partir del cual se desea demostrar cierta frmula W objetivo. Los sistemas de
demostracin basados en la regla de resolucin estn concebidos para producir
demostraciones por reduccin al absurdo refutaciones. En una refutacin por
resolucin comenzamos por negar la frmula objetivo, enseguida la adicionamos al
conjunto S, convertimos el conjunto ampliado a forma clausular y, finalmente, utilizamos
la regla de resolucin para intentar llegar a una contradiccin representada por la clusula
vaca.
Una demostracin por refutacin significa lo siguiente : Supongamos que una frmula W
se sigue lgicamente de un conjunto S frmulas, entonces, por definicin, cualquier
interpretacin que satisfaga a S, satisface tambin a W. Ninguna de las interpretaciones
que satisfagan a S puede satisfacer a W y, por tanto, ninguna interpretacin puede
satisfacer a la unin de S y {W}. Un conjunto de frmulas que no puede ser satisfecho
31
por ninguna interpretacin se conoce como incompatible; as, si W se sigue lgicamente

de S, el conjunto S {W} es incompatible.
Si se aplica entonces la regla de resolucin repetidamente a un conjunto de clusulas
incompatibles, se llegar en algn momento a producir la clusula vaca; as, si W se sigue
lgicamente de S, la resolucin podr llegar a producir la clusula vaca a partir de la
representacin mediante clusulas de S {W}, inversamente, si la clusula vaca se
produce a partir de la representacin de S {W}, la frmula W se sigue lgicamente de
S.
Conversin a forma clausular.
Cualquier frmula de la lgica de predicados se puede convertir en un conjunto de
clusulas. El proceso de conversin consiste en los siguientes pasos :
1). Eliminar los smbolos de implicacin. Todas las presencias de p q en una frmula
quedan eliminadas mediante la sustitucin de p q en toda la frmula.
2). Reducir los mbitos de los smbolos de negacin. Cada smbolo de negacin se debe
aplicar tan slo a una frmula atmica. Se puede hacer uso repetido de las siguientes
sustituciones para reducir el mbito de cada smbolo hasta que se aplique a un slo
predicado:
Reemplazar (A B)
Reemplazar (A B)
Reemplazar A
Reemplazar (x)A
Reemplazar (x)A
por A B
por A B
por A
por (x){A}
por (x){A}
3). Normalizar variables. Cada cuantificador debe estar ligado a una sola variable.
Dentro del mbito de cualquier cuantificador, una variable ligada a l, se dice que es una
variable muda y puede ser reemplazada por cualquier otra variable que no aparezca en
otra parte, uniformemente en todo el mbito del cuantificador, sin cambiar el valor de
verdad de la frmula. La normalizacin de variables en una frmula significa cambiar los
nombres de las variables mudas para asegurar que cada cuantificador tenga su propia
variable muda, distinta de las de los otros cuantificadores.
Por ejemplo, en lugar de escribir (x)[P(x) (x)Q(x)] escribiremos lo siguiente : (x)
[P(x) (y)Q(y)].
4). Eliminar cuantificadores existenciales. La regla general para eliminar un
cuantificador existencial en una frmula es reemplazar la variable cuantificada
existencialmente, en cada sitio en que aparezca, por una funcin de Skolem cuyos
argumentos sean aqullas variables cuantificadas universalmente que estn ligadas por
cuantificadores universales cuyos mbitos comprendan el mbito del cuantificador
32
existencial que se est eliminando; los smbolos usados para las funciones de Skolem
deben ser nuevos en el sentido de que no sean algunos de los que ya aparecen en la
frmula.
Consideremos por ejemplo la frmula (y)[(x)P(x,y)] que puede entenderse como "para
todo y existe un x, posiblemente dependiente de y, tal que P(x,y)". Ntese que como el
cuantificador existencial est en el mbito del cuantificador universal, admitimos la
posibilidad de que el x que existe pueda depender del valor de y. Definiremos
explcitamente sa dependencia mediante una funcin g(y) que hace corresponder a cada
valor de y el valor de x que "existe". Tal funcin se denomina como funcin de Skolem.
Si utilizamos la funcin de Skolem en lugar de la x que existe, podemos eliminar el
cuantificador existencial y escribir : (y)P(g(y),y).
Sea por ejemplo la siguiente frmula :
[(w)Q(w)] (x){(y){(z)[P(x,y,z) (u)R(x,y,u,z)]}}.
eliminamos (z) y obtenemos :
[(w)Q(w)] (x){(y)[P(x,y,g(x,y)) (u)R(x,y,u,g(x,y))].
Si el cuantificador existencial que vamos a eliminar no aparece en el mbito de un
cuantificador universal, usaremos una funcin de Skolem sin argumentos, sto es, una
constante. Por ejemplo, (x)P(x) dar lugar a P(A), donde A es un smbolo de constante
para referirnos al elemento que sabemos que existe. A debe ser un smbolo de constante
nuevo, no usado todava en ninguna frmula para referirse a otros elementos constantes.
5). Convertir a forma prenex. Como ya no quedan cuantificadores existenciales y cada
cuantificador universal tiene su propia variable, podemos mover todos los cuantificadores
universales al principio de la frmula y hacer que el mbito de cada cuantificador incluya
toda la parte de la frmula que le sigue. Se dice que la frmula que resulta est en forma
prenex. Esta frmula consiste de un prefijo de cuantificadores seguido de una frmula
exenta de cuantificadores llamada matriz.
6). Escribir la matriz en forma normal conjuntiva. Una matriz puede escribirse como
una conjuncin de un nmero finito de disyunciones de predicados y/ negaciones de
predicados. Tal matriz se dice que est en forma normal conjuntiva. Ejemplos de stas
matrices son :
[P(x) Q(x,y)] [P(w) R(y)] Q(x,y)
P(x) Q(x,y)
P(x) Q(x,y)
R(y)
Podemo escribir cualquier matriz en forma normal conjuntiva usando repetidamente la
regla :
33
Reemplazar A {B C} por {A B} {A C}
7). Eliminar cuantificadores universales. En ste momento todas las variables que
quedan estn cuantificadas universalmente, por tanto, el orden de los cuantificadores no
importa y en consecuencia podemos eliminar su escritura explcita conviniendo, para todo
lo que sigue, que todas las variables de la matriz estn cuantificadas universalmente.
8). Eliminar los smbolos . Podemos evitar la aparicin explcita de los smbolos ,
reemplazando las expresiones de la forma x y con las dos frmulas x, y. El resultado
final de stas operaciones es un conjunto finito de frmulas, cada una de las cuales es una
disyuncin de predicados y/ negaciones de predicados. Estas frmulas se denominan
clusulas.
9). Renombrar variables. Se cambian los smbolos de las variables de tal forma que no
haya dos clusulas que hagan referencia a la misma variable. Al realizar sta
transformacin nos basamos en el hecho de que :
(x)[P(x)Q(x)] es equivalente a [(x)P(x) (y)Q(y)]
Este proceso se denomina tambin como normalizar las variables por separado.
Finalmente, notaremos que los predicados de una clusula pueden contener variables, pero
se sobreentiende que sas variables estn siempre cuantificadas universalmente.
Si las variables se sustituyen por trminos que no contienen variables, obtenemos una
particularizacin bsica del predicado. Por ejemplo, Q(A,f(g(B)) es una particularizacin
bsica de Q(x,y).
Cuando se usa la resolucin como regla de inferencia en un sistema de demostracin de
teoremas, el conjunto de frmulas a partir del cual deseamos probar un teorema, ser
convertido, en primer lugar, en clusulas. Se puede ver que si una frmula X se sigue
lgicamente de un conjunto de frmulas S, tambin se sigue lgicamente del conjunto de
clusulas obtenidas al convertir las frmulas de S en clusulas, por lo tanto, para nuestros
propsitos, las clusulas son una forma general de expresin de las frmulas.
Ejemplo. Convertir la siguiente frmula lgica a su forma clausular :
(x) {P(x) {(y) [P(y) P(f(x,y))] (y) [Q(x,y) P(y)]}}
1). Eliminar los smbolos de implicacin.
(x) {P(x) {(y)[P(y) P(f(x,y))] (y)[Q(x,y) P(y)]}}.
2). Reducir los mbitos de los smbolos de negacin.
(x) {P(x) {(y)[P(y) P(f(x,y))] (y)[Q(x,y) P(y)]}}.
3). Normalizar variables.
34
(x) {P(x) {(y)[P(y) P(f(x,y))] (w)[Q(x,w) P(w)]}}.

4). Eliminar cuantificadores existenciales.
(x) {P(x) {(y)[P(y) P(f(x,y))] [Q(x,g(x)) P(g(x))]}}.
5). Convertir a forma prenex.
(x)(y){P(x) {[P(y) P(f(x,y))] [Q(x,g(x)) P(g(x))]}}.
6). Escribir la matriz en forma normal conjuntiva.
(x)(y) { [P(x) P(y) P(f(x,y))] [P(x) Q(x,g(x))]
[P(x) P(g(x))] }.
7). Eliminar cuantificadores universales.
{ [P(x) P(y) P(f(x,y))] [P(x) Q(x,g(x))]
[P(x) P(g(x))] }.
8). Eliminar los smbolos .
P(x) P(y) P(f(x,y))
P(x) Q(x,g(x))
P(x) P(g(x))
9). Renombrar variables.
P(x1) P(y) P(f(x1,y))
P(x2) Q(x2,g(x2))
P(x3) P(g(x3)).
4.5. Resolucin en lgica de proposiciones.
En lgica de proposiciones, el procedimiento para producir una demostracin por
resolucin de la proposicin S respecto a un conjunto de axiomas F es el siguiente :
1. Convertir todas las proposiciones de F a forma clausular.
2. Negar S y convertir el resultado a forma clausular. Adicionarla al conjunto de clusulas
obtenidas en el paso 1.
3. Hasta que se encuentre una contradiccin no pueda realizarse ningn progreso,
repetir lo siguiente :
1). Seleccionar dos clusulas. Denominarlas clusulas padres.
2).Resolverlas juntas. La clusula resultante, denominada como resolvente, ser la
disyuncin de todos los predicados de ambas clusulas padres con la siguiente excepcin:
si existen pares de predicados L y L de forma que una de las clusulas padre contenga L
y la otra contenga L, entonces eliminar tanto L como L del resolvente.
3). Si el resolvente es la clusula vaca, es que se ha encontrado una contradiccin. Si no
lo es, adicionarla al conjunto de clusulas disponibles por el procedimiento.
35
Ejemplo. Supongamos que tenemos los siguientes axiomas y queremos demostrar r :

Axiomas : {p, (p q) r, (s t) q, t}.
Demostrar : r.
Solucin :
1. Convertir todas las proposiciones a forma clausular.
{p, p q r, s q, t q, t}
2. Negar r y convertir el resultado a forma clausular.
{p, p q r, s q, t q, t, r}
3.
p q r
p q
t q
p
q
t
[]
4.6. Resolucin en lgica de predicados.

Las demostraciones por resolucin en lgica de predicados se apoyan en un algoritmo de
unificacin, por ello, la exposicin que sigue, iniciar con la descripcin de ste algoritmo.
Algoritmo de unificacin.
En lgica de proposiciones para determinar que dos proposiciones no pueden ser ciertas al
mismo tiempo comprobamos L y L. En lgica de predicados el proceso de
empatamiento es ms complicado puesto que deben considerarse las ligaduras de las
variables; por ejemplo, hombre(Jos) y hombre(Jos) es una contradiccin, mientras que
hombre(Jos) y hombre(Mara) no es una contradiccin. Por lo tanto, necesitamos un
proceso de empatamiento que compare dos predicados y encuentre si existe un conjunto
de sustituciones que los haga idnticos. El algoritmo de unificacin que se presenta
enseguida es un procedimiento recursivo directo que realiza lo anterior.
36
Algoritmo Unificar (L1,L2).

[Este algoritmo devuelve una lista que representa la composicin de sustituciones que se
han realizado en el proceso de empatamiento. La lista vaca NIL indica que se ha
encontrado un empatamiento sin ninguna sustitucin. Una lista que consiste
en el nico valor FAIL indica que el proceso de unificacin ha fracasado.]
1. Si L1 L2 son ambas variables constantes, entonces :
(a). Si L1 y L2 son idnticos, retornar NIL.
(b). De otro modo
Si L1 es una variable,
Entonces si L1 aparece en L2 retornar FAIL (falla)
De otro modo retornar (L2/L1).
(c). De otro modo
Si L2 es una variable,
Entonces si L2 aparece en L1 retornar FAIL (falla)
De otro modo retornar (L1/L2).
(d). De otro modo retornar FAIL (falla).
2. Si los smbolos de predicado iniciales en L1 y L2 no son idnticos,
entonces, retornar FAIL (falla).
3. SI L1 y L2 tienen diferente nmero de argumentos, retornar FAIL (falla).
4. Asignar a SUBST la constante NIL. (Al trmino de la ejecucin de ste
algoritmo, SUBST contendr todas las sustituciones efectuadas para unificar L1 y L2).
5. Para i = 1 hasta el nmero de argumentos en L1, repetir lo siguiente :
(a). Llamar Unificar con los siguientes argumentos: el isimo elemento de
L1 y el isimo elemento de L2, asignar el resultado de la llamada a S.
(b). Si S es igual a FAIL , entonces retornar FAIL (falla).
(c). Si S no es igual a NIL, entonces,
i). Aplicar S a lo que resta tanto de L1 como de L2.
ii). SUBST := APPEND(S, SUBST).
6. Retornar SUBST.
Ejemplo. Los predicados siguientes :
odia(x, y)
odia(Marco, z)
se unifica con la siguiente sustitucin, luego de aplicar el algoritmo :
(Marco/x, z/y)
Algoritmo de resolucin.
El algoritmo de unificacin es til para determinar si dos predicados son contradictorios:
lo son si uno de ellos puede unificarse con la negacin del otro. As, para usar la
resolucin en lgica de predicados, utilizaremos el algoritmo de unificacin para localizar
pares de predicados que se puedan cancelar mutuamente.
Tambin debemos utilizar el unificador producido por el algoritmo de unificacin para
generar la clusula resolvente. Por ejemplo, supongamos que queremos resolver las dos
clusulas :

hombre(Marco)
37
hombre(x1) mortal(x1)
el predicado hombre(Marco) se puede unificar con el predicado hombre(x1) con la

sustitucin siguiente: Marco/x1; pero la segunda clusula nos dice que para un x1 dado,
hombre(x1) mortal(x1) es cierto, por lo cual, debemos concluir que mortal(Marco)
debe ser tambin cierto.
As pues, el resolvente generado por las clusulas 1 y 2 debe ser mortal(Marco) que se
obtuvo aplicando el resultado del proceso de unificacin al resolvente mortal(x1) :
hombre(Marco)
hombre(x1) mortal(x1)
mortal(Marco)
el proceso de resolucin puede continuar ahora para descubrir si mortal(Marco) conduce a

una contradiccin con las otras clusulas disponibles.
Algoritmo Resolucin.
[Supone un conjunto de sentencias F y una sentencia S que queremos demostrar.]
1. Convertir todas las sentencias de F a forma clausular.
2. Invertir S y convertir el resultado a forma clausular. Adicionarlo al conjunto de
clusulas obtenidas en el paso 1.
3. Repetir hasta que, se encuentre una contradiccin, no pueda realizarse ningn
progreso, se haya consumido una cantidad de esfuerzo predeterminada :
1. Seleccionar dos clusulas. Llamarlas clusulas padres.
2. Resolverlas. El resolvente ser la disyuncin de todos los predicados de ambas
clusulas padres, habiendo realizado las sustituciones apropiadas con la siguiente
excepcin: si existe un par de predicados T1 y T2 tales que una de las
clusulas padres contenga T1 y la otra contenga T2, y si T1 y T2 son
unificables, entonces ni T1 ni T2 deben aparecer en el resolvente.
Llamaremos a T1 y T2 predicados complementarios. Usar la sustitucin producida
por la unificacin para crear el resolvente.
3. Si el resolvente es la clusula vaca, se ha encontrado una contradiccin.
Si no lo es, adicionarla al conjunto de clusulas disponibles para el procedimiento.
Ejemplo de demostracin por resolucin.
Demostrar : odia(Marco, Csar)
Axiomas en forma clausular :
1. hombre(Marco).
2. pompeyano(Marco).
3. pompeyano(x1) romano(x1).
4. gobierna(Csar).
5. romano(x2) leal(x2, Csar) odia(x2, Csar).
6. leal(x3, f1(x3)).
7.hombre(x4) gobierna(y1) intentaasesinar(x4,y1) leal(x4,y1).
38

8. intentaasesinar(Marco, Csar).
odia(Marco, Csar)
romano(Marco) leal(Marco,Csar)
pompeyano(Marco) leal(Marco,Csar)
7
1
4
leal(Marco,Csar)
hombre(Marco) gobierna(Csar) intentaasesinar(Marco,Csar)

gobierna(Csar) intentaasesinar(Marco,Csar)
intentaasesinar(Marco,Csar)
8
[]
Figura 4.3. Demostracin por resolucin.

4.7. Respuesta a preguntas.
El origen de los mtodos para extraccin de respuestas por resolucin se inici con Green
en 1969; El mtodo de Green consiste en adicionar a todas las clusulas que en el proceso
de refutacin provengan de la negacin de la conclusin, un predicado 'respuesta(y)'. Para
entender la aplicabilidad del mtodo presentaremos un ejemplo :
1. "Antonio estudia lo mismo que Juan".
(x)estudia(Juan,x) estudia(Antonio,x)
2. "Juan estudia Ingeniera".
estudia(Juan, Ingeniera)
De las premisas anteriores debe ser deducible que
"Antonio estudia algo"
es decir,
(y)estudia(Antonio,y)
En forma clausular :
1. estudia(Juan,x) estudia(Antonio,x).
2. estudia(Juan, Ingeniera)
3. estudia(Antonio,y).
estudia(Juan,x) estudia(Antonio,x).
estudia(Antonio,Ingeniera) estudia(Antonio,Ingeniera)
[]
por lo tanto es deducible que: (y)estudia(Antonio,y)
Si adicionamos el predicado 'respuesta(y)' para el ejemplo anterior :
estudia(Juan,x) estudia(Antonio,x).
estudia(Antonio,Ingeniera) estudia(Antonio,Ingeniera) respuesta(y)

respuesta(Ingeniera)
Por lo tanto, podemos concluir que "Antonio estudia Ingeniera".
4.8. Ejercicios.
1). Encontrar una refutacin para el siguiente conjunto de clusulas incompatible :
[P Q R] [S T] [T P] S R [S U] [U Q]
2). Convertir a forma clausular las siguientes frmulas :
a). (x)[P(x) p(x)]
b). {{(x)P(x)}} (x)[P(x)]
c). (x){P(x) {(y)[P(y) p(f(x,y))] (y)[Q(x,y) P(y)]}}
d). (x)(y){[P(x,y) Q(x,y)] [Q(y,x) S(x,y)]}
(x)(y)[P(x,y) S(x,y)]
3). A partir de las siguientes sentencias :
Cualquiera que sabe leer est alfabetizado.
Los delfines no estn alfabetizados.
39

Algn delfn es inteligente.
demostrar la sentencia :
Alguien que es inteligente no sabe leer.
40
41
5. Reglas de produccin y redes.

5.1. Reglas de produccin.
Consideremos un problema sencillo de fuga de agua en alguna tubera domstica : se trata
de encontrar la habitacin donde ocurre la fuente del problema; el esquema para ste
problema se muestra en la figura 5.1., la fuga puede ocurrir en el bao en la cocina, pero
no puede ocurrir en ambas partes al mismo tiempo; en cualquiera de los dos casos el
problema afecta la sala mojando el piso; en la figura 5.2. se muestra la red de inferencias
para el problema, el cual es, de hecho un grafo AND/OR.
De acuerdo al formalismo para representar el conocimiento que estamos tratando, una
regla de produccin para este problema podra ser como sigue :
SI sala_mojada AND bao_seco
ENTONCES problema_en_la_cocina.
ventana
cocina
bao
sala
Figura 5.1. Problema de la fuga de agua.

cocina_seca
fuga_en_el_bao
sala_mojada
problema_en_la_cocina
bao_seco
fuga_en_la_cocina
ventana_cerrada
no_entra_agua_de_afuera
no_hay_lluvia
Figura 5.2. Grafo AND/OR del problema.
Encadenamiento hacia atrs.
42
El razonamiento con encadenamientos hacia atrs se denomina as porque parte de una

hiptesis (fuga en la cocina) encadenando reglas hasta los elementos de evidencia (sala
mojada, ... ); sto es fcil de programar en prolog porque de hecho prolog est construido
con ste mismo tipo de razonamiento; el modo ms directo es escribir las reglas de la base
de conocimientos como reglas en prolog :
fuga_en_el_bano :cocina_seca ,
sala_mojada .
problema_en_la_cocina :sala_mojada ,
bao_seco .
no_entra_agua_de_afuera :ventana_cerrada ;
no_hay_lluvia .
fuga_en_la_cocina :problema_en_la_cocina ,
no_entra_agua_de_afuera .
Los elementos de evidencia se pueden establecer como hechos en prolog :
sala_mojada.
bao_seco.
no_hay_lluvia.
La hiptesis se puede verificar ahora con :
?- fuga_en_la_cocina .
yes
Sin embargo, utilizar la sintaxis de prolog para escribir las reglas tiene las siguientes
desventajas :
1). La sintaxis puede no ser recomendable para usuarios que no estn familiarizados con
prolog; por ejemplo, los expertos en el dominio de conocimientos que proporcionaran las
reglas, las consultaran y las modificarn.
2). La base de conocimientos no es sintcticamente distinguible del resto del programa; es
deseable una distincin ms explcita.
Si utilizamos la notacin de los operadores de prolog podemos disear la sintaxis de las
reglas en forma ms clara y precisa; por ejemplo, podemos elegir las palabras claves "si",
"entonces", "o", "y" como operadores en prolog declarndolos del siguiente modo :
:- op( 800, fx, si).
:- op( 700, xfx, entonces).
:- op( 300, xfy, o).
:- op( 200, xfy, y).
43
sto nos permite escribir las reglas de produccin de la figura 5.2. en la siguiente forma :
si cocina_seca y sala_mojada
entonces fuga_en_el_bao.
si sala_mojada y bao_seco
entonces problema_en_la_cocina.
si ventana_cerrada o no_hay_lluvia
entonces no_entra_agua_de_afuera.
si problema_en_la_cocina y no_entra_agua_de_afuera
entonces fuga_en_la_cocina.
Los elementos de evidencia (hechos observados) se pueden escribir con una relacin
hecho :
hecho( sala_mojada ).
hecho( bao_seco ).
hecho( no_entra_agua_de_afuera ).
Ahora necesitamos un intrprete para las reglas escritas con sta nueva sintaxis. Este
intrprete lo podemos definir con el siguiente procedimiento :
es_cierto( P )
donde la proposicin P est dada en la relacin hecho puede deducirse utilizando las
reglas. El intrprete se muestra en la figura 5.3. y puede responder a la pregunta :
?- es_cierto( fuga_en_la_cocina ) .
yes
una gran desventaja todava de stos ejemplos es la de que los hechos observados tienen
antes que escribirse como tales; lo correcto es que debe existir un dilogo con el usuario
para establecer estos hechos.
44
% Un intrprete elemental de reglas con

% encadenamiento hacia atrs.
:- op( 800, fx, si).
:- op( 300, xfy, o).
:- op( 200, xfy, y).
es_cierto( P ) :hecho( P ) .
es_cierto( P ) :si Condicion entonces P ,
es_cierto( Condicion ) .
es_cierto( P1 y P2) :es_cierto( P1 ) ,
es_cierto( P2 ) .
es_cierto( P1 o P2 ) :es_cierto( P1 ) ;
es_cierto( P2 ) .
Figura 5.3. Encadenamiento hacia atrs.
Encadenamiento hacia adelante.
El encadenamiento hacia adelante no comienza tratando de probar una hiptesis, sino que
intenta deducir los hechos que pueda deducir;
Para la base de conocimientos del ejemplo, el intrprete se ejecutar de la siguiente forma :
?- forward .
Deduzco : problema_en_la_cocina
Deduzco : el_agua_no_viene_de_fuera
Deduzco : fuga_en_la_cocina
No hay ms hechos
% Un intrprete elemental de reglas con

% encadenamiento hacia adelante.
:- op( 800, fx, si).
:- op( 300, xfy, o).
:- op( 200, xfy, y).
forward :nuevo_hecho_deducido( P ) ,
!,
write( 'Deduzco : ' ), write( P ), nl,
assert( hecho( P ) ) ,
forward
;
write( 'No hay ms hechos' ) .
nuevo_hecho_deducido( Conclusion ) :si Condicin entonces Conclusin ,
not hecho( Conclusin ) ,
hecho_compuesto( Condicin ) .
hecho_compuesto( Condicin ) :hecho( Condicin ) .
hecho_compuesto( Cond1 y Cond2 ) :hecho_compuesto( Cond1 ) ,
hecho_compuesto( Cond2 ) .
hecho_compuesto( Cond1 o Cond2 ) :hecho_compuesto( Cond1 ) ;
hecho_compuesto( Cond2 ) .
Figura 5.4. Encadenamiento hacia adelante.
45
46
5.2. Redes.
Se emplean principalmente grficas dirigidas tales como grficas relacionales, redes
semnticas, redes conceptuales y otras.
5.2.1. Redes semnticas.
Las redes semnticas fueron propuestas por Ross Quillian en 1966 como un medio para
codificar el significado de las palabras del lenguaje natural; en una red semntica la
informacin se representa como un conjunto de nodos conectados entre s por medio de
arcos etiquetados, que representan las relaciones entre los nodos; la idea principal parte de
que el significado de un concepto se infiere de los modos en que ste se encuentra
relacionado con otros conceptos. En la figura 5.5. se muestra un fragmento de una red
semntica.
Mamfero
es_un
Persona
Verde
color_de
uniforme
es_parte_de
Nariz
instancia
Jorge
Campos
equipo
Mxico
Figura 5.5. Red Semntica.

esta red contiene ejemplos de las relaciones generales instancia, es_un, y es_parte_de as
como de las relaciones especficas color_de_uniforme, y equipo; en esta red de ejemplo
podemos utilizar la propiedad de la herencia para inferir la relacin adicional :
es_parte_de( Jorge_Campos, Nariz)
Implementacin.
En la figura 5.6. se presenta una red semntica que representa los siguientes hechos : un
pjaro es un tipo de animal, volar es el mtodo normal para moverse de los pjaros, un
albatros es un pjaro y, Alberto y Rosa son albatros.
47
animal
es_un
luz_del_da
activo_en
pjaro
mtodo_para
moverse
es_un
es_un
albatros
color
es_un
Kim
es_un
activo_en
Rosa
es_un
Alberto
volar
kiwi
color
noche
mtodo_para
moverse
caf
caminar
blanco_y_negro
Figura 5.6. Red Semntica.

sta red se puede trasladar fcilmente a hechos en prolog tales como :
es_un( pjaro, animal).
es_un( rosa, albatros).
mtodo_para_moverse( pjaro, volar).
mtodo_para_moverse( kiwi, caminar).
en adicin a los hechos anteriores que estn explcitamente establecidos, se pueden inferir
otros hechos a partir de la red; un ejemplo tpico de inferencia es la propiedad de la
herencia; por ejemplo, el hecho 'el albatros vuela' se hereda del hecho 'los pjaros vuelan';
de manera similar podemos inferir 'Rosa vuela' y 'Kim camina'; los hechos se heredan al
travs de la relacin es_un; en prolog podemos enunciar que el mtodo para moverse es
heredado como :
mtodo_para_moverse( X, Mtodo) :es_un( X, SuperX) ,
mtodo_para_moverse( SuperX, Mtodo).
48
as, podramos establecer una regla para cada relacin que pudiera 'heredarse', aunque
podemos tambin escribir una regla ms general acerca de los hechos explcitamente
establecidos heredados :
hecho( Hecho ) :Hecho, ! .
hecho( Hecho ) :Hecho = .. [ Rel, Arg1, Arg2 ] ,
es_un( Arg1, SuperArg ) ,
SuperHecho = .. [ Rel, SuperArg, Arg2 ] .
a la red semntica puede hacrsele la siguiente pregunta :
?- hecho( mtodo_para_moverse( kim, Mtodo) ) .
Mtodo = caminar
lo cual fu heredado del hecho explcito de que los kiwis caminan; por otra parte :
?- hecho( mtodo_para_moverse( alberto, Mtodo) ) .
Mtodo = volar
se hered de la clase pjaro.
49
6. Objetos estructurados y procedimientos.

6.1. Objetos Estructurados.
Se utilizan prototipos de objetos como modelos de comparacin con otros objetos sujetos
a estudio anlisis.
6.1.1. Marcos (frames).
Se utilizaron inicialmente por Minsky (1975) en la comprensin de imgenes y lenguaje
natural. Un marco es una coleccin de slots (compartimientos) con valores asociados que
describen alguna entidad en el mundo.
Implementacin.
Retomemos nuevamente el ejemplo de la figura 5.6. : cuando un marco representa una
clase de objetos tales como los albatros y otra marco representa una superclase de sta
clase (tales como los pjaros) entonces el marco que representa la clase puede heredar los
valores del marco que representa la superclase.
El conocimiento acerca de los pjaros se puede almacenar en marcos como los siguientes
MARCO : pjaro
un_tipo_de : animal
mtodo_para_moverse : volar
activo_en : 'luz del da'
ste marco es vlido para la clase de todos los pjaros; los marcos para dos subclases de
pjaros podran ser :
MARCO : albatros
un_tipo_de : pjaro
color : 'blanco y negro'
tamao : 115
MARCO : kiwi
un_tipo_de : pjaro
mtodo_para_moverse : caminar
activo_en : noche
color : caf
tamao : 40
el albatros es un pjaro tpico y hereda la habilidad de volar y las actividades a la luz del
da del marco pjaro, por ello, no es necesario establecer stos hechos en el marco
albatros; el kiwi no es un pjaro tpico y sus valores para 'activo_en' y
'mtodo_para_moverse' deben escribirse.
Podemos tambin tener una instancia particular de una clase; por ejemplo, el albatros
llamado Alberto :
MARCO : Alberto
instancia_de : albatros
50
tamao : 120
es importante destacar la diferencia entre las dos relaciones un_tipo_de e instancia_de; la
primera es la relacin entre una clase y una superclase, mientras que la segunda es la
relacin entre un miembro de una clase y la clase. Los marcos anteriores se pueden
representar en prolog como una serie de hechos, un hecho por cada valor; por ejemplo :
Nombre_del_marco( Slot, Valor)
en la figura 6.1. se presentan algunos marcos con ste formato.
Para manipular los marcos necesitamos un procedimiento para recuperar hechos a partir
de los valores de los slots :
valor( Marco, Slot, Valor )
donde Valor es el valor del slot Slot en el marco Marco; si el valor existe explcito en el
marco, entonces se recupera dicho valor, de otro modo el valor se obtiene al travs de un
proceso de inferencia (por ejemplo la herencia).
Para encontrar un valor por medio de la herencia tenemos que movernos del marco actual
a otro ms general de acuerdo con la relacin un_tipo_de la relacin entre marcos
instancia_de. Este proceso nos lleva a un marco "padre" en el cual los valores pueden
encontrarse explcitos al travs de otros procesos de herencia :
% Un marco se representa con un conjunto de hechos del tipo :

%
nombre_del_marco( Slot, Valor )
% donde Valor es un valor simple una llamada a un procedi% miento que devolver el valor.
% Marco para un pjaro tpico.
pjaro( un_tipo_de, animal).
pjaro( mtodo_para_moverse, volar).
pjaro( activo_en, luz_del_dia ).
% Marco para un albatros; es un pjaro tpico con algunos hechos
% adicionales : color blanco y negro, mide 115 cm de largo.
albatros( un_tipo_de, pjaro).
albatros( color, blanco_y_negro).
albatros( tamao, 115).
% Marco para un kiwi; es un pjaro no muy comn que camina
% y est activo en la noche.
kiwi( un_tipo_de, pjaro).
kiwi( mtodo_para_moverse, caminar).
kiwi( activo_en, noche).
kiwi( tamao, 40).
kiwi( color, caf).
% Marco para alberto; es una instancia de un albatros adulto.
alberto( instancia_de, albatros).
alberto( tamao, 120).
% Marco para rosa; es una instancia de un albatros beb.
rosa( instancia_de, albatros).
rosa( tamao, 40).
% Marco para un animal; el slot tamao_relativo obtiene su
% valor ejecutando el procedimiento 'tamao_relativo'.
animal( tamao_relativo,
execute( tamao_relativo( Objeto, Valor),
Objeto, Valor ) ) .
Figura 6.1. Ejemplos de marcos.
51
52
valor( Marco, Slot, Valor ) :Pregunta = .. [ Marco, Slot, Valor ] ,

call( Pregunta ) , ! .
valor( Marco, Slot, Valor ) :padre( Marco, MarcoPadre ) ,
valor( MarcoPadre, Slot, Valor ) .
padre( Marco, MarcoPadre ) :( Pregunta = .. [ Marco, un_tipo_de, MarcoPadre ] ;
Pregunta = .. [ Marco, instancia_de, MarcoPadre ] ) ,
call( Pregunta ) .
lo cual es suficiente para responder a preguntas como las siguientes :
?- valor( alberto, activo_en, Activo_en ) .
Activo_en = luz_del_dia
?- valor( kiwi, activo_en, Activo_en ) .
Activo_en = noche
Ahora consideraremos un caso ms complicado de inferencia cuando en el slot se
especifica un procedimiento para calcular el valor en lugar del valor mismo. Por ejemplo,
un slot para todos los animales podra ser su tamao relativo respecto al tamao tpico de
una instancia anterior de sus especies. Establecidos en porcentajes para los albatros del
ejemplo (alberto y rosa), los tamaos relativos son : alberto 104% y rosa 35%. Estos
valores se obtienen como la razn en porcentaje entre el tamao de un individuo particular
y el tamao tpico de esta clase de individuos. Para rosa es :
(40 / 115) * 100% = 34.78%
As, el valor del slot tamao_relativo se obtiene ejecutando un procedimiento. Este
procedimiento es universal para todos los animales, de tal modo que es lgico definir el
slot tamao_relativo en el marco para los animales y llenarlo con el llamado al
procedimiento correspondiente. El intrprete de marcos valor debe ahora ser capaz de
responder a la pregunta :
?- valor( rosa, tamao_relativo, R ) .
R = 34.78
El procedimiento para obtener el tamao relativo se puede implementar en prolog con el
siguiente predicado :
tamao_relativo( Objeto, TamaoRelativo ) :valor( Objeto, tamao, TamaoObjeto) ,
valor( Objeto, instancia_de, ClaseObjeto ) ,
valor( ClaseObjeto, tamao, TamaoClase ) ,
TamaoRelativo is TamaoObjeto / TamaoClase * 100 .
Ahora s podemos llenar el slot tamao_relativo en el marco para los animales con una
llamada a ste procedimiento :
53
animal( tamao_relativo,
execute( tamao_relativo( Objeto, Valor), Objeto, Valor ) ) .
Enseguida debemos modificar el procedimiento valor para que pueda manejar slots con
procedimientos :
valor( Marco, Slot, Valor ) :- valor( Marco, Marco, Slot, Valor ) .
%
valor( Marco, SuperMarco, Slot, Valor ) :Pregunta = .. [ SuperMarco, Slot, Informacin ] ,
call( Pregunta ) ,
procesar( Informacin, Marco, Valor ) , ! .
% Inferir un valor por medio de la herencia.
valor( Marco, SuperMarco, Slot, Valor ) :padre( SuperMarco, MarcoSuperPadre ) ,
valor( Marco, MarcoSuperPadre, Slot, Valor ) .
% procesar( Informacin, Marco, Valor ).
procesar( execute( Meta, Marco, Valor ), Marco, Valor ) :! , call( Meta ) .
procesar( Valor, _, Valor ) .
6.2. Procedimientos.
La representacin mediante procedimientos utiliza un lenguaje de alto nivel en el
tratamiento de los conocimientos en forma explcita mediante un programa. El
comportamiento del programa est dirigido por instrucciones. Los conocimientos que
trata no se expresan en forma declarativa sino que se encuentran a travs de todo el
programa. Un ejemplo interesante de lenguaje procedural que facilita stas caractersticas
es PLANER (Hewitt 72). La controversia entre la estrategia procedural y declarativa
presenta amplias discusiones (Winograd 75); sin embargo, ninguna de las dos se
contrapone, de ah que el balance entre una y otra utilizacin depende de las caractersticas
del problema a tratar.
6.3. Conclusiones.
El estudio de los programas de aplicacin producidos dentro de la IA incluye la
representacin de conocimientos que utilizan, de ah que no es evidente la delimitacin de
una frontera rigurosa en el estudio de stos temas por s mismos. Se puede afirmar que
una aplicacin normalmente utiliza ms de un tipo de formalismo para la representacin de
conocimientos; la seleccin de stos repercute en la eficiencia de los sistemas.
54
Aplicaciones.
7. Aplicaciones.
En ste captulo se presenta una taxonoma de las aplicaciones de la Inteligencia Artificial,
as como algunas recomendaciones de libros y artculos relacionados; se recomienda que el
estudiante debe leer entre diez y quince artculos durante el semestre para que se pueda
familiarizar con la forma en que se estn desarrollando actualmente las aplicaciones de I.A.
7.1. Programacin Automtica.
Comprende la elaboracin de programas de apoyo para el usuario en el desarrollo de otros
programas.
7.1.1. Construccin de programas.
Un sistema capaz de comprender el enunciado de un problema especfico en un lenguaje
que no es de programacin; y a partir de sta interpretacin resolver el problema
ensamblando programas ya probados.
7.1.2. Verificacin de programas.
A partir de las especificaciones de un problema, as como de la interpretacin del sentido
de su solucin, un programa inteligente establece cuando un problema tiene solucin.
7.1.3. Programacin asistida por computadora.
Aqu se estudian los programas que sirven de herramienta a un usuario programador en la
comprensin de mensajes en lenguaje natural; para ello cuenta con subrutinas que
depuran, localizan y explican las acciones a efectuar.
7.1.4. Referencias.
1. The handbook of artificial intelligence. Vol. I, II, y III.
A. Barr; E. A. Feigenbaum. / William Kaufmann Inc. 1982.
2. Symbolic logic and mechanical theorem proving.
C. L. Chang; R. C. Lee. / Academic Press, 1973.
3. Artificial Intelligence Programming.
E. Charniack; C. Riesbeck; D. McDermott. / Laurence Erlbaum, 1980.
4. Logic for problem solving. / R. A. Kowalski. / North Holland, 1979.
5. Problem solving methods in artificial intelligence.
N. J. Nilsson. / Mc Graw-Hill, 1971.
6. Automatic generation of computer programs. Computers, Vol. 16.
M. Rubinoff; M. Yovits; (ed.). / Academic Press, 1977.
7. A global view of automatic programming.
Proceedings of the 3rd international conference on artificial intelligence.
pp. 494-499., 1973.
7.2. Deduccin.
El estudio de los mecanismos para ejecutar inferencias tales como : aplicacin de reglas,
demostracin de teoremas, deduccin de respuestas a preguntas, mtodos de planeacin,
resolucin de problemas y otros.
55
7.2.1. Mtodos directos.

Este mtodo se basa en reglas de inferencia como : instanciaciones universales y
existenciales, modus ponens; tambin los sistemas formales entre ellos los de Hilbert,
Gentzen, Fitch (deduccin natural), tc.
7.2.2. Mtodos de refutacin.
Los mtodos basados en probar la inconsistencia de la negacin mediante un conjunto de
axiomas; por ejemplo, los mtodos basados en el principio de resolucin.
7.2.3. Mtodos informales.
Los mtodos que emplean el "sentido comn" mediante reglas de inferencia como su
medio de razonamiento.
7.2.4. Lgicas no estndares.
Las aplicaciones de la lgica no clsica: lgica difusa, modal, intencional, polivalente y
otras.
7.2.5. Referencias.
1. Symbolic logic and mechanical theorem proving.
C.L.Chang; R.C.Lee. / Academic Press, 1973.
2. Artificial intelligence programming.
E. Charniack; C. Riesbeck; D. McDermott. / Laurence Erlbaum. 1980.
3. Logic for problema solving. / R.A.Kowalski. / North Holland. 1979.
4. Principles of artificial intelligence.
J. Nilsson. / Tioga Publishing Company. 1980.
5. Heuristics. Intelligent search strategies for computer problem solving.
J. Pearl. / Addison-Wesley. 1984.
6. Cmo plantear y resolver problemas. / G. Polya. / Trillas. 1985.
7. Artificial intelligence. 2a.ed. / E. Rich; K.Knight. / Mc Graw-Hill. 1991.
8. Artificial intelligence. / P.Winston. / Addison-Wesley. 1985.
7.3. Aprendizaje.
El estudio del diseo de programas capaces de modificar su comportamiento durante su
ejecucin.
7.3.1. Formacin de conceptos.
Los mtodos de formacin de modelos usados para decidir si los elementos de un
conjunto pertenecen a una clase especfica; las redes y los rboles de decisin son un
ejemplo de stos.
7.3.2. Inferencia gramatical.
Los mtodos que permiten la construccin de gramticas que pueden ser usados para
generar elementos pertenecientes a una clase, decidir si algunos elementos son miembros
de una clase determinada.
7.3.3. Inferencia inductiva.
56
Los mtodos que comprenden la formacin de reglas, los cuales pueden ser usados por
mtodos de inferencia inductiva.
7.3.4. Parmetros con cierto peso.
El ajuste de los coeficientes de evaluacin funciones de decisin, son un ejemplo tpico.
7.3.5. Referencias.
2. Introduction to artificial intelligence.
E. Charniack; D. McDermott. / Addison-Wesley. 1985.
3. Artificial intelligence. / E. Hunt. / Academic Press. 1975.
5.Planning and understanding.A computational approach to human reasoning.
R. Wilensky. / Addison-Wesley. 1983.
7.4. Procesamiento del lenguaje natural.
El estudio de cmo disear y construir programas que traten el lenguaje natural como
parte de las tareas bajo el cual se construy el sistema.
7.4.1. Comprensin de la voz.
7.4.2. Anlisis lexicogrfico.
La representacin interna del sentido de un texto escrito bajo una sintaxis de un lenguaje,
por ejemplo, el denominado como natural.
7.4.3. Anlisis del discurso.
La interpretacin de un texto que comprende mltiples frases, como son las historietas, los
dilogos, tc.
7.4.4. Generacin del lenguaje.
La interpretacin de la representacin interna de un texto para contestar preguntas,
comandar un robot, tc.
7.4.5. Generacin del discurso.

La generacin de textos de mltiples frases coherentes y bien expresadas son parte de ste
campo.
7.4.6. Sntesis de voz.
Incluye la generacin mecnica de voz y los problemas asociados a la produccin de
patrones.
7.4.7. Referencias.
1. Understanding natural language. / T. Winograd. / Academic Press. 1972.
57
2. Language as a cognitive process.

T. Winograd. / Addison-Wesley. 1983.
5.Planning and understanding.A computational approach to human reasoning.
R. Wilensky. / Addison-Wesley. 1983.
6. LISP. / P. Winston; B. Horn. / Addison-Wesley. 1985.
7.5. Resolucin de problemas.
Se puede subdividir en :
7.5.1. Teora de juegos.
Los ms tpicos son aqullos que tienen un adversario como en el ajedrez.
7.5.2. Bsqueda heurstica.
Estudio de mtodos de bsqueda, espacios de bsqueda, operadores para guiar la
bsqueda, tc.
7.5.3. Planeacin.
Estudio de mtodos para la construccin de programas que desarrollan planes, en el
proceso de solucin.
7.5.4. Referencias.
1. Heuristics. Intelligent search strategies for computer problem solving.
J. Pearl. / Addison-Wesley. 1984.
2. Cmo plantear y resolver problemas. / G. Polya. / Trillas. 1985.
7.6. Representacin de conocimientos.
Estudio de formalismos y estructuras de datos para la representacin del conocimiento
utilizado en cualquiera de las aplicaciones de la inteligencia artificial.
7.6.1. Redes.
Esta representacin presenta diversos tipos : grficas dirigidas como es el caso de grficas
relacionales, redes semnticas, redes conceptuales, tc.
7.6.2. Clculo de predicados.
Representacin basada en la lgica simblica.
7.6.3. Por procedimientos.
Por medio de procedimientos algortmicos escritos en lenguajes de alto nivel.
7.6.4. Referencias.
58

2. Steps toward artificial intelligence, in computers and thought, e.a.
M. Minsky. / McGraw-Hill. 1963.
7.7. Robtica.
Estudio de mquinas que interactan con su ambiente, real simulado.
7.7.1. Robots de exploracin.
A travs de la "sensibilidad", la mquina se desplaza evitando obstculos y salvando
precipicios.
7.7.2. Robots manipulados.
La mquina hace uso de sensores y efectores terminales para operar objetos.
7.7.3. Referencias.
1. Robot manipulations: mathematics, programming and control.
R. P. Paul. / Cambridge Univ. Press. 1978.
7.8. Visin.
Estudio del diseo de programas que procesan y clasifican la informacin visual.
7.8.1. Programas que tratan objetos en dos dimensiones, as como el contorno de lneas.
7.8.2. Objetos del mundo real y escenas. Un ejemplo es el tratamiento de fotografas y
radiografas.
7.8.3. Movimientos.
Por ejemplo el tratamiento de una serie de imgenes concernientes con el movimiento de
objetos.
7.8.4. Referencias.
1. Computer image processing and recognition.
E. L. Hall. / Academic Press. 1979.
2. Artificial intelligence, an MIT perspective. Vol. II.
H. P. Winston; R. H. Brown. / M.I.T. Press. 1979.
7.9. Software.
El estudio de tcnicas de programacin para crear programas utilizables en ms de un
campo de aplicacin :
7.9.1. Estructuras de control.
59
7.9.1.1. Jerrquicas.
7.9.1.1.1. Recursivas.
7.9.1.1.2. Con retroceso. (bactracking).
7.9.1.2. Heterrquicas.
7.9.1.2.1. Datos directos.
7.9.1.2.2. Corrutinas de comunicacin.
7.9.2. Lenguajes.
Es estudio sobre el diseo de lenguajes que incorporan tcnicas como parte de rutinas
bsicas, datos estructurados y/ estructuras de control. Ejemplos tpicos son los lenguajes
PLANNER, SAIL y STRIPS.
7.9.3. Referencias.
7.10. Sistemas expertos.
Son sistemas especializados que presentan comportamiento inteligente en un campo
particular de la ciencia. Para su estudio la subdivisin de sta rama es de acuerdo a
diferentes aspectos :
7.10.1. Por el dominio de aplicacin :
7.10.1.1. Sistemas qumicos.
Por ejemplo el sistema DENDRAL que infiere estructuras moleculares a partir de los
datos experimentales del espectro de absorcin de masas.
7.10.1.2. Sistemas mdicos.
Ejemplo de stos sistemas es MYCIN, que diagnostica infecciones bacterianas y sugiere
como contrarrestarlas.
7.10.2. Por el objetivo bajo el cual estn diseados :
7.10.2.1. Sistemas de diagnstico.
7.10.2.2. Sistemas de prediccin.
7.10.2.3. Sistemas de interpretacin.
7.10.3. Por el mecanismo de inferencia empleado :
7.10.3.1. Sistemas de mquina de inferencia cero.
7.10.3.2. Sistemas de mquina de inferencia con variables.
7.10.4. Referencias.
1. Inteligencia artificial: sistemas expertos.
J. Cuena; G. Fernndez; R. Lpez de Mntaras; M. Verdejo.
Alianza editorial. 1986.
2. Los sistemas expertos en la empresa.
Benchimol; Levine; Pomerol. / Macrobit. 1990.
3. Sistemas Expertos. Una metodologa de programacin.
Snchez; Beltrn. / Macrobit. 1990.
4. Principios de inteligencia artificial y sistemas expertos.
D.W.Rolston. / Mc Graw-Hill. 1990.
5. Expert System. A practical introduction.
P. S. Sell. / MacMillan. 1985.
6. Building expert systems.
60
F. Hayes-Roth; D.A.Waterman; D.B.Lenat. / Addison-Wesley. 1983.

7. Knowledge acquisition for expert systems.
A. Hart. / Mc Graw-Hill. 1986.
7.11. Redes neuronales.
Estudio del diseo de programas orientados al procesamiento distribuido y aprendizaje;
herramientas de software basadas en redes neuronales; estudio de las aplicaciones de sta
tecnologa a resolver problemas de I.A.
7.11.1. Paradigmas de redes neuronales.
El Perceptrn, red Hopfield, Hamming, Back Propagation, BAM.
7.11.2. Mquinas neuronales.
Mquinas neuronales, hardware para mquinas neuronales, aplicaciones.
7.11.3. Referencias.
2. Neural Networks. An Introduction.
B. Muller and J. Reinhardt. / Springer Verlag, 1991.
3. Artificial Neural Systems. / P. Simpson. / Pergammon Press, 1990.
4. Neural Networks in C++. / Adam Blum. / Wiley and Sons. 1992.
5. Neural Network PC Tools, a practical guide.
R. Eberhart. / Prentice Hall. 1992.

Bibliografia.
1. Inteligencia Artificial: Un enfoque moderno.
Russell, S.; Norvig, P.
Prentice Hall Hispanoamericana, 1996.
2. Inteligencia Artificial, 2a. ed.
Rich, E.; Knight, K.
Mc Graw-Hill, 1994.
3. Inteligencia Artificial: Conceptos, tcnicas y aplicaciones.
Shirai, Y.; Tsujii, J.
Ariel, 1987.
4. Principios de Inteligencia Artificial.
N. J. Nilson.
Springer Verlag.
5. Problems Solving in Artificial Intelligence.
N. J. Nilson.
Mc Graw-Hill.
6. PROLOG. Programming for artificial intelligence. 2a. ed.
Ivn Bratko.
Addison-Wesley. 1991.
7. LISP. 3a.ed.
P.H.Winston; B.K.P.Horn.
Addison-Wesley. 1991.
8. Lgica Informtica.
Jos Cuena.
Alianza Editorial, 1986.
9. Primer Curso Internacional de Sistemas Expertos.
A.M. Martnez; G. Morales; Z. Zdrahal.
CINVESTAV, I.P.N., 1988.
10. La inteligencia artificial y algunas de sus aplicaciones. Vol. I, II y III.
A.M. Martnez; H. Snchez.
CINVESTAV, I.P.N., 1987.
11. Artificial Intelligence: A new Synthesis
Nils J. Nilsson.
Morgan Kaufmann Publishers, 1998.
61

Material IA

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Material IA

Uploaded by

Copyright:

Available Formats

UNIVERSIDAD AUTONOMA DE GUERRERO

Serie: Material de Apoyo a la Maestra en Ciencias de la

Fundamentos de Inteligencia Artificial

Mtodos para la solucin de problemas

Representacin de conocimientos y razonamiento

Fundamentos de Inteligencia Artificial

Fundamentos de Inteligencia Artificial

Estupidez Artificial (E.A.)

Fundamentos de Inteligencia Artificial

Allen Newell ofrece la siguiente lista para un sistema inteligente :

Fundamentos de Inteligencia Artificial

Mtodos para la solucin de problemas.

Fundamentos de Inteligencia Artificial

Figura 2.2. Representacin espacio-estado para el problema

Fundamentos de Inteligencia Artificial

Figura 2.3. El rompecabezas de 8.

Figura 2.4. Representacin espacio-estado para el problema

Fundamentos de Inteligencia Artificial

El problema del juego de ajedrez.

Acabamos de definir el problema de jugar ajedrez como un problema de movimientos a

Fundamentos de Inteligencia Artificial

2.2. Sistemas de Produccin.

Fundamentos de Inteligencia Artificial

Figura 2.6. El problema del agente viajero.

1. Seleccionar arbitrariamente una ciudad de partida.

Fundamentos de Inteligencia Artificial

ste algoritmo se ejecuta en un tiempo proporcional al cuadrado de n lo que representa

Fundamentos de Inteligencia Artificial

3. Mtodos para la solucin de problemas.

3.1. Mtodos Bsicos.

Figura 3.1. Bsqueda en profundidad

Fundamentos de Inteligencia Artificial

Figura 3.2. Bsqueda a lo ancho

Fundamentos de Inteligencia Artificial

Ejemplo 1. El problema del laberinto.

Figura 3.3. Salida de un laberinto.

Figura 3.4. Espacio de estados del problema.

Fundamentos de Inteligencia Artificial

la bsqueda en profundidad pasa de cada nodo a su primer sucesor no revisado: si ste es

(defun path1 (x z p1 g scx)

Fundamentos de Inteligencia Artificial

Fundamentos de Inteligencia Artificial

en la funcin sucd, si el nodo es N, la lista de todos sus sucesores (cdar G) se pasa a la

Figura 3.6. Representacin de la Grfica G.

Fundamentos de Inteligencia Artificial

Fundamentos de Inteligencia Artificial

Fundamentos de Inteligencia Artificial

b). Solucin en Prolog.

Fundamentos de Inteligencia Artificial

Figura 3.7. Representacin de la Grfica G.

Fundamentos de Inteligencia Artificial

[n5,n2,n6], [n6,n2,n5,n9],[n7,n2,n9], [n8,n3,n4,n10],

c). Comparacin de las soluciones.

Fundamentos de Inteligencia Artificial

Representacin de conocimientos y razonamiento.

Fundamentos de Inteligencia Artificial

Para cumplir con el segundo requisito :

Fundamentos de Inteligencia Artificial

-El ltimo elemento de la sucesin Pn, es precisamente la frmula a

Fundamentos de Inteligencia Artificial

2. Generalizacin universal condicional

3. Generalizacin existencial condicional.

Fundamentos de Inteligencia Artificial

En las definiciones anteriores, A y B son frmulas cualesquiera; A(y), B(y), deben