DE102022111624B4 - Fehlerkorrektur mit schneller Syndromberechnung - Google Patents

Abstract

Verfahren zur Fehlerkorrektur,- bei dem basierend auf einem Datenwort eine Syndromberechnung mit einer Matrix M basierend auf einer Matrix H eines Codes durchgeführt wird,- bei dem, falls anhand des Ergebnisses der Syndromberechnung erkennbar ist, dass das Datenwort fehlerhaft ist, das Ergebnis der Syndromberechnung mittels einer linearen Abbildung transformiert wird,- bei dem anhand des Ergebnisses der linearen Abbildung mittels eines effizienten Fehlerkorrekturalgorithmus ein Fehlervektor bestimmt wird,- bei dem anhand des Fehlervektors das fehlerhafte Datenwort korrigiert wird.- bei dem die für die Syndromberechnung genutzte Matrix M basierend auf der Matrix H des Codes wie folgt bestimmt wird:- für die Zeilenvektoren der Matrix H werden Linearkombinationen bestimmt,- für jede Linearkombination wird ein Hamminggewicht bestimmt,- basierend auf den entsprechend ihres ansteigenden Hamminggewichts priorisierten Linearkombinationen werden Zeilenvektoren der Matrix M bestimmt, wobei Koeffizienten der jeweils selektierten Linearkombinationen Zeilen einer Matrix J bestimmen,- bei dem für die Zeilenvektoren der Matrix H nicht-triviale Linearkombinationen bestimmt werden,- bei dem für jede Linearkombination das Hamminggewicht bestimmt wird,- bei dem die Linearkombinationen entsprechend ihres Hamminggewichts gruppiert werden,- bei dem Linearkombinationen der Reihe nach mit ansteigendem Hamminggewicht selektiert werden und anhand jeder selektierten Linearkombination eine Zeile der Matrix M bestimmt wird sowie anhand der Koeffizienten der selektierten Linearkombination eine Zeile der Matrix J bestimmt wird,- bei dem die Linearkombinationen mit ansteigendem Hamminggewicht selektiert werden, bis alle Zeilen der Matrix M und alle Zeilen der Matrix J bestimmt sind,- bei dem die lineare Abbildung auf der inversen Matrix J-1basiert.

Description

• Der hier beschriebene Ansatz betrifft Lösungen zur Fehlerverarbeitung, umfassend z.B. die Erkennung und/oder Korrektur von Fehlern.
• DE 10 2020 110 787 B3 betrifft einen Ansatz zum Kodieren bzw. Dekodieren eines Datenworts.
• US 6 381 713 B1 betrifft die Behandlung von Übertragungsfehlern bei fehlerhaften Informationsfeldern.
• DE 2 041 320 A betrifft die Korrektur von Übertragungsfehlern bei Nachrichten.
• US 2008/0059867 A1 beschreibt Lösungsansätze zur Dekodierung bei der Verwendung linearer Blockcodes.
• [Russo, L [u.a.] : Sparsifying Parity-Check Matrices, Applied Soft Computing 96, 31.07.2020] betrifft die effiziente Reduzierung der Belegungen (d.h. die Anzahl der 1-Einträge) in Parity-Check-Matrizen.
• US 2010/0287440 A1 offenbart Matrixstrukturen zur Blockcodierung.
• Die Aufgabe der Erfindung besteht darin, Nachteile bekannter Lösungen zur Korrektur von Fehlern zu vermeiden und insbesondere eine effiziente Korrektur von Fehlern zu ermöglichen.
• Diese Aufgabe wird gemäß den Merkmalen der unabhängigen Ansprüche gelöst. Bevorzugte Ausführungsformen sind insbesondere den abhängigen Ansprüchen entnehmbar.
• Diese hierin vorgeschlagenen Beispiele können auf zumindest einer der nachfolgenden Lösungen basieren. Insbesondere können Kombinationen der nachfolgenden Merkmale eingesetzt werden, um ein gewünschtes Ergebnis zu erreichen. Die Merkmale des Verfahrens können mit (einem) beliebigen Merkmal(en) der Vorrichtung oder der Schaltung oder umgekehrt kombiniert werden.
• Zur Lösung der Aufgabe wird ein Verfahren zur Fehlerkorrektur angegeben,
• - bei dem basierend auf einem Datenwort eine Syndromberechnung mit einer Matrix M basierend auf einer Matrix H eines Codes durchgeführt wird,
• - bei dem, falls anhand des Ergebnisses der Syndromberechnung erkennbar ist, dass das Datenwort fehlerhaft ist, das Ergebnis der Syndromberechnung mittels einer linearen Abbildung transformiert wird,
• - bei dem anhand des Ergebnisses der linearen Abbildung mittels eines effizienten Fehlerkorrekturalgorithmus ein Fehlervektor bestimmt wird,
• - bei dem anhand des Fehlervektors das fehlerhafte Datenwort korrigiert wird,
• - bei dem die für die Syndromberechnung genutzte Matrix M basierend auf der Matrix H des Codes wie folgt bestimmt wird:
  • - für die Zeilenvektoren der Matrix H werden Linearkombinationen bestimmt,
  • - für jede Linearkombination wird ein Hamminggewicht bestimmt,
  • - basierend auf den entsprechend ihres ansteigenden Hamminggewichts priorisierten Linearkombinationen werden Zeilenvektoren der Matrix M bestimmt, wobei Koeffizienten der jeweils selektierten Linearkombinationen Zeilen einer Matrix J bestimmen,
• - bei dem für die Zeilenvektoren der Matrix H nicht-triviale Linearkombinationen bestimmt werden,
• - bei dem für jede Linearkombination das Hamminggewicht bestimmt wird,
• - bei dem die Linearkombinationen entsprechend ihres Hamminggewichts gruppiert werden,
• - bei dem Linearkombinationen der Reihe nach mit ansteigendem Hamminggewicht selektiert werden und anhand jeder selektierten Linearkombination eine Zeile der Matrix M bestimmt wird sowie anhand der Koeffizienten der selektierten Linearkombination eine Zeile der Matrix J bestimmt wird,
• - bei dem die Linearkombinationen mit ansteigendem Hamminggewicht selektiert werden, bis alle Zeilen der Matrix M und alle Zeilen der Matrix J bestimmt sind,
• - bei dem die lineare Abbildung auf der inversen Matrix J^-1 basiert.
• Bei dem Datenwort kann es sich um eine beliebige Information handeln, beispielsweise eine vorgegebene Anzahl von Bits oder Bytes.
• Es ist eine Weiterbildung, dass keine Korrektur erfolgt, falls anhand des Ergebnisses der Syndromberechnung bestimmt wurde, dass kein Fehler erkannt wurde.
• Es ist eine Weiterbildung, dass die für die Syndromberechnung genutzte Matrix M die folgenden Eigenschaften aufweist:
• - jede Zeile der Matrix M weist möglichst wenige Einsen auf,
• - die Matrix M weist insgesamt möglichst wenige Einsen auf.
• Es ist eine Weiterbildung, dass die Matrix J^-1 so bestimmt wird, dass sie möglichst wenige Einsen pro Zeile aufweist.
• Weiterhin wird eine Vorrichtung zur Fehlerkorrektur vorgeschlagen, umfassend eine Verarbeitungseinheit, eingerichtet zur Durchführung der folgenden Schritte:
• - basierend auf einem Datenwort, Durchführen einer Syndromberechnung mit einer Matrix M basierend auf einer Matrix H eines Codes,
• - falls anhand des Ergebnisses der Syndromberechnung erkennbar ist, dass das Datenwort fehlerhaft ist, Transformieren des Ergebnisses der Syndromberechnung mittels einer linearen Abbildung,
• - Bestimmen, anhand des Ergebnisses der linearen Abbildung, eines Fehlervektors mittels eines effizienten Fehlerkorrekturalgorithmus,
• - Korrigieren des fehlerhaften Datenworts anhand des Fehlervektors,
• - wobei die für die Syndromberechnung genutzte Matrix M basierend auf der Matrix H des Codes wie folgt bestimmt wird:
  • - Bestimmen von Linearkombinationen für die Zeilenvektoren der Matrix H,
  • - Bestimmen eines Hamminggewichts für jede Linearkombination,
  • - basierend auf den entsprechend ihres ansteigenden Hamminggewichts priorisierten Linearkombinationen, Bestimmen von Zeilenvektoren der Matrix M, wobei Koeffizienten der jeweils selektierten Linearkombinationen Zeilen einer Matrix J bestimmen,
• - ferner eingerichtet zum
  • - Bestimmen von nicht-trivialen Linearkombinationen für die Zeilenvektoren der Matrix H,
  • - Bestimmen des Hamminggewichts für jede Linearkombination,
  • - Gruppieren der Linearkombinationen entsprechend ihres Hamminggewichts,
  • - Selektieren von Linearkombinationen der Reihe nach mit ansteigendem Hamminggewicht, wobei anhand jeder selektierten Linearkombination eine Zeile der Matrix M bestimmt wird sowie anhand der Koeffizienten der selektierten Linearkombination eine Zeile der Matrix J bestimmt wird,
  • - Selektieren der Linearkombinationen gemäß ihrem ansteigendem Hamminggewicht solange, bis alle Zeilen der Matrix M und alle Zeilen der Matrix J bestimmt sind,
