Problemas de períodos cortos

01 · Punto de partida

El déjà vu que invalida todo

Imaginá una simulación de un millón de clientes con un generador de período 65536: a los 65536 el azar empieza de nuevo, idéntico. Tus “clientes” 1 y 65537 son clones, las colas se sincronizan y los promedios mienten con cara seria. Peor: con réplicas paralelas sembradas “al azar”, dos streams pueden solaparse sin que nadie lo note.

Este tema cuantifica el daño: regla de margen, solapamiento de streams y cómo detectar el ciclo antes de que te detecte a vos.

• ¿Qué pasa exactamente cuando N supera al período?
• ¿Cuánto margen pedir entre período y consumo?
• ¿Por qué dos semillas “distintas” pueden solaparse?
• ¿Re-sembrar a mitad de camino arregla algo?

02 · Definición

Período, consumo y solape

03 · Daños concretos

Qué rompe la repetición

Pasado p, la secuencia es un calco: medias que no convergen, varianzas que colapsan y tests que “pasan” sobre datos clonados. En paralelo es peor: con p = 2³¹ y 1000 streams de 10⁶ sembrados al azar, el solape esperado ya es apreciable.

Clones en serie

Cliente i y cliente i+p idénticos: la cola simulada se sincroniza en fase y los tiempos de espera se subestiman sistemáticamente.

Solape en paralelo

Semillas al azar ≈ puntos al azar en el ciclo: dos streams de largo L solapan con prob. ≈ 2L/p por par. Con p chico, casi seguro.

Re-sembrar no salva

Re-sembrar con el reloj o con rand() rompe la reproducibilidad y puede achicar el ciclo efectivo (caés en un punto ya visitado). La cura es generador con p grande + streams (Temas 37–38).

04 · Ejemplos

Tres mordidas del ciclo

1. 1
   Juguete m = 16, N = 100.

   Seis ciclos completos: la “muestra” es el mismo disco 6 veces. Media y χ² mienten con seguridad.

2. 2
   LCG 2³¹, N = 5·10⁹.

   Dos vueltas al ciclo: la segunda mitad calca la primera. Resultado “estable” y falso.

3. 3
   100 réplicas con srand(tiempo).

   Dos arranques en el mismo segundo comparten semilla y stream: réplicas gemelas que achican la varianza fingida.

05 · Implementación en Python

Detectar el ciclo y medir el margen

Detectamos el período del juguete con un diccionario estado→índice y auditamos margen p/N para consumos reales.

def periodo_lcg(semilla, a=5, c=3, m=16):
    visto = {}
    x = semilla % m
    i = 0
    while x not in visto:
        visto[x] = i
        x = (a * x + c) % m
        i += 1
        if i > m + 5:
            break
    return i - visto[x], visto[x]


p, trans = periodo_lcg(7)
print("periodo:", p, "transitorio:", trans)

Período 16, transitorio 0: ciclo puro desde el arranque (LCG de período máximo).

Margen para tu N

def apto(periodo, n, factor=1000):
    return periodo >= factor * n


for nombre, p in [("juguete m=16", 16), ("LCG 2**31", 2**31 - 1),
                  ("PCG64", 2**64), ("MT", 2**19937 - 1)]:
    print(nombre, "N=1e9:", apto(p, 10**9))

06 · Exploración

Laboratorio: ver el ciclo morder

Tres LCG didácticos con la secuencia dibujada: la línea vertical naranja marca el fin del primer período. Pedí N mayor que p y mirá cómo el calco se superpone exacto.

Pasada la línea naranja todo es calco: mismos valores, mismo orden. Ningún test 1D lo nota si el ciclo es parejo.

Preguntas para explorar

1. Con m = 16 y N = 16: ¿cuántos distintos? ¿Y con N = 17?
2. Con m = 1024 y N = 600: ¿hay repetición? ¿Qué margen p/N queda?
3. Si tu N real fuera 10⁹, ¿qué generador del laboratorio serviría? ¿Cuál de verdad?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: el calco exacto

Generá 40 valores del juguete m = 16 y mostrá que los primeros 16 igualan a los siguientes 16.

x = 7
seq = []
for _ in range(40):
    x = (5 * x + 3) % 16
    seq.append(x)
print(seq[:16] == seq[16:32])

Ejercicio 2: dimensionar de verdad

Tu simulación pide 200 réplicas × 50000 pasos × 3 variables. ¿Sirve un LCG 2³¹? ¿Y PCG64?

n = 200 * 50000 * 3
for nombre, p in [("LCG 2**31", 2**31 - 1), ("PCG64", 2**64)]:
    print(nombre, "N:", n, "margen:", round(p / n, 1))

Ejercicio 3: gemelas por reloj

Simulá dos réplicas sembradas con el mismo segundo y mostrá que salen idénticas.

import random

def replica(semilla):
    rng = random.Random(semilla)
    return [rng.random() for _ in range(5)]


print(replica(1718440000) == replica(1718440000))

09 · Síntesis

Ideas para recordar

En el próximo tema, otro sesgo silencioso: sesgos en la generación y sus causas.