Agentes Basados en Conocimiento: Wumpus World

Aplicando todo lo aprendido a un problema clásico de IA.

Introducción: Poniendo Todo Junto

A lo largo de este módulo hemos aprendido:

• Cómo representar conocimiento (lógica proposicional)
• Cómo derivar nuevas conclusiones (inferencia)
• Qué podemos computar (SAT)

Ahora es momento de aplicar todo esto a un problema concreto. El Wumpus World es un entorno clásico de IA que nos permite ver cómo un agente puede usar lógica para razonar y tomar decisiones en un mundo parcialmente observable.

El Wumpus World: Un Entorno Clásico

El Wumpus World fue introducido por Gregory Yob en 1973 como un juego de computadora y popularizado en el libro “Artificial Intelligence: A Modern Approach” de Russell y Norvig.

La Situación

Imagina que eres un explorador en una cueva oscura. No puedes ver más allá de la celda donde estás. La cueva tiene tesoros, pero también peligros mortales. Tu objetivo: encontrar el oro y salir con vida.

Los Elementos del Mundo

El mundo es una cuadrícula de 4×4 celdas con:

Nota sobre coordenadas: Usamos [columna, fila], donde [1,1] es la esquina inferior izquierda.

¿Qué Puedes Percibir?

Aquí está lo interesante: no puedes ver lo que hay en otras celdas, pero hay pistas:

Importante: “Adyacente” significa arriba, abajo, izquierda o derecha — no en diagonal.

¿Qué Puedes Hacer?

Sistema de Puntuación

Análisis PEAS

Recordando el framework PEAS de la Clase 2:

¿Por qué es interesante?

• Parcialmente observable: No ves todo el mundo, solo tu celda
• Determinista: Las acciones tienen efectos predecibles
• Secuencial: Tus decisiones pasadas afectan el futuro

¿Por Qué No Funciona un Agente Simple?

Intentemos programar un agente reflejo simple:

def agente_simple(percepcion):
    if percepcion.brillo:
        return 'Agarrar'
    if percepcion.brisa:
        return 'Girar'  # ¿Hacia dónde?
    if percepcion.hedor:
        return 'Huir'   # ¿A dónde?
    return 'Avanzar'    # ¿Es seguro?

Problemas:

1. Si hay brisa, ¿hacia dónde giro? No sé dónde está el pozo.
2. Si no hay brisa, ¿puedo avanzar? Tal vez sí, tal vez no.
3. El agente no tiene memoria de lo que ha visto antes.

El problema fundamental: Un agente reflejo solo mira la percepción actual. Pero para determinar si una celda es segura, necesitamos combinar información de múltiples percepciones en diferentes lugares.

Un Ejemplo de Por Qué Necesitamos Razonar

Situación:

• Estuviste en [1,1]: sin brisa, sin hedor
• Avanzaste a [2,1]: ¡sientes brisa!

¿Qué significa esto?

La brisa en [2,1] indica que hay un pozo adyacente a [2,1]. Las celdas adyacentes son: [1,1], [3,1], [2,2].

Pero espera — estuviste en [1,1] y no moriste, así que no hay pozo ahí. Entonces el pozo debe estar en [3,1] o [2,2] (o ambos).

¿Es seguro ir a [2,2]? No lo sabemos todavía. Necesitamos más información.

Este tipo de razonamiento — combinar hechos, eliminar posibilidades, derivar conclusiones — es exactamente lo que la lógica proposicional nos permite hacer de manera sistemática.

Representando el Mundo en Lógica

Para que nuestro agente pueda razonar, necesitamos traducir el mundo a lógica proposicional.

Los Símbolos Proposicionales

Cada cosa que queremos representar necesita su propio símbolo:

Las Reglas del Mundo

Ahora necesitamos expresar cómo funciona el mundo — las “leyes de la física” de Wumpus World.

Regla de la Brisa

“Hay brisa en una celda si y solo si hay un pozo en alguna celda adyacente.”

Para la celda [2,2], esto se escribe: $$B_{2,2} \leftrightarrow (P_{1,2} \lor P_{3,2} \lor P_{2,1} \lor P_{2,3})$$

Esto dice:

• Si hay brisa en [2,2], entonces hay pozo en [1,2], [3,2], [2,1] o [2,3]
• Si hay pozo en alguna de esas celdas, hay brisa en [2,2]

Necesitamos escribir esta regla para cada celda del mapa.

Regla del Hedor