• - wobei die lineare Abbildung auf der inversen Matrix J^-1 basiert.
• Die hier genannte Verarbeitungseinheit kann insbesondere als eine Prozessoreinheit und/oder eine zumindest teilweise festverdrahtete oder logische Schaltungsanordnung ausgeführt sein, die beispielsweise derart eingerichtet ist, dass das Verfahren wie hierin beschrieben durchführbar ist. Besagte Verarbeitungseinheit kann jede Art von Prozessor oder Rechner oder Computer mit entsprechend notwendiger Peripherie (Speicher, Input/Output-Schnittstellen, Ein-Ausgabe-Geräte, etc.) sein oder umfassen.
• Die vorstehenden Erläuterungen betreffend das Verfahren gelten für die Vorrichtung entsprechend. Die jeweilige Vorrichtung kann in einer Komponente oder verteilt auf mehrere Komponenten ausgeführt sein.
• Es ist eine Weiterbildung, dass die Vorrichtung und/oder die Verarbeitungseinheit derart eingerichtet ist, dass keine Korrektur erfolgt, falls anhand des Ergebnisses der Syndromberechnung bestimmt wurde, dass kein Fehler erkannt wurde.
• Es ist eine Weiterbildung, dass die für die Syndromberechnung genutzte Matrix M die folgenden Eigenschaften aufweist:
• - jede Zeile der Matrix M weist möglichst wenige Einsen auf,
• - die Matrix M weist insgesamt möglichst wenige Einsen auf.
• Es ist eine Weiterbildung, dass die Vorrichtung und/oder die Verarbeitungseinheit derart eingerichtet ist, dass die Matrix J^-1 so bestimmt wird, dass sie möglichst wenige Einsen pro Zeile aufweist.
• Ergänzend können hierin beschriebene Lösungen die folgenden Ansätze berücksichtigen oder umfassen: Ein Verfahren zur Fehlerkorrektur,
• - bei dem eine Syndromberechnung in einer Code-Domäne eines zweiten Codes durchgeführt wird,
• - bei dem ein effizienter Fehlerkorrekturalgorithmus in einer Code-Domäne eines ersten Codes durchgeführt wird.
• Die Code-Domäne ist beispielsweise durch einen Vektorraum des Codes bestimmt. Bei dem Code handelt es sich vorzugsweise um einen Fehler-erkennenden und/oder Fehler-korrigierenden Code. Der erste Code verfügt über einen effizienten Fehlerkorrekturalgorithmus. Vorzugsweise ist der erste Code ein Code, für den ein solcher effizienter Fehlerkorrekturalgorithmus bekannt ist. Beispielsweise handelt es sich bei dem ersten Code um einen der folgenden Codes: Einen Hamming-Code, einen BCH-Code, einen Reed-Muller-Code, einen Simplex-Code, einen Golay-Code oder einen Goppa-Code.
• Durch den Wechsel zwischen den Code-Domänen ist es möglich, die Syndromberechnung in der Code-Domäne des zweiten Codes effizienter durchzuführen und dennoch den effizienten Fehlerkorrekturalgorithmus des ersten Codes (nach dem Wechsel zurück in dessen Code-Domäne) verwenden zu können.
• Es ist eine Weiterbildung, dass zwischen der Syndromberechnung und der Durchführung des effizienten Fehlerkorrekturalgorithmus ein Übergang zwischen den Code-Domänen durchgeführt wird mittels mindestens einer linearen Abbildung.
• Es ist eine Weiterbildung, dass
• - ein Datenwort in der Code-Domäne des ersten Codes empfangen wird und mittels einer ersten lineare Abbildung in die Code-Domäne des zweiten Codes überführt wird,
• - die Syndromberechnung in der Code-Domäne des zweiten Codes basierend auf dem Ergebnis der ersten linearen Abbildung durchgeführt wird und, falls anhand des Ergebnisses der Syndromberechnung erkennbar ist, dass das Datenwort fehlerhaft ist, mittels einer zweiten linearen Abbildung das Ergebnis der Syndromberechnung in die Code-Domäne des ersten Codes überführt wird,
• - anhand des Ergebnisses der zweiten linearen Abbildung in der Code-Domäne des ersten Codes mittels des effizienten Fehlerkorrekturalgorithmus ein Fehlervektor bestimmt wird,
• - anhand des Fehlervektors das fehlerhafte Datenwort korrigiert wird.
• Es ist eine Weiterbildung, dass
• - die Syndromberechnung in der Code-Domäne des zweiten Codes basierend auf einem empfangenen Datenwort durchgeführt wird und, falls anhand des Ergebnisses der Syndromberechnung erkennbar ist, dass das Datenwort fehlerhaft ist, mittels einer zweiten linearen Abbildung das Ergebnis der Syndromberechnung in die Code-Domäne des ersten Codes überführt wird,
• - anhand des Ergebnisses der zweiten linearen Abbildung in der Code-Domäne des ersten Codes mittels des effizienten Fehlerkorrekturalgorithmus ein Fehlervektor der Code-Domäne des ersten Codes bestimmt wird,
• - mittels einer ersten linearen Abbildung der Fehlervektor der Code-Domäne des ersten Codes in einen Fehlervektor der Code-Domäne des zweiten Codes überführt wird,
• - anhand des Fehlervektors der Code-Domäne des zweiten Codes das fehlerhafte Datenwort korrigiert wird.
• Es ist eine Weiterbildung, dass
• - der erste Code durch eine Matrix H bestimmt ist,
• - der zweite Code durch eine Matrix K bestimmt ist,
• - die erste lineare Abbildung P und die zweite lineare so bestimmt sind, dass gilt $$H=L\cdot K\cdot P.$$
  
• Es ist eine Weiterbildung, dass die Matrix K eine Kontrollmatrix ist, die eine Einheitsmatrix umfasst.
• Es ist eine Weiterbildung, dass die erste lineare Abbildung eine Permutation umfasst.
• Es ist eine Weiterbildung, dass keine Korrektur erfolgt, falls anhand des Ergebnisses der Syndromberechnung bestimmt wurde, dass kein Fehler erkannt wurde.
• Eine beispielhafte Vorrichtung zur Fehlerkorrektur kann eine Verarbeitungseinheit umfassen, die eingerichtet ist zur Durchführung des hierin beschriebenen Verfahrens.
• Auch wird ein Computerprogrammprodukt vorgeschlagen, das direkt in einen Speicher eines digitalen Computers ladbar ist, umfassend Programmcodeteile, die dazu geeignet sind, Schritte dieses Verfahrens durchzuführen.
• Weiterhin wird das oben genannte Problem gelöst mittels eines computerlesbaren Speichermediums, z.B. eines beliebigen Speichers, umfassend von einem Computer ausführbare Anweisungen (z.B. in Form von Programmcode), die dazu geeignet sind, dass der Computer Schritte des hier beschriebenen Verfahrens durchführt.
• Die oben beschriebenen Eigenschaften, Merkmale und Vorteile dieser Erfindung sowie die Art und Weise, wie diese erreicht werden, werden nachfolgend beschrieben im Zusammenhang mit einer schematischen Beschreibung von Ausführungsbeispielen, die im Zusammenhang mit den Zeichnungen näher erläutert werden. Dabei können zur Übersichtlichkeit gleiche oder gleichwirkende Elemente mit gleichen Bezugszeichen versehen sein.
• 1 zeigt ein beispielhaftes Flussdiagramm zur Veranschaulichung einer Funktionsweise eines Decoders zur Bestimmung eines Fehlervektors $\overrightarrow{e}.$
  
• 2 zeigt ein beispielhaftes Schaltdiagramm für eine Umverdrahtung.
• 3 zeigt eine Code-Domäne eines ersten Codes und eine Code-Domäne eines zweiten Codes, wobei ein Übergang zwischen den Code-Domänen mittels (z.B. linearer) Transformation erfolgt und eine effiziente Fehlerkorrektur dadurch erreicht wird, dass die Syndromberechnung in der Code-Domäne des zweiten Codes und der effiziente Fehlerkorrekturalgorithmus in der Code-Domäne des ersten Codes erfolgt.
• 4 zeigt ein zu 3 alternatives Beispiel für die effiziente Fehlerkorrektur.
• 5 zeigt ein beispielhaftes Diagramm zur Veranschaulichung der effizienten Syndromberechnung insbesondere mittels Hardware.
• Jede binäre r × n Matrix H vom Rang r definiert einen binären linearen Code C der Länge n und der Dimension k = n - r. Dieser Code ist der Nullraum der Matrix H, d.h. $$C=\left\{\overrightarrow{c}\in \text{GF}{\left(2\right)}^2:H{\overrightarrow{c}}^T=0\right\}$$

  

  mit
• - einem Codewort $\overrightarrow{c}$
  
  (auch bezeichnet als Vektor $\overrightarrow{c}$
  
  ) des Codes C,
• - dem endlichen Körper GF(2) = 10, 11 der Ordnung zwei,
• - GF(2)ⁿ als n-dimensionalem Vektorraum (Galoisfeld) aller binären Zeilenvektoren der Länge n und
• - ${\overrightarrow{c}}^T$
  
  als transponiertem Vektor des Vektors (Codeworts) $\overrightarrow{c}.$
  
• Die Matrix H wird Kontrollmatrix des Codes C genannt. Der Code C ist durch die Kontrollmatrix H eindeutig definiert. Der Code ist beispielsweise ein Fehlererkennender und/oder Fehler-korrigierender Code.
• Ein Gewicht (Hamminggewicht) $w\left(\overrightarrow{y}\right)$

  

  eines binären Vektors $\overrightarrow{y}$

  

  ist definiert als die Anzahl der Einsen in dem binären Vektor $\overrightarrow{y}.$

  

  Jeder lineare Code enthält den Nullvektor Ö, der das Gewicht Null hat:
• Das kleinste Gewicht aller vom Nullvektor verschiedenen Vektoren $\overrightarrow{c}$

  

  eines linearen Codes C wird als Minimumdistanz des Codes C bezeichnet: $$d=\text{min}\left(w\left(\overrightarrow{c}\right):\overrightarrow{c}\in C\backslash \left\{\overrightarrow{0}\right\}\right)$$

  
