Reglas de decisión

01 · Punto de partida

Del verbo al si-entonces

En el Tema 5 el agente vagaba, comía o descansaba. Pero ¿quién elegía? La regla de decisión es el puente entre lo que el agente ve y lo que hace: una condición explícita del tipo si pasa esto, entonces hago aquello.

Sin reglas escritas, el modelo es una caja negra: nadie puede repetirlo, criticarlo ni mejorarlo. Con reglas claras, dos programadores obtienen el mismo comportamiento.

• ¿Qué condición dispara cada acción?
• ¿Qué umbral separa quedarse de moverse?
• ¿Qué pasa si dos condiciones se cumplen a la vez?
• ¿La regla es siempre igual o a veces tiembla?

02 · Definición

Anatomía de una regla

Toda regla tiene condición, umbral y acción, más un orden cuando compiten:

03 · Calidad

Cómo es una buena regla

Una regla falla más por ambigua que por simple:

Completa

Cubre todos los casos con un si-no final: siempre devuelve alguna acción.

Excluyente

Las condiciones no se pisan o tienen prioridad declarada: primera que cumple, gana.

Legible

Se lee como frase del dominio: “si hacinado, mudarse”, no como álgebra críptica.

Parametrizada

El umbral es un argumento (umbral=3), no un número enterrado en el código.

04 · Diseño

Escribir reglas en tres pasos

El método corto que usaremos en todo el curso:

1. 1
   Listar condiciones.

   Una por acción: ver comida, estar lleno, resto vagar.

2. 2
   Ordenar prioridades.

   La oportunidad primero (comer), luego el estado (descansar), luego el defecto (vagar).

3. 3
   Probar extremos.

   Umbral 0 y umbral gigante: ¿la regla sigue devolviendo algo sensato?

05 · Representación en Python

Decidir es una cascada de if

El orden del código es la prioridad. Leelo de arriba hacia abajo como las reglas del juego.

def decidir(vecinos, umbral=3):
    if vecinos > umbral:
        return "moverse"
    return "quedarse"

for v in [0, 2, 3, 4, 7]:
    print(v, decidir(v, umbral=3))

Con umbral 3, el escalón está entre 3 y 4: un vecino de más cambia la decisión.

Agregar temblor: reglas estocásticas

Los agentes reales a veces hacen lo contrario. El temblor invierte la decisión con probabilidad pequeña: rompe empates y evita parálisis.

import random
random.seed(8)

def decidir_con_temblor(vecinos, umbral=3, temblor=0.1):
    base = "moverse" if vecinos > umbral else "quedarse"
    if random.random() < temblor:
        return "quedarse" if base == "moverse" else "moverse"
    return base

print([decidir_con_temblor(5, temblor=0.3) for _ in range(10)])

06 · Exploración

Laboratorio: el escalón y el temblor

El gráfico muestra la probabilidad de moverse según vecinos percibidos. Sin temblor es un escalón perfecto en el umbral; con temblor, el escalón se ablanda: a veces se queda con muchos vecinos y a veces se mueve con pocos. La línea dorada es tu caso de prueba.

El escalón azul es la regla sin azar; la curva amarilla es la regla con temblor. La línea dorada marca tu caso. Pulsá Probar suerte para sortear un intento con esos valores.

Preguntas para explorar

1. Poné el caso justo en el umbral (3) y luego en 4. ¿Dónde duele más el temblor: lejos o cerca del borde?
2. Subí el temblor a 50 %. ¿La regla todavía decide algo o es una moneda?
3. Bajá el temblor a 0. ¿Qué perdés y qué ganás frente a un temblor 10 %?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: escribir el escalón

Ejecutá y marcá dónde está el escalón. Luego mové el umbral a 5.

def decidir(vecinos, umbral=3):
    return "moverse" if vecinos > umbral else "quedarse"

print([decidir(v) for v in range(7)])

Ejercicio 2: predecir con dos condiciones

Sin ejecutar primero: con 1 vecino y energía 20, ¿qué decide? ¿Y con 5 vecinos y energía 2? Comprobalo después.

def decidir2(vecinos, energia):
    if vecinos > 3:
        return "moverse"
    if energia > 15:
        return "descansar"
    return "vagar"

print(decidir2(1, 20))
print(decidir2(5, 2))

Ejercicio 3: medir el temblor

Con temblor 20 % y 100 intentos sobre el caso 5 (umbral 3), ¿cuántos “quedarse” esperás? Verificalo.

import random
random.seed(9)

def intento(temblor=0.2):
    base = "moverse"  # caso 5 con umbral 3
    return "quedarse" if random.random() < temblor else base

res = [intento() for _ in range(100)]
print(res.count("quedarse"), "quedarse de 100")

09 · Síntesis

Ideas para recordar

En el próximo tema estudiaremos el entorno: el mundo donde esas reglas se ejecutan.