Similar a la brisa: $$S_{x,y} \leftrightarrow (W_{x-1,y} \lor W_{x+1,y} \lor W_{x,y-1} \lor W_{x,y+1})$$

“Hay hedor en [x,y] si y solo si el Wumpus está en alguna celda adyacente.”

El Wumpus es Único

Solo hay un Wumpus. Esto requiere dos tipos de cláusulas:

Al menos un Wumpus existe: $$W_{1,1} \lor W_{1,2} \lor W_{1,3} \lor \cdots \lor W_{4,4}$$

A lo más un Wumpus existe (para cada par de celdas diferentes): $$\neg W_{1,1} \lor \neg W_{1,2}$$ $$\neg W_{1,1} \lor \neg W_{1,3}$$ $$\cdots$$

Esto dice “no pueden estar el Wumpus en [1,1] Y en [1,2] al mismo tiempo”.

Definición de Seguridad

Una celda es segura si no tiene pozo ni Wumpus: $$OK_{x,y} \leftrightarrow (\neg P_{x,y} \land \neg W_{x,y})$$

Ejemplo Completo de Razonamiento

Veamos paso a paso cómo el agente razona.

Estado Inicial

El agente está en [1,1] y percibe: nada (sin brisa, sin hedor, sin brillo).

Añadimos a la base de conocimiento:

• $\neg B_{1,1}$ (no hay brisa en [1,1])
• $\neg S_{1,1}$ (no hay hedor en [1,1])

Primera Inferencia: Celdas Adyacentes a [1,1]

Tenemos la regla de brisa para [1,1]: $$B_{1,1} \leftrightarrow (P_{0,1} \lor P_{2,1} \lor P_{1,0} \lor P_{1,2})$$

Pero [0,1] y [1,0] están fuera del mapa. Simplificando: $$B_{1,1} \leftrightarrow (P_{2,1} \lor P_{1,2})$$

Sabemos que $\neg B_{1,1}$ (no hay brisa). Entonces: $$\neg(P_{2,1} \lor P_{1,2})$$

Aplicando De Morgan: $$\neg P_{2,1} \land \neg P_{1,2}$$

Conclusión: No hay pozo en [2,1] ni en [1,2].

Razonamiento similar con el hedor: $$\neg S_{1,1} \rightarrow \neg W_{2,1} \land \neg W_{1,2}$$

Conclusión: El Wumpus no está en [2,1] ni en [1,2].

¿Son Seguras [2,1] y [1,2]?

Ahora podemos verificar: $$OK_{2,1} = \neg P_{2,1} \land \neg W_{2,1} = True \land True = True$$

¡Sí! Las celdas [2,1] y [1,2] son seguras para visitar.

El Agente se Mueve a [2,1]

Percibe: brisa.

Añadimos: $B_{2,1}$

La regla de brisa para [2,1]: $$B_{2,1} \leftrightarrow (P_{1,1} \lor P_{3,1} \lor P_{2,0} \lor P_{2,2})$$

Simplificando (quitando fuera del mapa): $$B_{2,1} \leftrightarrow (P_{1,1} \lor P_{3,1} \lor P_{2,2})$$

Sabemos que $B_{2,1}$ es verdadero. Además:

• $\neg P_{1,1}$ (el agente empezó ahí, no había pozo)

Entonces: $$P_{3,1} \lor P_{2,2}$$

Conclusión: Hay un pozo en [3,1] o en [2,2], pero no sabemos cuál.

El Agente Explora [1,2]

Regresa a [1,1] y va a [1,2]. Percibe: nada (sin brisa).

Añadimos: $\neg B_{1,2}$

La regla de brisa para [1,2]: $$B_{1,2} \leftrightarrow (P_{0,2} \lor P_{2,2} \lor P_{1,1} \lor P_{1,3})$$

Como $\neg B_{1,2}$: $$\neg P_{0,2} \land \neg P_{2,2} \land \neg P_{1,1} \land \neg P_{1,3}$$

¡Importante! Derivamos $\neg P_{2,2}$.

La Inferencia Final

Teníamos: $P_{3,1} \lor P_{2,2}$ (de la brisa en [2,1]) Ahora sabemos: $\neg P_{2,2}$ (de la ausencia de brisa en [1,2])

Por silogismo disyuntivo: $$\frac{P_{3,1} \lor P_{2,2}, \quad \neg P_{2,2}}{P_{3,1}}$$

Conclusión definitiva: ¡El pozo está en [3,1]!

