Estado del sistema

01 · Punto de partida

La prueba de la pausa

Imaginá que simulás el banco y a las 10:07 tenés que apagar la computadora. Anotás algo en un papel para seguir mañana exactamente donde quedaste. ¿Qué anotás?

Si anotás “hay 4 personas”, ¿alcanza? Mañana no sabrás si el cajero está atendiendo a una (y termina a las 10:09) o si está libre. Si anotás “hay 4, cajero ocupado, termina 10:09, próxima llegada 10:11”, sí podés continuar: cada evento futuro tiene todo lo que necesita.

Ese papel es el estado: lo mínimo que, junto al reloj y al FEL, permite retomar la historia sin adivinar.

• Si pauso ahora, ¿qué necesito para seguir sin preguntarle a nadie?
• ¿Qué dato, si lo borro, me deja sin saber qué hacer ante el próximo evento?
• ¿Qué dato puedo recalcular y por lo tanto no necesito guardar?
• ¿Mi estado cabe en 3 variables o necesito 30?

02 · Definición

Mínimo y suficiente, las dos condiciones

Un conjunto de variables es estado si pasa dos tests:

Ejemplo mínimo del banco con 1 caja: s = (N, ocupado) donde N = personas en sistema y ocupado = 0/1. Con eso: llegada → N+1 y si estaba libre se ocupa; salida → N−1 y si queda N=0 se libera. Nada más hace falta para decidir.

03 · Cómo elegirlo

El test de las tres preguntas

Ante cada variable candidata, preguntate:

1. 1
   ¿La necesito para procesar el próximo evento?

   “Servidor ocupado” sí: sin eso no sé si una llegada espera o se atiende. “Color de las sillas” no.

2. 2
   ¿La puedo derivar de otras?

   Si guardo N y ocupado, la cola sale sola. Guardarla duplica y arriesga inconsistencia (N=5 pero cola=7).

3. 3
   ¿Cambia solo en eventos?

   Si cambia sola con el tiempo (ej. “temperatura que se enfría”), o no es discreto puro o falta un evento que lo actualice. En discretos puros, todo cambio tiene su evento.

Variable de estado

Parte del mínimo suficiente: N, ocupado, stock. Vive en s y la modifican las rutinas.

Variable complementaria

Se deriva del estado: en cola, libres, utilización instantánea. Se calcula, no se guarda.

Parámetro

No cambia en la corrida: nº de cajas, tasa de llegada, capacidad. Configura, no es estado.

Estadística acumulada

Espera total, máximos, atendidos. Crece monótonamente para medir, no para decidir. (Tema 20)

04 · Ejemplos

Cuatro estados que ya sabés leer

1. 1
   Banco 1 caja: s=(2, ocupado).

   Llegada con libre → (3, ocupado). Salida con N=1 → (0, libre). Cola = N − ocupado siempre.

2. 2
   Servidor 3 workers: s=(cola=4, ocupados=3).

   Arribo → cola=5 (nadie libre). Fin → ocupados sigue 3 pero cola=4 (el siguiente toma el worker).

3. 3
   Inventario: s=(stock=6, pedido=no).

   Venta de 2 → (4, no). Si cruza el punto de pedido → (4, sí) y se agenda arribo de reposición.

4. 4
   Urgencias con prioridad: s=(cola_alta=1, cola_baja=3, médicos_ocupados=2).

   Sin separar por prioridad el estado no sabe a quién atender: la granularidad la pide la decisión.

05 · Representación en Python

El estado es un dict; la transición es pura

Guardá el estado en un diccionario (o dataclass) y escribí transiciones como funciones que reciben (estado, evento) y devuelven el nuevo estado. Así podés hacer snapshot con copy() y probar “¿qué pasaría si…?” sin romper nada.

estado = {"N": 2, "ocupado": 1}  # mínimo suficiente (1 caja)

def al_llegar(s):
    s = dict(s)
    s["N"] += 1
    s["ocupado"] = 1
    return s

def al_salir(s):
    s = dict(s)
    s["N"] = max(0, s["N"] - 1)
    if s["N"] == 0:
        s["ocupado"] = 0
    return s

print(al_llegar(estado))  # {'N': 3, 'ocupado': 1}
print(al_salir({"N": 1, "ocupado": 1}))  # {'N': 0, 'ocupado': 0}

# Snapshot: pausar en t=6 y reanudar mañana es copiar el dict + reloj
reloj = 6
snapshot = (reloj, dict({"N": 3, "ocupado": 1}))
print("pausa:", snapshot)

# Mañana: restauro y sigo
reloj2, estado2 = snapshot[0], dict(snapshot[1])
estado2 = {"N": estado2["N"] + 1, "ocupado": 1}  # llega uno en t=7
print("reanudo en", reloj2, "-> tras llegada:", estado2)
print("en cola:", estado2["N"] - estado2["ocupado"], "(derivado, no guardado)")

06 · Exploración

Laboratorio: pausar y reanudar sin perder nada

Elegí llegadas (A), servicio (S) y N(0). La curva muestra N(t) y la barra inferior si el servidor está ocupado. Movete el control pausa en Tp: la ficha muestra el snapshot mínimo para reanudar (N, ocupado, reloj, próximos del FEL). Comprobá que con esos 5 datos alcanza.

Escalera lima: N(t). Banda inferior verde: servidor ocupado; gris: libre. Línea blanca vertical: instante de pausa Tp. Con N, ocupado, reloj y los dos próximos alcanza para seguir.

Preguntas para explorar

1. Con A=2, S=3, N(0)=2 y Tp=6, ¿cuánto valen N, ocupado y en cola? ¿Necesitás algo más para seguir?
2. Buscá un Tp donde N=0. ¿Qué vale ocupado? ¿Y la próxima salida?
3. Si agregaras “en cola” al estado guardado, ¿qué riesgo aparece? Provocá un ejemplo inconsistente.

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: detectar redundancia

Este “estado” guarda de más. ¿Qué sobra y cómo lo derivás?

s = {"N": 4, "ocupado": 1, "en_cola": 3}
print("derivado:", s["N"] - s["ocupado"], "| guardado:", s["en_cola"])  # ¿coinciden?

Ejercicio 2: transición completa

Sin ejecutar primero: con {"N": 0, "ocupado": 0}, ¿qué dejan una llegada y luego una salida?

def llegar(s):
    return {"N": s["N"] + 1, "ocupado": 1}

def salir(s):
    n = max(0, s["N"] - 1)
    return {"N": n, "ocupado": 0 if n == 0 else 1}

s0 = {"N": 0, "ocupado": 0}
print(salir(llegar(s0)))

Ejercicio 3: snapshot que sí reanuda

Guardá reloj + estado en una tupla, modificá una copia y mostrá que el original no se contaminó.

reloj, estado = 6, {"N": 3, "ocupado": 1}
foto = (reloj, dict(estado))  # snapshot
copia = dict(foto[1])
copia["N"] += 1  # experimento "¿y si llega uno?"
print("foto intacta:", foto)
print("copia:", copia)

09 · Síntesis

Ideas para recordar

En el próximo tema conoceremos las entidades: quiénes circulan por el sistema y qué las distingue.