Simulación de Eventos Discretos · Tema 31

Modelo M/M/1

Llegadas y servicios exponenciales con un servidor — el “Hola mundo” con fórmulas exactas para validar tu simulador.

01 · Punto de partida

El único que se resuelve en un renglón

Poisson para llegar, exponencial para atender, un servidor, cupo infinito, FIFO. Con esos cinco supuestos nace el M/M/1: el único sistema con distribución exacta simple (geométrica), medias exactas y hasta distribución del tiempo en sistema. Todo lo demás —M/G/1, prioridades, redes— se mide contra él.

Su rol en tu carrera de simulador es el de testigo: si tu código con arribos Exp y servicios Exp no replica sus números en régimen, el bug es tuyo, no de Erlang.

  • ¿Qué supuestos definen al M/M/1 y qué pasa si ρ ≥ 1?
  • ¿Cómo son Pn, L, Wq con solo (λ, μ)?
  • ¿Cómo valido mi simulador contra sus fórmulas?
  • ¿Qué me dice P0 y qué me dice la cola de la distribución?

02 · Definición

Supuestos, distribución y medidas

λ·μ

Supuestos

Arribos Poisson(λ), servicios Exp(μ), c = 1, K = ∞, FIFO. Sin memoria en ambas puntas.

Pn

Distribución

En régimen, Pn = (1−ρ)ρn. P0 = 1−ρ: fracción ociosa y prob. de no esperar.

L·W

Medidas

L = ρ/(1−ρ), Lq = ρ²/(1−ρ), W = 1/(μ−λ), Wq = λ/(μ(μ−λ)). Little las ata.

M/M/1 en números: λ = 0.25/min, μ = 0.5 (ρ = 0.5).
MedidaFórmulaValorLectura
P0 (ocioso)1 − ρ0.50La mitad del tiempo libre; mitad llega sin espera
L / Lqρ/(1−ρ) / ρ²/(1−ρ)1.0 / 0.51 en sistema, 0.5 en cola en promedio
W / Wq1/(μ−λ) / λ/(μ(μ−λ))4 / 2 min2 de espera + 2 de servicio

03 · El corazón: nacimiento y muerte

Balance que pare una geométrica

λPₙ₋₁=μPₙ→Pₙ = ρⁿP₀

En equilibrio, el flujo que sube de n−1 a n (λPn−1) iguala al que baja de n a n−1 (μPn). De ahí Pn = ρPn−1 y, normalizando, la geométrica. Es un proceso de nacimiento y muerte con tasa de nacimiento λ y de muerte μ constantes: el más simple que existe.

  1. 1
    Verificar ρ < 1.

    Sin estabilidad no hay distribución estacionaria: la cadena se escapa a infinito.

  2. 2
    Plantear balance.

    λP0 = μP1, (λ+μ)Pn = λPn−1 + μPn+1: de cada corte sale Pn = ρnP0.

  3. 3
    Normalizar.

    Σρn = 1/(1−ρ) ⇒ P0 = 1−ρ. Serie geométrica mediante.

  4. 4
    Derivar medias.

    L = ΣnPn = ρ/(1−ρ); W = L/λ (Little); Wq = W − 1/μ.

PASTA
Poisson Arrivals See Time Averages: el que llega ve la distribución Pn. Por eso P(esperar) = 1 − P0 = ρ.
W ~ Exp(μ−λ)
El tiempo en sistema es exponencial de tasa μ−λ. P(W > t) = e−(μ−λ)t: percentiles directos.
Ergodicidad
Promedio temporal = promedio poblacional: tu simulación larga converge a estas fórmulas. Con T corto, no.
Sensibilidad
Todo depende de ρ, no de λ y μ por separado: (λ=1, μ=2) y (λ=50, μ=100) dan igual L, distinto W.

M/M/1

Referencia exacta

Geométrica en N y exponencial en W. Se usa para validar código y para dimensionar rápido con poco dato.

M/D/1 y M/G/1

Misma ρ, otra espera

D da la mitad de Wq; G con gigantes la multiplica (PK). M/M/1 es el punto medio bien portado.

04 · Ejemplos

Tres M/M/1 con nombre

  1. 1
    Caja única poissoniana.

    λ = 20/h, S medio 2 (μ = 30/h): ρ ≈ 0.67, L ≈ 2, Wq ≈ 4 min, P0 ≈ 0.33.

  2. 2
    Impresora.

    λ = 10/h, S medio 3 (μ = 20/h): ρ = 0.5, L = 1, W = 6 min. La mitad no espera.

  3. 3
    Helpdesk nocturno.

    λ = 2/h, S medio 15 min (μ = 4/h): ρ = 0.5 otra vez: igual L, W cuatro veces mayor (escala).

05 · Representación en Python

Una función mm1 y un validador

La teoría cabe en un dict; la validación en un bucle Poisson + Exp con c = 1.

Python en tu navegador. El primero calcula todo M/M/1; el segundo simula y compara P0, L y Wq. Cambiá ρ y mirá la geométrica.

# Todo M/M/1 en una función
def mm1(lam, mu):
    rho = lam / mu
    assert rho < 1, "sin régimen"
    return {"rho": rho, "P0": 1-rho, "L": rho/(1-rho),
            "Lq": rho**2/(1-rho), "W": 1/(mu-lam),
            "Wq": lam/(mu*(mu-lam))}