graph TD
    A["¬B[1,1]<br/>Sin brisa en inicio"] --> B["¬P[2,1] ∧ ¬P[1,2]<br/>Adyacentes seguras"]
    C["B[2,1]<br/>Brisa detectada"] --> D["P[3,1] ∨ P[2,2]<br/>Pozo en una de estas"]
    E["¬B[1,2]<br/>Sin brisa aquí"] --> F["¬P[2,2]<br/>No hay pozo"]
    D & F --> G["P[3,1]<br/>¡Pozo localizado!"]
    
    style G fill:#059669,stroke:#047857,color:#fff

El Algoritmo del Agente

Con todo lo aprendido, podemos esbozar cómo funcionaría el agente:

class AgenteLogico:
    def __init__(self):
        self.KB = BaseDeConocimiento()
        self.posicion = (1, 1)
        self.tiempo = 0
        
        # Añadir reglas del mundo
        self.KB.añadir_reglas_brisa()
        self.KB.añadir_reglas_hedor()
        self.KB.añadir_restricciones_wumpus()
    
    def siguiente_accion(self, percepcion):
        # 1. Registrar lo que percibimos
        self.KB.tell(self.crear_sentencia_percepcion(percepcion))
        
        # 2. Determinar celdas seguras
        celdas_seguras = []
        for celda in self.celdas_adyacentes():
            if self.KB.ask(f"OK_{celda}"):
                celdas_seguras.append(celda)
        
        # 3. Decidir qué hacer
        if percepcion.brillo:
            return 'Agarrar'
        elif celdas_seguras:
            # Ir a una celda segura no visitada
            destino = self.elegir_celda(celdas_seguras)
            return self.planificar_ruta(destino)
        else:
            # No hay opción segura conocida
            return self.evaluar_riesgos()
        
        self.tiempo += 1

Los métodos ask() y tell() son los que implementan la inferencia que vimos en las secciones anteriores.

Limitaciones de Este Enfoque

Aunque funciona, la lógica proposicional tiene limitaciones importantes:

1. Explosión de Símbolos

Para un grid de $n \times n$ necesitamos aproximadamente:

• $n^2$ símbolos para pozos ($P_{x,y}$)
• $n^2$ símbolos para Wumpus ($W_{x,y}$)
• $n^2$ símbolos para brisa ($B_{x,y}$)
• $n^2$ símbolos para hedor ($S_{x,y}$)
• … y más

Para 4×4: ~64 símbolos y cientos de cláusulas. Para 100×100: ~40,000 símbolos. ¡Impráctico!

2. No Podemos Generalizar

Escribimos la misma regla para cada celda: $$B_{1,1} \leftrightarrow \text{(pozos adyacentes a [1,1])}$$ $$B_{1,2} \leftrightarrow \text{(pozos adyacentes a [1,2])}$$ $$\cdots$$

Quisiéramos escribir: “Para toda celda, hay brisa si y solo si hay pozo adyacente.”

Esto requiere lógica de primer orden (variables, cuantificadores), que está fuera del alcance de este módulo.

3. Incertidumbre Irreducible

A veces llegamos a conclusiones como “$P_{3,1} \lor P_{2,2}$” y no podemos avanzar más sin más información.

¿Qué hacemos? Las opciones son:

• Explorar más para obtener información
• Tomar una decisión arriesgada

Pero la lógica no nos dice cuál opción es mejor. Para eso necesitamos probabilidad y utilidad esperada — temas de la Clase 5.

Ejercicios

Conexión con el Resto del Curso

Lo Que Hemos Logrado

En este módulo aprendimos a:

• Representar conocimiento sin ambigüedad (lógica proposicional)
• Derivar conclusiones automáticamente (inferencia)
• Entender los límites computacionales (SAT)
• Aplicar todo a un problema real (Wumpus World)

Lo Que Falta

El Wumpus World nos muestra claramente las limitaciones de la lógica binaria:

La Clase 5 extenderá nuestras herramientas para manejar incertidumbre de manera cuantitativa.

Puntos Clave

1. Wumpus World es un entorno clásico para estudiar agentes que razonan
2. Un agente reflejo simple no funciona — se necesita razonamiento
3. Representamos el mundo con símbolos proposicionales: $P_{x,y}$, $W_{x,y}$, $B_{x,y}$
4. Las reglas del mundo (brisa ↔ pozo adyacente) se codifican como fórmulas
5. El agente combina percepciones de diferentes lugares para inferir hechos
6. La lógica proposicional tiene limitaciones: muchos símbolos, no generaliza, no maneja probabilidad
7. El Wumpus World motiva el estudio de probabilidad y decisiones bajo incertidumbre