Hamming, 1950: tres bits de control para reparar un error

Artículo redactado y traducido por un sistema de IA a partir de las fuentes citadas, con controles automatizados según el método editorial News.

Mantenimiento — 7 de octubre de 2026. La portada se ha sustituido porque no se pudieron recuperar su archivo original y su recibo de generación con los accesos disponibles. La nueva imagen se recibió de la herramienta nativa y se inspeccionó visualmente; su archivo, instrucciones y referencias se conservan en el registro editorial privado. La portada anterior y su procedencia no verificada siguen en el historial. Es una ilustración, no una prueba experimental; el resultado científico central se mantiene.

Ilustración conceptual generada por IA del código de Hamming (7,4): cuatro bits de datos, tres de control y corrección de una inversión por bloque. Fichas simbólicas, no un circuito.

Antes de las ecuaciones

Un bit es un valor, 0 o 1. Una inversión cambia uno por el otro. La paridad indica si un grupo contiene un número par o impar de unos. Por ejemplo, 101 contiene dos unos: su paridad es par. La redundancia consiste en transmitir información adicional que permita comprobar los datos. Aquí, tres controles superpuestos localizan un bit invertido, siempre que haya como máximo uno en un bloque de siete bits.

Para comprender la idea, siga el ejemplo de la sección 3 y después vuelva a las ecuaciones de la sección 2. Para verificarla, utilice el programa completo de abajo. Pregúntese: ¿un control satisfactorio prueba que ningún bit cambió? La sección 5 explica por qué la respuesta depende del modelo de error.

1. Fiabilidad mediante redundancia estructurada

En abril de 1950, Richard W. Hamming publicó «Error Detecting and Error Correcting Codes» en el Bell System Technical Journal. El problema era práctico: detectar un fallo en un cálculo sin supervisión podía detenerlo; localizarlo y corregirlo podía permitir continuar. El artículo ofrece construcciones binarias explícitas, no una promesa de reparar cualquier daño. [1,2]

La innovación consiste en hacer informativa la redundancia. Repetir tres veces cada uno de cuatro bits requiere doce bits transmitidos. Un código de Hamming utiliza siete para proteger los mismos cuatro datos frente a cualquier inversión única dentro del bloque. Son distintas organizaciones de la redundancia, no una prueba de optimalidad para todos los canales. La compresión elimina redundancia; la corrección añade una forma controlada.

2. Siete posiciones, tres preguntas

Numeremos las posiciones de 1 a 7. Las posiciones 1, 2 y 4 contienen controles; 3, 5, 6 y 7 contienen d₁, d₂, d₃ y d₄. El símbolo ⊕ representa XOR, suma módulo 2: 1 ⊕ 1 = 0. Las ecuaciones imponen paridad par. Los subíndices de p indican posiciones, no el orden de los controles. [1, §3]

$p_1=d_1\oplus d_2\oplus d_4$p1​=d1​⊕d2​⊕d4​

$p_2=d_1\oplus d_3\oplus d_4$p2​=d1​⊕d3​⊕d4​

$p_4=d_2\oplus d_3\oplus d_4$p4​=d2​⊕d3​⊕d4​

El receptor comprueba {1,3,5,7}, {2,3,6,7} y {4,5,6,7}. Un control fallido produce un bit de síndrome 1; uno satisfecho produce 0. Sean s₁, s₂ y s₄. Si hay como máximo una inversión, su posición j es:

$j=s_1+2s_2+4s_4$j=s1​+2s2​+4s4​

Un síndrome cero indica ausencia de error solo bajo ese supuesto; no certifica universalmente la integridad.

3. Una corrección reproducible

Tomemos los datos 1010. Resultan p₁ = 1, p₂ = 0 y p₄ = 1. La palabra transmitida, leída de izquierda a derecha por posición, es 1011010. Si se invierte el bit 6, se recibe 1011000. El primer control es par y los otros dos son impares. Así, (s₁,s₂,s₄) = (0,1,1) y j = 0 + 2 + 4 = 6. Se vuelve a invertir el bit 6 y se leen las posiciones 3,5,6,7: se recupera 1010.

Esquema científico generado mediante código; secuencias exactas, no datos experimentales.

Es un cálculo editorial, no una medición experimental. El procedimiento también corrige un bit de control invertido. Supone límites de bloque y posiciones conocidos; insertar o eliminar bits pertenece a otro modelo de error.

4. Por qué funciona

Tres controles binarios tienen ocho resultados: justo los necesarios para distinguir siete posiciones de error único y la ausencia de error. En general, un código binario con r controles y n bits necesita al menos n + 1 síndromes distintos para corregir una inversión:

$2^r\ge n+1$2r≥n+1

