DE102014118531B4

DE102014118531B4 - Verfahren und Datenverarbeitungseinrichtung zum Ermitteln eines Fehlervektors in einem Datenwort

Info

Publication number: DE102014118531B4
Application number: DE102014118531.5A
Authority: DE
Inventors: Rainer Göttfert
Original assignee: Infineon Technologies AG
Current assignee: Infineon Technologies AG
Priority date: 2014-12-12
Filing date: 2014-12-12
Publication date: 2016-08-25
Anticipated expiration: 2034-12-13
Also published as: US10193573B2; DE102014118531A1; US20160173133A1

Abstract

Gemäß einem Ausführungsbeispiel wird ein Verfahren zum Ermitteln eines Fehlervektors in einem Datenwort beschrieben, aufweisend: Ermitteln des Syndroms des Fehlervektors; sukzessives Erzeugen von Codewörtern durch zyklisches Vertauschen ein oder mehrerer vorgegebener Codewörter, Bilden, für jedes erzeugte Codewort, der Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort und überprüfen, für das Codewort, ob die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat; und Ermitteln des Fehlervektors als die Summe des Syndroms mit dem Codewort, für das die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat.

Description

Ausführungsbeispiele betreffen allgemein Verfahren und Datenverarbeitungseinrichtungen zum Ermitteln eines Fehlervektors in einem Datenwort.
Um die Korrektur von Fehlern in Daten, die beispielsweise bei der Datenübertragung oder beim Speichern oder Auslesen entstanden sind, zu ermöglichen, werden Daten typischerweise mittels eines Codes codiert. So ein Code kann auch beispielsweise dazu verwendet werden, um die Rekonstruktion eines von einer PUF (Physical Unclonable Function) bereitgestellten Werts zu ermöglichen. In beiden Fällen ist es erforderlich, dass ein Fehlervektor in einem Datenwort (beispielsweise einer Nachricht oder einem PUF-Wert) ermittelt wird. Es ist wünschenswert, dass diese Ermittlung effizient durchgeführt wird.
Aus dem Dokument US 4 382 300 A ist ein Verfahren zum Ermitteln eines Fehlervektors in einem Datenwort bekannt, aufweisend ein Ermitteln des Syndroms des Fehlervektors und ein Ermitteln des Fehlervektors als die Summe des Syndroms mit dem Fehlervektor.
Aus dem Dokument US 2008/0 126 908 A1 ist ein Verfahren zum Ermitteln eines Fehlervektors in einem Datenwort bekannt, aufweisend sukzessives Erzeugen von Codewörtern durch zyklisches Vertauschen ein oder mehrerer vorgegebener Codewörter, Bilden, für jedes erzeugte Codewort, der Summe des Datenworts mit dem Codewort.
Gemäß einem Ausführungsbeispiel wird ein Verfahren zum Ermitteln eines Fehlervektors in einem Datenwort bereitgestellt, aufweisend: Ermitteln des Syndroms des Fehlervektors; sukzessives Erzeugen von Codewörtern durch zyklisches Vertauschen ein oder mehrerer vorgegebener Codewörter, Bilden, für jedes erzeugte Codewort, der Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort und überprüfen, für das Codewort, ob die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat; und Ermitteln des Fehlervektors als die Summe des Syndroms mit dem Codewort, für das die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat.
Gemäß einer weiteren Ausführungsform wird eine Datenverarbeitungseinrichtung gemäß dem oben beschriebenen Verfahren bereitgestellt.
Die Figuren geben nicht die tatsächlichen Größenverhältnisse wieder sondern sollen dazu dienen, die Prinzipien der verschiedenen Ausführungsbeispiele zu illustrieren. Im Folgenden werden verschiedene Ausführungsbeispiele mit Bezug auf die folgenden Figuren beschrieben.
1 zeigt ein Ablaufdiagramm, das ein Verfahren zum Ermitteln eines Fehlervektors in einem Datenwort veranschaulicht.
2 zeigt eine Datenverarbeitungseinrichtung zum Ermitteln eines Fehlervektors in einem Datenwort gemäß einer Ausführungsform.
3 zeigt zwei Darstellungen einer Hammingkugel.
4 zeigt einen Vergleich von Hammingkugeln mit Super-Hammingkugeln.
5 zeigt eine Schaltung zur Syndromberechnung.
6 zeigt ein Beispiel für einen Decoder für den Simplex-Code.
7 zeigt eine Schaltung zur Berechnung eines Syndroms zur PUF-Rekonstruktion.
8 zeigt eine Schaltung zur Syndromberechnung.
9 zeigt eine Schaltung zur Syndromberechnung zur PUF-Rekonstruktion.
10 zeigt einen Decoder zur PUF-Rekonstruktion für den (15, 4, 8) Simplex Code.
11 zeigt eine Schaltung zur Syndromberechnung.
12 zeigt ein lineares rückgekoppeltes Schieberegister.
13 veranschaulicht die Syndromberechnung für einen Vektor.
14 veranschaulicht die Syndromberechnung für einen PUF-Wert.
15 zeigt einen Decoder zur PUF-Rekonstruktion für den (31, 5, 16) Simplex Code.
Die folgende detaillierte Beschreibung bezieht sich auf die beiliegenden Figuren, die Details und Ausführungsbeispiele zeigen. Diese Ausführungsbeispiele sind so detailliert beschrieben, dass der Fachmann die Erfindung ausführen kann. Andere Ausführungsformen sind auch möglich und die Ausführungsbeispiele können in struktureller, logischer und elektrischer Hinsicht geändert werden, ohne vom Gegenstand der Erfindung abzuweichen. Die verschiedenen Ausführungsbeispiele schließen sich nicht notwendig gegenseitig aus sondern es können verschiedene Ausführungsformen miteinander kombiniert werden, so dass neue Ausführungsformen entstehen. Im Rahmen dieser Beschreibung werden die Begriffe ”verbunden”, ”angeschlossen” sowie ”gekoppelt” verwendet zum Beschreiben sowohl einer direkten als auch einer indirekten Verbindung, eines direkten oder indirekten Anschlusses sowie einer direkten oder indirekten Kopplung.
Im Folgenden werden Ausführungsformen beschrieben, bei denen mittels eines Schaltkreises (z. B. gemäß einem Algorithmus) Fehler korrigiert werden, die bei der Übertragung oder der Speicherung von Daten auftreten. Gemäß weiteren Ausführungsbeispielen wird ein Schaltkreis bereitgestellt, der als mit einem solchen Schaltkreis verwandt angesehen werden kann und die Rekonstruktion von PUF-Werten ermöglicht. Gemäß verschiedenen Ausführungsformen werden dabei hohe Fehlerraten (ca. 10%) korrigierbar gemacht.
Die Abkürzung PUF steht für „Physical unclonable function” oder Physikalische Hashfunktion. Die Idee dabei ist, physikalische Eigenschaften eines Objektes zu digitalisieren und so eine dem Objekt zugeordnete Bitfolge (Nummer) zu erhalten. Dabei ist es wünschenswert, dass die Bitfolgen zweier verschiedener physikalischer Objekte zueinander unkorreliert sind. Ein einfaches Beispiel zur Veranschaulichung ist ein Blatt Papier. Unter einem Mikroskop betrachtet erkennt man eine spezielle Feinstruktur der Holzspäne oder Zellstoffteile. Die Struktur kann mit Hilfe eines geeigneten Verfahrens vermessen werden und das Ergebnis als Bitfolge dargestellt werden. Diese Bitfolge ist die PUF oder der PUF-Wert für das Blatt. Ein anderes Blatt Papier ergibt bei diesem Vorgehen im Allgemeinen eine Bitfolge, die unkorreliert ist zur Bitfolge des ersten Blatts.
Den Prozess der Erzeugung einer Bitfolge (des PUF-Werts) aus den Eigenschaften des physikalischen Objektes wir als PUF-Generierung bezeichnet. Es ist wünschenswert, dass die PUF-Generierung auf effiziente Weise möglich ist.
Eine wünschenswerte Eigenschaft eines PUF-Generierungs-Mechanismus ist, dass dasselbe physikalische Objekt bei jeder PUF-Generierung jedes Mal dieselbe Bitfolge ergibt (z. B. bei jeder PUF-Anforderung). Dies ist jedoch typischerweise nicht der Fall. Eine wiederholte PUF-Generierung für dasselbe physikalische Objekt liefert typischerweise Bitfolgen, die zwar untereinander sehr ähnlich, aber im Allgemeinen nicht miteinander identisch sind. Dieses Defizit kann mit Methoden der Codierungstheorie (Fehlerkorrektur) ausgeglichen werden.
Dabei wird beispielsweise wie folgt vorgegangen: Gegeben sei ein physikalisches Objekt. Man erzeugt die dem Objekt zugeordnete erste PUF-Bitfolge A, und bezeichnet A als den wahren PUF-Wert. Aus dem wahren PUF-Wert A wird ein zugehöriger Hilfsvektor (auch bezeichnet als Hilfsinformation) b berechnet. Der Hilfsvektor b wird als öffentlich zugängliche Information betrachtet. Z. B. wird b in einer nicht sicheren Umgebung abgespeichert. Der wahre PUF-Wert A selbst ist geheim und wird gar nicht abgespeichert und steht daher auch nicht direkt zur Verfügung. Bei einer späteren erneuten PUF-Generierung erhält man einen neuen PUF-Wert A'. Der Wert A' ist im Allgemeinen nicht identisch mit A, unterscheidet sich aber von A nur geringfügig. Ziel ist, den wahren PUF-Wert A wiederzugewinnen, ihn aus dem vorhandenen aktuellen PUF-Wert A' zu rekonstruieren. Dabei verwendet man die abgespeicherten Hilfsdaten b.
1 zeigt ein Ablaufdiagramm 100.
Das Ablaufdiagramm 100 veranschaulicht ein Verfahren zum Ermitteln eines Fehlervektors in einem Datenwort.
In 101 wird das Syndrom des Fehlervektors ermittelt.
In 102 werden sukzessive Codewörter durch zyklisches Vertauschen ein oder mehrerer vorgegebener Codewörter erzeugt.
In 103 wird für jedes erzeugte Codewort die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort gebildet und für das Codewort überprüft, ob die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat.
In 104 wird der Fehlervektor als die Summe des Syndroms mit dem Codewort, für das die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat, ermittelt.
In anderen Worten werden die zyklischen Vertauschungen eines Codeworts durchlaufen, jede zyklische Vertauschung zu dem Syndrom addiert (das geeignet mit Nullen auf Codewortlänge ergänzt ist) und für jede zyklische Vertauschung ermittelt, ob ihre Summe mit dem Syndrom minimales Gewicht hat. Ist dies der Fall, wird die Summe als Fehlervektor verwendet.
Wenn das Nullwort ein Codewort ist, beispielsweise im Fall eines linearen Codes, kann das Minimum auch für das Syndrom selbst (d. h. für Summe aus Nullwort und Syndrom) angenommen werden. In diesem Fall wird also der Fehlervektor durch Ergänzen des Syndroms mit Nullen auf Datenwortlänge ermittelt. Beispielsweise kann vorab überprüft werden, ob das Hamminggewicht des Syndroms geringer ist als die halbe Hammingdistanz des Codes und in diesem Fall der Fehlervektor als ergänztes Syndrom ermittelt werden, bevor weitere Codewörter (durch zyklische Vertauschung eines Codeworts) erzeugt werden.
Unter der zyklischen Vertauschung eines Codeworts ist die zyklische Permutation eines Codeworts zu verstehen. Beispielsweise wird das Codewort in ein Schieberegister eingespeichert, dessen letztes Speicherelement (z. B. Flip-Flop) mit dem ersten Speicherelement verbunden ist, so dass ein an einem Ende herausgeschobenes Bit am anderen Ende in das Schieberegister hineingeschoben wird.
Gemäß einer Ausführungsform weist das ferner Verfahren ferner das Korrigieren des Datenworts mittels des Fehlervektors auf.
Gemäß einer Ausführungsform weist das Verfahren ferner das Ausgeben des korrigierten Datenworts an eine Verarbeitungseinrichtung auf.
Das Datenwort ist beispielsweise ein mit dem Code codiertes Nachrichtenwort.
Das Verfahren kann ferner das Empfangen des Datenworts von einem Sender aufweisen.
Das Syndrom des Fehlervektors ist beispielsweise das Syndrom des Datenworts.
Das Datenwort kann auch ein PUF-Wort sein.
Das Verfahren kann beispielsweise ferner das Empfangen des Datenworts von einer Schaltung, die eine PUF implementiert, aufweisen.
Das Syndrom des Fehlervektors ist beispielsweise die Summe aus dem Syndroms des Datenvektors und eines Hilfsvektors.
Der Hilfsvektor ist beispielsweise das Syndrom eines bei einer Initialisierung ermittelten PUF-Worts, das sich von dem Datenwort um den Fehlervektor unterscheidet.
Gemäß einer Ausführungsform weist das Prüfen, ob die Summe des auf Datenwortlänge ergänzten Syndroms mit dem Codewort minimales Gewicht hat, das Prüfen auf, ob das Gewicht der Summe kleiner als die halbe Hammingdistanz des Codes ist.
Gemäß einer Ausführungsform weist das Verfahren das Abbrechen des sukzessiven Erzeugens von Wörtern der Menge auf, wenn ein Codewort gefunden wurde, für das das Gewicht der Summe kleiner als die halbe Hammingdistanz des Codes ist.
Gemäß einer Ausführungsform weist das Prüfen, ob die Summe des auf Datenwortlänge ergänzten Syndroms mit dem Wort minimales Gewicht hat, das Ermitteln, für alle erzeugten Codewörter, der Summe des auf Datenwortlänge ergänzten Syndroms mit dem Codewort und den Vergleich der ermittelten Summen auf.
Gemäß einer Ausführungsform weist das Verfahren ferner das Ermitteln des Datenworts als nicht korrigierbar auf, wenn für kein Codewort die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat.
Das Ergänzen des Syndroms mit Nullen auf Datenwortlänge erfolgt beispielsweise gemäß einer Kontrollmatrix, die ebenso viele Einheitsvektoren aufweist, wie das Syndrom Komponenten hat.
Beispielsweise erfolgt das Ergänzen des Syndroms mit Nullen auf Datenwortlänge gemäß einer Kontrollmatrix, die eine Einheitsmatrix mit der Zeilenanzahl gleich der Anzahl von Komponenten des Syndroms aufweist.
Das Ergänzen des Syndroms mit Nullen auf Datenwortlänge weist beispielsweise das Einfügen von Nullen in das Syndrom an Stellen auf, die Spalten der Kontrollmatrix entsprechen, die keine Einheitsvektoren sind.
Gemäß einer Ausführungsform ist der Code ein zyklischer Code.
Gemäß einer Ausführungsform besteht der Code aus dem Nullwort und allen zyklischen Vertauschungen eines Codeworts ungleich dem Nullwort.
Die Codewörter werden beispielsweise durch zyklisches Vertauschen eines einzigen Codeworts erzeugt.
Beispielsweise ist der Code ein Simplex-Code.
Das in 1 dargestellte Verfahren wird beispielsweise von einer Vorrichtung, wie sie in 2 dargestellt ist, durchgeführt.
2 zeigt eine Datenverarbeitungseinrichtung 200 zum Ermitteln eines Fehlervektors in einem Datenwort gemäß einer Ausführungsform.
Die Datenverarbeitungseinrichtung 200 weist eine Syndromermittlungsschaltung 201, die eingerichtet ist, das Syndroms des Fehlervektors zu ermitteln auf.
Die Datenverarbeitungseinrichtung 200 weist ferner eine Decodierschaltung 202 auf, die eingerichtet ist, sukzessiv Codewörter durch zyklisches Vertauschen ein oder mehrerer vorgegebener Codewörter zu erzeugen, für jedes erzeugte Codewort, die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort zu bilden und für das Codewort zu überprüfen, ob die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat.
Ferner weist die Datenverarbeitungseinrichtung 200 eine Ausgabeschaltung 203 auf, die eingerichtet ist, die Summe des Syndroms mit dem Codewort, für das die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat, als Fehlervektor auszugeben.
Die Datenverarbeitungseinrichtung empfängt den Datenvektor, beispielsweise einen PUF-Wert oder einen Nachrichtenvektor, beispielsweise von einer Datenquelle 204. Der Fehlervektor wird beispielsweise von einer Korrekturschaltung 205 zur Korrektur des Datenvektors empfangen, die das Datenwort nach Korrektur an weitere Komponenten 206 (zur weiteren Verarbeitung) weitergibt.
Die Komponenten der Datenverarbeitungseinrichtung (z. B. die Syndromermittlungsschaltung, die Decodierschaltung und die Ausgabeschaltung) können durch ein oder mehrere Schaltkreise oder (Teil-)Schaltungen realisiert sein. In einer Ausführungsform ist ein ”Schaltkreis” oder eine „Schaltung” als jegliche Einheit zu verstehen, die eine Logik implementiert, und die sowohl Hardware, Software, Firmware oder eine Kombination daraus sein kann. Somit kann ein ”Schaltkreis” oder eine „Schaltung” in einer Ausführungsform ein hart-verdrahteter Logik-Schaltkreis oder ein programmierbarer Logik-Schaltkreis sein, wie beispielsweise ein programmierbarer Prozessor. Unter einem ”Schaltkreis” oder einer „Schaltung” kann auch ein Prozessor zu verstehen sein, der Software ausführt. Unter einem ”Schaltkreis” oder „Schaltung” kann in einer Ausführungsform jegliche Art der Implementierung der im Weiteren beschriebenen Funktionen zu verstehen sein.
Im Folgenden werden Ausführungsbeispiele genauer beschrieben.
Die im Folgenden beschriebenen Ausführungsbeispiele basieren auf einem binären linearen (n, k, d) Code. Die Parameter haben die folgende Bedeutung:
n ist die Länge eine Codeworts in Bit.
k ist die Dimension des Codes, d. h. der Code besteht aus 2^k Codewörtern.
d ist die Minimumdistanz des Codes.
Die Menge aller Codewörter wird mit dem Buchstaben C bezeichnet und heißt Code.
Ein binärer linearer (n, k, d) Code ist ein k-dimensionaler Unterraum des Vektorraums V_n = F₂ ⁿ (auch bezeichnet als GF(2)ⁿ.
Der Vektorraum V_n besteht aus allen binären Vektoren der Länge n, auch bezeichnet als n-Bitwörter.
Sei v ∊ V_n. Die Vektorschreibweise für v ist v = (v₀, v₁, ..., v_n-1). Die Wortschreibweise für v ist v = v₀v₁ ... v_n-1.
Das Hamminggewicht w(v) eines Vektors aus V_n ist die Anzahl der Einsen in v. Die Hammingdistanz zweier Vektoren u und v aus V_n ist die Anzahl der Koordinatenstellen, in denen u und v unterschiedliche Einträge haben. Bei einem linearen Code ist die Hammingdistanz d(u, v) zweier Vektoren u, v ∊ V_n gleich dem Hamminggewicht des Summenvektors u + v.
Beispiel: Sei u = 1000 und v = 1010. Dann ist d(u, v) = 1. Das (Hamming-)Gewicht der Summe u + v = 0010 ist w(u + v) = 1. Ferner gilt w(u) = 1 und w(v) = 2.
Bei der Codierung einer Nachricht mittels eines binären linearen (n, k, d) Code können k Nachrichtenbits a₀, a₁, ..., a_k-1 frei gewählt werden. Zu den k Nachrichtenbits werden dann (gemäß einer Rechenvorschrift entsprechend dem Code) r = n – k Kontrollbits b_k, b_k+1, ..., b_n-1 berechnet. Die Kontrollbits werden an die Nachrichtenbits angehängt, wodurch ein Codewort c ∊ C entsteht: c = a₀a₁ ... a_k-1b_kb_k+1 ... b_n-1.
Es gibt 2^k verschiedene Codewörter, entsprechend den 2^k Möglichkeiten, die k Nachrichtenbits zu wählen.
Sei C = {c₁, c₂, ..., c_M} ein binärer linearer (n, k, d) Code, wobei M = 2^k. Die Minimumdistanz d des Codes C ist die kleinstmögliche Hammingdistanz, die zwei verschiedende Codewörter aus C zueinander haben können. Es gilt also d(c_i, c_j) ≥ d für 1 ≤ i < j ≤ M.
Für lineare Codes kann die Minimumdistanz d des Codes auch durch die Hamminggewichte der Codewörter von C beschrieben werden: Die Minimumdistanz d ist das kleinste Hamminggewicht unter allen von 0 verschiedenen Codewörtern von C. Das heißt, w(c_i) ≥ d für alle c ∊ C mit c ≠ 0.
Eine Hammingkugel B(c, r) um ein Codewort c ∊ C ⊆ V_n mit Radius r ≥ 0 ist die Menge aller Vektoren aus V_n, deren Hammingdistanz zu c kleiner oder gleich r ist. Das heißt, B(c, r) = {x ∊ V_n:d(x, c) ≤ r}.
Beispiel: Sei C ein Code der Länge n = 5. Das heißt, C ⊆ V₅ = F₂ ⁵. Sei c = 11000 ein Codewort. Dann gibt es einen Vektor x ∊ V₅ mit d(x, c) = 0, nämlich x = c. Es gibt fünf Vektoren x ∊ V₅ mit d(x, c) = 1; nämlich x₁ = 01000, x₂ = 10000, x₃ = 11100, x₄ = 11010, x₅ = 11001.
Es gibt ( 5 / 2) = 10 Vektoren x ∊ V₅ mit d(x, c) = 2. Das sind die zehn Vektoren x_1,2 = 00000, x_1,3 = 01100; x_1,4 = 01010, x_1,5 = 01001, x_2,3 = 10100, x_2,4 = 10010, x_2,5 = 10001; x_3,4 = 11110, x_3,5 = 11101, x_4,5 = 11011.
Die Hammingkugel B(c, 2) enthält also ( 5 / 0) + ( 5 / 1) + ( 5 / 2) = 1 + 5 + 10 = 16 Vektoren.
3 zeigt zwei Darstellungen 301, 302 der Hammingkugel 300 in V₅ mit Radius 2.
Die erste Darstellung 301 zeigt ein Codewort 303, das von Datenwörtern mit Hammingdistanz 1 auf einem ersten Ring 304 und Datenwörtern mit Hammingdistanz 2 auf einem zweiten Ring 305 umgeben ist.
Die zweite Darstellung 302 ist eine vereinfachte Darstellung, die im Folgenden verwendet wird.
Über die zweite Darstellung 302 darf aber nicht vergessen werden, dass eine Hammingkugel kein kontinuierliches Gebilde ist, sondern eine Ansammlung diskreter Punkte. (Da es sich nicht um Punkte in der Ebene, sondern einen n-dimensionalen Raum handelt, sind Hammingkugeln auch im Allgemeinen nicht rund. Die erste Darstellung 301 stellt somit ebenfalls eine Vereinfachung dar.)
Die Hammingkugel B(c; r) mit Mittelpunkt c ∊ C ⊆ V_n und Radius r bei einem einen binären linearen (n, k, d) Code enthält 1 + ( n / 1) + ( n / 2) + ... + ( n / r) Vektoren des Vektorraums V_n.
Zur Erläuterung der Fehlerkorrektur sei C ein linearer (n, k, d) Code und t eine ganze Zahl mit der Eigenschaft d = 2t + 1, falls d ungerade ist, und d = 2t + 2, wenn d gerade ist, d. h. t ist die größte ganze Zahl mit t < d/2.
Beispiel: Für d = 9 ist t = 4. Für d = 8 ist t = 3. Für d = 10 ist t = 4.
Sei c ein Codewort. Die Hammingkugel B(c; t) enthält
Vektoren, einschließlich dem Codewort c, das den Mittelpunkt der Hammingkugel darstellt. Jeder Vektor (d. h., jedes empfangene Nachrichtenwort), das in der Kugel liegt, wird durch die Dekodierung auf c zurückgesetzt. Das heißt, für alle y ∊ B(c, t) geschieht die Fehlerkorrektur durch y
c. Der betrachtete (n, k, d) Code hat die Dimension k. Das heißt, es gibt 2^k Codewörter. Daher gibt es 2^k verschiedene (sich nicht überschneidende) Hammingkugeln (in deren Mittelpunkt sich jeweils ein Codewort befindet.)
Die Vektoren in diesen 2^k Hammingkugeln sind genau die korrigierbaren Nachrichtenvektoren. Es gibt somit
korrigierbare Nachrichtenvektoren in dem Raum aller möglichen Nachrichtenvektoren, der 2ⁿ Vektoren umfasst. Der relative Anteil der korrigierbaren Vektoren ist daher gegeben durch
Beispiel: Für den (31, 5, 16) Simplex Code gilt t = 7. Es gibt 2³¹ mögliche Nachrichtenvektoren. Die Anzahl der korrigierbaren Nachrichtenvektoren beträgt daher
d. h. nur 5,3% aller Nachrichten sind gemäß der obigen Vorgehensweise korrigierbar.
Im Unterschied zu der obigen Vorgehensweise, die als klassische Dekodierung angesehen werden kann, wird gemäß einer Ausführungsform eine Superdekodierung durchgeführt, wie sie im Folgenden beschrieben wird und in 4 veranschaulicht ist.
4 zeigt einen Vergleich von 15 Hammingkugeln 401 mit 15 Super-Hammingkugeln 402.
Ein gemäß der obigen Vorgehensweise dekodierbarer Nachrichtenvektor wird im Folgenden als klassisch dekodierbar bezeichnet, d. h. ein Vektor y heißt klassisch decodierbar, wenn es ein Codewort c ∊ C gibt mit d(y, c) ≤ t.
Entsprechend ist ein Nachrichtenvektor, der sich innerhalb einer Hammingkugel 401 befindet, klassisch decodierbar (d. h. korrigierbar): Decodierbar heißt, dass der Nachrichtenvektor bei der Dekodierung ersetzt wird durch das Codewort im Mittelpunkt der Kugel. Punkte außerhalb der Kugeln 401, sind nicht klassisch korrigierbar.
Für den Simplex Code können beispielsweise einfache Schaltkreise zur Kodierung und Dekodierung für die klassische Fehlerkorrektur verwendet werden, d. h. die Korrektur von Fehlern, die sich innerhalb einer Kugel mit Radius d/2 um das Codewort befinden, wobei der Parameter d die Minimumdistanz des Codes bezeichnet. Damit können nur moderate Fehlerraten bedient werden.
Im Unterschied dazu wird ein Vektor y als superdecodierbar bezeichnet, wenn es ein eindeutig bestimmtes Codewort c ∊ C gibt mit d(y, c) = d(y, C), d. h. y heißt superdecodierbar, wenn es ein eindeutiges c ∊ C gibt mit d(y, c) < d(y, c') für alle c' ∊ C mit c' ≠ c. Die Super-Hammingkugeln 402 stellen die entsprechenden Bereiche dar, innerhalb derer Vektoren superdecodierbar sind.
Entsprechend wird gemäß einer Ausführungsform eine Schaltung bereitgestellt, die zusätzlich zu den Nachrichten innerhalb der Hammingkugeln 401 auch zahlreiche Nachrichten korrigieren kann, die sich bereits außerhalb der Hammingkugel (aber innerhalb der entsprechenden Super-Hammingkugel) befinden, und zwar alle Nachrichten, für die gilt, dass sie zu dem Codewort, das den Kugelmittelpunkt darstellt, einen kleineren Abstand haben als zu allen anderen Codewörtern. Diese Nachrichten werden durch den Schaltkreis ebenfalls auf den Kugelmittelpunkt hin abgebildet. Zur Abgrenzung zu einem klassischen Decoder (d. h. einem Decoder, der eine klassische Fehlerkorrektur durchführt) wird ein solcher Decoder als Super-Decoder bezeichnet. Beim (31, 5, 16) Simplex Code können mit einem klassischen Decoder beispielsweise ca. 5,3% aller möglichen Nachrichten decodiert werden. Mit dem Super-Decoder sind es ca. 30%.
Als Anwendungsbeispiel wird zunächst im Folgenden der (7, 3, 4) Simplex Code betrachtet. Dieser kann mit dem primitiven Polynom f(x) = x³ + x + 1 realisiert werden. Mit dem primitiven Polynom f(x) wird die lineare Rekursionsformel u_n+3 = u_n+1 + u_n für n ≥ 0 assoziiert.
Die ersten drei Folgenglieder u₀, u₁, u₂ können frei aus dem binären Zahlenkörper F₂ = {0, 1} gewählt werden. Es gibt 2³ = 8 Möglichkeiten, die Anfangswerte (u₀, u₁, u₂) zu wählen. Mit Hilfe der linearen Rekursion werden zu jedem Anfangswert (u₀, u₁, u₂) die nächsten vier Folgenglieder u₃, u₄, u₅, u₆ berechnet (so dass insgesamt 7 = 2³ – 1 Folgeglieder vorliegen). Der Vektor der Länge 7 gegeben durch (u₀, u₁, u₂, u₃, u₄, u₅, u₆) ist dann ein Codewort des (7, 3, 4) Simplex Codes. Auf diese Weise können alle acht Codewörter ermittelt werden: c₀ = 0 0 0 0 0 0 0; c₁ = 1 0 0 1 0 1 1; c₂ = 0 1 0 1 1 1 0; c₃ = 0 0 1 0 1 1 1; c₄ = 1 1 0 0 1 0 1; c₅ = 1 0 1 1 1 0 0; c₆ = 0 1 1 1 0 0 1; c₇ = 1 1 1 0 0 1 0.
Eine 4×7 Kontrollmatrix H des Simplex Codes ist gegeben durch
Die ersten 4 Spalten der Matrix H bilden die 4×4 Einheitsmatrix. Die letzten drei Spalten der Matrix H sind die 4 Bit langen Endstücke der Codewörter c₁, c₂, c₃, d. h. die letzten drei Spalten der Matrix H können erzeugt werden, indem die drei Einheitsvektoren (1, 0, 0), (0, 1, 0), (0, 0, 1) jeweils mit Hilfe der obigen linearen Rekursion verlängert werden.
Die Kontrollmatrix H hat die Eigenschaft: Hc^T = 0 genau dann, wenn c ein Codewort ist.
Wenn y = (y₀, y₁, y₂, y₃, y₄, y₅, y₆) ein beliebiger 7 Bit langer (binärer) Zeilenvektor ist, dann heißt der 4 Bit lange Spaltenvektor
gegeben durch s = S(y) = Hy^T das Symdrom von y.
Es gilt also: Das Syndrom von einem Codewort ist stets Null. Und das Syndrom von einem Nicht-Codewort ist stets ungleich Null.
Aus Gründen der einfacheren Darstellung werden im Folgenden Spaltenvektoren waagrecht dargestellt, d. h. es wird im Folgenden nicht zwischen Spaltenvektoren und Zeilenvektoren unterschieden. Beispielsweise ist für y = (1, 1, 0, 0, 0, 0, 1) das Syndrom s = S(y) der Spaltenvektor
der im Folgenden aber s = S(y) = (1, 0, 1, 1) geschrieben wird.
Im Folgenden wird die Syndromberechnung für den Simplex Code erläutert.
Jeder lineare (n, k, d) Code besitzt eine (n – k)×n Kontrollmatrix H (d. h. die Matrix enthält n – k Zeilen und n Spalten). Sei y ein Zeilenvektor der Länge n. Dann ist das Syndrom von y definiert durch eine Matrix-Vektor-Multiplikation: S(y) = Hy^T
Die Kontrollmatrix H ist nicht eindeutig bestimmt. Mehrere unterschiedliche Kontrollmatrizen können denselben linearen Code beschreiben (in dem Sinn, dass ein Vektor c genau dann ein Codewort ist, wenn Hc^T = 0).
Es ist jedoch für jeden linearen Code möglich, die Kontrollmatrix H so zu wählen, dass sie die Form H = (I_n-k, A) hat, wobei I_n-k die (n – k)×(n – k) Einheitsmatrix ist. Für den hier betrachteten (7, 3, 4) Simplex Code wird im Folgenden für die Kontrollmatrix H eben diese Form gewählt:
Sei y = (y₀, y₁, y₂, y₃, y₄, y_5, y₆). Dann ist
bzw. S(y) = (y₀ + y₄ + y₅, y₁ + y₅ + y₆, y₂ + y₄ + y₅ + y₆, y₃ + y₄ + y₆), wenn das Syndrom als Zeilenvektor dargestellt wird.
Für den Simplex Code kann das Syndrom durch einen einfachen Algorithmus berechnet werden: Gegeben sei der Zeilenvektor y = (y₀, y₁, ..., y_n-1) der Länge n mit n = 2^k – 1. Schreibe die ersten 2^k – 1 – k Folgenglieder von y in eine Zeile. Berechne mit der linearen Rekursionsformel, die mit dem Polynom f(x) assoziiert ist, weitere 2^k – 1 – k Folgenglieder, wobei die letzten k Koordinaten von y, also y_n-k, ..., y_n-2, y_n-1 als Anfangswerte dienen (die der Folge aber nicht zugerechnet werden). Dann addiere die beiden Zeilen (durch bitweises XOR). Das Ergebnis ist das Syndrom S(y).
Für den hier betrachteten Simplex Code ist die Rechnung wie folgt: Sei y = (y₀, y₁, y₂, y₃, y₄, y₅, y₆) gegeben. Die erste Zeile ist: y₀, y₁, y₂, y₃. Die lineare Rekursion y_n+3 = y_n+1 + y_n mit den Anfangswerten (y₄, y₅, y₆) liefert die zweite Zeile: y₄ + y₅, y₅ + y₆, y₄ + y₅ + y₆, y₄ + y₆. Die bitweise Addition der beiden Zeilen liefert schließlich das Syndrom: y₀ + y₄ + y₅, y₁ + y₅ + y₆, y₂ + y₄ + y₅ + y₆, y₃ + y₄ + y₆. Die Syndromberechnung lässt sich beispielsweise mit der in 5 dargestellten Schaltung ausführen.
5 zeigt eine Schaltung 500 zur Syndromberechnung.
Die Schaltung 500 weist insgesamt 7 = 2³ – 1 Flip-Flops 501 (allgemein für den (2^k – 1, k, 2^k–1) Simplex Code 2^k–1 Flip-Flops) auf. Die Initialisierung erfolgt mit dem Zeilenvektor y wie in den Flip-Flops 501 angegeben. Die Flip-Flops 501 sind in einem linken Schaltkreis 502 und einem rechten Schaltkreis angeordnet. Der linke Schaltkreis 502 der Schaltung 500 ist ein zirkulierendes Schieberegister der Länge 4 = 2³ – 1 – 3 (allgemein der Länge 2^k – 1 – k). Der rechte Schaltkreis 503 der Schaltung ist ein LFSR (engl. linear feedback shift register, d. h. linear rückgekoppeltes Schieberegister) gemäß einem charakteristischem Polynom f(x) der Länge 3 (allgemein der Länge k = deg(f), d. h. dem Grad des Polynoms f).
Der Inhalt des rechten Schaltkreises 503 kann mittels eines Addierers 504 bitweise zu dem Inhalt des linken Schaltkreises 502 addiert werden.
Nach 4 = 2³ – 1 – 3 (allgemein 2^k – 1 – k) Takten enthält das Register auf der linken Seite (d. h. die Flip-Flops 501 des linken Schaltkreises 502) die Einträge y₀ + y₄ + y₅, y₁ + y₅ + y₆, y₂ + y₄ + y₅ + y₆, y₃ + y₄ + y₆, welche die vier Koordinaten des Syndroms darstellen (allgemein die 2^k – 1 – k Koordinaten).
6 zeigt ein Beispiel für einen Decoder 600 für den Simplex-Code.
Der Decoder 600 weist drei Register 601, 602, 603 auf. Das obere Register 601 ist ein zirkulierendes Schieberegister der Länge 2³ – 1 = 7 (allgemein der Länge 2^k – 1) mit einem fest eingeprägten Anfangszustand.
Die Angangsbelegung entspricht einem Codewort des Simplex Codes. Hier dem Codewort c5. Das mittlere Register 602 hat die Länge 2³ – 1 – 3 = 4. Es enthält das Syndrom s = S(y) des zu korrigierenden Nachrichtenvektors y. Das mittlere Register 602 kann also beschrieben werden, so dass das vorab berechnete Syndrom s in das Register eingelesen werden kann. (Das Syndrom s kann beispielsweise mit dem in 5 dargestellten Schaltkreis berechnet werden.)
Das untere Register 603 hat die Länge 7. In diesem Register steht am Ende der Ausführung des Fehlerdetektionsalgorithmus der Fehlervektor e. Für das untere Register 603 kann die Anzahl der Einsen (in den 7 Zellen) gezählt werden, d. h. das Hamminggewicht w = w(v) des aktuellen im unteren Register 603 gespeicherten 7-Bit Vektors v kann bestimmt werden. Das untere Register 603 kann auch zurückgesetzt werden. Bei Zurücksetzen werden alle Registerinhalte gelöscht. Der Inhalt des unteren Registers 603 kann ausgelesen werden.
Die linken vier Bits des Inhalts des ersten Registers 601 können mit dem Inhalt des zweiten Registers 602 mittels Addierern 604 kombiniert werden.
Im Folgenden wird der Algorithmus für die Fehlerdetektion bzw. Fehlerkorrektur gemäß einer Ausführungsform beschrieben.
Hinsichtlich der Fehlerkorrekturfähigkeit ist zu beachten, dass für den betrachteten (7, 3, 4) Simplex Code die Minimumdistanz d = 4 ist. Daher kann jeder Einbitfehler korrigiert werden (da 1 < d/2 = 2). Die Superdecodierfähigkeit kommt in diesem Beispiel nicht zum Tragen.
Der Decoder 600 arbeitet beispielsweise gemäß dem folgenden Algorithmus.
Sei y die empfangene (potentiell fehlerhafte) Nachricht.

1. Berechne das Syndrom s = S(y). Wenn s = 0, wird y als fehlerfrei betrachtet. Fertig.
2. Sei s ≠ 0. Berechne das Hamminggewicht w = w(s). Wenn w < d/2 = 2, dann werden an den Vektor s genau k = 3 Nullen angehängt. Das auf diese Weise verlängerte Syndrom ist der Fehlervektor e. Es ist c = y + e die korrigierte Nachricht. Fertig.
3. Sei w(s) ≥ d/2 = 2. Lese das Syndrom s in das mittlere Register 602 ein. Kombiniere die Inhalte des oberen Registers 601 und des mittleren Registers 602 mittels der Addierer 604. Dabei werden die ersten (d. h. linken) vier Bits des oberen Registers 601 bitweise zum Inhalt des mittleren Registers 602 addiert und die letzten (rechten) drei Bits des oberen Registers 601 unverändert in das untere Register 603 übernommen. Das Ergebnis dieser Addition wird mit E₀ bezeichnet. Der 7-Bit Vektor E₀ steht im unteren Register 603. Bestimme w(E₀), das Hamminggewicht des Vektors E₀. Wenn w(E₀) < d/2, dann setze e = E₀. Der Vektor e ist der gesuchte Fehlervektor. Fertig.
4. Sei w(E₀) ≥ d/2. Takte das obere Register 601 einmal, d. h. der Inhalt des oberen Registers 601 wird um eine Position zyklisch nach links verschoben. Kombiniere den (verschobenen) Inhalt des oberen Registers 601 mit dem gleichgebliebenen Inhalt des mittleren Registers 602 wie in 3. Hierdurch wird ein neuer Vektor w(E₁) im unteren Register 603 erhalten. Berechne w(E₁). Wenn w(E₁) < d/2, dann setze e = E₁. Fertig. Andernfalls wiederhole 4. solange bis ein Vektor E_j mit w(E_j) < d/2 im unteren Register 603 auftritt. Das ist der Fehlervektor e = E_j. Fertig.
5. Das obere Register 601 kann sieben Mal getaktet werden, dann befindet es sich wieder in seinem Ausgangszustand. Wenn sich bei diesen sieben Versuchen im unteren Register 603 niemals ein Vektor E_j ergibt mit Hamminggewicht kleiner als d/2, dann ist y nicht korrigierbar. Fertig.

Beispiel: Die empfangene Nachricht sei y = 1110101. Berechne das Syndrom: s = S(y) = 0010. Berechne das Hamminggewicht: w(s) = 1 < d/2 = 2. Der Fehlervektor ist e = (s; 000) = 0010000. Die korrigierte Nachricht ist daher c = y + e = 1100101.
Beispiel: Die empfangene Nachricht sei y = 0111011. s = 1110, w(s) = 3. E₀ = 0101100, w(E₀) = 3, wiederhole. E₁ = 1001001, w(E₁) = 3, wiederhole. E₂ = 0000010, w(E₂) = 1 < d/2, fertig. Der Fehlervektor ist e = E₂ = 0000010. Die korrigierte Nachricht c ist gegeben durch c = y + e = 0111001.
Der Decoder 600 kann wie folgt zu einem PUF-Decoder erweitert werden.
Sei a der wahre PUF-Wert. Die Hilfsinformation zu a sei mit b bezeichnet, wobei b das Syndrom von a ist: b = S(a) = Ha^T.
Sei a' der aktuelle vorliegende PUF-Wert. Das Ziel ist, den wahren PUF-Wert a aus a' und b zu rekonstruieren.
Dazu kann der Decoder 600 mit den folgenden Anpassungen verwendet werden:
Sei a' der aktuelle (potentiell fehlerhafte) PUF-Wert und sei b die zum wahren PUF-Wert a gehörige abgespeicherte Hilfsinformation.
1'. Berechne das Syndrom s' = S(a'). Berechne s = s' + b. Wenn s = 0, wird a' als fehlerfrei betrachtet. Setze a = a'. Fertig. Alle anderen Schritte des oben für den Decoder 600 beschriebenen Algorithmus bleiben gleich. Im unteren Register 603 wird am Ende des Algorithmus der Fehlervektor e erhalten. Der wahre PUF-Wert a ist dann gegeben durch a = a' + e.
Beispiel 1: Sei der aktuelle PUF-Wert a' = 1010011 und die Hilfsinformation sei b = 1000. Das Syndrom s' von a' ist s' = S(a') = Ha'^T = 0011.
Dann wird s = s' + b = 1011 berechnet. Das Hamminggewicht ist w(s) = 3, daher wird Schritt 3. durchgeführt. Dies liefert E₀ = 0000100. Da w(E₀) = 1 < d/2 ist, ist E₀ bereits der gesuchte Fehlervektor: e = E₀ = 0000100. Der wahre PUF-Wert a ist a = a' + e = 1010111.
Der Vektor s kann direkt mit der in 7 gezeigten Schaltung berechnet werden.
7 zeigt eine Schaltung 700 zur Berechnung eines Syndroms zur PUF-Rekonstruktion.
Die Verwendung der Schaltung 700 ist effizienter als eine Multiplikation mit der der Kontrollmatrix H zu implementieren.
Die Schaltung 700 weist einen linken Schaltkreis 701 und einen rechten Schaltkreis 702 entsprechend den Schaltkreisen 502, 503 der Schaltung 500 auf. Lediglich weist der Addierer 703 des linken Schaltkreises 701 einen zusätzlichen Eingang auf, über dem die in einem Register 704 gespeicherte Hilfsinformation dem linken Schaltkreis 702 zugeführt (d. h. bitweise in den linken Schaltkreis 702 eingeschoben) werden kann.
Initialisiert wird die Schaltung 700 wie dargestellt mit dem Vektor a'. 7 zeigt den Zustand der Schaltung 700 zum Zeitpunkt t = 0, d. h. unmittelbar nach der Initialisierung. Nach vier Takten, also zum Zeitpunkt t = 4 enthält das Register des linken Schaltkreises 701 den benötigten Vektor s.
Als weiteres Beispiel wird der (15, 4, 8) Simplex Code betrachtet.
Das primitive Polynom f(x) = x⁴ + x + 1 kann zur Konstruktion des (15, 4, 8) Simplex Codes benutzt werden. Dieser Code besteht aus 2⁴ = 16 Codewörtern, die jeweils 15 Bit lang sind.
Der Code hat die Minimumdistanz d = 8. Klassisch korrigierbar (gemäß der obigen Definition) sind alle 1, 2, und 3-Bitfehler. Darüber hinaus sind 31% aller 4-Bitfehler gemäß Superdecodierung korrigierbar.
Die 11×15 Matrix
ist eine Kontrollmatrix diese Codes. Mit Hilfe der Matrix H wird das Syndrom S(y) für einen 15-Bit Vektor y berechnet: S(y) = Hy^T
Die ersten n – k = 15 – 4 = 11 Spalten der Matrix H bilden die 11×11 Einheitsmatrix I₁₁. Die letzten k = 4 Spalten der Matrix H können mittels der (mit f(x) = x⁴ + x + 1 assoziierten) Rekursionsformel u_n+4 = u_n+1 + u_n und den Anfangswerten (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1) erzeugt werden. Zum Beispiel ergibt die Rekursionsformel mit dem Anfangsvektor (0, 0, 0, 1), d. h. mit u₀ = u₁ = u₂ = 0 und u₃ = 1 die Folgenglieder
u₄ = 0, u₅ = 0, u₆ = 1, u₇ = 1, u₈ = 0, u₉ = 1, u₁₀ = 0, u₁₁ = 1, u₁₂ = 1, u₁₃ = 1,
und u₁₄ = 1, d. h. die letzte Spalte der Matrix H.
Anstatt die Matrixmultiplikation auszuführen bzw. in Hardware zu implementieren, kann das Syndrom mit der in 8 gezeigten Schaltung berechnet werden.
8 zeigt eine Schaltung 800 zur Syndromberechnung.
Die Schaltung 800 weist analog zur Schaltung 500 einen linken Schaltkreis 801 und einen rechten Schaltkreis 802 auf, die dem linken Schaltkreis 501 und dem rechten Schaltkreis 502 entsprechend bis auf die Anpassung der jeweiligen Registerlängen an den in diesem Beispiel verwendeten Code.
Es sei angenommen, dass y = (y₀, y₁, ..., y₁₄) die empfangene Nachricht ist. Gesucht ist S(y), das Syndrom von y. Dann wird die Schaltung 800 mit dem Vektor y initialisiert. Die ersten 11 Komponenten y₀, y₁, ..., y₁₀ werden in den linken Schaltkreis 801, d. h. das linke zirkulierende Schieberegister gespeichert. Die letzten vier Koordinaten y₁₁, y₁₂, y₁₃, y₁₄ werden in dem rechten Schaltkreis 802, d. h. dem linear rückgekoppelten Schieberegister gespeichert.
Dann wird der Schaltkreis 800 elf Mal getaktet. Danach befindet sich das 11 Bit lange Syndrom im Register des linken Schaltkreises 801. Der Inhalt des 4 Bit langen Registers des rechten Schaltkreises 802 kann ignoriert werden.
9 zeigt eine Schaltung 900 zur Syndromberechnung zur PUF-Rekonstruktion.
Die Schaltung 900 weist einen linken Schaltkreis 901 und einen rechten Schaltkreis 902 entsprechend den Schaltkreisen 801, 802 der Schaltung 800 auf. Lediglich weist der Addierer 903 des linken Schaltkreises 901 einen zusätzlichen Eingang auf, über dem die in einem Register 904 gespeicherte Hilfsinformation dem linken Schaltkreis 902 zugeführt (d. h. bitweise in den linken Schaltkreis 902 eingeschoben) werden kann.
Für den ursprünglichen, den sogenannten wahren, PUF-Wert a (der ein 15 Bit langer Zeilenvektor ist) wird ein 11 Bit langer Hilfsvektor b berechnet und abgespeichert. Dieser Hilfsvektor b ist genau das Syndrom von a. Das heißt b = S(a). Der Hilfsvektor b wird bereitgehalten, um in der Folge den wahren PUF-Wert a rekonstruieren zu können. (Der wahre PUF-Wert a wird beispielsweise aus Sicherheitsgründen nicht gespeichert.) Bei einer neuen PUF-Anforderung liefert die PUF einen aktuellen 15 Bit langer Vektor a'. Der Vektor a' ist im Allgemeinen eine fehlerhafte Version des wahren PUF-Werts a. Aus a' und b wird der wahre PUF-Wert a rekonstruiert.
Dabei ist es erforderlich, einen elf Bit langen Vektor s = (s₀, s₁, ..., s₁₀) zu berechnen. Der Vektor s wird berechnet durch s = S(a') + b.
Die Berechnung von s kann mit der Schaltung 900 durchgeführt werden. Der linke Schaltkreis 901 und der rechte Schaltkreis 902 (Schieberegister) werden mit dem angefallenen PUF-Vektor a' initialisiert. Der Hilfsvektor b wird im Register 904 bereitgehalten.
Der Schaltkreis 900 wird elfmal getaktet. Danach befindet sich der gesuchte Vektor s in dem 11 Bit langen Schieberegister des linken Schaltkreises 901. Der Inhalt des linear rückgekoppelten Schieberegisters des rechten Schaltkreises kann ignoriert werden. Die Daten des Registers 904 wurden vollständig herausgeschoben.
Alternativ kann das Register 904, das den Hilfsvektor b enthält, als zirkulierendes, 11 Bit langes Schieberegister ausgeprägt werden. Wenn dieses Register mit dem Hilfsvektor b initialisiert ist, dann wäre es nach elf Takten nicht leer, sondern würde wiederum den Hilfsvektor b enthalten.
10 zeigt einen Decoder 1000 zur PUF-Rekonstruktion für den (15, 4, 8) Simplex Code.
Analog zu dem Decoder 600 weist der Decoder drei Register 1001, 1002, 1003 und Addierer 1004 auf, deren Länge bzw. Anzahl an den in diesem Beispiel verwendeten Code angepasst sind.
Beispiel (PUF-Rekonstruktion):

a' = 110111010011111;
b = 11101011011;
s' = 11001110011 = S(a');
s = 00100101000 = s' + b.

Das Hamminggewicht w(s) = 3 < d/2 = 4. Der um k = 4 Nullen verlängerte Vektor s ergibt daher bereits den gesuchten Fehlervektor: e = (s, 0000) = 001001010000000.
Der wahre PUF-Wert a ist a = a' + e = 111110000011111.
Beispiel (PUF-Rekonstruktion):

a' = 011101001101111;
b = 11110001000;
s' = 01100111100 = S(a');
s = 10010110100 = s' + b.

Das Hamminggewicht w(s) = 5 ≥ d/2 = 4. Der Decoder 100 wird zur Berechnung der Vektoren E₀, E₁, ... verwendet. E₀ = 000011000111000; w(E0) = 5 ≥ d/2, weiter. E₁ = 101000110110001; w(E1) = 7 ≥ d/2, weiter. E₂ = 111111010100010; w(E2) = 9 ≥ d/2, weiter. E₃ = 010000010000100; w(E3) = 3 < d = 2, stopp.
Der Fehlervektor ist e = E3. Der wahre PUF-Wert a ist gleich a = a' + e = 001101011101011.
In den vorhergehenden Beispielen wurden Nachrichten korrigiert bzw. PUF-Werte rekonstruiert, bei denen weniger als d/2 Fehler auftraten.
Wenn d/2 oder mehr Fehler auftreten, ist in manchen Fällen ebenfalls die Korrektur mittels möglich. Dazu wird der Decoder 600 gemäß einer Ausführungsform wie folgt zur Superdecodierung benutzt. Das Vorgehen wird für den allgemeinen n = 2^k – 1, k, d = 2^k–1 Simplex Code beschrieben.
Das Gewicht w(s) des Syndroms ist im Falle der Superdecodierung größer als d/2. 1 bis 4 im oben im Zusammenhang mit dem Decoder 600 beschrieben Algorithmus werden so ausgeführt wie oben beschrieben. In 3 und 4 des Algorithmus werden der Reihe nach die Vektoren E₀, E₁, ..., E_n-1 mit n = 2^k – 1 berechnet. Für jeden dieser Vektoren wird nun das Hamminggewicht ermittelt und die Hamminggewichte werden abgespeichert. Sei wj = w(Ej) für j = 0, 1, ..., n – 1. Dann wird die kleinste Zahl m aus der Menge {w₀, w₁, ...,w_n-1; w(s)} bestimmt. Wenn das Minimum m der Menge unter den 2^k Elementen der Menge nur einmal auftritt, dann ist der Nachrichtenvektor y bzw. der PUF-Wert a' korrigierbar.
Angenommen, für das Minimum m gilt m = w_j für ein eindeutig bestimmtes j ∊ {0, 1, ..., n – 1}, dann ist der gesuchte Fehlervektor e = E_j. Wenn das eindeutig bestimmte Minimum m der Menge identisch ist mit w(s), dann ist der Fehlervektor e = (s; 0 0 ... 0), wobei k Nullen an s angehängt werden.
Beispiel (PUF-Rekonstruktion):

a' = 001000010010000;
b = 01000101110;
s' = 00100001001 = S(a');
s = 01100100111= s' + b.

Das Hamminggewicht w(s) = 6 ≥ d/2 = 4. Der Decoder (in diesem Beispiel mit der Dimensionierung gemäß 10) berechnet die Vektoren E₀, E₁, ..., E₁₄. E₀ = 111111100001000; E₁ = 010100010000001; E₂ = 000011110010010; ... E₁₄ = 001010011001100.
Für jeden Vektor wird das Hamminggewicht bestimmt und abgespeichert. (Die Vektoren Ej selbst müssen nicht abgespeichert werden.) Die Gewichte der E_j sind w₀ = 8; w₁ = 4; w₂ = 6; w₃ = 8; w₄ = 10; w₅ = 8; w₆ = 8; w_n = 8; w₈ = 8; w₉ = 6; w₁₀ = 6; w₁₁ = 10; w₁₂ = 12; w₁₃ = 6; w₁₄ = 6.
Zu diesen 15 Hamminggewichten wird noch der Wert w(s) = 6 hinzugefügt. Das Minimum aus der Menge dieser 16 Hamminggewichte ist 4 und das Minimum tritt ein einziges Mal auf, nämlich w1 = 4. Daher ist der gesuchte Fehlervektor e = E₁ = 010100010000001.
Der wahre PUF-Wert a ist somit gegeben durch a = a' + e = 011100000010001.
Beispiel (PUF-Rekonstruktion):

a' = 011000011101100;
b = 10001000001;
s' = 00101100101 = S(a');
s = 10100100100 = s' + b.
w(s) = 4 ≥ d/2.

Es werden die 15 Vektoren E₀, E₁, ..., E₁₄ berechnet und ihre Hamminggewichte bestimmt.
Dann wird das Minimum m wie folgt bestimmt: m = min(w₀; w₁; w₂; ...; w₁₃; w₁₄; w(s)) = min(8; 6; 8; 6; 6; 10; 6; 8; 8; 8; 6; 8; 12; 6; 10; 4) = 4.
Das Minimum m = 4 wird nur einmal angenommen, nämlich für w(s) = 4. Daher ist der Fehlervektor e gegeben durch e = (s; 0000) = 101001001000000.
Der wahre PUF-Wert a ist a = a' + e = 110001010101100.
Beispiel (PUF-Rekonstruktion):

a' = 000010001111111;
b = 11111011100;
s' = 00011011101 = S(a');
s = 11100000001 = s' + b.
w(s) = 4 ≥ d/2.

