Número de simulaciones

01 · Punto de partida

N no se adivina, se calcula

¿100, 10 000 o un millón? Con N chico el promedio tiembla; con N gigante perdés tiempo. La respuesta depende de cuánto error tolerás y de cuánto varía tu salida.

La buena noticia: el error cae con regla fija, 1/√N. Con una prueba piloto de 1 000 réplicas ya podés predecir el N que necesitás.

• ¿Qué precisión necesito: ±0,1, ±0,01, ±1 $?
• ¿Cuánto varía mi salida (σ)?
• ¿Cuánto cuesta cada réplica?
• ¿Con qué N piloto estimo σ?

02 · Definición

La regla 1/√N manda

03 · Método

Piloto → cuenta → corrida final en 3 pasos

1. 1
   Correr piloto.

   N₀ = 1 000, calcular media y σ muestral. Barato y rápido.

2. 2
   Calcular N.

   Fijar e deseado y aplicar N = (1,96·σ/e)². Redondear hacia arriba.

3. 3
   Correr final.

   Una sola corrida grande con otra semilla. Reportar estimación ± e.

Semi-ancho e

Margen del intervalo: estimación ± e. Lo fijás vos según la decisión (¿±1 $? ¿±0,01?).

z = 1,96

Factor del 95% normal. Para 99% usá 2,58. Más confianza = más N.

Costo

Tiempo por réplica × N. Si cada réplica cuesta, el piloto ahorra horas.

04 · Ejemplos

Tres cuentas típicas

1. 1
   Moneda ±0,01.

   σ ≈ 0,5 ⇒ N ≈ (1,96·0,5/0,01)² ≈ 9 600. Por eso 10 000 es el clásico.

2. 2
   Utilidad σ = 15, e = 1 $.

   N ≈ (1,96·15/1)² ≈ 864. Con 1 000 alcanza.

3. 3
   P = 0,05 ± 0,005.

   σ = √[0,05·0,95] ≈ 0,22 ⇒ N ≈ 7 300. Los eventos raros piden más N.

05 · Representación en Python

Del piloto al N en código

import random
import statistics
import math

piloto = [150 - random.gauss(100, 15) for _ in range(1000)]
sigma = statistics.pstdev(piloto)
e = 1.0
N = math.ceil((1.96 * sigma / e) ** 2)
print("sigma:", round(sigma, 2), "N necesario:", N)

import random
import math

def n_para_proporcion(p, e=0.01, z=1.96):
    sigma = math.sqrt(p * (1 - p))
    return math.ceil((z * sigma / e) ** 2)

print(n_para_proporcion(0.5, 0.01))  # moneda
print(n_para_proporcion(0.05, 0.005))  # evento raro

06 · Exploración

Laboratorio: el embudo se cierra como 1/√N

Simulamos la moneda con tu N y dibujamos el embudo teórico ±1,96·0,5/√n. Tu punto debe caer dentro del embudo el 95% de las veces.

Curva: semi-ancho teórico que cae como 1/√N. Punto: tu corrida. Si duplicás N cuatro veces, el ancho se parte a la mitad.

Preguntas para explorar

1. Con N = 400, ¿el semi-ancho ronda 0,05? ¿Y con N = 6 400?
2. ¿Por qué pasar de 100 a 1 000 se nota y de 20 000 a 30 000 casi no?
3. Si tu punto cae fuera del embudo, ¿está mal el código?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: verificar la tabla

Comprobá que con σ = 0,5 y N = 100 el semi-ancho da ~0,10.

import math

def semi(sigma, N, z=1.96):
    return z * sigma / math.sqrt(N)

for N in [100, 1000, 10000]:
    print(N, round(semi(0.5, N), 4))

Ejercicio 2: N para e = 2 $

Si σ = 15 y querés ±2 $, ¿qué N necesitás?

import math

sigma, e = 15, 2
print(math.ceil((1.96 * sigma / e) ** 2))

Ejercicio 3: piloto real

Hacé un piloto de 800 para la utilidad y proyectá N para e = 1 $.

import random
import statistics
import math

piloto = [150 - random.gauss(100, 15) for _ in range(800)]
s = statistics.pstdev(piloto)
print("sigma piloto:", round(s, 2))
print("N:", math.ceil((1.96 * s / 1.0) ** 2))

09 · Síntesis

Ideas para recordar

En el próximo tema separaremos las replicaciones: repetir corridas para validar la estabilidad.