• Ein linearer Code der Länge n, der Dimension k und der Minimumdistanz d wird als (n, k, d)-Code bezeichnet.
• Mit einem Code der Minimumdistanz d sind prinzipiell alle t-Bitfehler korrigierbar, wobei gilt: 0 ≤ t < d/2.
• Korrigierbar bedeutet hierbei insbesondere, dass die t Fehlerpositionen in dem empfangenen fehlerhaften Codewort eindeutig bestimmt sind. Diese Fehlerpositionen sind dabei nicht in allen Fällen (insbesondere innerhalb einer vorgegebenen Zeitdauer) berechenbar.
• Die Fehlerpositionen sind nur dann innerhalb einer vorgegebenen Zeitdauer bestimmbar, wenn für den vorliegenden Code ein effizienter Fehlerkorrekturalgorithmus bekannt ist. Dies ist bei den wenigsten linearen Codes der Fall. Codes, die über einen effizienten Fehlerkorrekturalgorithmus verfügen sind z.B. die folgenden Codes: Hamming-Code, BCH-Code, Reed-Muller-Code, Simplex-Code, Golay-Code, Goppa-Code.
• In der Praxis, z.B. auf Computerchips, werden Codes eingesetzt, die über einen effizienten Fehlerkorrekturalgorithmus verfügen.
• Beispiel 1: Gegeben sei ein linearer Code der Länge n = 100 mit einer Minimumdistanz d = 21. Bei der Datenübertragung tritt ein 10-Bitfehler auf. Für den Code ist kein effizienter Fehlerkorrekturalgorithmus bekannt. Um den Fehler zu bestimmen, müssen alle $$\frac{100!}{90!\cdot 10!}=17310309456440$$

  

  möglichen Fehlermuster ausprobiert werden. Für genau ein Fehlermuster ist das Syndrom gleich Null: Dieses Fehlermuster entspricht dem aufgetretenen 10-Bitfehler. Für alle anderen Fehlermuster ist das Syndrom ungleich Null. Es sind daher ca. 17 Billionen Syndromberechnungen erforderlich, um den 10-Bitfehler zu bestimmen.
• Beispiel 2: Der Simplex Code einer Länge n = 127 hat eine Minimumdistanz d = 64. Für diesen Code gibt es einen effizienten Fehlerkorrekturalgorithmus. Bei der Datenübertragung tritt ein 30-Bitfehler auf. Der Fehlerkorrekturalgorithmus (implementiert in Hardware als elektronischer Schaltkreis aus 120 Flip-Flops und XOR- sowie Majority-Gattern) erlaubt, dass der 30-Bitfehler in 127 Takten einer Prozessoreinheit (CPU) bestimmt wird. Die Fehlerkorrektur benötigt nur eine einzige Syndromberechnung für die Initialisierung des Schaltkreises.
• Syndrom
• Die meisten Fehlerkorrekturalgorithmen benötigen als Input einen Syndromvektor (auch bezeichnet als Syndrom). Der Syndromvektor wird aus dem empfangen Datenwort mit Hilfe der Kontrollmatrix H berechnet.
• Ist $\overrightarrow{c}$

  

  das gesendete Codewort und $\overrightarrow{y}$

  

  das zugehörige empfangene Datenwort, so ist der Vektor $\overrightarrow{y}$

  

  eine (möglicherweise fehlerhafte) Version des gesendeten Codeworts $\overrightarrow{c}.$

  

  Das Syndrom von $\overrightarrow{y}$

  

  ist definiert durch $$S\left(\overrightarrow{y}\right)=H\cdot {\overrightarrow{y}}^T.$$

  
• Wenn kein Fehler bei der Übertragung (oder während der Speicherung) aufgetreten ist, wenn also $\overrightarrow{y}=\overrightarrow{c}$

  

  ist, dann ist das Syndrom gleich Null, d.h. der Syndromvektor $S\left(\overrightarrow{y}\right)$

  

  ist identisch mit dem Nullvektor $\overrightarrow{0}.$

  

  Ist hingegen ein (erkennbarer) Fehler aufgetreten, so gilt: $S\left(\overrightarrow{y}\right)\ne \overrightarrow{0}.$

  
• 1 zeigt ein beispielhaftes Flussdiagramm zur Veranschaulichung einer Funktionsweise eines Decoders zur Bestimmung eines Fehlervektors $\overrightarrow{e}.$

  
• In einem Schritt 101 wird ein Codewort $\overrightarrow{c}$

  

  bestimmt und über einen Kanal 102 gesendet und von dem Decoder in einem Schritt 103 als Datenwort (auch bezeichnet als Datenvektor) $\overrightarrow{y}$

  

  empfangen. In einem Schritt 104 erfolgt die Syndromberechnung gemäß Gleichung (1).
• Ist das Syndrom gleich Null, so wird zu einem Schritt 105 verzweigt, das empfangene Datenwort ist identisch mit dem gesendeten Codewort $\left(\overrightarrow{y}=\overrightarrow{c}\right).$

  

  In diesem Fall wird angenommen, dass kein Übertragungsfehler aufgetreten ist, das empfangene Datenwort $\overrightarrow{y}$

  

  wird als das gesendete (korrekte) Codewort $\overrightarrow{c}$

  

  akzeptiert.
• Ist das Syndrom ungleich Null, so wird von dem Schritt 104 zu einem Schritt 106 verzweigt: Da das empfangene Datenwort von dem gesendeten Codewort verschieden ist $\left(\overrightarrow{y}\ne \overrightarrow{c}\right),$

  

  wird ein Fehlerkorrekturalgorithmus genutzt, um den Fehlervektor $\overrightarrow{e}$

  

  zu bestimmen, so dass gilt: $$\overrightarrow{y}+\overrightarrow{e}=\overrightarrow{c}.$$

  
• Der Fehlerkorrekturalgorithmus berechnet aus dem Syndromvektor $S\left(\overrightarrow{y}\right)$

  

  Fehlerstellen und gibt diese in Form des Fehlervektors $\overrightarrow{e}$

  

  aus. Dann wird das empfangene Datenwort $\overrightarrow{y}$

  

  korrigiert, indem ein Vektor $$\overrightarrow{y}\oplus \overrightarrow{e}$$

  

  berechnet wird, wobei „⊕“ einer Exklusiv-oder-Verknüpfung entspricht. Somit ergibt sich ein korrigiertes Codewort $${\overrightarrow{c}}_{korr}=\overrightarrow{y}\oplus \overrightarrow{e},$$

  

  das als identisch mit dem gesendeten Codewort $\overrightarrow{c}$

  

  angenommen wird.
• Die Syndromberechnung wird vorzugsweise immer ausgeführt, wohingegen die Fehlerkorrektur nur benötigt wird, wenn das Syndrom ungleich Null ist.
• Beispiel 3: Beispielhaft angenommen wird ein 2-Fehler-korrigierender Code der Länge n = 40 mit einer Minimumdistanz d = 5. Es werden 100000 Codewörter übertragen. Eine Bitfehlerwahrscheinlichkeit beträgt p = 0,001. Somit werden im Mittel ca. 96 000 Codewörter fehlerfrei übertragen. Bei ca. 4000 Codewörtern tritt bei der Übertragung ein 1-Bitfehler oder ein 2-Bitfehler auf, die automatisch korrigiert werden. Bei nur einer einzigen Übertragung kommt es zu einem Mehrbitfehler (d.h. drei oder mehr Bit sind fehlerhaft) in dem gesendeten Codewort. Somit kann im Mittel eines der 100 000 empfangenen Datenwörter nicht korrigiert werden. In 96% der Fälle ist das Syndrom gleich Null und es ist keine Fehlerkorrektur notwendig. In 4% der Fälle ist das Syndrom ungleich Null und nur dann wird der Fehlerkorrekturalgorithmus benötigt.
• Da die Syndromberechnung immer, die Fehlerkorrektur aber nur manchmal durchgeführt wird, ist es zweckmäßig, die Syndromberechnung effizient zu implementieren. Auf diese Weise wird die Rechendauer verkürzt und der Stromverbrauch des Decoders reduziert.
• Effiziente Syndromberechnung in Software
• Kanonische Kontrollmatrix
• Kontrollmatrizen der Form $$K=\left(I,A\right),$$

  

  ermöglichen eine effiziente Syndromberechnung, beispielsweise mittels Software. Hierbei stellt I die Einheitsmatrix dar.
• Die Spalten der Einheitsmatrix I sind Einheitsvektoren, d.h. Vektoren mit nur einer Eins und sonst lauter Nullen. Somit ist die kanonische Matrix dünn besetzt, d.h. sie enthält insgesamt relativ wenige Einsen.
• Wird die Kontrollmatrix K für die Syndromberechnung genutzt, d.h. ein Spaltenvektor $$Z\left(\overrightarrow{y}\right)=K\cdot {\overrightarrow{y}}^T$$

  

  berechnet und dieser als Syndrom verwendet, dann sind für die Berechnung der Koordinaten z_i des Syndroms $$Z\left(\overrightarrow{y}\right)={\left(z_1,\dots ,z_{n-k}\right)}^T$$

  

  nur wenige Koordinaten y_j des Vektors $\overrightarrow{y}=\left(y_1,\dots ,y_n\right)$

  

  miteinander zu addieren (in dem Galoisfeld GF(2) entspricht eine solche Addition einer Exklusiv-Oder-Verknüpfung, auch bezeichnet als XOR-Verknüpfung), weil die kanonische Matrix K pro Zeile wenige Einsen enthält.
