Distribución exponencial y tiempos de espera

01 · Punto de partida

Esperar no adelanta la llegada

Llevás 20 minutos esperando el colectivo y pensás «ya tiene que venir». En Poisson, no: la chance de esperar 5 más es la misma que al llegar a la parada. La espera no tiene memoria.

Esa es la distribución exponencial: el único modelo continuo de espera donde lo ya esperado no descuenta nada.

• ¿Esperar mucho aumenta la chance de que llegue ya?
• ¿Qué probabilidad queda de esperar más que x: e^(−λx)?
• ¿Cuánto se espera en promedio y cuánto varía?
• ¿Por qué simular esperas con −ln(1−u)/λ?

02 · Definición

¿Qué es la exponencial?

Tres fórmulas la describen por completo:

Media 1/λ, varianza 1/λ², mediana ln2/λ ≈ 0,69/λ. La mediana menor que la media confirma la asimetría del Tema 11.

03 · Anatomía

Memoria, tasa y sorteo

Cuatro ideas para usarla sin miedo:

Falta de memoria

Única continua con esa propiedad. Si las esperas reales «envejecen» (desgaste), la exponencial falla.

Tasa λ

Manda todo: densidad, supervivencia, media. Más λ, curva más empinada y esperas más cortas.

Sorteo inverso

S = −ln(1−u)/λ con u uniforme. Así se genera Poisson espera por espera.

Mínimo de exponenciales

El mínimo de varias Exp independientes es Exp con la suma de tasas. Base de competencia entre eventos.

04 · Ejemplos

Esperas exponenciales (y una que no)

La exponencial modela esperas «sin desgaste»; si hay agenda o envejecimiento, no aplica:

1. 1
   Próxima llamada (λ = 6/hora).

   S ~ Exp(6): media 10 min, P(S > 20 min) = e^(−2).

2. 2
   Próximo pedido (λ = 1/s).

   Media 1 s. Esperar 3 s sin nada es raro pero posible.

3. 3
   Falla espontánea.

   Componente sin desgaste: riesgo constante.

4. 4
   Colectivo con horario.

   No exponencial: si viene cada 10 min, esperar 9 sí adelanta.

5. 5
   Reparación con etapas.

   No exponencial simple: varias fases suman otra distribución (Erlang).

05 · Representación en Python

Sortear y verificar la falta de memoria

En Python, la exponencial se sortea por inversión y se verifica contando supervivencias: la fracción que supera s+t entre las que superan s debe dar e^(−λt).

import random, math

def sortear(lam=2.0, n=6, semilla=7):
    random.seed(semilla)
    return [-math.log(1 - random.random()) / lam for _ in range(n)]

S = sortear()
print([round(s, 2) for s in S])

Cada valor es una espera Sₖ. La media ronda 0,5 (= 1/2) aunque haya valores de 1,2 y de 0,05.

Comprobar sin memoria con conteos

La verificación empírica de P(S > s+t | S > s) = e^(−λt):

import random, math

random.seed(12)
lam, s, t = 2.0, 0.5, 1.0
S = [-math.log(1 - random.random()) / lam for _ in range(20000)]
sup_s = [x for x in S if x > s]
cond = sum(1 for x in sup_s if x > s + t) / len(sup_s)
print("condicional:", round(cond, 4))
print("teoría e^(-λt):", round(math.exp(-lam * t), 4))

06 · Exploración

Laboratorio: esperar no descuenta

Curva de supervivencia P(S > x) = e^(−λx). Marcamos lo ya esperado s (línea turquesa) y el objetivo s+t (línea amarilla). El cociente de alturas es la condicional: mové s con igual t y verás que no cambia. Eso es la falta de memoria.

La altura de la curva en x es la chance de superar x. La condicional es altura en s+t sobre altura en s: el cociente no depende de s.

Preguntas para explorar

1. Fijá t = 1 y mové s de 0 a 2. ¿La condicional cambia? ¿Qué significa?
2. Con s = 0,5, duplicá t de 0,5 a 1. ¿La chance sube o baja? ¿Por qué?
3. Subí λ a 4. ¿La curva cae más rápido o más lento? ¿La media crece o se achica?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: leer la supervivencia

Con λ = 1,5 calculá P(S > 2) y la media. Interpretá el número.

import math

lam = 1.5
print("P(S>2):", round(math.exp(-lam * 2), 4))
print("media:", round(1 / lam, 3))

Ejercicio 2: condicional que no depende de s

Sin ejecutar primero: con λ = 2, s = 3 y t = 0,5, ¿qué condicional esperás? Comprobalo.

import math

lam, t = 2.0, 0.5
print(round(math.exp(-lam * t), 4))

Ejercicio 3: simular la falta de memoria

Con 20000 esperas Exp(1), compará P(S > 1) con P(S > 2 | S > 1). ¿Coinciden?

import random, math

random.seed(21)
S = [-math.log(1 - random.random()) for _ in range(20000)]
p1 = sum(1 for x in S if x > 1) / len(S)
sup = [x for x in S if x > 1]
cond = sum(1 for x in sup if x > 2) / len(sup)
print("P(S>1):", round(p1, 4))
print("P(S>2|S>1):", round(cond, 4))
print("teoría e^-1:", round(math.exp(-1), 4))

09 · Síntesis

Ideas para recordar

En el próximo tema usaremos estas esperas para simular procesos de Poisson completos.