Elección de la función envolvente

01 · Punto de partida

El rechazo vive o muere por la envolvente

El Tema 8 dio el algoritmo; este tema da el oficio: elegir g. Una g parecida a f con c ≈ 1 da 90 % de aceptación; una g liviana de colas no mayoriza (c = ∞, método imposible); una g válida pero lejana da 5 % y el método es correcto pero inútil.

La regla de oro en una frase: g fácil de muestrear, mismo soporte que f y colas al menos tan pesadas. El resto es optimizar c.

• ¿Qué tres condiciones debe cumplir g?
• ¿Cómo se calcula c = sup f/g sin adivinar?
• ¿Por qué las colas mandan más que el centro?
• ¿Cuándo conviene una mezcla de envolventes?

02 · Definición

Tres requisitos y una fórmula de c

Sea r(x) = f(x)/g(x). La envolvente válida mínima es c* = sup r(x). Entonces c·g toca a f en al menos un punto y la tasa máxima con esa g es 1/c*.

03 · Anatomía

Cómo calibrar c sin adivinar

1. Derivar cuando se puede

Maximizar ln r(x) = ln f − ln g igualando a cero. Ejemplo guía: Gamma(2,1) vs Exp(μ) da x* = 1/(1−μ) y c(μ) = 1/[μ·e·(1−μ)].

2. Grilla + refinamiento

Evaluar r en grilla densa (log en colas), tomar el máximo y refinar con bisección/Newton local. Sirve para f definidas por código.

3. Optimizar el parámetro

Minimizar c(μ) sobre la familia. En el ejemplo, mín c en μ = 0,5 con c* ≈ 1,47 y tasa ≈ 0,68.

4. Verificar gráficamente

Graficar f vs c·g y r(x) vs c. Tocar en un punto = óptimo; flotar por encima en todos = c derrochador; cortar = inválido.

04 · Familias que conviene tener a mano

De la forma de f a la g candidata

1. 1
   Soporte acotado.

   Uniforme o triangular escalada. c = máx f/g directo. (Beta, triangular a medida)

2. 2
   Soporte [0,∞).

   Exponencial con tasa menor que la cola de f. Optimizar μ. (Gamma, Weibull)

3. 3
   Soporte (−∞,∞).

   Laplace (doble exponencial) o t de Student: colas pesadas garantizadas. (Normal)

4. 4
   Forma multimodal.

   Una sola g lisa no alcanza: mezcla de envolventes, una por modo (puente al Tema 11).

05 · Representación en Python

Calibrar c por derivada y por grilla

Guía Gamma(2,1) con Exp(μ): f(x) = x·e^(−x). Fórmula c(μ) = 1/[μ·e·(1−μ)] válida para μ < 1; grilla para verificar sin fórmula.

import math

def f_gamma(x):
    return 0.0 if x < 0 else x * math.exp(-x)

def g_exp(x, mu):
    return 0.0 if x < 0 else mu * math.exp(-mu * x)

def c_formula(mu):
    return 1 / (mu * math.e * (1 - mu))  # válida si mu < 1

def c_grilla(mu, xmax=20.0, n=20001):
    best = 0.0
    for i in range(n):
        x = xmax * i / (n - 1)
        g = g_exp(x, mu)
        if g > 0:
            r = f_gamma(x) / g
            if r > best:
                best = r
    return best

for mu in [0.3, 0.5, 0.7, 0.9]:
    print(mu, "fórmula:", round(c_formula(mu), 3),
          "grilla:", round(c_grilla(mu), 3),
          "tasa:", round(1 / c_formula(mu), 3))

Mínimo en μ = 0,5 con c ≈ 1,47 y tasa ≈ 0,68. Con μ ≥ 1 la grilla crece sin techo: señal de c* = ∞.

06 · Exploración

Laboratorio: sintonizar μ para Gamma(2,1)

Movete μ ∈ [0,2 · 0,95]. La curva azul es f; la línea es c(μ)·g. Con μ = 0,5 la envolvente besa a f (óptima). Con μ → 1 la envolvente se dispara; con μ ≥ 1 no hay envolvente finita.

Histograma en densidad de aceptadas vs f teórica. Probá μ = 0,9 (envolvente alta, tasa baja) y μ = 0,3.

Preguntas para explorar

1. ¿Qué μ minimiza c y qué tasa da? Leelo en el panel con μ = 0,5.
2. Subí a μ = 0,9. ¿c sube o baja? ¿La tasa mejora o empeora?
3. ¿Por qué μ = 1,2 (fuera del control) sería inválido? Pensá en colas e^(−x) vs e^(−1,2x).

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: óptimo a mano

Minimizá c(μ) = 1/[μ·e·(1−μ)] para μ ∈ (0,1). Derivá o barrré μ y verificá μ* = 0,5.

import math

best = (None, 1e18)
for i in range(1, 100):
    mu = i / 100
    c = 1 / (mu * math.e * (1 - mu))
    if c < best[1]:
        best = (mu, c)
print("mu* =", best[0], " c* =", round(best[1], 3))

Ejercicio 2: detectar cola liviana

Evaluá r(x) = f/g en x = 0, 5, 10, 20 para Gamma(2,1) vs Exp(1,2). ¿Crece sin techo?

import math

def r(x, mu=1.2):
    f = x * math.exp(-x)
    g = mu * math.exp(-mu * x)
    return f / g

print([round(r(x), 1) for x in [0, 5, 10, 20]])

Ejercicio 3: uniforme para Beta, c exacto

Beta(2,5) con U(0,1): hallá el máximo de f(x) = 30x(1−x)⁴ derivando (x* = 0,2) y compará con grilla.

def f(x):
    return 30 * x * (1 - x) ** 4

xs = [i / 10000 for i in range(10001)]
print("grilla:", round(max(f(x) for x in xs), 4))
print("f(0.2):", round(f(0.2), 4))

09 · Síntesis

Ideas para recordar

En el próximo tema cuantificaremos ese costo: la eficiencia de aceptación-rechazo.