• Somit ist bei einer Hardware-Implementierung die logische Tiefe einer Schaltung zur Berechnung der Koordinaten des Syndroms bei Verwendung der dünn besetzten Matrix K kleiner als bei der Syndromberechnung mit einer dichter besetzten Matrix.
• Auch bei einer Software-Implementierung des Codes ist die Syndromberechnung mittels einer solchen kanonischen Matrix K von Vorteil: Die (n - k) × (n - k) Einheitsmatrix I an vorderster Stelle in der Kontrollmatrix K = (I, A) bewirkt, dass in der Syndromberechnung zunächst nur die letzten k Koordinaten y_j des Vektors $\overrightarrow{y}$

  

  in die einzelnen Zeilensummen einfließen. Die Komponenten des sich ergebenden Spaltenvektors werden allein aus den letzten k Koordinaten des Vektors $\overrightarrow{y}$

  

  bestimmt. Anschließend wird zu diesem Spaltenvektor der Spaltenvektor $${\left(y_1,y_2,\dots ,y_{n-k}\right)}^T$$

  

  addiert, um das Syndrom $Z\left(\overrightarrow{y}\right)$

  

  gemäß Gleichung (6) zu erhalten.
• Für i = 1,..., n - k ist das Ausgabebit z_i auf demselben Platz wie das entsprechende Eingabebit y_i. Dies ist für die Programmierung von Vorteil, da beispielsweise die Programmiersprachen C oder C++ Daten wortweise verarbeiten: Damit kann die bitweise Addition der beiden Spaltenvektoren mittels einer einzigen Instruktion erfolgen.
• Beispiel 4: Beispielsweise sei die folgende kanonische Kontrollmatrix gegeben: $$K=\left(\begin{array}{llll}1\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill \end{array}\begin{array}{rrr}\hfill 1& \hfill 0& \hfill 1\\ \hfill 1& \hfill 1& \hfill 1\\ \hfill 1& \hfill 1& \hfill 0\\ \hfill 0& \hfill 1& \hfill 1\end{array}\right).$$

  
• p K ist die kanonische Kontrollmatrix eines 1-Bitfehler-korrigierenden linearen Codes der Länge n = 7 und der Dimension k = 3. Das Syndrom von $$\overrightarrow{y}=\left(y_1,\dots ,y_7\right)$$

  

  ergibt sich wie folgt: $$Z\left(\overrightarrow{y}\right)=K\cdot {\overrightarrow{y}}^T=\left(\begin{array}{c}{z}_1\\ z_2\\ z_3\\ z_4\end{array}\right)=\left(\begin{array}{c}{y}_1\\ y_2\\ y_3\\ y_4\end{array}\right)\oplus \left(\begin{array}{c}{y}_5+y_7\\ y_5+y_6+y_7\\ y_5+y_6\\ y_6+y_7\end{array}\right).$$

  

  (Ende Beispiel 4)
• Die Kontrollmatrix H eines linearen (n, k, d) -Codes C ist nicht eindeutig bestimmt. Ist J eine invertierbare (n - k) × (n - k) Matrix ist, dann ist $$H*=J\cdot H$$

  

  ebenfalls eine Kontrollmatrix des Codes: Die Matrizen H und H* haben denselben Nullraum und der Code ist per Definition identisch mit diesem Vektorraum. Ein linearer Code C besitzt daher eine Vielzahl unterschiedlicher Kontrollmatrizen.
• Wenn der lineare Code C einen effizienten Fehlerkorrekturalgorithmus hat, der aus einem Syndrom $S\left(\overrightarrow{y}\right)=H\cdot {\overrightarrow{y}}^T$

  

  gemäß Gleichung (1) den Fehlervektor $\overrightarrow{e}$

  

  berechnet, dann gibt es in der Menge der unterschiedlichen Kontrollmatrizen eine spezielle Kontrollmatrix: Diese spezielle Kontrollmatrix hat Eigenschaften, die der Fehlerkorrekturalgorithmus ausnutzt, und die die übrigen Kontrollmatrizen nicht haben. Damit funktioniert der Fehlerkorrekturalgorithmus nur in Verbindung mit dieser speziellen Kontrollmatrix.
• Nur für Codes aus der Simplex-Familie und für den Reed-Muller-Code erster Ordnung ist die spezielle Kontrollmatrix bereits kanonisch, d.h. in der Form (I, A).
• Zur Verbesserung der Effizienz der Syndromberechnung ist es erstrebenswert, eine kanonische Matrix für die Syndromberechnung zu verwenden. Allerdings verlangt der effiziente Fehlerkorrekturalgorithmus, dass das Syndrom mit der zugehörigen speziellen Kontrollmatrix berechnet wird.
• Erzeugung der kanonischen Matrix
• Es sei H eine r × n Matrix vom Rang r. Aus dieser Matrix H kann eine kanonische r × n Matrix bestimmt werden, in dem elementare Zeilenumformungen für die Zeilen der Matrix H durchgeführt werden. Elementare Zeilenumformungen entsprechen einem Vertauschen von Zeilen der Matrix H und ein bitweises Addieren in dem Galoisfeld GF(2) einer Matrixzeile auf eine andere. Darüber hinaus können Spalten der Matrix H untereinander vertauscht werden.
• Mittels einer endlichen Anzahl solcher Operationen wird aus der Matrix H eine Matrix K vom Typ (I, A) bestimmt. Grundsätzlich kann jede Matrix H, die einen vollen Rang aufweist, in eine kanonische Matrix umgeformt werden.
• Das Durchführen elementarer Zeilenumformungen ist äquivalent zu einem Multiplizieren der Matrix H von links mit einer invertierbaren r × r Matrix A. Das Vertauschen von Spalten der Matrix H ist äquivalent zu einem Multiplizieren der Matrix H von rechts mit einer n × n Permutationsmatrix B.
• Eine Permutationsmatrix (auch bezeichnet als Vertauschungsmatrix) ist eine Matrix, die in jeder ihrer Zeilen und in jeder ihrer Spalten genau eine Eins und sonst nur Nullen aufweist.
• Es gibt also eine invertierbare r × r Matrix A und eine n × n Permutationsmatrix B, so dass $$K=A\cdot H\cdot B$$

  

  gilt, wobei die resultierende Matrix K die kanonische Form aufweist. Somit wird anhand der beiden Matrizen A und B aus der Matrix H die kanonische Matrix K bestimmt.
• Die Matrizen A und B sind beide invertierbar. Nachfolgend werden die inversen Matrizen mit L bzw. P bezeichnet gemäß der Beziehungen: $$L:=A^{-1}$$

  

  $$P:=B^{-1}$$

  
• Da B eine Permutationsmatrix ist, ist auch die inverse Matrix P eine Permutationsmatrix.
• Die Gleichung (9) ist somit äquivalent zu $$H=L\cdot K\cdot P.$$

  
• Der Vektor $\overrightarrow{y}=\left(y_1,\dots ,y_n\right)$

  

  ist ein binärer Zeilenvektor der Länge n. Wird die Gleichung (10) von rechts mit dem Spaltenvektor ${\overrightarrow{y}}^T$

  

  multipliziert, folgt $$H\cdot {\overrightarrow{y}}^T=L\cdot K\cdot P\cdot {\overrightarrow{y}}^T.$$

  
• Beträgt nun die Dimension k = n - r, so hat die Matrix H mit r = n - k Zeilen und n Spalten den Rang r = n - k. Damit ist der Nullraum der Matrix H ein linearer (n, k, d)-Code C und die Matrix H ist eine Kontrollmatrix für den Code C.
• Die linke Seite der Gleichung (11) entspricht gemäß Gleichung (1) dem Syndrom $S\left(\overrightarrow{y}\right)$

  

  des Vektors $\overrightarrow{y}$

  

  in dem Code C relativ zu der Kontrollmatrix H.
• Die rechte Seite der Gleichung (11) enthält den Vektor P ${\overrightarrow{y}}^T.$

  

  Da es sich bei der Matrix P um eine n × n Permutationsmatrix handelt, enthält der Vektor P ${\overrightarrow{y}}^T$

  

  dieselben Koordinaten wie der Vektor $\overrightarrow{y},$

  

  nur in einer anderen Reihenfolge.
