Probabilidad aplicada a simulaciones

01 · Punto de partida

Qué número le ponemos al «puede pasar»

La probabilidad es un número entre 0 y 1 que mide la chance de un evento. En simulación tiene dos usos: diseñar (le digo al modelo con qué probabilidad llega un cliente) y medir (cuento en cuántas réplicas hubo quiebre).

Cuando el modelo es chico, la calculamos con lápiz (Laplace: casos favorables sobre posibles). Cuando es grande —colas, redes, inventarios con reglas—, la estimamos simulando: repetimos N veces y la frecuencia es la estimación. Ese es el método Monte Carlo que usarás todo el curso.

• ¿La probabilidad viene de un cálculo o de muchas réplicas?
• ¿Qué reglas no se pueden romper (complemento, suma, cotas)?
• ¿Con qué N la estimación ya es confiable?
• ¿Cómo convierto una frecuencia en una decisión (stock, personal, precio)?

02 · Definición

Tres formas de asignar probabilidad

03 · Reglas que siempre valen

El kit mínimo para no romper el modelo

Axiomas

Probabilidades entre 0 y 1, suman 1 sobre Ω. Todo lo demás se deduce de ahí.

Regla de la suma

Para «A o B», sumar y restar el solapamiento. Base de «convirtió de alguna forma».

Monotonía

Si A ⊆ B, entonces P(A) ≤ P(B). Exigir más nunca da más chance.

Monte Carlo

Estimar contando réplicas. Verificar comparando con el cálculo exacto en un caso simplificado.

04 · Ejemplos

Dónde aparece en cada simulador

1. 1
   Quiebre.

   P(stock menor a 0 en 12 días). No se calcula a mano: se estima con réplicas.

2. 2
   Espera.

   P(espera mayor a 10 min). Define cuántos cajeros contratar.

3. 3
   Conversión.

   P(compra o suscripción) = P(C) + P(S) − P(ambas). Suma con solapamiento.

4. 4
   Disponibilidad.

   P(responde en menos de 2 s) = 1 − P(lento). Complemento directo.

5. 5
   Juego.

   P(ganar el combate) estimada con 10000 peleas simuladas antes de publicar el balance.

05 · Representación en Python

Calcular y estimar, lado a lado

La verificación de oro: el cálculo exacto y la estimación Monte Carlo deben coincidir. Si difieren, el bug está en el simulador:

import random
random.seed(5)

# Exacto: P(demanda U(6,14) mayor a 10) = (14-10)/(14-6)
exacta = (14 - 10) / (14 - 6)

# Monte Carlo: contar réplicas
N = 5000
exitos = sum(1 for _ in range(N) if random.uniform(6, 14) > 10)
print("exacta:", round(exacta, 4))
print("estimada:", round(exitos / N, 4))

Consejo: probá con N = 100, 1000 y 20000 para sentir la caída del error como 1/√N.

Regla de la suma en código

import random
random.seed(7)

# A = par, B = mayor a 4, con un dado, N = 6000
N = 6000
A = B = inter = union = 0
for _ in range(N):
    d = random.randint(1, 6)
    a, b = (d % 2 == 0), (d > 4)
    A += a; B += b; inter += (a and b); union += (a or b)
print("P(A∪B) directa:", round(union / N, 3))
print("P(A)+P(B)-P(∩):", round((A + B - inter) / N, 3))

06 · Exploración

Laboratorio: estimar P(demanda mayor a T)

Demanda diaria uniforme U(6, 14). Elegí el umbral T: la línea blanca es la probabilidad exacta (14−T)/8; las 3 curvas son frecuencias acumuladas Monte Carlo. Achicá N para ver el error, agrandalo para ver la convergencia.

Cada curva es la frecuencia acumulada de «demanda mayor a T». La línea blanca punteada es el valor exacto. El error cae al aumentar N, pero cada vez más lento (1/√N).

Preguntas para explorar

1. Con T = 10 y N = 50, ¿qué error típico ves? ¿Y con N = 2000?
2. Poné T = 13,5. ¿Por qué la estimación salta más en términos relativos?
3. Si cuadruplicás N, ¿cuánto se achica el error a ojo?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: verificar el laboratorio

Estimá P(U(6,14) mayor a 12) con N = 2000 y compará con (14−12)/8 = 0,25.

import random
random.seed(15)
N = 2000
ex = sum(1 for _ in range(N) if random.uniform(6, 14) > 12)
print("estimada:", round(ex / N, 4), "| exacta: 0.25")

Ejercicio 2: evento raro

Estimá P(suma 12 con dos dados) = 1/36 con N = 500 y N = 20000. ¿Qué cambia?

import random

def estimar(N, semilla):
    random.seed(semilla)
    ex = sum(1 for _ in range(N) if random.randint(1, 6) + random.randint(1, 6) == 12)
    return ex / N

print("N=500:", round(estimar(500, 2), 4))
print("N=20000:", round(estimar(20000, 2), 4))
print("exacta:", round(1/36, 4))

Ejercicio 3: de frecuencia a decisión

Con stock 110, 12 días U(6,14) y 3000 réplicas, estimá P(quiebre). ¿Conviene subir a 130 si el costo de quiebre es alto?

import random
random.seed(30)

def p_quiebre(stock, N=3000):
    q = 0
    for _ in range(N):
        s = stock
        for _ in range(12):
            s -= random.uniform(6, 14)
            if s < 0:
                q += 1
                break
    return q / N

print("P(quiebre|110):", round(p_quiebre(110), 3))
print("P(quiebre|130):", round(p_quiebre(130), 3))

09 · Síntesis

Ideas para recordar

En el próximo tema condicionaremos: probabilidad condicional para actualizar la chance cuando sabemos algo más.