Es werden wieder die Vektoren E₀, E₁, ..., E₁₄ berechnet und ihre Hamminggewichte w₀, w₁, ..., w₁₄ gespeichert. m = min(w₀; w₁; w₂; ...; w₁₃; w₁₄; w(s)) = min(8; 8; 8; 8; 8; 8; 8; 8; 4; 4; 8; 8; 12; 8; 8; 4) = 4; wobei das Minimum m = 4 dreimal angenommen wird: w₈ = 4, w₉ = 4, w(s) = 4.
Der Fehlervektor e ist nicht eindeutig bestimmt. Stattdessen gibt es drei mögliche Fehlervektoren: e₁ = E₈, e₂ = E₉, e₃ = (s, 0000).
Daher gibt es auch drei verschiedene Kandidaten für den wahren PUF-Wert a: a₁ = a' + 'e₁ = a' + E₈ = 000110011110101; a₂ = a' + e₂ = a' + E₉ = 000010101011010; a₃ = a' + e₃ = a' + (s, 0) = 111010001101111.
Gemäß einer Ausführungsform werden die Vektoren E₀, E₁, ..., E₁₄ nicht gespeichert, um den dafür nötigen Speicherbedarf (und entsprechende Kosten) zu vermeiden. Zum Beispiel kann aus der Information w₈ = 4 aber E₈ berechnet werden: Takte den Decoder 1000 in Bild 6 achtmal, addiere s, und erhalte E₈ im unteren Register 1003. Da w₉ = 4, takte das obere Register 1001 ein weiteres Mal, addiere s, und erhalte E9. e₁ = E₈ = 000100010001010; e₂ = E₉ = 000000100100101; e₃ = (s; 0) = 111000000010000.
Als weiteres Beispiel wird der (31, 5, 16) Simplex Code betrachtet.
Um den (31, 5, 16) Simplex Code zu konstruieren wird ein primitives binäres Polynom f(x) vom Grad k = 5 verwendet. Es gibt sechs solche Polynome. Das Polynom f(x) = x⁵ + x² + 1 ist eines davon. Der betrachtete Simplex Code besteht aus 2^k = 2⁵ = 32 verschiedenen Codewörtern. Jedes dieser Codewörter ist 2^k – 1 = 2⁵ – 1 = 31 Bit lang.
Sei u = u₀u₁u₂ ... u₂₉u₃₀ ein Codewort. Die ersten k = 5 Koordinaten u₀, u₁, u₂, u₃, u₄ sind frei wählbar. (Es gibt 2⁵ = 32 Möglichkeiten, diese ersten fünf Koordinaten zu wählen.) Die restlichen 2^k – 1 – k = 2⁵ – 1 – 5 = 26 Koordinaten u₅, u₆, ..., u₂₉, u₃₀ werden aus den Anfangswerten u₀, u₁, u₂, u₃, u₄ mit Hilfe der (mit f(x) assoziierten) Rekursionsformel u_j+5 = u_j+2 + u_j für j = 0, 1, ..., 25 berechnet. Diese 26 Koordinaten sind also durch die fünf Anfangswerte determiniert.
Es gibt 32 verschiedene Codewörter, weil es 32 Möglichkeiten gibt für das 5-Tupel (u₀, u₁, u₂, u₃, u₄) der Anfangswerte.
Die Minimumdistanz d des betrachteten (31, 5, 16) Simplex Codes ist d = 16. Mit einem klassischen Decoder kann daher jeder t-Bitfehler mit t ≤ 7 korrigiert werden. Eine genaue Analyse zeigt, dass mit einem Superdecoder ca. 95% aller 8-Bitfehler, 67% aller 9-Bitfehler und 30% aller 10-Bitfehler eindeutig korrigierbar sind.
Angenommen ein Nachrichtenwort c = c₀c₁ ... c₃₀ wurde abgeschickt und das Nachrichtenwort y = y0y1 ... y30 wird empfangen. Bestimmte Bits sind bei der Übertragung umgekippt (d. h. haben ihren Wert von 0 auf 1 oder von 1 auf 0 geändert). Diese sollen korrigiert werden. Dazu wird das Syndrom S(y) verwendet, das in diesem Beispiel ein 26 Bit langer Vektor ist. Das Syndrom S(y) kann effizient mit der in 11 gezeigten Schaltung berechnet werden.
11 zeigt eine Schaltung 1100 zur Syndromberechnung.
Analog zur Schaltung 900 weist die Schaltung 1100 einen linken Schaltkreis 1101 und einen rechten Schaltkreis 1102 auf und der Addierer 1103 des linken Schaltkreises 1101 weist einen zusätzlichen Eingang auf, über dem in einem Register 1104 gespeicherte Hilfsinformation dem linken Schaltkreis 1102 zugeführt (d. h. bitweise in den linken Schaltkreis 1102 eingeschoben) werden kann.
Das Register 1104 hat die Länge 26 Bit und kann für die Syndromberechnung zur PUF-Rekonstruktion verwendet werden. In diesem Beispiel, bei der das Wort y dekodiert werden soll, wird es nicht verwendet und beispielsweise durch Öffnen eines Schalters 1105 abgekoppelt.
Die Schaltung 1100 wird mit den 31 Bit von y initialisiert. Die ersten 26 Bits von y kommen in das linke Schieberegister (d. h. das Register des linken Schaltkreises 1101) und die letzten 5 Bits in das rechte Schieberegister (d. h. das Register des rechten Schaltkreises 1102). Das rechte Register ist ein linear rückgekoppeltes Schieberegister, das die lineare Rekursion u_j+5 = u_j+2 + u_j implementiert. Nachdem sie initialisiert wurde, wird sie Schaltung 1100 2^k – 1 – k = 2⁵ – 1 – 5 = 26 Mal getaktet. Danach befindet sich das Syndrom S(y) im 26 Bit langen linken Register.
Nun wird das Hamminggewicht des Syndroms bestimmt. Wenn das Hamminggewicht kleiner als d/2 = 16/2 = 8 ist, dann werden an das Syndrom k = 5 Nullen angehängt. Der so gebildete 31 Bit lange Vektor e ist der gesuchte Fehlervektor. Die korrigierte Nachricht c ist dann gegeben durch c = y + e.
Wenn das Hamminggewicht des Syndroms größer oder gleich d/2 = 8 ist, dann wird das Syndrom in das mittlere Register 1002 des (entsprechend dimensionierten) Decoders 1000 gespeichert. Der Decoder 1000 liefert dann den Fehlervektor e unter Verwendung eines der oben beschriebenen Algorithmen.
Die PUF-Rekonstruktion ist eng verwandt, aber nicht identisch, mit dem Problem der Fehlerkorrektur bei der Nachrichtenübertragung. Bei der Nachrichtenübertragung ist die zu übertragende Nachricht immer ein Codewort. Bei der PUF-Thematik ist der ursprüngliche, der sogenannte wahre PUF-Wert a grundsätzlich ein beliebiger n Bit langer Vektor (hier n = 31.) Die PUF-Wert-Erzeugung ist unabhängig von der Verwendung des (31; 5; 16) Simplex Codes für seine Korrektur.
Nach erstmaliger Erzeugung des PUF-Werts Für die PUF-Rekonstruktion wird zunächst die Hilfsinformation b = S(a) berechnet. Da die Hilfsinformation das Syndrom von a ist, kann die Schaltung 1100 verwendet werden: Initialisiere mit a, takte 26-mal. Entnehme den Hilfsvektor b dem linken Register.
Zur Beschreibung der PUF-Rekonstruktion sei nun a' ein neu ausgelesener PUF-Wert. Der 31 Bit lange Vektor a' ist im Allgemeinen ebenso wenig ein Codewort wie a.
Zunächst wird das Syndrom von a' berechnet und zu dem Hilfsvektor b addiert. Es gilt S(a') + b = S(a') + S(a) = S(a' + a) = S(e), d. h. auf diese Weise kann das Syndrom des Fehlervektors e bestimmt werden. Damit ist die Verbindung zur Fehlerkorrektur hergestellt, denn bei der Fehlerkorrektur bei der Nachrichtenübertragung wird ein Codewort c gesendet, ein potentiell fehlerhaftes Nachrichtenwort y = c + e empfangen und zunächst das Syndrom von y berechnet: S(y) = S(c + e) = S(c) + S(e) = 0 + S(e) = S(e).
Die Aufgabe des Decodierungsalgorithmus besteht darin, den Fehlervektor e aus dem Syndrom S(e) zu bestimmen.
Bei der PUF-Rekonstruktion wird also zunächst aus dem aktuellen PUF-Wert a' und dem Hilfsvektor b der 26 Bit lange Vektor s = S(a') + b = S(e) berechnet. Dazu kann die Schaltung 1100 verwendet werden: Initialisiere die beiden unteren Register, d. h. die Register des linken Schaltkreises 1101 und des rechten Schaltkreises 1102 wie oben beschrieben mit a' und das obere Register 1104 mit b. Schließe den Schalter 1104 und takte den Schaltkreis 26-mal. Danach befindet sich s im linken Register.
Beispiel (PUF: Berechnung des Hilfsvektors b.):
Sei der wahre PUF-Wert a gegeben durch: a = 01001 00010 00011 10101 01010 10101 1
Der Hilfsvektor b ist das Syndrom von a, also b = S(a). S(a) kann berechnet werden, indem die folgenden zwei 26-Bit langen Vektoren bitweise addiert werden:

