Generación de variables discretas

01 · Punto de partida

Del umbral a la ruleta

En el Tema 1 generamos Bernoulli(p) con un umbral: 1 si U < p. Era una discreta con dos valores. Pero una demanda diaria puede valer {0,1,2,3,4}, un dado cargado {1,…,6} con probabilidades desiguales, una llegada Poisson {0,1,2,…} sin tope.

Todas se generan con la misma idea generalizada: partir el intervalo [0,1) en subintervalos de largo p_k y devolver el valor cuyo intervalo atrapó a U. Es la inversión discreta, la ruleta del casino llevada a código.

• ¿Cómo se traduce una tabla de probabilidades en intervalos?
• ¿Qué fórmula única sirve para finitas e infinitas numerables?
• ¿Búsqueda lineal o binaria sobre acumuladas?
• ¿Cuándo conviene preprocesar con alias (Tema 13)?

02 · Definición

Masa, acumulada e inversa generalizada

Una discreta se define por su masa p_k ≥ 0 con suma 1 y su acumulada escalonada F(x) = Σ_{xk ≤ x} p_k. La inversa no existe como función lisa, pero sí como cuantil:

Ejemplo concreto. Dado cargado con masa [0,10 · 0,20 · 0,30 · 0,25 · 0,10 · 0,05] para {1,…,6}. Acumuladas: 0,10 · 0,30 · 0,60 · 0,85 · 0,95 · 1,00. Si sale U = 0,73, recorremos: 0,73 > 0,60 pero ≤ 0,85 → devolvemos 4. Si U = 0,05 → 1.

03 · Anatomía

Algoritmo general y sus variantes

Preproceso (una vez)

Validar que p_k ≥ 0 y suman 1 (con tolerancia), ordenar valores si conviene y construir acumuladas F_k. Costo O(n).

Muestreo (cada X)

Generar U, buscar el primer k con F_k ≥ U, devolver x_k. Lineal O(n), binaria O(log n) con bisect.

Soporte infinito

Geométrica, Poisson, binomial grande: no hay tabla finita. Se acumula sobre la marcha hasta superar U, o se usa fórmula cerrada / rechazo (Temas 18–20).

Aceleración

Si n es grande y N es enorme: alias O(1) tras O(n) de tablas Prob/Alias (Temas 13–14). Si p cambia en cada llamada, el preproceso no se amortiza.

04 · Casos típicos

Finitas, numerables y qué viene después

1. 1
   Finitas directas.

   Bernoulli, uniforme discreta, dado cargado, demanda empírica chica. Tabla completa + bisect. (Temas 16–17, 34–35)

2. 2
   Numerables con fórmula.

   Geométrica(p): k = 1 + piso(ln(1−U)/ln(1−p)). Evita acumular infinito con una inversión cerrada. (Tema 18)

3. 3
   Numerables por acumulación.

   Binomial(n,p) chico y Poisson(λ) chico: sumar p_k hasta superar U. Simple pero O(media). (Temas 19–20)

4. 4
   Masivas.

   Miles de categorías o N millonario: alias O(1). El preproceso se paga una vez. (Temas 13–14)

05 · Representación en Python

Un generador discreto genérico

La misma función sirve para cualquier finita: recibe valores y probabilidades, valida, precalcula F y muestrea con bisect.

import random
import bisect

random.seed(5)
valores = [1, 2, 3, 4, 5, 6]
probs = [0.10, 0.20, 0.30, 0.25, 0.10, 0.05]

# Preproceso: acumuladas (forzar último = 1.0).
acum = []
s = 0.0
for p in probs:
    s += p
    acum.append(s)
acum[-1] = 1.0

def discreta():
    u = random.random()
    k = bisect.bisect_left(acum, u)
    return valores[k]

muestra = [discreta() for _ in range(6000)]
for v in valores:
    print(v, round(muestra.count(v) / len(muestra), 3))

Probá cambiar probs a seis veces 1/6: todas las frecuencias deben rondar 0,167. Volvé a la cargada y verificá que el 3 domine (~0,30).

Versión lineal didáctica (equivale, más lenta)

Útil para entender el recorrido intervalo por intervalo antes de usar bisect:

import random

random.seed(5)
valores = [1, 2, 3, 4, 5, 6]
probs = [0.10, 0.20, 0.30, 0.25, 0.10, 0.05]

def discreta_lineal():
    u = random.random()
    acc = 0.0
    for v, p in zip(valores, probs):
        acc += p
        if u < acc:
            return v
    return valores[-1]  # resguardo ante redondeo

print([discreta_lineal() for _ in range(10)])

06 · Exploración

Laboratorio: dado justo frente a dado cargado

Elegí la distribución y el N. Las barras muestran la frecuencia observada; los rombos amarillos, la probabilidad teórica. Con N grande las barras se pegan a los rombos; con N chico, el ruido domina.

Seis barras para {1,…,6}. El rombo marca la probabilidad teórica de cada cara. Probá N = 100 y luego N = 6000 para ver la convergencia.

Preguntas para explorar

1. Con distribución cargada y N = 2000, ¿qué cara domina y a qué probabilidad teórica corresponde?
2. Cambiá a justa con N = 100. ¿Alguna cara se desvía más de 0,05? ¿Es sesgo del método o ruido?
3. Si U = 0,73 con la tabla cargada, ¿qué valor devuelve el algoritmo? Recorre las acumuladas a mano.

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: demanda con tabla dada

Demanda en {0,1,2,3} con probs [0,2 · 0,5 · 0,2 · 0,1]. Generá 5000 valores con semilla 9 y estimá P(demanda ≥ 2).

import random
import bisect

random.seed(9)
valores = [0, 1, 2, 3]
probs = [0.2, 0.5, 0.2, 0.1]
acum = []
s = 0.0
for p in probs:
    s += p
    acum.append(s)
acum[-1] = 1.0

muestra = [valores[bisect.bisect_left(acum, random.random())] for _ in range(5000)]
print(sum(1 for x in muestra if x >= 2) / len(muestra))

Ejercicio 2: predecir antes de ejecutar

Con la tabla del dado cargado del laboratorio: si U = 0,05 · 0,30 · 0,60 · 0,97, ¿qué valores salen? Después verificá con código.

import bisect

acum = [0.10, 0.30, 0.60, 0.85, 0.95, 1.0]
valores = [1, 2, 3, 4, 5, 6]
for u in [0.05, 0.30, 0.60, 0.97]:
    print(u, valores[bisect.bisect_left(acum, u)])

Ejercicio 3: detectar el sesgo del redondeo

Compará int(6U)+1 (correcto) contra round(5U)+1 o int(round(6U)) ingenuo con 20000 réplicas. ¿Qué caras se deforman?

import random

random.seed(4)
N = 20000
bien = [1 + int(6 * random.random()) for _ in range(N)]
random.seed(4)
mal = [1 + round(5 * random.random()) for _ in range(N)]

def frec(m):
    return [round(m.count(v) / len(m), 3) for v in range(1, 7)]

print("bien:", frec(bien))
print("mal: ", frec(mal))

09 · Síntesis

Ideas para recordar

En el próximo tema pasaremos al continuo: densidades, acumuladas lisas y la transformada inversa continua.