Pruebas de series

01 · Punto de partida

En 1D pasa, en 2D cae

RANDU daba media 0,5, χ² digno y correlograma tímido (Temas 26–28). Pero graficá los pares (uₙ, uₙ₊₁): en vez de nube aparecen diagonales; con ternas, 15 planos. La prueba de series es ese gráfico convertido en cuenta: partir el cuadrado [0,1)² en k² celdas y contar pares como el Tema 29 contaba décimos.

Es la prueba que separa generadores “de juguete 1D” de generadores aptos para simulación real, donde casi todo usa pares (puntos, agentes, colas).

• ¿Cómo se arma el χ² sobre k² celdas?
• ¿Pares solapados o no solapados?
• ¿Cuántos valores N exige un 10×10?
• ¿Pares que pasan garantizan ternas?

02 · Definición

El cuadrado y el cubo

03 · Procedimiento correcto

Grilla, conteo y lectura

Con k = 4 (16 celdas, didáctico) y P = 800 pares, E = 50 por celda: un sano ronda 50 ± 14 y χ² ≈ 15 con 15 gl (crítico 25,0). Un LCG con diagonales deja celdas en 0 y otras en 120: χ² ≈ 300.

k chico primero

k = 4 didáctico (16 celdas visibles), k = 10 estándar. k = 20 en pares (400 celdas) exige P ≥ 2000: solo con N grande.

Scatter antes que χ²

El gráfico de pares es gratis y demoledor: diagonales, grillas gruesas o huecos se ven antes de contar (Tema 31).

Pares ≠ ternas

Pasar pares no absuelve ternas: RANDU pasaba 2D flojo y caía en 3D. La batería sube de dimensión.

04 · Ejemplos

Tres nubes típicas

1. 1
   Sano, P = 2000, k = 10.

   Nube pareja, celdas ≈ 20, χ² ≈ 99 < 123,2. Pasa.

2. 2
   LCG a=5, c=3, m=16.

   Solo 16 puntos posibles en el cuadrado: celdas en 0 y picos. χ² astronómico con P grande.

3. 3
   RANDU en ternas.

   Pares “aceptables”, ternas en 15 planos: el 2D perdona, el 3D condena. Por eso la batería sube.

05 · Implementación en Python

χ² sobre el cuadrado

Pares no solapados sobre grilla k×k con crítico Wilson-Hilferty al 5 %. Probalo con random (pasa) y con el juguete (no pasa).

import random

def chi2_series(us, k=4):
    pares = [(us[i], us[i + 1]) for i in range(0, len(us) - 1, 2)]
    p = len(pares)
    e = p / (k * k)
    obs = [[0] * k for _ in range(k)]
    for x, y in pares:
        obs[min(k - 1, int(x * k))][min(k - 1, int(y * k))] += 1
    chi = sum((o - e) ** 2 / e for fila in obs for o in fila)
    return p, round(chi, 2)


rng = random.Random(30)
us = [rng.random() for _ in range(4000)]
print(chi2_series(us, k=4), "critico gl=15: 25.0")

P = 2000, χ² ≈ 10–20 bajo 25,0: nube sana en 4×4.

El juguete en el cuadrado

def chi2_series(us, k=4):
    pares = [(us[i], us[i + 1]) for i in range(0, len(us) - 1, 2)]
    e = len(pares) / (k * k)
    obs = [[0] * k for _ in range(k)]
    for x, y in pares:
        obs[min(k - 1, int(x * k))][min(k - 1, int(y * k))] += 1
    return round(sum((o - e) ** 2 / e for fila in obs for o in fila), 2)


x = 7
mal = []
for _ in range(4000):
    x = (5 * x + 3) % 16
    mal.append(x / 16)
print(chi2_series(mal, k=4), "critico gl=15: 25.0")

06 · Exploración

Laboratorio: la nube o las diagonales

Pares no solapados como puntos (x,y) sobre grilla 4×4. Fuentes: sano (nube), juguete m = 16 (16 puntos) y diagonal y ≈ (5x+c) mod 1 (LCG a ojo). El panel trae χ² con 15 gl.

Puntos alineados en diagonales = dependencia lineal. Celdas vacías sistemáticas = resolución o planos.

Preguntas para explorar

1. Con juguete y P = 1000: ¿cuántas celdas se llenan como máximo? ¿Qué χ² sale?
2. Con diagonal: ¿el χ² pasa con P = 100? ¿Y con P = 1000?
3. Si el scatter se ve bien, ¿puede igual fallar el χ²? ¿Y al revés?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: nube sana 4×4

Con 4000 valores de random (P = 2000) verificá χ² < 25,0 en grilla 4×4.

import random

rng = random.Random(17)
us = [rng.random() for _ in range(4000)]
pares = [(us[i], us[i + 1]) for i in range(0, len(us) - 1, 2)]
e = len(pares) / 16
obs = [[0] * 4 for _ in range(4)]
for x, y in pares:
    obs[min(3, int(x * 4))][min(3, int(y * 4))] += 1
chi = sum((o - e) ** 2 / e for fila in obs for o in fila)
print(len(pares), round(chi, 2), chi < 25.0)

Ejercicio 2: diagonal delatora

Construí pares y = (5x + 0,1) mod 1 y mostrá χ² ≫ 25 con P = 2000.

import random

rng = random.Random(17)
xs = [rng.random() for _ in range(2000)]
pares = [(x, (5 * x + 0.1) % 1.0) for x in xs]
e = len(pares) / 16
obs = [[0] * 4 for _ in range(4)]
for x, y in pares:
    obs[min(3, int(x * 4))][min(3, int(y * 4))] += 1
chi = sum((o - e) ** 2 / e for fila in obs for o in fila)
print(round(chi, 2))

Ejercicio 3: P que esconde

Mostrá que la diagonal “pasa” con P = 40 (E = 2,5) por falta de potencia y cae con P = 2000.

import random

def chi_diag(p):
    rng = random.Random(17)
    pares = [(x := rng.random(), (5 * x + 0.1) % 1.0) for _ in range(p)]
    e = p / 16
    obs = [[0] * 4 for _ in range(4)]
    for x, y in pares:
        obs[min(3, int(x * 4))][min(3, int(y * 4))] += 1
    return round(sum((o - e) ** 2 / e for fila in obs for o in fila), 2)


print("P=40:", chi_diag(40), "P=2000:", chi_diag(2000))

09 · Síntesis

Ideas para recordar

En el próximo tema miramos sin contar: pruebas gráficas, ver patrones a simple vista.