• Bei einer Realisierung in Hardware kann eine Abbildung $${\overrightarrow{y}}^T\mapsto P\cdot {\overrightarrow{y}}^T=\overrightarrow{y}{\text{'}}^T$$

  

  in Form einer Umverdrahtung vorteilhaft (weitgehend) kostenneutral umgesetzt werden.
• Beispiel 5: Gegeben ist eine Permutationsmatrix $$P=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 1& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\end{array}\right)$$

  

  und ein Vektor $$\overrightarrow{y}=\left(y_1,y_2,y_3,y_4\right).$$

  
• Daraus folgt: $$\overrightarrow{y}{\text{'}}^T=P\cdot {\overrightarrow{y}}^T=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 1& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\end{array}\right)\cdot \left(\begin{array}{c}{y}_1\\ y_2\\ y_3\\ y_4\end{array}\right)=\left(\begin{array}{c}{y}_1\\ y_3\\ y_2\\ y_4\end{array}\right)=\left(\begin{array}{c}y{\text{'}}_1\\ y{\text{'}}_2\\ y{\text{'}}_3\\ y{\text{'}}_4\end{array}\right).$$

  
• 2 zeigt ein beispielhaftes Schaltdiagramm, das eine Umverdrahtung von $\overrightarrow{y}$

  

  auf $\overrightarrow{y}\text{'}$

  

  gemäß diesem Beispiel veranschaulicht. (Ende Beispiel 5)
• Gleichung (11) kann mit Gleichung (12) wie folgt formuliert werden: $$H\cdot {\overrightarrow{y}}^T=L\cdot K\cdot P\cdot {\overrightarrow{y}}^T=L\cdot K\cdot \overrightarrow{y}{\text{'}}^T.$$

  
• Auf der linken Seite der Gleichung (14) steht das Syndrom $S\left(\overrightarrow{y}\right)=H{\overrightarrow{y}}^T$

  

  gemäß Gleichung (1), das der Fehlerkorrekturalgorithmus benötigt. Auf der rechten Seiten der Gleichung (14) steht das Syndrom $$Z\left(\overrightarrow{y}\text{'}\right)=K\cdot \overrightarrow{y}{\text{'}}^T.$$

  
• Somit ergibt sich, dass die beiden Syndrome $S:=S\left(\overrightarrow{y}\right)$

  

  und $Z:=Z\left(\overrightarrow{y}{\text{'}}^T\right)$

  

  zueinander lineare Transformationen sind: $$S=L\cdot Z.$$

  
• Wegen der vertauschten Matrixspalten bei der Herleitung der Matrix K aus der Matrix H ist die Matrix K keine Kontrollmatrix für den ursprünglichen Code C. Stattdessen definiert die Matrix K einen neuen Code C'.
• Der alte Code C und der neue Code C' haben dieselben Parameter n, k und d und dieselbe Gewichtsverteilung. Allerdings bestimmen sie unterschiedliche Vektorräume (auch bezeichnet als Code-Domänen): Ein Codewort des Codes C ist nicht notwendigerweise auch ein Codewort des Codes C'. Die Berechnungen der Syndrome S und Z beziehen sich also auf unterschiedliche Codes.
• Lösungsbeispiel
• 3 zeigt eine Code-Domäne 301 eines ersten Codes und eine Code-Domäne 302 eines zweiten Codes. Code-Domäne (Vektorraum) bedeutet in diesem Zusammenhang, dass die Berechnungen innerhalb der Domäne spezifisch für den jeweiligen Code sind. Ein Übergang zwischen den Code-Domänen erfolgt mittels (z.B. linearer) Transformation.
1. 1. Für den ersten Code C gibt es einen effizienten Fehlerkorrekturalgorithmus, der auf Eigenschaften einer speziellen Kontrollmatrix H basiert und für die Korrektur des empfangenen Datenworts y das Syndrom $H\cdot {\overrightarrow{y}}^T$
   
   gemäß Gleichung (1) benötigt. Eine zu übertragende Nachricht $\overrightarrow{m}$
   
   wird mit dem ersten Code C kompatibel zu der Matrix H codiert, d.h. ein Zeilenvektor $\overrightarrow{m}$
   
   wird mit einer zu der Matrix H gehörenden Generatormatrix G multipliziert, um ein Codewort $\overrightarrow{c}$
   
   zu berechnen: $$\overrightarrow{c}=\overrightarrow{m}\cdot G.$$
   
   Dieses Codewort $\overrightarrow{c}$
   
   wird übertragen und als Bitfolge $\overrightarrow{y}$
   
   (auch bezeichnet als empfangenes Datenwort, Datenvektor, Eingabe oder Eingabevektor) auf der anderen Seite des Kanals empfangen. Diese Bitfolge $\overrightarrow{y}$
   
   stellt in 3 die Eingabe in der Code-Domäne 301 dar.
• 2. Herleitung der kanonischen Matrix:
• Für die Matrix H werden die zugehörige kanonische Matrix $$K=\left(I,A\right),$$

  

  
  die invertierbare quadratische Matrix L und die Permutationsmatrix P berechnet, so dass gemäß Gleichung (10) gilt: $$H=L\cdot K\cdot P.$$

  
• 3. Umverdrahtung:
• Für das empfangene Datenwort $\overrightarrow{y}$

  

  wird ein Zeilenvektor $$\overrightarrow{y}\text{'}=\overrightarrow{y}\cdot P^T$$

  

  berechnet. Dies entspricht einem Übergang 303 von der ersten Code-Domäne 301 in die zweite Code-Domäne 302 mittels der Matrix P.
• 4. Schnelle Syndromberechnung 304:
• Es wird das Syndrom $Z\left(\overrightarrow{y}\text{'}\right)$

  

  von $\overrightarrow{y}\text{'}$

  

  unter Verwendung der kanonischen Matrix K berechnet: $$Z=Z\left(\overrightarrow{y}\text{'}\right)=K\cdot \overrightarrow{y}{\text{'}}^T.$$

  

  Wenn Z = 0, also das K-Syndrom Null ist, dann ist $\overrightarrow{y}$

  

  fehlerfrei. Das Verfahren kann beendet werden.
  Wenn Z ≠ 0, also das K-Syndrom ungleich Null ist, dann ist $\overrightarrow{y}$

  

  nicht fehlerfrei; es wird zu dem nachfolgenden Schritt (5.) verzweigt und eine lineare Transformation 305 durchgeführt.
• 5. Lineare Transformation 305:
• Der Spaltenvektor Z wird mit der quadratischen Matrix L multipliziert. Der resultierende Spaltenvektor $$S=L\cdot Z$$

  

  
  ist identisch mit dem benötigten Syndromvektor $S=H\cdot {\overrightarrow{y}}^T.$

  

  Die Multiplikation mit L entspricht einem Übergang von der zweiten Code-Domäne 302 in die erste Code-Domäne 301.
• 6. Fehlervektorberechnung 306:
• Mittels des Fehlerkorrekturalgorithmus wird anhand des Syndromvektors S ein Fehlervektor $\overrightarrow{e}$

  

  berechnet und ausgegeben.
• 7. Fehlerkorrektur:
• Anhand des Fehlervektors $\overrightarrow{e}$

  

  kann eine Korrektur durchgeführt werden: Das korrigierte Codewort ${\overrightarrow{c}}_{korr}$

  

  ergibt sich zu $${\overrightarrow{c}}_{korr}=\overrightarrow{y}+\overrightarrow{e}.$$

  
• Da die meisten eintreffenden Datenwörter $\overrightarrow{y}$

  

  fehlerfrei sind, endet das Programm in der überwiegend Zahl der Fälle bereits mit dem Schritt (4.). Relativ selten tritt ein Fehler auf bei dem das K-Syndrom ungleich Null ist und die Schritte 5. bis 7. durchgeführt werden.
• In Schritt 4. erfolgt die Syndromberechnung. Die hierfür erforderliche Zeit wirkt entscheidend auf die Gesamtperformance der hier vorgestellten Lösung.
• Ergänzend sei angemerkt, dass die Syndromberechnung 304 in der Code-Domäne 302 des zweiten Codes, also nach dem Übergang 303 (der Transformation mittels P), unter Verwendung der Matrix K erfolgt. Dies ersetzt eine Syndromberechnung ohne Transformation (also innerhalb der Code-Domäne 301 des ersten Codes) mittels der Matrix H (nicht in 3 dargestellt). Die Syndromberechnung 304 ist demgegenüber schneller, so dass der entstehende Mehraufwand der Übergänge 303 und 305 bezogen auf die Gesamtperformance der vorgestellten Lösung eine untergeordnete Rolle spielt.
• Alternative Lösung
• Nachfolgend wird eine alternative Lösung beschrieben. Zunächst gelten die gleichen Voraussetzungen: Für einen ersten linearen (n, k, d)-Code ist ein effizienter Fehlerkorrekturalgorithmus gegeben, der mit einer speziellen Kontrollmatrix H assoziiert ist.
• Zur Korrektur benötigt der Fehlerkorrekturalgorithmus als eine Eingabe das durch die Matrix H definierte Syndrom $S\left(\overrightarrow{y}\right)=H\cdot {\overrightarrow{y}}^T$

  

  gemäß Gleichung (1).
• Aus der Matrix H kann eine äquivalente Matrix K der Form K = (I, A) bestimmt werden. Hierbei bedeutet „äquivalent“, dass invertierbare quadratische Matrizen L und P der passenden Größe existieren, so dass gemäß Gleichung (10) gilt: $$H=L\cdot K\cdot P.$$

  
• Dabei ist die Matrix P die Permutationsmatrix.
• Wenn die Matrix P nicht selbst die Einheitsmatrix ist, dann definieren die Matrizen H und K unterschiedliche Codes. Diese Codes sind zueinander äquivalent, da die Codewörter des einen Codes aus den Codewörtern des anderen Codes durch Umordnung nach einer festen Vorschrift hervorgehen. Als Vektorräume betrachtet handelt es sich aber um zwei verschiedene Codes: Der erste Code ist der Nullraum der Matrix H und der zweite Code ist der Nullraum der Matrix K.
• In dieser alternativen Lösung erfolgt die Nachrichtencodierung mittels des zweiten Codes, also des Codes, der mit der kanonischen Kontrollmatrix K assoziiert ist. Das hat insbesondere die folgenden Vorteile:
• 1. Die Codierung der k-Bit langen Nachricht, vorliegend als Vektor $$\overrightarrow{m}=\left(m_1,\dots ,m_k\right)$$
  
  kann mithilfe der zu der kanonischen Matrix K gehörenden Generatormatrix G durchgeführt werden. Diese Kodierung wird auch mit K-Codierung bezeichnet. Die Generatormatrix G hat die Form G = (I, B) mit der k × k Einheitsmatrix I. Die Matrix K hat die Form K = (I, A) mit der (n - k) × (n - k) Einheitsmatrix I. Somit ist die Generatormatrix G ebenfalls eine kanonische Matrix. Für die Matrizen G und K gilt: $$G\cdot K^T=\mathrm{0,}$$
  
  wobei 0 hier für die k × (n - k) Nullmatrix (alle Matrixeinträge sind Null) steht. Die Codierung der Nachricht $\overrightarrow{m}$
  
  (also die Umwandlung der Nachricht $\overrightarrow{m}$
  
  in ein Codewort $\overrightarrow{c}$
  
  ) wird durch Multiplikation mit der Generatormatrix G erreicht, d.h. $$\overrightarrow{c}=\overrightarrow{m}\cdot G.$$
  
  Da die Generatormatrix G kanonisch ist, hat das mit ihr berechnete Codewort $\overrightarrow{c}$
  
  die Form $$\overrightarrow{c}=\left(\overrightarrow{m},\overrightarrow{r}\right).$$
  
  Das Codewort $\overrightarrow{c}$
  
  besteht aus dem Nachrichtenvektor $\overrightarrow{m},$
  
  an das n - k Redundanzbits $\overrightarrow{r}$
  
  angehängt werden. Somit kann in dem zweiten Code (d.h. dem Nullraum der kanonischen Matrix K) sowohl die Syndromberechnung als auch die Codierung effizienter ausgeführt werden als in dem ersten Code (d.h. dem Nullraum der Fehlerkorrekturmatrix H).
• 2. Die vorstehend erläuterte 3 zeigt einen Ansatz zur Codierung der Nachricht $\overrightarrow{m}$
  
  in dem ersten Code, also in dem Code mit dem effizienten Fehlerkorrekturalgorithmus. Hierbei wird jedes empfangene Datenwort $\overrightarrow{y}$
  
  zunächst koordinatenweise permutiert, d.h. auf jedes empfangene Datenwort wird die Permutation gemäß der Matrix P angewandt. In der vorliegend beschriebenen alternativen Lösung wird hiervon abgewichen: Das empfangene Datenwort $\overrightarrow{y}$
  
  liegt bereits codiert vor in dem Code mit der kanonischen Kontrollmatrix K, mit der auch die effiziente Syndromberechnung durchgeführt wird. Es kann also unverändert (d.h. ohne Permutation) der Syndromberechnung zugeführt werden. Ist das Syndrom gleich Null, erfolgt keine Korrektur (das empfangene Datenwort wird als korrekt betrachtet und das Verfahren kann beendet werden). Wenn hingegen das K-Syndrom Z ungleich Null ist, dann wird es mit der quadratischen Matrix L linear transformiert. Das transformierte Syndrom $$S=L\cdot Z$$
  
  wird in dem Fehlerkorrekturalgorithmus des ersten Codes zugeführt, der daraus einen Fehlervektor $\overrightarrow{e}\text{'}$
  
  (mittels des ersten Codes) berechnet. Um aus dem Fehlervektor $\overrightarrow{e}\text{'}$
  
  den zugehörigen Fehlervektor $\overrightarrow{e}$
  
  zu bestimmen, der in dem zweiten Code für die dort stattfindende Fehlerkorrektur benötigt wird, wird auf den Fehlervektor $\overrightarrow{e}\text{'}$
  
  die Permutation gemäß der Matrix P angewandt.
• 4 veranschaulicht diesen Zusammenhang anhand der Code-Domäne 301 des ersten Codes und der Code-Domäne 302 des zweiten Codes.
• In der Code-Domäne 302 erfolgt eine K-Codierung 401 des Nachrichtenvektors $\overrightarrow{m}$

  

  in das Codewort $\overrightarrow{c},$

  

  das über einen Kanal 402 übertragen und als Datenwort $\overrightarrow{y}$

  

  empfangen wird. Für das empfangene Datenwort $\overrightarrow{y}$

  

  erfolgt eine schnelle Syndromberechnung 403 vergleichbar mit der Syndromberechnung 304 aus 3:
• Es wird das Syndrom $Z\left(\overrightarrow{y}\right)$

  

  von $\overrightarrow{y}$

  

  unter Verwendung der kanonischen Matrix K berechnet: $$Z=Z\left(\overrightarrow{y}\right)=K\cdot {\overrightarrow{y}}^T.$$

  
• Wenn Z = 0, also das K-Syndrom Null ist, dann ist $\overrightarrow{y}$

  

  fehlerfrei. Das Verfahren kann beendet werden.
• Wenn Z ≠ 0, also das K-Syndrom ungleich Null ist, dann ist $\overrightarrow{y}$

  

  nicht fehlerfrei. In diesem Fall erfolgt anhand der Multiplikation mit der Matrix L eine lineare Transformation 404 $$S=L\cdot Z,$$

  

  die einen Übergang von der Code-Domäne 302 in die Code-Domäne 301 bewirkt.
• Mittels eines Fehlerkorrekturalgorithmus 405 der Code-Domäne 301 wird anhand des Syndromvektors S der Fehlervektor $\overrightarrow{e}\text{'}$

  

  berechnet und mittels der Matrix P 406 in den Fehlervektor $\overrightarrow{e}$

  

  der zweiten Code-Domäne 302 transformiert. Anhand des Fehlervektors $\overrightarrow{e}$

  

  kann das empfangene Datenwort $\overrightarrow{y}$

  

  korrigiert werden: $${\overrightarrow{c}}_{korr}=\overrightarrow{y}+\overrightarrow{e}.$$

  
• Im Ergebnis wird die Permutation der in 4 gezeigten Lösung seltener ausgeführt als in dem in 3 gezeigten Beispiel. Dies ist besonders bei Software-Implementierungen von Vorteil.
• Effiziente Syndromberechnung insbesondere mittels Hardware
• Eine Matrix M, die beispielsweise in Hardware implementiert werden kann und für die Syndromberechnung genutzt wird, soll folgende Eigenschaften besitzen:
1. (A) Jede Zeile der Matrix M soll möglichst wenige Einsen enthalten.
2. (B) Die Matrix M soll insgesamt wenige Einsen enthalten.
• Eigenschaft (A) ist wichtig, weil damit die logische Tiefe für die Berechnung der einzelnen Syndromkoordinaten möglichst klein ist. Je kleiner die logische Tiefe eines Schaltkreises ist, desto schneller kann dieser getaktet werden.
• Eigenschaft (B) ist wichtig, weil weniger Einsen in der Matrix bedeutet, dass die Matrix mit einer geringeren Anzahl von XOR-Gattern implementiert werden kann, was eine kleinere Halbleiterfläche bedingt.
• Gegeben sei eine Matrix H mit r × n Elementen, die eine spezielle Kontrollmatrix zu einem genutzten Fehlerkorrekturalgorithmus ist. Der Fehlerkorrekturalgorithmus benötigt das mit der Matrix H berechnete Syndrom $S\left(\overrightarrow{y}\right)=H\cdot {\overrightarrow{y}}^T$

  

  als Eingabe, wobei $\overrightarrow{y}$

  

  der Vektor des empfangenen Datenworts ist.
• Mit einer beliebigen invertierbaren r × r Matrix J ist auch eine Matrix $$M=J\cdot H$$

  

  eine Kontrollmatrix für den Code.
• Werden in Gleichung (16) alle möglichen invertierbaren binären r × r Matrizen J eingesetzt (was selbst für niedrige Werte von r zu einer sehr großen Zahl führt), dann durchläuft die Matrix M alle existierenden Kontrollmatrizen des Codes (der durch die Matrix H definiert ist). Unter diesen Kontrollmatrizen befinden sich Matrizen mit den Eigenschaften (A) und (B).
• Wird die Gleichung (16) beidseitig mit einer inversen Matrix J^-1 multipliziert, folgt: $$J^{-1}\cdot M=H.$$

  
• Wird Gleichung (17) von rechts mit ${\overrightarrow{y}}^T$

  

  multipliziert, ergibt sich: $$J^{-1}\cdot M\cdot {\overrightarrow{y}}^T=H\cdot {\overrightarrow{y}}^T$$

  
• Auf der rechten Seite der Gleichung (18) steht das H-Syndrom $$S\left(\overrightarrow{y}\right)=H\cdot {\overrightarrow{y}}^T.$$

  
• Auf der linken Seite der Gleichung (18) steht das mit der Matrix M berechnete Syndrom $M\cdot {\overrightarrow{y}}^T,$

  

  multipliziert mit der Matrix J^-1.
• Die inverse Matrix J^-1 kann beispielhaft in einer Hardware-Implementierung genutzt werden, die die Matrix J nicht benötigt.
• Beispielhaft wird die Matrix J^-1 mit F bezeichnet, d.h. F = J^-1.
• Es ist vorteilhaft, dass die Matrix J^-1 eine möglichst geringe Anzahl von Einsen pro Zeile enthält. Daher lautet eine dritte Eigenschaft für eine effiziente Syndromberechnung in Hardware:
• (C) Die inverse Matrix J^-1 zu der Matrix J gemäß Gleichung (16) soll möglichst wenige Einsen pro Zeile enthalten.
• 5 zeigt ein beispielhaftes Diagramm zur Veranschaulichung der effizienten Syndromberechnung mittels Hardware. Hierbei wird beispielhaft von nur einer Code-Domäne 501 (d.h. einem Vektorraum des Codes C, für den es auch den effizienten Fehlerkorrekturalgorithmus gibt) ausgegangen, ein Übergang zwischen unterschiedlichen Code-Domänen ist nicht erforderlich.
• Basierend auf dem empfangenen Datenwort $\overrightarrow{y}$

  

  erfolgt eine Syndromberechnung 502 mittels der Matrix M: $$W=W\left(\overrightarrow{y}\right)=M\cdot {\overrightarrow{y}}^T.$$

  
• Wenn W = 0, also das M-Syndrom Null ist, dann ist $\overrightarrow{y}$

  

  fehlerfrei. Das Verfahren kann beendet werden.
• Wenn W ≠ 0, also das M-Syndrom ungleich Null ist, dann ist $\overrightarrow{y}$

  

  nicht fehlerfrei und es wird eine lineare Transformation 503 mittels der Matrix F durchgeführt: $$S=F\cdot W.$$

  
• Anhand eines Fehlerkorrekturalgorithmus 504 wird basierend auf dem Syndromvektor S ein Fehlervektor $\overrightarrow{e}$

  

  berechnet und mittels des Fehlervektors $\overrightarrow{e}$

  

  kann das empfangene Datenwort $\overrightarrow{y}$

  

  korrigiert werden: $${\overrightarrow{c}}_{korr}=\overrightarrow{y}+\overrightarrow{e}.$$

  
• Berechnung hardware-optimierter Matrizen M und J^-1
• Nachfolgend wird ein Beispiel für die hardware-optimierte Bestimmung der Matrizen M und J^-1 angegeben.
• Es seien ${\overrightarrow{h}}_1,\dots ,{\overrightarrow{h}}_r$

  

  die Zeilen der r × n Matrix H.
1. 1. Es werden (insbesondere) alle 2^r - 1 nichttrivialen Linearkombinationen $$k_1\cdot {\overrightarrow{h}}_1+\dots +k_r\cdot {\overrightarrow{h}}_r$$
   
   der r Zeilenvektoren bestimmt.
2. 2. Das Hamminggewicht jeder Linearkombination wird berechnet und die Linearkombinationen werden nach aufsteigendem Hamminggewicht sortiert: Am Anfang der Liste stehen die Linearkombinationen mit dem Hamminggewicht 1 (falls es solche gibt), dann kommen die Linearkombinationen mit dem Hamminggewicht 2, usw. Linearkombinationen mit demselben Hamminggewicht können in Gruppen zusammengefasst werden. Die Anordnung der Linearkombinationen innerhalb einer Gruppe kann frei oder nach einem vorgegebenen Schema gewählt werden.
3. 3. Es wird eine Linearkombination $${\overrightarrow{v}}_1=a_1\cdot {\overrightarrow{h}}_1+\dots +a_r\cdot {\overrightarrow{h}}_r$$
   
   aus der ersten Gruppe ausgewählt. Damit ist der Zeilenvektor ${\overrightarrow{v}}_1$
   
   die erste Zeile der zu bestimmenden hardware-optimierten Kontrollmatrix M und (a₁,...,a_r) ist die erste Zeile der Matrix J.
4. 4. Falls vorhanden, wird eine Linearkombination ${\overrightarrow{v}}_2\ne {\overrightarrow{v}}_1$
   
   aus der ersten Gruppe ausgewählt. Falls nicht vorhanden, wird die Linearkombination ${\overrightarrow{v}}_2$
   
   aus der zweiten Gruppe ausgewählt. Der sich ergebende n Bit lange Zeilenvektor ${\overrightarrow{v}}_2$
   
   $${\overrightarrow{v}}_2=b_1\cdot {\overrightarrow{h}}_1+\dots +b_r\cdot {\overrightarrow{h}}_r$$
   
   entspricht der zweiten Zeile der Matrix M und (b₁,...,b_n) definiert die zweite Zeile der Matrix J.
5. 5. Es wird eine Linearkombination ${\overrightarrow{v}}_3$
   
   mit ${\overrightarrow{v}}_3\ne {\overrightarrow{v}}_1,{\overrightarrow{v}}_3\ne {\overrightarrow{v}}_2$
   
   und ${\overrightarrow{v}}_3\ne \left({\overrightarrow{v}}_1+{\overrightarrow{v}}_2\right)$
   
   ausgewählt, falls möglich aus der ersten Gruppe, sonst aus der zweiten Gruppe und falls auch das nicht möglich ist, aus der dritten Gruppe. Der sich ergebende Zeilenvektor $${\overrightarrow{v}}_3=c_1\cdot {\overrightarrow{h}}_1+\dots +c_r\cdot {\overrightarrow{h}}_r$$
   
   bestimmt die dritte Zeile der Matrix M und (c₁,...,c_r) definiert die dritte Zeile der Matrix J.
6. 6. Das Verfahren wird entsprechend fortgesetzt, bis alle r Zeilen der Kontrollmatrix M und die zugehörigen r Zeilen der Matrix J bestimmt sind.
• Dieser Ansatz liefert eine hardware-optimierte Kontrollmatrix M. Dabei ist die Matrix M nicht eindeutig bestimmt, es gibt eine Vielzahl derartiger optimierter Matrizen. Bei der Auswahl einer Linearkombination aus einer Gruppe gibt es mehrere Möglichkeiten, die zu unterschiedlichen optimierten Lösungen führen. Jede der optimierten Kontrollmatrizen H weist die beiden Eigenschaften (A) und (B) auf.
• Die unterschiedlichen Wahlmöglichkeiten für die Linearkombinationen aus einer jeweiligen Gruppe führen am Ende zu unterschiedlichen Ergebnissen für die erzeugten Matrizen M und J. Dies resultiert in unterschiedlichen inversen Matrizen J^-1. Um eine effiziente Form für die Matrix J^-1 zu finden, können mehrere (oder alle) Wahlmöglichkeiten für die Linearkombinationen in den jeweiligen Gruppen durchprobiert werden. Jede einzelne getroffene Wahl liefert ein Matrizenpaar (J,M). Beispielsweise kann diejenige inverse Matrix J^-1 mit den wenigsten Einsen pro Zeile genutzt werden. Auf diese Weise wird die Eigenschaft (C) erfüllt.
• Anwendungsbeispiel
• Der Fehlerkorrekturalgorithmus
• Die nachfolgende, beispielhaft angegebene Matrix H ist die Kontrollmatrix eines 2-Fehler-korrigierenden linearen Codes der Länge n = 15, der Dimension k = 7 und mit der Minimumdistanz d = 5. $$H=\left(\begin{array}{lllllllllllllll}1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill \\ 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \end{array}\right)$$

  
• Die Spalten der Matrix H werden durch die Boolesche Funktion $$f\left(w,x,y,z\right)=w\left(x+y\right)$$

  

  definiert.
• Für j = 1,...15 wird die j-te Spalte der Matrix H gemäß folgender Vorschrift erstellt:
1. 1. Berechne die Binärdarstellung (j₀, j₁, j₂, j₃) der ganzen Zahl j.
2. 2. Berechne $$k_0=f\left(j_0,j_1,j_2,j_3\right),$$
   
   $$k_1=f\left(j_3,j_0,j_1,j_2\right),$$
   
   $$k_2=f\left(j_2,j_3,j_0,j_1\right),$$
   
   $$k_3=f\left(j_1,j_2,j_3,j_0\right),$$
   
• Dann ist die j-te Matrixspalte gegeben durch $${\overrightarrow{h}}_j=\left(\begin{array}{l}{j}_0\hfill \\ j_1\hfill \\ j_2\hfill \\ j_3\hfill \\ k_0\hfill \\ k_1\hfill \\ k_2\hfill \\ k_3\hfill \end{array}\right).$$

  
• Die Darstellbarkeit der Spalten der Kontrollmatrix H durch eine einheitliche Formel resultiert in einem effizienten Fehlerkorrekturalgorithmus mit schneller 1-Bitfehler-Korrektur (vergleichbar mit der Dauer für eine einzige Syndromberechnung) und einer beschleunigten 2-Bitfehler-Korrektur (Rechendauer entspricht in etwa der von 15 Syndromberechnungen).
• Der Fehlerkorrekturalgorithmus erhält als Eingabe das durch die Kontrollmatrix H definierte acht Bit lange Syndrom $$S\left(\overrightarrow{y}\right)=H\cdot {\overrightarrow{y}}^T,$$

  

  wobei $\overrightarrow{y}=\left(y_1,\dots ,y_{15}\right)$

  

  das empfangene Datenwort ist.
• Effiziente Syndromberechnung in Software
• Die Matrix H wird in die kanonische Matrix K umgeformt. Dazu werden die Spaltenvektoren an den Plätzen 3, 4, 5, 6, 7, 8 und 9 umsortiert entsprechend der Permutation $$\sigma =\left(\mathrm{3,4,8,7,5}\right)\left(\mathrm{6,9}\right).$$

  
• Anschließend werden einige elementare Zeilenoperationen ausgeführt, so dass die 8 × 8 Einheitsmatrix am Beginn der neuen Matrix entsteht. Dabei fällt eine invertierbare 8 × 8 Matrix L als Nebenprodukt an. Die kanonische Matrix K ergibt sich zu: $$K=\left(\begin{array}{lllllllllllllll}1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill \\ 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \end{array}\right)$$

  
• Zwischen den Matrizen H und K besteht die Beziehung: $$H=L\cdot K\cdot P,$$

  

  wobei P eine 15 × 15 Permutationsmatrix ist, die die obige Permutation σ in Matrixform darstellt. Die Matrizen L und P sind gegeben durch: $$L=\left(\begin{array}{llllllll}1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 1\hfill & 1\hfill \\ 0\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill \end{array}\right)$$

  

  und $$P=\left(\begin{array}{lllllllllllllll}1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill \end{array}\right).$$

  
• Die kanonische Matrix K wird zur Syndromberechnung verwendet. Dazu wird zunächst das empfangene Datenwort $\overrightarrow{y}$

  

  umsortiert („umverdrahtet“) gemäß der vorstehend angegebenen Permutation σ bzw. Permutationsmatrix P: $$P\cdot \overrightarrow{y}=\overrightarrow{y}{\text{'}}^T$$

  

  mit $$\overrightarrow{y}\text{'}={\left(y_1,y_2,y_4,y_8,y_3,y_9,y_5,y_7,y_6,y_{10},y_{12},y_{13},y_{14},y_{15}\right)}^T.$$

  
• Anhand der kanonischen Matrix K wird das Syndrom $$Z=K\cdot \overrightarrow{y}{\text{'}}^T.$$

  

  bestimmt. Die Syndromberechnung mithilfe der Matrix K ist in Software effizienter durchführbar als unter Verwendung der Matrix H, weil die Matrix K zu Beginn die Einheitsmatrix I₈ (8 × 8-Einheitsmatrix) aufweist.
• Wenn das mit der Matrix K für den Vektor $\overrightarrow{y}\text{'}$

  

  berechnete Syndrom Z gleich Null ist, ist das Syndrom $$S\left(\overrightarrow{y}\right)=H\cdot {\overrightarrow{y}}^T$$

  

  gleich Null und das empfangene Datenwort $\overrightarrow{y}$

  

  ist (mit großer Wahrscheinlichkeit) fehlerfrei.
• Andernfalls wird die lineare Transformation L auf das Syndrom Z angewendet und es ergibt sich das Syndrom $$S\left(\overrightarrow{y}\right)=H\cdot {\overrightarrow{y}}^T=L\cdot Z$$

  

  für die durchzuführende Fehlervektorberechnung.
• Effiziente Syndromberechnung in Hardware
• Eine bei einer Hardwareimplementierung des Codes für die Syndromberechnung effiziente Kontrollmatrix M ist beispielsweise wie folgt bestimmt: $$M=\left(\begin{array}{lllllllllllllll}1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill \\ 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 1\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill \end{array}\right)$$

  
• Die Matrix M enthält 4 Einsen in jeder Zeile, wohingegen die Matrix H Zeilen mit acht Einsen aufweist. Die logische Tiefe bei der Berechnung der Syndromkomponenten mit der Matrix M beträgt zwei.
• Beispielsweise ergibt sich die erste Syndromkomponente w₁ des M-Syndroms gemäß $$W_1=\left(y_1\oplus y_7\right)\oplus \left(y_9\oplus y_{15}\right),$$

  

  wohingegen die erste Syndromkomponente s₁ des H-Syndroms gemäß $$s_1=\left[\left(y_1\oplus y_3\right)\oplus \left(y_5\oplus y_7\right)\right]\oplus \left[\left(y_9\oplus y_{11}\right)\oplus \left(y_{13}\oplus y_{15}\right)\right]$$

  

  bestimmt wird.
• Aufgrund der geringeren logischen Tiefe kann die Syndromberechnung mithilfe der Matrix M höher getaktet werden als die Syndromberechnung mithilfe der Matrix H.
• Die Matrix M enthält insgesamt 32 Einsen, wohingegen die Matrix H 48 Einsen aufweist. Damit ergeben sich die Implementierungskosten (d.h. die Anzahl der Gatter) für die Matrix M zu 2/3 der Implementierungskosten für die Matrix H.
• Wenn das Syndrom mit der Matrix M berechnet wird, muss es mit der linearen Transformation F in das von dem Fehlerkorrekturalgorithmus benötigte Syndrom $H\cdot {\overrightarrow{y}}^T$

  

  transformiert werden: $$H\cdot {\overrightarrow{y}}^T=F\cdot M\cdot {\overrightarrow{y}}^T,$$

  

  wobei die lineare Transformation bestimmt ist durch die Matrix $$F=\left(\begin{array}{llllllll}1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill \\ 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill & 0\hfill \\ 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 0\hfill & 1\hfill \end{array}\right)$$

  
• Die Matrizen M und F wurden mit dem vorstehend angegebenen Algorithmus bestimmt, wobei die Spalten der Matrix H dabei nicht vertauscht wurden. Daher definieren die Matrizen H und M denselben Code-Vektorraum (welcher gleichzeitig der Nullraum der Matrix H und der Nullraum der Matrix M ist) und es wird keine Permutation (Umverdrahtung) benötigt.

Claims (9)

1. Verfahren zur Fehlerkorrektur, - bei dem basierend auf einem Datenwort eine Syndromberechnung mit einer Matrix M basierend auf einer Matrix H eines Codes durchgeführt wird, - bei dem, falls anhand des Ergebnisses der Syndromberechnung erkennbar ist, dass das Datenwort fehlerhaft ist, das Ergebnis der Syndromberechnung mittels einer linearen Abbildung transformiert wird, - bei dem anhand des Ergebnisses der linearen Abbildung mittels eines effizienten Fehlerkorrekturalgorithmus ein Fehlervektor bestimmt wird, - bei dem anhand des Fehlervektors das fehlerhafte Datenwort korrigiert wird. - bei dem die für die Syndromberechnung genutzte Matrix M basierend auf der Matrix H des Codes wie folgt bestimmt wird: - für die Zeilenvektoren der Matrix H werden Linearkombinationen bestimmt, - für jede Linearkombination wird ein Hamminggewicht bestimmt, - basierend auf den entsprechend ihres ansteigenden Hamminggewichts priorisierten Linearkombinationen werden Zeilenvektoren der Matrix M bestimmt, wobei Koeffizienten der jeweils selektierten Linearkombinationen Zeilen einer Matrix J bestimmen, - bei dem für die Zeilenvektoren der Matrix H nicht-triviale Linearkombinationen bestimmt werden, - bei dem für jede Linearkombination das Hamminggewicht bestimmt wird, - bei dem die Linearkombinationen entsprechend ihres Hamminggewichts gruppiert werden, - bei dem Linearkombinationen der Reihe nach mit ansteigendem Hamminggewicht selektiert werden und anhand jeder selektierten Linearkombination eine Zeile der Matrix M bestimmt wird sowie anhand der Koeffizienten der selektierten Linearkombination eine Zeile der Matrix J bestimmt wird, - bei dem die Linearkombinationen mit ansteigendem Hamminggewicht selektiert werden, bis alle Zeilen der Matrix M und alle Zeilen der Matrix J bestimmt sind, - bei dem die lineare Abbildung auf der inversen Matrix J^-1 basiert.
2. Verfahren nach Anspruch 1, bei dem keine Korrektur erfolgt, falls anhand des Ergebnisses der Syndromberechnung bestimmt wurde, dass kein Fehler erkannt wurde.
3. Verfahren nach einem der vorhergehenden Ansprüche, bei dem die für die Syndromberechnung genutzte Matrix M die folgenden Eigenschaften aufweist: - jede Zeile der Matrix M weist möglichst wenige Einsen auf, - die Matrix M weist insgesamt möglichst wenige Einsen auf.
4. Verfahren nach einem der vorhergehenden Ansprüche, bei dem die Matrix J^-1 so bestimmt wird, dass sie möglichst wenige Einsen pro Zeile aufweist.
5. Vorrichtung zur Fehlerkorrektur umfassend eine Verarbeitungseinheit, eingerichtet zur Durchführung der folgenden Schritte: - basierend auf einem Datenwort, Durchführen einer Syndromberechnung mit einer Matrix M basierend auf einer Matrix H eines Codes, - falls anhand des Ergebnisses der Syndromberechnung erkennbar ist, dass das Datenwort fehlerhaft ist, Transformieren des Ergebnisses der Syndromberechnung mittels einer linearen Abbildung, - Bestimmen, anhand des Ergebnisses der linearen Abbildung, eines Fehlervektors mittels eines effizienten Fehlerkorrekturalgorithmus, - Korrigieren des fehlerhaften Datenworts anhand des Fehlervektors. - wobei die für die Syndromberechnung genutzte Matrix M basierend auf der Matrix H des Codes wie folgt bestimmt wird: - Bestimmen von Linearkombinationen für die Zeilenvektoren der Matrix H, - Bestimmen eines Hamminggewichts für jede Linearkombination, - basierend auf den entsprechend ihres ansteigenden Hamminggewichts priorisierten Linearkombinationen, Bestimmen von Zeilenvektoren der Matrix M, wobei Koeffizienten der jeweils selektierten Linearkombinationen Zeilen einer Matrix J bestimmen, - ferner eingerichtet zum - Bestimmen von nicht-trivialen Linearkombinationen für die Zeilenvektoren der Matrix H, - Bestimmen des Hamminggewichts für jede Linearkombination, - Gruppieren der Linearkombinationen entsprechend ihres Hamminggewichts, - Selektieren von Linearkombinationen der Reihe nach mit ansteigendem Hamminggewicht, wobei anhand jeder selektierten Linearkombination eine Zeile der Matrix M bestimmt wird sowie anhand der Koeffizienten der selektierten Linearkombination eine Zeile der Matrix J bestimmt wird, - Selektieren der Linearkombinationen gemäß ihrem ansteigendem Hamminggewicht solange, bis alle Zeilen der Matrix M und alle Zeilen der Matrix J bestimmt sind, - wobei die lineare Abbildung auf der inversen Matrix J^-1 basiert.
6. Vorrichtung nach Anspruch 5, die derart eingerichtet ist, dass keine Korrektur erfolgt, falls anhand des Ergebnisses der Syndromberechnung bestimmt wurde, dass kein Fehler erkannt wurde.
7. Vorrichtung nach einem der Ansprüche 5 oder 6, bei der die für die Syndromberechnung genutzte Matrix M die folgenden Eigenschaften aufweist: - jede Zeile der Matrix M weist möglichst wenige Einsen auf, - die Matrix M weist insgesamt möglichst wenige Einsen auf.
8. Vorrichtung nach Anspruch einem der Ansprüche 5 bis 7, die derart eingerichtet ist, dass die Matrix J^-1 so bestimmt wird, dass sie möglichst wenige Einsen pro Zeile aufweist.
9. Computerprogrammprodukt, das direkt in einen Speicher eines digitalen Computers ladbar ist, umfassend Programmcodeteile, die dazu geeignet sind, Schritte des Verfahrens nach einem der Ansprüche 1 bis 4 durchzuführen.

Images