Simulación de procesos de Poisson

01 · Punto de partida

De la teoría al generador

Ya sabemos qué es Poisson (Tema 8), qué es λ (Tema 9) y que las esperas son Exp(λ) sin memoria (Temas 11–12). Falta cerrar el círculo: generar arribos en la computadora que cumplan todo eso.

La receta es corta y exacta: se sortean esperas exponenciales y se acumulan hasta el horizonte. Con semilla es repetible; sin ella, cada corrida es otra historia del mismo proceso.

• ¿Cómo se sortea una espera Exp(λ) con un uniforme?
• ¿Cuándo se frena: al superar T?
• ¿Cómo sé que el generador anda: qué test pasa?
• ¿Cómo lo hago repetible sin congelar el azar?

02 · Definición

La receta en tres pasos

Todo simulador Poisson homogéneo hace lo mismo:

Complejidad proporcional a los eventos (λT por réplica): con λT = 1000 y R = 1000 hay un millón de sorteos. Para tasas enormes conviene el método normal o directo Po(λT) por conteo.

03 · Anatomía

Semilla, horizonte y costo

Cuatro decisiones de ingeniería del simulador:

Semilla

Fija la secuencia para depurar y publicar; se varía para estimar. Una figura = una semilla declarada.

Horizonte T

Condición de freno: se acumula mientras Tₖ ≤ T. El último sorteo que supera T se descarta.

Réplicas R

Una réplica es una historia; R = 300+ estima media y varianza. Más R, menos ruido.

Costo λ·T·R

Cantidad de exponenciales sorteadas. Si explota, se muestrea N(T) ~ Po(λT) directo y se uniformizan los instantes.

04 · Ejemplos

Simuladores que usarás ya

La misma receta con distintos λ y T:

1. 1
   Call center (λ = 15/h, T = 8 h).

   ~120 arribos por réplica para dimensionar turnos.

2. 2
   Servidor (λ = 1/s, T = 60 s).

   ~60 requests para test de carga de un minuto.

3. 3
   Fallas (λ = 0,1/día, T = 365).

   ~36 fallas al año para plan de repuestos.

4. 4
   Depuración (λ = 2, T = 5, semilla fija).

   Misma lista siempre: se puede inspeccionar a mano.

5. 5
   Escala (λT = 10⁶).

   Por esperas es lento: conviene conteo directo Po(λT).

05 · Representación en Python

El simulador en diez líneas

En Python, el simulador es una función simular_poisson(T, lam, semilla) que devuelve arribos. Otra función deriva N(t). La verificación usa muchas réplicas.

import random, math

def simular_poisson(T, lam=1.0, semilla=7):
    # Acumula esperas Exp(lam) hasta superar T.
    random.seed(semilla)
    t, arribos = 0.0, []
    while True:
        t += -math.log(1 - random.random()) / lam
        if t > T:
            break
        arribos.append(round(t, 2))
    return arribos

a = simular_poisson(10, lam=1.0, semilla=7)
print("N(10) =", len(a))
print(a)

Ejecutá con semilla 7 y 8: distintas listas, mismo proceso. La semilla fija la historia, no el modelo.

Verificar con media y varianza

El test que todo simulador Poisson debe pasar:

import random, math, statistics

def N_T(T, lam=1.0):
    t, n = 0.0, 0
    while True:
        t += -math.log(1 - random.random()) / lam
        if t > T:
            return n
        n += 1

random.seed(3)
datos = [N_T(10) for _ in range(500)]
print("media:", round(statistics.mean(datos), 2))
print("varianza:", round(statistics.pvariance(datos), 2), "| teoría: 10")

06 · Exploración

Laboratorio: generar y verificar Poisson

Generamos R réplicas por esperas Exp(λ) hasta T. Cada escalera es un N(t); la recta punteada es λt. Abajo, el test: media ≈ varianza ≈ λT. Movete λ y T y exigile al generador que cumpla.

Las escaleras se generan espera por espera; el test se lee en los números. Con pocas réplicas el test fluctúa: subí réplicas para estabilizarlo.

Preguntas para explorar

1. Con 2 réplicas, ¿media y varianza dan 10? ¿Qué le falta al test?
2. Subí réplicas a 12 con igual λ y T. ¿El test mejora? ¿Por qué?
3. Triplicá λ con igual T. ¿Las escaleras se empinan al triple? ¿La varianza también?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: inspeccionar una réplica

Generá una réplica con semilla fija y calculá esperas, N(5) y N(10). Verificá que N crece.

import random, math

def simular_poisson(T, lam=1.0, semilla=7):
    random.seed(semilla)
    t, arribos = 0.0, []
    while True:
        t += -math.log(1 - random.random()) / lam
        if t > T:
            break
        arribos.append(round(t, 2))
    return arribos

a = simular_poisson(10, semilla=7)
N = lambda t: sum(1 for x in a if x <= t)
print(a)
print("N(5) =", N(5), "| N(10) =", N(10))

Ejercicio 2: el test con pocas réplicas

Sin ejecutar primero: con R = 5 y λT = 10, ¿el test será exacto? Comprobalo con R = 5 y R = 1000.

import random, math, statistics

def N_T(T=10, lam=1.0):
    t, n = 0.0, 0
    while True:
        t += -math.log(1 - random.random()) / lam
        if t > T:
            return n
        n += 1

for R in [5, 1000]:
    random.seed(1)
    d = [N_T() for _ in range(R)]
    print(R, round(statistics.mean(d), 2), round(statistics.pvariance(d), 2))

Ejercicio 3: costo λ·T·R

Estimá cuántos sorteos hace tu simulador con λ = 5, T = 100 y R = 200. ¿Conviene por esperas?

print(5 * 100 * 200)

09 · Síntesis

Ideas para recordar

En el próximo tema el ritmo dejará de ser parejo: procesos de Poisson no homogéneos.