1. Die ersten 26 Bit von a, also 01001 00010 00011 10101 01010 1.
2. Die ersten 26 Ausgabebits eines linearen rückgekoppelten Schieberegisters gemäß dem charakteristischem Polynom f(x) = x⁵ + x² + 1, wobei die letzten 5 Bits von a für die Initialisierung des Schieberegisters benutzt werden, wie es in 12 dargestellt ist.

12 zeigt ein lineares rückgekoppeltes Schieberegister 1200.
Das Schieberegister 1200 weist fünf Flip-Flops 1201 auf sowie einen Addierer 1202 auf, der die Inhalte des linkesten Flip-Flops und des mittleren Flip-Flops addiert und das Ergebnis ausgibt und dem rechtesten Flip-Flop zuführt, so dass das Schieberegister 1200 die Rekursionsformel u_n+5 = u_n+2 + u_n implementiert.
Das Schieberegister 1200 liefert in diesem Beispiel den Vektor 00111 11000 11011 10101 00001 0. Der Hilfsvektor b = 01110 11010 11000 00000 01011 1 ist die Summe dieser beiden Vektoren. Dies ist in 13 dargestellt.
13 veranschaulicht die Syndromberechnung für den Vektor a.
Das Syndrom 1303, d. h. der Vektor b, ist gegeben durch die Summe aus einem ersten Vektor 1301, gegeben durch die ersten 26 Bis von a und einem zweiten Vektor 1302, der sich aus den rechten fünf Bits 1304 von a durch Anwendung der Rekursionsformel u_n+5 = u_n+2 + u_n ergibt.
Beispiel (PUF-Rekonstruktion):

