Independencia

01 · Punto de partida

Uniforme no alcanza: falta que no se copien

En el Tema 8 exigiste reparto justo. Pero hay secuencias uniformes e inútiles: 0,01, 0,02, 0,03… llena parejo y es totalmente predecible; 0,1, 0,9, 0,1, 0,9… promedia 0,5 y alterna como un reloj. Les falta la segunda exigencia: independencia.

Independencia significa que el pasado no ayuda a adivinar el futuro: saber u(n) no te dice nada de u(n+1). Sin ella, tus sorteos se encadenan y la simulación hereda memoria falsa.

• ¿Qué diferencia hay entre «cada uno es uniforme» y «son independientes»?
• ¿Cómo se ve la dependencia en pares consecutivos?
• ¿Qué mide la correlación y qué no mide?
• ¿Por qué las rachas no contradicen la independencia?

02 · Definición

Memoria cero, cuadrado lleno

03 · Cómo mirarla

Tres miradas que no perdonan

Nube de pares

Graficá x = u(n), y = u(n+1): lo sano llena sin formas; diagonal, rejilla o bandas = dependencia.

Correlación lag-1 y lag-k

Medí dependencia lineal con el vecino y con el de k pasos. Sana ≈ 0 en todos los lags, no solo el 1.

Rachas arriba/abajo

Contá subidas y bajadas: ni alternancia perfecta ni escalera eterna. Las rachas moderadas son sanas; las extremas delatan.

04 · Ejemplos

Los sospechosos habituales

1. 1
   Ordenada.

   0,01, 0,02, …: nube = diagonal perfecta, corr ≈ +1. Uniforme y totalmente predecible.

2. 2
   Arrastrada.

   u(n+1) = (u(n)+0,3) mod 1: bandas diagonales paralelas, corr alta. Típica de malos incrementos.

3. 3
   Alternada.

   0,1, 0,9, …: solo dos puntos en la nube, corr ≈ −1. El espejo perfecto.

4. 4
   Sana.

   PRNG bueno: nube que llena, corr ≈ 0, rachas naturales de 2–6 sin orden.

05 · Cómputo en Python

Correlación y cuadrantes en 20 líneas

Dos chequeos que usarás hasta el Tema 32: corr lag-1 y reparto de pares por cuadrantes.

import random

def corr_lag1(v):
    m = sum(v) / len(v)
    num = sum((v[i] - m) * (v[i + 1] - m) for i in range(len(v) - 1))
    den = sum((x - m) ** 2 for x in v)
    return num / den


random.seed(21)
sano = [random.random() for _ in range(2000)]
print("sano:", round(corr_lag1(sano), 4))

Sano con N = 2000: entre −0,06 y +0,06 es normal. Fuera de ±0,15, sospechá.

Cuadrantes de pares

Cada cuadrante del cuadrado espera ~25 % de los pares:

arr = []
x = 0.1
for _ in range(2000):
    x = (x + 0.3) % 1.0
    arr.append(x)

cuad = [0, 0, 0, 0]
for a, b in zip(arr, arr[1:]):
    cuad[(a >= 0.5) * 2 + (b >= 0.5)] += 1
print("arrastrado por cuadrante:", cuad)

06 · Exploración

Laboratorio: la nube delata

Elegí la fuente y N. Cada punto es un par (u(n), u(n+1)). El panel da correlación lag-1 y reparto por cuadrantes (ideal 25 % cada uno).

Nube pareja = independencia aparente. Diagonal, bandas o dos puntos = dependencia grosera.

Preguntas para explorar

1. Con arrastrado, ¿qué forma ves? ¿La correlación es positiva o negativa?
2. Con alternado, ¿cuántos puntos distintos hay? ¿Qué cuadrantes quedan vacíos?
3. Con sano y N = 1500, ¿algún cuadrante se escapa mucho de 25 %? ¿Y con N = 100?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: el arrastrado

Generá el arrastrado +0,3 mod 1 y medí su corr. ¿Supera 0,5?

def corr(v):
    m = sum(v) / len(v)
    num = sum((v[i] - m) * (v[i + 1] - m) for i in range(len(v) - 1))
    return num / sum((x - m) ** 2 for x in v)


x = 0.1
arr = []
for _ in range(2000):
    x = (x + 0.3) % 1.0
    arr.append(x)
print(round(corr(arr), 4))

Ejercicio 2: cuadrantes del sano

Contá pares por cuadrante con random y N = 4000. ¿Alguno se escapa de 22–28 %?

import random

random.seed(21)
v = [random.random() for _ in range(4000)]
cuad = [0, 0, 0, 0]
for a, b in zip(v, v[1:]):
    cuad[(a >= 0.5) * 2 + (b >= 0.5)] += 1
print(cuad)
print([round(c / (len(v) - 1), 4) for c in cuad])

Ejercicio 3: rachas arriba/abajo

Contá rachas de subidas consecutivas en una secuencia sana. ¿Hay rachas de 5+? ¿Contradice independencia?

import random

random.seed(21)
v = [random.random() for _ in range(500)]
rachas, actual = [], 1
for i in range(1, len(v)):
    if v[i] > v[i - 1]:
        actual += 1
    else:
        rachas.append(actual)
        actual = 1
print("racha máxima de subidas:", max(rachas))

09 · Síntesis

Ideas para recordar

En el próximo tema veremos la tercera exigencia: el período de un generador, o por qué toda secuencia calculada está condenada a repetirse.