La construcción alcanza ese número con n = 2ʳ − 1 y k = n − r datos. Para r = 3, n = 7 y k = 4. La distancia mínima de Hamming, el menor número de posiciones diferentes entre dos palabras válidas, es 3. Una palabra recibida no puede estar a una inversión de dos palabras válidas: estas distarían como máximo 2.

Hay 16 palabras válidas; cada una, junto a sus siete vecinas de una inversión, forma un conjunto. Los conjuntos disjuntos cubren las 128 palabras: 16 × 8 = 128. «Perfecto» describe este empaquetamiento, no fiabilidad ilimitada frente al ruido. [1, §§5,7]

5. La trampa de los dos errores

Dos inversiones siempre dan un síndrome no nulo: un detector que solo señale palabras inválidas puede detectarlas. Sin embargo, interpretarlo siempre como error único puede provocar una corrección incorrecta. Invertir las posiciones 2 y 5 da el mismo síndrome que invertir la 7. Corregir el bit 7 deja tres bits incorrectos y otra palabra válida.

Un octavo bit que haga par la paridad total eleva la distancia mínima a 4. El código extendido permite corregir un error y detectar dos: SECDED. Las decisiones siguientes suponen como máximo dos inversiones; q es la paridad de los ocho bits recibidos. [1, §4]

Tres errores o más quedan fuera de la garantía. Un decodificador SECDED puede corregir erróneamente algunos de ellos; detectar dos errores no equivale a diagnosticar todos los fallos mayores.

6. Una ventaja numérica, con supuestos explícitos

Supongamos inversiones independientes con probabilidad p = 0,01, igual para 0 y 1, codificación y decodificación perfectas y límites de bloque conocidos. Con el código de siete bits y este decodificador, el mensaje recuperado es incorrecto exactamente cuando hay al menos dos inversiones:

$\begin{aligned} P_{\rm fail}&=1-(1-p)^7\\ &\quad-7p(1-p)^6. \end{aligned}$Pfail​​=1−(1−p)7−7p(1−p)6.​

El resultado es aproximadamente 0,002031, o 0,2031 % de los bloques. Sin codificar los cuatro datos, 1 − (1 − p)⁴ = 0,039404: un 3,9404 % de mensajes con error. Son probabilidades de error de mensaje, no tasas residuales por bit ni prestaciones medidas de un equipo.

Se pagan tres bits adicionales por cuatro datos: un 75 % más de bits transmitidos y una tasa de código 4/7 ≈ 0,5714 bits de datos por bit transmitido. La comparación fija p, pero no simultáneamente ancho de banda, tiempo y energía por mensaje.

7. Qué promete el resultado y qué no

La contribución duradera vincula álgebra y fiabilidad de forma constructiva: separar palabras válidas, calcular controles compactos y localizar un fallo limitado. El caso de siete bits permite verificación exhaustiva. Para este artículo se comprobaron los 16 mensajes y sus 128 casos sin error o con uno, además de los 448 casos con dos errores del código extendido.

No repara ráfagas arbitrarias, software corrupto, alteraciones maliciosas ni pérdida de sincronización. Un sistema real debe adaptar el código al modelo de fallos y proteger codificador, decodificador y lógica circundante. Hamming no aporta mediciones de equipos modernos; nuestro cálculo se separa de tales afirmaciones. Complementa los límites de comunicación de Shannon con una construcción finita explícita, no con una solución universal que alcance la capacidad.

8. Reproducir el cálculo finito

Protocolo HAMMING-REPRO-1. Copie el bloque Python completo en reproduce_hamming.py y ejecute python3 reproduce_hamming.py. Solo utiliza la biblioteca estándar de Python, sin red, descarga de datos ni semilla aleatoria. Se ejecutó con CPython 3.12.14 para esta revisión editorial. Las posiciones empiezan en 1; el octavo bit impone paridad total par. El programa enumera los 16 mensajes, construye por separado las palabras válidas de siete bits mediante las restricciones de paridad y las compara con el codificador.

Salida esperada: status PASS, codewords 16, minimum_distances [3, 4]. Los contadores son 128 recuperaciones correctas con cero o un error en siete bits; 144 en ocho bits; 448 errores dobles detectados por el código extendido; 336 errores dobles corregidos incorrectamente por el decodificador de siete bits; y 896 errores triples corregidos incorrectamente por el decodificador de ocho bits descrito. Los dos últimos son controles negativos: muestran límites, no correcciones exitosas. Con p = 0,01, coded_message_error es aproximadamente 0,00203104163494 y uncoded_message_error 0,03940399. Estas probabilidades suponen inversiones independientes con p fijo, no igual energía o ancho de banda.

"""News HAMMING-REPRO-1: finite mathematical check, not hardware validation."""
from itertools import combinations, product
import json
import platform


