Número de replicaciones

01 · Punto de partida

Una corrida es una anécdota; n son evidencia

Con una sola corrida el azar manda: pudo tocarte la cola buena. Con n réplicas independientes (Tema 29), la media se estabiliza y el IC (Tema 26) se angosta hasta tu d (Tema 27). La pregunta es cuántas.

• ¿Qué es una réplica válida (independiente)?
• ¿Cuántas pide tu d con tu s piloto?
• ¿Fijas de antemano o paras en vivo?
• ¿Réplicas o corrida más larga (Temas 32–33)?

02 · Definición

Piloto, fórmula y parada

03 · Método

Protocolo en 5 pasos

1. 1
   Asegurar independencia (Tema 29).

   Semilla por réplica, estado fresco, sin reuso. Réplicas correlacionadas valen menos que n.

2. 2
   Correr piloto n₀ = 20–30.

   Estimar s y x̄. Si s ≈ 0, el sistema es determinista: pocas réplicas bastan.

3. 3
   Calcular n* ≈ (z·s/d)².

   Con colchón 20% en s y t si n* < 30. Si n* ≤ n₀, ya terminaste.

4. 4
   Completar o vigilar en vivo.

   Fijo: correr hasta n*. Secuencial: chequear EE cada 5 réplicas con n mínimo 20.

5. 5
   Reportar n + d lograda.

   «n = 64, d = ±0,48»: lo pedido y lo logrado, con semillas archivadas (Tema 43).

04 · Réplicas vs. longitud

Cuándo más corridas y cuándo más larga

Transitorio

El arranque sesga: se descarta por réplica (Temas 30–31). Más réplicas no corrigen no descartar.

Correlación interna

Dentro de una corrida los datos se correlacionan: n efectivo < n pasos. Entre réplicas no (si son independientes).

Costo

n réplicas × (calentamiento + corrida): el calentamiento se paga n veces. Longitud única lo paga una vez.

05 · Representación en Python

Piloto → n* → parada en vivo

import math, random
rng = random.Random(7)
piloto = [12 + rng.gauss(0, 2) for _ in range(20)]
m0 = sum(piloto)/len(piloto)
s0 = math.sqrt(sum((x-m0)**2 for x in piloto)/(len(piloto)-1))
d, z = 0.5, 1.96
n_star = math.ceil((z*s0/d)**2)
print(f"piloto s={s0:.2f} -> n* ≈ {n_star} para d=±{d}")

s ≈ 2 → n* ≈ 62. Con colchón saldría ≈ 85: presupuestar 90.

Monitor secuencial honesto

n, media, M2 = 0, 0.0, 0.0
rng2 = random.Random(11)
while True:
    x = 12 + rng2.gauss(0, 2)
    n += 1
    delta = x - media
    media += delta/n
    M2 += delta*(x-media)
    if n >= 20 and n % 5 == 0:
        s = math.sqrt(M2/(n-1))
        if s/math.sqrt(n) <= d/z:
            break
    if n >= 500:
        break
print(f"paró en n={n} con media {media:.2f} (EE ≤ {d/z:.2f})")

06 · Exploración

Laboratorio: EE(n) cae como 1/√n

Curva EE(n) = s/√n con tu s piloto. La línea verde es tu meta d/z (d pedida al 95%). El punto marca el n* donde se cruzan. Mové d, s y n corridas: a la derecha del cruce, decides; a la izquierda, adivinas.

Eje x: n réplicas. Eje y: EE. Verde: meta. Lima: tu curva. El cruce es n*: más allá, precisión suficiente.

Preguntas para explorar

1. Con s=2 y d=±0,5: ¿n*? Poné n=30: ¿EE y d lograda? ¿Decide?
2. Partí d a ±0,25: ¿n*? ¿Factor? ¿Qué enseña sobre pedir de más?
3. Subí s a 4 con d=±0,5: ¿n*? ¿Por qué reducir s (mejor diseño) vale tanto como pedir menos?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: n* desde piloto

¿n* con s=1,8 y d=±0,3?

import math
print(math.ceil((1.96*1.8/0.3)**2), "réplicas (con colchón ≈ 170)")

Ejercicio 2: d lograda con lo corrido

¿d con n=50, s=2,5?

import math
print(f"±{1.96*2.5/math.sqrt(50):.2f}")

Ejercicio 3: regla secuencial escrita

Escribí la regla de parada honesta.

print("Parar cuando n≥20 y EE≤d/1.96 chequeado cada 5, máx 500.")

09 · Síntesis

Ideas para recordar

En el próximo tema blindaremos la base: independencia entre replicaciones.