a' = 01111 01010 00111 10111 01111 00011 1;
b = 01110 11010 11000 00000 01011 1;

Berechnung von s' = S(a'): Nehme die letzten 5 Bits von a', also 00111, als Anfangswerte. Berechne mit der linearen Rekursion u_j+5 = u_j+2 + u_j die nächsten 26 Folgenglieder. Addiere zu diesem 26-Bit Vektor den 26-Bit Vektor, der aus den ersten 26 Gliedern von a' besteht. Der Summenvektor ist s' = 10111 10001 10010 10110 01001 1.
Berechnung von s: Es gilt s = s' + b. Daher ist s = 11001 01011 01010 10110 00001 0.
14 veranschaulicht die Syndromberechnung für den Vektor a'.
Das Syndrom 1404, d. h. der Vektor s, ist gegeben durch die Summe aus einem ersten Vektor 1401, gegeben durch die ersten 26 Bis von a', einem zweiten Vektor 1402 und einem dritten Vektor 1403. Der zweite Vektor ergibt sich aus den rechten fünf Bits 1405 von a' durch Anwendung der Rekursionsformel u_n+5 = u_n+2 + u_n, d. h. die letzten 5 Bits von a' sind die fünf Anfangswerte einer 31 Bit langen Schieberegisterfolge mit charakteristischem Polynom f(x) = x⁵ + x² + 1 und der zweite Vektor 1402 sind die letzten 26 Bit der Schieberegisterfolge. Der dritte Vektor 1403 ist der Hilfsvektor b.
Der Vektor s kann effizient mit der Schaltung 1100 berechnet werden: Initialisiere die beiden unteren Register, d. h. die Register des linken Schaltkreises 1101 und des rechten Schaltkreises 1102 wie oben beschrieben mit a' und das obere Register 1104 mit b. Schließe den Schalter 1104 und takte den Schaltkreis 26-mal. Danach befindet sich s im linken Register.
Anschließend wird das Hamminggewicht von s berechnet: w(s) = 12 ≥ d/2 = 8
15 zeigt einen Decoder 1500 zur PUF-Rekonstruktion für den (31, 5, 16) Simplex Code.
Analog zu dem Decoder 600 weist der Decoder drei Register 1501, 1502, 1503 und Addierer 1504 auf, deren Länge bzw. Anzahl an den in diesem Beispiel verwendeten Code angepasst sind.
Der Decoder 1500 liefert die Hamminggewichte w_j = w(E_j) für j = 0, 1, ..., 30. min(w₀, w₁, ..., w₃₀, w(s)) = min(16, 12, 18, 12, 14, 14, 12, 16, 14, 18, 10, 18, 14, 16, 12, 20, 22, 14, 16, 14, 18, 14, 20, 18, 16, 18, 12, 16, 16, 16, 18, 12) = 10.
Das Minimum 10 wird nur einmal angenommen: w₁₀ = 10. Daher ist der eindeutig bestimmte Fehlervektor e = E₁₀.
Um E₁₀ zu berechnen (beispielsweise wurden um Speicherplatz zu sparen die schon berechneten Vektoren E₀, E₁, ..., E₃₀ nicht abgespeichert) wird das obere Register 1501 des Decoders 1501 (mit dem in 15 angegebenen Initialisierungswert) zehnmal getaktet. Danach enthält das obere Register 1501 den Vektor 11111 00011 01110 10100 00100 10110 0.
Der Vektor in den oberen Register 1 wird auf den im mittleren Register 1502 enthaltenen Vektor s addiert und die Summe in das untere Register 1503 geschrieben (genau genommen werden die ersten 26 Koordinaten addiert, die letzten 5 Koordinaten werden übernommen). Im unteren Register 1503 befindet sich dann der Fehlervektor e = E₀ = 00110 01000 00100 00010 00101 10110 0.
Der wahre PUF-Wert a ist a = a₀ + e = 01001 00010 00011 10101 01010 10101 1.
Obwohl die Erfindung vor allem unter Bezugnahme auf bestimmte Ausführungsformen gezeigt und beschrieben wurde, sollte es von denjenigen, die mit dem Fachgebiet vertraut sind, verstanden werden, dass zahlreiche Änderungen bezüglich Ausgestaltung und Details daran vorgenommen werden können, ohne vom Wesen und Bereich der Erfindung, wie er durch die nachfolgenden Ansprüche definiert wird, abzuweichen. Der Bereich der Erfindung wird daher durch die angefügten Ansprüche bestimmt, und es ist beabsichtigt, dass sämtliche Änderungen, welche unter den Wortsinn oder den Äquivalenzbereich der Ansprüche fallen, umfasst werden.