def encode(data):
    a, b, c, d = data
    return (a ^ b ^ d, a ^ c ^ d, a, b ^ c ^ d, b, c, d)


def syndrome(word):
    a, b, c, d, e, f, g = word[:7]
    return (a ^ c ^ e ^ g) + 2 * (b ^ c ^ f ^ g) + 4 * (d ^ e ^ f ^ g)


def flip(word, positions):
    result = list(word)
    for position in positions:
        result[position - 1] ^= 1
    return tuple(result)


def decode7(word):
    position = syndrome(word)
    return flip(word, (position,)) if position else word


def decode8(word):
    position, parity = syndrome(word), sum(word) % 2
    if parity:
        return flip(word, (position or 8,))
    return None if position else word


def distance(a, b):
    return sum(x != y for x, y in zip(a, b))


def require(condition, label):
    if not condition:
        raise RuntimeError(label)


messages = list(product((0, 1), repeat=4))
code7 = [encode(data) for data in messages]
code8 = [word + (sum(word) % 2,) for word in code7]
# Independent enumeration uses parity sums rather than the encoder equations.
groups = ((1, 3, 5, 7), (2, 3, 6, 7), (4, 5, 6, 7))
oracle = {
    word for word in product((0, 1), repeat=7)
    if all(sum(word[p - 1] for p in group) % 2 == 0 for group in groups)
}
require(len(set(code7)) == 16 and set(code7) == oracle, "codebook")
min7 = min(distance(a, b) for a, b in combinations(code7, 2))
min8 = min(distance(a, b) for a, b in combinations(code8, 2))
require((min7, min8) == (3, 4), "minimum distances")
counts = {"seven_zero_or_one": 0, "eight_zero_or_one": 0,
          "eight_double_detected": 0, "seven_double_miscorrected": 0,
          "eight_triple_miscorrected": 0}
for word in code7:
    for positions in [()] + [(i,) for i in range(1, 8)]:
        require(decode7(flip(word, positions)) == word, "seven-bit recovery")
        counts["seven_zero_or_one"] += 1
    for positions in combinations(range(1, 8), 2):
        received = flip(word, positions)
        require(syndrome(received) != 0, "double error detectable")
        require(decode7(received) != word, "double error outside correction guarantee")
        counts["seven_double_miscorrected"] += 1
for word in code8:
    for positions in [()] + [(i,) for i in range(1, 9)]:
        require(decode8(flip(word, positions)) == word, "eight-bit recovery")
        counts["eight_zero_or_one"] += 1
    for positions in combinations(range(1, 9), 2):
        require(decode8(flip(word, positions)) is None, "double error must be flagged")
        counts["eight_double_detected"] += 1
    for positions in combinations(range(1, 9), 3):
        result = decode8(flip(word, positions))
        require(result is not None and result != word and result in code8,
                "triple error counterexample")
        counts["eight_triple_miscorrected"] += 1
require(list(counts.values()) == [128, 144, 448, 336, 896], "case counts")
require(encode((1, 0, 1, 0)) == (1, 0, 1, 1, 0, 1, 0), "worked example")
require(syndrome((1, 0, 1, 1, 0, 0, 0)) == 6, "worked syndrome")
p = 0.01
failure = 1 - (1-p)**7 - 7*p*(1-p)**6
uncoded = 1 - (1-p)**4
require(abs(failure - 0.00203104163494) < 1e-12, "probability")
print(json.dumps({"protocol": "HAMMING-REPRO-1", "python": platform.python_version(),
                  "codewords": len(code7), "minimum_distances": [min7, min8],
                  "counts": counts, "p": p, "coded_message_error": failure,
                  "uncoded_message_error": uncoded, "status": "PASS"}, indent=2))

PASS significa que estas comprobaciones matemáticas finitas pasaron. No demuestra prestaciones de hardware, robustez ante otros modelos de error ni replicación independiente. El campo python indica la versión de su intérprete y puede variar. Si aparece RuntimeError, conserve el script y la salida completa y examine la comprobación indicada; una ejecución parcial no equivale a validación.

Método News de este artículo

2026-10-03 — La revisión HAMMING-EN-2 añade la introducción progresiva y el protocolo completo. El cuerpo científico y el esquema programado se conservan de HAMMING-EN-1. Para esta actualización se revisaron la construcción y sus límites en el artículo de 1950 y las secciones 5.6–5.7 del MIT; se ejecutó el programa finito. Redacción y traducciones son de IA, sin revisión experta independiente ni validación humana.

Fuentes

[1] R. W. Hamming — Error Detecting and Error Correcting Codes — DOI: 10.1002/j.1538-7305.1950.tb00463.x.

[2] Nokia Bell Labs — Error Detecting and Error Correcting Codes.

[3] MIT 6.02 — Coping with Bit Errors using Error Correction Codes.