print(mm1(0.25, 0.5))
# Validar P0, L y Wq simulando (T largo, semilla fija)
import random
random.seed(31)
lam, mu, T = 0.25, 0.5, 500.0
t, libre, area, prev, wqs, idle = 0.0, 0.0, 0.0, 0.0, [], 0.0
N, evs = 0, []
while t < T:
    t += random.expovariate(lam)
    ini = max(t, libre)
    libre = ini + random.expovariate(mu)
    wqs.append(ini - t)
print(f"Wq sim={sum(wqs)/len(wqs):.2f} vs {lam/(mu*(mu-lam)):.2f}")

06 · Exploración

Laboratorio: la geométrica aparece sola

Simulamos M/M/1 hasta T = 200 (semilla = réplica) y medimos la fracción de tiempo en cada N (barras teal) contra Pn = (1−ρ)ρn (barras lima). Subí λ con S fijo: la cola de la distribución se alarga y P0 se hunde.

EXPERIMENTO 31

Simulación que converge a geométrica

Pn = (1−ρ)ρⁿ · T=200

Los resultados numéricos aparecen debajo.
ρ = λS0
P0 sim / teórica0
L sim / teórica0
Wq sim / teórica0

Acercate a ρ = 0.9 para estirar la cola.

Parejas por N: lima = teoría geométrica, teal = fracción de tiempo simulada. Con ρ alta la convergencia pide T largo.

Preguntas para explorar

  1. Con ρ=0.5: ¿P0 sim ≈ 0.5? ¿P3 ≈ 0.06? Cambiá de réplica: ¿cuánto tiembla?
  2. Con ρ=0.75 (λ=0.375, S=2): ¿L teórica? ¿La sim la alcanza con T=200?
  3. ¿Por qué con ρ=0.9 las barras altas (N≥6) difieren más entre réplicas?
Ver respuestas sugeridas
  1. Sí: P0 ~0.48–0.52 y P3 ~0.05–0.08. Con ρ media, T=200 estabiliza bien.
  2. L = 3: la sim ronda 2.7–3.3. A ρ alta el régimen tarda y T=200 apenas alcanza.
  3. Son eventos raros (ρn chico): pocas visitas ⇒ mucho ruido relativo. Para colas finas se alarga T o se replica.

07 · Comprensión

Confusiones frecuentes

«P0 es la prob. de que no haya espera»

Casi: P0 es fracción ociosa; por PASTA el Poisson la ve igual, así que sí: P(no esperar) = P0 = 1−ρ. Solo vale con arribos Poisson.

«N es Poisson de media L»

No: N es geométrica (cola pesada a la derecha). Poisson es lo que llega por ventana, no lo que hay dentro.

«Wq = Lq × S medio, obvio»

Es Little (Wq = Lq/λ), no “× S”. Coincide en números solo si λ = μρ… siempre, pero la justificación es Little, no intuición.

«Con ρ=0.99 simulo un rato y valido»

Con ρ→1 el régimen tarda ~1/(1−ρ)² y la varianza explota: T=200 no alcanza. Validá en ρ ≤ 0.8 y extrapolá con fórmula.

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: tabla M/M/1

λ=0.25, μ=0.5. Calculá P0, P2, L y W con tu función.

lam, mu, rho = 0.25, 0.5, 0.25/0.5
print(f"P0={1-rho} P2={(1-rho)*rho**2:.3f} L={rho/(1-rho)} W={1/(mu-lam)}")
Ver solución razonada

P0 = 0.5, P2 = 0.125, L = 1.0, W = 4.0. La geométrica cae a la mitad por nivel.

Ejercicio 2: percentil de W

Con μ−λ = 0.25, ¿P(W > 8)? ¿W tal que P(W > w) = 5%?

import math
r = 0.25
print(f"P(W>8)={math.exp(-r*8):.3f} w95={-math.log(0.05)/r:.1f}")
Ver solución

P ≈ 0.135; w95 ≈ 12.0 min: el 5% más lento supera 3× la media (típico exponencial).

Ejercicio 3: escala con igual ρ

(λ=1, μ=2) vs (λ=50, μ=100): ¿L y W en cada uno?

Ver una posible respuesta
for lam, mu in [(1, 2), (50, 100)]:
    print(f"lam={lam} L={lam/(mu-lam):.1f} W={1/(mu-lam):.3f}")

L = 1.0 en ambos; W = 1.0 vs 0.02: igual foto (ρ), distinta película (escala temporal).

09 · Síntesis

Ideas para recordar

  • M/M/1 = Poisson + Exp + 1 + ∞ + FIFO; ρ < 1 o nada.
  • Pn geométrica, W exponencial(μ−λ); PASTA ata llegadas con tiempo.
  • L = ρ/(1−ρ), W = 1/(μ−λ): valida tu simulador con el trío P0/L/Wq.
  • En Python: mm1() como hipótesis, bucle Exp como experimento.
  • Igual ρ, igual L; la escala la pone 1/(μ−λ).

En el próximo tema escalamos la fórmula: el modelo M/M/c.