Claims

Verfahren zum Ermitteln eines Fehlervektors in einem Datenwort aufweisend: Ermitteln des Syndroms des Fehlervektors; sukzessives Erzeugen von Codewörtern durch zyklisches Vertauschen ein oder mehrerer vorgegebener Codewörter, Bilden, für jedes erzeugte Codewort, der Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort und überprüfen, für das Codewort, ob die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat; und Ermitteln des Fehlervektors als die Summe des Syndroms mit dem Codewort, für das die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat.
Verfahren gemäß Anspruch 1, ferner aufweisend Korrigieren des Datenworts mittels des Fehlervektors.
Verfahren gemäß Anspruch 1 oder 2, ferner aufweisend Ausgeben des korrigierten Datenworts an eine Verarbeitungseinrichtung.
Verfahren gemäß einem der Ansprüche 1 bis 3, wobei das Datenwort ein mit dem Code codiertes Nachrichtenwort ist.
Verfahren gemäß Anspruch 4, ferner aufweisend Empfangen des Datenworts von einem Sender.
Verfahren gemäß Anspruch 4 oder 5, wobei das Syndrom des Fehlervektors das Syndrom des Datenworts ist.
Verfahren gemäß einem der Ansprüche 1 bis 3, wobei das Datenwort ein PUF-Wort (Physical unclonable function – Wort) ist.
Verfahren gemäß Anspruch 7, ferner aufweisend Empfangen des Datenworts von einer Schaltung, die eine PUF implementiert.
Verfahren gemäß Anspruch 7 oder 8, wobei das Syndrom des Fehlervektors die Summe aus dem Syndroms des Datenvektors und eines Hilfsvektors ist.
Verfahren gemäß Anspruch 9, wobei der Hilfsvektor das Syndrom eines bei einer Initialisierung ermittelten PUF-Worts ist, das sich von dem Datenwort um den Fehlervektor unterscheidet.
Verfahren gemäß einem der Ansprüche 1 bis 10, wobei das Prüfen, ob die Summe des auf Datenwortlänge ergänzten Syndroms mit dem Codewort minimales Gewicht hat, das Prüfen aufweist, ob das Gewicht der Summe kleiner als die halbe Hammingdistanz des Codes ist.
Verfahren gemäß Anspruch 11, ferner aufweisend Abbrechen des sukzessiven Erzeugens von Wörtern der Menge, wenn ein Codewort gefunden wurde, für das das Gewicht der Summe kleiner als die halbe Hammingdistanz des Codes ist.
Verfahren gemäß einem der Ansprüche 1 bis 12, wobei das Prüfen, ob die Summe des auf Datenwortlänge ergänzten Syndroms mit dem Wort minimales Gewicht hat, das Ermitteln, für alle erzeugte Codewörter, der Summe des auf Datenwortlänge ergänzten Syndroms mit dem Codewort aufweist und den Vergleich der ermittelten Summen aufweist.
Verfahren gemäß einem der Ansprüche 1 bis 13, ferner aufweisend Ermitteln des Datenworts als nicht korrigierbar, wenn für kein Codewort die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat.
Verfahren gemäß einem der Ansprüche 1 bis 14, wobei das Ergänzen des Syndroms mit Nullen auf Datenwortlänge gemäß einer Kontrollmatrix erfolgt, die ebenso viele Einheitsvektoren aufweist, wie das Syndrom Komponenten hat.
Verfahren gemäß einem der Ansprüche 1 bis 15, wobei das Ergänzen des Syndroms mit Nullen auf Datenwortlänge gemäß einer Kontrollmatrix erfolgt, die eine Einheitsmatrix mit der Zeilenanzahl gleich der Anzahl von Komponenten des Syndroms aufweist.
Verfahren gemäß Anspruch 15 oder 16, wobei das Ergänzen des Syndroms mit Nullen auf Datenwortlänge das Einfügen von Nullen in das Syndrom an Stellen aufweist, die Spalten der Kontrollmatrix entsprechen, die keine Einheitsvektoren sind.
Verfahren gemäß einem der Ansprüche 1 bis 17, wobei der Code ein zyklischer Code ist.
Verfahren gemäß einem der Ansprüche 1 bis 18, wobei der Code aus dem Nullwort und allen zyklischen Vertauschungen eines Codeworts ungleich dem Nullwort besteht.
Verfahren gemäß Anspruch 19, wobei die Codewörter durch zyklisches Vertauschen eines einzigen Codeworts erzeugt werden.
Verfahren gemäß einem der Ansprüche 1 bis 20, wobei der Code ein Simplex-Code ist.
Datenverarbeitungseinrichtung zum Ermitteln eines Fehlervektors in einem Datenwort aufweisend: eine Syndromermittlungsschaltung, die eingerichtet ist, das Syndroms des Fehlervektors zu ermitteln; eine Decodierschaltung, die eingerichtet ist, sukzessiv Codewörter durch zyklisches Vertauschen ein oder mehrerer vorgegebener Codewörter zu erzeugen, für jedes erzeugte Codewort, die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort zu bilden und für das Codewort zu überprüfen, ob die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat; und eine Ausgabeschaltung, die eingerichtet ist, die Summe des Syndroms mit dem Codewort, für das die Summe des mit Nullen auf Datenwortlänge ergänzten Syndroms mit dem Codewort unter allen Codewörtern minimales Gewicht hat, als Fehlervektor auszugeben.