El código que todos inventan primero no paga nunca

El primer código que inventa cualquiera es repetir: mandar cada bit tres veces y quedarse con la mayoría. Corrige un error de cada tres bits, se explica en una línea, y parece obvio que conviene.

No conviene nunca. Con decisión dura, la repetición (3,1) tiene una BER peor que no codificar en todo el rango de Eb/N0 —no en un tramo: medido de −5 a 25 dB, sin una sola excepción— y no hay ningún punto del recorrido donde eso cambie. La fórmula es la que ya escribió el curso: falla si dos o tres de los tres bits recibidos se dan vuelta.

Esa p es la misma de la nota anterior: la probabilidad de que el canal binario simétrico (BSC) dé vuelta un bit. La diferencia es que ahí se la movía a mano con un deslizador, y acá aparece del otro lado del hueco que esa nota dejó abierto —«un canal de verdad no te entrega p; te entrega bits»—: Eb/N0 es la relación señal-ruido que un receptor de radio sí mide, y de ahí sale p con la fórmula del canal gaussiano. Subir Eb/N0 baja p; son la misma cantidad, vista desde dos costados distintos del mismo problema.

from random import random

def ber_repeticion(p):
    """Falla si 2 o 3 de los 3 bits recibidos se dan vuelta."""
    return 3 * p**2 * (1 - p) + p**3

def simular_repeticion(p, n_msg=200_000):
    """Monte Carlo: cada bit de mensaje viaja tres veces; se decide por mayoría."""
    errores = 0
    for _ in range(n_msg):
        bit = 1 if random() < 0.5 else 0
        recibidos = [bit ^ (1 if random() < p else 0) for _ in range(3)]
        decidido = 1 if sum(recibidos) >= 2 else 0
        errores += decidido != bit
    return errores / n_msg

ber_repeticion(0.1)        # 0,028 exacto: la fórmula cerrada
simular_repeticion(0.1)    # converge al mismo número, bit por bit

El motivo no es una curiosidad del canal: es que la repetición no compra distancia por lo que paga. La ganancia asintótica de un código es el límite de cuánto Eb/N0 ahorra frente a no codificar cuando Eb/N0 crece sin cota, y depende de cómo decide el receptor. Con decisión dura —la de estas curvas: cada muestra se convierte en un bit antes de decodificar— un código que corrige t errores falla cuando llegan t + 1, y el límite es 10·log₁₀(R · (t + 1)). La repetición (3,1) tiene tasa R = 1/3 y corrige t = 1, así que R · (t + 1) = 2/3: el límite es −1,76 dB. No es que gane poco: pierde, y sigue perdiendo por más energía que le pongas. Si el receptor pudiera sumar las tres muestras antes de decidir —decisión blanda—, el límite sería 10·log₁₀(R · d_min) = 0 dB exactos: gastar tres bits para mandar uno compraría una distancia mínima de 3 y la pagaría justo lo que vale, ni un decibel más.

Hamming (7,4), en cambio, sí paga:

Ese «5,85 dB» necesita una advertencia, porque hay una manera fácil de arruinarlo: comparar la probabilidad de que un bloque entero salga mal contra la de que un bit salga mal sin codificar. Son dos magnitudes distintas —una probabilidad de bloque no es una probabilidad de bit— y el cruce entre ellas no significa nada, aunque la bisección devuelva un número con toda tranquilidad. Reproduciendo esa comparación rota da un cruce cerca de 9,11 dB, y ese número estuvo en una versión anterior de este cálculo. El criterio que importa compara BER contra BER —la tasa de error de bit después de decodificar, contra la de no codificar, la misma magnitud de los dos lados— y con eso el cruce de Hamming es 5,85 dB, no 9.

Y hay un ancla que no depende de ninguna fórmula aproximada: Hamming (7,4) tiene apenas 128 patrones de error posibles, así que se los puede enumerar los 128, decodificar cada uno por síndrome, y contar exactamente cuántos de los 4 bits de mensaje quedan mal. Esa cuenta exacta cruza en 5,8489 dB. La fórmula genérica que dibuja el widget de abajo —la misma que sirve para cualquier código, no sólo para Hamming— da 5,8620 dB: 0,013 dB de diferencia, el precio de no simular bit por bit, y un precio que esta nota puede pagar porque quedó medido, no supuesto.