Dieser Artikel wurde von einem KI-System anhand der angegebenen Quellen verfasst und übersetzt, mit automatisierten Prüfungen nach der News-Redaktionsmethode.
Wartung — 7. Oktober 2026. Das Titelbild wurde ersetzt, weil seine ursprüngliche Datei und der Erzeugungsbeleg mit den verfügbaren Zugängen nicht wiedergefunden werden konnten. Das neue Bild wurde vom nativen Bildwerkzeug empfangen und visuell geprüft; Datei, Anweisung und Quellen bleiben im privaten redaktionellen Dossier erhalten. Das frühere Bild und seine nicht verifizierte Herkunft bleiben im Verlauf. Es handelt sich um eine Illustration, nicht um einen experimentellen Beleg; das zentrale wissenschaftliche Ergebnis bleibt erhalten.
KI-generierte konzeptionelle Illustration des Hamming-Codes (7,4): vier Datenbits, drei Prüfbits und Korrektur einer Bitumkehr pro Block. Symbolische Plättchen, kein Schaltkreis.
Vor den Gleichungen
Ein Bit ist ein Wert, 0 oder 1. Ein Bitfehler vertauscht diese Werte. Parität gibt an, ob eine Gruppe eine gerade oder ungerade Anzahl von Einsen enthält. Zum Beispiel enthält 101 zwei Einsen: Die Parität ist gerade. Redundanz bedeutet, zusätzliche Informationen zu übertragen, mit denen der Empfänger die Daten prüfen kann. Hier lokalisieren drei überlappende Prüfungen ein gekipptes Bit, sofern höchstens eines in einem Sieben-Bit-Block vorliegt.
Zum Verständnis folgen Sie dem Beispiel in Abschnitt 3 und kehren dann zu den Gleichungen in Abschnitt 2 zurück. Zur Überprüfung dient das vollständige Programm unten. Fragen Sie sich: Beweist eine bestandene Prüfung, dass kein Bit verändert wurde? Abschnitt 5 erklärt, warum die Antwort vom Fehlermodell abhängt.
1. Zuverlässigkeit durch strukturierte Redundanz
Im April 1950 veröffentlichte Richard W. Hamming „Error Detecting and Error Correcting Codes“ im Bell System Technical Journal. Das Problem war praktisch: Eine erkannte Störung konnte einen unbeaufsichtigten Rechenlauf stoppen. Ließ sie sich lokalisieren und korrigieren, konnte die Arbeit weitergehen. Der Aufsatz liefert konkrete binäre Konstruktionen, kein Versprechen, beliebige Schäden zu beheben. [1,2]
Der Fortschritt besteht in aussagekräftiger Redundanz. Vier Bits jeweils dreimal zu senden erfordert zwölf übertragene Bits. Ein Hamming-Code benötigt sieben, um dieselben vier Datenbits gegen ein beliebiges einzelnes gekipptes Bit im Block zu schützen. Das sind unterschiedliche Anordnungen von Redundanz, keine universelle Optimalitätsaussage. Kompression entfernt Redundanz; Fehlerkorrektur fügt gezielt welche hinzu.
2. Sieben Positionen, drei Fragen
Die übertragenen Positionen werden von 1 bis 7 nummeriert. An 1, 2 und 4 stehen Prüfbits, an 3, 5, 6 und 7 die Daten d₁, d₂, d₃ und d₄. ⊕ bedeutet exklusives Oder, also Addition modulo 2: 1 ⊕ 1 = 0. Die Gleichungen erzeugen gerade Parität. Die Indizes von p bezeichnen Positionen, nicht die Reihenfolge der Prüfungen. [1, §3]
p1=d1⊕d2⊕d4
p2=d1⊕d3⊕d4
p4=d2⊕d3⊕d4
Der Empfänger prüft {1,3,5,7}, {2,3,6,7} und {4,5,6,7}. Eine verletzte Prüfung ergibt Syndrombit 1, eine erfüllte 0. Diese Bits heißen s₁, s₂ und s₄. Bei höchstens einem gekippten Bit ist dessen Position j:
j=s1+2s2+4s4
Ein Nullsyndrom bedeutet nur unter dieser Annahme Fehlerfreiheit; es ist kein allgemeines Integritätszertifikat.
3. Eine nachvollziehbare Korrektur
Für die Daten 1010 ergeben sich p₁ = 1, p₂ = 0 und p₄ = 1. Das von links nach rechts in Positionsreihenfolge gesendete Wort lautet 1011010. Kippt Bit 6, kommt 1011000 an. Die erste Prüfung ist gerade, die zweite und dritte ungerade. Damit gilt (s₁,s₂,s₄) = (0,1,1) und j = 0 + 2 + 4 = 6. Bit 6 wird erneut umgekehrt; die Positionen 3,5,6,7 liefern wieder 1010.
Programmiertes wissenschaftliches Schema; exakte Bitfolgen, keine Messdaten.
Dies ist eine redaktionelle Beispielrechnung, keine Messung. Das Verfahren korrigiert auch ein gekipptes Prüfbit. Blockgrenzen und Positionen müssen bekannt sein; eingefügte oder gelöschte Bits gehören zu einem anderen Fehlermodell.
4. Warum die Konstruktion funktioniert
Drei binäre Prüfungen haben acht mögliche Ergebnisse: genau genug für sieben Einzelfehlerpositionen und den fehlerfreien Fall. Allgemein benötigt ein binärer Code mit r Prüfbits und n Gesamtbits mindestens n + 1 unterscheidbare Syndrome zur Einzelfehlerkorrektur:
2r≥n+1
Die Hamming-Konstruktion erreicht diese Anzahl mit n = 2ʳ − 1 und k = n − r Datenbits. Für r = 3 gilt n = 7 und k = 4. Der minimale Hamming-Abstand, die kleinste Zahl unterschiedlicher Positionen zwischen gültigen Wörtern, ist 3. Ein Empfangswort kann nicht nur einen Bitwechsel von zwei gültigen Wörtern entfernt sein: Diese hätten höchstens Abstand 2.
Es gibt 16 gültige Wörter mit jeweils sieben Einzelfehlernachbarn. Einschließlich der Wörter selbst füllen diese disjunkten Mengen alle 128 Möglichkeiten: 16 × 8 = 128. „Perfekt“ bezeichnet diese Packung, nicht fehlerlosen Betrieb bei beliebigem Rauschen. [1, §§5,7]
5. Die Falle bei zwei Fehlern
Zwei gekippte Bits erzeugen stets ein Syndrom ungleich null. Ein reiner Detektor für ungültige Wörter erkennt sie daher. Ein Decoder, der jedes solche Syndrom als Einzelfehler deutet, kann jedoch falsch korrigieren. Fehler an den Positionen 2 und 5 ergeben dasselbe Syndrom wie einer an Position 7. Die Korrektur von Bit 7 hinterlässt drei falsche Bits und ein anderes gültiges Wort.
Ein achtes Bit für gerade Gesamtparität erhöht den Mindestabstand auf 4. Der erweiterte Code ermöglicht Einzelfehlerkorrektur und Doppelfehlererkennung: SECDED. Die folgenden Entscheidungen setzen höchstens zwei Bitfehler voraus. q ist die Parität aller acht empfangenen Bits. [1, §4]
| Syndrom j | Parität q | Aktion unter der genannten Annahme |
|---|---|---|
| 0 | 0 | Kein Fehler |
| 0 | 1 | Bit 8 korrigieren |
| ungleich null | 1 | Bit j korrigieren |
| ungleich null | 0 | Zwei Fehler melden; nicht korrigieren |
Drei oder mehr Fehler liegen außerhalb der Garantie. Ein SECDED-Decoder kann manche davon falsch korrigieren. Doppelfehlererkennung bedeutet keine Diagnose beliebig großer Störungen.
6. Ein Zahlenbeispiel mit klaren Annahmen
Jedes übertragene Bit kippe unabhängig mit Wahrscheinlichkeit p = 0,01, gleich für 0 und 1. Codierung und Decodierung seien fehlerfrei, die Blockgrenzen bekannt. Beim Sieben-Bit-Code mit diesem Decoder ist die rekonstruierte Vier-Bit-Nachricht genau dann falsch, wenn mindestens zwei Bits kippen:
Pfail=1−(1−p)7−7p(1−p)6.
Das ergibt ungefähr 0,002031 beziehungsweise 0,2031 % der Blöcke. Für vier uncodierte Bits gilt 1 − (1 − p)⁴ = 0,039404, also 3,9404 % fehlerhafte Nachrichten. Das sind Nachrichtenfehlerwahrscheinlichkeiten, keine verbleibenden Bitfehlerraten oder gemessenen Geräteleistungen.
Der Preis beträgt drei zusätzliche Bits für vier Datenbits: 75 % mehr übertragene Bits und Coderate 4/7 ≈ 0,5714 Datenbits je übertragenem Bit. Der Vergleich hält p konstant, nicht gleichzeitig Bandbreite, Übertragungszeit und Energie pro Nachricht.
7. Reichweite und Grenzen des Ergebnisses
Der bleibende Beitrag verbindet Algebra konstruktiv mit Zuverlässigkeit: gültige Wörter trennen, kompakte Prüfungen berechnen und begrenzte Fehler lokalisieren. Der Sieben-Bit-Fall lässt sich vollständig prüfen. Für diesen Artikel wurden alle 16 Nachrichten und ihre 128 Fälle mit null oder einem Fehler geprüft, dazu die 448 Doppelfehlerfälle des erweiterten Codes.
Beliebige Fehlerbursts, beschädigte Software, böswillige Änderungen oder verlorene Synchronisation werden damit nicht behoben. Reale Systeme müssen den Code auf ihr Fehlermodell abstimmen und Encoder, Decoder sowie umgebende Logik schützen. Hamming liefert keine Messdaten moderner Hardware. Unsere Beispielrechnung ist davon ausdrücklich getrennt. Sie ergänzt Shannons Kommunikationsgrenzen durch eine konkrete endliche Konstruktion, nicht durch eine universell kapazitätserreichende Lösung.
8. Die endliche Rechnung reproduzieren
Protokoll HAMMING-REPRO-1. Kopieren Sie den vollständigen Python-Block in reproduce_hamming.py und führen Sie python3 reproduce_hamming.py aus. Das Programm verwendet nur die Python-Standardbibliothek, ohne Netzwerk, Datendownload oder Zufallsstartwert. Für diese redaktionelle Revision wurde es mit CPython 3.12.14 ausgeführt. Positionen beginnen bei 1; das achte Bit stellt gerade Gesamtparität her. Das Programm zählt alle 16 Nachrichten auf, konstruiert die gültigen Sieben-Bit-Wörter separat aus den Paritätsbedingungen und vergleicht sie mit dem Encoder.
Erwartete Ausgabe: status PASS, codewords 16, minimum_distances [3, 4]. Die Zähler ergeben 128 korrekte Wiederherstellungen bei null oder einem Fehler für sieben Bits; 144 für acht Bits; 448 erkannte Doppelfehler des erweiterten Codes; 336 Fehlkorrekturen von Doppelfehlern durch den Sieben-Bit-Decoder; und 896 Fehlkorrekturen von Dreifachfehlern durch den beschriebenen Acht-Bit-Decoder. Die letzten beiden sind Negativkontrollen: Sie zeigen Grenzen, keine erfolgreichen Korrekturen. Für p = 0,01 beträgt coded_message_error ungefähr 0,00203104163494 und uncoded_message_error 0,03940399. Vorausgesetzt werden unabhängige Bitfehler bei festem p, nicht gleiche Energie oder Bandbreite.
"""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 bedeutet, dass diese endlichen mathematischen Prüfungen bestanden wurden. Es belegt weder Hardwareleistung noch Robustheit gegenüber anderen Fehlermodellen oder unabhängige Replikation. Das Feld python nennt Ihre Interpreterversion und kann abweichen. Bei RuntimeError bewahren Sie Skript und vollständige Ausgabe auf und untersuchen die genannte Prüfung; ein Teillauf ist keine Validierung.
News-Methode für diesen Artikel
2026-10-03 — Revision HAMMING-EN-2 ergänzt die schrittweise Einführung und das vollständige Protokoll. Wissenschaftlicher Haupttext und programmiertes Schema bleiben aus HAMMING-EN-1 erhalten. Für diese Aktualisierung wurden Konstruktion und Grenzen im Aufsatz von 1950 und in den MIT-Abschnitten 5.6–5.7 erneut geprüft; das endliche Programm wurde ausgeführt. Text und Übersetzungen stammen von KI, ohne unabhängige Fachbegutachtung oder menschliche Validierung.
Quellen
[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.